public void ODRTagsAreCreatedAsExpected()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "ODRTags1Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "ODRTags1.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var dataset = catalog.OpenDataSet("data1");
dataset.AddVariant(new DeviceRequirement(), testFiles.CreateFile("data1.dat", "data1"), null);
dataset.AddOnDemandResourceTag("tag1");
dataset.AddOnDemandResourceTag("tag2");
catalog.Write();
string datasetPath = Path.Combine(catalogPath, "data1.dataset");
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsTrue(Directory.Exists(datasetPath));
AssertFileExistsAndHasContents(Path.Combine(datasetPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "ODRTags1.data1.dataset.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(datasetPath, "data1.dat"), "data1");
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
public void ImageSetCanBeCreatedWithDuplicateFiles()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "Imageset1Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "Imageset-duplicate.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var imageset = catalog.OpenImageSet("img1");
var filePath = testFiles.CreateFile("data1.png", "img1");
imageset.AddVariant(new DeviceRequirement().AddWidthClass(SizeClassRequirement.Regular),
filePath);
imageset.AddVariant(new DeviceRequirement().AddHeightClass(SizeClassRequirement.Compact),
filePath);
catalog.Write();
string imagesetPath = Path.Combine(catalogPath, "img1.imageset");
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsTrue(Directory.Exists(imagesetPath));
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "Imageset-duplicate.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "data1.png"), "img1");
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "data1-1.png"), "img1");
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
public AssetStoreViewModel()
{
IsInstallingAsset = false;
DisplayMaps = true;
SetSelectedCategoriesFromAppSettings();
FetchAllPreviewImages = AppSettingsUtil.GetAppSetting(SettingKey.FetchAllPreviewImages).Equals("true", StringComparison.OrdinalIgnoreCase);
if (AppSettingsUtil.GetAppSetting(SettingKey.DeleteDownloadAfterAssetInstall) == "")
{
DeleteDownloadAfterInstall = true; // default to true if does not exist in app config
}
else
{
DeleteDownloadAfterInstall = AppSettingsUtil.GetAppSetting(SettingKey.DeleteDownloadAfterAssetInstall).Equals("true", StringComparison.OrdinalIgnoreCase);
}
InstallStatusList = new List <string>()
{
defaultInstallStatusValue, "Installed", "Not Installed"
};
SelectedInstallStatus = defaultInstallStatusValue;
AuthorList = new List <AuthorDropdownViewModel>()
{
new AuthorDropdownViewModel(defaultAuthorValue, 0)
};
AuthorToFilterBy = AuthorList[0];
_catalogCache = GetCurrentCatalog();
ReloadAllAssets();
CheckForCatalogUpdatesAsync(clearCache: false);
}
public void BrandAssetCreationWorks()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "BrandAsset11Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "BrandAsset1.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var brandAssets = catalog.OpenBrandAssetGroup("brand1");
var icon1 = brandAssets.OpenImageSet("icon1", "tv", "primary-app-icon", 128, 256);
icon1.AddVariant(new DeviceRequirement(), testFiles.CreateFile("data1.png", "img1"));
catalog.Write();
string brandAssetsPath = Path.Combine(catalogPath, "brand1.brandassets");
string icon1Path = Path.Combine(brandAssetsPath, "icon1.imageset");
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsTrue(Directory.Exists(brandAssetsPath));
Assert.IsTrue(Directory.Exists(icon1Path));
AssertFileExistsAndHasContents(Path.Combine(brandAssetsPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "BrandAssets1.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(icon1Path, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "BrandAssets1.icon1.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(icon1Path, "data1.png"), "img1");
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
public void DataSetCreationWorks()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "Dataset1Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "Dataset1.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var dataset = catalog.OpenDataSet("data1");
dataset.AddVariant(new DeviceRequirement().AddDevice(DeviceTypeRequirement.iPad),
testFiles.CreateFile("data1.dat", "data1"), null);
dataset.AddVariant(new DeviceRequirement().AddMemory(MemoryRequirement.Mem1GB),
testFiles.CreateFile("data2.dat", "data2"), "testtype1");
dataset.AddVariant(new DeviceRequirement().AddMemory(MemoryRequirement.Mem2GB).AddGraphics(GraphicsRequirement.Metal1v2),
testFiles.CreateFile("data3", "data3"), "testtype2");
catalog.Write();
string datasetPath = Path.Combine(catalogPath, "data1.dataset");
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsTrue(Directory.Exists(datasetPath));
AssertFileExistsAndHasContents(Path.Combine(datasetPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "Dataset1.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(datasetPath, "data1.dat"), "data1");
AssertFileExistsAndHasContents(Path.Combine(datasetPath, "data2.dat"), "data2");
AssertFileExistsAndHasContents(Path.Combine(datasetPath, "data3"), "data3");
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
batch = new SpriteBatch(GraphicsDevice);
Assets = new AssetCatalog(Content, lua);
TheGame = new GameManager();
primitives = new Primitives(GraphicsDevice, batch);
#if DEVELOPMENT_BUILD
console = new DevelopmentConsole(this, batch, primitives, lua, this.Window);
Components.Add(console);
#endif
world = new World(32, 32);
world.Register(new SpriteRenderer());
world.Register(new PlayerController(camera, primitives));
world.Register(new CharacterController(primitives));
world.Register(new IlluminationSystem(penumbra));
world.Register(new AnimationSystem());
var physics = (PhysicsSystem)world.Register(new PhysicsSystem(primitives));
// Goto the menu level
gsm.Goto(new GameLevel(world, penumbra, camera));
//gsm.Goto(new Menu(world));
}
public BoolWithMessage AddAsset()
{
string errorMessage = ValidateAssetInfo(null);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
return(BoolWithMessage.False($"The following errors were found:\n\n{errorMessage}"));
}
Asset newAsset = new Asset()
{
ID = $"{SelectedAssetID}{SelectedIDExtension}",
Author = SelectedAssetAuthor,
Category = SelectedAssetCategory,
Description = SelectedAssetDescription,
Name = SelectedAssetName,
PreviewImage = SelectedAssetImageUrl,
UpdatedDate = DateTime.UtcNow,
Version = 1,
};
if (!string.IsNullOrWhiteSpace(SelectedAssetUpdatedDate))
{
DateTime.TryParse(SelectedAssetUpdatedDate, out DateTime updateDate);
if (updateDate != null && updateDate != DateTime.MinValue)
{
newAsset.UpdatedDate = updateDate;
}
}
double.TryParse(SelectedAssetVersion, out double version);
if (version <= 0)
{
newAsset.Version = version;
}
if (SelectedAssetDownloadType == "Url")
{
newAsset.DownloadLink = AssetCatalog.FormatUrl(SelectedAssetDownloadUrl);
}
else if (SelectedAssetDownloadType == "Google Drive")
{
newAsset.DownloadLink = $"rsmm://GDrive/{SelectedAssetDownloadUrl}";
}
AssetViewModel viewModel = new AssetViewModel(newAsset);
AssetList.Add(viewModel);
AssetToEdit = null;
SelectedAsset = null;
SelectedAsset = AssetList[AssetList.Count - 1];
return(BoolWithMessage.True());
}
public void ImageSetCreationWorks()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "Imageset1Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "Imageset1.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var imageset = catalog.OpenImageSet("img1");
imageset.AddVariant(new DeviceRequirement().AddWidthClass(SizeClassRequirement.Regular),
testFiles.CreateFile("data1.png", "img1"));
imageset.AddVariant(new DeviceRequirement().AddHeightClass(SizeClassRequirement.Compact),
testFiles.CreateFile("data2.png", "img2"));
imageset.AddVariant(new DeviceRequirement().AddScale(ScaleRequirement.X1),
testFiles.CreateFile("data3.png", "img3"));
var alignment = new ImageAlignment();
alignment.top = 1;
alignment.bottom = 2;
alignment.left = 3;
alignment.right = 4;
var resizing = new ImageResizing();
resizing.type = ImageResizing.SlicingType.HorizontalAndVertical;
resizing.top = 1;
resizing.bottom = 2;
resizing.left = 3;
resizing.right = 4;
resizing.centerResizeMode = ImageResizing.ResizeMode.Stretch;
resizing.centerWidth = 2;
resizing.centerHeight = 4;
imageset.AddVariant(new DeviceRequirement().AddScale(ScaleRequirement.X3),
testFiles.CreateFile("data4.png", "img4"), alignment, resizing);
catalog.Write();
string imagesetPath = Path.Combine(catalogPath, "img1.imageset");
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsTrue(Directory.Exists(imagesetPath));
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "Imageset1.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "data1.png"), "img1");
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "data2.png"), "img2");
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "data3.png"), "img3");
AssertFileExistsAndHasContents(Path.Combine(imagesetPath, "data4.png"), "img4");
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
public void ImageStackCreationWorks()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "ImageStack1Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "ImageStack1.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var imageStack = catalog.OpenImageStack("stack1");
var layer = imageStack.AddLayer("layer1");
var imageset = layer.GetImageSet();
imageset.AddVariant(new DeviceRequirement().AddWidthClass(SizeClassRequirement.Regular),
testFiles.CreateFile("data1.png", "img1"));
imageset.AddVariant(new DeviceRequirement().AddHeightClass(SizeClassRequirement.Compact),
testFiles.CreateFile("data2.png", "img2"));
layer = imageStack.AddLayer("layer2");
layer.SetReference("Image1");
catalog.Write();
string imageStackPath = Path.Combine(catalogPath, "stack1.imagestack");
string layer1Path = Path.Combine(imageStackPath, "layer1.imagestacklayer");
string layer1ImageSetPath = Path.Combine(layer1Path, "Content.imageset");
string layer2Path = Path.Combine(imageStackPath, "layer2.imagestacklayer");
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsTrue(Directory.Exists(imageStackPath));
Assert.IsTrue(Directory.Exists(layer1Path));
Assert.IsTrue(Directory.Exists(layer1ImageSetPath));
Assert.IsTrue(Directory.Exists(layer2Path));
AssertFileExistsAndHasContents(Path.Combine(imageStackPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "ImageStack1.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(layer1Path, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "ImageStack1.layer1.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(layer1ImageSetPath, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "ImageStack1.layer1.Content.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(layer2Path, "Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "ImageStack1.layer2.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(layer1ImageSetPath, "data1.png"), "img1");
AssertFileExistsAndHasContents(Path.Combine(layer1ImageSetPath, "data2.png"), "img2");
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
IEnumerator Init()
{
return(LoadValue(
string.Format("http://{0}/api/assetcatalogs", assetServerAddress),
data => {
if (data as DataArray != null)
{
CoreLogger.LogInfo(_loggerModule, string.Format("received catalog: {0}", data));
_catalog = new AssetCatalog(data[0]);
}
else
{
CoreLogger.LogWarning(_loggerModule, "response is not a json array - no catalog will be available");
_catalog = new AssetCatalog();
}
}
));
}
public BoolWithMessage ImportCatalog(string pathToCatalog)
{
try
{
AssetCatalog catalog = JsonConvert.DeserializeObject <AssetCatalog>(File.ReadAllText(pathToCatalog));
AssetList = new ObservableCollection <AssetViewModel>(catalog.Assets.Select(a => new AssetViewModel(a)).ToList());
ClearSelectedAsset();
CatalogName = catalog.Name;
return(BoolWithMessage.True());
}
catch (Exception e)
{
return(BoolWithMessage.False($"Failed to import catalog: {e.Message}"));
}
}
public void FoldersAreCreatedAsExpected()
{
var testFiles = new TestFileCache(Path.Combine(GetTestOutputPath(), "Folder1Files"));
string catalogPath = Path.Combine(GetTestOutputPath(), "Folder1.xcassets");
var catalog = new AssetCatalog(catalogPath, "test.test");
var dataset = catalog.OpenDataSet("test/test/test2/data1");
dataset.AddVariant(new DeviceRequirement().AddDevice(DeviceTypeRequirement.iPad),
testFiles.CreateFile("data1.dat", "data1"), null);
var folder = catalog.OpenFolder("test/test2");
folder.providesNamespace = true;
dataset = catalog.OpenDataSet("test/test2/data2");
dataset.AddVariant(new DeviceRequirement().AddDevice(DeviceTypeRequirement.iPad),
testFiles.CreateFile("data2.dat", "data2"), null);
catalog.Write();
Assert.IsTrue(Directory.Exists(catalogPath));
Assert.IsFalse(File.Exists(Path.Combine(catalogPath, "Contents.json")));
Assert.IsTrue(Directory.Exists(Path.Combine(catalogPath, "test")));
Assert.IsFalse(File.Exists(Path.Combine(catalogPath, "test/Contents.json")));
Assert.IsTrue(Directory.Exists(Path.Combine(catalogPath, "test/test")));
Assert.IsFalse(File.Exists(Path.Combine(catalogPath, "test/test/Contents.json")));
Assert.IsTrue(Directory.Exists(Path.Combine(catalogPath, "test/test/test2")));
Assert.IsFalse(File.Exists(Path.Combine(catalogPath, "test/test/test2/Contents.json")));
Assert.IsTrue(Directory.Exists(Path.Combine(catalogPath, "test/test/test2/data1.dataset")));
Assert.IsTrue(Directory.Exists(Path.Combine(catalogPath, "test/test2")));
AssertFileExistsAndHasContents(Path.Combine(catalogPath, "test/test2/Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "Folder1.test2.Contents.json")));
Assert.IsTrue(Directory.Exists(Path.Combine(catalogPath, "test/test2/data2.dataset")));
AssertFileExistsAndHasContents(Path.Combine(catalogPath, "test/test/test2/data1.dataset/Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "Folder1.data1.dataset.Contents.json")));
AssertFileExistsAndHasContents(Path.Combine(catalogPath, "test/test2/data2.dataset/Contents.json"),
File.ReadAllText(Path.Combine(GetTestSourcePath(), "Folder1.data2.dataset.Contents.json")));
if (!DebugEnabled())
{
testFiles.CleanUp();
Directory.Delete(catalogPath, true);
}
}
public static void Build()
{
BuildTarget buildTarget = EditorUserBuildSettings.activeBuildTarget;
BuildAssetBundleOptions options = BuildAssetBundleOptions.ChunkBasedCompression | BuildAssetBundleOptions.StrictMode;
string folder = EditorUtility.OpenFolderPanel("Build AssetBundles", Application.streamingAssetsPath, "");
DirectoryInfo directory = new DirectoryInfo(folder);
if (!directory.Exists)
{
Debug.LogError($"Directory '{folder}' does not exist!");
return;
}
directory.Delete(true);
directory.Create(); // clear it
try
{
BuildPipeline.BuildAssetBundles(directory.FullName, options, buildTarget);
foreach (var manifest in directory.GetFiles("*.manifest", SearchOption.AllDirectories))
{
manifest.Delete();
}
string manifestBundlePath = Path.Combine(directory.FullName, directory.Name);
File.Delete(manifestBundlePath);
AssetCatalog catalog = AssetUtility.CreateEditorAssetCatalog();
string catalogJson = JsonConvert.SerializeObject(catalog);
File.WriteAllText(Path.Combine(directory.FullName, AssetCatalog.FileName), catalogJson);
AssetDatabase.Refresh();
Debug.Log("Build Successfully");
}
catch (Exception e)
{
Debug.LogException(e);
Debug.Log("Build Failed");
}
}
public BoolWithMessage ExportCatalog(string savePath)
{
try
{
UpdateAsset(SelectedAsset); // ensure the currently selected asset is updated before writing to file
AssetCatalog catalog = new AssetCatalog()
{
Name = CatalogName,
Assets = AssetList.Select(a => a.Asset).ToList()
};
string fileContents = JsonConvert.SerializeObject(catalog, Formatting.Indented);
File.WriteAllText(savePath, fileContents);
return(BoolWithMessage.True());
}
catch (Exception e)
{
return(BoolWithMessage.False($"Failed to export catalog: {e.Message}"));
}
}
private BoolWithMessage UpdateAsset(AssetViewModel assetToUpdate)
{
if (assetToUpdate == null)
{
return(BoolWithMessage.False("assetToUpdate is null"));
}
string validationMsg = ValidateAssetInfo(assetToUpdate);
if (!string.IsNullOrEmpty(validationMsg))
{
UpdatedAssetInvalid?.Invoke(validationMsg);
return(BoolWithMessage.False(validationMsg));
}
if (SelectedAssetDownloadType == "Url")
{
assetToUpdate.Asset.DownloadLink = AssetCatalog.FormatUrl(SelectedAssetDownloadUrl);
}
else if (SelectedAssetDownloadType == "Google Drive")
{
assetToUpdate.Asset.DownloadLink = $"rsmm://GDrive/{SelectedAssetDownloadUrl}";
}
else if (SelectedAssetDownloadType == "Mega")
{
assetToUpdate.Asset.DownloadLink = $"rsmm://MegaFile/{SelectedAssetDownloadUrl}";
}
assetToUpdate.Asset.ID = $"{SelectedAssetID}{SelectedIDExtension}";
assetToUpdate.Asset.Name = SelectedAssetName;
assetToUpdate.Asset.Author = SelectedAssetAuthor;
assetToUpdate.Asset.Category = SelectedAssetCategory;
assetToUpdate.Asset.Description = SelectedAssetDescription;
assetToUpdate.Asset.PreviewImage = SelectedAssetImageUrl;
double.TryParse(SelectedAssetVersion, out double version);
if (version <= 0)
{
assetToUpdate.Asset.Version = 1;
}
else
{
assetToUpdate.Asset.Version = version;
}
DateTime.TryParse(SelectedAssetUpdatedDate, out DateTime updateDate);
if (updateDate != DateTime.MinValue)
{
assetToUpdate.Asset.UpdatedDate = updateDate.ToUniversalTime();
}
else if (string.IsNullOrWhiteSpace(SelectedAssetUpdatedDate))
{
assetToUpdate.Asset.UpdatedDate = DateTime.UtcNow;
}
assetToUpdate.Name = assetToUpdate.Asset.Name;
assetToUpdate.Author = assetToUpdate.Asset.Author;
assetToUpdate.AssetCategory = assetToUpdate.Asset.Category;
assetToUpdate.Version = assetToUpdate.Asset.Version.ToString();
assetToUpdate.UpdatedDate = assetToUpdate.Asset.UpdatedDate.ToLocalTime().ToString(AssetViewModel.dateTimeFormat);
assetToUpdate.Description = assetToUpdate.Asset.Description;
return(BoolWithMessage.True());
}
//**********DeleteAsset**************************************************
//NAME : DeleteAsset
//PURPOSE : Function to delete assets from product catalog.
//PARAMETERS : AssetPID,Language,Mode(Add,Update,Delete),isClone,DeleteAll
//RETURN VALUE : boolean
//USAGE :
//CREATED ON : 11-02-2006
//CHANGE HISTORY :Auth Date Description
//***********************************************************************
public bool DeleteAsset(string AssetPID, string Language, string Mode, bool isClone, bool DeleteAll)
{
try
{
Product objAsset;
int lngCnt;
string AssetCatalog;
objAsset = new Product(Convert.ToInt32(AssetPID));
ArrayList LocalArray;
//LocalArray=GetLocales(Language.Substring(0,2));
LocalArray = GetLocales(Language);
try
{
if ((Mode == "U") || (DeleteAll == true))
{
foreach (Product Assetparent in objAsset.ParentProducts)
{
Assetparent.Assets.Remove(objAsset);
//objAsset.ParentProducts.Remove(Assetparent,DanaherTM.ProductEngine.DBUtils.DataStructures.RelationshipTypes.Products.Asset);
//objAsset.ParentProducts.Remove(
}
}
}
catch (Exception Ex)
{
//Do nothing
}
for (lngCnt = 0; lngCnt < LocalArray.Count; lngCnt++)
{
try
{
ProductLocalized LocalProduct = new ProductLocalized(objAsset, Convert.ToString(LocalArray[lngCnt].ToString().Trim()));
LocalProduct.Delete();
}
catch (Exception ex)
{
//Do Nothing
}
}
for (lngCnt = 0; lngCnt < LocalArray.Count; lngCnt++)
{
try
{
AssetCatalog = Convert.ToString(LocalArray[lngCnt]);
AssetCatalog = AssetCatalog.Trim().Substring(AssetCatalog.Trim().Length - 2, 2);
Catalog ProductCatalog = new Catalog("Fnet-" + AssetCatalog.ToUpper());
ProductCatalog.Assets.Remove(objAsset);
}
catch (Exception ex)
{
//Do Nothing
}
}
try
{
if ((Mode == "U") || (DeleteAll == true))
{
// foreach(Category AssetCat in objAsset.Categories)
// {
// //objAsset.Categories.Remove(AssetCat);
// Deletecategory(AssetCat.ID,objAsset.ID);
// }
objAsset.Categories.Remove(DanaherTM.ProductEngine.DBUtils.DataStructures.RelationshipTypes.Products.Asset);
}
}
catch (Exception Ex)
{
//Do nothing
}
if (((Mode != "U") && (Mode != "A")) || DeleteAll == true)
//if(DeleteAll==true)
{
objAsset.Delete();
}
return(true);
}
catch (Exception ex)
{
//Code for error handling
return(false);
}
}
public Task CheckForCatalogUpdatesAsync(bool clearCache = true)
{
object countLock = new object();
Task t = Task.Factory.StartNew(() =>
{
string catFile = AbsolutePathToCatalogSettingsJson;
Directory.CreateDirectory(AbsolutePathToTempDownloads);
CatalogSettings currentSettings = new CatalogSettings();
if (File.Exists(catFile))
{
currentSettings = JsonConvert.DeserializeObject <CatalogSettings>(File.ReadAllText(catFile));
currentSettings.CatalogUrls.RemoveAll(s => string.IsNullOrWhiteSpace(s.Url));
}
else
{
CatalogSettings.AddDefaults(currentSettings);
}
if (currentSettings.CatalogUrls.Count == 0)
{
if (File.Exists(catFile))
{
File.Delete(catFile);
}
_catalogCache = new AssetCatalog();
ReloadAllAssets();
RefreshFilteredAssetList();
return;
}
if (clearCache)
{
lock (catalogCacheLock)
{
_catalogCache = new AssetCatalog();
}
}
foreach (CatalogSubscription sub in currentSettings.CatalogUrls.Where(c => c.IsActive).ToArray())
{
Logger.Info($"Checking catalog {sub.Url}");
string uniqueFileName = $"cattemp{Path.GetRandomFileName()}.xml"; // save temp catalog update to unique filename so multiple catalog updates can download async
string path = Path.Combine(AbsolutePathToTempDownloads, uniqueFileName);
Guid downloadId = Guid.NewGuid();
Action onCancel = () =>
{
RemoveFromDownloads(downloadId);
};
Action onError = () =>
{
RemoveFromDownloads(downloadId);
};
Action onComplete = () =>
{
RemoveFromDownloads(downloadId);
try
{
AssetCatalog c = JsonConvert.DeserializeObject <AssetCatalog>(File.ReadAllText(path));
lock (catalogCacheLock) // put a lock on the Catalog so multiple threads can only merge one at a time
{
_catalogCache = AssetCatalog.Merge(_catalogCache, c);
File.WriteAllText(AbsolutePathToCatalogJson, JsonConvert.SerializeObject(_catalogCache, Formatting.Indented));
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
finally
{
// delete temp catalog
if (File.Exists(path))
{
File.Delete(path);
}
ReloadAllAssets();
RefreshFilteredAssetList();
}
};
DownloadItemViewModel catalogDownload = new DownloadItemViewModel()
{
UniqueId = downloadId,
DownloadType = DownloadType.Catalog,
ItemName = $"Checking catalog {sub.Url}",
DownloadUrl = AssetCatalog.FormatUrl(sub.Url),
SaveFilePath = path,
OnComplete = onComplete,
OnError = onError,
OnCancel = onCancel
};
AddToDownloads(catalogDownload);
}
});
return(t);
}
