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)));
}