void Awake()
{
this.pack = PackageManager.Instance;
// this.objectGroup = GetComponentsInChildren<ObjectGroup>();
this.pack.onLoaded += pack_onLoaded;
}
public void InstallPackageAddsAllFilesToFileSystem()
{
// Arrange
var projectSystem = new MockProjectSystem();
var sourceRepository = new MockPackageRepository();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new PackageManager(sourceRepository, pathResolver, projectSystem,
new SharedPackageRepository(pathResolver, projectSystem, projectSystem));
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
new[] { "contentFile", @"sub\contentFile" },
new[] { @"lib\reference.dll" },
new[] { @"readme.txt" });
sourceRepository.AddPackage(packageA);
// Act
Install("A", new NullProjectManager(packageManager));
// Assert
Assert.Equal(0, projectSystem.References.Count);
Assert.Equal(5, projectSystem.Paths.Count);
Assert.True(projectSystem.FileExists(@"A.1.0\content\contentFile"));
Assert.True(projectSystem.FileExists(@"A.1.0\content\sub\contentFile"));
Assert.True(projectSystem.FileExists(@"A.1.0\lib\reference.dll"));
Assert.True(projectSystem.FileExists(@"A.1.0\tools\readme.txt"));
Assert.True(projectSystem.FileExists(@"A.1.0\A.1.0.nupkg"));
}
public override void ExecuteCommand()
{
var feedUrl = DefaultFeedUrl;
if (!String.IsNullOrEmpty(Source)) {
feedUrl = Source;
}
IPackageRepository packageRepository = RepositoryFactory.CreateRepository(new PackageSource(feedUrl));
// Use the passed in install path if any, and default to the current dir
string installPath = OutputDirectory ?? Directory.GetCurrentDirectory();
var packageManager = new PackageManager(packageRepository,
new DefaultPackagePathResolver(installPath, useSideBySidePaths: !ExcludeVersion),
new PhysicalFileSystem(installPath));
packageManager.Logger = Console;
// If the first argument is a packages.config file, install everything it lists
// Otherwise, treat the first argument as a package Id
if (Path.GetFileName(Arguments[0]).Equals(PackageReferenceRepository.PackageReferenceFile, StringComparison.OrdinalIgnoreCase)) {
InstallPackagesFromConfigFile(packageManager, installPath);
}
else {
string packageId = Arguments[0];
Version version = Version != null ? new Version(Version) : null;
packageManager.InstallPackage(packageId, version);
}
}
public static InstallationDefinition InstallationDefinition(PackageManager packageManager, string visualStudioVersion)
{
var isVisualStudioInstalled = VisualStudioDetecter.InstalledVersions.Contains(visualStudioVersion);
var packageName = string.Format("ServiceMatrix.{0}.install", visualStudioVersion);
var isChocolateyPackageInstalled = packageManager.IsInstalled(packageName);
return GetInstallationDefinition(visualStudioVersion, isVisualStudioInstalled, isChocolateyPackageInstalled, packageName);
}
private IEnumerable<ITaskItem> ResolvePackage(ITaskItem package)
{
string id = package.ItemSpec;
string version = package.GetMetadata("Version");
Log.LogMessage(MessageImportance.Normal, "Resolving Package Reference {0} {1}...", id, version);
// Initial version just searches a machine-level repository
var localFs = new PhysicalFileSystem(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Lib"));
var defaultResolver = new DefaultPackagePathResolver(localFs);
var machineRepo = new LocalPackageRepository(defaultResolver, localFs);
var buildRepo = new BuildPackageRepository();
var remoteRepo = new DataServicePackageRepository(new Uri("https://nuget.org/api/v2"));
var project = new BuildProjectSystem(ProjectDirectory, new FrameworkName(TargetFramework), CurrentReferences);
var manager = new PackageManager(remoteRepo, defaultResolver, localFs, machineRepo);
var projectManager = new ProjectManager(remoteRepo, defaultResolver, project, buildRepo);
// Install the package
var ver = new SemanticVersion(version);
manager.PackageInstalling += manager_PackageInstalling;
manager.InstallPackage(id, ver);
projectManager.AddPackageReference(id, ver);
return project.OutputReferences.Select(item =>
{
var name = AssemblyName.GetAssemblyName(item);
return new TaskItem(name.FullName, new Dictionary<string, string>() {
{"HintPath", item },
{"Private", "true"}
});
});
}
/// <summary>
/// Uninstall package
/// </summary>
/// <param name="pkgId"></param>
/// <returns></returns>
public static JsonResponse UninstallPackage(string pkgId)
{
try
{
var packageManager = new PackageManager(
_repository,
new DefaultPackagePathResolver(BlogSettings.Instance.GalleryFeedUrl),
new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages"))
);
var package = _repository.FindPackage(pkgId);
if (package == null)
return new JsonResponse { Success = false, Message = "Package " + pkgId + " not found" };
packageManager.UninstallPackage(package, true);
FileSystem.UninstallPackage(package.Id);
BlogService.DeletePackage(pkgId);
// reset cache
Blog.CurrentInstance.Cache.Remove(Constants.CacheKey);
Utils.Log(string.Format("Uninstalled package {0} by {1}", pkgId, Security.CurrentUser.Identity.Name));
}
catch (Exception ex)
{
Utils.Log("BlogEngine.Core.Packaging.Installer.UninstallPackage(" + pkgId + ")", ex);
return new JsonResponse { Success = false, Message = "Error uninstalling package, see logs for details" };
}
return new JsonResponse { Success = true, Message = "Package successfully uninstalled" };
}
public void ExistsTest( )
{
Device device = GetFirstDevice ( );
PackageManager pm = new PackageManager ( device );
Assert.True ( pm.Exists ( "com.android.contacts" ) );
Assert.False ( pm.Exists ( "foo.bar.package" ) );
}
public static bool IsKitKatWithStepCounter(PackageManager pm)
{
// Require at least Android KitKat
int currentApiVersion = (int)Build.VERSION.SdkInt;
// Check that the device supports the step counter and detector sensors
return currentApiVersion >= 19
&& pm.HasSystemFeature (Android.Content.PM.PackageManager.FeatureSensorStepCounter);
}
public void TestFixtureSetUp()
{
_mockFileSystem = new MockFileSystem();
_packageManager = new PackageManager(
AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(Utilities.GetFactory(),
Utilities.GetSourceProvider(),
new List<string>() { "Dev" }),
new DefaultPackagePathResolver(_mockFileSystem), _mockFileSystem);
}
public InstallingViewModel(PackageDefinitionService packageDefinitionDiscovery, ChocolateyInstaller chocolateyInstaller, IEventAggregator eventAggregator, PackageManager packageManager, IWindowManager windowManager, PowerShellRunner powerShellRunner, List<string> itemsToInstall)
{
PackageDefinitionService = packageDefinitionDiscovery;
this.chocolateyInstaller = chocolateyInstaller;
this.eventAggregator = eventAggregator;
this.packageManager = packageManager;
this.windowManager = windowManager;
this.powerShellRunner = powerShellRunner;
this.itemsToInstall = itemsToInstall;
}
public void RefreshPackagesTest( )
{
Device device = GetFirstDevice ( );
PackageManager pm = new PackageManager ( device );
pm.RefreshPackages ( );
Assert.IsTrue ( pm.Packages.ContainsKey ( "com.android.contacts" ) );
Assert.IsTrue ( pm.Packages.ContainsKey ( "android" ) ); // the framework
}
public static InstallationDefinition InstallationDefinition(PackageManager packageManager)
{
var versionsToInstall = VisualStudioDetecter.InstalledVersions.Where(version => supportedVersions.Contains(version));
var installationDefinition = new InstallationDefinition
{
SortOrder = 20,
Name = "ServiceMatrix",
Image = "/Images/SM.png",
Disabled = true,
ToolTip = "ServiceMatrix requires Visual Studio 2012 to be installed,",
PackageDefinitions = new List<PackageDefinition>(),
SelectedByDefault = false
};
foreach (var version in versionsToInstall)
{
var packageName = "ServiceMatrix." + version + ".install";
if (packageManager.IsInstalled(packageName))
{
continue;
}
installationDefinition.PackageDefinitions.Add(new PackageDefinition
{
Name =packageName,
DisplayName = "ServiceMatrix for " + version
});
}
if (installationDefinition.PackageDefinitions.Any())
{
installationDefinition.Status = "Install";
installationDefinition.SelectedByDefault = true;
installationDefinition.Disabled = false;
installationDefinition.ToolTip = "Install ServiceMatrix";
}
else
{
if (versionsToInstall.Any())
{
installationDefinition.Status = "Already installed";
installationDefinition.ToolTip = "ServiceMatrix for Visual Studio 2012";
}
else
{
installationDefinition.Status = "VS 2012 required";
installationDefinition.ToolTip = "ServiceMatrix requires Visual Studio 2012";
}
}
return installationDefinition;
}
public void RefreshPackagesTest( )
{
Device device = GetFirstDevice ( );
PackageManager pm = new PackageManager ( device );
Assert.DoesNotThrow ( new Assert.ThrowsDelegate ( delegate ( ) {
pm.RefreshPackages ( );
} ) );
Assert.True ( pm.Packages.ContainsKey ( "com.android.contacts" ) );
Assert.True ( pm.Packages.ContainsKey ( "android" ) ); // the framework
}
public void Execute(IPackage package, string packagePath)
{
var dialog = new OpenFileDialog();
var result = dialog.ShowDialog();
if (result == DialogResult.OK)
{
var provider = new EnvironmentProvider();
var packageManager = new PackageManager(provider);
packageManager.ConfigurePackage(packagePath, dialog.FileNames[0], @"c:\temp\packageexplorer");
}
}
internal bool AppToTakePicturesExists(PackageManager pkgManager)
{
// Check if there is an application that can take pictures
var intent = new Intent (MediaStore.ActionImageCapture);
IList<ResolveInfo> availableActivities = pkgManager.QueryIntentActivities (intent, PackageInfoFlags.MatchDefaultOnly);
foreach (var item in availableActivities) {
Log.Info ("AVAILABLE CAMERA APPS", item.ToString());
}
return availableActivities != null && availableActivities.Count > 0;
}
public NuGetDownloader(string nugetName, IEnumerable<string> repositories)
{
package = nugetName;
var nugetCacheDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Cache");
var reposToUse = new List<IPackageRepository>
{
PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory)
};
reposToUse.AddRange(repositories.ToList().Select(r => PackageRepositoryFactory.Default.CreateRepository(r)));
var repo = new AggregateRepository(reposToUse);
packageManager = new PackageManager(repo, "packages");
}
public void UninstallingPackageWithNoDependents()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
var package = PackageUtility.CreatePackage("foo", "1.2.33");
localRepository.AddPackage(package);
// Act
packageManager.UninstallPackage("foo");
// Assert
Assert.False(packageManager.LocalRepository.Exists(package));
}
public IPackageInstaller CreatePackageInstaller(string installationPath, string configurationPath)
{
var packagePath = this.configurationManager.PackagePath;
var sourceRepository = this.source.CreatePackageRepository();
var logger = new PackageLogger();
var packagePathResolver = new DefaultPackagePathResolver(packagePath);
var fileSystem = new PhysicalFileSystem(installationPath ?? this.directorySystem.CurrentDirectory) { Logger = logger };
var destinationRepository = new LocalPackageRepository(packagePath);
var manager = new PackageManager(
sourceRepository, packagePathResolver, fileSystem, destinationRepository) { Logger = logger };
var powerShellPackageFile = new PowerShellPackageFile(
new BackgroundProcess(),
manager,
new PhysicalFileSystem(this.directorySystem.TemporaryPath),
configurationPath);
return new DefaultPackageInstaller(manager, powerShellPackageFile, logger);
}
/// <summary>
/// Install package
/// </summary>
/// <param name="pkgId"></param>
public static JsonResponse InstallPackage(string pkgId)
{
try
{
if(BlogService.InstalledFromGalleryPackages() != null &&
BlogService.InstalledFromGalleryPackages().Find(p => p.PackageId == pkgId) != null)
UninstallPackage(pkgId);
var packageManager = new PackageManager(
_repository,
new DefaultPackagePathResolver(BlogSettings.Instance.GalleryFeedUrl),
new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages"))
);
var package = _repository.FindPackage(pkgId);
packageManager.InstallPackage(package, false, true);
var iPkg = new InstalledPackage { PackageId = package.Id, Version = package.Version.ToString() };
BlogService.InsertPackage(iPkg);
var packageFiles = FileSystem.InstallPackage(package.Id, package.Version.ToString());
BlogService.InsertPackageFiles(packageFiles);
Blog.CurrentInstance.Cache.Remove(Constants.CacheKey);
Utils.Log(string.Format("Installed package {0} by {1}", pkgId, Security.CurrentUser.Identity.Name));
}
catch (Exception ex)
{
Utils.Log("BlogEngine.Core.Packaging.Installer.InstallPackage(" + pkgId + ")", ex);
try
{
UninstallPackage(pkgId);
}
catch (Exception)
{
// just trying to clean up if package did not installed properly
}
return new JsonResponse { Success = false, Message = "Error installing package, see logs for details" };
}
return new JsonResponse { Success = true, Message = "Package successfully installed" };
}
public static int Main(string[] args)
{
Console.WriteLine("Copyright (c) Microsoft Corporation. All rights reserved.");
Console.WriteLine("FindPackagesWithPackageTypes sample");
Console.WriteLine();
PackageManager packageManager = new PackageManager();
try
{
PackageTypes type = PackageTypes.Main;
IEnumerable<Package> packages = (IEnumerable<Package>) packageManager.FindPackagesWithPackageTypes(type);
int packageCount = 0;
foreach (var package in packages)
{
DisplayPackageInfo(package);
Console.WriteLine();
packageCount += 1;
}
if (packageCount < 1)
{
Console.WriteLine("No packages were found.");
}
}
catch (UnauthorizedAccessException)
{
Console.WriteLine("packageManager.FindPackagesWithPackageTypes() failed because access was denied. This program must be run from an elevated command prompt.");
return 1;
}
catch (Exception ex)
{
Console.WriteLine("packageManager.FindPackagesWithPackageTypes() failed, error message: {0}", ex.Message);
Console.WriteLine("Full Stacktrace: {0}", ex.ToString());
return 1;
}
return 0;
}
/// <summary>
/// Install package
/// </summary>
/// <param name="pkgId"></param>
public static bool InstallPackage(string pkgId)
{
try
{
// if package already installed - uninstall it
if (BlogService.InstalledFromGalleryPackages() != null)
{
if(BlogService.InstalledFromGalleryPackages().Find(p => p.PackageId == pkgId) != null)
{
UninstallPackage(pkgId);
}
}
var packageManager = new PackageManager( _repository,
new DefaultPackagePathResolver(BlogConfig.GalleryFeedUrl),
new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages"))
);
var package = _repository.FindPackage(pkgId);
packageManager.InstallPackage(package, false, true);
var iPkg = new InstalledPackage { PackageId = package.Id, Version = package.Version.ToString() };
BlogService.InsertPackage(iPkg);
var packageFiles = FileSystem.InstallPackage(package);
BlogService.InsertPackageFiles(packageFiles);
Blog.CurrentInstance.Cache.Remove(Constants.CacheKey);
CustomFieldsParser.ClearCache();
Utils.Log(string.Format("Installed package {0} by {1}", pkgId, Security.CurrentUser.Identity.Name));
}
catch (Exception ex)
{
Utils.Log("BlogEngine.Core.Packaging.Installer.InstallPackage(" + pkgId + ")", ex);
UninstallPackage(pkgId);
throw;
}
return true;
}
public bool CanDetermineVersionlessPackageIsInstalled(string id, string onDiskVersion, string packageVersion, bool installedUsingMultipleVersion, bool currentlyAllowMultipleVersions, bool exhaustive)
{
var mfs = new Mock<MockFileSystem>() { CallBase = true };
mfs.Setup(m => m.Root).Returns(@"c:\packages");
var installPathResolver = new DefaultPackagePathResolver(mfs.Object, installedUsingMultipleVersion);
var currentPathResolver = new DefaultPackagePathResolver(mfs.Object, currentlyAllowMultipleVersions);
var testPackage = new DataServicePackage()
{
Version = packageVersion,
Id = id
};
var filePackage = new DataServicePackage()
{
Version = onDiskVersion,
Id = id
};
IPackage zipPackage = null;
if (!string.IsNullOrEmpty(onDiskVersion))
{
string baseLocation = installPathResolver.GetInstallPath(filePackage);
string fileName = installPathResolver.GetPackageFileName(filePackage.Id, SemanticVersion.Parse(filePackage.Version));
string filePath = Path.Combine(baseLocation, fileName);
zipPackage = PackageUtility.GetZipPackage(filePackage.Id, filePackage.Version);
mfs.Setup(m => m.FileExists(filePath)).Returns(true);
mfs.Setup(m => m.OpenFile(filePath)).Returns(zipPackage.GetStream());
mfs.Object.AddFile(filePath, zipPackage.GetStream());
}
var pm = new PackageManager(new MockPackageRepository(), currentPathResolver, mfs.Object);
var exists = pm.IsPackageInstalled(testPackage,exhaustive: exhaustive);
//var test = testPackage.IsPackageInstalled(allowMultipleVersions, pm, mfs.Object);
return exists;
}
public void InstallingPackageWithUnknownDependencyAndIgnoreDepencenciesInstallsPackageWithoutDependencies()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository);
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("C")
});
IPackage packageC = PackageUtility.CreatePackage("C", "1.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
// Act
packageManager.InstallPackage("A", version: null, ignoreDependencies: true, allowPrereleaseVersions: true);
// Assert
Assert.True(localRepository.Exists(packageA));
Assert.False(localRepository.Exists(packageC));
}
public void ApproveNServiceBus()
{
var packages = new[]
{
"4.6.4", "5.0.0-beta0004"
};
var nugetCacheDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Cache");
var repo = new AggregateRepository(new[]
{
PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory),
PackageRepositoryFactory.Default.CreateRepository("https://www.nuget.org/api/v2"),
PackageRepositoryFactory.Default.CreateRepository("https://www.myget.org/F/particular/"),
});
var packageManager = new PackageManager(repo, "packages");
foreach (var v in packages)
{
if (!Directory.Exists(Path.Combine("packages", "NServiceBus." + v)))
packageManager.InstallPackage("NServiceBus", SemanticVersion.Parse(v));
}
var file1 = Path.Combine("packages", "NServiceBus." + packages[0], "lib", "net40", "NServiceBus.Core.dll");
var file2 = Path.Combine("packages", "NServiceBus." + packages[1], "lib", "net45", "NServiceBus.Core.dll");
var engine = new ComparerEngine();
var diff = engine.CreateDiff(file1, file2);
var stringBuilder = new StringWriter();
var formatter = new APIUpgradeToMarkdownFormatter();
formatter.WriteOut(diff, stringBuilder, new FormattingInfo(string.Empty, string.Empty));
Approvals.Verify(stringBuilder.ToString());
}
public static bool CheckIfPackageFamilyNameExist(string PackageFamilyName)
{
PackageManager Manager = new PackageManager();
return(Manager.FindPackagesForUserWithPackageTypes(string.Empty, PackageFamilyName, PackageTypes.Main).Any());
}
/// <summary> Creates skeletal source code (without correct data structure but no business
/// logic) for all data types found in the normative database. For versions > 2.2, Primitive data types
/// are not generated, because they are coded manually (as of HAPI 0.3).
/// </summary>
public static void makeAll(System.String baseDirectory, System.String version)
{
//make base directory
if (!(baseDirectory.EndsWith("\\") || baseDirectory.EndsWith("/")))
{
baseDirectory = baseDirectory + "/";
}
System.IO.FileInfo targetDir = SourceGenerator.makeDirectory(baseDirectory + PackageManager.GetVersionPackagePath(version) + "Datatype");
SourceGenerator.makeDirectory(baseDirectory + PackageManager.GetVersionPackagePath(version) + "Datatype");
//get list of data types
System.Collections.ArrayList types = new System.Collections.ArrayList();
System.Data.OleDb.OleDbConnection conn = NormativeDatabase.Instance.Connection;
System.Data.OleDb.OleDbCommand stmt = SupportClass.TransactionManager.manager.CreateStatement(conn);
//get normal data types ...
System.Data.OleDb.OleDbCommand temp_OleDbCommand;
temp_OleDbCommand = stmt;
temp_OleDbCommand.CommandText = "select data_type_code from HL7DataTypes, HL7Versions where HL7Versions.version_id = HL7DataTypes.version_id and HL7Versions.hl7_version = '" + version + "'";
System.Data.OleDb.OleDbDataReader rs = temp_OleDbCommand.ExecuteReader();
while (rs.Read())
{
types.Add(System.Convert.ToString(rs[1 - 1]));
}
rs.Close();
//get CF, CK, CM, CN, CQ sub-types ...
System.Data.OleDb.OleDbCommand temp_OleDbCommand2;
temp_OleDbCommand2 = stmt;
temp_OleDbCommand2.CommandText = "select data_structure from HL7DataStructures, HL7Versions where (" + "data_type_code = 'CF' or " + "data_type_code = 'CK' or " + "data_type_code = 'CM' or " + "data_type_code = 'CN' or " + "data_type_code = 'CQ') and " + "HL7Versions.version_id = HL7DataStructures.version_id and HL7Versions.hl7_version = '" + version + "'";
rs = temp_OleDbCommand2.ExecuteReader();
while (rs.Read())
{
types.Add(System.Convert.ToString(rs[1 - 1]));
}
stmt.Dispose();
NormativeDatabase.Instance.returnConnection(conn);
System.Console.Out.WriteLine("Generating " + types.Count + " datatypes for version " + version);
if (types.Count == 0)
{
log.Warn("No version " + version + " data types found in database " + conn.Database);
}
for (int i = 0; i < types.Count; i++)
{
if (!((String)types[i]).Equals("*"))
{
make(targetDir, (System.String)types[i], version);
}
}
}
public PackageOperationData(PackageManager manager, PackageInfo package, Action <PackageOperationData> operation)
{
this.manager = manager;
this.package = package;
this.operation = operation;
}
private void UpdateInfoArea()
{
PackageInfo itemInfo = this.selectedItem != null ? this.selectedItem.ItemPackageInfo : null;
PackageInfo installedInfo = this.selectedItem != null ? this.selectedItem.InstalledPackageInfo : null;
PackageInfo newestInfo = this.selectedItem != null ? this.selectedItem.NewestPackageInfo : null;
this.SuspendLayout();
if (itemInfo == null)
{
this.labelPackageTitle.Text = PackageManagerFrontendRes.NoPackageSelected;
this.labelPackageId.Text = null;
this.labelPackageDesc.Text = PackageManagerFrontendRes.NoDescAvailable;
this.labelPackageAuthor.Text = null;
this.labelPackageTags.Text = null;
this.labelPackageVersion.Text = null;
this.labelPackageUpdated.Text = null;
this.labelPackageWebsite.Text = null;
this.labelPackageLicense.Text = null;
this.textBoxReleaseNotes.Text = null;
}
else
{
bool isItemInstalled = installedInfo != null;
bool isItemUpdatable = isItemInstalled && newestInfo != null && installedInfo.Version < newestInfo.Version;
string releaseNoteText = (isItemUpdatable && !string.IsNullOrWhiteSpace(newestInfo.ReleaseNotes)) ? newestInfo.ReleaseNotes : string.Empty;
if (!string.IsNullOrWhiteSpace(releaseNoteText))
{
releaseNoteText = Regex.Replace(releaseNoteText, @"\r\n?|\n", Environment.NewLine);
}
string websiteLinkCaption = itemInfo.ProjectUrl != null ? itemInfo.ProjectUrl.Host : string.Empty;
string licenseLinkCaption = itemInfo.LicenseUrl != null ? itemInfo.LicenseUrl.Host : string.Empty;
if (!string.IsNullOrWhiteSpace(websiteLinkCaption))
{
websiteLinkCaption = string.Format(PackageManagerFrontendRes.ItemName_VisitLinkUrl, websiteLinkCaption);
}
if (!string.IsNullOrWhiteSpace(licenseLinkCaption))
{
licenseLinkCaption = string.Format(PackageManagerFrontendRes.ItemName_VisitLinkUrl, licenseLinkCaption);
}
this.labelPackageTitle.Text = !string.IsNullOrWhiteSpace(itemInfo.Title) ? itemInfo.Title : itemInfo.Id;
this.labelPackageId.Text = itemInfo.Id;
this.labelPackageDesc.Text = itemInfo.Description;
this.labelPackageAuthor.Text = itemInfo.Authors.ToString(", ");
this.labelPackageTags.Text = itemInfo.Tags.Except(InvisibleTags).ToString(", ");
this.labelPackageUpdated.Text = itemInfo.PublishDate.ToString("yyyy-MM-dd, HH:mm", System.Globalization.CultureInfo.InvariantCulture);
this.labelPackageWebsite.Text = websiteLinkCaption;
this.labelPackageWebsite.Tag = itemInfo.ProjectUrl;
this.labelPackageLicense.Text = licenseLinkCaption;
this.labelPackageLicense.Tag = itemInfo.LicenseUrl;
this.textBoxReleaseNotes.Text = releaseNoteText;
this.labelPackageVersion.Text = isItemUpdatable ?
string.Format("{0} --> {1}",
PackageManager.GetDisplayedVersion(installedInfo.Version),
PackageManager.GetDisplayedVersion(newestInfo.Version)) :
PackageManager.GetDisplayedVersion(itemInfo.Version);
}
this.labelPackageAuthor.Visible = !string.IsNullOrWhiteSpace(this.labelPackageAuthor.Text);
this.labelPackageTags.Visible = !string.IsNullOrWhiteSpace(this.labelPackageTags.Text);
this.labelPackageVersion.Visible = !string.IsNullOrWhiteSpace(this.labelPackageVersion.Text);
this.labelPackageUpdated.Visible = !string.IsNullOrWhiteSpace(this.labelPackageUpdated.Text);
this.labelPackageWebsite.Visible = !string.IsNullOrWhiteSpace(this.labelPackageWebsite.Text);
this.labelPackageLicense.Visible = !string.IsNullOrWhiteSpace(this.labelPackageLicense.Text);
this.textBoxReleaseNotes.Visible = !string.IsNullOrWhiteSpace(this.textBoxReleaseNotes.Text);
this.labelPackageAuthorCaption.Visible = this.labelPackageAuthor.Visible;
this.labelPackageTagsCaption.Visible = this.labelPackageTags.Visible;
this.labelPackageVersionCaption.Visible = this.labelPackageVersion.Visible;
this.labelPackageUpdatedCaption.Visible = this.labelPackageUpdated.Visible;
this.labelPackageWebsiteCaption.Visible = this.labelPackageWebsite.Visible;
this.labelPackageLicenseCaption.Visible = this.labelPackageLicense.Visible;
this.labelReleaseNotesCaption.Visible = this.textBoxReleaseNotes.Visible;
this.ResumeLayout();
}
public PackageManagerWrapper()
{
_packageManager = new PackageManager();
}
public CreateMethodViewModel(
IAuthenticationManager authenticationManager,
IDialogFactory dialogFactory,
IProjectConfiguraiton projectConfiguration,
TemplateLoader templateLoader,
PackageManager packageManager,
IProjectManager projectManager,
IArasDataProvider arasDataProvider,
ICodeProvider codeProvider,
IGlobalConfiguration userConfiguration,
MessageManager messageManager)
{
if (authenticationManager == null)
{
throw new ArgumentNullException(nameof(authenticationManager));
}
if (dialogFactory == null)
{
throw new ArgumentNullException(nameof(dialogFactory));
}
if (projectConfiguration == null)
{
throw new ArgumentNullException(nameof(projectConfiguration));
}
if (templateLoader == null)
{
throw new ArgumentNullException(nameof(templateLoader));
}
if (packageManager == null)
{
throw new ArgumentNullException(nameof(packageManager));
}
if (projectManager == null)
{
throw new ArgumentNullException(nameof(projectManager));
}
if (arasDataProvider == null)
{
throw new ArgumentNullException(nameof(arasDataProvider));
}
if (codeProvider == null)
{
throw new ArgumentNullException(nameof(codeProvider));
}
if (userConfiguration == null)
{
throw new ArgumentNullException(nameof(userConfiguration));
}
if (messageManager == null)
{
throw new ArgumentNullException(nameof(messageManager));
}
this.authenticationManager = authenticationManager;
this.dialogFactory = dialogFactory;
this.projectConfiguration = projectConfiguration;
this.templateLoader = templateLoader;
this.packageManager = packageManager;
this.projectManager = projectManager;
this.arasDataProvider = arasDataProvider;
this.codeProvider = codeProvider;
this.globalConfiguration = userConfiguration;
this.messageManager = messageManager;
this.isUseVSFormattingCode = projectConfiguration.UseVSFormatting;
this.UserCodeTemplates = LoadUserCodeTemplates();
this.SelectedUserCodeTemplate = this.userCodeTemplates.First();
this.methodItemTypeInfo = arasDataProvider.GetMethodItemTypeInfo();
this.MethodNameMaxLength = methodItemTypeInfo.NameStoredLength;
this.MethodCommentMaxLength = methodItemTypeInfo.CommentsStoredLength;
actionLocations = new ObservableCollection <ListInfo>();
foreach (var localtion in Utilities.Utils.GetValueListByName(authenticationManager.InnovatorInstance, "Action Locations"))
{
string value = localtion.getProperty("value", string.Empty);
if (string.Equals(value, "client"))
{
continue;
}
actionLocations.Add(new ListInfo(value, localtion.getProperty("label", string.Empty)));
}
allLanguages = new List <FilteredListInfo>();
foreach (var language in Utilities.Utils.GetFilterValueListByName(authenticationManager.InnovatorInstance, "Method Types"))
{
string value = language.getProperty("value");
string label = language.getProperty("label");
string filter = language.getProperty("filter");
if (string.Equals(filter, "server", StringComparison.CurrentCultureIgnoreCase) && !string.Equals(value, this.codeProvider.Language, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
allLanguages.Add(new FilteredListInfo(value, label, filter));
}
SelectedActionLocation = actionLocations.First(al => string.Equals(al.Value.ToLowerInvariant(), "server"));
okCommand = new RelayCommand <object>(OnOkClick, IsEnabledOkButton);
cancelCommand = new RelayCommand <object>(OnCancelClick);
closeCommand = new RelayCommand <object>(OnCloseCliked);
selectedIdentityCommand = new RelayCommand(SelectedIdentityCommandClick);
browseCodeTemplateCommand = new RelayCommand(BrowseCodeTemplateCommandClick);
deleteUserCodeTemplateCommand = new RelayCommand <KeyValuePair <string, XmlMethodInfo> >(DeleteUserCodeTemplateCommandClick);
SelectedEventSpecificData = EventSpecificData.First();
}
public void CopyLogFiles()
{
PackageManager.CopyLogFiles("ServiceControl");
}
private static bool Prefix(BuildingInfo __instance)
{
// Basic sanity check before proceeding; if failed, don't do anything here - just continue on to game method.
if (__instance.name == null)
{
return(true);
}
// Create a new building record for this prefab and add it to our lists.
var buildingData = new BuildingData
{
prefab = __instance,
name = __instance.name,
density = Loading.xmlManager.SetPrefabDensity(__instance),
category = Loading.xmlManager.AssignCategory(__instance),
};
Loading.xmlManager.prefabHash[__instance] = buildingData;
// Add to broken prefabs list (will be removed later if it's not broken).
Loading.brokenPrefabs.Add(__instance);
// Search for PloppableRICODefinition.xml files with this asset.
// Need to use FindAssetByName(string, AssetType) because FindAssetByName(string) doesn't catch all assets at this stage of initialisation
// (those two methods are more different than you might think - discovered that the hard way).
Package.Asset asset = PackageManager.FindAssetByName(__instance.name, Package.AssetType.Object);
if (asset?.package?.packagePath != null)
{
// Get custom asset filesystem location (if CRP pacakge).
string crpPath = asset.package.packagePath;
// Look for RICO settings file.
string ricoDefPath = Path.Combine(Path.GetDirectoryName(crpPath), "PloppableRICODefinition.xml");
if (File.Exists(ricoDefPath))
{
// Parse the file.
var tempRicoDef = RICOReader.ParseRICODefinition(asset.package.packageName, ricoDefPath);
if (tempRicoDef != null)
{
foreach (var buildingDef in tempRicoDef.Buildings)
{
// Go through each building parsed and check to see if we've got a match for this prefab.
if (MatchRICOName(buildingDef.name, __instance.name, asset.package.packageName))
{
// Match! Add these author settings to our prefab dictionary.
Debugging.OptionalMessage("found author settings for " + buildingDef.name);
Loading.xmlManager.prefabHash[__instance].author = buildingDef;
Loading.xmlManager.prefabHash[__instance].hasAuthor = true;
}
}
}
}
}
// Check for and add any local settings for this prefab to our list.
if (Loading.localRicoDef != null)
{
// Step through our previously loaded local settings and see if we've got a match.
foreach (var buildingDef in Loading.localRicoDef.Buildings)
{
if (buildingDef.name.Equals(__instance.name))
{
// Match! Add these author settings to our prefab dictionary.
Loading.xmlManager.prefabHash[__instance].local = buildingDef;
Loading.xmlManager.prefabHash[__instance].hasLocal = true;
}
}
}
// Check for any Workshop RICO mod settings for this prefab.
if (Loading.mod1RicoDef != null)
{
// Step through our previously loaded local settings and see if we've got a match.
foreach (var buildingDef in Loading.mod1RicoDef.Buildings)
{
if (buildingDef.name.Equals(__instance.name))
{
// Match! Add these author settings to our prefab dictionary.
Loading.xmlManager.prefabHash[__instance].mod = buildingDef;
Loading.xmlManager.prefabHash[__instance].hasMod = true;
}
}
}
// Check for Modern Japan CCP mod settings for this prefab.
if (Loading.mod2RicoDef != null)
{
// Step through our previously loaded local settings and see if we've got a match.
foreach (var buildingDef in Loading.mod2RicoDef.Buildings)
{
if (buildingDef.name.Equals(__instance.name))
{
// Match! Add these author settings to our prefab dictionary.
Loading.xmlManager.prefabHash[__instance].mod = buildingDef;
Loading.xmlManager.prefabHash[__instance].hasMod = true;
}
}
}
// Apply appropriate RICO settings to prefab.
if (Loading.convertPrefabs != null)
{
// Start with local settings.
if (Loading.xmlManager.prefabHash[__instance].hasLocal)
{
// If local settings disable RICO, dont convert.
if (Loading.xmlManager.prefabHash[__instance].local.ricoEnabled)
{
Loading.convertPrefabs.ConvertPrefab(Loading.xmlManager.prefabHash[__instance].local, __instance);
}
}
// If no local settings, apply author settings.
else if (Loading.xmlManager.prefabHash[__instance].hasAuthor)
{
// If author settings disable RICO, dont convert.
if (Loading.xmlManager.prefabHash[__instance].author.ricoEnabled)
{
Loading.convertPrefabs.ConvertPrefab(Loading.xmlManager.prefabHash[__instance].author, __instance);
}
}
// If none of the above, apply mod settings.
else if (Loading.xmlManager.prefabHash[__instance].hasMod)
{
// If mod settings disable RICO, dont convert.
if (Loading.xmlManager.prefabHash[__instance].mod.ricoEnabled)
{
Loading.convertPrefabs.ConvertPrefab(Loading.xmlManager.prefabHash[__instance].mod, __instance);
}
}
else
{
// No RICO settings; replicate game InitializePrefab checks overridden by transpiler.
int privateServiceIndex = ItemClass.GetPrivateServiceIndex(__instance.m_class.m_service);
if (privateServiceIndex != -1)
{
if (__instance.m_placementStyle == ItemClass.Placement.Manual)
{
throw new PrefabException(__instance, "Private building cannot have manual placement style");
}
if (__instance.m_paths != null && __instance.m_paths.Length != 0)
{
throw new PrefabException(__instance, "Private building cannot include roads or other net types");
}
}
}
}
else
{
// This means that there's been a significant failure. Ploppable RICO settings can't be applied.
Debugging.Message("convertPrefabs not initialised");
}
// If we've made it this far, the patch is working fine - set the watchdog flag to confirm.
Loading.patchOperating = true;
// Continue on to execute game InitializePrefab.
return(true);
}
private bool IsPackageInstalledInProject(Project project, IPackage package)
{
IProjectManager projectManager = PackageManager.GetProjectManager(project);
return(projectManager != null && projectManager.IsInstalled(package));
}
private static string GetClassSource(string dataType, string version)
{
string namespaceName = PackageManager.GetVersionPackageName(version);
namespaceName = namespaceName.Substring(0, namespaceName.Length - 1);
string baseClass = "NHapi.Base.Model.Primitive." + dataType;
if (dataType.Equals("ST"))
{
baseClass = "AbstractPrimitive";
}
StringBuilder sb = new StringBuilder();
sb.Append("using System;\n\n");
sb.Append("using NHapi.Base.Model;\n");
sb.Append("namespace " + namespaceName + ".Datatype\n");
sb.Append("{\n");
sb.Append("/// <summary>");
sb.Append("/// Summary description for " + dataType + ".\n");
sb.Append("/// </summary>\n");
sb.Append("public class " + dataType + ": " + baseClass + "\n");
sb.Append("{\n");
sb.Append("/// <summary>Return the version\n");
sb.Append("/// <returns>" + version + "</returns>\n");
sb.Append("///</summary>\r\n");
sb.Append(@"
virtual public System.String Version
{
get
{
return """ + version + @""";
}
}
");
if (dataType.Equals("ID") || dataType.Equals("IS"))
{
sb.Append("\n\n");
sb.Append(@"
///<summary>Construct the type
///<param name=""theMessage"">message to which this Type belongs</param>
///<param name=""theTable"">The table which this type belongs</param>
///</summary>
public " + dataType + @"(IMessage theMessage,int theTable):base(theMessage, theTable)
{}
");
sb.Append("\n\n");
sb.Append(@"
///<summary>Construct the type
///<param name=""message"">message to which this Type belongs</param>
///<param name=""theTable"">The table which this type belongs</param>
///<param name=""description"">The description of this type</param>
///</summary>
public " + dataType +
@"(IMessage message, int theTable, string description) : base(message,theTable, description)
{}
");
}
else
{
sb.Append("\n\n");
sb.Append(@"
///<summary>Construct the type
///<param name=""theMessage"">message to which this Type belongs</param>
///</summary>
public " + dataType + @"(IMessage theMessage):base(theMessage)
{}
");
sb.Append("\n\n");
sb.Append(@"
///<summary>Construct the type
///<param name=""message"">message to which this Type belongs</param>
///<param name=""description"">The description of this type</param>
///</summary>
public " + dataType + @"(IMessage message, string description) : base(message,description)
{}
");
}
sb.Append("}\r");
sb.Append("}\r");
return(sb.ToString());
}
public async Task CanRunDiscoveryTool()
{
string testDir = TestUtils.CreateTemporaryFolder();
using var packageManager = new PackageManager();
string packageLocation = packageManager.PackTestTemplatesNuGetPackage();
packageLocation = await packageManager.GetNuGetPackage("Microsoft.Azure.WebJobs.ProjectTemplates").ConfigureAwait(false);
new DotnetCommand(
_log,
"Microsoft.TemplateSearch.TemplateDiscovery.dll",
"--basePath",
testDir,
"--packagesPath",
Path.GetDirectoryName(packageLocation),
"-v")
.Execute()
.Should()
.ExitWith(0);
string[] cacheFilePaths = new[]
{
Path.Combine(testDir, "SearchCache", "NuGetTemplateSearchInfo.json"),
Path.Combine(testDir, "SearchCache", "NuGetTemplateSearchInfoVer2.json")
};
var settingsPath = TestUtils.CreateTemporaryFolder();
foreach (var cacheFilePath in cacheFilePaths)
{
Assert.True(File.Exists(cacheFilePath));
new DotnetNew3Command(_log)
.WithCustomHive(settingsPath)
.WithEnvironmentVariable("DOTNET_NEW_SEARCH_FILE_OVERRIDE", cacheFilePath)
.WithEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE", "true")
.Execute()
.Should()
.ExitWith(0)
.And.NotHaveStdErr();
new DotnetNew3Command(_log, "func", "--search")
.WithCustomHive(settingsPath)
.WithEnvironmentVariable("DOTNET_NEW_SEARCH_FILE_OVERRIDE", cacheFilePath)
.WithEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE", "true")
.Execute()
.Should()
.ExitWith(0)
.And.NotHaveStdErr()
.And.NotHaveStdOutContaining("Exception")
.And.HaveStdOutContaining("Microsoft.Azure.WebJobs.ProjectTemplates");
new DotnetNew3Command(_log)
.WithCustomHive(settingsPath)
.WithEnvironmentVariable("DOTNET_NEW_SEARCH_FILE_OVERRIDE", cacheFilePath)
.WithEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE", "true")
.Execute()
.Should()
.ExitWith(0)
.And.NotHaveStdErr();
new DotnetNew3Command(_log, "func", "--search")
.WithCustomHive(settingsPath)
.WithEnvironmentVariable("DOTNET_NEW_SEARCH_FILE_OVERRIDE", cacheFilePath)
.WithEnvironmentVariable("DOTNET_CLI_CONTEXT_VERBOSE", "true")
.Execute()
.Should()
.ExitWith(0)
.And.NotHaveStdErr()
.And.NotHaveStdOutContaining("Exception")
.And.HaveStdOutContaining("Microsoft.Azure.WebJobs.ProjectTemplates");
}
}
/// <summary> Returns the Java source code for a class that represents the specified segment.</summary>
public static String makeSegment(String name, String version)
{
Console.WriteLine("Making segment " + name);
StringBuilder source = new StringBuilder();
try
{
ArrayList elements = new ArrayList();
SegmentElement se;
String segDesc = null;
OdbcConnection conn = NormativeDatabase.Instance.Connection;
StringBuilder sql = new StringBuilder();
sql.Append("SELECT HL7SegmentDataElements.seg_code, HL7SegmentDataElements.seq_no, ");
sql.Append("HL7SegmentDataElements.repetitional, HL7SegmentDataElements.repetitions, ");
sql.Append("HL7DataElements.description, HL7DataElements.length_old, HL7DataElements.table_id, ");
sql.Append("HL7SegmentDataElements.req_opt, HL7Segments.description, HL7DataElements.data_structure ");
sql.Append(
"FROM HL7Versions RIGHT JOIN (HL7Segments INNER JOIN (HL7DataElements INNER JOIN HL7SegmentDataElements ");
sql.Append("ON (HL7DataElements.version_id = HL7SegmentDataElements.version_id) ");
sql.Append("AND (HL7DataElements.data_item = HL7SegmentDataElements.data_item)) ");
sql.Append("ON (HL7Segments.version_id = HL7SegmentDataElements.version_id) ");
sql.Append("AND (HL7Segments.seg_code = HL7SegmentDataElements.seg_code)) ");
sql.Append("ON (HL7Versions.version_id = HL7Segments.version_id) ");
sql.Append("WHERE HL7SegmentDataElements.seg_code = '");
sql.Append(name);
sql.Append("' and HL7Versions.hl7_version = '");
sql.Append(version);
sql.Append("' ORDER BY HL7SegmentDataElements.seg_code, HL7SegmentDataElements.seq_no;");
DbCommand stmt = TransactionManager.manager.CreateStatement(conn);
DbCommand temp_OleDbCommand;
temp_OleDbCommand = stmt;
temp_OleDbCommand.CommandText = sql.ToString();
DbDataReader rs = temp_OleDbCommand.ExecuteReader();
while (rs.Read())
{
if (segDesc == null)
{
segDesc = Convert.ToString(rs[9 - 1]);
}
se = new SegmentElement();
se.field = Convert.ToInt32(rs.GetValue(2 - 1));
se.rep = Convert.ToString(rs[3 - 1]);
if (rs.IsDBNull(4 - 1))
{
se.repetitions = 0;
}
else
{
se.repetitions = Convert.ToInt32(rs.GetValue(4 - 1));
}
if (se.repetitions == 0)
{
if (se.rep == null || !se.rep.ToUpper().Equals("Y".ToUpper()))
{
se.repetitions = 1;
}
}
se.desc = Convert.ToString(rs[5 - 1]);
if (!rs.IsDBNull(6 - 1))
{
se.length = DetermineLength(rs);
}
se.table = Convert.ToInt32(rs.GetValue(7 - 1));
se.opt = Convert.ToString(rs[8 - 1]);
se.type = Convert.ToString(rs[10 - 1]);
//shorten CE_x to CE
if (se.type.StartsWith("CE"))
{
se.type = "CE";
}
elements.Add(se);
/*System.out.println("Segment: " + name + " Field: " + se.field + " Rep: " + se.rep +
* " Repetitions: " + se.repetitions + " Desc: " + se.desc + " Length: " + se.length +
* " Table: " + se.table + " Segment Desc: " + segDesc);*/
}
rs.Close();
stmt.Dispose();
NormativeDatabase.Instance.returnConnection(conn);
//write imports, class documentation, etc ...
source.Append("using System;\r\n");
source.Append("using NHapi.Base;\r\n");
source.Append("using NHapi.Base.Parser;\r\n");
source.Append("using NHapi.Base.Model;\r\n");
source.Append("using ");
source.Append((string)PackageManager.GetVersionPackageName(version));
source.Append("Datatype;\r\n");
source.Append("using NHapi.Base.Log;\r\n\r\n");
source.Append("namespace ");
source.Append((string)PackageManager.GetVersionPackageName(version));
source.Append("Segment{\r\n\r\n");
source.Append("///<summary>\r\n");
source.Append("/// Represents an HL7 ");
source.Append(name);
source.Append(" message segment. \r\n");
source.Append("/// This segment has the following fields:<ol>\r\n");
PrepareAppendStringsForElementsWithDuplicateDescriptions(name, elements);
for (int i = 0; i < elements.Count; i++)
{
se = (SegmentElement)elements[i];
source.Append("///");
source.Append("<li>");
source.Append(name);
source.Append("-");
source.Append(se.field);
source.Append(": ");
source.Append(se.GetDescriptionWithoutSpecialCharacters());
source.Append(" (");
source.Append(se.type);
source.Append(")</li>\r\n");
}
source.Append("///</ol>\r\n");
source.Append("/// The get...() methods return data from individual fields. These methods \r\n");
source.Append("/// do not throw exceptions and may therefore have to handle exceptions internally. \r\n");
source.Append("/// If an exception is handled internally, it is logged and null is returned. \r\n");
source.Append("/// This is not expected to happen - if it does happen this indicates not so much \r\n");
source.Append("/// an exceptional circumstance as a bug in the code for this class.\r\n");
source.Append("///</summary>\r\n");
source.Append("[Serializable]\r\n");
source.Append("public class ");
source.Append(name);
source.Append(" : AbstractSegment ");
//implement interface from Model.control package if required
/*Class correspondingControlInterface = Control.getInterfaceImplementedBy(name);
* if (correspondingControlInterface != null) {
* source.append("implements ");
* source.append(correspondingControlInterface.getName());
* } */
source.Append(" {\r\n\r\n");
source.Append(" /**\r\n");
source.Append(" * Creates a ");
source.Append(name);
source.Append(" (");
source.Append(segDesc);
source.Append(") segment object that belongs to the given \r\n");
source.Append(" * message. \r\n");
source.Append(" */\r\n");
//write constructor
source.Append("\tpublic ");
source.Append(name);
source.Append("(IGroup parent, IModelClassFactory factory) : base(parent,factory) {\r\n");
source.Append("\tIMessage message = Message;\r\n");
if (elements.Count > 0)
{
source.Append(" try {\r\n");
for (int i = 0; i < elements.Count; i++)
{
se = (SegmentElement)elements[i];
String type = SourceGenerator.getAlternateType(se.type, version);
source.Append(" this.add(");
source.Append("typeof(" + type + ")");
// if (type.equalsIgnoreCase("Varies")) {
// } else {
// source.append("factory.getTypeClass(\"");
// source.append(type);
// source.append("\", \"");
// source.append(version);
// source.append("\")");
// }
source.Append(", ");
if (se.opt == null)
{
source.Append("false");
}
else
{
if (se.opt.ToUpper().Equals("R".ToUpper()))
{
source.Append("true");
}
else
{
source.Append("false");
}
}
source.Append(", ");
source.Append(se.repetitions);
source.Append(", ");
source.Append(se.length);
source.Append(", ");
if (se.type.Equals("ID") || se.type.Equals("IS"))
{
source.Append("new System.Object[]{message, ");
source.Append(se.table);
source.Append("}");
}
else
{
source.Append("new System.Object[]{message}");
}
if (se.desc != null && se.desc.Trim().Length > 0)
{
source.Append(", ");
source.Append("\"" + se.GetDescriptionWithoutSpecialCharacters() + "\"");
}
source.Append(");\r\n");
}
source.Append(" } catch (HL7Exception he) {\r\n");
source.Append(
" HapiLogFactory.GetHapiLog(GetType()).Error(\"Can't instantiate \" + GetType().Name, he);\r\n");
source.Append(" }\r\n");
}
source.Append(" }\r\n\r\n");
//write a datatype-specific accessor for each field
for (int i = 0; i < elements.Count; i++)
{
se = (SegmentElement)elements[i];
if (!se.desc.ToUpper().Equals("UNUSED".ToUpper()))
{
//some entries in 2.1 DB say "unused"
String type = SourceGenerator.getAlternateType(se.type, version);
source.Append("\t///<summary>\r\n");
source.Append("\t/// Returns ");
if (se.repetitions != 1)
{
source.Append("a single repetition of ");
}
source.Append(se.GetDescriptionWithoutSpecialCharacters());
source.Append("(");
source.Append(name);
source.Append("-");
source.Append(se.field);
source.Append(").\r\n");
if (se.repetitions != 1)
{
source.Append("\t/// throws HL7Exception if the repetition number is invalid.\r\n");
source.Append("\t/// <param name=\"rep\">The repetition number (this is a repeating field)</param>\r\n");
}
source.Append("\t///</summary>\r\n");
source.Append("\tpublic ");
source.Append(type);
source.Append(" ");
source.Append(SourceGenerator.MakeAccessorName(se.desc, se.repetitions) + se.AccessorNameToAppend);
if (se.repetitions != 1)
{
source.Append("(int rep)");
}
source.Append("\n\t{\r\n");
if (se.repetitions == 1)
{
source.Append("\t\tget{\r\n");
}
source.Append("\t\t\t");
source.Append(type);
source.Append(" ret = null;\r\n");
source.Append("\t\t\ttry\n\t\t\t{\r\n");
source.Append("\t\t\tIType t = this.GetField(");
source.Append(se.field);
source.Append(", ");
if (se.repetitions == 1)
{
source.Append("0");
}
else
{
source.Append("rep");
}
source.Append(");\r\n");
source.Append("\t\t\t\tret = (");
source.Append(type);
source.Append(")t;\r\n");
if (se.repetitions == 1)
{
source.Append("\t\t\t}\n\t\t\t catch (HL7Exception he) {\r\n");
source.Append(
"\t\t\tHapiLogFactory.GetHapiLog(GetType()).Error(\"Unexpected problem obtaining field value. This is a bug.\", he);\r\n");
source.Append("\t\t\t\tthrow new System.Exception(\"An unexpected error ocurred\", he);\r\n");
}
source.Append("\t\t} catch (System.Exception ex) {\r\n");
source.Append(
"\t\t\tHapiLogFactory.GetHapiLog(GetType()).Error(\"Unexpected problem obtaining field value. This is a bug.\", ex);\r\n");
source.Append("\t\t\t\tthrow new System.Exception(\"An unexpected error ocurred\", ex);\r\n");
source.Append(" }\r\n");
source.Append("\t\t\treturn ret;\r\n");
if (se.repetitions == 1)
{
source.Append("\t}\r\n"); //End get
}
source.Append(" }\r\n\r\n");
//add an array accessor as well for repeating fields
if (se.repetitions != 1)
{
source.Append(" ///<summary>\r\n");
source.Append(" /// Returns all repetitions of ");
source.Append(se.GetDescriptionWithoutSpecialCharacters());
source.Append(" (");
source.Append(name);
source.Append("-");
source.Append(se.field);
source.Append(").\r\n");
source.Append(" ///</summary>\r\n");
source.Append(" public ");
source.Append(type);
source.Append("[] Get");
source.Append(SourceGenerator.MakeAccessorName(se.desc) + se.AccessorNameToAppend);
source.Append("() {\r\n");
source.Append(" ");
source.Append(type);
source.Append("[] ret = null;\r\n");
source.Append(" try {\r\n");
source.Append(" IType[] t = this.GetField(");
source.Append(se.field);
source.Append("); \r\n");
source.Append(" ret = new ");
source.Append(type);
source.Append("[t.Length];\r\n");
source.Append(" for (int i = 0; i < ret.Length; i++) {\r\n");
source.Append(" ret[i] = (");
source.Append(type);
source.Append(")t[i];\r\n");
source.Append(" }\r\n");
source.Append(" } catch (HL7Exception he) {\r\n");
source.Append(
" HapiLogFactory.GetHapiLog(this.GetType()).Error(\"Unexpected problem obtaining field value. This is a bug.\", he);\r\n");
source.Append(" throw new System.Exception(\"An unexpected error ocurred\", he);\r\n");
source.Append(" } catch (System.Exception cce) {\r\n");
source.Append(
" HapiLogFactory.GetHapiLog(GetType()).Error(\"Unexpected problem obtaining field value. This is a bug.\", cce);\r\n");
source.Append(" throw new System.Exception(\"An unexpected error ocurred\", cce);\r\n");
source.Append(" }\r\n");
source.Append(" return ret;\r\n");
source.Append("}\r\n\r\n");
//Add property for the total repetitions of this object
source.Append(" ///<summary>\r\n");
source.Append(" /// Returns the total repetitions of ");
source.Append(se.GetDescriptionWithoutSpecialCharacters());
source.Append(" (");
source.Append(name);
source.Append("-");
source.Append(se.field);
source.Append(").\r\n");
source.Append(" ///</summary>\r\n");
source.Append(" public int ");
source.Append(SourceGenerator.MakeName(se.desc) + se.AccessorNameToAppend);
source.Append("RepetitionsUsed\r\n");
source.Append("{\r\n");
source.Append("get{\r\n");
source.Append(" try {\r\n");
source.Append("\treturn GetTotalFieldRepetitionsUsed(" + se.field + ");\r\n");
source.Append(" }\r\n");
source.Append("catch (HL7Exception he) {\r\n");
source.Append(
" HapiLogFactory.GetHapiLog(this.GetType()).Error(\"Unexpected problem obtaining field value. This is a bug.\", he);\r\n");
source.Append(" throw new System.Exception(\"An unexpected error ocurred\", he);\r\n");
source.Append("} catch (System.Exception cce) {\r\n");
source.Append(
" HapiLogFactory.GetHapiLog(GetType()).Error(\"Unexpected problem obtaining field value. This is a bug.\", cce);\r\n");
source.Append(" throw new System.Exception(\"An unexpected error ocurred\", cce);\r\n");
source.Append("}\r\n");
source.Append("}\r\n");
source.Append("}\r\n");
}
}
}
//add adapter method code for control package if it exists
//source.append(Control.getImplementation(correspondingControlInterface, version));
source.Append("\n}");
}
catch (DbException sqle)
{
SupportClass.WriteStackTrace(sqle, Console.Error);
}
return(source.ToString());
}
public static List <PackageInfo> GetListOfApps()
{
PackageManager packageManager = Application.Context.PackageManager;
return(packageManager.GetInstalledPackages(0).ToList());
}
public static IPackageManager GetPackageManager(ChocolateyConfiguration configuration, ILogger nugetLogger, Action <PackageOperationEventArgs> installSuccessAction, Action <PackageOperationEventArgs> uninstallSuccessAction, bool addUninstallHandler)
{
IFileSystem nugetPackagesFileSystem = GetNuGetFileSystem(configuration, nugetLogger);
IPackagePathResolver pathResolver = GetPathResolver(configuration, nugetPackagesFileSystem);
var packageManager = new PackageManager(GetRemoteRepository(configuration, nugetLogger), pathResolver, nugetPackagesFileSystem, GetLocalRepository(pathResolver, nugetPackagesFileSystem))
{
DependencyVersion = DependencyVersion.Highest,
};
if (configuration.Debug)
{
packageManager.Logger = nugetLogger;
}
//NOTE DO NOT EVER use this method - packageManager.PackageInstalling += (s, e) =>
packageManager.PackageInstalled += (s, e) =>
{
var pkg = e.Package;
"chocolatey".Log().Info(ChocolateyLoggers.Important, "{0}{1} v{2}{3}".format_with(Environment.NewLine, pkg.Id, pkg.Version.to_string(), configuration.Force ? " (forced)" : string.Empty));
if (installSuccessAction != null)
{
installSuccessAction.Invoke(e);
}
};
if (addUninstallHandler)
{
// NOTE DO NOT EVER use this method, or endless loop - packageManager.PackageUninstalling += (s, e) =>
packageManager.PackageUninstalled += (s, e) =>
{
IPackage pkg = packageManager.LocalRepository.FindPackage(e.Package.Id, e.Package.Version);
if (pkg != null)
{
// install not actually removed, let's clean it up. This is a bug with nuget, where it reports it removed some package and did NOTHING
// this is what happens when you are switching from AllowMultiple to just one and back
var chocoPathResolver = packageManager.PathResolver as ChocolateyPackagePathResolver;
if (chocoPathResolver != null)
{
chocoPathResolver.UseSideBySidePaths = !chocoPathResolver.UseSideBySidePaths;
// an unfound package folder can cause an endless loop.
// look for it and ignore it if doesn't line up with versioning
if (nugetPackagesFileSystem.DirectoryExists(chocoPathResolver.GetInstallPath(pkg)))
{
//todo: This causes an issue with upgrades.
// this causes this to be called again, which should then call the uninstallSuccessAction below
packageManager.UninstallPackage(pkg, forceRemove: configuration.Force, removeDependencies: false);
}
chocoPathResolver.UseSideBySidePaths = configuration.AllowMultipleVersions;
}
}
else
{
if (uninstallSuccessAction != null)
{
uninstallSuccessAction.Invoke(e);
}
}
};
}
return(packageManager);
}
/// <summary> <p>Creates skeletal source code (without correct data structure but no business
/// logic) for all segments found in the normative database. </p>
/// </summary>
public static void makeAll(System.String baseDirectory, System.String version)
{
//make base directory
if (!(baseDirectory.EndsWith("\\") || baseDirectory.EndsWith("/")))
{
baseDirectory = baseDirectory + "/";
}
System.IO.FileInfo targetDir = SourceGenerator.makeDirectory(baseDirectory + PackageManager.GetVersionPackagePath(version) + "Segment");
//get list of data types
System.Data.OleDb.OleDbConnection conn = NormativeDatabase.Instance.Connection;
System.String sql = "SELECT seg_code, [section] from HL7Segments, HL7Versions where HL7Segments.version_id = HL7Versions.version_id AND hl7_version = '" + version + "'";
System.Data.OleDb.OleDbCommand temp_OleDbCommand = new System.Data.OleDb.OleDbCommand();
temp_OleDbCommand.Connection = conn;
temp_OleDbCommand.CommandText = sql;
System.Data.OleDb.OleDbDataReader rs = temp_OleDbCommand.ExecuteReader();
System.Collections.ArrayList segments = new System.Collections.ArrayList();
while (rs.Read())
{
System.String segName = System.Convert.ToString(rs[1 - 1]);
if (System.Char.IsLetter(segName[0]))
{
segments.Add(altSegName(segName));
}
}
temp_OleDbCommand.Dispose();
NormativeDatabase.Instance.returnConnection(conn);
if (segments.Count == 0)
{
log.Warn("No version " + version + " segments found in database " + conn.Database);
}
for (int i = 0; i < segments.Count; i++)
{
try
{
System.String seg = (System.String)segments[i];
System.String source = makeSegment(seg, version);
using (System.IO.StreamWriter w = new System.IO.StreamWriter(targetDir.ToString() + @"\" + GetSpecialFilename(seg) + ".cs"))
{
w.Write(source);
w.Write("}");
}
}
catch (System.Exception e)
{
System.Console.Error.WriteLine("Error creating source code for all segments: " + e.Message);
SupportClass.WriteStackTrace(e, Console.Error);
}
}
}
/// <summary>
/// Initializes the widget commands.
/// </summary>
/// <returns>
/// The <see cref="IList"/>.
/// </returns>
protected virtual IList <WidgetMenuItem> InitializeCommands()
{
var packageManager = new PackageManager();
var commandsList = new List <WidgetMenuItem>();
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <PageResources>().ZoneEditorAddPersonalizedVersion,
CommandName = "addPersonalizedVersion",
CssClass = "sfPersonalizeItm"
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <PageResources>().ZoneEditorRemovePersonalizedVersion,
CommandName = "removePersonalizedVersion",
CssClass = "sfRemPersonalizedItm sfSeparatorDown"
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <PageResources>().ZoneEditorEnablePageOverrideDisplayContenxtMenuInfo,
CommandName = "displayWidgetOverrideText",
CssClass = "sfDisplayText"
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <Labels>().Delete,
CommandName = "beforedelete",
CssClass = "sfDeleteItm"
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <Labels>().Duplicate,
CommandName = "duplicate",
CssClass = "sfDuplicateItm"
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <PageResources>().ZoneEditorEnablePageOverride,
CommandName = "widgetOverride",
CssClass = "sfWidgetOverrideItm"
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <PageResources>().ZoneEditorDisablePageOverride,
CommandName = "widgetDisableOverride",
CssClass = "sfWidgetOverrideItm"
});
if (this.ResolveCurrentSitemapNode() != null)
{
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <PageResources>().ZoneEditorRollback,
CommandName = "rollback",
CssClass = "sfDisableWidgetOverrideItm"
});
}
if (this.SharedContentID == Guid.Empty)
{
var shareActionLink =
packageManager.EnhanceUrl(
RouteHelper.ResolveUrl(string.Format(CultureInfo.InvariantCulture, DesignerTemplate, "Share"), UrlResolveOptions.Rooted));
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <ContentBlockResources>().Share,
ActionUrl = shareActionLink,
NeedsModal = true
});
}
else
{
var unshareActionLink =
packageManager.EnhanceUrl(
RouteHelper.ResolveUrl(string.Format(CultureInfo.InvariantCulture, DesignerTemplate, "Unshare"), UrlResolveOptions.Rooted));
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <ContentBlockResources>().Unshare,
ActionUrl = unshareActionLink,
NeedsModal = true
});
}
var useSharedActionLink =
packageManager.EnhanceUrl(
RouteHelper.ResolveUrl(string.Format(CultureInfo.InvariantCulture, DesignerTemplate, "UseShared"), UrlResolveOptions.Rooted));
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <ContentBlockResources>().UseShared,
ActionUrl = useSharedActionLink,
NeedsModal = true
});
commandsList.Add(
new WidgetMenuItem
{
Text = Res.Get <Labels>().Permissions,
CommandName = "permissions",
CssClass = "sfPermItm"
});
return(commandsList);
}
protected override IEnumerable <ICommandOutput> ExecuteCore()
{
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
yield return(VerifyDescriptor(_targetDescriptor));
yield return(VerifyProjectRepository());
yield return(SetupEnvironmentForAdd());
var sourceRepositories = GetSourceRepositories().ToList();
var descriptor = new PackageDescriptor(_targetDescriptor.Value);
if (Project && System)
{
var sysToAdd = new List <PackageIdentifier>();
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return(ToOutput(m));
ParseSuccess(m, sysToAdd.Add);
}
foreach (var identifier in sysToAdd)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest.Exact(identifier.Name, identifier.Version), sourceRepositories, HostEnvironment.SystemRepository))
{
yield return(ToOutput(m));
}
}
}
}
else if (Project)
{
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return(ToOutput(m));
}
}
}
else if (System)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest, sourceRepositories, HostEnvironment.SystemRepository, AddOptions))
{
yield return(ToOutput(m));
}
}
if (_packageNotFound)
{
var hit = false;
foreach (var m in PackageManager.ListPackages(sourceRepositories, Name))
{
if (!hit)
{
yield return(new Info("Did you mean one of the following packages?", Name));
hit = true;
}
yield return(ToOutput(m));
}
}
}
protected override int Invoke(string[] args)
{
if (args.Length == 0)
{
Console.Error.WriteLine("Expected at least 1 argument");
return(1);
}
var mgr = new PackageManager();
var installing = new HashSet <Package>();
foreach (var name in args)
{
if (!mgr.Registry.TryGetValue(name, out var pkg))
{
_log.Error("Package {0} does not exist", name);
return(1);
}
installing.Add(pkg);
}
void AddDependencies(Package package)
{
foreach (var name in package.Dependencies)
{
if (mgr.Registry.TryGetValue(name, out var dep) && installing.Add(dep))
{
AddDependencies(dep);
}
}
}
foreach (var pkg in installing.ToArray())
{
AddDependencies(pkg);
}
_log.Basic("Packages to be installed:");
_log.Basic(string.Empty);
foreach (var pkg in installing.ToArray())
{
var installed = mgr.LocalPackages.ContainsKey(pkg.Name);
if (installed)
{
installing.Remove(pkg);
}
var status = installed ? " (already installed; skipping)" : string.Empty;
_log.Basic(" {0}{1}", pkg.Name, status);
}
_log.Basic(string.Empty);
foreach (var pkg in installing)
{
var finfo = new FileInfo(pkg.Path);
var dinfo = new DirectoryInfo(pkg.Path);
if (!finfo.Exists && !dinfo.Exists)
{
continue;
}
_log.Error("Package path {0} exists already", pkg.Path);
return(1);
}
foreach (var pkg in installing)
{
foreach (var name in pkg.Conflicts)
{
if (mgr.LocalPackages.ContainsKey(name))
{
const string format = "Package {0} conflicts with already-installed package {1}{2}";
if (!_force)
{
_log.Error(format, pkg.Name, name, string.Empty);
return(1);
}
_log.Warning(format, pkg.Name, name, "; ignoring");
}
if (installing.Any(x => x.Name == name))
{
const string format = "Package {0} conflicts with to-be-installed package {1}{2}";
if (!_force)
{
_log.Error(format, pkg.Name, name, string.Empty);
return(1);
}
_log.Warning(format, pkg.Name, name, "; ignoring");
}
}
}
var count = 0;
foreach (var pkg in installing)
{
_log.Info("Installing package {0}...", pkg.Name);
mgr.Install(pkg);
count++;
}
_log.Basic("Installed {0} packages", count);
var kinds = installing.SelectMany(x => x.Assets).Distinct();
if (kinds.Any())
{
var assets = new AssetManager();
foreach (var kind in kinds)
{
assets.Update(kind);
}
}
return(0);
}
/// <summary>
/// Installs the package.
/// </summary>
/// <param name="packageManager">The package manager.</param>
/// <param name="fileSystem">The file system.</param>
/// <param name="packageId">The package id.</param>
/// <param name="version">The version.</param>
/// <param name="allowPreReleaseVersion"> </param>
/// <returns></returns>
internal bool InstallPackage(PackageManager packageManager, IFileSystem fileSystem, string packageId, SemanticVersion version, Boolean allowPreReleaseVersion = true)
{
if (packageManager.IsPackageInstalled(packageId, version))
{
return false;
}
if (!AllowMultipleVersions)
{
var installedPackage = packageManager.LocalRepository.FindPackage(packageId);
if (installedPackage != null)
{
if (version != null && installedPackage.Version >= version)
{
// If the package is already installed (or the version being installed is lower), then we do not need to do anything.
return false;
}
else if (packageManager.SourceRepository.Exists(packageId, version))
{
// If the package is already installed, but
// (a) the version we require is different from the one that is installed,
// (b) side-by-side is disabled
// we need to uninstall it.
// However, before uninstalling, make sure the package exists in the source repository.
packageManager.UninstallPackage(installedPackage, forceRemove: true, removeDependencies: false);
}
}
}
//TODO Will need to expose the last boolean here......
var package = _packageResolutionManager.ResolvePackage(packageManager.LocalRepository, _repository, packageId, version, allowPreReleaseVersion);
packageManager.InstallPackage(package, ignoreDependencies: !IncludeDependencies, allowPrereleaseVersions: allowPreReleaseVersion);
//packageManager.InstallPackage(packageId, version, !IncludeDependencies, allowPreReleaseVersion);
return true;
}
public int InstallCommand()
{
if (Arguments.Count < 1){
Console.WriteLine ("muget: you must specify a package to install");
return 1;
}
var package = Arguments [0];
var version = Arguments.Count > 1 ? new Version (Arguments [1]) : null;
var pm = new PackageManager (PackageRepository, "packages"){
Logger = new Logger ()
};
pm.InstallPackage (package, version);
return 0;
}
public void hide()
{
ComponentName componentName = new ComponentName(this, Java.Lang.Class.FromType(typeof(MainActivity)).Name);
PackageManager.SetComponentEnabledSetting(componentName, ComponentEnabledState.Disabled, ComponentEnableOption.DontKillApp);
}
/// <summary>
/// OnCreate
/// </summary>
/// <param name="savedInstanceState"></param>
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
var b = (savedInstanceState ?? Intent.Extras);
var ran = b.GetBoolean("ran", defaultValue: false);
title = b.GetString(MediaStore.MediaColumns.Title);
description = b.GetString(MediaStore.Images.ImageColumns.Description);
tasked = b.GetBoolean(ExtraTasked);
id = b.GetInt(ExtraId, 0);
type = b.GetString(ExtraType);
front = b.GetInt(ExtraFront);
if (type == "image/*")
{
isPhoto = true;
}
action = b.GetString(ExtraAction);
Intent pickIntent = null;
try
{
pickIntent = new Intent(action);
if (action == Intent.ActionPick)
{
pickIntent.SetType(type);
}
else
{
if (!isPhoto)
{
seconds = b.GetInt(MediaStore.ExtraDurationLimit, 0);
if (seconds != 0)
{
pickIntent.PutExtra(MediaStore.ExtraDurationLimit, seconds);
}
size = b.GetLong(MediaStore.ExtraSizeLimit, 0);
if (size != 0)
{
pickIntent.PutExtra(MediaStore.ExtraSizeLimit, size);
}
}
saveToAlbum = b.GetBoolean(ExtraSaveToAlbum);
pickIntent.PutExtra(ExtraSaveToAlbum, saveToAlbum);
quality = (VideoQuality)b.GetInt(MediaStore.ExtraVideoQuality, (int)VideoQuality.High);
pickIntent.PutExtra(MediaStore.ExtraVideoQuality, GetVideoQuality(quality));
if (front != 0)
{
pickIntent.UseFrontCamera();
}
else
{
pickIntent.UseBackCamera();
}
if (!ran)
{
path = GetOutputMediaFile(this, b.GetString(ExtraPath), title, isPhoto, false);
Touch();
var targetsNOrNewer = false;
try
{
targetsNOrNewer = (int)Application.Context.ApplicationInfo.TargetSdkVersion >= 24;
}
catch (Exception appInfoEx)
{
System.Diagnostics.Debug.WriteLine("Unable to get application info for targetSDK, trying to get from package manager: " + appInfoEx);
targetsNOrNewer = false;
var appInfo = PackageManager.GetApplicationInfo(Application.Context.PackageName, 0);
if (appInfo != null)
{
targetsNOrNewer = (int)appInfo.TargetSdkVersion >= 24;
}
}
if (targetsNOrNewer && path.Scheme == "file")
{
try
{
var photoURI = FileProvider.GetUriForFile(this,
Application.Context.PackageName + ".fileprovider",
new Java.IO.File(path.Path));
GrantUriPermissionsForIntent(pickIntent, photoURI);
pickIntent.AddFlags(ActivityFlags.GrantReadUriPermission);
pickIntent.AddFlags(ActivityFlags.GrantWriteUriPermission);
pickIntent.PutExtra(MediaStore.ExtraOutput, photoURI);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"Unable to get file location, check and set manifest with file provider. Exception: {ex}");
throw new ArgumentException("Unable to get file location. This most likely means that the file provider information is not set in your Android Manifest file. Please check documentation on how to set this up in your project.", ex);
}
}
else
{
pickIntent.PutExtra(MediaStore.ExtraOutput, path);
}
}
else
{
path = Uri.Parse(b.GetString(ExtraPath));
}
}
if (!ran)
{
StartActivityForResult(pickIntent, id);
}
}
catch (Exception ex)
{
OnMediaPicked(new MediaPickedEventArgs(id, ex));
//must finish here because an exception has occured else blank screen
Finish();
}
finally
{
if (pickIntent != null)
{
pickIntent.Dispose();
}
}
}
public bool RicofyPrefabs(List <PrefabInfo> prefabs)
{
if (!ModIsLoaded)
{
return(false);
}
try
{
var asset = PackageManager.FindAssetByName(prefabs[0].name);
var ricoDefPath = Path.Combine(Path.GetDirectoryName(asset.package.packagePath), "PloppableRICODefinition.xml");
if (!File.Exists(ricoDefPath))
{
return(true);
}
var ricoDef = PloppableRICO.RICOReader.ParseRICODefinition(asset.package.packageName, ricoDefPath);
if (ricoDef == null)
{
return(false);
}
foreach (var prefab in prefabs)
{
var category = new PloppableRICO.XMLManager().Invoke("AssignCategory", prefab);
var buildingData = new PloppableRICO.BuildingData
{
prefab = (BuildingInfo)prefab,
name = prefab.name,
category = (PloppableRICO.Category)category,
hasAuthor = true
};
PloppableRICO.XMLManager.prefabList.Add(buildingData);
PloppableRICO.XMLManager.prefabHash[buildingData.prefab] = buildingData;
foreach (var buildingDef in ricoDef.Buildings)
{
var pf = FindPrefab(buildingDef, asset);
//Add asset author settings to dictionary.
if (PloppableRICO.XMLManager.prefabHash.ContainsKey(pf))
{
PloppableRICO.XMLManager.prefabHash[pf].local = buildingDef;
PloppableRICO.XMLManager.prefabHash[pf].hasLocal = true;
}
if (buildingData.local.ricoEnabled)
{
try
{
new PloppableRICO.ConvertPrefabs().ConvertPrefab(buildingData.local, buildingData.name);
var cat = UICategoryOf(buildingDef.service, buildingDef.subService);
DrawRicoBuildingButton(buildingData.prefab, cat);
RemoveVanillaUIButton(buildingData.prefab);
}
catch (Exception e)
{
Profiler.Error("Cant convert prefab", e);
}
}
}
}
return(true);
}
catch (Exception e)
{
Profiler.Error("Cant rerun rico", e);
}
return(false);
}
private void PackageManager_PackageInstalling(PackageManager sender, Package target) {
if (this.IsLoggedIn == true && this.m_blEventsEnabled == true) {
this.Game.SendRequest("procon.packages.onInstalling", target.Uid);
}
}
// Only call from InitializeAgentConnectionAsync
async Task DoInitalizeAgentConnectionAsync()
{
try {
ResetAgentConnection();
using (ViewControllers.Messages.PushMessage(
Message.CreateInfoStatus(
Catalog.GetString("Connecting to agent…"), showSpinner: true)))
await ConnectToAgentAsync(CancellationToken);
using (ViewControllers.Messages.PushMessage(
Message.CreateInfoStatus(
Catalog.GetString("Preparing workspace…"), showSpinner: true))) {
await InitializeCompilationWorkspaceAsync(CancellationToken);
if (EvaluationService == null)
{
var evaluationService = new EvaluationService(
CompilationWorkspace,
new EvaluationEnvironment(WorkingDirectory));
evaluationService.NotifyAgentConnected(Agent);
EvaluationService = evaluationService;
}
if (SessionKind == ClientSessionKind.Workbook)
{
PackageManager = new PackageManagerService(
CompilationWorkspace.DependencyResolver,
EvaluationService,
async(refreshForAgentIntegration, cancellationToken) => {
if (refreshForAgentIntegration)
{
await RefreshForAgentIntegration();
}
return(Agent);
});
}
else
{
PackageManager = null;
}
}
} catch (Exception e) {
Log.Error(TAG, e);
ViewControllers.Messages.PushMessage(WithReconnectSessionAction(e
.ToAlertMessage(Catalog.GetString("Unable to connect"))));
return;
}
try {
using (ViewControllers.Messages.PushMessage(
Message.CreateInfoStatus(
Catalog.GetString("Restoring packages…"), showSpinner: true)))
await PackageManager?.InitializeAsync(
WorkbookApp.Sdk,
Workbook
.Pages
.SelectMany(page => page.Packages),
CancellationToken);
} catch (Exception e) {
Log.Error(TAG, e);
ViewControllers.Messages.PushMessage(e
.ToAlertMessage(Catalog.GetString("Unable to restore packages")));
}
}
/// <summary> Returns a String containing source code for a Composite data type. The
/// dataTypes array contains the data type names (e.g. ST) of each component.
/// The descriptions array contains the corresponding descriptions (e.g. string).
/// </summary>
private static System.String makeComposite(System.String dataType, System.String description, System.String[] dataTypes, System.String[] descriptions, int[] tables, System.String version)
{
System.Text.StringBuilder source = new System.Text.StringBuilder();
source.Append("using System;\n");
source.Append("using NHapi.Base.Model;\n");
source.Append("using NHapi.Base.Log;\n");
source.Append("using NHapi.Base;\n");
source.Append("using NHapi.Base.Model.Primitive;\r\n\r\n");
source.Append("namespace ");
source.Append(PackageManager.GetVersionPackageName(version));
source.Append("Datatype\r\n");
source.Append("{\r\n\r\n");
source.Append("///<summary>\r\n");
source.Append("/// <p>The HL7 ");
source.Append(dataType);
source.Append(" (");
source.Append(description);
source.Append(") data type. Consists of the following components: </p><ol>\r\n");
for (int i = 0; i < dataTypes.Length; i++)
{
source.Append("/// <li>");
source.Append(GetDescription(descriptions[i]));
source.Append(" (");
source.Append(dataTypes[i]);
source.Append(")</li>\r\n");
}
source.Append("/// </ol>\r\n");
source.Append("///</summary>\r\n");
source.Append("[Serializable]\r\n");
source.Append("public class ");
source.Append(dataType);
source.Append(" : AbstractType, IComposite");
source.Append("{\r\n");
source.Append("\tprivate IType[] data;\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t/// Creates a ");
source.Append(dataType);
source.Append(".\r\n");
source.Append("\t/// <param name=\"message\">The Message to which this Type belongs</param>\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic ");
source.Append(dataType);
source.Append("(IMessage message) : this(message, null){}\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t/// Creates a ");
source.Append(dataType);
source.Append(".\r\n");
source.Append("\t/// <param name=\"message\">The Message to which this Type belongs</param>\r\n");
source.Append("\t/// <param name=\"description\">The description of this type</param>\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic ");
source.Append(dataType);
source.Append("(IMessage message, string description) : base(message, description){\r\n");
source.Append("\t\tdata = new IType[");
source.Append(dataTypes.Length);
source.Append("];\r\n");
for (int i = 0; i < dataTypes.Length; i++)
{
source.Append("\t\tdata[");
source.Append(i);
source.Append("] = new ");
source.Append(SourceGenerator.getAlternateType(dataTypes[i], version));
if (dataTypes[i].Equals("ID") || dataTypes[i].Equals("IS"))
{
source.Append("(message, ");
source.Append(tables[i]);
}
else
{
source.Append("(message");
}
if (descriptions[i] != null && descriptions[i].Trim().Length > 0)
{
string desc = descriptions[i];
desc = desc.Replace("\"", "'");
desc = desc.Substring(0, 1).ToUpper() + desc.Substring(1);
source.Append(",\"" + desc + "\"");
}
source.Append(")");
source.Append(";\r\n");
}
source.Append("\t}\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t/// Returns an array containing the data elements.\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic IType[] Components\r\n");
source.Append("\t{ \r\n");
source.Append("\t\tget{\r\n");
source.Append("\t\t\treturn this.data; \r\n");
source.Append("\t\t}\r\n");
source.Append("\t}\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t/// Returns an individual data component.\r\n");
source.Append("\t/// @throws DataTypeException if the given element number is out of range.\r\n");
source.Append("\t///<param name=\"index\">The index item to get (zero based)</param>\r\n");
source.Append("\t///<returns>The data component (as a type) at the requested number (ordinal)</returns>\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic IType this[int index] { \r\n\r\n");
source.Append("get{\r\n");
source.Append("\t\ttry { \r\n");
source.Append("\t\t\treturn this.data[index]; \r\n");
source.Append("\t\t} catch (System.ArgumentOutOfRangeException) { \r\n");
source.Append("\t\t\tthrow new DataTypeException(\"Element \" + index + \" doesn't exist in ");
source.Append(dataTypes.Length);
source.Append(" element ");
source.Append(dataType);
source.Append(" composite\"); \r\n");
source.Append("\t\t} \r\n");
source.Append("\t} \r\n");
source.Append("\t} \r\n");
//make type-specific accessors ...
for (int i = 0; i < dataTypes.Length; i++)
{
System.String dtName = SourceGenerator.getAlternateType(dataTypes[i], version);
source.Append("\t///<summary>\r\n");
source.Append("\t/// Returns ");
source.Append(GetDescription(descriptions[i]));
source.Append(" (component #");
source.Append(i);
source.Append("). This is a convenience method that saves you from \r\n");
source.Append("\t/// casting and handling an exception.\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic ");
source.Append(dtName);
source.Append(" ");
source.Append(SourceGenerator.MakeAccessorName(descriptions[i]));
source.Append(" {\r\n");
source.Append("get{\r\n");
source.Append("\t ");
source.Append(dtName);
source.Append(" ret = null;\r\n");
source.Append("\t try {\r\n");
source.Append("\t ret = (");
source.Append(dtName);
source.Append(")this[");
source.Append(i);
source.Append("];\r\n");
source.Append("\t } catch (DataTypeException e) {\r\n");
source.Append("\t HapiLogFactory.GetHapiLog(this.GetType()).Error(\"Unexpected problem accessing known data type component - this is a bug.\", e);\r\n");
source.Append("\t throw new System.Exception(\"An unexpected error ocurred\",e);\r\n");
source.Append("\t }\r\n");
source.Append("\t return ret;\r\n");
source.Append("}\r\n\r\n");
source.Append("}\r\n");
}
/*if (correspondingControlInterface != null) {
* source.append(Control.getImplementation(correspondingControlInterface, version));
* } */
source.Append("}");
return(source.ToString());
}
public InstalledPackagesTreeModel(PackageManager manager) : base(manager)
{
this.packageManager.PackageInstalled += this.packageManager_PackageInstalled;
this.packageManager.PackageUninstalled += this.packageManager_PackageUninstalled;
}
private void UpdateBags()
{
PackageManager pack = mDataModule.GetPackManager();
for (int i = 0; i < mItemList.Count; ++i)
{
CommonItemUI grid = mItemList[i] as CommonItemUI;
grid.gameObject.SetActive(false);
}
int idx = 0;
//选中所有
if (mSelect == BagSelect.Bag_All)
{
Dictionary <int, ItemObj> dic = pack.getPackDic(PackageType.Pack_Bag);
foreach (KeyValuePair <int, ItemObj> value in dic)
{
UpdateBagGrid(idx++, value.Value);
}
dic = pack.getPackDic(PackageType.Pack_Gem);
foreach (KeyValuePair <int, ItemObj> value in dic)
{
UpdateBagGrid(idx++, value.Value);
}
mLockItem.SetActive(false);
}
else if (mSelect == BagSelect.Bag_Item || mSelect == BagSelect.Bag_Gem)
{
PackageType type = PackageType.Pack_Bag;
if (mSelect == BagSelect.Bag_Gem)
{
type = PackageType.Pack_Gem;
}
Dictionary <int, ItemObj> dic = pack.getPackDic(type);
foreach (KeyValuePair <int, ItemObj> value in dic)
{
UpdateBagGrid(idx++, value.Value);
}
int max_vaild_number = pack.GetPackMaxVaildSize(type);
int max_number = pack.GetPackMaxSize(type);
if (idx < max_vaild_number)
{
for (int i = idx; i < max_vaild_number; ++i)
{
UpdateBagGrid(idx++, null);
}
}
//还有扩充空间
if (max_vaild_number < max_number)
{
if (mLockItem.transform.parent != null)
{
mLockItem.transform.parent = null;
}
mLockItem.transform.parent = mItemsGrid.transform;
mLockItem.transform.localScale = Vector3.one;
//增加解锁节点
mLockItem.SetActive(true);
}
else
{
mLockItem.SetActive(false);
}
}
mItemsGrid.Reposition();// = true;
if (mLockItem.activeSelf)
{
Vector3 pos = mLockItem.transform.localPosition;
pos.x = 130;
mLockItem.transform.localPosition = pos;
}
mScrollView.ResetPosition();
}
private void PackageManager_PackageDownloadFail(PackageManager sender, Package target) {
if (this.IsLoggedIn == true && this.m_blEventsEnabled == true) {
this.Game.SendRequest("procon.packages.onDownloadError", target.Uid, target.Error);
}
}
/// <summary>
/// Creates the list of standard prefab levels to load.
/// </summary>
KeyValuePair <string, float>[] SetLevels()
{
MethodInfo dlcMethod = typeof(LoadingManager).GetMethod("DLC", BindingFlags.Instance | BindingFlags.NonPublic);
LoadingManager.instance.m_supportsExpansion[0] = (bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 369150u });
LoadingManager.instance.m_supportsExpansion[1] = (bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 420610u });
LoadingManager.instance.m_supportsExpansion[2] = (bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 515191u });
LoadingManager.instance.m_supportsExpansion[3] = (bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 547502u });
LoadingManager.instance.m_supportsExpansion[4] = (bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 614580u });
LoadingManager.instance.m_supportsExpansion[5] = (bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 715191u });
bool isWinter = SimulationManager.instance.m_metaData.m_environment == "Winter";
if (isWinter && !LoadingManager.instance.m_supportsExpansion[1])
{
SimulationManager.instance.m_metaData.m_environment = "Sunny";
isWinter = false;
}
List <KeyValuePair <string, float> > levels = new List <KeyValuePair <string, float> >(18);
string scene = (string)Util.Invoke(LoadingManager.instance, "GetLoadingScene");
if (!string.IsNullOrEmpty(scene))
{
levels.Add(new KeyValuePair <string, float>(scene, 0.015f));
}
levels.Add(new KeyValuePair <string, float>(SimulationManager.instance.m_metaData.m_environment + "Prefabs", 0.12f));
if ((bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 1u }))
{
levels.Add(new KeyValuePair <string, float>(isWinter ? "WinterLoginPackPrefabs" : "LoginPackPrefabs", 0.121f));
}
levels.Add(new KeyValuePair <string, float>(isWinter ? "WinterPreorderPackPrefabs" : "PreorderPackPrefabs", 0.122f));
levels.Add(new KeyValuePair <string, float>(isWinter ? "WinterSignupPackPrefabs" : "SignupPackPrefabs", 0.123f));
if ((bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 346791u }))
{
levels.Add(new KeyValuePair <string, float>("DeluxePackPrefabs", 0.124f));
}
if (PlatformService.IsAppOwned(238370u))
{
levels.Add(new KeyValuePair <string, float>("MagickaPackPrefabs", 0.125f));
}
if (LoadingManager.instance.m_supportsExpansion[0])
{
levels.Add(new KeyValuePair <string, float>(isWinter ? "WinterExpansion1Prefabs" : "Expansion1Prefabs", 0.126f));
}
if (LoadingManager.instance.m_supportsExpansion[1])
{
levels.Add(new KeyValuePair <string, float>("Expansion2Prefabs", 0.127f));
}
if (LoadingManager.instance.m_supportsExpansion[2])
{
levels.Add(new KeyValuePair <string, float>("Expansion3Prefabs", 0.128f));
}
if (LoadingManager.instance.m_supportsExpansion[3])
{
levels.Add(new KeyValuePair <string, float>("Expansion4Prefabs", 0.13f));
}
if (LoadingManager.instance.m_supportsExpansion[4])
{
levels.Add(new KeyValuePair <string, float>(isWinter ? "WinterExpansion5Prefabs" : "Expansion5Prefabs", 0.132f));
}
if (LoadingManager.instance.m_supportsExpansion[5])
{
levels.Add(new KeyValuePair <string, float>(SimulationManager.instance.m_metaData.m_environment + "Expansion6Prefabs", 0.133f));
}
for (int i = 0; i < levelStrings.Length; i++)
{
if ((bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { levelStrings[i].Value }))
{
levels.Add(new KeyValuePair <string, float>(levelStrings[i].Key, 0.134f + i * 0.01f / levelStrings.Length));
}
}
if ((bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 715190u }))
{
Package.Asset asset = PackageManager.FindAssetByName("System." + DistrictStyle.kEuropeanSuburbiaStyleName);
if (asset != null && asset.isEnabled)
{
levels.Add(new KeyValuePair <string, float>("ModderPack3Prefabs", 0.144f));
}
}
if ((bool)dlcMethod.Invoke(LoadingManager.instance, new object[] { 563850u }))
{
levels.Add(new KeyValuePair <string, float>("ChinaPackPrefabs", 0.145f));
}
Package.Asset europeanStyles = PackageManager.FindAssetByName("System." + DistrictStyle.kEuropeanStyleName);
if (europeanStyles != null && europeanStyles.isEnabled)
{
levels.Add(new KeyValuePair <string, float>(SimulationManager.instance.m_metaData.m_environment.Equals("Europe") ? "EuropeNormalPrefabs" : "EuropeStylePrefabs", 0.15f));
}
return(levels.ToArray());
}
private void PackageManager_PackageAwaitingRestart(PackageManager sender, Package target) {
if (this.IsLoggedIn == true && this.m_blEventsEnabled == true) {
this.Game.SendRequest("procon.packages.onInstalled", target.Uid, Packet.bltos(true));
}
}
/// <summary> Returns a String containing the complete source code for a Primitive HL7 data
/// type. Note: this method is no longer used, as all Primitives are now coded manually.
/// </summary>
private static System.String makePrimitive(System.String datatype, System.String description, System.String version)
{
System.Text.StringBuilder source = new System.Text.StringBuilder();
source.Append("using System;\n");
source.Append("using NHapi.Base.Model;\n");
source.Append("using NHapi.Base;\n");
source.Append("using NHapi.Base.Model.Primitive;\r\n");
source.Append("namespace ");
source.Append(PackageManager.GetVersionPackageName(version));
source.Append("Datatype\r\n");
source.Append("{\r\n");
source.Append("///<summary>\r\n");
source.Append("///Represents the HL7 ");
source.Append(datatype);
source.Append(" (");
source.Append(description);
source.Append(") datatype. A ");
source.Append(datatype);
source.Append(" contains a single String value.\r\n");
source.Append("///</summary>\r\n");
source.Append("[Serializable]\r\n");
source.Append("public class ");
source.Append(datatype);
source.Append(" : AbstractPrimitive ");
source.Append(" {\r\n\r\n");
//source.append("\tprotected String value;\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t///Constructs an uninitialized ");
source.Append(datatype);
source.Append(".\r\n");
source.Append("\t///<param name=\"message\">The Message to which this Type belongs</param>\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic ");
source.Append(datatype);
source.Append("(IMessage message) : base(message){\r\n");
source.Append("\t}\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t///Constructs an uninitialized ");
source.Append(datatype);
source.Append(".\r\n");
source.Append("\t///<param name=\"message\">The Message to which this Type belongs</param>\r\n");
source.Append("\t///<param name=\"description\">The description of this type</param>\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic ");
source.Append(datatype);
source.Append("(IMessage message, string description) : base(message,description){\r\n");
source.Append("\t}\r\n\r\n");
source.Append("\t///<summary>\r\n");
source.Append("\t/// @return \"");
source.Append(version);
source.Append("\"\r\n");
source.Append("\t///</summary>\r\n");
source.Append("\tpublic string getVersion() {\r\n");
source.Append("\t return \"");
if (version.IndexOf("UCH") > -1)
{
source.Append("2.3");
}
else
{
source.Append(version);
}
source.Append("\";\r\n");
source.Append("}\r\n");
source.Append("}\r\n");
return(source.ToString());
}
/// <summary>
/// Creates the package manager.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="useMachineCache">if set to <c>true</c> [use machine cache].</param>
/// <returns></returns>
protected virtual PackageManager CreatePackageManager(IFileSystem fileSystem, bool useMachineCache = false)
{
var pathResolver = new DefaultPackagePathResolver(fileSystem, useSideBySidePaths: AllowMultipleVersions);
var packageManager = new PackageManager(_repository, pathResolver, fileSystem, new LocalPackageRepository(pathResolver, fileSystem));
packageManager.Logger = Console;
return packageManager;
}
private static void DoAutoInstallPackages()
{
if (IsReinitializingTheSystem)
{
return;
}
try
{
// This is not so good, unittests run and normal runs should have same semantic behavior.
// But if this is not here, some unittests will start failing. /MRJ
if (RuntimeInformation.IsUnittest)
{
return;
}
var zipFiles = new List <AutoInstallPackageInfo>();
string directory = PathUtil.Resolve(GlobalSettingsFacade.AutoPackageInstallDirectory);
if (C1Directory.Exists(directory))
{
Log.LogVerbose(LogTitle, $"Installing packages from: {directory}");
zipFiles.AddRange(C1Directory.GetFiles(directory, "*.zip")
.OrderBy(f => f)
.Select(f => new AutoInstallPackageInfo {
FilePath = f, ToBeDeleted = true
}));
}
else
{
Log.LogVerbose(LogTitle, $"Auto install directory not found: {directory}");
}
if (RuntimeInformation.IsDebugBuild)
{
string workflowTestDir = Path.Combine(PathUtil.Resolve(GlobalSettingsFacade.AutoPackageInstallDirectory), "WorkflowTesting");
if (C1Directory.Exists(workflowTestDir))
{
Log.LogVerbose(LogTitle, $"Installing packages from: {workflowTestDir}");
zipFiles.AddRange(C1Directory.GetFiles(workflowTestDir, "*.zip")
.OrderBy(f => f)
.Select(f => new AutoInstallPackageInfo {
FilePath = f, ToBeDeleted = false
}));
}
}
foreach (var zipFile in zipFiles)
{
try
{
using (Stream zipFileStream = C1File.OpenRead(zipFile.FilePath))
{
Log.LogVerbose(LogTitle, $"Installing package: {zipFile.FilePath}");
PackageManagerInstallProcess packageManagerInstallProcess = PackageManager.Install(zipFileStream, true);
if (packageManagerInstallProcess.PreInstallValidationResult.Count > 0)
{
Log.LogError(LogTitleNormal, "Package installation failed! (Pre install validation error)");
LogErrors(packageManagerInstallProcess.PreInstallValidationResult);
continue;
}
List <PackageFragmentValidationResult> validationResults = packageManagerInstallProcess.Validate();
if (validationResults.Count > 0)
{
Log.LogError(LogTitleNormal, "Package installation failed! (Validation error)");
LogErrors(validationResults);
continue;
}
List <PackageFragmentValidationResult> installResult = packageManagerInstallProcess.Install();
if (installResult.Count > 0)
{
Log.LogError(LogTitleNormal, "Package installation failed! (Installation error)");
LogErrors(installResult);
continue;
}
}
}
catch (Exception ex)
{
Log.LogWarning(LogTitleNormal, ex);
}
if (zipFile.ToBeDeleted)
{
FileUtils.Delete(zipFile.FilePath);
}
}
}
catch (Exception ex)
{
Log.LogError(LogTitleNormal, ex);
}
}
protected override bool ExecuteCore(PackageItem item)
{
IPackage package = item.PackageIdentity;
// treat solution-level packages specially
if (!PackageManager.IsProjectLevel(package))
{
return(UninstallSolutionPackage(package));
}
// display the Manage dialog to allow user to pick projects to install/uninstall
IEnumerable <Project> selectedProjects = _userNotifierServices.ShowProjectSelectorWindow(
Resources.Dialog_InstalledSolutionInstruction,
item.PackageIdentity,
// Selector function to return the initial checkbox state for a Project.
// We check a project by default if it has the current package installed.
project => PackageManager.GetProjectManager(project).IsInstalled(package),
ignored => true);
if (selectedProjects == null)
{
// user presses Cancel button on the Solution dialog
return(false);
}
// bug #1181: Use HashSet<unique name> instead of HashSet<Project>.
// in some rare cases, the project instance returned by GetProjects() may be different
// than the ones in selectedProjectSet.
var selectedProjectsSet = new HashSet <string>(
selectedProjects.Select(p => p.UniqueName),
StringComparer.OrdinalIgnoreCase);
// now determine if user has actually made any change to the checkboxes
IList <Project> allProjects = _solutionManager.GetProjects().ToList();
bool hasInstallWork = allProjects.Any(p =>
selectedProjectsSet.Contains(p.UniqueName) && !IsPackageInstalledInProject(p, package));
bool hasUninstallWork = allProjects.Any(p =>
!selectedProjectsSet.Contains(p.UniqueName) && IsPackageInstalledInProject(p, package));
if (!hasInstallWork && !hasUninstallWork)
{
// nothing to do, so return
return(false);
}
var uninstallRepositories = new List <IPackageRepository>();
var uninstallFrameworks = new List <FrameworkName>();
var uninstallProjects = new List <Project>();
bool?removeDepedencies = false;
if (hasUninstallWork)
{
// Starting in 2.0, each project can have a different set of dependencies (because of different target frameworks).
// To keep the UI simple, we aggregate all the dependencies from all uninstall projects
// and ask if user wants to uninstall them all.
foreach (Project project in allProjects)
{
// check if user wants to uninstall the package in this project
if (!selectedProjectsSet.Contains(project.UniqueName))
{
uninstallProjects.Add(project);
uninstallRepositories.Add(PackageManager.GetProjectManager(project).LocalRepository);
uninstallFrameworks.Add(project.GetTargetFrameworkName());
}
}
removeDepedencies = AskRemoveDependencyAndCheckUninstallPSScript(package, uninstallRepositories, uninstallFrameworks);
if (removeDepedencies == null)
{
// user cancels the operation.
return(false);
}
}
ShowProgressWindow();
// now install the packages that are checked
// Bug 1357: It's crucial that we perform all installs before uninstalls
// to avoid the package file being deleted before an install.
if (hasInstallWork)
{
bool successful = InstallPackageIntoProjects(allProjects, selectedProjectsSet, package);
if (!successful)
{
return(false);
}
}
// now uninstall the packages that are unchecked
for (int i = 0; i < uninstallProjects.Count; ++i)
{
try
{
CheckDependentPackages(package, uninstallRepositories[i], uninstallFrameworks[i]);
UninstallPackageFromProject(uninstallProjects[i], item, (bool)removeDepedencies);
}
catch (Exception ex)
{
AddFailedProject(uninstallProjects[i], ex);
}
}
HideProgressWindow();
return(true);
}
/// <summary> Creates skeletal source code (without correct data structure but no business
/// logic) for all data types found in the normative database. For versions > 2.2, Primitive data types
/// are not generated, because they are coded manually (as of HAPI 0.3).
/// </summary>
public static void MakeAll(string baseDirectory, string version)
{
// make base directory
if (!(baseDirectory.EndsWith("\\") || baseDirectory.EndsWith("/")))
{
baseDirectory += Path.DirectorySeparatorChar;
}
var targetDir =
SourceGenerator.MakeDirectory(
Path.Combine(baseDirectory, PackageManager.GetVersionPackagePath(version), "Datatype"));
// get list of data types
var types = new List <string>();
var conn = NormativeDatabase.Instance.Connection;
var stmt = TransactionManager.Manager.CreateStatement(conn);
// get normal data types ...
DbCommand temp_OleDbCommand;
temp_OleDbCommand = stmt;
temp_OleDbCommand.CommandText =
"select data_type_code from HL7DataTypes, HL7Versions where HL7Versions.version_id = HL7DataTypes.version_id and HL7Versions.hl7_version = '" +
version + "'";
var rs = temp_OleDbCommand.ExecuteReader();
while (rs.Read())
{
types.Add(Convert.ToString(rs[1 - 1]));
}
rs.Close();
// get CF, CK, CM, CN, CQ sub-types ...
DbCommand temp_OleDbCommand2;
temp_OleDbCommand2 = stmt;
temp_OleDbCommand2.CommandText = "select data_structure from HL7DataStructures, HL7Versions where (" +
"data_type_code = 'CF' or " + "data_type_code = 'CK' or " +
"data_type_code = 'CM' or " + "data_type_code = 'CN' or " +
"data_type_code = 'CQ') and " +
"HL7Versions.version_id = HL7DataStructures.version_id and HL7Versions.hl7_version = '" +
version + "'";
rs = temp_OleDbCommand2.ExecuteReader();
while (rs.Read())
{
types.Add(Convert.ToString(rs[1 - 1]));
}
stmt.Dispose();
NormativeDatabase.Instance.ReturnConnection(conn);
Console.Out.WriteLine("Generating " + types.Count + " datatypes for version " + version);
if (types.Count == 0)
{
Log.Warn("No version " + version + " data types found in database " + conn.Database);
}
foreach (var type in types)
{
if (!type.Equals("*"))
{
Make(targetDir, type, version);
}
}
}
