port-prod.xml

<?xml version="1.0" encoding="UTF8"?>
<Export generator="Cache" version="25">
<Class name="Port.AutoInstall">
<Super>%Projection.AbstractProjection</Super>
<TimeCreated>64463,49658.530976</TimeCreated>

<Projection name="Reference">
<Type>Port.AutoInstall</Type>
</Projection>

<Method name="CreateProjection">
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[classname:%String,&parameters:%String,modified:%String,qstruct]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Installer).Install()
]]></Implementation>
</Method>

<Method name="RemoveProjection">
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[classname:%String,&parameters:%String,recompile:%Boolean,modified:%String,qstruct]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Installer).Uninstall()
]]></Implementation>
</Method>
</Class>


<Class name="Port.Configuration">
<IncludeCode>portutils</IncludeCode>
<Super>%SYSTEM.Help</Super>
<TimeCreated>64306,34528.990495</TimeCreated>

<Method name="SetLogLevel">
<Description>
Sets the log level verbosity used to display the info. Ranging from 1 to 2, greater provides more detailed info.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>logLevel:%Integer</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if logLevel > 0 && (logLevel < 3) {
    set ^Port.Configuration("general.logLevel") = logLevel
    return $$$OK
  }
  return $$$PERROR($$$LogLevelIsOutOfRange, "1, 2")
]]></Implementation>
</Method>

<Method name="GetLogLevel">
<Description>
Gets the current configured log level.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  return $get(^Port.Configuration("general.logLevel"), 0)
]]></Implementation>
</Method>

<Method name="SetPrimaryWorkspace">
<Description>
Sets the primary path where the project should be exported. This can be overwritten by SetCustomWorkspace.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>newWorkspace:%String=""</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  set ^Port.Configuration("source.path") = $select(newWorkspace = "" : "/CacheProjects/{NAMESPACE}/{PROJECT}", 1: newWorkspace)
]]></Implementation>
</Method>

<Method name="GetWorkspace">
<Description>
Resolves any placeholders and gets the precise path for the specified project. This priorizes the custom workspace and falls back to the primary.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String=$get(^||Port.Project)</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set customWorkspace = ..GetCustomWorkspace(projectName)
  if customWorkspace '= "" return ..RewritePlaceHolders(customWorkspace, projectName,$lb("{NAMESPACE}","{PROJECT}","{USERNAME}"))
  return ..RewritePlaceHolders($get(^Port.Configuration("source.path")), projectName, $lb("{NAMESPACE}","{INSTALLDIR}","{PROJECT}","{USERNAME}"))
]]></Implementation>
</Method>

<Method name="EnableAutoExportXML">
<Description>
Generates and export a XML project whenever a item is saved. This is useful for keeping the project XML always up-to-date.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[  set ^Port.Configuration("xml.autoexport") = 1
]]></Implementation>
</Method>

<Method name="DisableAutoExportXML">
<Description>
Disables the generation of the project XML file.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[  set ^Port.Configuration("xml.autoexport") = 0
]]></Implementation>
</Method>

<Method name="IsAutoExportXMLEnabled">
<Description>
Returns if project XML generation is enabled.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  return ($get(^Port.Configuration("xml.autoexport")) = 1)
]]></Implementation>
</Method>

<Method name="SetTestPath">
<Description>
Relative to it's project. Sets the path where test cases should be exported.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>newPath:%String=""</FormalSpec>
<Implementation><![CDATA[  set ^Port.Configuration("test.path") = $select(newPath = "" : "tests/cls", 1: newPath)
]]></Implementation>
</Method>

<Method name="GetTestPath">
<Description>
Retrives the resolved path where tests are being exported.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set isUsingUDL = (..GetTestFormat() = "UDL")
  if isUsingUDL return "cls"
  return ..RewritePlaceHolders($get(^Port.Configuration("test.path")),,$lb("{NAMESPACE}","{PROJECT}","{USERNAME}"))
]]></Implementation>
</Method>

<Method name="EnableTestOnDemand">
<Description>
Allows Port to run matching test cases whenever the match is compiled.</Description>
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[  set ^Port.Configuration("test.ondemand") = 1
]]></Implementation>
</Method>

<Method name="DisableTestOnDemand">
<Description>
Prevents Port from running test cases automatically.</Description>
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[  set ^Port.Configuration("test.ondemand") = 0
]]></Implementation>
</Method>

<Method name="IsTestOnDemandEnabled">
<Description>
Retrieves if Port is configured to run test cases automatically.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  return ($get(^Port.Configuration("test.ondemand")) = 1)
]]></Implementation>
</Method>

<Method name="SetTestClassPrefix">
<Description>
Sets the prefix used to match against the implementation classe.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>newPrefix:%String=""</FormalSpec>
<Implementation><![CDATA[  set ^Port.Configuration("test.prefix") = $select(newPrefix = "" : "UnitTest", 1: newPrefix)
]]></Implementation>
</Method>

<Method name="GetTestClassPrefix">
<Description>
Gets the associated test prefix.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  return $get(^Port.Configuration("test.prefix"))
]]></Implementation>
</Method>

<Method name="SetCustomWorkspace">
<Description>
Defines a custom workspace, a path where a single project should be exported. This configuration ovewrites the primary workspace.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String,path:%String=..GetWorkspace()</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set ^Port.Configuration("workspace.project", projectName) = path
  return $$$OK
]]></Implementation>
</Method>

<Method name="GetCustomWorkspace">
<Description>
Retrieves the resolved workspace path for the provided project. Returns empty if there's none.</Description>
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set customWorkspace = $get(^Port.Configuration("workspace.project", projectName))
  return ..RewritePlaceHolders(customWorkspace, projectName, $lb("{NAMESPACE}","{INSTALLDIR}","{PROJECT}","{USERNAME}"))
]]></Implementation>
</Method>

<Method name="HasCustomWorkspace">
<Description>
Returns if the project has a custom workspace.</Description>
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[

  return (..GetCustomWorkspace(projectName) '= "")
]]></Implementation>
</Method>

<Method name="RemoveCustomWorkspace">
<Description>
Removes the custom workspace from the project provided, which also resets it back to using the primary.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String</FormalSpec>
<Implementation><![CDATA[  kill ^Port.Configuration("workspace.project", projectName)
]]></Implementation>
</Method>

<Method name="Uninstall">
<Description>
Remove all Port configurations. This will not erase project logs.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  kill ^Port.Configuration
  return $$$OK
]]></Implementation>
</Method>

<Method name="RegisterExtendedHooks">
<Description>
Defines a class used to handle source control hooks after Port execution.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>implementer:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if implementer = "" kill ^Port.Configuration("source.hooks.custom")
  if '##class(%Dictionary.CompiledClass).%ExistsId(implementer) return $$$ERROR($$$ClassDoesNotExist, implementer)
  set ^Port.Configuration("source.hooks.custom") = implementer
  return $$$OK
]]></Implementation>
</Method>

<Method name="GetInternalCharset">
<Description>
Get the charset to be used when saving a document matching the provided extension.
Defaults to "UTF8".</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>extension:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  return $get(^Port.Configuration("source.charset.internal", $$$ucase(extension)), "UTF8")
]]></Implementation>
</Method>

<Method name="GetExternalCharset">
<Description>
Get the charset to be used when retrieving/exporting a file matching the provided extension.
Defaults to "UTF8".</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>extension:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  return $get(^Port.Configuration("source.charset.external", $$$ucase(extension)), "UTF8")
]]></Implementation>
</Method>

<Method name="SetInternalCharset">
<Description>
Set the character set to be used when saving a document to Caché with the provided extension.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>extension:%String,charset:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set ^Port.Configuration("source.charset.internal", $$$ucase(extension)) = charset
  return $$$OK
]]></Implementation>
</Method>

<Method name="SetExternalCharset">
<Description>
Set the character set to be used when retrieving a document from Caché with the provided extension.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>extension:%String,charset:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set ^Port.Configuration("source.charset.external", $$$ucase(extension)) = charset
  return $$$OK
]]></Implementation>
</Method>

<Method name="GetExtendedHooksImplementer">
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  return $get(^Port.Configuration("source.hooks.custom"))
]]></Implementation>
</Method>

<Method name="SetTestFormat">
<Description>
Defines which format the Port should for running unit test. When "XML" is selected, Port will export test classes as xml.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>type:%String</FormalSpec>
<Implementation><![CDATA[
  set type = $$$ucase(type)
  if '$lf($lb("UDL", "XML"), type) quit
  set ^Port.Configuration("test.format") = type
]]></Implementation>
</Method>

<Method name="GetTestFormat">
<Description>
Returns the selected test format. It can be "UDL" or "XML".</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>type:%String</FormalSpec>
<Implementation><![CDATA[  return $get(^Port.Configuration("test.format"), "XML")
]]></Implementation>
</Method>

<Method name="RewritePlaceHolders">
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec>basePath:%String,projectName:%String=$get(^||Port.Project),allowedPlaceholders="*",params...:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[

  if '$data(params) set params = ""
  set translatedPath = basePath
  #define RewriteIfPathContains(%expression, %replacement) if ($lv(allowedPlaceholders) && $lf(allowedPlaceholders, %expression)) || (allowedPlaceholders = "*") set translatedPath = $select(translatedPath [ %expression : $replace(translatedPath, %expression, %replacement), 1: translatedPath)

  set installDirectory = $System.Util.InstallDirectory()
  set installDirectory = $extract(installDirectory, 1, $length(installDirectory) - 1)
  $$$RewriteIfPathContains("{NAMESPACE}", $namespace)
  $$$RewriteIfPathContains("{INSTALLDIR}", installDirectory)
  $$$RewriteIfPathContains("{USERNAME}", $username)
  $$$RewriteIfPathContains("{EXPORTPATH}", ..GetWorkspace())
  $$$RewriteIfPathContains("{FULLEXPORTPATH}", ##class(%File).NormalizeFilename(..GetWorkspace()))
  $$$RewriteIfPathContains("{SLASH}", $select($$$isWINDOWS: "\", 1: "/"))
  $$$RewriteIfPathContains("{PROJECT}", projectName)

  if params {
    for i=1:1:params $$$RewriteIfPathContains("{P"_i_"}", params(i))
  }
  return translatedPath
]]></Implementation>
</Method>

<Method name="AllowEmptyFileName">
<Description>
Enable or disable enqueing files that follow the format ".name". When disabled
Port will ignore these files altogether. Useful if you don't want to import directories
that there supposed to be internal or hidden.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>value:%Integer</FormalSpec>
<Implementation><![CDATA[
  if '$lf($lb(0,1), value) quit
  set ^Port.Configuration("files.allowEmptyName") = value
]]></Implementation>
</Method>

<Method name="IsAllowEmptyFileNameEnabled">
<Description>
Returns if Port is allowed to enqueue files on which the name follows the format ".name".</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[  return $get(^Port.Configuration("files.allowEmptyName"), 0)
]]></Implementation>
</Method>
</Class>


<Class name="Port.Installer">
<Abstract>1</Abstract>
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64306,34529.365286</TimeCreated>

<XData name="LocaleEN">
<XMLNamespace>https://github.com/rfns/port</XMLNamespace>
<Data><![CDATA[
<?xml version="1.0" encoding="UTF-8"?>
<MsgFile Language="en">
  <MsgDomain Domain="Port Errors">
    <Message Id="-100" Name="InvalidPhysicalPath">The provided physical path '%1' is not part of the static files directory.</Message>
    <Message Id="-101" Name="NamespaceDoesntHaveAppWithPath">There is not an application with a physical path for the namespace %1.</Message>
    <Message Id="-102" Name="CannotCreateDirectory">Could not create the directory %1.</Message>
    <Message Id="-103" Name="CannotUseRelativePath">Cannot use a relative path, an absolute path must be provided.</Message>
    <Message Id="-104" Name="UnableToCopySource">Could not copy the file from %1 to %2.</Message> 
    <Message Id="-105" Name="UnableToExportInvalidItem">Could not export the item %1 because it does not exist.</Message>
    <Message Id="-106" Name="ErrorsWhileImporting">There were errors while export the project %1.</Message>
    <Message Id="-107" Name="AmbiguousPartialToWorkspace">The obtained partial path %1 is ambiguous to this project path. If you want to export the project itself, then use the 'Import' method.</Message>
    <Message Id="-108" Name="SupressedAttemptToExportFromOutside">Cannot import a file that is outside the project workspace.</Message>    
    <Message Id="-109" Name="UnableToRemoveDirectory">Could not remove the directory %1.</Message>
    <Message Id="-110" Name="UnableToDescribeItem">Could not describe the item %1 due to a violation regarding the expected extension: this item should %2</Message>
    <Message Id="-111" Name="PortIsNotInstalled">Port is not installed on namespace %1.</Message>
    <Message Id="-112" Name="NoTestSuitesWereFound">No tests suites were found for this project.</Message>
    <Message Id="-113" Name="ExportingProjectNotFound">The selected %1 project does not exist.</Message>
    <Message Id="-114" Name="ErrorsWhileImportingType">There were errors while importing items type of %1.</Message>
    <Message Id="-115" Name="LogLevelIsOutOfRange">The provided log level %1 is out of range. Parameter must be one of: %2.</Message>
    <Message Id="-116" Name="CouldNotDetermineWorkspace">Could not determine the correct workspace from the provided path.</Message>
    <Message Id="-117" Name="CannotSaveConflictingItems">Cannot save items that belongs to other projects. Please remove '%1' from the projects listed below if you want to save it into '%3': %2</Message>
    <Message Id="-118" Name="FailedWhileRunningExtendedHook">Failed while running extended hook '%1'.</Message>
    <Message Id="-119" Name="NoCompatibleApplicationForPublicFile">There is no compatible web application for the public file located at %1.</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Log Messages">
    <Message Id="-200" Name="BackupStart">Starting backup ...</Message>
    <Message Id="-201" Name="BackupAlert">DO NOT INTERRUPT THIS PROCESS.</Message>
    <Message Id="-202" Name="BackupMirror">Mirroring the web application to a temporary directory ...</Message>
    <Message Id="-203" Name="RemovingBackupMirror">Removing the temporary directory.</Message>
    <Message Id="-300" Name="NoItemsToExport">There are no items to export. The operation has been aborted.</Message>
    <Message Id="-301" Name="ExportingProject">Exporting the project %1.</Message>
    <Message Id="-302" Name="SourceExportedToPath">The source code has been exported to the path %1.</Message>
    <Message Id="-303" Name="ExportingType">Exporting %1 %2 ...</Message>
    <Message Id="-304" Name="NewWorkspaceDetected">A new workspace has been detected for %1. The project will be exported as a whole.</Message>
    <Message Id="-400" Name="SynchronizingProject">Synchronizing the project %1.</Message>
    <Message Id="-401" Name="CheckingExtraneousItems">Checking the project for extraneous items ...</Message>
    <Message Id="-402" Name="TotalExtraneousItems">Total extraneous items found: %1.</Message>
    <Message Id="-403" Name="NoExtraneousItems">No extraneous items were found.</Message>
    <Message Id="-404" Name="RemovingFile">Removing %1 (file).</Message>
    <Message Id="-405" Name="RemovingDirectory">Removing %1 (directory).</Message>
    <Message Id="-406" Name="TotalExtraneousItemsRemoved">Total of extraneous items removed: %1</Message>
    <Message Id="-500" Name="Done"> done.</Message>
    <Message Id="-501" Name="DoneWithErrors"> done, but with errors.</Message>
    <Message Id="-501" Name="Failed"> failed.</Message>
    <Message Id="-502" Name="AllDone">Finished with success.</Message>
    <Message Id="-503" Name="UpToDate"> is up-to-date.</Message>
    <Message Id="-504" Name="OvewriteWithExtension"> end with the %1 extension.</Message>
    <Message Id="-600" Name="ImportingType">Importing %1 %2 ...</Message>
    <Message Id="-601" Name="EnqueingType">Enqueueing the selected %1 to be imported.</Message>
    <Message Id="-602" Name="NothingToImport">Nothing to import has been found.</Message>
    <Message Id="-603" Name="ImportingProject">Importing the project %1.</Message>
    <Message Id="-604" Name="EnqueueingItems">Enqueing items to be imported ...</Message>
    <Message Id="-605" Name="TotalItemsToImport">Total of items to import: %1.</Message>
    <Message Id="-606" Name="NoPendingItemsToImport">No items to import were found.</Message>
    <Message Id="-607" Name="NewProject">The project %1 does not exist yet and will be created.</Message>
    <Message Id="-608" Name="FatalErrorAlert">FATAL: The following errors prevented the project from being imported:</Message>
    <Message Id="-609" Name="FatalRollbackAlert">All changes will be discarded on the next steps.</Message>
    <Message Id="-610" Name="FatalProjectIntegrityRiskWarning">WARNING! DO NOT INTERRUPT THE PROCESS TO AVOID COMPROMISING THE PROJECT INTEGRITY!</Message>
    <Message Id="-611" Name="FatalRollingBackTransaction">Discarding the pending transaction ...</Message>
    <Message Id="-612" Name="FatalApplyingBackup">Applying the backup to revert the web application back to its initial state.</Message>
    <Message Id="-613" Name="FatalFailedToRestoreBackup">ERROR: Could not apply the backup entirely due to a system error. The backup will be kept to be applied manually.</Message>    
    <Message Id="-614" Name="ProjectSaved">The project %1 has been saved with %2 items.</Message>
    <Message Id="-700" Name="CannotUseDefault">The usage of 'Default' named projects is prohibited. If you want use this project, you must provide another name by using File->Save As.</Message>
    <Message Id="-701" Name="CannotUseDefault2">All active hooks are now disabled.</Message>    
    <Message Id="-800" Name="ClassType">class</Message>
    <Message Id="-801" Name="ProjectType">project</Message>
    <Message Id="-802" Name="RoutineType">routine</Message>
    <Message Id="-803" Name="FileType">file</Message>
    <Message Id="-804" Name="DirectoryType">diretório</Message>
    <Message Id="-805" Name="MACGroupType">macro routines</Message>
    <Message Id="-806" Name="INCGroupType">include files</Message>
    <Message Id="-807" Name="INTGroupType">intermediate routines</Message>
    <Message Id="-808" Name="BASGroupType">Basic routines</Message>
    <Message Id="-809" Name="MVBGroupType">MV Basic routines</Message>
    <Message Id="-810" Name="MVIGroupType">MVI routines</Message>
    <Message Id="-811" Name="DFIGroupType">DFI files</Message>
    <Message Id="-812" Name="CLSGroupType">classes</Message>
    <Message Id="-813" Name="FileGroupType">files</Message>
    <Message Id="-900" Name="ExportingXML">Exporting the project %1 to XML ...</Message>
    <Message Id="-901" Name="XMLExportedTo">%1 project XML exported to %2.</Message>
    <Message Id="-902" Name="ExportingTestClassToXML">Exporting test class %1 ...</Message>
    <Message Id="-1000" Name="ConflictingItemDetected">CAUTION! Detected the usage of the item %1 on the following projects: %2.</Message>
    <Message Id="-1001" Name="ConflictingItemDetected2">It's extremely recommended to keep the item exclusive to a single project!</Message>
    <Message Id="-1100" Name="RunningCustomHook">Executing hook extension %1 from the class %2 ...</Message>
    <Message Id="-1101" Name="HookReturnedOK">%1 returned without errors.</Message>
    <Message Id="-1102" Name="HookReturnedError">Failed while executing %1 due to the following reason: %2.</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Menu Labels">
    <Message Id="-5000" Name="MLExport">Export</Message>    
    <Message Id="-5001" Name="MLExportToXML">Export to XML</Message>
    <Message Id="-5002" Name="MLExportTests">Export tests</Message>
    <Message Id="-5003" Name="MLRemoveClasses">Remove classes</Message>
    <Message Id="-5004" Name="MLRemoveFiles">Remove files</Message>
    <Message Id="-5005" Name="MLRemoveRoutines">Remove routines</Message>
    <Message Id="-5006" Name="MLScanAndFix">Scan and fix</Message>
    <Message Id="-5007" Name="MLRunTests">Run tests</Message>
    <Message Id="-5008" Name="MLImport">Import</Message>
    <Message Id="-5009" Name="MLForceExport">Export (forced)</Message>
    <Message Id="-5010" Name="MLForceImport">Import (forced)</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Context Menu Labels">
    <Message Id="-6000" Name="CMLExportActive">Export from here</Message>
    <Message Id="-6001" Name="CMLImportActive">Import from here</Message>
    <Message Id="-6002" Name="CMLRunActiveTest">Run test</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Configuration Wizard">
    <Message Id="-7000" Name="PCWWelcome">Welcome to the Port configuration wizard.</Message>
    <Message Id="-7001" Name="PCWInvalidChoice">Invalid choice.</Message>
    <Message Id="-7002" Name="PCWChoiceQuestion">What do you want to do? (type the number)</Message>
    <Message Id="-7003" Name="PCWChoicePrompt">Your choice: </Message>
    <Message Id="-7004" Name="PCWAborted">Aborted.</Message>
    <Message Id="-7005" Name="PCWToggleEnabled">ENABLED</Message>
    <Message Id="-7006" Name="PCWToggleDisabled">DISABLED</Message>
    <Message Id="-7007" Name="PCWBye">Bye.</Message>
    <Message Id="-7100" Name="PCWManageWorkspaceChoice">1. Manage workspaces.</Message>
    <Message Id="-7101" Name="PCWManageWorkspaceDescription">Manages workspaces that will contain the exported source code.</Message>
    <Message Id="-7110" Name="PCWManageWorkspaceChoice1">1. Change primary workspace.</Message>
    <Message Id="-7111" Name="PCWManageWorkspaceChoice1Description">Configures the primary workspace that will be used to export your source code.</Message>    
    <Message Id="-7112" Name="PCWManageWorkspaceChoice1StatusCurrent">The current primary workspace is %1.</Message>
    <Message Id="-7113" Name="PCWManageWorkspaceChoice1StatusNow">The primary workspace is now set to %1.</Message>
    <Message Id="-7120" Name="PCWManageWorkspaceChoice2">2. Manage existing workspaces.</Message>
    <Message Id="-7121" Name="PCWManageWorkspaceChoice2Description">Manages workspaces associated to projects.</Message>
    <Message Id="-7122" Name="PCWManageWorkspaceChoice2Description2">Projects named here will not use the primary workspace definition.</Message>
    <Message Id="-7123" Name="PCWManageWorkspaceChoice2Prompt">Type the name of the project (or leave it empty to abort):</Message>
    <Message Id="-7124" Name="PCWManageWorkspaceChoice2Warning">WARNING: The project %1 doesn't exist yet."</Message>
    <Message Id="-7125" Name="PCWManageWorkspaceChoice2StatusCurrent">Current workspace for this project is: %1.</Message>
    <Message Id="-7126" Name="PCWManageWorkspaceChoice2CurrentWorskpaceWarn">You will be asked for a new workspace now.</Message>
    <Message Id="-7127" Name="PCWManageWorkspaceChoice2Prompt2">Type the workspace path (or leave it empty to abort):</Message>
    <Message Id="-7128" Name="PCWManageWorkspaceChoice2StatusNow">The project %1 is now configured to be exported using the following path: %2.</Message>    
    <Message Id="-7200" Name="PCWManageChangeTestSettingsChoice">2. Change test settings.</Message>
    <Message Id="-7201" Name="PCWManageChangeTestSettingsDescription">Configures settings related to the Studio test integration.</Message>
    <Message Id="-7210" Name="PCWManageChangeTestSettingsChoice1">1. Enable or disable test on demand.</Message>
    <Message Id="-7211" Name="PCWManageChangeTestSettingsChoice1Description">When this settings is enabled, Port will try to match the test class prefix and run the related test.</Message>
    <Message Id="-7212" Name="PCWManageChangeTestSettingsChoice1Choice1">1. Enable test on demand.</Message>
    <Message Id="-7213" Name="PCWManageChangeTestSettingsChoice1Choice2">2. Disable test on demand.</Message>
    <Message Id="-7214" Name="PCWManageChangeTestSettingsChoice1StatusCurrent">Test on demand is currently %1.</Message>
    <Message Id="-7220" Name="PCWManageChangeTestSettingsChoice2">2. Define a new test class prefix.</Message>
    <Message Id="-7221" Name="PCWManageChangeTestSettingsChoice2Description">A test class prefix is required to inform Port which package should be considered as a test package.</Message>
    <Message Id="-7222" Name="PCWManageChangeTestSettingsChoice2Description2">Port uses this prefix when trying to find an equivalent implementation class.</Message>
    <Message Id="-7223" Name="PCWManageChangeTestSettingsChoice2Description3">Ex: UnitTest.MyPackage.MyClass -> MyPackage.MyClass.</Message>
    <Message Id="-7224" Name="PCWManageChangeTestSettingsChoice2Prompt">Please type the prefix below. Note that prefixes can also be composed. Ex: Package.UnitTest.</Message>
    <Message Id="-7225" Name="PCWManageChangeTestSettingsChoice2StatusNow">The prefix is now set to: %1.</Message>
    <Message Id="-7230" Name="PCWManageChangeTestSettingsChoice3">3. Define the path where unit test classes should exported (XML).</Message>
    <Message Id="-7231" Name="PCWManageChangeTestSettingsChoice3Description">Defines the path where the each test classes should be exported.</Message>
    <Message Id="-7232" Name="PCWManageChangeTestSettingsChoice3StatusNow">"The test path is now set to: %1.</Message>
    <Message Id="-7300" Name="PCWToggleAutoExportChoice">3. Toggle project XML auto-export.</Message>
    <Message Id="-7301" Name="PCWToggleAutoExportDescription">Exports a XML file from project when a document is saved.</Message>
    <Message Id="-7302" Name="PCWToggleAutoExportChoice1StatusCurrent">Auto-export XML is currently %1.</Message>
    <Message Id="-7303" Name="PCWToggleAutoExportChoice1StatusNow">Auto-export XML is now %1.</Message>
    <Message Id="-7310" Name="PCWToggleAutoExportChoice1">1. Enable project XML auto-export.</Message>
    <Message Id="-7320" Name="PCWToggleAutoExportChoice2">2. Disable project XML auto-export.</Message>    
    <Message Id="-7400" Name="PCWSetLogLevelChoice">4. Set log level.</Message>
    <Message Id="-7401" Name="PCWSetLogLevelDescription">Specifies the log verbosity level when displaying operations.</Message>
    <Message Id="-7402" Name="PCWSetLogLevelStatusCurrent">Log verbosity level is currently: %1.</Message>
    <Message Id="-7403" Name="PCWSetLogLevelStatusNow">Log verbosity level is now: %1.</Message>
    <Message Id="-7404" Name="PCWSetLogLevelStatusPrompt">Please set the log verbosity level (type the number): </Message>
    <Message Id="-7410" Name="PCWSetLogLevelStatusChoice1">1. Level 1: Displays item enqueieing, import categories, backup notifications, repository status and error messages.</Message>
    <Message Id="-7420" Name="PCWSetLogLevelStatusChoice2">2. Level 2: Includes all verbosity from Level 1 plus detailed logging about atomical operations.</Message>    
    <Message Id="-7600" Name="PCWExit">5. Exit.</Message>
    <Message Id="-7970" Name="PCWPlaceholdersAnnounce">You can use the following specific placeholders:</Message>
    <Message Id="-7971" Name="PCWPlaceholdersProject">{PROJECT} - The active project name.</Message>
    <Message Id="-7972" Name="PCWPlaceholdersNamespace">{NAMESPACE} - The active namespace name.</Message>
    <Message Id="-7973" Name="PCWPlaceholdersUsername">{USERNAME} - The active user name.</Message>
    <Message Id="-7974" Name="PCWPlaceholdersInstallDir">{INSTALLDIR} - The Caché installation directory.</Message>
    <Message Id="-7980" Name="PCWPathRelative">Please type the RELATIVE path to be used when exporting your test files. Paths should be relative to the exported project root. (Or leave it empty to restore the default)</Message>
    <Message Id="-7981" Name="PCWPathAbsolute">Please type the ABSOLUTE path to be used when exporting your source files (Or leave it empty to restore the default)</Message>
    <Message Id="-7982" Name="PCWPathOSSchemes">You can use both: *NIX or Windows schemes.</Message>
    <Message Id="-7983" Name="PCWPathDefault">Default is:</Message>
    <Message Id="-7984" Name="PCWPathCurrent">Current is:</Message>
    <Message Id="-7985" Name="PCWPathNew">New: </Message>
    <Message Id="-7999" Name="PCWGoBackChoice">%1. Go back.</Message>
  </MsgDomain>
</MsgFile>
]]></Data>
</XData>

<XData name="LocalePTBR">
<XMLNamespace>https://github.com/rnfs/port</XMLNamespace>
<Data><![CDATA[
<?xml version="1.0" encoding="UTF-8"?>
<MsgFile Language="pt-br">
  <MsgDomain Domain="Port Errors">
    <Message Id="-100" Name="InvalidPhysicalPath">O caminho físico '%1' fornecido não pertence ao diretório de arquivos estáticos.</Message>
    <Message Id="-101" Name="NamespaceDoesntHaveAppWithPath">Não existe uma aplicação com caminho físico para o namespace %1.</Message>
    <Message Id="-102" Name="CannotCreateDirectory">Não foi possível criar o diretório %1.</Message>
    <Message Id="-103" Name="CannotUseRelativePath">Não é possível utilizar um caminho relativo, o caminho precisa estar completo.</Message> 
    <Message Id="-104" Name="UnableToCopySource">Não foi possível copiar o arquivo de %1 para %2.</Message> 
    <Message Id="-105" Name="UnableToExportInvalidItem">Não foi possível exportar o item %1 pois ele não existe.</Message>
    <Message Id="-106" Name="ErrorsWhileImporting">Houveram erros ao importar %1.</Message>
    <Message Id="-107" Name="AmbiguousPartialToWorkspace">O caminho parcial %1 obtido é ambíguo ao caminho deste projeto. Se você deseja exportar o projeto, utilize o método 'Import'.</Message>
    <Message Id="-108" Name="SupressedAttemptToExportFromOutside">Não é possível importar um arquivo que esteja fora do espaço de trabalho deste projeto.</Message>
    <Message Id="-109" Name="UnableToRemoveDirectory">Não foi possível remover o diretório %1.</Message>
    <Message Id="-110" Name="UnableToDescribeItem">Não foi possível descrever o item o %1 devido à uma violação no extensão esperada: este item deve %2</Message>
    <Message Id="-111" Name="PortIsNotInstalled">Port não está instalado no namespace %1.</Message>
    <Message Id="-112" Name="NoTestSuitesWereFound">Não foram encontradas suítes de teste para este projeto.</Message>
    <Message Id="-113" Name="ExportingProjectNotFound">O projeto %1 selecionado para ser exportado não existe.</Message>
    <Message Id="-114" Name="ErrorsWhileImportingType">Houveram errors ao importar itens do tipo %1.</Message>
    <Message Id="-115" Name="LogLevelIsOutOfRange">O nível de log fornecido está fora da faixa permitida. O parâmetro deve ser um destes: %2.</Message>
    <Message Id="-116" Name="CouldNotDetermineWorkspace">Não foi possível determinar o espaço de trabalho correto a patir do caminho fornecido.</Message>
    <Message Id="-117" Name="CannotSaveConflictingItems">Não é possível salvar itens que pertençam a outros projetos. Por favor remova o item %1 dos projetos abaixo se você deseja salvá-lo em '%3': %2</Message>
    <Message Id="-118" Name="FailedWhileRunningExtendedHook">Falha ao rodar extensão do evento '%1'.</Message>
    <Message Id="-119" Name="NoCompatibleApplicationForPublicFile">Não existe uma aplicação web compatível com o arquivo público localizado em %1.</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Log Messages">
    <Message Id="-200" Name="BackupStart">Iniciando backup...</Message>
    <Message Id="-201" Name="BackupAlert">NÃO INTERROMPA ESTE PROCESSO.</Message>
    <Message Id="-202" Name="BackupMirror">Espelhando a estrutura da aplicação web para um diretório temporário ...</Message>
    <Message Id="-203" Name="RemovingBackupMirror">Removendo o diretório temporário.</Message>
    <Message Id="-300" Name="NoItemsToExport">Não há itens para serem exportados. A operação foi abortada.</Message>
    <Message Id="-301" Name="ExportingProject">Exportando o projeto %1.</Message>
    <Message Id="-302" Name="SourceExportedToPath">O código-fonte foi exportado para o caminho %1.</Message>
    <Message Id="-303" Name="ExportingType">Exportando %1 %2 ...</Message>
    <Message Id="-304" Name="NewWorkspaceDetected">Um novo espaço de trabalho foi detectado para %1. O projeto será exportado como um todo.</Message>
    <Message Id="-400" Name="SynchronizingProject">Sincronizando o projeto %1.</Message>
    <Message Id="-401" Name="CheckingExtraneousItems">Verificando o projeto em busca de itens desconhecidos ... </Message>
    <Message Id="-402" Name="TotalExtraneousItems">Total de items desconhecidos encontrados: %1.</Message>
    <Message Id="-403" Name="NoExtraneousItems">Não há itens para eliminar.</Message>
    <Message Id="-404" Name="RemovingFile">Removendo %1 (arquivo).</Message>
    <Message Id="-405" Name="RemovingDirectory">Removendo %1 (diretório).</Message>
    <Message Id="-406" Name="TotalExtraneousItemsRemoved">Total de itens desconhecidos removidos: %1.</Message>
    <Message Id="-500" Name="Done"> feito.</Message>
    <Message Id="-501" Name="DoneWithErrors"> feito, mas com erros.</Message>
    <Message Id="-501" Name="Failed"> falhou.</Message>
    <Message Id="-502" Name="AllDone">Terminado com sucesso.</Message>
    <Message Id="-503" Name="UpToDate"> o item já está atualizado.</Message>
    <Message Id="-504" Name="OvewriteWithExtension">terminar com a extensão %1.</Message> 
    <Message Id="-600" Name="ImportingType">Importando %1 %2 ...</Message>
    <Message Id="-601" Name="EnqueingType">Enfileirando o %1 escolhido para ser importado ...</Message>
    <Message Id="-602" Name="NothingToImport">Nada para importar foi encontrado.</Message>
    <Message Id="-603" Name="ImportingProject">Importando o projeto %1.</Message>
    <Message Id="-604" Name="EnqueueingItems">Enfilerando itens para serem importados.</Message>
    <Message Id="-605" Name="TotalItemsToImport">Total de itens para importar: %1.</Message>
    <Message Id="-606" Name="NoPendingItemsToImport">Não há itens para serem importados.</Message>
    <Message Id="-607" Name="NewProject">O projeto %1 ainda não existe e será criado a seguir.</Message>
    <Message Id="-608" Name="FatalErrorAlert">FATAL: O seguintes erros impediram o projeto de ser importado:</Message>
    <Message Id="-609" Name="FatalRollbackAlert">As alterações serão desfeitas nas etapas a seguir.</Message>
    <Message Id="-610" Name="FatalProjectIntegrityRiskWarning">AVISO! NÃO INTERROMPA O PROCESSO PARA NÃO COMPROMETER A INTEGRIDADE DO PROJETO!</Message>
    <Message Id="-611" Name="FatalRollingBackTransaction">Descartando a transação pendente ...</Message>
    <Message Id="-612" Name="FatalApplyingBackup">Aplicando o backup para reverter alterações no caminho da aplicação.</Message>
    <Message Id="-613" Name="FatalFailedToRestoreBackup">ERRO: Não foi possível aplicar o backup inteiramente devido a um erro de sistema. O backup será mantido para uma correção manual.</Message>
    <Message Id="-614" Name="ProjectSaved">O projeto %1 foi salvo com %2 itens.</Message>
    <Message Id="-700" Name="CannotUseDefault">Não é permitido o uso de projetos 'Default'. Se você deseja usar este projeto, você precisa fornecer outro nome utilizando Arquivo->Salvar Como.</Message>
    <Message Id="-701" Name="CannotUseDefault2">Todos os eventos foram desativados.</Message>
    <Message Id="-800" Name="ClassType">classe</Message>
    <Message Id="-801" Name="ProjectType">projeto</Message>
    <Message Id="-802" Name="RoutineType">rotina</Message>
    <Message Id="-803" Name="FileType">arquivo</Message>
    <Message Id="-804" Name="DirectoryType">diretório</Message>
    <Message Id="-805" Name="MACGroupType">rotinas macro</Message>
    <Message Id="-806" Name="INCGroupType">arquivos de inclusão</Message>
    <Message Id="-807" Name="INTGroupType">rotinas intermediárias</Message>
    <Message Id="-808" Name="BASGroupType">rotinas Basic</Message>
    <Message Id="-809" Name="MVBGroupType">rotinas MV Basic</Message>
    <Message Id="-810" Name="MVIGroupType">rotinas MVI</Message>
    <Message Id="-811" Name="DFIGroupType">arquivos DFI</Message>
    <Message Id="-812" Name="CLSGroupType">classes</Message>
    <Message Id="-813" Name="FileGroupType">arquivos</Message>
    <Message Id="-900" Name="ExportingXML">Exportando o projeto %1 para XML ...</Message>
    <Message Id="-901" Name="XMLExportedTo">XML do projeto %1 exportado para %2.</Message>
    <Message Id="-902" Name="ExportingTestClassToXML">Exportando a classe de teste %1 ...</Message>
    <Message Id="-1000" Name="ConflictingItemDetected">CUIDADO! Foi detectada a presença do item %1 nos seguintes projetos: %2.</Message>
    <Message Id="-1001" Name="ConflictingItemDetected2">É extremamente recomendado manter o item exclusivo a um projeto!</Message>
    <Message Id="-1100" Name="RunningCustomHook">Executando extensão do evento %1 da classe %2 ...</Message>
    <Message Id="-1101" Name="HookReturnedOK">%1 retornou sem erros.</Message>
    <Message Id="-1102" Name="HookReturnedError">Falhou ao executar %1 devido ao seguinte motivo: %2</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Menu Labels">
    <Message Id="-5000" Name="MLExport">Exportar</Message>    
    <Message Id="-5001" Name="MLExportToXML">Exportar para XML</Message>
    <Message Id="-5002" Name="MLExportTests">Exportar testes</Message>
    <Message Id="-5003" Name="MLRemoveClasses">Remover classes</Message>
    <Message Id="-5004" Name="MLRemoveFiles">Remover arquivos</Message>
    <Message Id="-5005" Name="MLRemoveRoutines">Remover rotinas</Message>
    <Message Id="-5006" Name="MLScanAndFix">Verificar e corrigir</Message>
    <Message Id="-5007" Name="MLRunTests">Executar testes</Message>
    <Message Id="-5008" Name="MLImport">Importar</Message>
    <Message Id="-5009" Name="MLForceExport">Exportar (forçado)</Message>
    <Message Id="-5010" Name="MLForceImport">Importar (forçado)</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Context Menu Labels">
    <Message Id="-6000" Name="CMLExportActive">Exportar a partir deste item</Message>
    <Message Id="-6001" Name="CMLImportActive">Importar a partir deste item</Message>
    <Message Id="-6002" Name="CMLRunActiveTest">Executar teste</Message>
  </MsgDomain>
  <MsgDomain Domain="Port Configuration Wizard">
    <Message Id="-7000" Name="PCWWelcome">Bem-vindo ao assistente de configuração do Port.</Message>
    <Message Id="-7001" Name="PCWInvalidChoice">Escolha inválida.</Message>
    <Message Id="-7002" Name="PCWChoiceQuestion">O que você deseja fazer? (digite o número)</Message>
    <Message Id="-7003" Name="PCWChoicePrompt">Sua escolha: </Message>
    <Message Id="-7004" Name="PCWAborted">Abortado.</Message>
    <Message Id="-7005" Name="PCWToggleEnabled">ATIVADO</Message>
    <Message Id="-7006" Name="PCWToggleDisabled">DESATIVADO</Message>
    <Message Id="-7007" Name="PCWBye">Até mais.</Message>
    <Message Id="-7100" Name="PCWManageWorkspaceChoice">1. Gerenciar espaços de trabalho.</Message>
    <Message Id="-7101" Name="PCWManageWorkspaceDescription">Gerencia espaços de trabalho que irão conter o código-fonte.</Message>
    <Message Id="-7110" Name="PCWManageWorkspaceChoice1">1. Alterar espaço de trabalho padrão.</Message>
    <Message Id="-7111" Name="PCWManageWorkspaceChoice1Description">Altera o espaço de trabalho utilizado por padrão. Aplicável somente para novos projetos.</Message>
    <Message Id="-7112" Name="PCWManageWorkspaceChoice1StatusCurrent">O espaço de trabalho padrão atual é %1.</Message>
    <Message Id="-7113" Name="PCWManageWorkspaceChoice1StatusNow">O espaço de trabalho padrão agora é %1.</Message>
    <Message Id="-7120" Name="PCWManageWorkspaceChoice2">2. Gerencia espaços de trabalho existentes.</Message>
    <Message Id="-7121" Name="PCWManageWorkspaceChoice2Description">Gerencia espaços de trabalhos vinculados a projetos já existentes ou de antemão.</Message>
    <Message Id="-7122" Name="PCWManageWorkspaceChoice2Description2">Esta configuração sobrescreverá o espaço de trabalho padrão para o projeto escolhido.</Message>
    <Message Id="-7123" Name="PCWManageWorkspaceChoice2Prompt">Digite o nome do projeto (ou deixe vazio para abortar):</Message>
    <Message Id="-7124" Name="PCWManageWorkspaceChoice2Warning">AVISO: O projeto %1 ainda não existe."</Message>
    <Message Id="-7125" Name="PCWManageWorkspaceChoice2StatusCurrent">Espaço de trabalho atual para este projeto: %1.</Message>
    <Message Id="-7126" Name="PCWManageWorkspaceChoice2CurrentWorskpaceWarn">Será requisitado um novo espaço de trabalho a seguir.</Message>
    <Message Id="-7127" Name="PCWManageWorkspaceChoice2Prompt2">Digite o caminho do espaço de trabalho (ou deixe vazio para abortar):</Message>
    <Message Id="-7128" Name="PCWManageWorkspaceChoice2StatusNow">O projeto %1 agora está configurado para ser exportado no caminho: %2.</Message>    
    <Message Id="-7200" Name="PCWManageChangeTestSettingsChoice">2. Alterar configurações de teste.</Message>
    <Message Id="-7201" Name="PCWManageChangeTestSettingsDescription">Altera configurações relacionadas à integração do Studio com a API de testes.</Message>
    <Message Id="-7210" Name="PCWManageChangeTestSettingsChoice1">1. Ativar ou desativar testes por demanda.</Message>
    <Message Id="-7211" Name="PCWManageChangeTestSettingsChoice1Description">Quando esta configuração estivar ativa, Port irá tentar encontrar a classe de teste da classe em edição e executar seus testes após sua compilação.</Message>
    <Message Id="-7212" Name="PCWManageChangeTestSettingsChoice1Choice1">1. Ativar testes por demanda.</Message>
    <Message Id="-7213" Name="PCWManageChangeTestSettingsChoice1Choice2">2. Desativar testes por demanda.</Message>
    <Message Id="-7214" Name="PCWManageChangeTestSettingsChoice1StatusCurrent">Testes por demanda está atualmente %1.</Message>
    <Message Id="-7220" Name="PCWManageChangeTestSettingsChoice2">2. Definir um novo prefíxo para classes de teste.</Message>
    <Message Id="-7221" Name="PCWManageChangeTestSettingsChoice2Description">Um prefixo é requirido para informar ao Port qual pacote deve ser considerado como um pacote com classes de teste.</Message>
    <Message Id="-7222" Name="PCWManageChangeTestSettingsChoice2Description2">Este prefíxo é utilizado como uma forma de equivalência.</Message>
    <Message Id="-7223" Name="PCWManageChangeTestSettingsChoice2Description3">Ex: UnitTest.MyPackage.MyClass -> MyPackage.MyClass.</Message>
    <Message Id="-7224" Name="PCWManageChangeTestSettingsChoice2Prompt">Por favor digite o prefíxo abaixo. Note que prefíxos também pode ser compostos. Ex: Package.UnitTest.</Message>
    <Message Id="-7225" Name="PCWManageChangeTestSettingsChoice2StatusNow">O prefíxo agora é: %1.</Message>
    <Message Id="-7230" Name="PCWManageChangeTestSettingsChoice3">3. Alterar caminho para classes de teste (XML).</Message>
    <Message Id="-7231" Name="PCWManageChangeTestSettingsChoice3Description">Define o caminho raíz aonde as classes de testes serão hierarquicamente exportadas.</Message>
    <Message Id="-7232" Name="PCWManageChangeTestSettingsChoice3StatusNow">O caminho para classes de teste agora é: %1.</Message>
    <Message Id="-7300" Name="PCWToggleAutoExportChoice">3. Ativar ou desativar a exportação automática do XML do projeto.</Message>
    <Message Id="-7301" Name="PCWToggleAutoExportDescription">Exporta um arquivo XML quando o projeto ou um item dele é salvo.</Message>
    <Message Id="-7302" Name="PCWToggleAutoExportChoice1StatusCurrent">Exportação automática está atualmente como %1.</Message>
    <Message Id="-7303" Name="PCWToggleAutoExportChoice1StatusNow">Exportação automática agora está como %1.</Message>
    <Message Id="-7310" Name="PCWToggleAutoExportChoice1">1. Ativar exportação automática do XML.</Message>
    <Message Id="-7320" Name="PCWToggleAutoExportChoice2">2. Desativar exportação automática do XML.</Message>
    <Message Id="-7400" Name="PCWSetLogLevelChoice">4. Definir nível de log.</Message>
    <Message Id="-7401" Name="PCWSetLogLevelDescription">Especifica o nível de verbosidade utilizado no log de operações.</Message>
    <Message Id="-7402" Name="PCWSetLogLevelStatusCurrent">Nível de verbosidade atual do log: %1.</Message>
    <Message Id="-7403" Name="PCWSetLogLevelStatusNow">O nível de verbosidade do log agora é: %1.</Message>
    <Message Id="-7404" Name="PCWSetLogLevelStatusPrompt">Por favor escolha o nível de verbosidade do log (digite o número): </Message>
    <Message Id="-7410" Name="PCWSetLogLevelStatusChoice1">1. Nível 1: Exibe enfileiramento, categorias de importação/exportação, notificações de backup, situação do espaço de trabalho e mensagens de erro.</Message>
    <Message Id="-7420" Name="PCWSetLogLevelStatusChoice2">2. Nível 2: Inclui toda a verbosidade do nível 1, substituindo categorias por notificações por item.</Message>    
    <Message Id="-7600" Name="PCWExit">5. Sair.</Message>
    <Message Id="-7970" Name="PCWPlaceholdersAnnounce">Você pode utilizar os seguinte marcadores:</Message>
    <Message Id="-7971" Name="PCWPlaceholdersProject">{PROJECT} - O nome do projeto ativo.</Message>
    <Message Id="-7972" Name="PCWPlaceholdersNamespace">{NAMESPACE} - O namespace ativo.</Message>
    <Message Id="-7973" Name="PCWPlaceholdersUsername">{USERNAME} - O login do usuário que iniciou o processo.</Message>
    <Message Id="-7974" Name="PCWPlaceholdersInstallDir">{INSTALLDIR} - O diretório de instalação.</Message>
    <Message Id="-7980" Name="PCWPathRelative">Por favor digite o caminho RELATIVO a ser utilizado ao exportar os arquivos de teste. Os caminhos devem ser relativos à raiz do projeto exportado. (Ou deixe vazio para usar o padrão)</Message>
    <Message Id="-7981" Name="PCWPathAbsolute">Por favor digite o caminho ABSOLUTO a ser utilizado ao exportar o código-fonte. (Ou deixe vazio para usar o padrão)</Message>
    <Message Id="-7982" Name="PCWPathOSSchemes">Você pode usar ambos: esquemas *NIX ou Windows.</Message>
    <Message Id="-7983" Name="PCWPathDefault">Padrão é:</Message>
    <Message Id="-7984" Name="PCWPathCurrent">Atual é:</Message>
    <Message Id="-7985" Name="PCWPathNew">Novo: </Message>
    <Message Id="-7999" Name="PCWGoBackChoice">%1. Retornar.</Message>
  </MsgDomain>  
</MsgFile>
]]></Data>
</XData>

<Method name="Uninstall">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if '$data(^Port.Configuration("installed")) {
    return $$$PERROR($$$PortIsNotInstalled, $namespace)
  }
  
  write "Removing Port, please wait ...", !
  set sc = $$$OK
  do ##class(Port.Configuration).Uninstall()
  do ##class(Port.SourceControl.Log).Flush()
  set sc = $$$ADDSC(sc, ##class(%Studio.SourceControl.Interface).SourceControlClassSet($get(^Port.Configuration("old")), $namespace))
  set sc = $$$ADDSC(sc, ##class(Port.SourceControl.LogCleaner).RemoveTask())
  set sc = $$$ADDSC(sc, ..RemoveGlobalMapping())  
  if $$$ISOK(sc) write $$$FormatText("Port has been removed from %1.", $namespace), !
  else  write "One or more errors ocurred while removing Port:", !!, $System.Status.GetErrorText(sc)
  return $$$OK
]]></Implementation>
</Method>

<Method name="Install">
<ClassMethod>1</ClassMethod>
<FormalSpec>force:%Boolean={$get(^||Port.Envs("FORCE_INSTALL"), 0)}</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  
  if 'force {
    if $data(^Port.Configuration("installed")) {
      write "Port is already installed. The installer has been aborted.", !
      write "If you wish to change current settings then please use the wizard (Wizard^Port) or call this method with force=1.", !!
      return $$$ERROR($$$GeneralError, "Port is already installed.")
    }
  }
  
  try {
    write !, "Installing Port ... please wait a moment.", !    
    write "> Creating Message Dictionary ... ", !
    $$$ThrowOnError(..CreateMessageDictionary())
    write "> Creating global mappings ...", !   
    $$$ThrowOnError(..CreateGlobalMapping())
    write "> Setting up workspace structure ... ", !
    do ##class(Port.Configuration).SetPrimaryWorkspace("/CacheProjects/{NAMESPACE}/{PROJECT}")
    write "> Setting up test files directory ...", !
    do ##class(Port.Configuration).SetTestPath("tests/cls")
    write "> Defining default test class prefix ..", !
    do ##class(Port.Configuration).SetTestClassPrefix("UnitTest")
    write "> Configuring to run tests automatically ...", !
    do ##class(Port.Configuration).EnableTestOnDemand()
    write "> Configuring to export the project to XML automatically ...", !
    do ##class(Port.Configuration).EnableAutoExportXML()
    write "> Configuring log verbosity level to recommended level ...", !
    do ##class(Port.Configuration).SetLogLevel(1)
    write "> Registering source control log cleaner task for "_$namespace_" ...", !
    $$$ThrowOnError(##class(Port.SourceControl.LogCleaner).StartTask())
    write "> Installing %SourceControl hooks and activating it ...", !!
    set ^Port.Configuration("old.sourcecontrol") = ##class(%Studio.SourceControl.Interface).SourceControlClassGet($namespace)
    $$$ThrowOnError(##class(%Studio.SourceControl.Interface).SourceControlClassSet("Port.SourceControl.Hooks", $namespace))
    write "ALL DONE.", !
    write "NOTE: You must restart Studio in order to make the source control hooks work as expected."
    set ^Port.Configuration("installed") = 1
  } catch ex {
    set sc = ex.AsStatus()    
    write !!, "FATAL: Failed to install port due to the following reason: "
    do $System.OBJ.DisplayError(sc)
  }
  return sc
]]></Implementation>
</Method>

<Method name="CreateGlobalMapping">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set storage = $get(^||Port.Envs("DATABASE"), $namespace)
  set thisNamespace = $namespace
  new $namespace
  
  set $namespace = "%SYS"
  
  if ##class(Config.MapGlobals).Exists(storage, "Port.*") {
    write "> Global is already mapped. Skipping ...", !
    return $$$OK
  }
  
  try {
    $$$ThrowOnError(##class(Config.Namespaces).Get($namespace, .nsProperties))
    set glProperties("Database") = storage
    $$$ThrowOnError(##class(Config.MapGlobals).Create(thisNamespace, "Port.*", .glProperties))    
  } catch ex {
    set sc = ex.AsStatus()
  }
  set $namespace = thisNamespace
  return sc
]]></Implementation>
</Method>

<Method name="RemoveGlobalMapping">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set storage = $get(^||Port.Envs("DATABASE"), $namespace)
  set thisNamespace = $namespace    
  new $namespace
  
  set $namespace = "%SYS"  
  
  if ##class(Config.MapGlobals).Exists(storage, "Port.SourceControl*") {
    return ##class(Config.MapGlobals).Delete(storage, "Port.SourceControl*")
  }
  return $$$OK
]]></Implementation>
</Method>

<Method name="CreateMessageDictionary">
<ClassMethod>1</ClassMethod>
<CodeMode>objectgenerator</CodeMode>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
    
  do %code.WriteLine("  k ^CacheMsg(""Port Errors""),^CacheMsgNames(""Port Errors"")")
  do %code.WriteLine("  k ^CacheMsg(""Port Log Messages""), ^CacheMsgNames(""Port Log Messages"")")
  do %code.WriteLine("  k ^CacheMsg(""Port Menu Labels""), ^CacheMsgNames(""Port Menu Labels"")")
  do %code.WriteLine("  k ^CacheMsg(""Port Context Menu Labels""), ^CacheMsgNames(""Port Context Menu Labels"")")
  
  set XDatas = %compiledclass.XDatas
  
  for i=1:1:XDatas.Count() {
    set XDataId = $$$quote(%compiledclass.Name_"||"_XDatas.GetAt(i).Name)    
    do %code.WriteLine("  set localeXData = ##class(%Dictionary.CompiledXData).%OpenId("_XDataId_").Data")
    do %code.WriteLine("  set tmpFilename = ##class(%File).TempFilename(""xml"")")
    do %code.WriteLine("  set file = ##class(%Stream.FileCharacter).%New()")
    do %code.WriteLine("  set file.TranslateTable = ""UTF8""")
    do %code.WriteLine("  $$$QuitOnError(file.LinkToFile(tmpFilename))")
    do %code.WriteLine("  $$$QuitOnError(file.CopyFrom(localeXData))")
    do %code.WriteLine("  $$$QuitOnError(file.%Save())")
    do %code.WriteLine("  $$$QuitOnError(##class(%MessageDictionary).Import(tmpFilename))")
    do %code.WriteLine("  do ##class(%File).Delete(tmpFilename)")
    do %code.WriteLine("  set (localXData, tmpFilename, file) = """"")    
  }
  do %code.WriteLine("  set io = $io")
  do %code.WriteLine("  open $$$NULL")
  do %code.WriteLine("  use $$$NULL")
  do %code.WriteLine("  set sc = ##class(%MessageDictionary).GenerateInclude(""portmd"",,,""Port Errors,Port Log Messages,Port Menu Labels,Port Context Menu Labels"")")
  do %code.WriteLine("  use io")
  do %code.WriteLine("  close $$$NULL")
  do %code.WriteLine("  quit sc")
]]></Implementation>
</Method>
</Class>


<Class name="Port.Logger">
<IncludeCode>portutils</IncludeCode>
<Super>%RegisteredObject</Super>
<TimeCreated>64306,37945.966346</TimeCreated>

<Property name="LogLevel">
<Type>%Integer</Type>
<InitialExpression>2</InitialExpression>
</Property>

<Property name="Silent">
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Method name="%OnNew">
<FormalSpec>logLevel:%Integer=2</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if ((logLevel < 1) || (logLevel > 2)) {    
    $$$ThrowOnError($$$PERROR($$$LogLevelIsOutOfRange, logLevel, "1, 2")) 
  }
  set ..LogLevel = logLevel  
  return $$$OK
]]></Implementation>
</Method>

<Method name="Log">
<FormalSpec>messageCode:%String,messageLogLevel=2,params...:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  if ..Silent || (..LogLevel < messageLogLevel) return ""
  if '$data(params) set params = 0    
  set formattedParams = 0 
  for i=1:1:params {
    set formattedParams = $increment(formattedParams)
    set formattedParams(formattedParams) = $$$FormatMessage($$$SessionLanguage, "Port Log Messages", params(i), params(i))
  }
  set msg = $$$FormatMsg("Port Log Messages", messageCode, formattedParams...)
  if messageCode '= $$$Done && ((messageCode '= $$$Failed) && (messageCode '= $$$UpToDate)) set msg = "[Port] "_msg
  return msg
]]></Implementation>
</Method>

<Method name="LogLine">
<FormalSpec>messageCode:%String,messageLogLevel=2,params...:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  
  if ..Silent || (..LogLevel < messageLogLevel) return ""
  return ..Log(messageCode, messageLogLevel, params...)_$c(13, 10)
]]></Implementation>
</Method>
</Class>




<Class name="Port.Project.Backup">
<Description>
This is an internal utility used to backup CSP files which is triggered whenever
the user attempts to import a workspace that contains a 'public' folder.</Description>
<IncludeCode>portutils</IncludeCode>
<Super>%RegisteredObject</Super>
<TimeCreated>64306,37561.640431</TimeCreated>

<Property name="BackupDirectory">
<Description>
The directory where the affected items will be copied into.</Description>
<Type>%String</Type>
<Internal>1</Internal>
<Private>1</Private>
</Property>

<Property name="Logger">
<Description>
A reference for the logger used to display the current operation.</Description>
<Type>Port.Project.Importer</Type>
</Property>

<Property name="IsRequired">
<Description>
An internal flag used to signal if the backup should be made.</Description>
<Type>%Boolean</Type>
<Internal>1</Internal>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="BackupList">
<Description>
A list of affected files that is used to rollback.</Description>
<Type>%String</Type>
<MultiDimensional>1</MultiDimensional>
</Property>

<Method name="%OnNew">
<FormalSpec>backupDir:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set ..BackupDirectory = backupDir
  set ..Logger = ##class(Port.Logger).%New()
  quit $$$OK
]]></Implementation>
</Method>

<Method name="Create">
<Description><![CDATA[
Creates a backup from a list generated by the Importer. Everything affected will be put into the
path provided by BackupDiretory, which is usually located at <workspace>/__backup__.]]></Description>
<FormalSpec><![CDATA[&list:%String=0]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[

  set sc = $$$OK
  set itemName = ""
  set backupCount = 0
  set backupFolderIsCreated = 0

  if '..IsRequired quit $$$OK

  write ..Logger.Log($$$BackupStart), !
  write ..Logger.Log($$$BackupAlert), !
  write ..Logger.Log($$$BackupMirror, 1)

  do Scan(10, "CSP", .created)

  if $$$ISOK(sc) write ..Logger.Log($$$Done, 1), !
  else  write ..Logger.Log($$$Failed, 1), !
  return sc


Scan(group, type, created)
  set itemName = ""
  set created  = 0
  for {
    set itemName = $order(list(group, type, itemName), 1, updatedFilePath)
    quit:itemName=""

    set appPath = $System.CSP.GetAppName(itemName)
    set destination = ##class(%CSP.Routine).%New(itemName).Filename
    // TODO: Add extra check to avoid backing up files that are not really outdated.
    // Don't backup or remove anything if target file is not present in the project
    // or doesn't exists in the app.
    if '(##class(%File).Exists(updatedFilePath) && ##class(%File).Exists(destination)) {
      continue
    }
    set backup = ##class(Port.Util).ItemToPath(itemName, ..BackupDirectory)
    set backupDirectory = ##class(%File).GetDirectory(backup)
    set sc = ##class(Port.Util).EnsurePathExists(backupDirectory)
    if $$$ISERR(sc) quit

    set created = 1
    set isCopied = ##class(%File).CopyFile(destination, backup, 1)
    if isCopied = 0 {
      set sc = $$$ADDSC(sc, $$$PERROR($$$UnableToCopySource, itemName, backup))
    } else {
      set i%BackupList = $get(i%BackupList, 0) + 1
      set i%BackupList(i%BackupList) = $listbuild(backup, destination)
    }
  }
  if 'created {
    set ..IsRequired = 0
  }
]]></Implementation>
</Method>

<Method name="Rollback">
<Description>
Undo the changes made by the importer copying the __backup__ directory back into the CSP directory.</Description>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK

  for i=1:1:i%BackupList {
    set entry = i%BackupList(i)
    set backup = $listget(entry, 1)
    set destination = $listget(entry, 2)

    set success = ##class(%File).CopyFile(backup, destination, 1)
    if 'success set sc = $$$ADDSC(sc, $$$PERROR($$$UnableToCopySource, backup, destination))
  }

  kill i%BackupList
  quit sc
]]></Implementation>
</Method>
</Class>


<Class name="Port.Project.Base">
<Description>
This is the main class used to define a set of features that are shared by each type of utility.</Description>
<IncludeCode>portutils,portmd</IncludeCode>
<Super>%RegisteredObject</Super>
<TimeCreated>64306,34528.425857</TimeCreated>

<Property name="Logger">
<Description>
A reference for the utility that is used to display information regarding the current operation.</Description>
<Type>Port.Logger</Type>
</Property>

<Property name="Project">
<Description>
A reference for the current opened %Studio.Project.</Description>
<Type>%Studio.Project</Type>
<Private>1</Private>
</Property>

<Property name="BasePath">
<Description>
A string containing the workspace directory.</Description>
<Type>%String</Type>
</Property>

<Property name="IncPath">
<Description>
A string containing the workspace plus the 'inc' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="ClassPath">
<Description>
A string containing the workspace plus the 'cls' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="IntPath">
<Description>
A string containing the workspace plus the 'int' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="MacPath">
<Description>
A string containing the workspace plus the 'mac' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="PublicPath">
<Description>
A string containing the workspace plus the 'public' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="MvbPath">
<Description>
A string containing the workspace plus the 'mvb' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="MviPath">
<Description>
A string containing the workspace plus the 'mvi' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="BasPath">
<Description>
A string containing the workspace plus the 'bas' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="DfiPath">
<Description>
A string containing the workspace plus the 'dfi' directory.</Description>
<Type>%String</Type>
<Private>1</Private>
</Property>

<Property name="AffectedCount">
<Description>
Contains the count of items imported/exported.</Description>
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="IsBatch">
<Description>
A flag that indicates if the user opted to import/export more than one item.</Description>
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="Overwrite">
<Description>
A flag that signals the exporter/imported to overwrite every file/document regardless if they are up-to-date or not.</Description>
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="LogLevel">
<Description>
An integer indicating the level of the logger, which is used to filter what kind of info should de display for the end-user.</Description>
<Type>%Integer</Type>
<InitialExpression>2</InitialExpression>
</Property>

<Property name="IgnoredPaths">
<Description>
A list of files that are ignored by the synchronizer utility.</Description>
<Type>%String</Type>
<Collection>list</Collection>
</Property>

<Property name="ProjectName">
<Type>%String</Type>
<Private>1</Private>
</Property>

<Method name="%OnNew">
<FormalSpec>target:%String,logLevel:%Integer=2</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if target = "" {
    throw ##class(%Exception.StatusException).CreateFromStatus($$$ERROR(5001, "No target specified."))
  }

  if (target [ "/") || (target [ "\") {
    set workspaceName = $piece(target, $$$PathSlash(target), *)
    
    set project = ##class(%Studio.Project).%OpenId(workspaceName)
    if '$isobject(project) set project = ##class(%Studio.Project).%New()
    
    set project.Name = workspaceName
    set fullProjectPath = ##class(%File).NormalizeFilename(target)
    set ..BasePath = ##class(%File).NormalizeFilename(fullProjectPath)
    set ..Project = project    
    set ..ProjectName = workspaceName
    set ..Logger = ##class(Port.Logger).%New(logLevel)
    do ..BuildTypePaths(..BasePath)
    quit $$$OK
  }
  quit $$$PERROR($$$CannotUseRelativePath)
]]></Implementation>
</Method>

<Method name="LogExclusive">
<Description>
Displays the message only if the configured log level is exactly the same on provided for this method.</Description>
<Internal>1</Internal>
<FormalSpec>messageCode:%String,logLevel:%Integer,params...:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  if ..Logger.LogLevel '= logLevel quit ""
  quit ..Log(messageCode, logLevel, params...)
]]></Implementation>
</Method>

<Method name="Log">
<Description>
Displays the message if the configured log level is either the same or higher than the one provided for this method.
This method won't break the line.</Description>
<Internal>1</Internal>
<FormalSpec>messageCode:%Boolean,logLevel:%Integer=1,params...:%String</FormalSpec>
<Implementation><![CDATA[  quit ..Logger.Log(messageCode, logLevel, params...)
]]></Implementation>
</Method>

<Method name="LogLine">
<Description>
Same as Log, but this will break into a new line.</Description>
<Internal>1</Internal>
<FormalSpec>messageCode:%String,logLevel:%Integer=1,params...:%String</FormalSpec>
<Implementation><![CDATA[

  quit ..Logger.LogLine(messageCode, logLevel, params...)
]]></Implementation>
</Method>

<Method name="LogExclusiveLine">
<Description>
Same as LogExclusive, but will break into a new line.</Description>
<Internal>1</Internal>
<FormalSpec>message:%Boolean,logLevel:%Integer=1,params...:%String</FormalSpec>
<Implementation><![CDATA[
  if ..Logger.LogLevel '= logLevel quit ""
  quit ..Logger.LogLine(message, logLevel, params...)
]]></Implementation>
</Method>

<Method name="GetProjectName">
<Description>
Returns the name of the project that is being used by the utility.</Description>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  quit ..ProjectName
]]></Implementation>
</Method>

<Method name="Ignore">
<Description>
Adds a path to the IgnoredPaths list. Which is used by the Synchronizer to skip files.</Description>
<FormalSpec>ignoredPaths:%ArrayOfDataTypes=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK

  if '$isobject(ignoredPaths) quit sc
  if 'ignoredPaths.%IsA("%Collection.AbstractList") {
    quit $$$ERROR($$$BadParameter, "ignoredPaths")
  }

  for i=1:1:ignoredPaths.Count() {
    set absolutePath = ##class(%File).NormalizeFilename(..BasePath_"/"_ignoredPaths.GetAt(i))
    set sc = ..IgnoredPaths.Insert(absolutePath)
    if $$$ISERR(sc) quit
  }
  quit sc
]]></Implementation>
</Method>

<Method name="IsIgnored">
<Description>
This method is used by the Sychronizer to check if the file should be skipped or not.</Description>
<FormalSpec>maybeIgnoredPath:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[

  set key = ""
  set isIgnored = 0

  for i=1:1:..IgnoredPaths.Count() {
    set path = ..IgnoredPaths.GetAt(i)
    set isIgnored = ((path = maybeIgnoredPath) || (maybeIgnoredPath [ path))
    if isIgnored quit
  }
  quit isIgnored
]]></Implementation>
</Method>

<Method name="GetTypePath">
<Description>
Returns the current path for the 'type' and 'itemName' provided. This method is not intended to be used by the Synchronizer</Description>
<Internal>1</Internal>
<FormalSpec>itemType:%String,itemName:%String=""</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[

  if itemType = "CLS" quit ..ClassPath
  if itemType = "INT" quit ..IntPath
  if itemType = "INC" || (itemType = "MAC" && ($piece(itemName, ".", 2) = "INC")) {
    // InterSystems groups INC into MAC type, so we patch it checking the name instead.
    quit ..IncPath
  }
  if itemType = "MAC" quit ..MacPath
  if itemType = "CSP" quit ..PublicPath
  if itemType = "MVB" quit ..MvbPath
  if itemType = "MVI" quit ..MviPath
  if itemType = "BAS" quit ..BasPath
  if itemType = "DFI" quit ..DfiPath
  if itemType = "PKG" quit ..ClassPath
  quit ..PublicPath
]]></Implementation>
</Method>

<Method name="BuildTypePaths">
<Description>
Populates each path type property that is used to discover where the file is located.</Description>
<Final>1</Final>
<Internal>1</Internal>
<FormalSpec>workspacePath:%String</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  #define BuildTypedPath(%type) $$$NFN(workspacePath_"/"_%type)

  set ..ClassPath   = $$$BuildTypedPath("cls")
  set ..IntPath     = $$$BuildTypedPath("int")
  set ..MacPath     = $$$BuildTypedPath("mac")
  set ..IncPath     = $$$BuildTypedPath("inc")
  set ..PublicPath  = $$$BuildTypedPath("public")
  set ..MvbPath     = $$$BuildTypedPath("mvb")
  set ..MviPath     = $$$BuildTypedPath("mvi")
  set ..BasPath     = $$$BuildTypedPath("bas")
  set ..DfiPath     = $$$BuildTypedPath("dfi")
  quit $$$OK
]]></Implementation>
</Method>

<Method name="IsOutdated">
<Description>
Returns if the item is up-to-date to its equivalent file version.</Description>
<FormalSpec>current:%String,external:%String,isImport:%Boolean=0</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.Util).IsOutdated(..GetProjectName(), current, external, isImport)
]]></Implementation>
</Method>
</Class>


<Class name="Port.Project.Exporter">
<Description>
This is the utility used to export the source code to the workspace.</Description>
<IncludeCode>portutils</IncludeCode>
<Super>Port.Project.Base</Super>
<TimeCreated>64306,34528.610794</TimeCreated>

<Property name="ExportedPackages">
<Description>
A list of packages that are already exported, this is used to prevent items from the same package from being exported again.</Description>
<Type>%List</Type>
<Private>1</Private>
</Property>

<Property name="Synchronizer">
<Description>
A reference for the sychronizer, which keeps the workspace directory sync'ed with the project items.</Description>
<Type>Synchronizer</Type>
<Private>1</Private>
</Property>

<Method name="%OnNew">
<FormalSpec>path:%String,logLevel:%Integer=2</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  $$$QuitOnError(##super(path, logLevel))

  if '$isobject(..Project) {
    set ..Project.Name = "null"
    throw ##class(%Exception.StatusException).CreateFromStatus($$$PERROR($$$ExportingProjectNotFound, ..Project.Name))
  }
  set ..Synchronizer = ##class(Synchronizer).%New($this)
  return $$$OK
]]></Implementation>
</Method>

<Method name="Export">
<Description>
Exports the project to the provided workspace.</Description>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[

  set ..IsBatch = 1
  do ..Reset()

  write ..LogLine($$$ExportingProject, 0, ..Project.Name)

  $$$QuitOnError(..ExportProjectItems())

  if ..AffectedCount > 0 {
    write ..LogLine($$$SourceExportedToPath, 0, ..BasePath)
    write ..LogLine($$$SynchronizingProject, 0, ..Project.Name)
    write ..LogLine($$$AllDone, 0)
  } else {
    write ..LogLine($$$NoItemsToExport, 0, ..Project.Name)
  }

  $$$QuitOnError(..Synchronizer.Purge())
  return $$$OK
]]></Implementation>
</Method>

<Method name="ExportProjectItems">
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set s = ##class(%SQL.Statement).%New()
  $$$QuitOnError(s.%PrepareClassQuery("%Studio.Project", "ProjectItemsList"))
  set r = s.%Execute(..Project.Name, 1)
  while r.%Next(.sc) {
    if $$$ISERR(sc) quit
    set itemName = r.%Get("Name")
    set itemType = r.%Get("Type")
    set sc = $$$ADDSC(sc, ..ExportItem(itemName, itemType))
  }
  return sc
]]></Implementation>
</Method>

<Method name="ExportItem">
<Description>
Exports a single item from the project to the workspace.</Description>
<FormalSpec>itemName:%String,type:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if ##class(Port.Util).IsRoutine(itemName) return ..ExportRoutine(itemName)

  set itemType = $case(type, "": ##class(Port.Util).GetItemType(itemName), : type)
  if itemType = "PKG" return ..ExportPackage(itemName)
  if itemType = "CLS" return ..ExportClass(itemName)

  return ..ExportPublicFile(itemName)
]]></Implementation>
</Method>

<Method name="ExportPackage">
<Description>
Exports a class package and all its classes added by the project.</Description>
<FormalSpec>packageName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set id = ##class(Port.Util).ResolveItemId(packageName_".PKG", ..Project.Name)
  // Cannot assume that the package is always present in the project,
  // even if the project has some classes from it.
  if '##class(%Studio.ProjectItem).%ExistsId(id) return $$$OK

  if $listfind(i%ExportedPackages, packageName) return $$$OK

  set classList = $System.OBJ.GetPackageList(.classList, packageName)
  set className = ""
  set sc = $$$OK
  for {
    set className = $order(classList(className))
    quit:className=""
    set err = ..ExportClass(className, 1)
    if $$$ISERR(err) {
      if $$$ISOK(sc) set sc = err
      else  set sc = $$$ADDSC(sc, err)
    }
  }
  set $list(i%ExportedPackages, *+1) = packageName
  return sc
]]></Implementation>
</Method>

<Method name="ExportPublicFile">
<Description>
Exports a CSP-like file to the workspace's public folder.
The CSP application name is mirrored into subfolders inside the public folder.</Description>
<FormalSpec>itemName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set id = ##class(Port.Util).ResolveItemId(itemName, ..Project.Name)

  if '##class(%Studio.ProjectItem).%ExistsId(id) {
    return $$$PERROR($$$UnableToExportInvalidItem, itemName)
  }  

  set workspace = ##class(Port.Configuration).GetWorkspace(..Project.Name)
  set extension = $piece(itemName, ".", *)

  try {
    set csp = ##class(%RoutineMgr).%New(itemName)
    set destination = ##class(Port.Util).ItemToPath(itemName, workspace)
    set destinationLocation = ##class(%File).GetDirectory(destination)

    write ..Log($$$ExportingType, 1, $$$FileType, destination)

    $$$ThrowOnError(##class(Port.Util).EnsurePathExists(destinationLocation))
    $$$ThrowOnError(..Synchronizer.AddToWhitelist(itemName))

    if ..Overwrite = 0 && '..IsOutdated(itemName, destination) {
      write ..LogLine($$$UpToDate)
      quit
    }
    
    set itt = ##class(Port.Configuration).GetInternalCharset(extension)
    set ett = ##class(Port.Configuration).GetExternalCharset(extension)
    
    set csp.Code.TranslateTable = itt
        
    set fs = ##class(%Stream.FileCharacter).%New()
   	set fs.TranslateTable = ett
   	
   	$$$ThrowOnError(fs.LinkToFile(destination))
   	$$$ThrowOnError(fs.CopyFrom(csp.Code))
   	$$$ThrowOnError(fs.%Save())

    write ..LogLine($$$Done)
    set ..AffectedCount = ..AffectedCount + 1
  } catch ex {
    set sc = ex.AsStatus()
    write ..LogLine($$$Failed, 1)
  }
  quit sc
]]></Implementation>
</Method>

<Method name="ExportRoutine">
<Description>
Export a routine to the workspace, the path inside the workspace is taken from the type of routine to be exported.</Description>
<FormalSpec>name:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK

  try {
    write ..Log($$$ExportingType, 1, $$$RoutineType, name)

    set id = ##class(Port.Util).ResolveItemId(name, ..Project.Name)

    if '##class(%Studio.ProjectItem).%ExistsId(id) {
      return $$$PERROR($$$UnableToExportInvalidItem, name)
    }

    set workspace = ##class(Port.Configuration).GetWorkspace(..Project.Name)
    set destination = ##class(Port.Util).ItemToPath(name, workspace)
    set destinationLocation = ##class(%File).GetDirectory(destination)
    set extension = $piece(name, ".", *)

    $$$ThrowOnError(..Synchronizer.AddToWhitelist(name))

    if '##class(%RoutineMgr).Exists(name) $$$ThrowStatus($$$PERROR($$$UnableToExportInvalidItem, name))
    $$$ThrowOnError(##class(Port.Util).EnsurePathExists(destinationLocation))

    if ..Overwrite = 0 && '..IsOutdated(name, destination) {
      write ..LogLine($$$UpToDate)
      quit
    }

    set file = ##class(%Stream.FileCharacter).%New()
    set file.TranslateTable = ##class(Port.Configuration).GetExternalCharset(extension)
    do file.LinkToFile(destination)

    set routine = ##class(%RoutineMgr).%OpenId(name)
    set sc = file.CopyFrom(routine.Code)

    $$$ThrowOnError(file.%Save())
    write ..LogLine($$$Done)

    set ..AffectedCount = ..AffectedCount + 1
  } catch ex {
    set sc = ex.AsStatus()
    write ..LogLine($$$Failed, 1)
  }

  quit sc
]]></Implementation>
</Method>

<Method name="ExportClass">
<Description>
Export a class to the workspace's 'cls' folder. Each class package is treated like a subfolder.</Description>
<FormalSpec>className:%String,fromPackage:%Boolean=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK

  set itemName = className

  // If the call is from the source control remove the suffix.
  if ##class(Port.Util).GetItemType(className) = "CLS" {
    set className = $piece(className, ".", 1, *-1)
  } else {
    // But we still must ensure that a qualified item name is available.
    set itemName = itemName_".CLS"
  }

  try {
    write ..Log($$$ExportingType, 1, $$$ClassType, className)

    // We can rely on the id if the call is delegated by ExportPackages, so we only check it if the class is exported single-handedly.
    if 'fromPackage && '##class(Port.Util).ExistsInProject(..Project.Name, itemName) {
      $$$ThrowStatus($$$PERROR($$$UnableToExportInvalidItem, itemName))
    }

    set workspace = ##class(Port.Configuration).GetWorkspace(..Project.Name)
    set package = $piece(itemName, ".", 1, *-1)
    set destination = ##class(Port.Util).ItemToPath(itemName, workspace)
    set destinationLocation = ##class(%File).GetDirectory(destination)

    $$$ThrowOnError(..Synchronizer.AddToWhitelist(itemName))
    if $listfind(..ExportedPackages, package) quit

    $$$ThrowOnError(##class(Port.Util).EnsurePathExists(destinationLocation))

    if ..Overwrite = 0 && '..IsOutdated(itemName, destination) {
      write ..LogLine($$$UpToDate)
      quit
    }

    if '##class(%ClassDefinition).%ExistsId(className) {
      $$$ThrowStatus($$$PERROR($$$UnableToExportInvalidItem, className))
    }

    $$$ThrowOnError(##class(%Compiler.UDL.TextServices).GetTextAsStream($namespace, itemName, .stream))

    set file = ##class(%Stream.FileCharacter).%New()
    set file.TranslateTable = ##class(Port.Configuration).GetExternalCharset("CLS")
    do file.LinkToFile(destination)

    $$$ThrowOnError(file.CopyFromAndSave(stream))
    write ..LogLine($$$Done, 1)

    set ..AffectedCount = ..AffectedCount + 1
    set isUsingXML = (##class(Port.Configuration).GetTestFormat() = "XML")
    
    if ##class(Port.UnitTest.Util).AssertTestableClass(className, .testableClass) && isUsingXML {
      set xmlExporter = ##class(Port.Project.XMLExporter).%New(..BasePath, ..LogLevel)
      do xmlExporter.ExportTest(testableClass, .sc)
      $$$ThrowOnError(sc)
    }
  } catch ex {
    set sc = ex.AsStatus()
    write ..LogLine($$$Failed, 1)
  }

  quit sc
]]></Implementation>
</Method>

<Method name="Reset">
<Internal>1</Internal>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set i%ExportedPackages = ""
  do ..Synchronizer.Reset()
]]></Implementation>
</Method>
</Class>


<Class name="Port.Project.Importer">
<IncludeCode>portutils,%sySystem</IncludeCode>
<Super>Port.Project.Base</Super>
<TimeCreated>64306,34528.722609</TimeCreated>

<Property name="IsNewProject">
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
<Private>1</Private>
</Property>

<Property name="Backup">
<Type>Port.Project.Backup</Type>
<Private>1</Private>
</Property>

<Property name="BackupDirectory">
<Type>%String</Type>
<Internal>1</Internal>
</Property>

<Property name="SkipBackup">
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="ImportList">
<Type>%String</Type>
<InitialExpression>0</InitialExpression>
<MultiDimensional>1</MultiDimensional>
</Property>

<Property name="ItemsList">
<Type>%String</Type>
<InitialExpression>0</InitialExpression>
<MultiDimensional>1</MultiDimensional>
<Private>1</Private>
</Property>

<Method name="%OnNew">
<FormalSpec>inputPath:%String,logLevel:%Integer=2,sourceExtension:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  $$$QuitOnError(##super(inputPath, logLevel))

  set ..BackupDirectory = $$$NFN(..BasePath_"/__backup__/")
  set ..Backup = ##class(Port.Project.Backup).%New(..BackupDirectory)
  set ..Backup.Logger = ..Logger

  set i%ImportList = 0
  set i%ItemsList = 0

  if '$isobject(..Project) {
    set ..IsNewProject = 1
    set ..Project = ##class(%Studio.Project).%New()
    set ..Project.Name = ..Project.Name
  }
  quit $$$OK
]]></Implementation>
</Method>

<Method name="EnqueueAll">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  do ..ResetLists()

  set sc = $$$OK
  for i = ..IncPath, ..IntPath, ..ClassPath, ..MacPath, ..BasPath, ..MviPath, ..MvbPath, ..DfiPath, ..PublicPath {
    set sc = ..EnqueueDirectory(i)
    if $$$ISERR(sc) quit
  }
  quit sc
]]></Implementation>
</Method>

<Method name="EnqueueItem">
<FormalSpec>origin:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  $$$QuitOnError(..DescribeItem(origin, .isOutdated, .itemName, .itemType, .group))
  
  // Skip this item because it's invalid.
  if group = -1 return $$$OK

  if '$data(i%ItemsList(itemName)) {
    if '..Backup.IsRequired && '..SkipBackup && ((itemType = "CSP") && isOutdated) {
      set ..Backup.IsRequired = 1
    }
    set i%ItemsList = $increment(i%ItemsList)
    set i%ItemsList(itemName) = ""

    if isOutdated || ..Overwrite {
      set i%ImportList = $increment(i%ImportList)
      set i%ImportList(group, itemType, itemName) = origin
    }
  }
  quit $$$OK
]]></Implementation>
</Method>

<Method name="EnqueueDirectory">
<FormalSpec>searchPath:%String,fs:%SQL.Statement=$$$NULLOREF</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[

  if '..IsBatch && '$isobject(fs) {
    do ..ResetLists()
  }

  if ..IsIgnored(searchPath) quit $$$OK

  if '$isobject(fs) {
    set fs = ##class(%SQL.Statement).%New()
    $$$QuitOnError(fs.%PrepareClassQuery("%File", "FileSet"))
  }

  set sc = $$$OK
  set rows = fs.%Execute(searchPath)

  set slash = $$$Slash(searchPath)

  while rows.%Next(.sc) {
    if $$$ISERR(sc) quit
    set compilable = 0
    set type = rows.%Get("Type")
    set external = rows.%Get("Name")
    if type = "F" {
      set sc = ..EnqueueItem(external)
      if $$$ISERR(sc) quit
    } elseif type = "D" {
      set targetDir = $piece(external, slash, *)
      if '(targetDir?1".".AN) {
        set sc = ..EnqueueDirectory(external, fs)
        if $$$ISERR(sc) quit
      }
    }
  }
  quit sc
]]></Implementation>
</Method>

<Method name="GetTypePriority">
<Internal>1</Internal>
<FormalSpec>type:%String</FormalSpec>
<Private>1</Private>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
  if type = "INC" quit 1
  if type = "INT" quit 2
  if type = "CLS" quit 3
  if type = "MAC" quit 4
  if type = "MVI" quit 5
  if type = "MVB" quit 6
  if type = "BAS" quit 7
  if type = "DFI" quit 8
  quit 9
]]></Implementation>
</Method>

<Method name="DescribeItem">
<Internal>1</Internal>
<FormalSpec>origin:%String,*isOutdated:%Boolean=0,*itemName:%String,*itemType:%String,*priority:%String</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
 
  set fileName = ##class(%File).GetFilename(origin)     
  set allowEmptyName = ##class(Port.Configuration).IsAllowEmptyFileNameEnabled() && ($piece(fileName, ".") = "")
  set pathType = ##class(Port.Util).GetPathType(origin)
  
  set isOutdated = 1
  set itemName = ##class(Port.Util).PathToItem(origin)
  set itemType = ##class(Port.Util).GetItemType(itemName)  
  set priority = ..GetTypePriority(itemType)
  
  if allowEmptyName || (pathType '= itemType && (pathType '= "PUBLIC")) {
    set itemName = ""
    set itemType = ""
    set priority = -1
    set isOutdated = 0
  } elseif '..Overwrite {
    set isOutdated = ..IsOutdated(itemName, origin, 1)
  }
  
  quit $$$OK
]]></Implementation>
</Method>

<Method name="ImportList">
<Internal>1</Internal>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK

  for i=1:1:10 {
   set sc = ..ImportType(i)
   if $$$ISERR(sc) {
    set typeSC = $$$PERROR($$$ErrorsWhileImportingType, $listget($$$ImportTypeDescriptions, i))
    set typeSC = $$$EMBEDSC(typeSC, sc)
    set sc = typeSC quit
   }
  }
  quit sc
]]></Implementation>
</Method>

<Method name="ImportType">
<Internal>1</Internal>
<FormalSpec>group:%Integer</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  if '$data(i%ImportList(group)) quit sc
  set itemType = $listget($$$ImportTypes, group, "CSP")

  write ..LogExclusiveLine($$$ImportingType, 1, $$$GetGroupTypeDescription(itemType))

  set itemName = ""
  for {
    quit:'$data(i%ImportList(group))
    set itemName = $order(i%ImportList(group, itemType, itemName), 1, modifiedFilePath)
    quit:itemName=""

    write ..LogExclusive($$$ImportingType, 2, $$$GetTypeDescription(itemType), itemName)

    set sc = ..ImportFromExternalSource(itemName, modifiedFilePath,  itemType)
    if $$$ISERR(sc)  write ..LogExclusiveLine($$$Failed, 2) quit
    else  write ..LogExclusiveLine($$$Done, 2)
  }
  quit sc
]]></Implementation>
</Method>

<Method name="ImportPartial">
<FormalSpec>target:%String,*importedList:%String=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
 
  set sc = $$$OK
    
  set resolvedTarget = ##class(Port.Util).ItemToPath(target, ..BasePath)

  if resolvedTarget '[ ..BasePath {
    quit $$$PERROR($$$AmbiguousPartialToWorkspace, resolvedTarget)
  }

  if '(resolvedTarget [ ..ClassPath || (resolvedTarget [ ..IncPath) ||
      (resolvedTarget [ ..IntPath)  || (resolvedTarget [ ..MacPath) ||
      (resolvedTarget [ ..PublicPath)
  ) {
    quit $$$PERROR($$$SupressedAttemptToExportFromOutside)
  }   

  if ##class(%File).DirectoryExists(resolvedTarget) {
    write ..Log($$$EnqueingType, 1, $$$DirectoryType)
    set sc = ..EnqueueDirectory(resolvedTarget)
  } elseif ##class(%File).Exists(resolvedTarget) {
    write ..Log($$$EnqueingType, 1, "item")
    set sc = ..EnqueueItem(resolvedTarget)
  } else {
    write ..Log($$$NothingToImport)
    quit sc
  }

  if sc {
    write ..LogLine($$$Done)
    set sc = ..Import()
    if $$$ISOK(sc) {
      set importedList = i%ImportList
      merge importedList = i%ImportList
    }
  } else {
    write ..LogLine($$$Failed)
  }
  quit sc
]]></Implementation>
</Method>

<Method name="Import">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set onlyPopulateProject = 0
  set ..AffectedCount = 0

  tstart

  try {
    if ..IsBatch {
      write ..LogLine($$$ImportingProject, 0, ..Project.Name)
      write ..LogLine($$$EnqueueingItems, 0)
      $$$ThrowOnError(..EnqueueAll())
    }

    if i%ImportList > 0 {
      write ..LogLine($$$TotalItemsToImport, 0, i%ImportList)
      merge list = i%ImportList
      if '..SkipBackup $$$ThrowOnError(..Backup.Create(.list))
      $$$ThrowOnError(..ImportList())
    } else {
      write ..LogLine($$$NoPendingItemsToImport, 0)
    }

    if ..IsNewProject {      
      write ..LogLine($$$NewProject, 0, ..Project.Name)
    }

    if i%ImportList > 0 {
      write ..LogLine($$$SynchronizingProject, 0, ..Project.Name)
      $$$ThrowOnError(..SynchronizeProject())
      write ..LogLine($$$ProjectSaved, 0, ..Project.Name, ..Project.Items.Count())
    }

    set ..AffectedCount = i%ImportList

    if ..Backup.IsRequired && '..SkipBackup {
      // If anything is ok until here, then delete the backup.
      write ..Log($$$RemovingBackupMirror, 0)
      set isRemoved = ##class(%File).RemoveDirectoryTree(..BackupDirectory)
      if isRemoved {
        write ..LogLine($$$Done, 0)
        set ..Backup.IsRequired = 0
      } else  {
        write ..LogLine($$$Failed, 0)
        $$$ThrowOnError($$$PERROR($$$UnableToRemoveDirectory, ..BackupDirectory))
      }
    }
    $$$ThrowOnError(..Project.%Save())
    tcommit
  } catch ex {
    set sc = ex.AsStatus()
    write !!, ..LogLine($$$FatalErrorAlert, 0)
    write $System.Status.GetErrorText(sc), !!

    write ..LogLine($$$FatalRollbackAlert, 0), !
    write ..LogLine($$$FatalProjectIntegrityRiskWarning, 0)
    write ..Log($$$FatalRollingBackTransaction, 0)

    trollback
    write ..LogLine($$$Done, 0)

    if ..Backup.IsRequired {
      write ..LogLine($$$FatalApplyingBackup, 0)
      set backupSC = ..Backup.Rollback()
      if $$$ISERR(backupSC) {
        write ..LogLine($$$FatalFailedToRestoreBackup, 0)
        set sc = $$$ADDSC(sc, backupSC)
      } else {
        do ##class(%File).RemoveDirectoryTree(..BackupDirectory)
      }
    }
  }
  quit sc
]]></Implementation>
</Method>

<Method name="ImportFromExternalSource">
<Final>1</Final>
<Internal>1</Internal>
<FormalSpec>itemName:%String,origin:%String,itemType:%String</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set extension = $$$ucase($piece(origin, ".", *))
  set itt = ##class(Port.Configuration).GetInternalCharset(extension)
  set ett = ##class(Port.Configuration).GetExternalCharset(extension)

  if (itemType = "CLS") {
    set fs = ##class(%Stream.FileCharacter).%New()
    set fs.TranslateTable = ett
    $$$QuitOnError(fs.LinkToFile(origin))
    $$$QuitOnError(##class(%Compiler.UDL.TextServices).SetTextFromStream($namespace, itemName, fs))
  } elseif ##class(Port.Util).IsRoutine(itemName) || (itemType = "CSP") {
    if itemName [ "/" set itemName = $$$LPadProvidedSlash(itemName, "/")         
    
    set localSource = ##class(%Stream.FileCharacter).%New()
    set localSource.TranslateTable = ett
    
    $$$QuitOnError(localSource.LinkToFile(origin))
    
    if itemType = "CSP" {
      if extension = "" set extension = "TXT"
      do ##class(%CSP.StreamServer).FileClassify(extension, .type, .bin)
      if $lf($lfs("CSP CSR JSON MD", " "), extension) set bin = 0
      
      set code = ##class(%CSP.Routine).%New()
      set code.TranslateTable = itt
      
      $$$QuitOnError(code.LinkToUrl(itemName))
      do code.Clear()
      
      set destination = code.Filename
      set path = ##class(%File).GetDirectory(destination)
      $$$QuitOnError(##class(Port.Util).EnsurePathExists(path))

      /// We can't use any translation table when importing a binary, so we do a bit-to-bit copy.
      if bin {
        set localSource = ""
        set code = ""
        $$$QuitOnError(##class(%File).CopyFile(origin, destination))
        quit $$$OK
      }
    } else {
      set routine = ##class(%RoutineMgr).%New(itemName)
      set code = routine.Code
      do code.Clear()
    }

    $$$QuitOnError(code.CopyFrom(localSource))
    $$$QuitOnError(code.%Save())
    set routine = ""
  }
  quit $$$OK
]]></Implementation>
</Method>

<Method name="SynchronizeProject">
<Internal>1</Internal>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set (sc, scc) = $$$OK
  set itemName = ""

  #dim item As %Studio.Project

  // We must check and remove all invalid items if the user desires to import everything
  // from the repository.
  if ..IsBatch $$$QuitOnError(..Project.Check())

  // Now that the project is clear, we add the new items.
  
  for {
    set itemName = $order(i%ItemsList(itemName), 1, type)    
    quit:itemName=""       
    
    set pSC = ..Project.AddItem(itemName)    

    if ($$$ISERR(pSC) && $$$GETERRORCODE(pSC)) = $$$ProjectIncludesPackage {
      set package = itemName
      for i=1:1:$length(package, ".") {
        set packagePart = $piece(package, 1, *-i)
        set exists = ##class(Port.Util).ExistsInProject(..Project.Name, packagePart_".PKG")
        if exists {
          set sc = $$$ADDSC(sc, ..Project.RemoveItem(package))
          set sc = $$$ADDSC(sc, ..Project.AddItem(itemName))
        }
      }
    }
  }
  set ssc = ..Project.%Save()
  set scc = $$$EMBEDSC(scc, sc)
  quit scc
]]></Implementation>
</Method>

<Method name="ResetLists">
<Implementation><![CDATA[

  kill i%ImportList, i%ItemsList
  set (i%ImportList, i%ItemsList) = 0
]]></Implementation>
</Method>
</Class>


<Class name="Port.Project.Manager">
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64306,34528.811674</TimeCreated>

<Method name="InstantiateTool">
<ClassMethod>1</ClassMethod>
<FormalSpec>type:%String,path:%String,logLevel:%String,*sc:%Status</FormalSpec>
<Private>1</Private>
<ReturnType>Port.Project.Base</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set utility = ""  
  set utilityTypes("E") = "Port.Project.Exporter"
  set utilityTypes("I") = "Port.Project.Importer"
  set utilityTypes("X") = "Port.Project.XMLExporter"
  try {
    set utility = $classmethod(utilityTypes(type), "%New", path, logLevel)
    quit
  } catch ex {
    set sc = ex.AsStatus()
  }
  return utility
]]></Implementation>
</Method>

<Method name="Export">
<ClassMethod>1</ClassMethod>
<FormalSpec>outputPath:%String,logLevel:%Integer=2,force:%Boolean=0,ignoredPaths:%ListOfDataTypes=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set exporter = ..InstantiateTool("E", outputPath, logLevel, .sc)
  $$$QuitOnError(sc)
  set exporter.Overwrite = force    
  $$$QuitOnError(exporter.Ignore(ignoredPaths))
  $$$QuitOnError(exporter.Export())
  set projectName = exporter.GetProjectName()
  if exporter.AffectedCount > 0 {
    $$$QuitOnError(##class(Port.SourceControl.Log).LogChange(projectName, projectName_".PRJ"))
  }
  return $$$OK
]]></Implementation>
</Method>

<Method name="ExportToXML">
<ClassMethod>1</ClassMethod>
<FormalSpec>outputPath:%String,logLevel:%Integer=2,justProject:%Boolean=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set exporter = ..InstantiateTool("X", outputPath, logLevel, .sc)
  $$$QuitOnError(sc)  
  return exporter.ExportToXML(justProject)
]]></Implementation>
</Method>

<Method name="Import">
<ClassMethod>1</ClassMethod>
<FormalSpec>inputPath:%String,logLevel:%Boolean=2,skipBackup:%Boolean=0,overwrite:%Boolean=0,ignoredPaths:%ListOfDataTypes=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set importer = ..InstantiateTool("I", inputPath, logLevel, .sc)
  $$$QuitOnError(sc)
  $$$QuitOnError(importer.Ignore(ignoredPaths))
  
  set importer.SkipBackup = skipBackup
  set importer.IsBatch = 1
  set importer.Overwrite = overwrite   
  set projectName = importer.GetProjectName()
  
  $$$QuitOnError(importer.Import())
  
  if importer.AffectedCount > 0 {
    $$$QuitOnError(##class(Port.SourceControl.Log).LogChange(projectName, projectName_".PRJ"))
  }
  return sc
]]></Implementation>
</Method>

<Method name="ImportPartial">
<ClassMethod>1</ClassMethod>
<FormalSpec>basePath:%String,target,logLevel:%Boolean=2,skipBackup:%Boolean=0,overwrite:%Boolean=0,ignoredPaths:%ListOfDataTypes=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set importer = ..InstantiateTool("I", basePath, logLevel, .sc)  
  $$$QuitOnError(sc)
  $$$QuitOnError(importer.Ignore(ignoredPaths))
  
  set importer.LogLevel = logLevel
  set importer.SkipBackup = skipBackup
  set importer.Overwrite = 1
     
  $$$QuitOnError(importer.ImportPartial(target, .importedList))
  
  do ..LogFromImportList(importer.GetProjectName(), .importedList)
  return $$$OK
]]></Implementation>
</Method>

<Method name="RemoveInvalidItems">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String=^||Port.Project</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set project = ##class(%Studio.Project).%OpenId(projectName)
  $$$QuitOnError(project.Check())
  $$$QuitOnError(project.%Save()) 
  return $$$OK
]]></Implementation>
</Method>

<Method name="RemoveItemsByType">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String,type:%String,*items:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set project = ##class(%Studio.Project).%OpenId(projectName)
  set s = ##class(%SQL.Statement).%New()
  $$$QuitOnError(s.%PrepareClassQuery("%Studio.Project", "ProjectItemsList"))
  set r = s.%Execute(projectName)
  
  while r.%Next() {
    set itemType = r.%Get("Type")
    set name = r.%Get("Name")
    if itemType = type {
      set items(name) = ""     
      set sc = project.RemoveItem(name, itemType)
      if $$$ISERR(sc) quit
    }
  }
  $$$QuitOnError(project.%Save())
  return sc
]]></Implementation>
</Method>

<Method name="ExportTestSuiteToXML">
<ClassMethod>1</ClassMethod>
<FormalSpec>outputPath:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set exporter = ..InstantiateTool("X", outputPath, 2, .sc)
  $$$QuitOnError(sc)
  return exporter.ExportTests()
]]></Implementation>
</Method>

<Method name="LogFromImportList">
<Final>1</Final>
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[projectName:%String,&importList:%String]]></FormalSpec>
<Private>1</Private>
<Implementation><![CDATA[
  if 'importList quit
  
  for i=1:1:10 {
    do LoopThroughType(projectName, importList, i)
  }  
  
LoopThroughType(projectName, importedList, group) 
  set itemName = ""
  quit:($order(importList(group)) = "")
  
  for {
    set itemName = $order(importList(group, $listget($$$ImportTypes, group), itemName))
    quit:itemName=""
      
    do ##class(Port.SourceControl.Log).LogChange(projectName, itemName)
  }
  return 1
]]></Implementation>
</Method>
</Class>


<Class name="Port.Project.Synchronizer">
<IncludeCode>portutils</IncludeCode>
<Super>%RegisteredObject</Super>
<TimeCreated>64471,51323.955849</TimeCreated>

<Property name="ExtraneousEntries">
<Type>%List</Type>
<Private>1</Private>
</Property>

<Property name="Whitelist">
<Type>%String</Type>
<Collection>array</Collection>
<Private>1</Private>
</Property>

<Property name="Tool">
<Type>Port.Project.Base</Type>
<Private>1</Private>
</Property>

<Property name="TypePaths">
<Type>%List</Type>
<Private>1</Private>
</Property>

<Method name="%OnNew">
<FormalSpec>tool:Port.Project.Base,simulated:%Boolean=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set ..Tool = tool
  do ..BuildTypePaths()
  return $$$OK
]]></Implementation>
</Method>

<Method name="BuildTypePaths">
<Implementation><![CDATA[  for i=1:1:$ll($$$PathTypes) set $list(i%TypePaths, *+1) = $$$NFN($$$FormatText("%1/%2", ..Tool.BasePath, $lg($$$PathTypes, i)))
]]></Implementation>
</Method>

<Method name="AddToWhitelist">
<Internal>1</Internal>
<FormalSpec>itemName:%String,sourceLocation:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[

  set sc = $$$OK
  set type = ##class(Port.Util).GetItemType(itemName)
  set typePath = ..Tool.GetTypePath(type)
  set slash = $$$Slash(typePath)

  if sourceLocation = "" {
    set workspacePath = $piece(typePath, slash, 1, *-1)
    set sourceLocation = ##class(Port.Util).ItemToPath(itemName, workspacePath)
  }

  set typePath = $$$LTrimProvidedSlash(typePath, "/")

  set absoluteBasePath = ##class(%File).NormalizeFilename(typePath, slash)
  set dirLength = $length(sourceLocation, slash)
  set dirLengthLimit = dirLength - (dirLength - $length(absoluteBasePath, slash))

  // Slices the path at every iteration. Ex: /a/b/c -> /a/b -> /a
  // We do this to create a dependency chain based on those directories.
  for i=dirLength:-1:dirLengthLimit+1 {
    set dir = $piece(sourceLocation, slash, 1, i)
    if ..Whitelist.IsDefined(dir) return $$$OK
    set sc = ..Whitelist.SetAt(itemName, dir)
    if $$$ISERR(sc) quit
  }
  return sc
]]></Implementation>
</Method>

<Method name="Purge">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[

  set sc = $$$OK
  set s = ##class(%SQL.Statement).%New()

  $$$QuitOnError(s.%PrepareClassQuery("%File", "FileSet"))

  set removedDirectories = ""
  set lastParent = ""
  set parentDirectory = ""

  write ..Tool.LogLine($$$CheckingExtraneousItems, 1)

  for i=1:1:$listlength(i%TypePaths) {
    set pathToSearch = $listget(i%TypePaths, i)
    set sc = ..Scan(s, pathToSearch)
    if $$$ISERR(sc) return sc
  }

  set length = $listlength(i%ExtraneousEntries)
  if length > 0 write ..Tool.LogLine($$$TotalExtraneousItems, 1, length)
  else  write ..Tool.LogLine($$$NoExtraneousItems, 1)

  for i=1:1:length {
    set path = $listget(i%ExtraneousEntries, i)
    do ..TreeDelete(s, path)
  }
  
  if length > 0 {
    write ..Tool.LogLine($$$TotalExtraneousItemsRemoved, 1, length)
  }
  
  return sc
]]></Implementation>
</Method>

<Method name="TreeDelete">
<FormalSpec>statement:%SQL.Statement,path:%String,hasContent:%Boolean=0</FormalSpec>
<Private>1</Private>
<Implementation><![CDATA[
  if path = ..Tool.BasePath return $$$OK 
  
  // There's a bug when using Exists for directories, it seems to assume that a directory is also a file.
  // To workaround this, DirectoryExists is also applied because it WILL return 0.
  if '##class(%File).DirectoryExists(path) && ##class(%File).Exists(path) { 
    write ..Tool.LogLine($$$RemovingFile, 2, path)
    do ##class(%File).Delete(path) 
  } elseif hasContent = 0 { 
    else  write ..Tool.LogLine($$$RemovingDirectory, 2, path)
    do ##class(%File).RemoveDirectory(path)
  }
    
  set path = $piece(path, $$$OSSlash, 1, *-1)
  set r = statement.%Execute(path)
  set hasContent = 0
    
  if r.%Next(.sc) {
    if $$$ISERR(sc) return sc
    set hasContent = 1
  }  
  return ..TreeDelete(statement, path, hasContent)
]]></Implementation>
</Method>

<Method name="Scan">
<FormalSpec>statement:%SQL.Statement,path:%String,filesCount:%Integer=0</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[

  set dir = $$$NFN(path)
  set dirType = ##class(Port.Util).GetPathType(path)
  // Need to convert from Port format to CSP legacy format.
  if dirType = "PUBLIC" set dirType = "CSP"

  set slash = $$$Slash(path)
  set row = statement.%Execute(dir)
  set sc = $$$OK

  while row.%Next(.sc) {
    if $$$ISERR(sc) quit
    set type = row.%Get("Type")
    set fullPath = row.%Get("Name")

    if ..Tool.IsIgnored(fullPath) continue

    if type = "D" {
      set filesCount = 0
      set sc = ..Scan(statement, fullPath, .filesCount)
      if $$$ISERR(sc) return sc
      continue
    } else {
      set filesCount =  filesCount + 1
    }

    if 'filesCount && $lf($$$ImportTypes, dirType) || ($lf($$$ImportTypes, dirType) && '..Whitelist.IsDefined(fullPath) && '$listfind(i%ExtraneousEntries, fullPath)) {      
      set $list(i%ExtraneousEntries, $listlength(i%ExtraneousEntries)+1) = fullPath
      
      // Handle test files created for classes.      
      if dirType = "CLS" {
        set className = $replace(##class(Port.Util).PathToItem(fullPath_".cls"), ".cls", "")        
        
        // Attempt to find the equivalent test class.
        if ##class(Port.UnitTest.Util).AssertTestableClass(className, .testableClass) {
          set fullPath = ##class(Port.UnitTest.Util).GetTestClassPath(testableClass, ..Tool.BasePath)
          // Only mark to remove if the test suite was exported as XML, regardless of what type of test format has been selected.                    
           set $list(i%ExtraneousEntries, $listlength(i%ExtraneousEntries)+1) = fullPath
        }
      }
    }
  }
  return sc
]]></Implementation>
</Method>

<Method name="Reset">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set i%ExtraneousEntries = ""
  return ..Whitelist.Clear()
]]></Implementation>
</Method>
</Class>


<Class name="Port.Project.XMLExporter">
<Super>Port.Project.Base</Super>
<TimeCreated>64306,34528.900364</TimeCreated>

<Method name="ExportToXML">
<FormalSpec>justProject:%Boolean=0,qspec:%String="/diffexport=1/nodisplay",charset:%String="UTF8",*errorlog:%Status=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set developmentXML = ##class(%File).NormalizeFilename(..BasePath_"/"_..Project.Name_".xml")
  set productionXML = ##class(%File).NormalizeFilename(..BasePath_"/"_..Project.Name_"-prod.xml")
  write ..LogLine($$$ExportingXML, 0, ..Project.Name)
  $$$QuitOnError(..Project.Export(developmentXML, qspec, justProject, errorlog, charset))
  write ..LogLine($$$XMLExportedTo, 0, ..Project.Name, developmentXML)  
  
  do SanitizePackages(.items)  
  
  if $order(items("")) '= "" {  
    $$$QuitOnError($System.OBJ.Export(.items, productionXML, qspec, errorlog, charset))
    write ..LogLine($$$XMLExportedTo, 0, ..Project.Name, productionXML)
  }
    
  quit $$$OK    
  
SanitizePackages(items="")
  set sc = $$$OK 
  set testPrefix = ##class(Port.Configuration).GetTestClassPrefix()
  
  set s = ##class(%SQL.Statement).%New()
  do s.%PrepareClassQuery("%Studio.Project", "ProjectItemsList")
  
  set r = s.%Execute(..Project.Name)
  while r.%Next() {
    set itemName = r.%Get("Name")
    set itemType = r.%Get("Type")
    if itemType '= "CLS" || (itemType = "CLS" && '($extract(itemName, 1, $length(testPrefix)) = testPrefix)) {
      set name = itemName
      set type = itemType
      do ##class(%Studio.Project).NormalizeName(.name, .type)             
      if type = "CLS" || (type = "PKG") set name = name_"."_type
      set items(name) = ""
    }    
  }
  quit
]]></Implementation>
</Method>

<Method name="ExportTests">
<FormalSpec><![CDATA[qspec:%String="/diffexport=1/nodisplay",&tests:%String="",&errors=""]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set exported = 0
  
  // We don't actually export any XML if UDL is enabled.
  set isUsingUDL = (##class(Port.Configuration).GetTestFormat() = "UDL")   
  if isUsingUDL return $$$OK  
  
  set s = ##class(%SQL.Statement).%New()
  $$$QuitOnError(s.%PrepareClassQuery("%Studio.Project", "ProjectItemsList"))
  set r = s.%Execute(..Project.Name)
  while r.%Next(.sc) {
    if $$$ISERR(sc) quit
    set type = r.%Get("Type")
    if type = "CLS" {     
      set class = r.%Get("Name")      
      if 'exported set exported = ..ExportTest(class, .esc, qspec)
      else  do ..ExportTest(class, .esc)          
      set sc = $$$ADDSC(sc, esc)
    }
  } 
  if 'exported {
    set sc = $$$PERROR($$$NoTestSuitesWereFound)
  }
  quit sc
]]></Implementation>
</Method>

<Method name="ExportTest">
<FormalSpec>className:%String,sc:%Status=$$$OK,qspec="/diffexport=1/nodisplay"</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
  set sc = $$$OK
  set exported  = 0
  
  if '##class(Port.UnitTest.Util).IsUnitTestClass(className) quit exported  
  
  set classPath = ##class(Port.UnitTest.Util).GetTestClassPath(className, ..BasePath)
  
  if classPath '= "" {
    write ..Log($$$ExportingTestClassToXML, 0, $replace(className, ".CLS", ""))
    set cSC = $System.OBJ.Export(className_".CLS", classPath,qspec)
    set sc = $$$ADDSC(sc, cSC)
    if $$$ISOK(cSC) write ..LogLine($$$Done, 0)
    else  write ..LogLine($$$Failed, 0)
    set exported = 1
  }
  quit exported
]]></Implementation>
</Method>
</Class>


<Class name="Port.SourceControl.ExtendedHooks">
<Abstract>1</Abstract>
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64496,37005.318621</TimeCreated>

<Method name="Call">
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec>sourceControl:%Studio.Extension.Base,hookName:%String="",parameters...:%String</FormalSpec>
<ProcedureBlock>0</ProcedureBlock>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  new sc, content, implementer, alreadyRedirected, 
      isNewLineTerminator, currentMnemonic, 
      childSC, expectingContent, firstLine, s
  
  set sc = $$$OK
  set s = ""
  set childSC = $$$OK
  set implementer = ##class(Port.Configuration).GetExtendedHooksImplementer() 
  set alreadyRedirected = ##class(%Device).ReDirectIO()
  set expectingContent = 0
  set firstLine = ""
  
  if '##class(%Dictionary.CompiledMethod).%ExistsId(implementer_"||"_hookName) return sc 
  set content = ##class(%Stream.GlobalBinary).%New() 
  
  if implementer '= "" { 
    write !, "[Port] "_$$$FormatMsg("Port Log Messages", $$$RunningCustomHook, hookName, implementer)
    
    try {
      set currentMnemonic = "^"_##class(%Device).GetMnemonicRoutine()
      use $io::("^"_$zname)
      do ##class(%Device).ReDirectIO(1)
      set sc = $classmethod(implementer, hookName, sourceControl, parameters...)
    } catch ex {
      set content = "" 
      set sc = ex.AsStatus() 
    }
  }
  
  if alreadyRedirected { 
    do ##class(%Device).ReDirectIO(1) 
    use $io::(currentMnemonic) 
  }
  
  if $isobject(content) {  
    do content.OutputToDevice()    
  }
  
  write !       
  
  if $$$ISOK(sc) {    
    write "[Port] "_$$$FormatMsg("Port Log Messages", $$$HookReturnedOK, hookName)
  } else {
    set errorText = $System.Status.GetOneStatusText(sc)
    write "[Port] "_$$$FormatMsg("Port Log Messages", $$$HookReturnedError, hookName, errorText)
    set childSC = sc
    set sc = $$$PERROR($$$FailedWhileRunningExtendedHook, hookName)    
    set sc = $$$EMBEDSC(sc, childSC)  
  }
  write !   
  return sc 
  
rchr(c)      
  quit
rstr(sz,to)  
  quit
wchr(s)      
  do output($char(s))  
  quit 
wff()        
  do output($char(12))  
  quit
wnl()
  if firstLine = 0 set firstLine = 1
  else  set firstLine = -1
  do output($char(13,10))
  quit
wstr(s)
  do output(s) 
  quit
wtab(s)      
  do output($char(9)) 
  quit
output(s)
  // Skips writing the first !, we leave it to our write.
  if firstLine = 1 quit
  // Remaining writes ! are always a standalone buffer so we can check it's equality.
  if s = $c(13,10) {
    // However we can only write if the the next buffer has indeed some content.
    // So we defer it to the next call where we can actually assert it.    
    set expectingContent = 1
    // This catches writes with embedded CRLF (like the compiler ones).    
  } elseif $extract(s, 1, 2) = $c(13,10) {
    set expectingContent = 1
    do output($replace(s, $c(13,10), ""))
    set expectingContent = 0 
    quit
  } elseif $length(s) > 0 {
    // After deferring it, we can finally write a CRLF and the content, as long as it's not empty.
    if expectingContent = 1 { 
      set expectingContent = 0      
      do content.WriteLine("")
      do content.Write($$$FormatText("[Port] %1: ", hookName)) 
    }
    // Writes without ! must be written on the same line.     
    do content.Write(s)
  }
   
  quit
]]></Implementation>
</Method>
</Class>


<Class name="Port.SourceControl.Hooks">
<IncludeCode>portutils</IncludeCode>
<Super>%Studio.SourceControl.Base</Super>
<TimeCreated>64306,34529.285329</TimeCreated>

<XData name="Menu">
<Data><![CDATA[
<MenuBase>
<Menu Name="%SourceMenu" Type="0"> 
<MenuItem Name="%MLExport"/>
<MenuItem Name="%MLExportToXML"/>
<MenuItem Name="%MLExportTests"/> 
<MenuItem Separator="1" />
<MenuItem Name="%MLRemoveClasses"/>
<MenuItem Name="%MLRemoveFiles"/>
<MenuItem Name="%MLRemoveRoutines"/>
<MenuItem Separator="1" />
<MenuItem Name="%MLScanAndFix"/>
<MenuItem Separator="1" />
<MenuItem Name="%MLRunTests"/> 
<MenuItem Separator="1" />
<MenuItem Name="%MLImport"/>
<MenuItem Separator="1" />
<MenuItem Name="%MLForceExport"/>
<MenuItem Name="%MLForceImport"/>
</Menu>
<Menu Name="%SourceContext" Type="1">
<MenuItem Name="%CMLExportActive" />
<MenuItem Name="%CMLImportActive" />
<MenuItem Separator="1" />
<MenuItem Name="%CMLRunActiveTest"/>
</Menu>
</MenuBase>
]]></Data>
</XData>

<Method name="OnAfterSave">
<FormalSpec>InternalName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  #dim exporter As Port.Project.Exporter
  if $get(%importingFromXML, 0) quit $$$OK 
  
  set sc = $$$OK
  set projectName = $get(^||Port.Project)
  if projectName [ "Default" || (projectName = "") quit sc  
  
  if projectName '= "" { 
    set exportPath = ##class(Port.Configuration).GetWorkspace()    
    set type = ##class(Port.Util).GetItemType(InternalName)
    
    if '##class(%File).DirectoryExists($$$NFN(exportPath)) {
      set logLevel = ##class(Port.Configuration).GetLogLevel()
           
      write "[Port] "_$$$FormatMsg("Port Log Messages", $$$NewWorkspaceDetected, projectName), !
     
      $$$QuitOnError(##class(Port.Project.Manager).Export(exportPath, logLevel, 1))
      // Called with do, because we don't want to display errors from it.
      do ##class(Port.Project.Manager).ExportTestSuiteToXML(exportPath) 
      
      quit $$$OK
    }
    
    if type '= "PRJ" {
      set exporter = ##class(Port.Project.Exporter).%New(exportPath, 2)
      set shouldExportAsXML = ##class(Port.Configuration).IsAutoExportXMLEnabled()      
      set conflicts = ##class(Port.Util).ListConflicts(projectName, InternalName)
      
      if '##class(Port.Util).ExistsInProject(projectName, InternalName) {
        quit $$$OK
      }
      
      if conflicts '= "" {
        write !, "[Port] "_$$$FormatMsg("Port Log Messages", $$$ConflictingItemDetected, InternalName, $lfs(conflicts))
        write !, "[Port] "_$$$FormatMsg("Port Log Messages", $$$ConflictingItemDetected2)
      }
      
      if type = "CLS" {
        set sc = exporter.ExportClass(InternalName)
        if ##class(Port.UnitTest.Util).AssertTestableClass(InternalName, .testableClass) {          
          set testPath = ##class(Port.Configuration).GetTestPath()
          set xmlExporter = ##class(Port.Project.XMLExporter).%New(exportPath, 2)
          do xmlExporter.ExportTest($$$NFN(exportPath_"/"_testPath), testableClass, .ssc)          
          set sc = $$$ADDSC(sc, ssc)
        }
      } elseif ##class(Port.Util).IsRoutine(InternalName) {
        set sc = exporter.ExportRoutine(InternalName)
      } elseif type = "PKG" {     
        set sc = exporter.ExportPackage(InternalName)     
      } elseif type '= "" {
        set sc = exporter.ExportPublicFile(InternalName) 
      }   
      
      $$$QuitOnError(##class(Log).LogChange(projectName, InternalName))
      if shouldExportAsXML $$$QuitOnError(##class(Port.Project.Manager).ExportToXML(exportPath, 2))      
    }  
  }
  if '##class(Port.Configuration).HasCustomWorkspace(projectName) {
    do ##class(Port.Configuration).SetCustomWorkspace(projectName)
  }
  $$$QuitOnError(##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterSave", InternalName)) 
  quit sc
]]></Implementation>
</Method>

<Method name="OnBeforeSave">
<FormalSpec>InternalName:%String,Location:%String="",Object:%RegisteredObject=$$$NULLOREF</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if $get(%importingFromXML, 0) quit $$$OK
  set projectName = $get(^||Port.Project)  
  set ext = ##class(Port.Util).GetItemType(InternalName)
  set isProject = (ext = "PRJ")  
  
  if isProject {
    set projectName = $replace(InternalName, ".PRJ", "")
    set ^||Port.Project = projectName  
    if projectName [ "Default" {
      write "[Port] "_$$$FormatMsg("Port Log Messages", $$$CannotUseDefault), !
      write "[Port] "_$$$FormatMsg("Port Log Messages", $$$CannotUseDefault2), !
      quit $$$ERROR($$$CanNotExportDefaultProject, projectName)
    }
  } else {
    set projectsOwningItem = $lts(##class(Port.Util).ListConflicts(projectName, InternalName), $char(10))
    if projectsOwningItem '= "" {
      quit $$$PERROR($$$CannotSaveConflictingItems, InternalName, $char(10, 10)_projectsOwningItem, projectName)
    }
  }    

  $$$QuitOnError(##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeSave", InternalName, Location, Object))
  quit $$$OK
]]></Implementation>
</Method>

<Method name="UserAction">
<FormalSpec><![CDATA[Type:%Integer,Name:%String,InternalName:%String,SelectedText:%String,&Action:%String,&Target:%String,&Msg:%String,&Reload:%Boolean]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  
  set name = $piece(Name, ",", 2)
  set isContextual = ($piece(Name, ",", 1) = "%SourceContext")
  // We must know if the user is importing from a XML and prevent it from realizing certain tasks automatically.
  set %importingFromXML = (Name = 6)
  
  if $data(^||Port.Project) { 
    set projectName = ^||Port.Project
    if projectName [ "Default" quit $$$OK
    set projectPath = ##class(Port.Configuration).GetWorkspace()
    set testPath = ##class(Port.Configuration).GetTestPath()
    set logLevel = ##class(Port.Configuration).GetLogLevel()
    set shouldExportAsXML = ##class(Port.Configuration).IsAutoExportXMLEnabled()
    set ignoredPaths = ##class(Port.Util).GetIgnoredPaths(projectName)
    
    if name = "%MLExport" {   
      $$$QuitOnError(##class(Port.Project.Manager).Export(projectPath, logLevel, 0, ignoredPaths))
      if shouldExportAsXML $$$QuitOnError(##class(Port.Project.Manager).ExportToXML(projectPath))      
      quit $$$OK
    }
    if name = "%MLExportToXML" {
      quit ##class(Port.Project.Manager).ExportToXML(projectPath)
    }
    if name = "%MLExportTests" {
      quit ##class(Port.Project.Manager).ExportTestSuiteToXML(projectPath)
    }
    if name = "%MLRunTests" && (projectPath '= "") {
      set loadType = "/load"_$$$ucase(##class(Port.Configuration).GetTestFormat())
      $$$QuitOnError(##class(Port.UnitTest.Manager).RunTest(testPath, "/recursive/run/noload/nodelete"_loadType))
    }       
    if name = "%MLImport" {
      $$$QuitOnError(##class(Port.Project.Manager).Import(projectPath, logLevel, 0, 0))
    }
    if name = "%MLRemoveClasses" {
      $$$QuitOnError(##class(Port.Project.Manager).RemoveItemsByType(projectName, "CLS"))
      quit ##class(Log).Synchronize()
    }
    if name = "%MLRemoveFiles" {
      $$$QuitOnError(##class(Port.Project.Manager).RemoveItemsByType(projectName, "CSP"))
      quit ##class(Log).Synchronize()
    }
    if name = "%MLRemoveRoutines" {
      $$$QuitOnError(##class(Port.Project.Manager).RemoveItemsByType(projectName, "MAC"))
      quit ##class(Log).Synchronize()
    }
    if name = "%MLScanAndFix" {
      $$$QuitOnError(##class(Port.Project.Manager).RemoveInvalidItems(projectName))
      quit ##class(Log).Synchronize()     
    }
    
    if name = "%CMLExportActive" {
      if $$$ucase(InternalName) '= ($$$ucase(projectName_".PRJ")) {
        set exporter = ##class(Port.Project.Exporter).%New(projectPath)
        set exporter.Overwrite = 1
        set internalName = InternalName
        if $extract(InternalName, 1) = "/" {
          set internalName = $extract(InternalName, 2, *)
        }
        $$$QuitOnError(exporter.ExportItem(internalName))
        $$$QuitOnError(##class(Log).LogChange(projectName, internalName))
        if shouldExportAsXML $$$QuitOnError(##class(Port.Project.Manager).ExportToXML(projectPath))
      } else {
        set ignoredPaths = ##class(Port.Util).GetIgnoredPaths(projectPath)
        quit ##class(Port.Project.Manager).Export(projectPath, logLevel, 1)
      }
    }
    
    if name = "%CMLImportActive" {
      if $$$ucase(InternalName) = ($$$ucase(projectName_".PRJ")) {
        quit ##class(Port.Project.Manager).Import(projectPath, logLevel, 0, 1, ignoredPaths)
      } else {
        quit ##class(Port.Project.Manager).ImportPartial(projectPath, InternalName, logLevel,,,ignoredPaths)
      }
    }
    
    if name = "%CMLRunActiveTest" {
      set testable = ##class(Port.UnitTest.Util).AssertTestableClass(InternalName, .testableClass)
      if testable {
        $$$QuitOnError(##class(Port.UnitTest.Manager).RunTest(##class(Port.UnitTest.Util).GetClassTestSpec(testableClass), "/norecursive/run/noload/nodelete"))
      }
    }
    
    if name = "%MLForceExport" {
      $$$QuitOnError(##class(Port.Project.Manager).Export(projectPath, logLevel, 1, ignoredPaths))
      if shouldExportAsXML $$$QuitOnError(##class(Port.Project.Manager).ExportToXML(projectPath))
      if '##class(Port.Configuration).HasCustomWorkspace(projectName) { 
        do ##class(Port.Configuration).SetCustomWorkspace(projectName)
      }
    }
    
    if name = "%MLForceImport" {
      quit ##class(Port.Project.Manager).Import(projectPath, logLevel, 0, 1, ignoredPaths)
    }    
  }
  $$$QuitOnError(##class(Port.SourceControl.ExtendedHooks).Call($this, "UserAction",  Type, Name, InternalName, SelectedText, .Action, .Target, .Msg, .Reload))
  quit $$$OK
]]></Implementation>
</Method>

<Method name="AfterUserAction">
<FormalSpec><![CDATA[Type:%Integer,Name:%String,InternalName:%String,Answer:%Integer,Msg:%String="",&Reload:%Boolean]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "AfterUserAction", Type, Name, InternalName, Answer, .Msg, .Reload)
]]></Implementation>
</Method>

<Method name="OnMenuItem">
<FormalSpec><![CDATA[MenuName:%String,InternalName:%String,SelectedText:%String,&Enabled:%Boolean,&DisplayName:%String]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  
  set menu=$piece(MenuName,","),name=$piece(MenuName,",",2)
  If menu'="%SourceMenu",menu'="%SourceContext" Quit $$$OK
  set isContextual = (menu = "%SourceContext")
  set domain = "Port Menu Labels"
  
  if 'isContextual {
    set code = $case(name, 
      "%MLExport": $$$MLExport,
      "%MLExportToXML": $$$MLExportToXML,
      "%MLExportTests": $$$MLExportTests,
      "%MLRemoveClasses": $$$MLRemoveClasses,
      "%MLRemoveFiles": $$$MLRemoveFiles,
      "%MLRemoveRoutines": $$$MLRemoveRoutines,
      "%MLScanAndFix": $$$MLScanAndFix,
      "%MLRunTests": $$$MLRunTests,
      "%MLImport": $$$MLImport,
      "%MLForceExport": $$$MLForceExport, 
      "%MLForceImport": $$$MLForceImport,
      : ""
     )
  } else {
    set domain = "Port Context Menu Labels"
    set code = $case(name, 
      "%CMLExportActive": $$$CMLExportActive,
      "%CMLImportActive": $$$CMLImportActive,
      "%CMLRunActiveTest": $$$CMLRunActiveTest,
      : ""
    )          
  }
  
  if code '= "" {
    // We can only change the text if we find it, otherwise we leave the Studio decide what to show.
    set DisplayName = $$$FormatMsg(domain, code)
  }
  
  if name = "%CMLRunActiveTest" {
    set Enabled = 
      ##class(Port.Util).ExistsInProject(^||Port.Project, InternalName) &&
      ##class(Port.UnitTest.Util).AssertTestableClass(InternalName)
  }
  
  if name = "%MLExportTests" {
    set Enabled = (##class(Port.Configuration).GetTestFormat() = "XML")
  } 
  
  set isProjectOpened = ($get(^||Port.Project, "Default") '[ "Default")
  if 'isProjectOpened {
    set Enabled = 0
  }
  Quit $$$OK
]]></Implementation>
</Method>

<Method name="OnAfterCompile">
<Description>
Called after the compile of the item is done.</Description>
<FormalSpec>InternalName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if $get(%importingFromXML, 0) quit $$$OK
  set projectName = $get(^||Port.Project)
  set sc = $$$OK
  
  if projectName '= "" && (projectName '[ "Default") {
    set projectPath = ##class(Port.Configuration).GetWorkspace()
    set type = ##class(Port.Util).GetItemType(InternalName)
    set xmlExporter = ##class(Port.Project.XMLExporter).%New(projectPath)
    
    if type = "CLS" {     
      set testPath = ##class(Port.Configuration).GetTestPath()      
      set shouldRunTest = (
        ##class(Port.Configuration).IsTestOnDemandEnabled() &&
        ##class(Port.UnitTest.Util).AssertTestableClass(InternalName, .testableClass) &&
        ##class(%File).DirectoryExists(projectPath_"/"_testPath)        
      )
      if shouldRunTest {
       $$$QuitOnError(xmlExporter.ExportTest(testableClass))
       $$$QuitOnError(##class(Port.UnitTest.Manager).RunTest(##class(Port.UnitTest.Util).GetClassTestSpec(testableClass), "/norecursive/run/noload/nodelete"))
      } 
    }
  }
  $$$QuitOnError(##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterCompile",  InternalName))
  quit $$$OK
]]></Implementation>
</Method>

<Method name="OnBeforeDelete">
<FormalSpec>InternalName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  // This is used to prevent orphan workspace entries.
  if (InternalName?1".PRJ") {
    set projectName = $piece(InternalName, ".", 1, *-1)
    do ##class(Port.Configuration).RemoveCustomWorkspace(projectName)
  }
  $$$QuitOnError(##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeDelete",  InternalName))
  quit $$$OK
]]></Implementation>
</Method>

<Method name="OnBeforeLoad">
<FormalSpec>InternalName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set isProject = (##class(Port.Util).GetItemType(InternalName) = "PRJ")
  
  // Port normally uses its own project global to track the opened project and stop %Studio.Project methods from disrupting the source control instance.
  if isProject {
    set ^||Port.Project = $piece(InternalName, ".", 1, *-1)  
  } elseif '$data(^||Port.Project) {
    set ^||Port.Project = $get(^||%Studio.Project)
  }
   
  set projectName = ^||Port.Project
      
  if projectName '= "" && (projectName [ "Default") {
    write "[Port] "_$$$FormatMsg("Port Log Messages", $$$CannotUseDefault), !
    write "[Port] "_$$$FormatMsg("Port Log Messages", $$$CannotUseDefault2), !
  }  
  
  set conflicts = ##class(Port.Util).ListConflicts(projectName, InternalName)
  if conflicts '= "" {
    write !, "[Port] "_$$$FormatMsg("Port Log Messages", $$$ConflictingItemDetected, InternalName, $lts(conflicts, ", "))
    write !, "[Port] "_$$$FormatMsg("Port Log Messages", $$$ConflictingItemDetected2), !
  }
  $$$QuitOnError(##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeLoad",  InternalName))
  quit $$$OK
]]></Implementation>
</Method>

<Method name="OnAfterAllClassCompile">
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[List:%String,Level:%Integer,&qstruct:%String,Status:%Status]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  $$$QuitOnError(##super(.List, .Level, .qstruct, .Status))
  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterAllClassCompile", .List, Level, .qstruct, Status)
]]></Implementation>
</Method>

<Method name="OnAfterClassCompile">
<FormalSpec><![CDATA[List:%String,Level:%Integer,&qstruct:%String,Status:%Status]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterClassCompile", .List, Level, qstruct, Status)
]]></Implementation>
</Method>

<Method name="OnAfterDelete">
<Description>
Called after an item is deleted.</Description>
<FormalSpec>InternalName:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterDelete", InternalName)
]]></Implementation>
</Method>

<Method name="OnAfterLoad">
<FormalSpec>InternalName:%String,Object:%RegisteredObject=$$$NULLOREF</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterLoad", InternalName)
]]></Implementation>
</Method>

<Method name="OnAfterStorage">
<FormalSpec>InternalName:%String,Location:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnAfterStorage", InternalName, Location)
]]></Implementation>
</Method>

<Method name="OnBeforeAllClassCompile">
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[List:%String,Level:%Integer,&qstruct:%String]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  $$$QuitOnError(##super(.List, Level, .qstruct))
  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeAllClassCompile", .List, Level, qstruct)
]]></Implementation>
</Method>

<Method name="OnBeforeClassCompile">
<FormalSpec><![CDATA[List:%String,Level:%Integer,&qstruct:%String]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeClassCompile", .List, Level, qstruct)
]]></Implementation>
</Method>

<Method name="OnBeforeCompile">
<FormalSpec><![CDATA[InternalName:%String,&qstruct:%String]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeCompile", InternalName, qstruct)
]]></Implementation>
</Method>

<Method name="OnBeforeTimestamp">
<FormalSpec>InternalName:%String</FormalSpec>
<Implementation><![CDATA[  quit ##class(Port.SourceControl.ExtendedHooks).Call($this, "OnBeforeTimestamp", InternalName)
]]></Implementation>
</Method>
</Class>


<Class name="Port.SourceControl.Log">
<Abstract>1</Abstract>
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64306,34529.444198</TimeCreated>

<Method name="LogChange">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName=^||Port.Project,itemName:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  do ..ExtractItemDescription(itemName, .name, .type)
  set ^Port.SourceControl.Projects(projectName, type, name) = $zdatetime($horolog, 3,,,,,,,,,0) 
  return $$$OK
]]></Implementation>
</Method>

<Method name="ExtractItemDescription">
<ClassMethod>1</ClassMethod>
<FormalSpec>itemName,*name="",*type=""</FormalSpec>
<Private>1</Private>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  
  set type = $$$ucase($piece(itemName, ".", *))
  set name = $piece(itemName, ".", 1, *-1)
  if '$listfind($$$ImportTypes, type) && (type '= "PRJ") {
    set name = itemName
    set type = "CSP"
  }
]]></Implementation>
</Method>

<Method name="GetLastChange">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String,itemName:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  do ..ExtractItemDescription(itemName, .name, .type)
  return $get(^Port.SourceControl.Projects(projectName, type, name), 0)
]]></Implementation>
</Method>

<Method name="Synchronize">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  #define ProjectExists(%id) ##class(%Studio.Project).%ExistsId(%id)
  #define ItemExists(%id) ##class(%Studio.ProjectItem).%ExistsId(%id)
  
  set sc = $$$OK
  if '$data(^Port.SourceControl.Projects) return sc
  
  set global = "^Port.SourceControl.Projects"
  set q = $query(@global@(""))
  for {
    quit:q=""
    
    set projectName = $qsubscript(q, 1)
    set type = $qsubscript(q, 2)
    set itemName = $qsubscript(q, 3)
    
    if type '= "CLS" && (type '= "PRJ") set itemName = itemName_"."_type
    if type = "CSP" set itemName = $extract(itemName, 2, *)
    set itemId = projectName_"||"_itemName_"||"_type
    if '$$$ProjectExists(projectName) || '$$$ItemExists(itemId) {
      kill @q
    }
    set q = $query(@q, 1)
  }
  return $$$OK
]]></Implementation>
</Method>

<Method name="Flush">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  kill ^Port.SourceControl.Projects
  return $$$OK
]]></Implementation>
</Method>
</Class>


<Class name="Port.SourceControl.LogCleaner">
<Super>%SYS.Task.Definition</Super>
<TimeCreated>64306,34529.529651</TimeCreated>

<Method name="StartTask">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set taskName = "Port Log Synchronizer for "_$namespace
  if ##class(%SYS.Task).FindId(taskName) return $$$OK    
  set task = ##class(%SYS.Task).%New()
  set task.TimePeriod = 0
  set task.Description = "Keeps the log synchronized with existing projects and files."
  set task.Name = taskName
  set task.TimePeriodEvery = 1
  set task.DailyFrequency = 1
  set task.DailyFrequencyTime = 0
  set task.DailyStartTime = 28800
  set task.DailyIncrement = 180
  set task.NameSpace = $namespace
  set task.TaskClass = $classname($this)
  return task.%Save()
]]></Implementation>
</Method>

<Method name="RemoveTask">
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  #dim task as %SYS.Task
  
  set name = "Port Log Synchronizer for "_$namespace
  set taskId = ##class(%SYS.Task).FindId(name)
  
  if taskId = "" return $$$OK
  $$$QuitOnError(##class(%SYS.Task).Suspend(taskId, 2))
  $$$QuitOnError(##class(%SYS.Task).%DeleteId(taskId))
  return $$$OK
]]></Implementation>
</Method>

<Method name="OnTask">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[  return ##class(Port.SourceControl.Log).Synchronize()
]]></Implementation>
</Method>
</Class>


<Class name="Port.TestUtils.MockProject">
<Super>%RegisteredObject</Super>
<TimeCreated>64239,32011.631107</TimeCreated>

<Parameter name="MOCKNAME">
<Default>Faux</Default>
</Parameter>

<Property name="Project">
<Type>%Studio.Project</Type>
</Property>

<Property name="ItemsList">
<Type>%String</Type>
<MultiDimensional>1</MultiDimensional>
</Property>

<Property name="FixtureDirectory">
<Type>%String</Type>
</Property>

<Method name="%OnNew">
<FormalSpec>fixtureDir:%String,withFauxFiles:%Boolean=0,addToProject:%Boolean=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set ..FixtureDirectory = fixtureDir
  $$$QuitOnError(..Create(withFauxFiles, addToProject))
  return $$$OK
]]></Implementation>
</Method>

<Method name="%OnClose">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  $$$QuitOnError(..Delete())
  return $$$OK
]]></Implementation>
</Method>

<Method name="Delete">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if ##class(%Studio.Project).%ExistsId(..#MOCKNAME) {    
    $$$QuitOnError(##class(%Studio.Project).Delete(..#MOCKNAME))
    $$$QuitOnError(..DisposeFauxItems())
  }  
  return $$$OK
]]></Implementation>
</Method>

<Method name="Create">
<FormalSpec>withFauxFiles:%Boolean=0,addToProject:%Boolean=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  
  $$$QuitOnError(..Delete())
  set ..Project = ##class(%Studio.Project).%New(..#MOCKNAME)
  set ..Project.Name = ..#MOCKNAME
  if withFauxFiles  $$$QuitOnError(..CreateFauxItems())
  if addToProject   $$$QuitOnError(..AddItemsToProject())
  set sc = ..Project.%Save()
  $$$QuitOnError(sc)
  return $$$OK
]]></Implementation>
</Method>

<Method name="CreateFauxItems">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  
  #define TAB $char(9)
  #define GetAbsolutePath(%relative) ##class(%File).Normalize($System.Util.InstallDirectory, %relative)    
  set sc = $$$OK
  
  set fauxItems = 13
  set fauxItems(1)  = "Faux.Class.cls"
  set fauxItems(2)  = "fauxjs.js"
  set fauxItems(3)  = "fauxcss.css"
  set fauxItems(4)  = "fauxinc.inc"
  set fauxItems(5)  = "fauxmac.mac"
  set fauxItems(6)  = "fauxint.int"
  set fauxItems(7)  = "fauxmvi.mvi"
  set fauxItems(8)  = "fauxmvb.mvb"
  set fauxItems(9)  = "fauxbas.bas"
  set fauxItems(10) = "fauxdfi.dfi"
  set fauxItems(11) = "fauxcsp.csp"
  set fauxItems(12) = "fauxcsr.csr"
  set fauxItems(13) = "fauxhtml.html"
  
  for i=1:1:fauxItems {    
    set contentType = 0       
    set name = fauxItems(i)
    set ext = $piece(name, ".", *)
    set destination = name
    set absoluteFilePath = ##class(%File).NormalizeFilename(..FixtureDirectory_"/"_name)
    if '##class(%File).Exists(absoluteFilePath) continue
    if $lf($lfs("inc,mac,int,dfi,mvi,mvb,bas"), ext) {
      set file = ##class(%FileCharacterStream).%New()
      set file.Filename = absoluteFilePath
      if ##class(%RoutineMgr).Exists(name) {
        do ##class(%RoutineMgr).Delete(name)
      }
      set routine = ##class(%RoutineMgr).%OpenId(name)     
      set sc = routine.Code.CopyFrom(file)
      if $$$ISERR(sc) quit
      set sc = routine.Code.%Save()
      if $$$ISERR(sc) quit
      set routine = ""
      set contentType = 1
    } elseif ext = "cls" {
      set sc = ##class(%Compiler.UDL.TextServices).SetTextFromFile($namespace, ##class(%File).GetFilename(absoluteFilePath), absoluteFilePath)
      if $$$ISERR(sc) quit
    } else {
      set name = $extract($System.CSP.GetDefaultApp($namespace)_"/"_name, 2, *)
      set destination = ##class(Port.Project.Helper).CSPToAbsoluteAppPath(name)
      set sc = ##class(%File).CopyFile(absoluteFilePath, destination, 1, .o)
      if 'sc quit
      set contentType = 2
    }
    set i%ItemsList = $increment(i%ItemsList)
    set i%ItemsList(destination) = contentType
    set file = ""
  }
  return sc
]]></Implementation>
</Method>

<Method name="DisposeFauxItems">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  if $data(i%ItemsList) return $$$OK
  set name = ""
  for {
    set name = $order(i%ItemsList(name), 1, type)
    quit:name=""
    
    if type = 1 do ##class(%Routine).Delete(name)
    if type = 2 do $System.OBJ.Delete(name)
    if type = 3 do ##class(%File).Delete($System.Util.InstallDirectory()_"/csp/"_$$$lcase($namespace)_"/name")
  }
  return $$$OK
]]></Implementation>
</Method>

<Method name="AddItemsToProject">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set name = ""
  for {    
    set name = $order(i%ItemsList(name))
    quit:name=""
    
    do ..Project.AddItem(name)
  }
  return $$$OK
]]></Implementation>
</Method>
</Class>


<Class name="Port.UnitTest.Manager">
<Super>%UnitTest.Manager</Super>
<TimeCreated>64306,34529.705584</TimeCreated>

<Method name="Root">
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  // This provides us the capability to search for tests unrelated to ^UnitTestRoot.
  return ##class(%File).NormalizeFilename(##class(Port.Configuration).GetWorkspace())
]]></Implementation>
</Method>

<Method name="RunTestsFromWorkspace">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String,targetClass:%String="",targetMethod:%String="",targetSpec:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
    
  set recursive = "recursive"
  set activeProject = $get(^||Port.Project)
  set ^||Port.Project = projectName
  
  if targetClass '= "" set target = ##class(Port.UnitTest.Util).GetClassTestSpec(targetClass)
  else  set target = ##class(Port.Configuration).GetTestPath()
  
  if targetMethod '= "" {
    set target = target_":"_targetMethod
    set recursive = "norecursive"
  }
  
  set sc = ..RunTest(target, "/"_recursive_"/run/noload/nodelete/"_targetSpec)
  set ^||Port.Project = activeProject
  return sc
]]></Implementation>
</Method>
</Class>


<Class name="Port.UnitTest.TestCase">
<Super>%UnitTest.TestCase</Super>
<TimeCreated>64306,34529.790238</TimeCreated>

<Method name="GetTestDirectory">
<FormalSpec>filePath:%String=""</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  
  set testPath = ##class(Port.Configuration).GetTestPath()
  return ##class(%File).NormalizeFilename(filePath, ..Manager.Root()_"/"_testPath)
]]></Implementation>
</Method>
</Class>


<Class name="Port.UnitTest.Util">
<Description>
This class presents a list of methods used to resolve qualified test files locations.</Description>
<Abstract>1</Abstract>
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64468,37198.779512</TimeCreated>

<Method name="GetTestClassPath">
<Final>1</Final>
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec>className:%String,workspace:%String=##class(Port.Configuration).GetWorkspace()</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set className = className_".CLS"
  set isUsingXML = (##class(Port.Configuration).GetTestFormat() = "XML")
  
  if isUsingXML set workspace = workspace_"/"_##class(Port.Configuration).GetTestPath()
  set path = ##class(Port.Util).ItemToPath(className, workspace)  
  if isUsingXML set path = $replace(path, ".cls", ".xml")
  
  return path
]]></Implementation>
</Method>

<Method name="IsUnitTestClass">
<Description>
Returns if the className is a qualified test case class.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>className:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
  
  set isUnitTest = 0
  set descriptor = ##class(%Dictionary.CompiledClass).%OpenId(className)
  if '$isobject(descriptor) || ($isobject(descriptor) && (descriptor.Super = "")) return 0
  
  // Target class is direct descendant.
  if descriptor.Super [ "Port.UnitTest.TestCase" return 1
  
  // Target class is not a direct descendant, so we go deep down till we find which parent class
  /// is actually extending from Port.UnitTest.TestCase.
  for i=1:1:$length(descriptor.Super, ",") {
    set extension = $piece(descriptor.Super, ",", i)
    if ..IsUnitTestClass(extension) {
      set isUnitTest = 1
      quit
    }   
  }  
  return isUnitTest
]]></Implementation>
</Method>

<Method name="AssertTestableClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>className,*testableClass:%String="",projectName:%String=$get(^||Port.Project)</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
  if $piece(className, ".", *) = "CLS" set className = $piece(className, ".", 1, *-1)
  
  set prefix = ##class(Port.Configuration).GetTestClassPrefix()
  set rootPackage = $piece(className, ".")
  
  if ##class(%Dictionary.ClassDefinition).%ExistsId(prefix_"."_className) {
    set maybeTestableClass = prefix_"."_className
    if ..IsUnitTestClass(maybeTestableClass) {
      set testableClass = prefix_"."_className
      if '##class(Port.Util).ExistsInProject(projectName, testableClass_".CLS") {
        // Cannot export Unit Test classes that aren't in the project.
        set testableClass = ""
      }
    }
  } elseif ..IsUnitTestClass(className) {
    set testableClass = className
  }
  
  return (testableClass '= "")
]]></Implementation>
</Method>

<Method name="GetClassTestSpec">
<ClassMethod>1</ClassMethod>
<FormalSpec>testableClass:%String,baseTestPath:%String=##class(Port.Configuration).GetTestPath()</FormalSpec>
<Implementation><![CDATA[
  set isUsingUDL = (##class(Port.Configuration).GetTestFormat() = "UDL")
  set baseTestPath = $$$RTrimProvidedSlash(baseTestPath, "/")
  
  if isUsingUDL set baseTestPath = ""
  return baseTestPath_$piece($replace(testableClass, ".", "/"), "/", 1, *-1)_":"_testableClass
]]></Implementation>
</Method>
</Class>


<Class name="Port.Util">
<Abstract>1</Abstract>
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64470,32188.149177</TimeCreated>

<Method name="GetWorkspaceNameFromAbsoluteItemPath">
<Description><![CDATA[
Returns the workspace folder name according to an absolute path. The name is matched
from the directory part that is before the item type folder. E.g.: <workspace_name>/<item_type>/<item_filename>.
If item_type is a known type, then it will be used as a pointer to find the workspace_name.]]></Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>absolutePath:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set pathParts = $lfs(absolutePath, $$$Slash(absolutePath))
  set workspaceName = ""

  for i=1:1:$ll(pathParts) {
    set part = $lg(pathParts, i)
    if $lf($$$PathTypes, part) set workspaceName = $lg(pathParts, i - 1) quit
  }
  quit workspaceName
]]></Implementation>
</Method>

<Method name="GetWorkspaceFromItemPath">
<Description>
Returns the path that leads to the workspace folder, excluding any folder that is part of it.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>itemPath:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set slash = $$$Slash(itemPath)
  set workspaceName = ""

  for i=1:1:$length(itemPath, slash) {
    set part = $piece(itemPath, slash, i)
    if $lf($$$PathTypes, part) {
      set workspace = $piece(itemPath, slash, 1, i - 1)
      quit
    }
  }
  quit workspace
]]></Implementation>
</Method>

<Method name="GetItemType">
<Description>
Retrieves the extension from the itemName. If the extension matches none, then attempt to find out if the extension is actually a package.
Otherwise assume that the extension is defined from a custom file.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>itemName:%String,checkPackageExists:%Boolean=1</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set ext = $$$ucase($piece(itemName, ".", *))
  set slash = $$$PathSlash(itemName)

  if itemName [ slash quit "CSP"
  if $lf($$$RoutineExtensions, "."_ext) || (ext = "CLS") || (ext = "PRJ") return ext
  
  if 'checkPackageExists || (checkPackageExists && ..IsPackage(itemName)) { quit "PKG" }
  quit ext
]]></Implementation>
</Method>

<Method name="IsPackage">
<Description>
Checks if the itemName is actually a package. Returns 1 if yes otherwise 0.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>itemName</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
  if itemName = "" return 0
  if $get(^oddPKG($$$ucase(itemName))) '= "" quit 1
  if ##class(%Dictionary.PackageDefinition).%ExistsId(itemName) quit 1
  do $System.OBJ.GetPackageList(.l, itemName)
  if $data(l) quit 1

  quit 0
]]></Implementation>
</Method>

<Method name="GetWorkspaceBasedItemPath">
<Description>
Translates an item name into a workspace path.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>itemName:%String,project:%String=$get(^||Port.Project)</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[  quit ..ItemToPath(itemName, $$$NFN(##class(Port.Configuration).GetWorkspace(project)))
]]></Implementation>
</Method>

<Method name="ItemToPath">
<Description>
Translates the item name into an item path which represents the location to where the file source is located.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>itemName:%String,workspace:%String=""</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  #define WithAbsolute(%s) $select(workspace '= "" : $$$NFN(workspace_%s), 1: %s)

  set fullPath = ""
  set type = ..GetItemType(itemName, 0)
  set slash = $$$Slash(itemName)
  set workspace = $select(workspace '= "" : $$$RPadProvidedSlash(workspace, slash), 1: "")

  if type = "CLS" {    
    set classWithoutTheExtension = $piece(itemName, ".", 1, *-1)
    set fullPath = $$$WithAbsolute("cls"_$$$OSSlash_..ClassToFile(classWithoutTheExtension))
  } elseif $lf($$$RoutineExtensions, "."_$$$ucase(type)) {
    set itemName = $piece(itemName, slash, *)
    set ext = $$$lcase(type)
    set fileName = itemName
    set $piece(fileName, ".", *) = ext
    set fullPath = $$$WithAbsolute(ext_"/"_fileName)
  } elseif type = "PKG" {
    // Deep package?
    if $$$ucase(itemName) '[ ".PKG" set itemName = itemName_".PKG"
    set name = $select(itemName [ "." : $piece(itemName, ".", 1, *-1), 1: itemName)
    set fullPath = $$$WithAbsolute("cls/"_..ClassToFile(name, 0))
  } else {
    set itemName = $$$LTrimProvidedSlash(itemName, "/")
    set webApplication = $System.CSP.GetAppName(itemName)
    set remainingPath = $piece(itemName, "/", $length(webApplication, "/"), *)
    set sourceFilePath = "public/"_webApplication_remainingPath
    set fullPath = $$$WithAbsolute(sourceFilePath)
  }
  quit $replace(fullPath, "/", $$$Slash(fullPath))
]]></Implementation>
</Method>

<Method name="PathToItem">
<Description>
Translates an absolute item path into its item format.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>sourcePath:%String,namespace:%String=$namespace</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set isPackage = 0
  if sourcePath [ "." set type = $piece(sourcePath, ".", *)
  else  set type = "cls" set isPackage = 1

  set uppercaseType = $$$ucase(type)

  set sourcePath = $$$NFN(sourcePath)
  set slash = $$$Slash(sourcePath)

  if $lf($$$RoutineExtensions, "."_uppercaseType) || (uppercaseType = "CLS") {
    set item = $replace($piece($$$LPadProvidedSlash(sourcePath, slash), slash_type_slash, 2, *), slash, ".")
    if isPackage set $piece(item, ".", *+1) = "pkg"
    quit item
  }

  set item = ..GetItemFromCSPPath(sourcePath, namespace)
  quit item
]]></Implementation>
</Method>

<Method name="GetPathType">
<Description>
Extracts the portion of the folder that represents the source type.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>absolutePath:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set part = ""
  set slash = $$$PathSlash(absolutePath)
  set partsLength = $length(absolutePath, $$$PathSlash(absolutePath))

  for i=1:1:partsLength {
    set part = $$$lcase($piece(absolutePath, slash, i))
    if $lf($$$PathTypes, part) quit
  }

  quit $$$ucase(part)
]]></Implementation>
</Method>

<Method name="ResolveItemId">
<Description>
Resolves item name into a qualified id that can be manipulated by the %Studio.Project API.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>name:%String,projectName:%String=$get(^||Port.Project)</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set nameOnly = $piece(name, ".", 1, *-1)
  set maskedMacs = $lb("BAS", "INT", "INC", "MVI")
  set itemName = name
  set id = ""

  set extension = ..GetItemType(name)

  if ..IsRoutine(name) {
    set itemType = extension
    if $lf(maskedMacs, itemType) set itemType = "MAC"
    set itemName = nameOnly_"."_extension
  } elseif extension = "CLS" {
    set itemName = nameOnly
    set itemType = extension
  } elseif extension = "PKG" {
    set itemName = nameOnly
    set itemType = "PKG"
  } else {
    // Ensures that CSP items starts with normalized path.
    set itemName = $$$LTrimProvidedSlash(name, "/")
    set itemType = "CSP"
  }
  return projectName_"||"_itemName_"||"_itemType
]]></Implementation>
</Method>

<Method name="GetItemFromCSPPath">
<ClassMethod>1</ClassMethod>
<FormalSpec>physicalPath:%String,namespace:%String=$namespace</FormalSpec>
<Private>1</Private>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set slash = $$$Slash(physicalPath)
  quit $replace($extract(physicalPath, $find(physicalPath, slash_"public"_slash), *), "\", "/")
]]></Implementation>
</Method>

<Method name="IsRoutine">
<ClassMethod>1</ClassMethod>
<FormalSpec>itemName:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
  set extension = ..GetItemType(itemName)

  if extension = "MAC"  || (extension = "INT") ||
    (extension = "MVB") || (extension = "MVI") ||
    (extension = "BAS") || (extension = "INC") ||
    (extension = "DFI") {
    return 1
  }
  return 0
]]></Implementation>
</Method>

<Method name="ClassToFile">
<ClassMethod>1</ClassMethod>
<FormalSpec>className:%String,appendCLS:%Boolean=1</FormalSpec>
<Private>1</Private>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set cls = $case(appendCLS, 1: ".cls", : "")
  quit $replace(className, ".", $$$OSSlash)_cls
]]></Implementation>
</Method>

<Method name="FileToClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>path:%String</FormalSpec>
<Private>1</Private>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  set slash = $$$Slash(path)
  set path = $$$NFN(path)
  set fileName = ##class(%File).GetFilename(path)
  set contextPath = $extract(path, $find(path, slash_"cls") + 1, ($length(path) - 1) - 3)
  return $replace(contextPath, slash, ".")
]]></Implementation>
</Method>

<Method name="ExistsInProject">
<Internal>1</Internal>
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String,name:%String,type:%String="",namespace:%String=$namespace</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[

  new $namespace
  set $namespace = namespace

  try {
    do ##class(%Studio.Project).NormalizeName(.name, .type)

    set s = ##class(%SQL.Statement).%New()
    do s.%PrepareClassQuery("%Studio.Project", "ProjectItemsList")
    set r = s.%Execute(projectName)

    while r.%Next(.sc) {
      set itemName = r.%Get("Name")
      set itemType = r.%Get("Type")
      if itemType = type && ($$$lcase(itemName) = $$$lcase(name)) {
        do ##class(%Studio.Project).NormalizeName(.itemName, .itemType)
        if itemName = name return 1
      }
    }
  } catch ex {
    return 0
  }

  return 0
]]></Implementation>
</Method>

<Method name="ListConflicts">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String,name:%String,type:%String="",namespace:%String=$namespace</FormalSpec>
<ReturnType>%List</ReturnType>
<Implementation><![CDATA[
  new $namespace
  set $namespace = namespace
  
  do ##class(%Studio.Project).NormalizeName(.name, .type)
  &sql(
    SELECT
      LIST(DISTINCT P.NAME) INTO :conflicts
    FROM
      %STUDIO.PROJECTITEM PI
    LEFT OUTER JOIN
      %STUDIO.PROJECT P ON P.ID = PI.Project
    WHERE
      P.NAME <> :projectName AND (
       -- This deals with common cases.
       (:type NOT IN ('PKG', 'CLS') AND PI.NAME = :name) OR
       -- This deals with cases where a project is trying to add a package that is
       -- depended by another class in another project.
       (:type = 'PKG' AND PI.NAME %STARTSWITH :name) OR
       -- This deals with attempts to add classes that are owned by another project's
       -- package.
       (:type = 'CLS' AND PI.NAME = :name)
      )
  )
  return $lfs(conflicts)
]]></Implementation>
</Method>

<Method name="EnsurePathExists">
<ClassMethod>1</ClassMethod>
<FormalSpec>path:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  set absolutePath = $$$NFN(path)
  set isCreated = 1
  if '##class(%File).DirectoryExists(absolutePath)  {
    set isCreated = ##class(%File).CreateDirectoryChain(absolutePath)
    if isCreated = 0 {
      return $$$PERROR($$$CannotCreateDirectory, absolutePath)
    }
  }
  return $$$OK
]]></Implementation>
</Method>

<Method name="GetIgnoredPaths">
<ClassMethod>1</ClassMethod>
<FormalSpec>projectName:%String=$get(^||Port.Project)</FormalSpec>
<ReturnType>%ListOfDataTypes</ReturnType>
<Implementation><![CDATA[
  set workspaceDir = ##class(Port.Configuration).GetWorkspace(projectName)
  set ignoredPaths = ##class(%ListOfDataTypes).%New()

  set f = ##class(%FileCharacterStream).%New()
  set f.Filename = workspaceDir_"/.portignore"

  if f.Size > 0 {
    while 'f.AtEnd {
      do ignoredPaths.Insert(f.ReadLine())
    }
  }
  return ignoredPaths
]]></Implementation>
</Method>

<Method name="TranslatePath">
<ClassMethod>1</ClassMethod>
<FormalSpec>path:%String,OSFormat:%Integer=$zversion(1)</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
  // Unix
  if OSFormat = 3 {
    if $extract(path, 1, 2)?1A1":" {
      set path = $extract(path, 3, *)
    }
    return $replace(path, "\", "/")
  // Windows
  } elseif OSFormat = 2 {
    set path = $replace(path, "/", "\")
    if $extract(path) = "\" {
      set path = ##class(%File).NormalizeFilename("\")_path
    }
  }
  return path
]]></Implementation>
</Method>

<Method name="IsOutdated">
<Description>
Checks if an an item is outdated to their counterpart (the local source file).
Use the isImport flag to invert the condition.</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>project:%String,current:%String,external:%String,isImport:%Boolean=0</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
  if '##class(%File).Exists(external) quit 1
  set externalTS = $zdt(##class(%File).GetFileDateModified(##class(%File).NormalizeFilename(external)), 3,,,,,,,,,0)
  set workspace = ..GetWorkspaceFromItemPath(external)

  if externalTS < 0 quit 1
  set lastModified = 0

  set projectTS = ##class(Port.SourceControl.Log).GetLastChange(project, project_".PRJ")
  set currentDate = ##class(Port.SourceControl.Log).GetLastChange(project, current)

  if currentDate = 0 set lastModified = projectTS
  else  set lastModified = $select(currentDate ] projectTS : currentDate, 1: projectTS)

  if ..IsRoutine(current) || (..GetItemType(current) = "CLS") {
    set currentTS = $piece(##class(%RoutineMgr).TS(current, .compileTime), ".")
  } else {
    set fullSourcePath = ""
    set target = ##class(%CSP.Routine).%New(current)
    /// Skip what we can't import.
    if '$isobject(target) return 0
    set currentTS = $zdatetime(##class(%File).GetFileDateModified(target.Filename), 3,,,,,,,,,0)
  }

  // If the file or the item is missing it's considered outdated as well.
  if currentTS = 0 return 1

  // Same date for both entries? Then consider updated.
  if currentTS = externalTS return 0
  if 'isImport {
    if currentTS = "" return 1
    // As currentTS is referring to the existing source code, this condition checks if
    // it is newer than the external source code.
    return (
      (currentTS ] externalTS) &&
      (currentTS ] lastModified)
    )
  }
  // Otherwise everything is inverted:
  // External files must be newer than the imported source code and newer than their last
  // registry as well.
  return (
    (externalTS ] currentTS) &&
    (externalTS ] lastModified)
  )
]]></Implementation>
</Method>
</Class>


<Class name="Port.Wizard">
<Abstract>1</Abstract>
<IncludeCode>portutils</IncludeCode>
<TimeCreated>64399,33218.690245</TimeCreated>

<Method name="Start">
<ClassMethod>1</ClassMethod>
<FormalSpec>hideIntroduction:%Boolean=0</FormalSpec>
<Implementation><![CDATA[
  set validChoices = $listbuild(1,2,3,4,5)
  set invalidChoice = 1
  set choice = ""  
  
  if 'hideIntroduction {
    write !, $$$FormatWizardMsg($$$PCWWelcome)
  }
  
  while invalidChoice {
    if invalidChoice && (choice '= "") write $$$FormatWizardMsg($$$PCWInvalidChoice)
    do Menu
  }
    
  if choice = 1 return ..StartWorkspaceConfigAssistant() quit
  if choice = 2 return ..StartTestConfigAssistant() quit
  if choice = 3 return ..StartAutoExportXMLConfigAssistant() quit
  if choice = 4 return ..StartLogLevelConfigAssistant() quit
  if choice = 5 write !, $$$FormatWizardMsg($$$PCWBye) return $$$OK
         
Menu
  set choice = ""
  write !!, $$$FormatWizardMsg($$$PCWChoiceQuestion), !!
  
  write $$$FormatWizardMsg($$$PCWManageWorkspaceChoice), !
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice), !
  write $$$FormatWizardMsg($$$PCWToggleAutoExportChoice), !
  write $$$FormatWizardMsg($$$PCWSetLogLevelChoice), !
  write $$$FormatWizardMsg($$$PCWExit), !!
  
  write $$$FormatWizardMsg($$$PCWChoicePrompt)
  
  read choice
  write !  
  set invalidChoice = ($listfind(validChoices, choice) = 0)
  quit
]]></Implementation>
</Method>

<Method name="StartWorkspaceConfigAssistant">
<ClassMethod>1</ClassMethod>
<FormalSpec>hideIntroduction:%Boolean=0</FormalSpec>
<Implementation><![CDATA[
 
  set validChoices = $listbuild(1,2,3,4,5)
  set invalidChoice = 1
  set choice = ""    
  
  if 'hideIntroduction {  
    write !, $$$FormatWizardMsg($$$PCWManageWorkspaceDescription), !!
  }
  
  while invalidChoice {
    if invalidChoice && (choice '= "") write $$$FormatWizardMsg($$$PCWInvalidChoice), !!
    do Menu
  }
  
  if choice = 1 return ..StartWorkspaceChoice1ConfigAssistant()
  if choice = 2 return ..StartWorkspaceChoice2ConfigAssistant()
  if choice = 3 return ..Start(1)
  
  return $$$OK
    
Menu
  set choice = ""
  write !, $$$FormatWizardMsg($$$PCWChoiceQuestion), !!

  write $$$FormatWizardMsg($$$PCWManageWorkspaceChoice1), !
  write $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2), !
  write $$$FormatWizardMsg($$$PCWGoBackChoice, "3"), !!
  
  write $$$FormatWizardMsg($$$PCWChoicePrompt)
  
  read choice
  write !  
  set invalidChoice = ($listfind(validChoices, choice) = 0)
  quit
]]></Implementation>
</Method>

<Method name="StartWorkspaceChoice1ConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  set isPathValid = 0
      
  write !, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice1Description)
  
  write !!, $$$FormatWizardMsg($$$PCWPlaceholdersAnnounce), !!
  
  write $$$FormatWizardMsg($$$PCWPlaceholdersProject), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersNamespace), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersUsername), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersInstallDir)
  
  write !!, $$$FormatWizardMsg($$$PCWPathAbsolute), !!
 
  write $$$FormatWizardMsg($$$PCWPathOSSchemes), !!
  write $$$FormatWizardMsg($$$PCWPathDefault), !, "/CacheProjects/{NAMESPACE}/{PROJECT}", !
  write $$$FormatWizardMsg($$$PCWPathCurrent), !, $get(^Port.Configuration("source.path"), "none"), !!
  write $$$FormatWizardMsg($$$PCWPathNew), !
  read path
  
  if path = "" set path = "/CacheProjects/{NAMESPACE}/{PROJECT}"
    
  do ##class(Port.Configuration).SetPrimaryWorkspace(path)
  write !!, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice1StatusNow, path), !
  return ..StartWorkspaceConfigAssistant(1)
]]></Implementation>
</Method>

<Method name="StartWorkspaceChoice2ConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  write !, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2Description), ! 
  write !, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2Description2), !
  
  write !, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2Prompt), !
  read projectName
  
  if projectName = "" write !, $$$FormatWizardMsg($$$PCWAborted), !! return ..StartWorkspaceConfigAssistant(1)
  set projectExists = ##class(%Studio.Project).%ExistsId(projectName)
  
  if 'projectExists {
    write !!, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2Warning), !!
  }  
  
  set currentWorkspace = ##class(Port.Configuration).GetCustomWorkspace(projectName)
  write !!, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice1StatusCurrent, ##class(Port.Configuration).GetWorkspace(projectName)), !
  write !, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2CurrentWorskpaceWarn)
  
  write !!, $$$FormatWizardMsg($$$PCWPathAbsolute), !!
  
  write $$$FormatWizardMsg($$$PCWPlaceholdersProject), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersNamespace), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersUsername), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersInstallDir)
    
  write !!, $$$FormatWizardMsg($$$PCWPathOSSchemes) 
  
  write !!, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2Prompt2), !
  read workspacePath
  
  if workspacePath = "" write !, $$$FormatWizardMsg($$$PCWAborted), !! return ..StartWorkspaceConfigAssistant(1)
  
  do ##class(Port.Configuration).SetCustomWorkspace(projectName, workspacePath)
  write !!, $$$FormatWizardMsg($$$PCWManageWorkspaceChoice2StatusNow, projectName, ##class(Port.Configuration).GetWorkspace(projectName)), !
  
  return ..StartWorkspaceConfigAssistant(1)
]]></Implementation>
</Method>

<Method name="StartTestConfigAssistant">
<ClassMethod>1</ClassMethod>
<FormalSpec>hideIntroduction:%Boolean=0</FormalSpec>
<Implementation><![CDATA[
  set validChoices = $listbuild(1,2,3,4)
  set invalidChoice = 1
  set choice = ""    
  
  if 'hideIntroduction {  
    write !, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsDescription), !
  }
  
  while invalidChoice {
    if invalidChoice && (choice '= "") write $$$FormatWizardMsg($$$PCWInvalidChoice), !!
    do Menu
  }
  
  if choice = 1 return ..StartTestChoice1ConfigAssistant()
  if choice = 2 return ..StartTestChoice2ConfigAssistant()
  if choice = 3 return ..StartTestChoice3ConfigAssistant()
  if choice = 4 return ..Start(1)
  
  return $$$OK
    
Menu
  set choice = ""
  write !, $$$FormatWizardMsg($$$PCWChoiceQuestion), !!
  
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1), !
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice2), !
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice3), !
  write $$$FormatWizardMsg($$$PCWGoBackChoice, 4), !!
  
  write $$$FormatWizardMsg($$$PCWChoicePrompt)
  
  read choice
  write !  
  set invalidChoice = ($listfind(validChoices, choice) = 0)
  quit
]]></Implementation>
</Method>

<Method name="StartAutoExportXMLConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  set validChoices = $listbuild(1,2)
  set choice = ""
  set invalidChoice = 1
  
  set labels(0) = $$$FormatWizardMsg($$$PCWToggleDisabled)
  set labels(1) = $$$FormatWizardMsg($$$PCWToggleEnabled)
  
  write !, $$$FormatWizardMsg($$$PCWToggleAutoExportDescription), !

  while invalidChoice {
    if invalidChoice && (choice '= "") write $$$FormatWizardMsg($$$PCWInvalidChoice), !!
    do Menu
  }
  
  if choice = 1 do ##class(Port.Configuration).EnableAutoExportXML()
  if choice = 2 do ##class(Port.Configuration).DisableAutoExportXML() set choice = 0
    
  write $$$FormatWizardMsg($$$PCWToggleAutoExportChoice1StatusCurrent, labels(choice))
  
  write !!
  return ..Start(1)
  
Menu
  set choice = ""
  write !, $$$FormatWizardMsg($$$PCWChoiceQuestion), !!
    
  write $$$FormatWizardMsg($$$PCWToggleAutoExportChoice1), ! 
  write $$$FormatWizardMsg($$$PCWToggleAutoExportChoice2), !!  
     
  set status = ##class(Port.Configuration).IsAutoExportXMLEnabled()
  
  write $$$FormatWizardMsg($$$PCWToggleAutoExportChoice1StatusCurrent, labels(status)), !!
  write $$$FormatWizardMsg($$$PCWChoicePrompt)
  
  read choice
  set invalidChoice = ($listfind(validChoices, choice) = 0)
  write !
  quit
]]></Implementation>
</Method>

<Method name="StartLogLevelConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  set validChoices = $listbuild(1,2)
  set invalidChoice = 1
  set choice = ""
  
  write !, $$$FormatWizardMsg($$$PCWSetLogLevelDescription), !
  
  while invalidChoice {
    if invalidChoice && (choice '= "") write $$$FormatWizardMsg($$$PCWInvalidChoice), !!
    do Menu
  }
  
  do ##class(Port.Configuration).SetLogLevel(choice)
  write $$$FormatWizardMsg($$$PCWSetLogLevelStatusNow, ##class(Port.Configuration).GetLogLevel())
  return ..Start(1)
  
Menu
  set choice = ""
  write !, $$$FormatWizardMsg($$$PCWSetLogLevelStatusPrompt), !!
    
  write $$$FormatWizardMsg($$$PCWSetLogLevelStatusChoice1), !!
  
  write $$$FormatWizardMsg($$$PCWSetLogLevelStatusChoice2), !!
  
  write $$$FormatWizardMsg($$$PCWSetLogLevelStatusCurrent, ##class(Port.Configuration).GetLogLevel()), !!
  write $$$FormatWizardMsg($$$PCWChoicePrompt)
  
  read choice
  set invalidChoice = ($listfind(validChoices, choice) = 0)
  write !
  quit
]]></Implementation>
</Method>

<Method name="StartTestChoice1ConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  set validChoices = $listbuild(1,2)  
  set invalidChoice = 1
  set choice = ""
  
  set labels(0) = $$$FormatWizardMsg($$$PCWToggleEnabled)
  set labels(1) = $$$FormatWizardMsg($$$PCWToggleDisabled)
  
  write !, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1Description), !  
  
  while invalidChoice {
    if invalidChoice && (choice '= "") write $$$FormatWizardMsg($$$PCWInvalidChoice), !!
    do Menu
  }
  
  if choice = 1 do ##class(Port.Configuration).EnableTestOnDemand()      
  if choice = 2 do ##class(Port.Configuration).DisableTestOnDemand()
  
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1StatusCurrent, labels(choice - 1))
  
  write !
  return ..StartTestConfigAssistant(1)
  
Menu
  set choice = ""
  write !, $$$FormatWizardMsg($$$PCWChoiceQuestion), !!
    
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1Choice1), ! 
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1Choice2), !! 
     
  set status = ##class(Port.Configuration).IsTestOnDemandEnabled()
  
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1StatusCurrent, labels(status)), !
  write $$$FormatWizardMsg($$$PCWChoicePrompt)
  
  read choice
  set invalidChoice = ($listfind(validChoices, choice) = 0)
  write !
  quit
]]></Implementation>
</Method>

<Method name="StartTestChoice2ConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  
  write !, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice1Description), !
  write !, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice2Description), !
  write !, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice3Description), !!
  
  write $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice2Prompt), !  
  write $$$FormatWizardMsg($$$PCWPathDefault), " UnitTest", !
  write $$$FormatWizardMsg($$$PCWPathCurrent), " ", ##class(Port.Configuration).GetTestClassPrefix(), !!
  write $$$FormatWizardMsg($$$PCWPathNew)
  read prefix   
  
  do ##class(Port.Configuration).SetTestClassPrefix(prefix)
  write !!, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice2StatusNow, ##class(Port.Configuration).GetTestClassPrefix())
  write !!
  return ..StartTestConfigAssistant(1)
]]></Implementation>
</Method>

<Method name="StartTestChoice3ConfigAssistant">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
  write !, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice3Description)
  
  write !!, $$$FormatWizardMsg($$$PCWPlaceholdersAnnounce), !!
  
  write $$$FormatWizardMsg($$$PCWPlaceholdersProject), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersNamespace), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersUsername), !
  write $$$FormatWizardMsg($$$PCWPlaceholdersInstallDir)
  
  write !!, $$$FormatWizardMsg($$$PCWPathRelative), !
    
  write $$$FormatWizardMsg($$$PCWPathDefault), !, "tests", !
  write $$$FormatWizardMsg($$$PCWPathCurrent), !, $get(^Port.Configuration("test.path")), !!
  write $$$FormatWizardMsg($$$PCWPathNew), !
  read path
   
  do ##class(Port.Configuration).SetTestPath(path)
  write !!, $$$FormatWizardMsg($$$PCWManageChangeTestSettingsChoice3StatusNow, ^Port.Configuration("test.path"))
  write !!
  return ..StartTestConfigAssistant(1)
]]></Implementation>
</Method>
</Class>


<Routine name="portmd" type="INC"><![CDATA[
#define PCWGoBackChoice                                 -7999
#define PCWPathNew                                      -7985
#define PCWPathCurrent                                  -7984
#define PCWPathDefault                                  -7983
#define PCWPathOSSchemes                                -7982
#define PCWPathAbsolute                                 -7981
#define PCWPathRelative                                 -7980
#define PCWPlaceholdersInstallDir                       -7974
#define PCWPlaceholdersUsername                         -7973
#define PCWPlaceholdersNamespace                        -7972
#define PCWPlaceholdersProject                          -7971
#define PCWPlaceholdersAnnounce                         -7970
#define PCWExit                                         -7600
#define PCWSetLogLevelStatusChoice2                     -7420
#define PCWSetLogLevelStatusChoice1                     -7410
#define PCWSetLogLevelStatusPrompt                      -7404
#define PCWSetLogLevelStatusNow                         -7403
#define PCWSetLogLevelStatusCurrent                     -7402
#define PCWSetLogLevelDescription                       -7401
#define PCWSetLogLevelChoice                            -7400
#define PCWToggleAutoExportChoice2                      -7320
#define PCWToggleAutoExportChoice1                      -7310
#define PCWToggleAutoExportChoice1StatusNow             -7303
#define PCWToggleAutoExportChoice1StatusCurrent         -7302
#define PCWToggleAutoExportDescription                  -7301
#define PCWToggleAutoExportChoice                       -7300
#define PCWManageChangeTestSettingsChoice3StatusNow     -7232
#define PCWManageChangeTestSettingsChoice3Description   -7231
#define PCWManageChangeTestSettingsChoice3              -7230
#define PCWManageChangeTestSettingsChoice2StatusNow     -7225
#define PCWManageChangeTestSettingsChoice2Prompt        -7224
#define PCWManageChangeTestSettingsChoice2Description3  -7223
#define PCWManageChangeTestSettingsChoice2Description2  -7222
#define PCWManageChangeTestSettingsChoice2Description   -7221
#define PCWManageChangeTestSettingsChoice2              -7220
#define PCWManageChangeTestSettingsChoice1StatusCurrent -7214
#define PCWManageChangeTestSettingsChoice1Choice2       -7213
#define PCWManageChangeTestSettingsChoice1Choice1       -7212
#define PCWManageChangeTestSettingsChoice1Description   -7211
#define PCWManageChangeTestSettingsChoice1              -7210
#define PCWManageChangeTestSettingsDescription          -7201
#define PCWManageChangeTestSettingsChoice               -7200
#define PCWManageWorkspaceChoice2StatusNow              -7128
#define PCWManageWorkspaceChoice2Prompt2                -7127
#define PCWManageWorkspaceChoice2CurrentWorskpaceWarn   -7126
#define PCWManageWorkspaceChoice2StatusCurrent          -7125
#define PCWManageWorkspaceChoice2Warning                -7124
#define PCWManageWorkspaceChoice2Prompt                 -7123
#define PCWManageWorkspaceChoice2Description2           -7122
#define PCWManageWorkspaceChoice2Description            -7121
#define PCWManageWorkspaceChoice2                       -7120
#define PCWManageWorkspaceChoice1StatusNow              -7113
#define PCWManageWorkspaceChoice1StatusCurrent          -7112
#define PCWManageWorkspaceChoice1Description            -7111
#define PCWManageWorkspaceChoice1                       -7110
#define PCWManageWorkspaceDescription                   -7101
#define PCWManageWorkspaceChoice                        -7100
#define PCWBye                                          -7007
#define PCWToggleDisabled                               -7006
#define PCWToggleEnabled                                -7005
#define PCWAborted                                      -7004
#define PCWChoicePrompt                                 -7003
#define PCWChoiceQuestion                               -7002
#define PCWInvalidChoice                                -7001
#define PCWWelcome                                      -7000
#define CMLRunActiveTest                                -6002
#define CMLImportActive                                 -6001
#define CMLExportActive                                 -6000
#define NoCompatibleApplicationForPublicFile            -119
#define FailedWhileRunningExtendedHook                  -118
#define CannotSaveConflictingItems                      -117
#define CouldNotDetermineWorkspace                      -116
#define LogLevelIsOutOfRange                            -115
#define ErrorsWhileImportingType                        -114
#define ExportingProjectNotFound                        -113
#define NoTestSuitesWereFound                           -112
#define PortIsNotInstalled                              -111
#define UnableToDescribeItem                            -110
#define UnableToRemoveDirectory                         -109
#define SupressedAttemptToExportFromOutside             -108
#define AmbiguousPartialToWorkspace                     -107
#define ErrorsWhileImporting                            -106
#define UnableToExportInvalidItem                       -105
#define UnableToCopySource                              -104
#define CannotUseRelativePath                           -103
#define CannotCreateDirectory                           -102
#define NamespaceDoesntHaveAppWithPath                  -101
#define InvalidPhysicalPath                             -100
#define HookReturnedError                               -1102
#define HookReturnedOK                                  -1101
#define RunningCustomHook                               -1100
#define ConflictingItemDetected2                        -1001
#define ConflictingItemDetected                         -1000
#define ExportingTestClassToXML                         -902
#define XMLExportedTo                                   -901
#define ExportingXML                                    -900
#define FileGroupType                                   -813
#define CLSGroupType                                    -812
#define DFIGroupType                                    -811
#define MVIGroupType                                    -810
#define MVBGroupType                                    -809
#define BASGroupType                                    -808
#define INTGroupType                                    -807
#define INCGroupType                                    -806
#define MACGroupType                                    -805
#define DirectoryType                                   -804
#define FileType                                        -803
#define RoutineType                                     -802
#define ProjectType                                     -801
#define ClassType                                       -800
#define CannotUseDefault2                               -701
#define CannotUseDefault                                -700
#define ProjectSaved                                    -614
#define FatalFailedToRestoreBackup                      -613
#define FatalApplyingBackup                             -612
#define FatalRollingBackTransaction                     -611
#define FatalProjectIntegrityRiskWarning                -610
#define FatalRollbackAlert                              -609
#define FatalErrorAlert                                 -608
#define NewProject                                      -607
#define NoPendingItemsToImport                          -606
#define TotalItemsToImport                              -605
#define EnqueueingItems                                 -604
#define ImportingProject                                -603
#define NothingToImport                                 -602
#define EnqueingType                                    -601
#define ImportingType                                   -600
#define OvewriteWithExtension                           -504
#define UpToDate                                        -503
#define AllDone                                         -502
#define Failed                                          -501
#define Done                                            -500
#define TotalExtraneousItemsRemoved                     -406
#define RemovingDirectory                               -405
#define RemovingFile                                    -404
#define NoExtraneousItems                               -403
#define TotalExtraneousItems                            -402
#define CheckingExtraneousItems                         -401
#define SynchronizingProject                            -400
#define NewWorkspaceDetected                            -304
#define ExportingType                                   -303
#define SourceExportedToPath                            -302
#define ExportingProject                                -301
#define NoItemsToExport                                 -300
#define RemovingBackupMirror                            -203
#define BackupMirror                                    -202
#define BackupAlert                                     -201
#define BackupStart                                     -200
#define MLForceImport                                   -5010
#define MLForceExport                                   -5009
#define MLImport                                        -5008
#define MLRunTests                                      -5007
#define MLScanAndFix                                    -5006
#define MLRemoveRoutines                                -5005
#define MLRemoveFiles                                   -5004
#define MLRemoveClasses                                 -5003
#define MLExportTests                                   -5002
#define MLExportToXML                                   -5001
#define MLExport                                        -5000
]]></Routine>


<Routine name="portutils" type="INC"><![CDATA[
#include %occStatus
#include %occMessages
#include %occErrors

#include portmd

#define NULL                             $s($$$isWINDOWS : "//./nul", 1: "/dev/null")
#define PathTypes                        $listbuild("inc", "int", "cls", "mac", "mvi", "mvb", "bas", "public", "dfi", "data")
#define ImportTypes                      $listbuild("INC", "INT", "CLS", "MAC", "MVI", "MVB", "BAS", "CSR", "CSP")
#define ImportTypeDescriptions           $listbuild("include files", "intermediate routines", "classes", "macro routines",  "MV Intermediate routines", "MV Basic routines", "Basic routines", "DFI XML", "CSP Rules", "files")
#define RoutineExtensions                $listbuild(".MAC", ".INT", ".INC", ".MVB", ".MVI", ".BAS", ".DFI")
#define GlobalExtensions                 $listbuild(".GBL", ".GOF", ".GSA")
#define RoutineGroups                   "MAC,INT,INC,MVB,MVI,BAS,DFI"
#define IsRoutine(%type)                 ($$$RoutineGroups[%type)
#define GetTypeDescription(%type)        $select($$$IsRoutine(%type)=1:$$$RoutineType,(%type = "CLS"):$$$ClassType,(%type = "PRJ"):$$$ProjectType,1:$$$FileType)
#define GetGroupTypeDescription(%type)   $case(%type,"MAC":$$$MACGroupType,"INC":$$$INCGroupType,"INT":$$$INTGroupType,"BAS":$$$BASGroupType,"MVB":$$$MVBGroupType,"MVI":$$$MVIGroupType,"DFI":$$$DFIGroupType,"CLS":$$$CLSGroupType,:$$$FileGroupType)
#def1arg PERROR(%errorArgs)              $$$ERROR($$$GeneralError, $$$FormatMsg("Port Errors", %errorArgs))
#def1arg FormatWizardMsg(%args)          $$$FormatMsg("Port Configuration Wizard", %args)
#define RemoveClassExtension(%iname)     $select($piece(%iname, ".", $$$ucase(%iname), *) [ "CLS" :  $piece(%iname, ".", 1, *-1), 1: %iname)
#define Slash(%path)                     $select($$$IsRemoteAware : $select(%path [ "\" : "\", 1: "/"), 1: $$$OSSlash)
#define OSSlash                          $select($$$isWINDOWS : "\", 1: "/")
#define OSFromSlash(%path)               $select(%path [ "\" : 2, 1: 3)
#define PathSlash(%path)                 $select(%path [ "\" : "\", 1: "/")
#define NFN(%path)                       $select($$$IsRemoteAware : ##class(Port.Util).TranslatePath(%path, $$$OSFromSlash(%path)), 1: ##class(Port.Util).TranslatePath(%path))
#define IsRemoteAware                    $get(^||Port.Internals.Configuration("remote")) = 1
#define LTrimSlash(%p)                   $s($e(%p) = $$$Slash(%p) : $e(%p, 2, *), 1: %p)
#define RTrimSlash(%p)                   $s($e(%p, *) = $$$Slash(%p) : $e(%p, 1, *-1), 1: %p)
#define LTrimProvidedSlash(%p, %slash)   $s($e(%p) = %slash : $e(%p, 2, *), 1: %p)
#define RTrimProvidedSlash(%p, %slash)   $s($e(%p, *) = %slash : $e(%p, 1, *-1), 1: %p)
#define LPadSlash(%p)                    $s($e(%p) '= $$$Slash(%p) : $$$Slash(%p)_%p, 1: %p)
#define RPadSlash(%p)                    $s($e(%p, *) '= $$$Slash(%p) : %p_$$$Slash(%p), 1: %p)
#define LPadProvidedSlash(%p, %slash)    $s($e(%p) '= %slash : %slash_%p, 1: %p)
#define RPadProvidedSlash(%p, %slash)    $s($e(%p, *) '= %slash : %p_%slash, 1: %p)

]]></Routine>
</Export>