public void TestGenerationOfFiles()
{
var container = new Container(c =>
{
c.AddRegistry <MetaDataCreationRegistry>();
c.For <IHttpGetFile>().Use <HttpService>();
c.For <IHttpGet>().Use <HttpService>();
c.For <IProvideSettings>().Use(() => new AppConfigSettingsProvider(new MachineSettings()));
c.For <ILog>().Use(() => Mock.Of <ILog>());
c.For <IUnzipStream>().Use <ZipFileExtractor>();
});
var larsDataService = container.GetInstance <ILarsDataService>();
var mockElasticsearchDataService = container.GetInstance <IElasticsearchLarsDataService>();
var vstsDataService = container.GetInstance <IVstsService>();
var settings = container.GetInstance <IAppServiceSettings>();
var logger = container.GetInstance <ILog>();
var angleSharpService = container.GetInstance <IAngleSharpService>();
Assert.True(string.IsNullOrEmpty(settings.GitUsername));
Assert.True(string.IsNullOrEmpty(settings.GitPassword));
MetaDataManager metaData = new MetaDataManager(larsDataService, mockElasticsearchDataService, vstsDataService, settings, angleSharpService, logger);
var standardsFromLars = larsDataService.GetListOfCurrentStandards();
metaData.GenerateStandardMetadataFiles();
var result = metaData.GetStandardsMetaData();
result.Count().Should().Be(standardsFromLars.Count());
}
public void ShouldMapTypicalLength()
{
var mockSettings = new Mock <IAppServiceSettings>();
var mockLarsDataService = new Mock <ILarsDataService>();
var mockElasticsearchDataService = new Mock <IElasticsearchLarsDataService>();
mockSettings.Setup(x => x.MetadataApiUri).Returns("www.abba.co.uk");
mockElasticsearchDataService.Setup(m => m.GetListOfFrameworks())
.Returns(
new List <FrameworkMetaData>
{
new FrameworkMetaData {
EffectiveFrom = DateTime.Parse("2015-01-01"), EffectiveTo = null, FworkCode = 500, PwayCode = 1, ProgType = 21
}
});
mockLarsDataService.Setup(m => m.GetListOfCurrentFrameworks())
.Returns(
new List <FrameworkMetaData>
{
new FrameworkMetaData {
EffectiveFrom = DateTime.Parse("2015-01-01"), EffectiveTo = null, FworkCode = 500, PwayCode = 1, ProgType = 21
}
});
var metaDataManager = new MetaDataManager(mockLarsDataService.Object, mockElasticsearchDataService.Object, _mockVstsService.Object, mockSettings.Object, null, Mock.Of <ILog>());
var framework = metaDataManager.GetAllFrameworks().FirstOrDefault();
framework.Should().NotBeNull();
framework.TypicalLength.From.Should().Be(12);
framework.TypicalLength.To.Should().Be(24);
}
/// <summary>
/// Upon the asset being done loading from resources send it to the correct place to store
/// </summary>
/// <param name="to"></param>
public void HandleAssetLoaded(AssetLoadRequestTO to)
{
switch (to.assetLoadType)
{
case AssetLoadType.Conversation:
DialogController.GetInstance().LoadDialogFromTO(to);
DialogController.GetInstance().PreloadPortraits();
DialogController.GetInstance().PreloadMusic();
break;
case AssetLoadType.MapData:
MapData md = MapData.FromTO(to);
MapController.GetInstance().LoadMapData(md);
break;
case AssetLoadType.MapMaterial:
MapController.GetInstance().LoadCurrMapMaterialFromTO(to);
break;
case AssetLoadType.Metadata:
MetaDataManager.GetInstance().LoadMetadataFromTO(to);
break;
case AssetLoadType.Music:
MusicController.GetInstance().LoadMusicFromTO(to);
break;
case AssetLoadType.SoundEfect:
SoundEffectController.GetInstance().LoadSoundEffectFromTO(to);
break;
}
}
public void ShouldMapJobRoles()
{
var mockSettings = new Mock <IAppServiceSettings>();
var mockLarsDataService = new Mock <ILarsDataService>();
var mockElasticsearchDataService = new Mock <IElasticsearchLarsDataService>();
mockSettings.Setup(x => x.MetadataApiUri).Returns("www.abba.co.uk");
mockElasticsearchDataService.Setup(m => m.GetListOfFrameworks())
.Returns(
new List <FrameworkMetaData>
{
new FrameworkMetaData {
EffectiveFrom = DateTime.Parse("2015-01-01"), EffectiveTo = null, FworkCode = 500, PwayCode = 1, ProgType = 21
}
});
var metaDataManager = new MetaDataManager(mockLarsDataService.Object, mockElasticsearchDataService.Object, _mockVstsService.Object, mockSettings.Object, null, Mock.Of <ILog>());
var framework = metaDataManager.GetAllFrameworks().FirstOrDefault();
framework.Should().NotBeNull();
framework.JobRoleItems.Count().Should().Be(2);
framework.JobRoleItems.FirstOrDefault().Title.Should().Be("Job role 2");
framework.JobRoleItems.FirstOrDefault().Description.Should().Be("Description 2");
}
public void TestExportClassWithFirstClassAttribute()
{
EAMetaModel meta = new EAMetaModel();
APIModel.createAPI_AttributesFirstClass(meta);
meta.setupSchemaPackage();
//Test
JSchema jschema = SchemaManager.schemaToJsonSchema(EARepository.Repository, EARepository.currentDiagram).Value;
{
JSchema child = jschema.Properties["propClass"];
Assert.AreEqual(JSchemaType.String, child.Type);
}
{
JSchema child = jschema.Properties["propertyClass2"];
Assert.AreEqual(JSchemaType.String, child.Type);
}
EA.Package package = SchemaManager.generateSample(EARepository.Repository);
object o = package.Diagrams.GetAt(0);
EA.Diagram diaObj = (EA.Diagram)o;
IList <EA.Element> objects = MetaDataManager.diagramSamples(EARepository.Repository, diaObj);
Assert.AreEqual(1 + 1, objects.Count);
}
private void ContextMenu_ContextMenuOpening(object sender, System.Windows.Controls.ContextMenuEventArgs e)
{
// disable certain menu items if no map selected
bool isMapSelected = (lstMaps.SelectedItem != null);
bool isSessionPathValid = SessionPath.IsSessionPathValid();
menuReimporSelectedMap.IsEnabled = isMapSelected;
menuOpenSelectedMapFolder.IsEnabled = isMapSelected;
menuRenameSelectedMap.IsEnabled = isMapSelected;
menuHideSelectedMap.IsEnabled = isMapSelected;
menuOpenSessionFolder.IsEnabled = isSessionPathValid;
menuOpenMapsFolder.IsEnabled = isSessionPathValid;
if (isMapSelected)
{
MapListItem selected = (lstMaps.SelectedItem as MapListItem);
bool hasImportLocation = MetaDataManager.IsImportLocationStored(selected);
menuReimporSelectedMap.IsEnabled = hasImportLocation;
menuReimporSelectedMap.ToolTip = hasImportLocation ? null : "You can only re-import if you imported the map from 'Import Map > From Computer ...' and imported a folder.\n(does not work with .zip files)";
menuHideSelectedMap.Header = selected.IsHiddenByUser ? "Show Selected Map ..." : "Hide Selected Map ...";
bool canBeDeleted = MetaDataManager.HasPathToMapFilesStored(selected);
menuDeleteSelectedMap.IsEnabled = canBeDeleted;
menuDeleteSelectedMap.ToolTip = canBeDeleted ? null : "You can only delete a map that has been imported via version 2.2.3 or greater.";
}
}
private void button1_Click(object sender, EventArgs e)
{
var manager = new MetaDataManager();
manager.DownloadCover(_film.Image);
var film = PersistenceManager.Instance.Films.FirstOrDefault(x => x.FileName == _film.FileName);
if (film != null)
{
film.Description = _film.Description;
film.ID = _film.ID;
film.Title = _film.Title;
film.Year = _film.Year;
film.Image = _film.Image;
PersistenceManager.Instance.Save();
MetaDataManager mdManager = new MetaDataManager();
var detail = mdManager.GetDetail(film.ID);
film.DurationInMinutes = detail.runtime ?? 0;
film.Genre = string.Join(", ", detail.genres.Select(x => x.name));
film.Note = Math.Round(detail.vote_average, 1);
var credits = mdManager.GetCredits(film.ID);
film.Director = credits.crew.Any(x => x.job == "Director") ? credits.crew.FirstOrDefault(x => x.job == "Director").name : string.Empty;
film.Casting = string.Join(", ", credits.cast.Select(x => x.name));
if (OkClick != null)
{
OkClick(this, EventArgs.Empty);
}
}
}
public HierarchyMetaData(List <ExtendedHierarchyMember> members)
{
this.metaDataManager = new MetaDataManager();
this.members = members;
this.memberAncestors = new List <HierarchyMemberAncestor>();
this.memberOperators = new Dictionary <int, int>();
members.ForEach(x => memberOperators.Add(x.Id, Utility.GetMemberOperator(x.Operator)));
PopulateAncestors(members);
}
internal Task <BoolWithMessage> ImportMapAsync(bool isReimport = false)
{
Task <BoolWithMessage> task = Task.Factory.StartNew(() =>
{
string sourceFolderToCopy;
if (IsZipFileImport)
{
if (File.Exists(PathToFileOrFolder) == false)
{
System.Windows.MessageBox.Show("File does not exist", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
return(new BoolWithMessage(false, $"{PathToFileOrFolder} does not exist."));
}
// extract files first before copying
Directory.CreateDirectory(PathToTempUnzipFolder);
BoolWithMessage didExtract = FileUtils.ExtractCompressedFile(PathToFileOrFolder, PathToTempUnzipFolder);
if (didExtract.Result == false)
{
UserMessage = $"Failed to extract file: {didExtract.Message}";
return(new BoolWithMessage(false, $"Failed to extract: {didExtract.Message}."));
}
sourceFolderToCopy = EnsurePathToMapFilesIsCorrect(PathToTempUnzipFolder);
}
else
{
if (Directory.Exists(PathToFileOrFolder) == false)
{
System.Windows.MessageBox.Show("Folder does not exist", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
return(new BoolWithMessage(false, $"{PathToFileOrFolder} does not exist."));
}
sourceFolderToCopy = PathToFileOrFolder;
}
FileUtils.CopyDirectoryRecursively(sourceFolderToCopy, SessionPath.ToContent, filesToExclude: FilesToExclude, foldersToExclude: AllStockFoldersToExclude, doContainsSearch: false);
if (IsZipFileImport && Directory.Exists(PathToTempUnzipFolder))
{
// remove unzipped temp files
Directory.Delete(PathToTempUnzipFolder, true);
}
else if (isReimport == false)
{
// make .meta file to tag where the imported map came from to support the 'Re-import' feature
string mapName = MetaDataManager.GetMapFileNameFromFolder(sourceFolderToCopy);
BoolWithMessage result = MetaDataManager.TrackMapLocation(mapName, sourceFolderToCopy);
}
return(new BoolWithMessage(true));
});
return(task);
}
public EnCManager(Process process)
{
resource = new ResourceManager(this, process);
resource.PreLoad();
process.Modules.Added += this.ProcessModuleAdded;
metadata = new MetaDataManager(this);
eventCreator = new EditorEventCreator(this);
process.EnCHook = this;
this.process = process;
LocalVarDiff.ClearLocalVarCache();
}
/// <summary>
/// Reads installed_textures.json meta data and initializes <see cref="InstalledTextures"/> with results
/// </summary>
private void InitInstalledTextures()
{
InstalledTexturesMetaData installedMetaData = MetaDataManager.LoadTextureMetaData();
List <InstalledTextureItemViewModel> textures = new List <InstalledTextureItemViewModel>();
foreach (TextureMetaData item in installedMetaData.InstalledTextures)
{
textures.Add(new InstalledTextureItemViewModel(item));
}
InstalledTextures = textures.OrderBy(t => t.TextureName).ToList();
}
/// <summary>
/// Fill the Views and Fields comboboxes by the selected entity
/// </summary>
/// <param name="selectedEntity"></param>
private void FillComboBoxesFieldaAndViews(ComboBoxEntities selectedEntity)
{
lblAuditHistoryNotEnabled.Visible = !selectedEntity.IsAuditEnabled;
WorkAsync(new WorkAsyncInfo
{
Message = RetrievingEntityViewAndFields,
Work = (w, ev) =>
{
try
{
if (chkPersonalView.Checked)
{
lsViewsForEntity = MetaDataManager.GetListUserViews(Service, selectedEntity.LogicalName, selectedEntity.ObjectTypeCode);
}
else
{
lsViewsForEntity = MetaDataManager.GetListViews(Service, selectedEntity.LogicalName, selectedEntity.ObjectTypeCode, true);
}
lsAllFields = MetaDataManager.GetListFieldsForEntity(Service, selectedEntity.LogicalName);
lsStringFieldsForEntity = MetaDataManager.GetStringFieldsFieldListForEntity(Service, selectedEntity.LogicalName);
}
catch (Exception ex)
{
ev.Result = ex.Message;
}
},
PostWorkCallBack = ev =>
{
if (ev.Result == null)
{
FillComboListViews();
FillComboListFieldsForEntity(selectedEntity.LogicalName);
}
else
{
DialogResult dialogResult = MessageBox.Show(ev.Result.ToString(),
"Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
},
AsyncArgument = null,
IsCancelable = true,
MessageWidth = 340,
MessageHeight = 150
});
}
private bool IsAssetInstalled(AssetViewModel asset, List <MapMetaData> mapMetaData, InstalledTexturesMetaData installedTextures)
{
if (asset.AssetCategory == AssetCategory.Maps.Value)
{
if (mapMetaData == null)
{
mapMetaData = MetaDataManager.GetAllMetaDataForMaps();
}
return(mapMetaData.Any(m => m.AssetName == asset.Asset.ID));
}
else
{
return(MetaDataManager.GetTextureMetaDataByName(asset.Asset.ID, installedTextures) != null);
}
}
public void ShouldUpdateMetadataFromLars()
{
var mockLarsDataService = new Mock <ILarsDataService>();
var mockElasticsearchDataService = new Mock <IElasticsearchLarsDataService>();
var mockVstsService = new Mock <IVstsService>();
var mockSettings = new Mock <IAppServiceSettings>();
var mockAngleSharpService = new Mock <IAngleSharpService>();
var mockLogger = new Mock <ILog>(MockBehavior.Loose);
mockSettings.Setup(x => x.MetadataApiUri).Returns("www.abba.co.uk");
// Add link
var larsStandards = new List <LarsStandard> {
new LarsStandard {
Id = 2, Title = "Title1", NotionalEndLevel = 4
}
};
mockElasticsearchDataService.Setup(m => m.GetListOfStandards()).Returns(larsStandards);
mockAngleSharpService.Setup(m => m.GetLinks("StandardUrl", ".attachment-details h2 a", "Apprenticeship")).Returns(new List <string> {
"/link/to/ApprenticeshipPDF"
});
mockAngleSharpService.Setup(m => m.GetLinks("StandardUrl", ".attachment-details h2 a", "Assessment")).Returns(new List <string> {
"/link/to/AssessmentPDF"
});
var standardsFromRepo = new List <StandardMetaData> {
new StandardMetaData {
Id = 2, Title = "Title1", Published = true
}, new StandardMetaData {
Id = 3, Title = "Title2", Published = true
}
};
mockVstsService.Setup(m => m.GetStandards()).Returns(standardsFromRepo);
var metaDataManager = new MetaDataManager(mockLarsDataService.Object, mockElasticsearchDataService.Object, mockVstsService.Object, mockSettings.Object, mockAngleSharpService.Object, mockLogger.Object);
var standardJson = metaDataManager.GetStandardsMetaData();
var standard = standardJson.FirstOrDefault(m => m.Id == 2);
standard.NotionalEndLevel.Should().Be(4);
Assert.That(standardJson, Is.TypeOf <List <StandardMetaData> >());
}
public void RefreshFilteredAssetList(bool checkForFileChanges = false)
{
List <AssetCategory> categories = GetSelectedCategories();
List <AssetViewModel> newList = new List <AssetViewModel>();
foreach (AssetCategory cat in categories)
{
newList.AddRange(GetAssetsByCategory(cat));
}
RefreshAuthorList();
if (AuthorToFilterBy.Author != defaultAuthorValue)
{
newList = newList.Where(a => a.Author == AuthorToFilterBy.Author).ToList();
}
if (SelectedInstallStatus != defaultInstallStatusValue)
{
// read currently installed textures/map from files into memory so checking each asset is quicker
InstalledTexturesMetaData installedTextures = MetaDataManager.LoadTextureMetaData();
List <MapMetaData> installedMaps = MetaDataManager.GetAllMetaDataForMaps();
switch (SelectedInstallStatus)
{
case "Installed":
newList = newList.Where(a => IsAssetInstalled(a, installedMaps, installedTextures)).ToList();
break;
case "Not Installed":
newList = newList.Where(a => IsAssetInstalled(a, installedMaps, installedTextures) == false).ToList();
break;
default:
break;
}
}
FilteredAssetList = newList;
if (FilteredAssetList.Count == 0 && GetSelectedCategories().Count() == 0)
{
UserMessage = "Check categories to view the list of downloadable assets ...";
}
}
public void GetAllAsJsonShouldReturnDictionary()
{
// ILarsDataService larsDataService, IVstsService vstsService, IAppServiceSettings settings
var mockLarsDataService = new Mock <ILarsDataService>();
var mockElasticsearchDataService = new Mock <IElasticsearchLarsDataService>();
var mockVstsService = new Mock <IVstsService>();
var mockSettings = new Mock <IAppServiceSettings>();
var mockAngleSharpService = new Mock <IAngleSharpService>();
var mockLogger = new Mock <ILog>(MockBehavior.Loose);
mockSettings.Setup(x => x.MetadataApiUri).Returns("www.abba.co.uk");
var metaDataManager = new MetaDataManager(mockLarsDataService.Object, mockElasticsearchDataService.Object, mockVstsService.Object, mockSettings.Object, mockAngleSharpService.Object, mockLogger.Object);
var standardJson = metaDataManager.GetStandardsMetaData();
Assert.That(standardJson, Is.TypeOf <List <StandardMetaData> >());
}
public void LoadMapByUID(string uid)
{
MapInfoVO vo = MetaDataManager.GetInstance().Map.GetVO <MapInfoVO>(uid);
List <AssetLoadRequestTO> requests = new List <AssetLoadRequestTO>();
AssetLoadRequestTO mapCSV = AssetLoadRequestTO.CreateMapDataRequest(vo.tileMapCSV);
requests.Add(mapCSV);
AssetLoadRequestTO mat = AssetLoadRequestTO.CreateMapMaterialRequest(vo.material);
requests.Add(mat);
EventController.GetInstance().RegisterForEvent(
EventTypeEnum.AssetsLoadMultipleComplete, OnLoadCompleteEvent);
AssetLoader.GetInstance().LoadAssets(requests);
}
/// <summary>
/// Deletes the selected asset files from Session folders
/// </summary>
public void RemoveSelectedAsset()
{
AssetViewModel assetToRemove = SelectedAsset;
BoolWithMessage deleteResult = BoolWithMessage.False("");
if (assetToRemove.AssetCategory == AssetCategory.Maps.Value)
{
MapMetaData mapToDelete = MetaDataManager.GetAllMetaDataForMaps()?.Where(m => m.AssetName == assetToRemove.Asset.ID).FirstOrDefault();
if (mapToDelete == null)
{
UserMessage = "Failed to find meta data to delete map files ...";
return;
}
deleteResult = MetaDataManager.DeleteMapFiles(mapToDelete);
}
else
{
TextureMetaData textureToDelete = MetaDataManager.GetTextureMetaDataByName(assetToRemove.Asset.ID);
if (textureToDelete == null)
{
UserMessage = $"Failed to find meta data to delete texture files for {assetToRemove.Asset.ID}...";
return;
}
deleteResult = MetaDataManager.DeleteTextureFiles(textureToDelete);
}
UserMessage = deleteResult.Message;
if (deleteResult.Result)
{
RefreshPreviewForSelected();
// refresh list if filtering by installed or uninstalled
if (SelectedInstallStatus != defaultInstallStatusValue)
{
RefreshFilteredAssetList();
}
}
}
public void Test_CreateMapMetaData_Returns_Correct_FilePaths()
{
SessionPath.ToSession = TestPaths.ToSessionTestFolder;
string pathToMapImporting = Path.Combine(TestPaths.ToTestFilesFolder, "Mock_Map_Files", "cool_valid_map");
MapMetaData expectedResult = new MapMetaData()
{
FilePaths = new List <string>()
{
Path.Combine(SessionPath.ToContent, "coolmap.uexp"), Path.Combine(SessionPath.ToContent, "coolmap.umap"),
Path.Combine(SessionPath.ToContent, "coolmap_BuiltData.uexp"), Path.Combine(SessionPath.ToContent, "coolmap_BuiltData.uasset"),
Path.Combine(SessionPath.ToContent, "coolmap_BuiltData.ubulk")
}
};
MapMetaData actualResult = MetaDataManager.CreateMapMetaData(pathToMapImporting, true);
actualResult.FilePaths.TrueForAll(s => expectedResult.FilePaths.Contains(s));
expectedResult.FilePaths.TrueForAll(s => actualResult.FilePaths.Contains(s));
}
public void GetAllFrameworks()
{
var mockSettings = new Mock <IAppServiceSettings>();
var mockLarsDataService = new Mock <ILarsDataService>();
var mockElasticsearchDataService = new Mock <IElasticsearchLarsDataService>();
mockSettings.Setup(x => x.MetadataApiUri).Returns("www.abba.co.uk");
mockElasticsearchDataService.Setup(m => m.GetListOfFrameworks())
.Returns(
new List <FrameworkMetaData> {
new FrameworkMetaData {
EffectiveFrom = DateTime.Parse("2015-01-01"), EffectiveTo = null, FworkCode = 500, PwayCode = 1, ProgType = 2
}
});
var metaDataManager = new MetaDataManager(mockLarsDataService.Object, mockElasticsearchDataService.Object, _mockVstsService.Object, mockSettings.Object, null, Mock.Of <ILog>());
var frameworks = metaDataManager.GetAllFrameworks();
Assert.AreEqual(1, frameworks.Count());
}
protected override void PopulateDisplayMembers()
{
List <T> parents = new List <T>();
MetaDataManager metaDataManager = new MetaDataManager();
if (typeof(T).Equals(typeof(ExtendedHierarchyMember)))
{
foreach (int selectedMember in SelectedMembers.Distinct())
{
T member = Members.FirstOrDefault(x => x.Id == selectedMember);
if (member != null)
{
parents.Add(member);
List <int> ancestors = metaDataManager.GetAncestors((member as ExtendedHierarchyMember).Lineage);
List <ExtendedHierarchyMember> members = (Members as List <ExtendedHierarchyMember>).Where(x => ancestors.Contains(x.Id) && x.MemberType == MemberType.Rollup).ToList();
if (members != null && members.Count > 0)
{
parents.AddRange(members as List <T>);
}
}
}
}
//else if (typeof(T).Equals(typeof(TimeHierarchy)))
//{
// foreach (int selectedMember in SelectedMembers.Distinct())
// {
// T member = Members.FirstOrDefault(x => x.Id == selectedMember);
// if (member != null)
// {
// parents.Add(member);
// List<int> ancestors = metaDataManager.GetAncestors((member as TimeHierarchy).Lineage);
// List<TimeHierarchy> members = (Members as List<TimeHierarchy>).Where(x => ancestors.Contains(x.Id) && x.Level < 4).ToList();
// if (members != null && members.Count > 0)
// {
// parents.AddRange(members as List<T>);
// }
// }
// }
//}
DisplayMembers = parents.Distinct();
}
private void ContextMenu_ContextMenuOpening(object sender, System.Windows.Controls.ContextMenuEventArgs e)
{
// disable certain menu items if no map selected
bool isMapSelected = (lstMaps.SelectedItem != null);
bool isSessionPathValid = SessionPath.IsSessionPathValid();
menuReimporSelectedMap.IsEnabled = isMapSelected;
menuOpenSelectedMapFolder.IsEnabled = isMapSelected;
menuRenameSelectedMap.IsEnabled = isMapSelected;
menuHideSelectedMap.IsEnabled = isMapSelected;
menuOpenSessionFolder.IsEnabled = isSessionPathValid;
menuOpenMapsFolder.IsEnabled = isSessionPathValid;
if (isMapSelected)
{
MapListItem selected = (lstMaps.SelectedItem as MapListItem);
bool hasImportLocation = MetaDataManager.IsImportLocationStored(selected);
menuReimporSelectedMap.IsEnabled = hasImportLocation;
menuReimporSelectedMap.ToolTip = hasImportLocation ? null : "You can only re-import if you imported the map from 'Import Map > From Computer ...' and imported a folder.\n(does not work with .zip files)";
menuHideSelectedMap.Header = selected.IsHiddenByUser ? "Show Selected Map ..." : "Hide Selected Map ...";
if (ViewModel.SecondMapToLoad == null || ViewModel.SecondMapToLoad?.FullPath != selected.FullPath)
{
menuSecondMapToLoad.Header = "Set As Second Map To Load (When Leaving Apartment) ...";
menuSecondMapToLoad.ToolTip = "Set the map to be loaded after you leave the apartment (before starting the game)";
}
else
{
menuSecondMapToLoad.ToolTip = "This will clear the selected map to not load after you leave the apartment";
menuSecondMapToLoad.Header = "Clear As Second Map To Load ...";
}
bool canBeDeleted = MetaDataManager.HasPathToMapFilesStored(selected);
menuDeleteSelectedMap.IsEnabled = canBeDeleted;
menuDeleteSelectedMap.ToolTip = canBeDeleted ? null : "You can only delete a map that has been imported via version 2.2.3 or greater.";
}
}
public void RemoveSelectedTexture()
{
InstalledTextureItemViewModel textureToRemove = SelectedTexture;
if (textureToRemove == null)
{
Logger.Warn("textureToRemove is null");
return;
}
BoolWithMessage deleteResult = MetaDataManager.DeleteTextureFiles(textureToRemove.MetaData);
if (deleteResult.Result)
{
StatusMessage = $"Successfully removed {textureToRemove.TextureName}!";
InitInstalledTextures();
}
else
{
StatusMessage = $"Failed to remove texture: {deleteResult.Message}";
}
}
/// <summary>
/// Opens a window to enter a new name for a map.
/// Writes to meta data file if user clicks 'Rename' in window.
/// </summary>
/// <param name="selectedMap"></param>
internal void OpenRenameMapWindow(MapListItem selectedMap)
{
RenameMapViewModel viewModel = new RenameMapViewModel(selectedMap);
RenameMapWindow window = new RenameMapWindow(viewModel)
{
WindowStartupLocation = WindowStartupLocation.CenterScreen
};
bool?result = window.ShowDialog();
if (result.GetValueOrDefault(false) == true)
{
bool didWrite = MetaDataManager.WriteCustomMapPropertiesToFile(ViewModel.AvailableMaps);
if (didWrite == false)
{
ViewModel.UserMessage = "Failed to update .meta file with new custom name. Your custom name may have not been saved and will be lost when the app restarts.";
return;
}
ViewModel.RefreshFilteredMaps();
ViewModel.UserMessage = $"{selectedMap.MapName} renamed to {selectedMap.CustomName}!";
}
}
public void Test_SaveMapMetaData_Saves_Correct_Json()
{
SessionPath.ToSession = TestPaths.ToSessionTestFolder;
MapMetaData testMetaData = new MapMetaData()
{
FilePaths = new List <string>()
{
"test1", "test2"
},
CustomName = "Test Custom Name",
MapName = "MapName",
IsHiddenByUser = false,
OriginalImportPath = "",
MapFileDirectory = "Path\\To\\Content\\MapName_Folder"
};
MetaDataManager.SaveMapMetaData(testMetaData);
string pathToSavedFile = Path.Combine(MetaDataManager.FullPathToMetaFolder, testMetaData.GetJsonFileName());
Assert.AreEqual(Newtonsoft.Json.JsonConvert.SerializeObject(testMetaData), File.ReadAllText(pathToSavedFile));
}
public void Test_SaveMapMetaData_Saves_File()
{
SessionPath.ToSession = TestPaths.ToSessionTestFolder;
MapMetaData testMetaData = new MapMetaData()
{
FilePaths = new List <string>()
{
"test1", "test2"
},
CustomName = "Test Custom Name",
MapName = "MapName",
IsHiddenByUser = false,
OriginalImportPath = "",
MapFileDirectory = "Path\\To\\Content\\MapName_Folder"
};
MetaDataManager.SaveMapMetaData(testMetaData);
string pathToExpectedFile = Path.Combine(MetaDataManager.FullPathToMetaFolder, "MapName_Folder_MapName_meta.json");
Assert.IsTrue(File.Exists(pathToExpectedFile));
}
public void GenerateStandardMetadataFilesTestShouldPushOnlyMissingStandardsToGit()
{
// ILarsDataService larsDataService, IVstsService vstsService, IAppServiceSettings settings
var mockLarsDataService = new Mock <ILarsDataService>();
var mockElasticsearchDataService = new Mock <IElasticsearchLarsDataService>();
var mockVstsService = new Mock <IVstsService>();
var mockSettings = new Mock <IAppServiceSettings>();
var mockLogger = new Mock <ILog>(MockBehavior.Loose);
List <FileContents> standardsToAdd = null;
var currentStandards = new List <LarsStandard>
{
new LarsStandard {
Id = 1, Title = "One"
},
new LarsStandard {
Id = 2, Title = "Two"
},
new LarsStandard {
Id = 3, Title = "Three"
}
};
var existingMetaDataIds = new List <string> {
"1", "2"
};
mockLarsDataService.Setup(x => x.GetListOfCurrentStandards()).Returns(currentStandards);
mockVstsService.Setup(x => x.GetExistingStandardIds()).Returns(existingMetaDataIds);
mockVstsService.Setup(x => x.PushCommit(It.IsAny <List <FileContents> >())).Callback <List <FileContents> >(x => { standardsToAdd = x; });
var metaDataManager = new MetaDataManager(mockLarsDataService.Object, mockElasticsearchDataService.Object, mockVstsService.Object, mockSettings.Object, null, mockLogger.Object);
metaDataManager.GenerateStandardMetadataFiles();
Assert.That(standardsToAdd.Count, Is.EqualTo(1));
}
static void Main(string[] args)
{
// Preparation of Meta Data
MetaDataManager metaDataManager = new MetaDataManager();
List <Segment> segments = metaDataManager.GetSegments();
Dictionary <Segment, HierarchyMetaData> metaData = new Dictionary <Segment, HierarchyMetaData>();
foreach (Segment segment in segments)
{
metaData.Add(segment, new HierarchyMetaData(metaDataManager.GetHierarchyMembers(segment.Id)));
}
//List<TimeHierarchy> timeHierarchies = metaDataManager.GetTimeHierarchies();
//Utility.PopulateLRValues(timeHierarchies);
List <DimensionSelection> selections = new List <DimensionSelection>()
{
new DimensionSelection()
{
SegmentID = 1, SelectedMembers = new List <int>()
{
1
}, Option = ExtendedMemberOption.SelectedAndAllChildern
},
new DimensionSelection()
{
SegmentID = 2, SelectedMembers = new List <int>()
{
1
}, Option = ExtendedMemberOption.SelectedAndAllChildern
}
//,new DimensionSelection(){ SegmentID = 3, SelectedMembers = new List<int>(){ 1 }, Option = ExtendedMemberOption.SelectedAndAllChildern }
//,new DimensionSelection(){ SegmentID = 4, SelectedMembers = new List<int>(){ 1 }, Option = ExtendedMemberOption.SelectedAndAllChildern }
};
selections = metaDataManager.ApplyDefaultSegmentMemberIDs(segments, selections);
List <GLRecord> lstGLRecord = metaDataManager.GetSourceData();
Dictionary <DimensionSelection, IAggregation <ExtendedHierarchyMember> > selectionAggregations = new Dictionary <DimensionSelection, IAggregation <ExtendedHierarchyMember> >();
foreach (DimensionSelection selection in selections)
{
AggregationFactory <ExtendedHierarchyMember> aggregationFactory = new AggregationFactory <ExtendedHierarchyMember>(selection.SelectedMembers, metaData[segments.FirstOrDefault(x => x.Id == selection.SegmentID)].Members.ToList());
IAggregation <ExtendedHierarchyMember> aggregation = aggregationFactory.Create(selection.Option);
lstGLRecord.RemoveAll(x => !aggregation.RelevantLeafIDs.Contains(x.GLMembers.SegmentValues.FirstOrDefault(z => z.Key == selection.SegmentID).Value));
selectionAggregations.Add(selection, aggregation);
}
foreach (KeyValuePair <DimensionSelection, IAggregation <ExtendedHierarchyMember> > selectionAggregation in selectionAggregations)
{
DimensionAggregationFactory <ExtendedHierarchyMember, HierarchyMemberAncestor> dimensionAggregationFactory =
new DimensionAggregationFactory <ExtendedHierarchyMember, HierarchyMemberAncestor>(selectionAggregation.Key.SegmentID, lstGLRecord, selectionAggregation.Value, metaData[segments.FirstOrDefault(x => x.Id == selectionAggregation.Key.SegmentID)].MemberAncestors.ToList());
switch (selectionAggregation.Key.Option)
{
case ExtendedMemberOption.Leaves:
default:
break;
case ExtendedMemberOption.Selected:
if (lstGLRecord.Select(x => x.GLMembers.SegmentValues.FirstOrDefault(z => z.Key == selectionAggregation.Key.SegmentID).Value).Except(selectionAggregation.Value.DisplayMembers.Select(x => x.Id)).Count() > 0)
{
foreach (ExtendedHierarchyMember extendedHierarchyMember in selectionAggregation.Value.DisplayMembers)
{
DimensionMember dimensionMember = new DimensionMember(extendedHierarchyMember);
dimensionMember.Accept(dimensionAggregationFactory.Create(CompositionType.Part));
}
}
break;
case ExtendedMemberOption.Children:
case ExtendedMemberOption.AllChildren:
case ExtendedMemberOption.SelectedAndChildren:
case ExtendedMemberOption.SelectedAndAllChildern:
case ExtendedMemberOption.SelectedAndLeaves:
case ExtendedMemberOption.SelectedAndParents:
int maxDepth = selectionAggregation.Value.DisplayMembers.Where(x => x.MemberType == MemberType.Rollup).Max(z => z.Level);
int minDepth = selectionAggregation.Value.DisplayMembers.Where(x => x.MemberType == MemberType.Rollup).Min(z => z.Level);
for (int level = maxDepth; level >= minDepth; level--)
{
foreach (ExtendedHierarchyMember extendedHierarchyMember in selectionAggregation.Value.DisplayMembers.Where(x => x.MemberType == MemberType.Rollup && x.Level == level))
{
if (!selectionAggregation.Value.DisplayMembers.Any(x => x.MemberType == MemberType.Rollup && (x.ParentId == extendedHierarchyMember.Id)))
{
DimensionMember dimensionMember = new DimensionMember(extendedHierarchyMember);
dimensionMember.Accept(dimensionAggregationFactory.Create(CompositionType.Part));
}
else
{
DimensionWholePartHierarchy dimensionWholePartHierarchy = new DimensionWholePartHierarchy(selectionAggregation.Value.DisplayMembers.Where(x => x.ParentId == extendedHierarchyMember.Id || x.Id == extendedHierarchyMember.Id).ToList());
dimensionWholePartHierarchy.Accept(dimensionAggregationFactory.Create(CompositionType.Composite));
}
}
}
break;
}
lstGLRecord.RemoveAll(x => selectionAggregation.Value.PostProcessDeleteMemberIDs.Contains(x.GLMembers.SegmentValues.FirstOrDefault(z => z.Key == selectionAggregation.Key.SegmentID).Value));
}
Utility.Export(lstGLRecord, segments, metaData);
}
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues)
{
Gateway gateway = owner.Gateway;
Type type = Util.GetType(this.owner.TypeName);
string keyMember = null;
Type keyType = null;
object keyValue = null;
PropertyInfo keyMemberProperty = null;
List <string> keyNames = new List <string>();
List <object> keyValues = new List <object>();
if (keys != null && keys.Count > 0)
{
IEnumerator en = keys.Keys.GetEnumerator();
while (en.MoveNext())
{
keyMember = en.Current.ToString();
keyNames.Add(keyMember);
keyMemberProperty = Util.DeepGetProperty(type, keyMember);
keyValue = ChangeType(keys[keyMember], keyMemberProperty.PropertyType);
keyValues.Add(keyValue);
}
}
else
{
EntityConfiguration ec = MetaDataManager.GetEntityConfiguration(this.owner.TypeName);
foreach (PropertyConfiguration pc in ec.Properties)
{
if (pc.IsPrimaryKey)
{
keyMember = pc.Name;
keyNames.Add(keyMember);
keyType = Util.GetType(pc.PropertyType);
keyValue = ChangeType(oldValues[keyMember], keyType);
keyValues.Add(keyValue);
}
}
}
MethodInfo miFind = GetGatewayMethodInfo("EntityType Find[EntityType](System.Object[])");
object entity = miFind.MakeGenericMethod(type).Invoke(gateway, new object[] { keyValues.ToArray() });
if (entity == null)
{
return(0);
}
//check DBConcurrency
if (this.owner.ConflictDetection == ConflictOptions.CompareAllValues)
{
foreach (string key in oldValues.Keys)
{
if (keyNames.Contains(key))
{
continue;
}
PropertyInfo property = Util.DeepGetProperty(type, key);
if (property != null && property.GetValue(entity, null) != ChangeType(oldValues[key], property.PropertyType))
{
throw new System.Data.DBConcurrencyException("The underlying data has changed.");
}
}
}
NBearDataSourceEventArgs deletingArgs = new NBearDataSourceEventArgs(entity);
owner.OnDeleting(deletingArgs);
entity = deletingArgs.Entity;
if (entity == null)
{
return(0);
}
System.Data.Common.DbTransaction tran = null;
try
{
tran = gateway.BeginTransaction();
MethodInfo miDelete = GetGatewayMethodInfo("Void Delete[EntityType](EntityType, System.Data.Common.DbTransaction)");
miDelete.MakeGenericMethod(type).Invoke(gateway, new object[] { entity, tran });
tran.Commit();
}
catch
{
tran.Rollback();
throw;
}
finally
{
gateway.CloseTransaction(tran);
}
owner.OnDeleted(new NBearDataSourceEventArgs(entity));
this.OnDataSourceViewChanged(EventArgs.Empty);
return(1);
}
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues)
{
Gateway gateway = owner.Gateway;
Type type = Util.GetType(this.owner.TypeName);
string keyMember = null;
Type keyType = null;
object keyValue = null;
PropertyInfo keyMemberProperty = null;
List <string> keyNames = new List <string>();
Entity entity = (Entity)Activator.CreateInstance(type);
if (keys != null && keys.Count > 0)
{
IEnumerator en = keys.Keys.GetEnumerator();
while (en.MoveNext())
{
keyMember = en.Current.ToString();
keyNames.Add(keyMember);
keyMemberProperty = Util.DeepGetProperty(type, keyMember);
keyValue = ChangeType(keys[keyMember], keyMemberProperty.PropertyType);
keyMemberProperty.SetValue(entity, keyValue, null);
}
}
else
{
EntityConfiguration ec = MetaDataManager.GetEntityConfiguration(this.owner.TypeName);
foreach (PropertyConfiguration pc in ec.Properties)
{
if (pc.IsPrimaryKey)
{
keyMember = pc.Name;
keyNames.Add(keyMember);
keyType = Util.GetType(pc.PropertyType);
keyValue = ChangeType(oldValues[keyMember], keyType);
keyMemberProperty = Util.DeepGetProperty(type, keyMember);
keyMemberProperty.SetValue(entity, keyValue, null);
}
}
}
bool changed = false;
entity.Attach();
foreach (string key in values.Keys)
{
if (keyNames.Contains(key))
{
continue;
}
PropertyInfo property = Util.DeepGetProperty(type, key);
if (this.owner.ConflictDetection == ConflictOptions.CompareAllValues)
{
if (property != null && property.GetValue(entity, null) != ChangeType(oldValues[key], property.PropertyType))
{
throw new System.Data.DBConcurrencyException("The underlying data has changed.");
}
}
if (values[key] == oldValues[key])
{
continue;
}
if (property != null && property.CanWrite)
{
changed = true;
property.SetValue(entity, ChangeType(values[key], property.PropertyType), null);
}
}
if (changed)
{
NBearDataSourceEventArgs savingArgs = new NBearDataSourceEventArgs(entity);
owner.OnSaving(savingArgs);
entity = (Entity)savingArgs.Entity;
if (entity == null)
{
return(0);
}
System.Data.Common.DbTransaction tran = null;
try
{
tran = gateway.BeginTransaction();
MethodInfo miSave = GetGatewayMethodInfo("Int32 Save[EntityType](EntityType, System.Data.Common.DbTransaction)");
miSave.MakeGenericMethod(type).Invoke(gateway, new object[] { entity, tran });
tran.Commit();
}
catch
{
tran.Rollback();
throw;
}
finally
{
gateway.CloseTransaction(tran);
}
owner.OnSaved(new NBearDataSourceEventArgs(entity));
this.OnDataSourceViewChanged(EventArgs.Empty);
}
return(changed ? 1 : 0);
}
// Use this for initialization
void Start()
{
instance = this;
}