//
//====================================================================================================
/// <summary>
/// Install a collectionZip from the Collection Library (registry, distribution, etc.)
/// downloads the collection to a private folder
/// Calls installCollectionFromCollectionFolder.
/// </summary>
/// <param name="core"></param>
/// <param name="collectionGuid"></param>
/// <param name="return_ErrorMessage"></param>
/// <param name="ImportFromCollectionsGuidList"></param>
/// <param name="IsNewBuild"></param>
/// <param name="repair"></param>
/// <param name="nonCriticalErrorList"></param>
/// <param name="logPrefix"></param>
/// <param name="collectionsInstalledList"></param>
/// <returns></returns>
public static bool installCollectionFromLibrary(CoreController core, bool isDependency, Stack <string> contextLog, string collectionGuid, ref string return_ErrorMessage, bool IsNewBuild, bool repair, ref List <string> nonCriticalErrorList, string logPrefix, ref List <string> collectionsInstalledList)
{
bool UpgradeOK = true;
try {
//
contextLog.Push(MethodInfo.GetCurrentMethod().Name + ", [" + collectionGuid + "]");
//
collectionGuid = GenericController.normalizeGuid(collectionGuid);
if (string.IsNullOrWhiteSpace(collectionGuid))
{
LogController.logWarn(core, "installCollectionFromRemoteRepo, collectionGuid is null");
}
else if (!collectionsInstalledList.Contains(collectionGuid.ToLower(CultureInfo.InvariantCulture)))
{
//
// Download all files for this collection and build the collection folder(s)
string tempFilesDownloadPath = AddonController.getPrivateFilesAddonPath() + Contensive.Processor.Controllers.GenericController.getGUIDNaked() + "\\";
core.tempFiles.createPath(tempFilesDownloadPath);
//
// -- download the collection file into the download path from the collectionGuid provided
DateTime CollectionLastModifiedDate = default;
if (CollectionLibraryController.downloadCollectionFromLibrary(core, tempFilesDownloadPath, collectionGuid, ref CollectionLastModifiedDate, ref return_ErrorMessage))
{
//
// -- build the collection folders for all collection files in the download path and created a list of collection Guids that need to be installed
var collectionsDownloaded = new List <string>();
CollectionInstallController.installCollectionsFromTempFolder(core, isDependency, contextLog, tempFilesDownloadPath, ref return_ErrorMessage, ref collectionsInstalledList, IsNewBuild, repair, ref nonCriticalErrorList, logPrefix, true, ref collectionsDownloaded);
}
//
// -- delete the temporary install folder
core.tempFiles.deleteFolder(tempFilesDownloadPath);
//
// -- invalidate cache
core.cache.invalidateAll();
}
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
} finally {
contextLog.Pop();
}
return(UpgradeOK);
}
//
//====================================================================================================
/// <summary>
/// Builds collection folders for a collectionZip file
/// unzip a folder and if the collection is not in the collections installed or the collectionsToInstall, save the collection to the appropriate collection folder and add it to the collectionsToInstall
/// </summary>
/// <param name="core"></param>
/// <param name="sourceTempFolderPathFilename"></param>
/// <param name="CollectionLastChangeDate"></param>
/// <param name="collectionGuid"></param>
/// <param name="return_ErrorMessage"></param>
/// <param name="collectionsDownloaded">collection guids that have been saved to the collection folder and need to be saved to the database druing this install.</param>
/// <param name="collectionsInstalledList">collection guids that have been saved to the database during this install.</param>
/// <param name="collectionsBuildingFolder">folder building is recursive. These are the collection guids whose folders are currently being built.</param>
/// <returns></returns>
public static bool buildCollectionFolderFromCollectionZip(CoreController core, Stack <string> contextLog, string sourceTempFolderPathFilename, DateTime CollectionLastChangeDate, ref string return_ErrorMessage, ref List <string> collectionsDownloaded, ref List <string> collectionsInstalledList, ref List <string> collectionsBuildingFolder)
{
try {
//
contextLog.Push(MethodInfo.GetCurrentMethod().Name + ", [" + sourceTempFolderPathFilename + "]");
traceContextLog(core, contextLog);
//
string collectionPath = "";
string collectionFilename = "";
core.tempFiles.splitDosPathFilename(sourceTempFolderPathFilename, ref collectionPath, ref collectionFilename);
string CollectionVersionFolderName = "";
if (!core.tempFiles.pathExists(collectionPath))
{
//
// return false, The working folder is not there
return_ErrorMessage = "<p>There was a problem with the installation. The installation folder is not valid.</p>";
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, CheckFileFolder was false for the temp folder [" + collectionPath + "]");
return(false);
}
//
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, processing files in temp folder [" + collectionPath + "]");
//
// --move collection file to a temp directory
// -- use try-finally to delete temp folder
string tmpInstallPath = "tmpInstallCollection" + GenericController.getGUIDNaked() + "\\";
try {
core.tempFiles.copyFile(sourceTempFolderPathFilename, tmpInstallPath + collectionFilename);
if (collectionFilename.ToLowerInvariant().Substring(collectionFilename.Length - 4) == ".zip")
{
core.tempFiles.unzipFile(tmpInstallPath + collectionFilename);
core.tempFiles.deleteFile(tmpInstallPath + collectionFilename);
}
//
// -- find xml file in temp folder and process it
bool CollectionXmlFileFound = false;
foreach (FileDetail file in core.tempFiles.getFileList(tmpInstallPath))
{
if (file.Name.Substring(file.Name.Length - 4).ToLower(CultureInfo.InvariantCulture) == ".xml")
{
//
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", build collection folder for Collection file [" + file.Name + "]");
//
XmlDocument CollectionFile = new XmlDocument();
try {
CollectionFile.LoadXml(core.tempFiles.readFileText(tmpInstallPath + file.Name));
} catch (Exception ex) {
//
// -- There was a parse error in this xml file. Set the return message and the flag
// -- If another xml files shows up, and process OK it will cover this error
return_ErrorMessage = "There was a problem installing the Collection File [" + tmpInstallPath + file.Name + "]. The error reported was [" + ex.Message + "].";
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, error reading collection [" + sourceTempFolderPathFilename + "]");
continue;
}
string CollectionFileBaseName = GenericController.toLCase(CollectionFile.DocumentElement.Name);
if ((CollectionFileBaseName != "contensivecdef") && (CollectionFileBaseName != CollectionFileRootNode) && (CollectionFileBaseName != GenericController.toLCase(CollectionFileRootNodeOld)))
{
//
// -- Not a problem, this is just not a collection file
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, xml base name wrong [" + CollectionFileBaseName + "]");
continue;
}
bool IsFound = false;
//
// Collection File
//
string Collectionname = XmlController.getXMLAttribute(core, ref IsFound, CollectionFile.DocumentElement, "name", "");
string collectionGuid = XmlController.getXMLAttribute(core, ref IsFound, CollectionFile.DocumentElement, "guid", Collectionname);
if ((!collectionsInstalledList.Contains(collectionGuid.ToLower(CultureInfo.InvariantCulture))) && (!collectionsDownloaded.Contains(collectionGuid.ToLower(CultureInfo.InvariantCulture))))
{
if (string.IsNullOrEmpty(Collectionname))
{
//
// ----- Error condition -- it must have a collection name
//
return_ErrorMessage = "<p>There was a problem with this Collection. The collection file does not have a collection name.</p>";
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, collection has no name");
continue;
}
//
//------------------------------------------------------------------
// Build Collection folder structure in /Add-ons folder
//------------------------------------------------------------------
//
collectionsDownloaded.Add(collectionGuid.ToLower(CultureInfo.InvariantCulture));
CollectionXmlFileFound = true;
if (string.IsNullOrEmpty(collectionGuid))
{
//
// must have a guid
collectionGuid = Collectionname;
}
//
//
CollectionVersionFolderName = verifyCollectionVersionFolderName(core, collectionGuid, Collectionname);
string CollectionVersionFolder = AddonController.getPrivateFilesAddonPath() + CollectionVersionFolderName;
//
core.tempFiles.copyPath(tmpInstallPath, CollectionVersionFolder, core.privateFiles);
//
// -- iterate through all nodes of this collection xml file and install all dependencies
foreach (XmlNode metaDataSection in CollectionFile.DocumentElement.ChildNodes)
{
string ChildCollectionGUID = null;
string ChildCollectionName = null;
bool Found = false;
switch (GenericController.toLCase(metaDataSection.Name))
{
case "resource":
break;
case "getcollection":
case "importcollection":
//
// -- Download Collection file into install folder
ChildCollectionName = XmlController.getXMLAttribute(core, ref Found, metaDataSection, "name", "");
ChildCollectionGUID = XmlController.getXMLAttribute(core, ref Found, metaDataSection, "guid", metaDataSection.InnerText);
if (string.IsNullOrEmpty(ChildCollectionGUID))
{
ChildCollectionGUID = metaDataSection.InnerText;
}
ChildCollectionGUID = GenericController.normalizeGuid(ChildCollectionGUID);
string statusMsg = "Installing collection [" + ChildCollectionName + ", " + ChildCollectionGUID + "] referenced from collection [" + Collectionname + "]";
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, getCollection or importcollection, childCollectionName [" + ChildCollectionName + "], childCollectionGuid [" + ChildCollectionGUID + "]");
if (GenericController.strInstr(1, CollectionVersionFolder, ChildCollectionGUID, 1) == 0)
{
if (string.IsNullOrEmpty(ChildCollectionGUID))
{
//
// -- Needs a GUID to install
return_ErrorMessage = statusMsg + ". The installation can not continue because an imported collection could not be downloaded because it does not include a valid GUID.";
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, return message [" + return_ErrorMessage + "]");
}
else
{
if ((!collectionsBuildingFolder.Contains(ChildCollectionGUID)) && (!collectionsDownloaded.Contains(ChildCollectionGUID)) && (!collectionsInstalledList.Contains(ChildCollectionGUID)))
{
//
// -- add to the list of building folders to block recursive loop
collectionsBuildingFolder.Add(ChildCollectionGUID);
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, [" + ChildCollectionGUID + "], not found so needs to be installed");
//
// If it is not already installed, download and install it also
//
string workingTempPath = GenericController.getGUIDNaked() + "\\";
DateTime libraryCollectionLastModifiedDate = default(DateTime);
try {
//
// try-finally to delete the working folder
if (!CollectionLibraryController.downloadCollectionFromLibrary(core, workingTempPath, ChildCollectionGUID, ref libraryCollectionLastModifiedDate, ref return_ErrorMessage))
{
//
// -- did not download correctly
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, [" + statusMsg + "], downloadCollectionFiles returned error state, message [" + return_ErrorMessage + "]");
if (string.IsNullOrEmpty(return_ErrorMessage))
{
return_ErrorMessage = statusMsg + ". The installation can not continue because there was an unknown error while downloading the necessary collection file, [" + ChildCollectionGUID + "].";
}
else
{
return_ErrorMessage = statusMsg + ". The installation can not continue because there was an error while downloading the necessary collection file, guid [" + ChildCollectionGUID + "]. The error was [" + return_ErrorMessage + "]";
}
}
else
{
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, libraryCollectionLastChangeDate [" + libraryCollectionLastModifiedDate.ToString() + "].");
bool installDependentCollection = true;
var localCollectionConfig = CollectionFolderModel.getCollectionFolderConfig(core, ChildCollectionGUID);
if (localCollectionConfig == null)
{
//
// -- collection not installed, ok to install
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, collection");
}
else
{
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, localCollectionConfig.lastChangeDate [" + localCollectionConfig.lastChangeDate.ToString() + "].");
if (localCollectionConfig.lastChangeDate < libraryCollectionLastModifiedDate)
{
//
// -- downloaded collection is newer than installed collection, reinstall
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, **** local version is older than library, needs to reinstall.");
}
else
{
//
// -- download is older than installed, skip the rest of the xml file processing
installDependentCollection = false;
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, **** local version is newer or the same as library, can skip install.");
break;
}
}
if (installDependentCollection)
{
//
// -- install the downloaded file
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, collection missing or needs to be updated.");
if (!buildCollectionFoldersFromCollectionZips(core, contextLog, workingTempPath, libraryCollectionLastModifiedDate, ref collectionsDownloaded, ref return_ErrorMessage, ref collectionsInstalledList, ref collectionsBuildingFolder))
{
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, [" + statusMsg + "], BuildLocalCollectionFolder returned error state, message [" + return_ErrorMessage + "]");
if (string.IsNullOrEmpty(return_ErrorMessage))
{
return_ErrorMessage = statusMsg + ". The installation can not continue because there was an unknown error installing the included collection file, guid [" + ChildCollectionGUID + "].";
}
else
{
return_ErrorMessage = statusMsg + ". The installation can not continue because there was an unknown error installing the included collection file, guid [" + ChildCollectionGUID + "]. The error was [" + return_ErrorMessage + "]";
}
}
}
}
} catch (Exception) {
//
// -- exception in try-finally for folder handling, just rethrow to the catch for hte method
throw;
} finally {
//
// -- remove child installation working folder
core.tempFiles.deleteFolder(workingTempPath);
//
// -- no longer building this folder
collectionsBuildingFolder.Remove(ChildCollectionGUID);
}
}
}
}
break;
}
if (!string.IsNullOrEmpty(return_ErrorMessage))
{
//
// -- if error during xml processing, skip the rest of the xml nodes and go to the next file.
break;
}
}
}
if (!string.IsNullOrEmpty(return_ErrorMessage))
{
//
// -- stop processing xml nodes if error
break;
}
//
// If the collection parsed correctly, update the Collections.xml file and exit loop
updateCollectionFolderConfig(core, Collectionname, collectionGuid, CollectionLastChangeDate, CollectionVersionFolderName);
break;
}
if (!string.IsNullOrEmpty(return_ErrorMessage))
{
//
// -- stop files if error
break;
}
}
//
// -- all files finished
if (string.IsNullOrEmpty(return_ErrorMessage) && !CollectionXmlFileFound)
{
//
// no errors, but xml file not found. Make an error
return_ErrorMessage = "<p>There was a problem with the installation. The collection zip was not downloaded successfully.</p>";
}
} catch (Exception) {
throw;
} finally {
//
// delete the tmp working folder
core.tempFiles.deleteFolder(tmpInstallPath);
}
//
LogController.logInfo(core, MethodInfo.GetCurrentMethod().Name + ", BuildLocalCollectionFolder, Exiting with ErrorMessage [" + return_ErrorMessage + "]");
//
return(string.IsNullOrEmpty(return_ErrorMessage));
} catch (Exception ex) {
LogController.logError(core, ex);
throw;
} finally {
contextLog.Pop();
}
}