private static void LoadMessages(FileInfo file, VmListItemsData <IVmLanguageMessages> result, string language)
{
if (file.Exists)
{
var json = File.ReadAllText(file.FullName);
var data = JsonConvert.DeserializeObject <Dictionary <string, string> >(json);
result.Add
(
new VmLanguageMessages
{
LanguageCode = language.ToLower(),
Texts = data
}
);
}
else
{
result.Add(new VmLanguageMessages
{
LanguageCode = language,
Texts = new Dictionary <string, string> {
{ file.Name, file.FullName }
}
});
}
}
/// <summary>
/// Gets ui localized text for application
/// </summary>
/// <returns></returns>
public IVmListItemsData <IVmLanguageMessages> GetMessages()
{
var localizationDir = new DirectoryInfo(environment.GetFilePath(devRootDirectory, Path.Combine("wwwroot", "localization")));
var result = new VmListItemsData <IVmLanguageMessages>();
foreach (var file in localizationDir.GetFiles($"*{jsonFileExtension}"))
{
LoadMessages(file, result, file.Name.Replace(jsonFileExtension, string.Empty));
}
return(result);
}
public IVmListItemsData <IVmTreeItem> GetFilteredTree(IVmGetFilteredTree vmGetFilteredTree)
{
var treeType = Enum.Parse(typeof(TreeTypeEnum), vmGetFilteredTree.TreeType);
VmListItemsData <IVmTreeItem> result = null;//new VmListItemsData<IVmTreeItem>();// { FilteredTree = new List<VmTreeItem>(), TreeType = vmGetFilteredTree.TreeType };
var lowerValue = vmGetFilteredTree.SearchValue?.ToLower();
contextManager.ExecuteReader(unitOfWork =>
{
switch ((TreeTypeEnum)treeType)
{
case TreeTypeEnum.ServiceClass:
var scFiltered = SearchFintoTree <ServiceClass, ServiceClassName>(unitOfWork, vmGetFilteredTree);
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmFilteredTreeItem, IVmTreeItem>(scFiltered, x => x.Name));
break;
case TreeTypeEnum.IndustrialClass:
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmFilteredTreeItem, IVmTreeItem>(SearchFintoList <IndustrialClass, IndustrialClassName>(unitOfWork, vmGetFilteredTree.SearchValue, industrialClassLevel), x => x.Name));
break;
case TreeTypeEnum.OntologyTerm:
var owFiltered = SearchFintoTree(unitOfWork, vmGetFilteredTree).ToList();
var ontologyTerms = owFiltered.SelectMany(x => x.Parents).Any() ? owFiltered.SelectMany(x => x.Parents).Select(x => x.Parent) : owFiltered;
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmExpandedVmTreeItem>(ontologyTerms));
break;
case TreeTypeEnum.AnnotationOntologyTerm:
var aotFiltered = SearchAnnotationFintoTree(unitOfWork, vmGetFilteredTree).ToList();
var annotationOntologyTerms = aotFiltered.SelectMany(x => x.Parents).Any() ? aotFiltered.SelectMany(x => x.Parents).Select(x => x.Parent) : aotFiltered;
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmExpandedVmTreeItem>(annotationOntologyTerms));
break;
case TreeTypeEnum.LifeEvent:
var leFiltered = SearchFintoTree <LifeEvent, LifeEventName>(unitOfWork, vmGetFilteredTree);
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmFilteredTreeItem, IVmTreeItem>(leFiltered, x => x.Name));
break;
case TreeTypeEnum.Organization:
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmExpandedVmTreeItem>(SearchOrganizationTree(unitOfWork, vmGetFilteredTree.SearchValue)));
break;
case TreeTypeEnum.DigitalAuthorization:
var daFiltered = SearchFintoTree <DigitalAuthorization, DigitalAuthorizationName>(unitOfWork, vmGetFilteredTree);
result = new VmListItemsData <IVmTreeItem>(CreateTree <VmFilteredTreeItem, IVmTreeItem>(daFiltered, x => x.Name));
break;
default:
break;
}
});
return(result);
}
public void GetElectronicChannelStep1Test()
{
var organizations = new List <VmListItem>()
{
new VmListItem {
Name = test
}
};
commonServiceMockSetup.Setup(sr => sr.GetOrganizationNames(unitOfWorkMockSetup.Object, null, true)).Returns(organizations);
var serviceChargeTypes = new VmListItemsData <VmListItem>(new List <VmListItem>()
{
new VmListItem()
{
Code = test
}
});
commonServiceMockSetup.Setup(sr => sr.GetPhoneChargeTypes()).Returns(serviceChargeTypes);
var userOrganizations = new List <UserOrganization>()
{
new UserOrganization {
}
};
userOrganizationRepositoryMockSetup.Setup(sr => sr.All()).Returns(userOrganizations.AsQueryable());
// listItemLogicMockSetup.Setup(l => l.SelectByIds(It.IsAny<List<VmSelectableItem>>(), It.IsAny<List<Guid>>(), false));
//var dataUtils = new Mock<DataUtils>();
//var channelService = new ChannelService(contextManager, null, translationManagerMock, translationManagerViewModelMockSetup.Object, logger, null, serviceUtilitiesMock, null, commonServiceMock, listItemLogic, dataUtils.Object, ownerReferenceLogic.Object, null, cacheManagerMock.Object, null);
//var result = channelService.GetElectronicChannelStep1(new VmChannelBasic());
//organizationNameRepositoryMockSetup.AssertWasCalled(x => x.All(), x => x.Repeat.Once());
//serviceChargeTypeRepositoryMockSetup.AssertWasCalled(x => x.All(), x => x.Repeat.Once());
//Assert.True(result.Description.Organizations.Any());
//Assert.True(result.Support.PhoneChargeTypes.Any());
}
public IVmListItemsData <VmListItem> Search(IVmGetFilteredTree vmGetFilteredTree)
{
var treeType = Enum.Parse(typeof(TreeTypeEnum), vmGetFilteredTree.TreeType);
IEnumerable <IFintoItemBase> searchResult = null;
contextManager.ExecuteReader(unitOfWork =>
{
switch ((TreeTypeEnum)treeType)
{
case TreeTypeEnum.ServiceClass:
searchResult = SearchFintoList <ServiceClass, ServiceClassName>(unitOfWork, vmGetFilteredTree.SearchValue);
break;
case TreeTypeEnum.IndustrialClass:
searchResult = SearchFintoList <IndustrialClass, IndustrialClassName>(unitOfWork, vmGetFilteredTree.SearchValue, industrialClassLevel);
break;
case TreeTypeEnum.OntologyTerm:
searchResult = SearchFintoList <OntologyTerm, OntologyTermName>(unitOfWork, vmGetFilteredTree.SearchValue, languages: vmGetFilteredTree.Languages);
break;
case TreeTypeEnum.LifeEvent:
searchResult = SearchFintoList <LifeEvent, LifeEventName>(unitOfWork, vmGetFilteredTree.SearchValue);
break;
case TreeTypeEnum.DigitalAuthorization:
searchResult = SearchFintoList <DigitalAuthorization, DigitalAuthorizationName>(unitOfWork, vmGetFilteredTree.SearchValue);
break;
default:
searchResult = new List <IFintoItem>();
break;
}
});
var result = new VmListItemsData <VmListItem>(TranslationManagerToVm.TranslateAll <IFintoItemBase, VmListItem>(searchResult.ToList()).ToList());
return(result);
}
public IVmListItemsData <IVmTranslationItem> GetTranslatedData()
{
var result = new VmListItemsData <IVmTranslationItem>();
contextManager.ExecuteReader(unitOfWork =>
{
List <VmJsonTypeName> names = GetNames <ProvisionTypeName>(unitOfWork).ToList();
names.AddRange(GetNames <ExceptionHoursStatusTypeName>(unitOfWork));
names.AddRange(GetNames <PhoneNumberTypeName>(unitOfWork));
names.AddRange(GetNames <ServiceChannelTypeName>(unitOfWork));
names.AddRange(GetNames <WebPageTypeName>(unitOfWork));
names.AddRange(GetNames <PrintableFormChannelUrlTypeName>(unitOfWork));
names.AddRange(GetTranslationData <OrganizationTypeName>(unitOfWork));
names.AddRange(GetNames <ServiceChargeTypeName>(unitOfWork));
names.AddRange(GetNames <ServiceTypeName>(unitOfWork));
names.AddRange(GetTranslationData <LanguageName>(unitOfWork));
names.AddRange(GetNames <CoordinateTypeName>(unitOfWork));
names.AddRange(GetNames <AreaInformationTypeName>(unitOfWork));
names.AddRange(GetNames <AreaTypeName>(unitOfWork));
names.AddRange(GetNames <ServiceChannelConnectionTypeName>(unitOfWork));
names.AddRange(GetNames <ServiceFundingTypeName>(unitOfWork));
names.AddRange(GetNames <PublishingStatusTypeName>(unitOfWork));
// var asdx = names.GroupBy(x => x.Language)
// .Select<IGrouping<string, VmJsonTypeName>, IVmTranslation>(type => new VmTranslation {
// LanguageCode = type.Key,
// Texts = type.Distinct(new TypeNameComparer()).ToDictionary(x => x.TypeId.ToString(), x => x.Name) as IDictionary<string, string>
// }).ToList();
var items = names.GroupBy(x => x.TypeId).Select <IGrouping <Guid, VmJsonTypeName>, IVmTranslationItem> (type => new VmTranslationItem {
Id = type.Key,
Texts = type.Distinct(new TypeLanguageComparer()).ToDictionary(x => x.Language, x => x.Name) as IDictionary <string, string>
}).ToList();
result = new VmListItemsData <IVmTranslationItem>(items);
});
return(result);
}
