IPackageInfo Publish(IPackageRepository source, string packageFileName, Stream packageStream)
{
var fileWithoutExtension = packageFileName.Trim().ToLowerInvariant().EndsWith(".wrap")
? System.IO.Path.GetFileNameWithoutExtension(packageFileName)
: packageFileName;
if (Packages.Any(x => x.FullName.EqualsNoCase(fileWithoutExtension)))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = inMemoryFile.OpenWrite())
IO.StreamExtensions.CopyTo(packageStream, stream);
var tempFolder = new ZipPackage(inMemoryFile);
var package = new InMemoryPackage(tempFolder)
{
Source = this
};
Packages.Add(package);
return(package);
}
public override void Validate(ValidationContext ctx)
{
base.Validate(ctx);
if (!Packages.Any())
{
ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Warning, Catalog, this, StringConsts.METABASE_NO_APP_PACKAGES_WARNING.Args(Name)));
}
if (Packages.Count() != Packages.Distinct().Count())
{
ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, StringConsts.METABASE_APP_PACKAGE_REDECLARED_ERROR.Args(Name)));
}
foreach (var ap in Packages)
{
if (ap.Name.IsNullOrEmpty())
{
ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, StringConsts.METABASE_APP_PACKAGE_BLANK_NAME_ERROR.Args(Name)));
continue;
}
var refed = Metabank.CatalogBin.Packages.Where(pi => Metabank.INVSTRCMP.Equals(pi.Name, ap.Name)).Select(pi => pi.Name).FirstOrDefault();
if (refed == null)
{
ctx.Output.Add(new MetabaseValidationMsg(MetabaseValidationMessageType.Error, Catalog, this, StringConsts.METABASE_APP_PACKAGE_NOT_FOUND_IN_BIN_CATALOG_ERROR.Args(Name, ap.Name)));
}
}
}
internal void CreateLanguagePackages()
{
using (new UndoManager.EventGroupScope())
{
// Build packages for every RSX stream file
IEnumerable <ContentItemViewModel> items = ProjectViewModel.Current.ContentItems;
IEnumerable <string> languages = items.Select(i => i.Language).Distinct();
foreach (string language in languages.Where(l => l != "SFX"))
{
string packageName = Path.Combine(language, "Default.pck");
if (!Packages.Any(p => p.Name == packageName))
{
Package package = new Package()
{
Name = packageName
};
_manualPackagingInfo.Packages.Add(package);
// Assign
DefaultLanguagePackageIds.SingleOrDefault(l => l.Language == language).BankPackageId = package.Id;
DefaultLanguagePackageIds.SingleOrDefault(l => l.Language == language).StreamPackageId = package.Id;
DefaultLanguagePackageIds.SingleOrDefault(l => l.Language == language).LooseMediaPackageId = package.Id;
}
}
}
}
public override string ToString()
{
var sb = new StringBuilder();
sb.AppendLine();
sb.AppendLine("Environment -");
sb.AppendLine($"Target: {Target}");
sb.AppendLine($"Local Folder: {LocalFolder}");
sb.AppendLine($"Server Folder: {ServerFolder}");
sb.AppendLine($"Output Folder: {OutputPath}");
sb.AppendLine();
sb.AppendLine("Model details -");
sb.AppendLine($"Generator: {GeneratorName}");
sb.AppendLine($"Version: {Version}");
sb.AppendLine($"Model Name: {ModelName}");
sb.AppendLine($"Source Model: {SourceModel}");
sb.AppendLine($"Supports Regeneration: {SupportRegen}");
if (!Packages.Any())
{
return(sb.ToString());
}
sb.AppendLine();
sb.AppendLine("Packages -");
foreach (var package in Packages)
{
sb.AppendLine($" {package.Name}, verion: {package.Version}");
}
return(sb.ToString());
}
IPackageInfo Publish(string packageFileName, Stream packageStream)
{
var fileWithoutExtension = packageFileName.Trim().ToLowerInvariant().EndsWith(".wrap")
? Path.GetFileNameWithoutExtension(packageFileName)
: packageFileName;
if (Packages.Any(x => x.FullName.EqualsNoCase(fileWithoutExtension)))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = FileExtensions.OpenWrite(inMemoryFile))
packageStream.CopyTo(stream);
var tempFolder = new CachedZipPackage(null, inMemoryFile, null);
var package = new InMemoryPackage
{
Name = PackageNameUtility.GetName(fileWithoutExtension),
Version = PackageNameUtility.GetVersion(fileWithoutExtension),
Source = this,
Dependencies = tempFolder.Dependencies.ToList(),
Anchored = tempFolder.Anchored
};
Packages.Add(package);
return(package);
}
public virtual void NuGetRestore(string directory, string packagesDirectory = null)
{
if (!Packages.Any())
{
return;
}
var isWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;
var nuget = Path.Combine(Root, "NuGet.exe");
var psi = new ProcessStartInfo(isWindows ? nuget : "mono")
{
Arguments = $"{(isWindows ? "" : "\"" + nuget + "\"")} restore -Verbosity Detailed -PackagesDirectory \"{Path.Combine (Root, directory, "..", "packages")}\" \"{Path.Combine (Root, directory, "packages.config")}\"",
CreateNoWindow = true,
UseShellExecute = false,
WindowStyle = ProcessWindowStyle.Hidden,
RedirectStandardError = true,
RedirectStandardOutput = true,
};
//TODO: possibly remove this later?
psi.EnvironmentVariables.Add("MONO_LOG_LEVEL", "debug");
Console.WriteLine($"{psi.FileName} {psi.Arguments}");
using (var process = new Process {
StartInfo = psi,
}) {
process.OutputDataReceived += (sender, e) => Console.WriteLine(e.Data);
process.ErrorDataReceived += (sender, e) => Console.Error.WriteLine(e.Data);
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.WaitForExit();
}
}
public virtual ProjectRootElement Construct()
{
// Workaround for https://github.com/dotnet/msbuild/issues/2554 when using Microsoft.Build.Construction.ProjectRootElement.Create
var msbuildExePathVarName = "MSBUILD_EXE_PATH";
if (!Builder.UseDotNet && !TestEnvironment.IsWindows)
{
Environment.SetEnvironmentVariable(msbuildExePathVarName, typeof(DotNetXamarinProject).Assembly.Location);
}
ProjectRootElement root = null;
try {
root = ProjectRootElement.Create();
} finally {
if (!Builder.UseDotNet && !TestEnvironment.IsWindows)
{
Environment.SetEnvironmentVariable(msbuildExePathVarName, null);
}
}
if (Packages.Any())
{
root.AddItemGroup().AddItem(BuildActions.None, "packages.config");
}
foreach (var pkg in Packages.Where(p => p.AutoAddReferences))
{
foreach (var reference in pkg.References)
{
if (!References.Any(r => r.Include == reference.Include))
{
References.Add(reference);
}
}
}
foreach (var pg in PropertyGroups)
{
pg.AddElement(root);
}
foreach (var ig in ItemGroupList)
{
var ige = root.AddItemGroup();
foreach (var i in ig)
{
if (i.Deleted)
{
continue;
}
ige.AddItem(i.BuildAction, i.Include(), i.Metadata);
}
}
root.FullPath = ProjectName + Language.DefaultProjectExtension;
return(root);
}
public GatherCacheResult(bool hasEntry, IReadOnlyList <SourcePackageDependencyInfo> packages)
{
HasEntry = hasEntry;
Packages = packages ?? new List <SourcePackageDependencyInfo>();
if (Packages.Any(package => package == null))
{
throw new ArgumentException("Values in packages must not be null", nameof(packages));
}
}
public virtual List <ProjectResource> Save(bool saveProject = true)
{
var list = new List <ProjectResource> ();
if (saveProject)
{
var contents = SaveProject();
var timestamp = contents != project_file_contents ? default(DateTimeOffset?) :
ItemGroupList.SelectMany(ig => ig).Where(i => i.Timestamp != null).Select(i => (DateTimeOffset)i.Timestamp).Max();
list.Add(new ProjectResource()
{
Timestamp = timestamp,
Path = ProjectFilePath,
Content = project_file_contents = contents,
Encoding = System.Text.Encoding.UTF8,
});
}
if (Packages.Any())
{
list.Add(new ProjectResource()
{
Path = "packages.config",
Content = "<packages>\n" + string.Concat(Packages.Select(p => string.Format(" <package id='{0}' version='{1}' targetFramework='{2}' />\n",
p.Id, p.Version, p.TargetFramework))) + "</packages>"
});
}
foreach (var ig in ItemGroupList)
{
list.AddRange(ig.Select(s => new ProjectResource()
{
Timestamp = s.Timestamp,
Path = s.Include(),
Content = s.TextContent == null ? null : s.TextContent(),
BinaryContent = s.BinaryContent == null ? null : s.BinaryContent(),
Encoding = s.Encoding,
Deleted = s.Deleted,
Attributes = s.Attributes,
}));
}
foreach (var import in Imports)
{
list.Add(new ProjectResource()
{
Path = import.Project(),
Content = import.TextContent == null ? null : import.TextContent(),
Encoding = System.Text.Encoding.UTF8,
});
}
return(list);
}
public void OnGet([FromRoute] string author)
{
Packages = _helper.PackageCache.OrderByDescending(p => p.DatePublished)
.Where(p => p.Author.Equals(author, StringComparison.OrdinalIgnoreCase));
if (Packages.Any())
{
Author = Packages.First().Author;
}
else
{
Author = author;
}
}
public void NuGetRestore(string directory, string packagesDirectory = null)
{
if (!Packages.Any())
{
return;
}
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2");
PackageManager packageManager = new PackageManager(repo, Path.Combine(Root, "temp", "packages"));
foreach (var package in Packages)
{
packageManager.InstallPackage(package.Id, new SemanticVersion(package.Version));
}
}
public void NuGetRestore(string directory, string packagesDirectory = null)
{
if (!Packages.Any())
{
return;
}
var isWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;
var psi = new ProcessStartInfo(isWindows ? "NuGet.exe" : "mono")
{
Arguments = $"{(isWindows ? "" : "\"" + Path.Combine (Root,"NuGet.exe") + "\"")} restore -PackagesDirectory \"{Path.Combine (Root, directory, "..", "packages")}\" \"{Path.Combine (Root, directory, "packages.config")}\"",
};
var process = Process.Start(psi);
process.WaitForExit();
}
/// <summary>
/// Evaluates the settings and writes them to <paramref name="args"/>.
/// </summary>
/// <param name="args">The argument builder into which the settings should be written.</param>
protected override void EvaluateCore(ProcessArgumentBuilder args)
{
base.EvaluateCore(args);
foreach (var package in Packages)
{
args.Append(package);
}
if (Force)
{
args.Append("--force");
}
if (Global)
{
args.Append("--global");
}
if (NoOptional)
{
args.Append("--no-optional");
}
if (!string.IsNullOrWhiteSpace(Registry))
{
args.Append($"--registry {Registry.ToLower()}");
}
if (PreferOffline)
{
args.Append("--prefer-offline");
}
if (Production)
{
if (Packages.Any())
{
throw new NotSupportedException("Can't specify production flag when installing individual packages");
}
args.Append("--production");
}
}
public virtual ProjectRootElement Construct()
{
var root = ProjectRootElement.Create();
if (Packages.Any())
{
root.AddItemGroup().AddItem(BuildActions.None, "packages.config");
}
foreach (var pkg in Packages.Where(p => p.AutoAddReferences))
{
foreach (var reference in pkg.References)
{
if (!References.Any(r => r.Include == reference.Include))
{
References.Add(reference);
}
}
}
foreach (var pg in PropertyGroups)
{
pg.AddElement(root);
}
foreach (var ig in ItemGroupList)
{
var ige = root.AddItemGroup();
foreach (var i in ig)
{
if (i.Deleted)
{
continue;
}
ige.AddItem(i.BuildAction, i.Include(), i.Metadata);
}
}
root.FullPath = ProjectName + Language.DefaultProjectExtension;
return(root);
}
public override string ToString()
{
var sb = new StringBuilder();
sb.AppendLine(Repository.Name);
if (Packages.Any() == false)
{
return(sb.ToString());
}
var currentPackage = Packages.First();
foreach (var package in Packages.Skip(1))
{
sb.AppendFormat("├─{0}{1} [{2}]\r\n", currentPackage.Name, GenerateTitle(currentPackage), GenerateVersions(currentPackage));
currentPackage = package;
}
sb.AppendFormat("└─{0}{1} [{2}]\r\n", currentPackage.Name, GenerateTitle(currentPackage), GenerateVersions(currentPackage));
return(sb.ToString());
}
private void LoadConfig()
{
Packages.Clear();
var cfg = UploaderConfigFile.Parse(ConfigKey);
if (cfg == null)
{
return;
}
ConfigLoaded?.Raise(cfg);
var pkgs = cfg.LocalPackages
.Select(p => LocalR2Package.From(p));
AsUI(_ => Packages.Swap(pkgs));
if (Packages.Any())
{
Package = Packages[0];
}
}
/// <summary>
/// Build a field from argument data
/// </summary>
/// <typeparam name="T_Field"></typeparam>
/// <param name="arg"></param>
/// <param name="recordArg"></param>
/// <param name="mapPosition"></param>
/// <returns></returns>
private IField BuildField <T_Field>(IArgument arg, IArgument recordArg, int mapPosition) where T_Field : class, IField, new()
{
IField field = new T_Field {
Name = arg.ArgumentName,
EntityName = recordArg.TypeSubname,
DataType = arg.DataType,
DataPrecision = arg.DataPrecision,
DataScale = arg.DataScale,
CharLength = arg.CharLength,
OrclType = arg.OrclType,
MapPosition = mapPosition,
SubField = (arg?.NextArgument?.DataLevel == arg.DataLevel + 1)
? BuildField <T_Field>(arg.NextArgument, recordArg, mapPosition)
: null
};
//if (arg?.NextArgument?.DataLevel == arg.DataLevel + 1) field.SubField = BuildField<T_Field>(arg.NextArgument, recordArg, mapPosition);
// set the containing class from the package name
if (!String.IsNullOrEmpty(arg.TypeName) && !arg.TypeName.Equals(arg.PackageName))
{
if (!Parameter.Instance.IsDuplicatePackageRecordOriginatingOutsideFilterAndSchema
// owned by another schema or owned by package that was filtered out
&& (!(arg.Owner ?? "").Equals(arg.TypeOwner) ||
!Packages.Any(p => p.PackageName.Equals(arg.TypeName))))
{
field.ContainerClassName = Trns.ClassNameOfOracleIdentifier(arg.TypeName).Code;
}
if (!(arg.TypeName ?? "").Equals(arg.PackageName) &&
Packages.Any(p => p.PackageName.Equals(arg.TypeName)) && // package of origin of record being created
PackageRecordTypes.Exists(r => r.PackageName.Equals(arg.TypeName) && r.TypeSubName.Equals(arg.TypeSubname)))
{
field.ContainerClassName = Trns.ClassNameOfOracleIdentifier(arg.TypeName).Code;
}
}
return(field);
}
void Publish(IPackageRepository source, string packageFileName, Stream packageStream)
{
var name = PackageNameUtility.GetName(packageFileName);
var version = PackageNameUtility.GetVersion(packageFileName);
if (Packages.Any(x => x.Name.EqualsNoCase(name) && x.SemanticVersion == version))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = inMemoryFile.OpenWrite())
IO.StreamExtensions.CopyTo(packageStream, stream);
var tempFolder = new ZipFilePackage(inMemoryFile);
var package = new InMemoryPackage(tempFolder)
{
Source = this
};
Packages.Add(package);
}
/// <summary>
/// Given a record type argument, extract and store the record type and its fields (recurse if necessary)
/// </summary>
/// <param name="recordArg">Argument with record</param>
/// <param name="args">List of arguments following record argument</param>
private void LoadRecordType <T_PackageRecord, T_Field, T_Argument>(IArgument recordArg, List <IArgument> args, String cSharpType)
where T_PackageRecord : class, IPackageRecord, new()
where T_Field : class, IField, new()
where T_Argument : class, IArgument, new()
{
if (recordArg.DataType != Orcl.RECORD)
{
throw new Exception("Argument sent to LoadRecordType() that is not a PL/SQL RECORD");
}
// happens for type OBJECT, TABLE, VARRAY or UNDEFINED
if ((recordArg.TypeName == null && recordArg.TypeSubname != null) || (recordArg.TypeName != null && recordArg.TypeSubname == null))
{
return;
}
if (cSharpType == null)
{
cSharpType = Translater.ConvertOracleArgTypeToCSharpType(recordArg, false);
}
// if the record type has already been stored, do not proceeed
if (PackageRecordTypes.Any(r => (r.SubName ?? "") == (recordArg.TypeSubname ?? "") &&
(r.Name ?? "") == (recordArg.TypeName ?? "") &&
(r.Owner ?? "") == (recordArg.TypeOwner ?? "") &&
(r.PackageName ?? "") == (recordArg.PackageName ?? "")))
{
return;
}
// begin creation of record type
IPackageRecord newRec = new T_PackageRecord();
newRec.PackageName = recordArg.PackageName; // package containing argument
newRec.Name = recordArg.TypeName; // package containing *record type*
newRec.SubName = recordArg.TypeSubname; // name of record type if outside argument's package
newRec.CSharpType = cSharpType;
newRec.Owner = recordArg.TypeOwner;
newRec.Attributes = new List <IEntityAttribute>();
int recordDataLevel = recordArg.DataLevel;
// loop the args to find this record's fields or a nested record type
int columnPosition = 0;
foreach (IArgument arg in args)
{
if (arg.DataLevel == recordDataLevel + 1) // found a record field
// each of these fields are to be added to the record
{
IField f = new T_Field();
f.Name = arg.ArgumentName;
// convert to C# now - this should to be adjusted so it's done later
f.CSharpType = Translater.ConvertOracleArgTypeToCSharpType(arg, false);
// set the containing class from the package name
if (!String.IsNullOrEmpty(arg.TypeName) && !arg.TypeName.Equals(arg.PackageName))
{
if (!Parameter.Instance.IsDuplicatePackageRecordOriginatingOutsideFilterAndSchema
// owned by another schema or owned by package that was filtered out
&& (!(arg.Owner ?? "").Equals(arg.TypeOwner)
// || !_packages.Exists(p => p.PackageName.Equals(arg.TypeName)) ) ) {
|| !Packages.Any(p => p.PackageName.Equals(arg.TypeName))))
{
f.ContainerClassName = Translater.ConvertOracleNameToCSharpName(arg.TypeName, false);
}
if (!(arg.TypeName ?? "").Equals(arg.PackageName)
// && _packages.Exists(p => p.PackageName.Equals(arg.TypeName)) // package of origin of record being created
&& Packages.Any(p => p.PackageName.Equals(arg.TypeName)) && // package of origin of record being created
PackageRecordTypes.Exists(r => r.PackageName.Equals(arg.TypeName) && r.SubName.Equals(arg.TypeSubname)))
{
f.ContainerClassName = Translater.ConvertOracleNameToCSharpName(arg.TypeName, false);
}
}
f.AttrType = arg.DataType;
f.Length = arg.DataLength;
f.Precision = arg.DataPrecision;
f.Scale = arg.DataScale;
f.MapPosition = columnPosition++;
newRec.Attributes.Add(f);
}
else if (arg.DataLevel == recordDataLevel + 2) // found a lower level field, so skip
{
continue;
}
else if (arg.DataLevel <= recordDataLevel) // we are past the last record field, we are done
{
break;
}
// if field is nested record, recurse into it
if (arg.DataType == Orcl.RECORD)
{
LoadRecordType <T_PackageRecord, T_Field, T_Argument>(arg, args.GetRange(args.IndexOf(arg) + 1, args.Count - args.IndexOf(arg) - 1), null);
}
}
// newRec.Fields.Sort();
PackageRecordTypes.Add(newRec);
return;
}
public void TakeAllEntries(Label count, List <Peer> peers)
{
GetDump(FilePath);
I = 0;
List <Package> packages = new List <Package>();
foreach (var item in peers)
{
var taker = Dump.Packages.Where(x => (x.From == item.IP || x.To == item.IP) && (!Packages.Any(y => y.Id == x.Id))).ToList();
Packages.AddRange(taker);
}
count.Content = Packages.Count.ToString();
}
public virtual List <ProjectResource> Save(bool saveProject = true)
{
var list = new List <ProjectResource> ();
if (saveProject)
{
if (project == null)
{
project = new ProjectResource {
Path = ProjectFilePath,
Encoding = System.Text.Encoding.UTF8,
};
}
// Clear the Timestamp if the project changed
var contents = SaveProject();
if (contents != project.Content)
{
project.Timestamp = null;
project.Content = contents;
}
list.Add(project);
}
if (Packages.Any())
{
var contents = "<packages>\n" + string.Concat(Packages.Select(p => string.Format(" <package id='{0}' version='{1}' targetFramework='{2}' />\n",
p.Id, p.Version, p.TargetFramework))) + "</packages>";
var timestamp = contents != packages_config_contents ? default(DateTimeOffset?) : DateTimeOffset.MinValue;
list.Add(new ProjectResource()
{
Timestamp = timestamp,
Path = "packages.config",
Content = packages_config_contents = contents,
});
}
else
{
packages_config_contents = null;
}
foreach (var ig in ItemGroupList)
{
list.AddRange(ig.Select(s => new ProjectResource()
{
Timestamp = s.Timestamp,
Path = s.Include?.Invoke(),
Content = s.TextContent == null ? null : s.TextContent(),
BinaryContent = s.BinaryContent == null ? null : s.BinaryContent(),
Encoding = s.Encoding,
Deleted = s.Deleted,
Attributes = s.Attributes,
}));
}
foreach (var import in Imports)
{
list.Add(new ProjectResource()
{
Timestamp = import.Timestamp,
Path = import.Project(),
Content = import.TextContent == null ? null : import.TextContent(),
Encoding = System.Text.Encoding.UTF8,
});
}
return(list);
}
public bool HasPackage(string packageName)
{
return(Packages.Any(p => String.Equals(p.Name, packageName, StringComparison.InvariantCultureIgnoreCase)));
}
public bool Contains(string name)
{
return(Packages.Any(p => p.Name == name));
}
public DeleteAccountViewModel()
{
_hasOrphanPackages = new Lazy <bool>(() => Packages.Any(p => p.HasSingleOwner));
}
public async Task LoadPackages()
{
try
{
if (!CanLoadRemotePackages() && Packages.Any())
{
return;
}
_hasLoaded = false;
var sort = SortSelection == Resources.RemoteSourceViewModel_SortSelectionPopularity ? "DownloadCount" : "Title";
await _progressService.StartLoading(string.Format(Resources.RemoteSourceViewModel_LoadingPage, CurrentPage));
_progressService.WriteMessage(Resources.RemoteSourceViewModel_FetchingPackages);
try
{
var result =
await
_chocolateyPackageService.Search(
SearchQuery,
new PackageSearchOptions(
PageSize,
CurrentPage - 1,
sort,
IncludePrerelease,
IncludeAllVersions,
MatchWord,
Source.Value));
var installed = await _chocolateyPackageService.GetInstalledPackages();
var outdated = await _chocolateyPackageService.GetOutdatedPackages();
PageCount = (int)(((double)result.TotalCount / (double)PageSize) + 0.5);
Packages.Clear();
result.Packages.ToList().ForEach(p =>
{
if (installed.Any(package => string.Equals(package.Id, p.Id, StringComparison.OrdinalIgnoreCase)))
{
p.IsInstalled = true;
}
if (outdated.Any(package => string.Equals(package.Item1, p.Id, StringComparison.OrdinalIgnoreCase)))
{
p.IsLatestVersion = false;
}
Packages.Add(Mapper.Map <IPackageViewModel>(p));
});
if (PageCount < CurrentPage)
{
CurrentPage = PageCount == 0 ? 1 : PageCount;
}
}
finally
{
await _progressService.StopLoading();
_hasLoaded = true;
}
await _eventAggregator.PublishOnUIThreadAsync(new ResetScrollPositionMessage());
}
catch (Exception ex)
{
Logger.Error(ex, "Failed to load new packages.");
await _progressService.ShowMessageAsync(
Resources.RemoteSourceViewModel_FailedToLoad,
string.Format(Resources.RemoteSourceViewModel_FailedToLoadRemotePackages, ex.Message));
throw;
}
}
public bool CanUpdateAll()
{
return(Packages.Any(p => p.CanUpdate) && _allowedCommandsService.IsUpgradeCommandAllowed && _allowedCommandsService.IsUpgradeAllCommandAllowed);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The Install method installs the feature.
/// </summary>
/// -----------------------------------------------------------------------------
public bool Install()
{
InstallerInfo.Log.StartJob(Util.INSTALL_Start);
bool bStatus = true;
try
{
bool clearClientCache = false;
InstallPackages(ref clearClientCache);
if (clearClientCache)
{
//Update the version of the client resources - so the cache is cleared
HostController.Instance.IncrementCrmVersion(true);
}
}
catch (Exception ex)
{
InstallerInfo.Log.AddFailure(ex);
bStatus = false;
}
finally
{
//Delete Temp Folder
if (!string.IsNullOrEmpty(TempInstallFolder))
{
Globals.DeleteFolderRecursive(TempInstallFolder);
}
InstallerInfo.Log.AddInfo(Util.FOLDER_DeletedBackup);
}
if (InstallerInfo.Log.Valid)
{
InstallerInfo.Log.EndJob(Util.INSTALL_Success);
}
else
{
InstallerInfo.Log.EndJob(Util.INSTALL_Failed);
bStatus = false;
}
//log installation event
LogInstallEvent("Package", "Install");
//when the installer initialized by file stream, we need save the file stream into backup folder.
if (_inputStream != null && bStatus && Packages.Any())
{
Task.Run(() =>
{
BackupStreamIntoFile(_inputStream, Packages[0].Package);
});
}
//Clear Host Cache
DataCache.ClearHostCache(true);
if (Config.GetFcnMode() == Config.FcnMode.Disabled.ToString())
{
// force application restart after the new changes only when FCN is disabled
Config.Touch();
}
return(bStatus);
}
public async Task LoadPackages(bool forceCheckForOutdatedPackages)
{
try
{
if (!CanLoadRemotePackages() && Packages.Any())
{
return;
}
if (!HasLoaded && (_configService.GetEffectiveConfiguration().PreventPreload ?? false))
{
ShowShouldPreventPreloadMessage = true;
HasLoaded = true;
return;
}
HasLoaded = false;
ShowShouldPreventPreloadMessage = false;
var sort = SortSelection == Resources.RemoteSourceViewModel_SortSelectionPopularity ? "DownloadCount" : "Title";
await _progressService.StartLoading(string.Format(Resources.RemoteSourceViewModel_LoadingPage, CurrentPage));
_progressService.WriteMessage(Resources.RemoteSourceViewModel_FetchingPackages);
try
{
var result =
await
_chocolateyPackageService.Search(
SearchQuery,
new PackageSearchOptions(
PageSize,
CurrentPage - 1,
sort,
IncludePrerelease,
IncludeAllVersions,
MatchWord,
Source.Value));
var installed = await _chocolateyPackageService.GetInstalledPackages();
var outdated = await _chocolateyPackageService.GetOutdatedPackages(false, null, forceCheckForOutdatedPackages);
PageCount = (int)Math.Ceiling((double)result.TotalCount / (double)PageSize);
Packages.Clear();
SourceType sourceType = SourceType.normal;
Enum.TryParse <SourceType>(Source.Value, out sourceType);
result.Packages.ToList().ForEach(p =>
{
if (installed.Any(package => string.Equals(package.Id, p.Id, StringComparison.OrdinalIgnoreCase)))
{
p.IsInstalled = true;
}
if (outdated.Any(package => string.Equals(package.Id, p.Id, StringComparison.OrdinalIgnoreCase)))
{
p.IsLatestVersion = false;
}
var pnew = Mapper.Map <IPackageViewModel>(p);
pnew.SourceType = sourceType;
Packages.Add(pnew);
});
if (_configService.GetEffectiveConfiguration().ExcludeInstalledPackages ?? false)
{
Packages.RemoveAll(x => x.IsInstalled);
}
if (PageCount < CurrentPage)
{
CurrentPage = PageCount == 0 ? 1 : PageCount;
}
}
finally
{
await _progressService.StopLoading();
HasLoaded = true;
}
await _eventAggregator.PublishOnUIThreadAsync(new ResetScrollPositionMessage());
}
catch (Exception ex)
{
Logger.Error(ex, "Failed to load new packages.");
await _dialogService.ShowMessageAsync(
Resources.RemoteSourceViewModel_FailedToLoad,
string.Format(Resources.RemoteSourceViewModel_FailedToLoadRemotePackages, ex.Message));
throw;
}
}
public bool CanUpdateAll()
{
return(Packages.Any(p => p.CanUpdate));
}
public ServiceWizardViewModel(PanaceaServices core, TaskCompletionSource <bool> source)
{
_core = core;
_source = source;
SelectedItems = new ObservableCollection <Service>();
RemoveServiceCommand = new RelayCommand(args =>
{
SelectedItems.Remove(args as Service);
if (!SelectedItems.Any())
{
CartBoxIsOpen = false;
}
});
SwitchToServicesCommand = new RelayCommand(args =>
{
if (SelectedIndex == 0)
{
SelectedIndex = 1;
}
else
{
SelectedIndex = 0;
}
});
BuyServiceCommand = new RelayCommand(arg =>
{
SelectedItems.Clear();
TabsSelectedIndex = 0;
});
CompleteCommand = new RelayCommand(arg =>
{
source.TrySetResult(true);
});
ToggleCartBoxCommand = new RelayCommand(arg =>
{
CartBoxIsOpen = !CartBoxIsOpen;
});
CheckoutCommand = new RelayCommand(async args =>
{
if (Packages != null && Packages.Any(p => p.IsChecked) ||
Services != null && Services.Any(s => s.IsChecked))
{
CartBoxIsOpen = false;
if (core.UserService.User.Id == null)
{
if (core.TryGetUserAccountManager(out IUserAccountManager account))
{
_waitingForAnotherTask = true;
if (await account.RequestLoginAsync("In order to continue, you need to sign in with your user account"))
{
_waitingForAnotherTask = false;
TabsSelectedIndex = 1;
CreateWebBrowser();
BuyService();
}
}
//todo TabsSelectedIndex = 1;
}
else
{
var pop = new UserConfirmationViewModel(_core.UserService.User);
if (_core.TryGetUiManager(out IUiManager ui))
{
var res = await ui.ShowPopup(pop);
if (res == UserConfirmationResult.Confirm)
{
TabsSelectedIndex = 1;
CreateWebBrowser();
BuyService();
//CheckUserService(() =>
//{
// });
}
else if (res == UserConfirmationResult.NotMe)
{
if (!(_core.TryGetUserAccountManager(out IUserAccountManager user) && await user.LogoutAsync()))
{
await _core.UserService.LogoutAsync(); //todo (true)
}
CheckoutCommand.Execute(null);
}
else
{
CartBoxIsOpen = true;
}
}
}
}
else
{
if (core.TryGetUiManager(out IUiManager ui))
{
await ui.ShowPopup(new NoServiceSelectedPopupViewModel());
}
}
});
SelectCommand = new RelayCommand(args =>
{
var package = args as Service;
if (package == null)
{
return;
}
CancelButtonVisibility = Visibility.Collapsed;
CancelButtonServicesVisibility = Visibility.Visible;
if (package is Package)
{
CancelButtonVisibility = Visibility.Visible;
CancelButtonServicesVisibility = Visibility.Collapsed;
SelectedItems.Clear();
Packages.ForEach(lp => lp.IsChecked = false);
Services.ForEach(lp => lp.IsChecked = false);
package.IsChecked = true;
}
else if (SelectedItems.Any(i => i is Package))
{
SelectedItems.Clear();
Packages.ForEach(lp => lp.IsChecked = false);
Services.ForEach(lp => lp.IsChecked = false);
package.IsChecked = true;
}
if (SelectedItems.Contains(package))
{
SelectedItems.Remove(package);
package.IsChecked = false;
CartBoxIsOpen = SelectedItems.Count > 0;
HasSelectedPerDay = SelectedItems.All(i => i.IsPricePerDay);
UpdateSum();
TotalPanelVisibility = SelectedItems.Any(i => i.IsPricePerDay) || SelectedItems.Count > 1
? Visibility.Visible
: Visibility.Collapsed;
return;
}
if ((package.IsPricePerDay && SelectedItems.Any(s => !s.IsPricePerDay)) ||
(!package.IsPricePerDay && SelectedItems.Any(s => s.IsPricePerDay)))
{
/*todo
* var warning = new ChangeServiceTypeWarning();
* warning.Continue += (oo, ee) =>
* {
* window.ThemeManager.HidePopup(warning);
* SelectedItems.Clear();
* packages.ForEach(lp => lp.IsChecked = false);
* services.ForEach(lp => lp.IsChecked = false);
* package.IsChecked = true;
* SelectedItems.Add(package);
* CartBox.IsOpen = SelectedItems.Count > 0;
* HasSelectedPerDay = SelectedItems.All(i => i.IsPricePerDay);
* UpdateSum();
* TotalPanel.Visibility = SelectedItems.Any(i => i.IsPricePerDay) || SelectedItems.Count > 1
* ? Visibility.Visible
* : Visibility.Collapsed;
* };
*
* warning.Cancel += (oo, ee) =>
* {
* window.ThemeManager.HidePopup(warning);
* package.IsChecked = false;
* CartBox.IsOpen = SelectedItems.Count > 0;
* };
* CartBoxIsOpen = false;
*
* window.ThemeManager.ShowPopup(warning).Closed += (oo, ee) =>
* {
* package.IsChecked = false;
* };
*/
}
else
{
SelectedItems.Add(package);
CartBoxIsOpen = SelectedItems.Count > 0;
HasSelectedPerDay = SelectedItems.All(i => i.IsPricePerDay);
UpdateSum();
TotalPanelVisibility = SelectedItems.Any(i => i.IsPricePerDay) || SelectedItems.Count > 1
? Visibility.Visible
: Visibility.Collapsed;
}
});
}
