public IVmListItemsData <IVmPostalCode> GetPostalCodes(string searchedCode, bool onlyValid = true) { IReadOnlyList <IVmPostalCode> result = new List <IVmPostalCode>(); contextManager.ExecuteReader(unitOfWork => { var searchCode = searchedCode.ToLower(); var postalCodeRep = unitOfWork.CreateRepository <IPostalCodeRepository>(); var qry = postalCodeRep.All(); if (onlyValid) { qry = qry.Where(pc => pc.IsValid); } var resultTemp = unitOfWork.ApplyIncludes(qry, i => i.Include(j => j.PostalCodeNames)); if (!string.IsNullOrEmpty(searchCode)) { resultTemp = resultTemp .Where(x => x.Code.ToLower().Contains(searchedCode) || x.PostalCodeNames.Any(y => y.Name.ToLower().Contains(searchedCode)) ) .OrderBy(x => x.Code) .Take(CoreConstants.MaximumNumberOfAllItems); result = TranslationManagerToVm.TranslateAll <PostalCode, VmPostalCode>(resultTemp); } }); return(new VmListItemsData <IVmPostalCode> (result)); }
internal IVmEntityBase LockEntityVersioned <T, T2>(Guid id, bool isLockDisAllowedForArchived = false) where T : class, IEntityIdentifier, IVersionedVolume <T2> where T2 : IVersionedRoot { Guid?rootId = null; contextManager.ExecuteReader(unitOfWork => { rootId = unitOfWork.GetSet <T>().Where(i => i.Id == id).Select(i => i.UnificRootId).FirstOrDefault(); if (!versioningManager.IsAllowedForEditing <T>(unitOfWork, id)) { throw new ModifiedExistsException("", new List <string>()); } if (isLockDisAllowedForArchived && versioningManager.IsEntityArchived <T>(unitOfWork, id)) { throw new LockNotAllowedException(); } }); if (rootId == null) { throw new LockException("", new List <string>() { CoreMessages.EntityNotFoundToUpdate }); } if (!CheckEntityAccess <T, T2>(rootId.Value, id)) { throw new Exception(CoreMessages.EntityAccessDenied); } return(LockEntityRoot <T2>(rootId.Value)); }
public IVmListItemsData <IVmListItem> GetMunicipalities(string searchedCode, bool onlyValid = true)//TODO ADD LANGUAGE PARAM, MUNICIPALITY NAME { IReadOnlyList <VmListItem> result = new List <VmListItem>(); contextManager.ExecuteReader(unitOfWork => { var searchCode = searchedCode.ToLower(); var municipalityRep = unitOfWork.CreateRepository <IMunicipalityRepository>(); var qry = municipalityRep.All(); if (onlyValid) { qry = qry.Where(m => m.IsValid); } var resultTemp = unitOfWork.ApplyIncludes(qry, i => i.Include(j => j.MunicipalityNames)); if (!string.IsNullOrEmpty(searchCode)) { resultTemp = resultTemp .Where(x => x.Code.ToLower().Contains(searchedCode) || x.MunicipalityNames.Any(y => y.Name.ToLower().Contains(searchedCode) // && y.LocalizationId == languageCache.Get(LanguageCode.fi.ToString()) )) .OrderBy(x => x.Code) .Take(CoreConstants.MaximumNumberOfAllItems); result = translationEntToVm.TranslateAll <Municipality, VmListItem>(resultTemp); } }); return(new VmListItemsData <IVmListItem>(result)); }
public IVmOpenApiGuidPageVersionBase GetServiceCollections(DateTime?date, int pageNumber, int pageSize, bool archived) { var vm = new V3VmOpenApiGuidPage(pageNumber, pageSize); if (pageNumber <= 0) { return(vm); } List <ServiceCollectionVersioned> collections = null; contextManager.ExecuteReader(unitOfWork => { if (archived) { collections = GetArchivedEntities <ServiceCollectionVersioned, ServiceCollection, ServiceCollectionLanguageAvailability>(vm, date, unitOfWork, q => q.Include(i => i.ServiceCollectionNames)); } else { collections = GetPublishedEntities <ServiceCollectionVersioned, ServiceCollection, ServiceCollectionLanguageAvailability>(vm, date, unitOfWork, q => q.Include(i => i.ServiceCollectionNames)); } }); if (collections?.Count > 0) { vm.ItemList = TranslationManagerToVm.TranslateAll <ServiceCollectionVersioned, VmOpenApiItem>(collections).ToList(); } return(vm); }
/// <summary> /// Check if entity is locked by another user /// </summary> /// <param name="id">Id of entity which should be checked</param> /// <returns>True if locked by another user, false if not locked or locked by current user</returns> public bool IsLocked(Guid id) { var userName = userIdentification.UserName; if (string.IsNullOrEmpty(userName)) { return(true); } return(contextManager.ExecuteReader(unitOfWork => { var currentTime = DateTime.UtcNow; var lockingRep = unitOfWork.CreateRepository <ILockingRepository>(); return lockingRep.All().Any(i => i.LockedEntityId == id && i.LockedBy != userName && (i.LockedAt.AddMinutes(entityLockTimeMinutes) > currentTime)); })); }
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 <IVmCountry> GetCountries(string searchedCode) { IReadOnlyList <IVmCountry> result = new List <IVmCountry>(); contextManager.ExecuteReader(unitOfWork => { var searchCode = searchedCode.ToLower(); var countryRep = unitOfWork.CreateRepository <ICountryRepository>(); var resultTemp = unitOfWork.ApplyIncludes(countryRep.All(), i => i.Include(j => j.CountryNames)); if (!string.IsNullOrEmpty(searchCode)) { resultTemp = resultTemp .Where(x => x.Code.ToLower().Contains(searchedCode) || x.CountryNames.Any(y => y.Name.ToLower().Contains(searchCode))) .OrderBy(x => x.Code) .Take(CoreConstants.MaximumNumberOfAllItems); result = translationEntToVm.TranslateAll <Country, VmCountry>(resultTemp); } }); return(new VmListItemsData <IVmCountry> (result)); }
public IList <VmOpenApiCodeListItem> GetLanguageCodeList() { IReadOnlyList <VmOpenApiCodeListItem> result = new List <VmOpenApiCodeListItem>(); contextManager.ExecuteReader(unitOfWork => { var languageRep = unitOfWork.CreateRepository <ILanguageRepository>(); var resultTemp = unitOfWork.ApplyIncludes(languageRep.All(), i => i.Include(j => j.Names)); resultTemp = resultTemp.OrderBy(x => x.Code); result = translationEntToVm.TranslateAll <Language, VmOpenApiCodeListItem>(resultTemp); }); return(new List <VmOpenApiCodeListItem>(result)); }
public List <RequestFilterConfigurationData> GetRequestFilterConfiguration(string interfaceTag = null) { return(contextManager.ExecuteReader(unitOfWork => { var cfgRep = unitOfWork.CreateRepository <ICFGRequestFilterRepository>(); var query = cfgRep.All(); if (interfaceTag != null) { query = query.Where(i => i.Interface == interfaceTag); } var allData = query.ToList(); return allData.Select(i => new RequestFilterConfigurationData() { UserName = i.UserName, IPAddress = i.IPAddress, ConcurrentRequests = i.ConcurrentRequests }).ToList(); })); }
public VmAddressSimpleBase GetAddress(VmGetCoordinatesForAddressIn model) { if (!model.Id.IsAssigned()) { return(null); } VmAddressSimpleBase result = null; contextManager.ExecuteReader(unitOfWork => { var addressQuery = unitOfWork.CreateRepository <IAddressRepository>().All().Where(x => x.Id == model.Id); var address = unitOfWork.ApplyIncludes(addressQuery, q => q .Include(x => x.Coordinates)).FirstOrDefault(); TranslationManagerToVm.SetLanguage(model.Language); result = address != null ? TranslationManagerToVm.Translate <Address, VmAddressSimpleBase>(address) : null; }); 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); }
public IVmListItem GetMunicipalityByCode(string code, bool onlyValid = false) { var result = new VmListItem(); contextManager.ExecuteReader(unitOfWork => { var rep = unitOfWork.CreateRepository <IMunicipalityRepository>(); var municipalityCodeQry = rep.All().Where(x => x.Code == code); if (onlyValid) { municipalityCodeQry = municipalityCodeQry.Where(m => m.IsValid); } var municipalityCode = municipalityCodeQry.FirstOrDefault(); if (municipalityCode != null) { result = translationEntToVm.Translate <Municipality, VmListItem>(municipalityCode); } }); return(result); }
public VmOrganizationHeader GetOrganizationHeader(Guid?organizationId) { return(contextManager.ExecuteReader(unitOfWork => GetOrganizationHeader(organizationId, unitOfWork))); }
public List <Guid> LoadOrganizationTree(IEnumerable <Guid> rootIds) { return(contextManager.ExecuteReader(unitOfWork => LoadOrganizationTree(unitOfWork, rootIds))); }