private static List <string> GetAddonsInPackageSorted(AddonPackageSet pPackageSet)
{
List <string> addons = new List <string>();
if ((pPackageSet.Addons?.Count ?? 0) == 0)
{
return(addons);
}
foreach (AddonPackage addon in pPackageSet.Addons)
{
addons.Add($"{addon.Name} [{addon.Publisher}]");
}
addons.Sort();
// Removes duplicated...
List <string> notDups = new List <string>();
string last = "xxx";
foreach (string item in addons)
{
if (item == last)
{
continue;
}
notDups.Add(item);
last = item;
}
return(notDups);
}
// ----------------------------------------------------------------------------------------------------------------------
private bool NewCatalogue()
{
string newCatalogueName = CheckCatalogueName(tbNewCat.Text);
if (newCatalogueName == null)
{
tbNewCat.Focus();
return(false);
}
if (CheckNameDuplicate(newCatalogueName))
{
tbNewCat.Focus();
return(false);
}
NewAddonPackageSet = new AddonPackageSet(_moviestormPaths, null, tbDescription.Text.Trim());
string newCatalogueFilename = newCatalogueName + ".scat";
string errorText;
NewAddonPackageSet.Save(out errorText, newCatalogueFilename);
CataloguesIndex.Update(newCatalogueName, tbDescription.Text, NewAddonPackageSet.Addons?.Count ?? 0, NewAddonPackageSet.LastUpdate, NewAddonPackageSet.CatalogueVersion);
NewAddonPackageSetName = newCatalogueName;
return(true);
}
private bool EditCatalogueDescription()
{
string newDescription = tbDescription.Text.Trim();
CatalogueInfo selectedCatalogue = CataloguesIndex.GetByName(_selectedCatalogueName);
string oldDescription = selectedCatalogue.Description?.Trim() ?? "";
if (oldDescription == newDescription)
{
return(true);
}
string errorText;
AddonPackageSet selectedAddonPackageSet = AddonPackageSet.Load(out errorText, selectedCatalogue.FilePath);
selectedAddonPackageSet.SetDescription(newDescription);
if (!selectedAddonPackageSet.Save(out errorText, selectedCatalogue.FilePath))
{
MessageBox.Show(errorText, "Error saving updated catalogue", MessageBoxButtons.OK);
tbDescription.Focus();
return(false);
}
CataloguesIndex.Update(_selectedCatalogueName, newDescription);
NewAddonPackageSet = selectedAddonPackageSet;
return(true);
}
public AssetSearchResultForm(List <AssetSearchResultItem> pAssets, AddonPackageSet pAddonPackageSet, bool pListAlwaysAnimations)
{
_assets = pAssets;
_addonPackageSet = pAddonPackageSet;
_listAlwaysAnimations = pListAlwaysAnimations;
InitializeComponent();
}
// --------------------------------------------------------------------------------------------------------------------
public CompareByFingerprintForm(List <AddonPackage> pAddons, AddonPackageSet pAddonPackageSet, TextBox pLogOutput)
{
_addons = pAddons;
_addonPackageSet = pAddonPackageSet;
_logOutput = pLogOutput;
InitializeComponent();
}
private static CataloguesIndex InitializeNoCatalogues(MoviestormPaths pMoviestormPaths, out string pErrorText)
{
CataloguesIndex cataloguesIndex = new CataloguesIndex();
cataloguesIndex.Catalogues = new List <CatalogueInfo>();
AddonPackageSet packageSet = new AddonPackageSet(pMoviestormPaths, null)
{
Description = "Default catalogue"
};
packageSet.Save(out pErrorText, cataloguesIndex.DefaultAddonDatabaseFilename);
CatalogueInfo catalogue = new CatalogueInfo()
{
Name = cataloguesIndex.DefaultAddonDatabase,
Description = "Default catalogue",
AddonCount = 0,
LastUpdateDateTime = packageSet.LastUpdate,
Version = packageSet.CatalogueVersion
};
cataloguesIndex.Catalogues.Add(catalogue);
cataloguesIndex.Save(CataloguesIndexFilePath, out pErrorText);
return(cataloguesIndex);
}
// -------------------------------------------------------------------------------------------------
public static CataloguesIndex Initialize(MoviestormPaths pMoviestormPaths, out string pErrorText)
{
pErrorText = null;
List <string> catalogueFiles = Directory.EnumerateFiles(Utils.GetExecutableDirectory(), "*.scat").ToList();
if ((catalogueFiles == null) || (catalogueFiles.Count == 0))
{
return(InitializeNoCatalogues(pMoviestormPaths, out pErrorText));
}
int defaultIndex = -1;
int index = 0;
List <CatalogueInfo> catalogues = new List <CatalogueInfo>();
foreach (string file in catalogueFiles)
{
CatalogueInfo catalogue = new CatalogueInfo()
{
Name = Path.GetFileNameWithoutExtension(file)
};
string errorText;
AddonPackageSet packageSet = AddonPackageSet.Load(out errorText, file);
catalogue.Description = packageSet?.Description;
if ((catalogue.FilePath.ToLower() == AddonPackageSet.DefaultAddonPackageSetFileName.ToLower()) ||
(catalogueFiles.Count == 1))
{
if (catalogue.Description == null)
{
catalogue.Description = "Default catalogue";
}
defaultIndex = index;
}
catalogue.LastUpdateDateTime = packageSet.LastUpdate;
catalogue.AddonCount = packageSet?.Addons.Count ?? 0;
catalogue.Version = packageSet.CatalogueVersion;
catalogues.Add(catalogue);
index++;
}
CataloguesIndex cataloguesIndex = new CataloguesIndex();
cataloguesIndex.Catalogues = catalogues.OrderBy(o => o.FilePath).ToList();
cataloguesIndex.DefaultAddonDatabase =
(defaultIndex < 0)
? cataloguesIndex.Catalogues[0].Name
: cataloguesIndex.Catalogues[defaultIndex].Name;
cataloguesIndex.Save(CataloguesIndexFilePath, out pErrorText);
return(cataloguesIndex);
}
private bool CheckEntity(ProcessingFlags pProcessingFlags, out string pReport)
{
pReport = null;
bool showDetailedContents = pProcessingFlags.HasFlag(ProcessingFlags.ShowAddonContents);
bool appendToPackageSet = pProcessingFlags.HasFlag(ProcessingFlags.AppendToAddonPackageSet);
if (!showDetailedContents)
{
pReport = BriefReport();
if (!appendToPackageSet)
{
return(true);
}
}
string tempPath = Utils.GetTempDirectory();
AddonPackage package = new AddonPackage(AbsolutePath, pProcessingFlags, tempPath);
if (showDetailedContents)
{
pReport = package?.ToString();
}
if (appendToPackageSet && (AddonPackageSet != null) && (package != null))
{
if (package.HasIssues)
{
pReport += " >>> NOT inserted/updated into Catalogue (has problems!)";
}
else
{
if (AddonPackageSet.Append(package, pProcessingFlags.HasFlag(ProcessingFlags.AppendToAddonPackageSetForceRefresh)))
{
pReport += " >>> Inserted/updated into Catalogue";
}
}
}
return(true);
}
private bool CopyCatalogue()
{
string newCatalogueName = CheckCatalogueName(tbNewCat.Text);
if (newCatalogueName == null)
{
tbNewCat.Focus();
return(false);
}
if (CheckNameDuplicate(newCatalogueName))
{
tbNewCat.Focus();
return(false);
}
CatalogueInfo selectedCatalogue = CataloguesIndex.GetByName(_selectedCatalogueName);
string errorText;
AddonPackageSet newPackageSet = AddonPackageSet.Load(out errorText, selectedCatalogue.FilePath);
newPackageSet.SetDescription(tbDescription.Text.Trim());
if (!newPackageSet.Save(out errorText, newCatalogueName + ".scat"))
{
MessageBox.Show(errorText, "Error saving copied catalogue", MessageBoxButtons.OK);
return(false);
}
CataloguesIndex.Update(newCatalogueName, tbDescription.Text.Trim(), newPackageSet.Addons?.Count ?? 0, newPackageSet.LastUpdate, newPackageSet.CatalogueVersion);
NewAddonPackageSet = newPackageSet;
NewAddonPackageSetName = newCatalogueName;
return(true);
}
public AddonPackageSetOperator(AddonPackageSet pAddonPackageSet)
{
AddonPackageSet = pAddonPackageSet;
}
// ---------------------------------------------------------------------------------------------------------------------------
public static List <CatalogueContentComparisionItem> CompareCataloguesContents(AddonPackageSet pPackageSet0, AddonPackageSet pPackageSet1)
{
List <string> addonsCatalogue0 = GetAddonsInPackageSorted(pPackageSet0);
List <string> addonsCatalogue1 = GetAddonsInPackageSorted(pPackageSet1);
List <CatalogueContentComparisionItem> comparisionItems = new List <CatalogueContentComparisionItem>();
if (addonsCatalogue0.Count == 0)
{
foreach (string addon1 in addonsCatalogue1)
{
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue1 = addon1
});
}
return(comparisionItems);
}
if (addonsCatalogue1.Count == 0)
{
foreach (string addon0 in addonsCatalogue0)
{
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue0 = addon0
});
}
return(comparisionItems);
}
do
{
string addon0 = addonsCatalogue0.Count > 0 ? addonsCatalogue0[0] : "";
string addon1 = addonsCatalogue1.Count > 0 ? addonsCatalogue1[0] : "";
if (addon0 == "")
{
if (addon1 == "")
{
break; // it shoudn't happen
}
foreach (string addon in addonsCatalogue1)
{
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue1 = addon
});
}
break;
}
if (addon1 == "")
{
foreach (string addon in addonsCatalogue0)
{
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue0 = addon
});
}
break;
}
int stringCompare = string.Compare(addon0, addon1, StringComparison.InvariantCulture);
if (stringCompare == 0)
{
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue0 = addon0, AddonCatalogue1 = addon1
});
addonsCatalogue0.RemoveAt(0);
addonsCatalogue1.RemoveAt(0);
continue;
}
if (stringCompare < 0)
{
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue0 = addon0
});
addonsCatalogue0.RemoveAt(0);
continue;
}
comparisionItems.Add(new CatalogueContentComparisionItem()
{
AddonCatalogue1 = addon1
});
addonsCatalogue1.RemoveAt(0);
} while ((addonsCatalogue0.Count > 0) || (addonsCatalogue1.Count > 0));
return(comparisionItems);
}
private bool CheckEntity(ProcessingFlags pProcessingFlags, out string pReport)
{
bool reportOnlyIssues = pProcessingFlags.HasFlag(ProcessingFlags.JustReportIssues);
bool showAddonContents = pProcessingFlags.HasFlag(ProcessingFlags.ShowAddonContents);
bool appendToPackageSet = pProcessingFlags.HasFlag(ProcessingFlags.AppendToAddonPackageSet);
List <ArchiveFileInfo> entryList;
SevenZipArchiver archiver = new SevenZipArchiver(AbsolutePath);
archiver.ArchivedFileList(out entryList);
if ((entryList?.Count ?? -1) <= 0)
{
pReport = $"{ErrorTokenString} Invalid file or format";
if (showAddonContents)
{
pReport += "\n";
}
return(false);
}
List <string> demoMovies, stockAssets;
bool hasMeshes, hasData;
AddonSignatureFile addonSignature;
bool formatOk = CheckFormat(archiver, entryList, out hasMeshes, out hasData, out demoMovies, out stockAssets, out addonSignature);
if (!formatOk)
{
pReport = $"{ErrorTokenString} Invalid/obsolete addon format";
if (showAddonContents)
{
pReport += "\n";
}
return(false);
}
// Addon good format
pReport = null;
if (reportOnlyIssues)
{
return(true);
}
if (!showAddonContents)
{
pReport = (hasMeshes ? "OK" : "OK, no meshes");
if (demoMovies != null)
{
pReport += " (incl. Movies)";
}
if (stockAssets != null)
{
pReport += " (incl. Stock assets)";
}
string freeText = addonSignature.Free ? "" : " NOT FREE!";
pReport += $" [{addonSignature.Publisher}{freeText}]";
if (!appendToPackageSet)
{
return(true);
}
}
string tempPath = Utils.GetTempDirectory();
AddonPackage package = new AddonPackage(archiver, pProcessingFlags, tempPath, ArchivedPath);
if (showAddonContents)
{
pReport = package?.ToString();
}
if (appendToPackageSet && (AddonPackageSet != null) && (package != null))
{
if (package.HasIssues)
{
pReport += " >>> Not inserted/updated into Catalogue (has problems!)";
}
else
{
if (AddonPackageSet.Append(package, pProcessingFlags.HasFlag(ProcessingFlags.AppendToAddonPackageSetForceRefresh)))
{
pReport += " >>> Inserted/updated into Catalogue";
}
}
}
return(true);
}
