public VmTreeItem GetFintoTree(IVmNode model) { var treeType = Enum.Parse(typeof(TreeTypeEnum), model.TreeType); var result = model; contextManager.ExecuteReader(unitOfWork => { result.TreeItem.AreChildrenLoaded = true; switch ((TreeTypeEnum)treeType) { case TreeTypeEnum.ServiceClass: result.TreeItem.Children = CreateTree <VmTreeItem, IVmTreeItem>(LoadFintoTree(GetIncludesForFinto <ServiceClass, ServiceClassName>(unitOfWork, unitOfWork.CreateRepository <IServiceClassRepository>().All()), 1, new List <Guid>() { model.TreeItem.Id }), x => x.Name); break; case TreeTypeEnum.IndustrialClass: result.TreeItem.Children = CreateTree <VmTreeItem, IVmTreeItem>(LoadFintoTree(GetIncludesForFinto <IndustrialClass, IndustrialClassName>(unitOfWork, unitOfWork.CreateRepository <IIndustrialClassRepository>().All()), 1, new List <Guid>() { model.TreeItem.Id }), x => x.Name); break; case TreeTypeEnum.OntologyTerm: // result.TreeItem.Children = CreateTree<VmTreeItem>(LoadFintoTree(unitOfWork.CreateRepository<IOntologyTermRepository>().All(), 1, new List<Guid>() { model.TreeItem.Id })); break; case TreeTypeEnum.LifeEvent: result.TreeItem.Children = CreateTree <VmTreeItem, IVmTreeItem>(LoadFintoTree(GetIncludesForFinto <LifeEvent, LifeEventName>(unitOfWork, unitOfWork.CreateRepository <ILifeEventRepository>().All()), 1, new List <Guid>() { model.TreeItem.Id }), x => x.Name); break; case TreeTypeEnum.Organization: var rep = unitOfWork.CreateRepository <IOrganizationVersionedRepository>(); var psPublished = PublishingStatusCache.Get(PublishingStatus.Published); var organizations = unitOfWork.ApplyIncludes(rep.All().Where(x => x.PublishingStatusId == psPublished), query => query.Include(organization => organization.OrganizationNames)); result.TreeItem.Children = CreateTree <VmTreeItem>(LoadOrganizationTree(organizations, 1, new List <Guid>() { model.TreeItem.Id })); break; case TreeTypeEnum.DigitalAuthorization: result.TreeItem.Children = CreateTree <VmTreeItem, IVmTreeItem> (LoadFintoTree(GetIncludesForFinto <DigitalAuthorization, DigitalAuthorizationName>(unitOfWork, unitOfWork.CreateRepository <IDigitalAuthorizationRepository>().All()), 1, new List <Guid>() { model.TreeItem.Id }), x => x.Name); break; default: result.TreeItem.AreChildrenLoaded = false; break; } }); return(result.TreeItem); }
private ServiceService Arrange(List <ServiceVersioned> list = null) { var serviceList = list ?? _list; var publishedItem = serviceList.Where(o => o.PublishingStatusId == PublishedId).FirstOrDefault(); var id = publishedItem.Id; var rootId = publishedItem.UnificRootId; unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes( It.IsAny <IQueryable <ServiceVersioned> >(), It.IsAny <Func <IQueryable <ServiceVersioned>, IQueryable <ServiceVersioned> > >(), It.IsAny <bool>() )).Returns((IQueryable <ServiceVersioned> services, Func <IQueryable <ServiceVersioned>, IQueryable <ServiceVersioned> > func, bool applyFilters) => { return(services); }); var unitOfWork = unitOfWorkMockSetup.Object; var contextManager = new TestContextManager(unitOfWork, unitOfWork); var serviceUtilities = new ServiceUtilities(UserIdentification, LockingManager, contextManager, UserOrganizationService, VersioningManager, UserInfoService, UserOrganizationChecker); translationManagerMockSetup.Setup(t => t.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>())) .Returns((ServiceVersioned entity) => { if (entity == null) { return(null); } return(new VmOpenApiServiceVersionBase() { Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId) }); }); var translationManagerMock = translationManagerMockSetup.Object; VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWork, rootId, PublishingStatus.Published, true)).Returns(id); // repositories ServiceRepoMock.Setup(g => g.All()).Returns(serviceList.AsQueryable()); ServiceNameRepoMock.Setup(m => m.All()).Returns(Enumerable.Empty <ServiceName>().AsQueryable()); var serviceNameRepoMock = new Mock <IServiceNameRepository>(); unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceNameRepository>()).Returns(serviceNameRepoMock.Object); return(new ServiceService(contextManager, translationManagerMock, TranslationManagerVModel, Logger, serviceUtilities, DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache, VersioningManager, gdService, UserOrganizationChecker)); }
public void GetLatestService(PublishingStatus publishingStatus) { // Arrange var item = _list.Where(i => i.PublishingStatusId == PublishingStatusCache.Get(publishingStatus)).FirstOrDefault(); var rootId = item.UnificRootId; var id = item.Id; VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWorkMockSetup.Object, rootId, null, false)).Returns(id); var service = Arrange(); // Act var result = service.GetServiceById(rootId, 7, VersionStatusEnum.Latest); // Assert result.Should().NotBeNull(); var vmResult = Assert.IsType <V7VmOpenApiService>(result); vmResult.PublishingStatus.Should().Be(publishingStatus.ToString()); VersioningManagerMock.Verify(x => x.GetVersionId <ServiceVersioned>(unitOfWorkMockSetup.Object, rootId, null, false), Times.Once); }
public void GetLatestActiveServiceChannel(PublishingStatus publishingStatus) { // Arrange var channelType = ServiceChannelTypeEnum.ServiceLocation; var item = _channelList.Where(i => i.PublishingStatusId == PublishingStatusCache.Get(publishingStatus)).FirstOrDefault(); item.TypeId = TypeCache.Get <ServiceChannelType>(channelType.ToString()); var rootId = item.UnificRootId; var id = item.Id; VersioningManagerMock.Setup(s => s.GetVersionId <ServiceChannelVersioned>(unitOfWorkMockSetup.Object, rootId, null, true)) .Returns(() => { if (publishingStatus == PublishingStatus.Deleted || publishingStatus == PublishingStatus.OldPublished) { return(null); } return(id); }); var service = Arrange(channelType); // Act var result = service.GetServiceChannelById(rootId, 7, VersionStatusEnum.LatestActive); // Assert // Method should only return draft, modified or published versions. VersioningManagerMock.Verify(x => x.GetVersionId <ServiceChannelVersioned>(unitOfWorkMockSetup.Object, rootId, null, true), Times.Once); if (publishingStatus == PublishingStatus.Draft || publishingStatus == PublishingStatus.Modified || publishingStatus == PublishingStatus.Published) { result.Should().NotBeNull(); var vmResult = Assert.IsType <V7VmOpenApiServiceLocationChannel>(result); vmResult.PublishingStatus.Should().Be(publishingStatus.ToString()); } else { result.Should().BeNull(); } }
public void Add_DraftEntity() { // Arrange var userName = "******"; var list = EntityGenerator.GetServiceEntityList(1, PublishingStatusCache); var draftEntity = list.Where(i => i.PublishingStatusId == PublishingStatusCache.Get(PublishingStatus.Draft)).FirstOrDefault(); var vm = new VmOpenApiServiceInVersionBase() { PublishingStatus = PublishingStatus.Draft.ToString() }; var unitOfWork = unitOfWorkMockSetup.Object; var contextManager = new TestContextManager(unitOfWork, unitOfWork); UserIdentificationMock.Setup(s => s.UserName).Returns(userName); var serviceUtilities = new ServiceUtilities(UserIdentificationMock.Object, LockingManager, contextManager, UserOrganizationService, VersioningManager, UserInfoService, UserOrganizationChecker); CommonServiceMock.Setup(s => s.PublishAllAvailableLanguageVersions <ServiceVersioned, ServiceLanguageAvailability>(draftEntity.Id, It.IsAny <Expression <Func <ServiceLanguageAvailability, bool> > >())) .Returns(new PublishingResult()); var service = new ServiceService(contextManager, translationManagerMockSetup.Object, translationManagerVModelMockSetup.Object, Logger, serviceUtilities, DataUtils, CommonService, new VmOwnerReferenceLogic(), CacheManager.TypesCache, LanguageCache, PublishingStatusCache, VersioningManager, gdService, UserOrganizationChecker); // Act var result = service.AddService(vm, false, DefaultVersion, false); // Assert result.Should().NotBeNull(); var vmResult = Assert.IsType <V7VmOpenApiService>(result); vmResult.PublishingStatus.Should().Be(PublishingStatus.Draft.ToString()); translationManagerVModelMockSetup.Verify(x => x.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <VmOpenApiServiceInVersionBase>(), unitOfWork), Times.Once()); translationManagerMockSetup.Verify(x => x.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>()), Times.Once()); CommonServiceMock.Verify(x => x.PublishAllAvailableLanguageVersions <ServiceVersioned, ServiceLanguageAvailability>(_serviceId, It.IsAny <Expression <Func <ServiceLanguageAvailability, bool> > >()), Times.Never()); }
public ServiceTestBase() { VersioningManagerMock = new Mock <IVersioningManager>(); UserIdentificationMock = new Mock <IUserIdentification>(); CommonServiceMock = new Mock <ICommonServiceInternal>(); ExternalSourceRepoMock = new Mock <IExternalSourceRepository>(); unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IExternalSourceRepository>()).Returns(ExternalSourceRepoMock.Object); ConnectionRepoMock = new Mock <IServiceServiceChannelRepository>(); unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceServiceChannelRepository>()).Returns(ConnectionRepoMock.Object); translationManagerMockSetup = new Mock <ITranslationEntity>(); translationManagerVModelMockSetup = new Mock <ITranslationViewModel>(); LockingManager = (new Mock <ILockingManager>()).Object; VersioningManager = VersioningManagerMock.Object; UserOrganizationChecker = (new Mock <IUserOrganizationChecker>()).Object; UserIdentification = UserIdentificationMock.Object; TranslationManagerVModel = translationManagerVModelMockSetup.Object; AddressService = (new Mock <IAddressService>()).Object; CommonService = CommonServiceMock.Object; UserInfoService = (new Mock <IUserInfoService>()).Object; UserOrganizationService = (new Mock <IUserOrganizationService>()).Object; DataUtils = new DataUtils(); ValidationManagerMock = (new Mock <IValidationManager>()).Object; PublishedId = PublishingStatusCache.Get(PublishingStatus.Published); DeletedId = PublishingStatusCache.Get(PublishingStatus.Deleted); OldPublishedId = PublishingStatusCache.Get(PublishingStatus.OldPublished); var mapServiceProviderMock = new MapServiceProvider( (new Mock <IHostingEnvironment>()).Object, new ApplicationConfiguration((new Mock <IConfigurationRoot>()).Object), (new Mock <IOptions <ProxyServerSettings> >()).Object, new Mock <ILogger <MapServiceProvider> >().Object); AddressLogic = new AddressLogic(mapServiceProviderMock); }
public void Archived_OnlyOnePerRootIdReturned() { var rootId = Guid.NewGuid(); // Let's create two version for same root organization var deletedItem = EntityGenerator.CreateEntity <OrganizationVersioned, Model.Models.Organization, OrganizationLanguageAvailability>(PublishingStatusCache.Get(PublishingStatus.Deleted), rootId); deletedItem.UnificRoot = new Model.Models.Organization { Id = rootId }; var oldPublishedItem = EntityGenerator.CreateEntity <OrganizationVersioned, Model.Models.Organization, OrganizationLanguageAvailability>(PublishingStatusCache.Get(PublishingStatus.OldPublished), rootId); oldPublishedItem.UnificRoot = new Model.Models.Organization { Id = rootId }; var list = new List <OrganizationVersioned> { deletedItem, oldPublishedItem }; var result = ArrangeAndAct(null, list, 1, 1, true); // Assert result.Should().NotBeNull(); result.PageCount.Should().Be(1);// Only one item per root should be found var vmResult = Assert.IsType <VmOpenApiOrganizationGuidPage>(result); vmResult.ItemList.Count.Should().Be(1); }
public void Active_OnlyOnePerRootIdReturned() { var rootId = Guid.NewGuid(); // Let's create two versions for same root channel var publishedItem = EntityGenerator.CreateEntity <ServiceChannelVersioned, ServiceChannel, ServiceChannelLanguageAvailability>(PublishingStatusCache.Get(PublishingStatus.Published), rootId); publishedItem.UnificRoot = new ServiceChannel { Id = rootId }; var modifiedItem = EntityGenerator.CreateEntity <ServiceChannelVersioned, ServiceChannel, ServiceChannelLanguageAvailability>(PublishingStatusCache.Get(PublishingStatus.Modified), rootId); modifiedItem.UnificRoot = new ServiceChannel { Id = rootId }; var list = new List <ServiceChannelVersioned> { publishedItem, modifiedItem }; var result = ArrangeAndAct(null, list, 1, 1, false, true); // Assert result.Should().NotBeNull(); result.PageCount.Should().Be(1);// Only one item per root should be found var vmResult = Assert.IsType <V3VmOpenApiGuidPage>(result); vmResult.ItemList.Count.Should().Be(1); }
public VmConnectableServiceSearchResult GetConnectableService(VmConnectableServiceSearch search) { search.Name = search.Name != null ? search.Name.Trim() : search.Name; return(ContextManager.ExecuteReader(unitOfWork => { var languageCode = SetTranslatorLanguage(search); var selectedLanguageId = languageCache.Get(languageCode.ToString()); var nameTypeId = typesCache.Get <NameType>(NameTypeEnum.Name.ToString()); var publishedStatusId = PublishingStatusCache.Get(PublishingStatus.Published); var draftStatusId = PublishingStatusCache.Get(PublishingStatus.Draft); var notCommonId = typesCache.Get <ServiceChannelConnectionType>(ServiceChannelConnectionTypeEnum.NotCommon.ToString()); var languagesIds = new List <Guid>() { selectedLanguageId }; var serviceRep = unitOfWork.CreateRepository <IServiceVersionedRepository>(); var generalDescriptionRep = unitOfWork.CreateRepository <IStatutoryServiceGeneralDescriptionVersionedRepository>(); var resultTemp = serviceRep.All(); #region SearchByFilterParam if (search.Type == DomainEnum.Channels) { var channelRep = unitOfWork.CreateRepository <IServiceChannelVersionedRepository>(); var channel = channelRep.All().FirstOrDefault(x => x.Id == search.Id); if (channel?.ConnectionTypeId == notCommonId) { resultTemp = resultTemp .Where(x => (x.OrganizationId == channel.OrganizationId)); } var languageAvaliabilitiesRep = unitOfWork.CreateRepository <IServiceChannelLanguageAvailabilityRepository>(); languagesIds = languageAvaliabilitiesRep.All() .Where(x => x.ServiceChannelVersionedId == search.Id) .Select(x => x.LanguageId).ToList(); } if (search.OrganizationId.HasValue) { resultTemp = resultTemp .Where( x => x.OrganizationServices .Any(o => o.OrganizationId == search.OrganizationId) || x.OrganizationId == search.OrganizationId.Value ); } if (!string.IsNullOrEmpty(search.Name)) { var rootId = GetRootIdFromString(search.Name); if (!rootId.HasValue) { var searchText = search.Name.ToLower(); resultTemp = resultTemp .Where( x => x.ServiceNames.Any(y => y.Name.ToLower().Contains(searchText)) ); } else { resultTemp = resultTemp .Where(service => service.UnificRootId == rootId ); } } else { resultTemp = resultTemp.Where( x => x.ServiceNames.Any( y => !string.IsNullOrEmpty(y.Name))); } if (search.ServiceTypeId.HasValue) { var generalDescIds = generalDescriptionRep.All() .Where(x => x.TypeId == search.ServiceTypeId && x.PublishingStatusId == publishedStatusId) .Select(x => x.UnificRootId); resultTemp = resultTemp .Where(x => (x.TypeId == search.ServiceTypeId.Value && x.StatutoryServiceGeneralDescriptionId == null) || generalDescIds.Any(d => d == x.StatutoryServiceGeneralDescriptionId)); } //commonService.ExtendPublishingStatusesByEquivalents(search.SelectedPublishingStatuses); resultTemp = resultTemp.WherePublishingStatusIn(new List <Guid>() { publishedStatusId, draftStatusId }); resultTemp = resultTemp.Where(x => x.LanguageAvailabilities.Select(y => y.LanguageId).Any(l => languagesIds.Contains(l))); #endregion SearchByFilterParam resultTemp = resultTemp // .Include(sv => sv.OrganizationServices) // .Include(sv => sv.ServiceNames) .Include(sv => sv.StatutoryServiceGeneralDescription) .ThenInclude(ssgd => ssgd.Versions) // .Include(sv => sv.Type) .Include(sv => sv.LanguageAvailabilities) .ThenInclude(sla => sla.Language); var rowCount = resultTemp.Count(); var pageNumber = search.PageNumber.PositiveOrZero(); var resultTempData = resultTemp.Select(i => new { Id = i.Id, ServiceVersioned = i, UnificRootId = i.UnificRootId, // Name = i.ServiceNames // .OrderBy(x => x.Localization.OrderNumber) // .FirstOrDefault(x => selectedLanguageId == x.LocalizationId && x.TypeId == nameTypeId).Name, // AllNames = i.ServiceNames // .Where(x => x.TypeId == typesCache.Get<NameType>(NameTypeEnum.Name.ToString())) // .Select(x => new { x.LocalizationId, x.Name }), Modified = i.Modified, // required for sorting ModifiedBy = i.ModifiedBy // required for sorting }) .OrderByDescending(i => i.Modified) .ApplyPaging(pageNumber); var serviceIds = resultTempData.Data.Select(i => i.Id).ToList(); var serviceNameRep = unitOfWork.CreateRepository <IServiceNameRepository>(); var serviceNames = serviceNameRep.All().Where(x => serviceIds.Contains(x.ServiceVersionedId) && x.TypeId == nameTypeId).OrderBy(i => i.Localization.OrderNumber).Select(i => new { i.ServiceVersionedId, i.Name, i.LocalizationId }).ToList().GroupBy(i => i.ServiceVersionedId) .ToDictionary(i => i.Key, i => i.ToDictionary(x => languageCache.GetByValue(x.LocalizationId), x => x.Name)); var result = resultTempData.Data.Select(i => { Guid?typeId = null; if (i.ServiceVersioned?.TypeId != null) { typeId = i.ServiceVersioned.TypeId.Value; } else if (i.ServiceVersioned.StatutoryServiceGeneralDescription?.Versions?.Count > 0) { var ssgdv = versioningManager.ApplyPublishingStatusFilterFallback(i.ServiceVersioned.StatutoryServiceGeneralDescription.Versions); typeId = ssgdv?.TypeId; } return new VmConnectableService { Id = i.Id, UnificRootId = i.UnificRootId, Name = serviceNames.TryGetOrDefault(i.Id, new Dictionary <string, string>()), ServiceTypeId = typeId, ServiceType = typeId == null ? string.Empty : typesCache.GetByValue <ServiceType>(typeId.Value), LanguagesAvailabilities = TranslationManagerToVm.TranslateAll <ILanguageAvailability, VmLanguageAvailabilityInfo>(i.ServiceVersioned.LanguageAvailabilities), OrganizationId = i.ServiceVersioned.OrganizationId, Modified = i.ServiceVersioned.Modified.ToEpochTime(), ModifiedBy = i.ServiceVersioned.ModifiedBy }; }) .ToList(); return new VmConnectableServiceSearchResult() { Data = result, MoreAvailable = resultTempData.MoreAvailable, Count = rowCount, PageNumber = pageNumber }; })); }
internal void ArrangeTranslationManager(ServiceChannelTypeEnum channelType) { translationManagerMockSetup.Setup(t => t.Translate <ServiceChannelVersioned, VmOpenApiElectronicChannelVersionBase>(It.IsAny <ServiceChannelVersioned>())) .Returns((ServiceChannelVersioned entity) => { if (channelType != ServiceChannelTypeEnum.EChannel) { return(new VmOpenApiElectronicChannelVersionBase()); } return(new VmOpenApiElectronicChannelVersionBase() { Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId) }); }); translationManagerMockSetup.Setup(t => t.Translate <ServiceChannelVersioned, VmOpenApiPhoneChannelVersionBase>(It.IsAny <ServiceChannelVersioned>())) .Returns((ServiceChannelVersioned entity) => { if (channelType != ServiceChannelTypeEnum.Phone) { return(new VmOpenApiPhoneChannelVersionBase()); } return(new VmOpenApiPhoneChannelVersionBase() { Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId) }); }); translationManagerMockSetup.Setup(t => t.Translate <ServiceChannelVersioned, VmOpenApiServiceLocationChannelVersionBase>(It.IsAny <ServiceChannelVersioned>())) .Returns((ServiceChannelVersioned entity) => { if (channelType != ServiceChannelTypeEnum.ServiceLocation) { return(new VmOpenApiServiceLocationChannelVersionBase()); } return(new VmOpenApiServiceLocationChannelVersionBase() { Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId) }); }); translationManagerMockSetup.Setup(t => t.Translate <ServiceChannelVersioned, VmOpenApiPrintableFormChannelVersionBase>(It.IsAny <ServiceChannelVersioned>())) .Returns((ServiceChannelVersioned entity) => { if (channelType != ServiceChannelTypeEnum.PrintableForm) { return(new VmOpenApiPrintableFormChannelVersionBase()); } return(new VmOpenApiPrintableFormChannelVersionBase() { Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId) }); }); translationManagerMockSetup.Setup(t => t.Translate <ServiceChannelVersioned, VmOpenApiWebPageChannelVersionBase>(It.IsAny <ServiceChannelVersioned>())) .Returns((ServiceChannelVersioned entity) => { if (channelType != ServiceChannelTypeEnum.WebPage) { return(new VmOpenApiWebPageChannelVersionBase()); } return(new VmOpenApiWebPageChannelVersionBase() { Id = entity.UnificRootId, PublishingStatus = PublishingStatusCache.GetByValue(entity.PublishingStatusId) }); }); }
private IList <IVmOpenApiServiceCollectionVersionBase> GetServiceCollectionsWithDetails(IUnitOfWork unitOfWork, List <Guid> versionIdList, int openApiVersion, bool getOnlyPublished = true) { if (versionIdList.Count == 0) { return(new List <IVmOpenApiServiceCollectionVersionBase>()); } var serviceCollectionRep = unitOfWork.CreateRepository <IServiceCollectionVersionedRepository>(); var publishedId = PublishingStatusCache.Get(PublishingStatus.Published); var resultTemp = unitOfWork.ApplyIncludes(serviceCollectionRep.All().Where(s => versionIdList.Contains(s.Id)), q => //q.Include(i => i.ServiceCollectionLanguages).ThenInclude(i => i.Language) q.Include(i => i.ServiceCollectionNames) .Include(i => i.ServiceCollectionDescriptions) .Include(i => i.ServiceCollectionServices).ThenInclude(i => i.Service).ThenInclude(i => i.Versions) .Include(i => i.LanguageAvailabilities) .Include(i => i.Organization).ThenInclude(i => i.Versions) .OrderByDescending(i => i.Modified)); // Filter out items that do not have language versions published! var serviceCollections = getOnlyPublished ? resultTemp.Where(c => c.LanguageAvailabilities.Any(l => l.StatusId == publishedId)).ToList() : resultTemp.ToList(); // Find only published services for service collections var publishedServices = serviceCollections.SelectMany(i => i.ServiceCollectionServices).Select(i => i.Service).SelectMany(i => i.Versions) .Where(i => i.PublishingStatusId == publishedId).ToList(); var publishedServiceIds = publishedServices.Select(i => i.Id).ToList(); var publishedServiceRootIds = new List <Guid>(); if (publishedServiceIds.Count > 0) { var servicenRep = unitOfWork.CreateRepository <IServiceVersionedRepository>(); publishedServiceRootIds = servicenRep.All().Where(c => publishedServiceIds.Contains(c.Id)) .Where(s => s.LanguageAvailabilities.Any(l => l.StatusId == publishedId)) // Filter out services with no language versions published .Select(c => c.UnificRootId).ToList(); } serviceCollections.ForEach(serviceCollection => { // Filter out not published services serviceCollection.ServiceCollectionServices = serviceCollection.ServiceCollectionServices.Where(c => publishedServiceRootIds.Contains(c.ServiceId)).ToList(); // Filter out not published language versions if (getOnlyPublished) { var notPublishedLanguageVersions = serviceCollection.LanguageAvailabilities.Where(l => l.StatusId != publishedId).Select(l => l.LanguageId).ToList(); if (notPublishedLanguageVersions.Count > 0) { serviceCollection.ServiceCollectionNames = serviceCollection.ServiceCollectionNames.Where(i => !notPublishedLanguageVersions.Contains(i.LocalizationId)).ToList(); serviceCollection.ServiceCollectionDescriptions = serviceCollection.ServiceCollectionDescriptions.Where(i => !notPublishedLanguageVersions.Contains(i.LocalizationId)).ToList(); } } }); // Fill with service names (only type: Name) var serviceNames = unitOfWork.CreateRepository <IServiceNameRepository>().All() .Where(i => publishedServiceIds.Contains(i.ServiceVersionedId) && i.TypeId == typesCache.Get <NameType>(NameTypeEnum.Name.ToString())) .GroupBy(i => i.ServiceVersionedId).ToDictionary(i => i.Key, i => i.ToList()); // Fill with service descriptions (only type: Description) var serviceDescriptions = unitOfWork.CreateRepository <IServiceDescriptionRepository>().All() .Where(i => publishedServiceIds.Contains(i.ServiceVersionedId) && i.TypeId == typesCache.Get <DescriptionType>(DescriptionTypeEnum.Description.ToString())) .GroupBy(i => i.ServiceVersionedId).ToDictionary(i => i.Key, i => i.ToList()); // Get language availabilities for published services var serviceLanguageAvailabilities = unitOfWork.CreateRepository <IServiceLanguageAvailabilityRepository>().All() .Where(i => publishedServiceIds.Contains(i.ServiceVersionedId) && i.StatusId == publishedId) .GroupBy(i => i.ServiceVersionedId) .ToDictionary(i => i.Key, i => i.Select(l => l.LanguageId).ToList()); // Filter out name and description language versions that are not available publishedServices.ForEach(s => { var availableLanguages = serviceLanguageAvailabilities.TryGet(s.Id); if (availableLanguages?.Count > 0) { s.ServiceNames = serviceNames.TryGet(s.Id)?.Where(n => availableLanguages.Contains(n.LocalizationId)).ToList(); s.ServiceDescriptions = serviceDescriptions?.TryGet(s.Id).Where(n => availableLanguages.Contains(n.LocalizationId)).ToList(); } }); var result = TranslationManagerToVm.TranslateAll <ServiceCollectionVersioned, VmOpenApiServiceCollectionVersionBase>(serviceCollections).ToList(); if (result == null) { throw new Exception(CoreMessages.OpenApi.RecordNotFound); } // Get the right open api view model version var versionList = new List <IVmOpenApiServiceCollectionVersionBase>(); result.ForEach(serviceCollection => { // Get the sourceId if user is logged in var userId = utilities.GetRelationIdForExternalSource(false); if (!string.IsNullOrEmpty(userId)) { serviceCollection.SourceId = GetSourceId <ServiceCollection>(serviceCollection.Id.Value, userId, unitOfWork); } versionList.Add(GetEntityByOpenApiVersion(serviceCollection as IVmOpenApiServiceCollectionVersionBase, openApiVersion)); }); return(versionList); }
public AddServiceTests() { _serviceId = Guid.NewGuid(); _serviceVersionedId = Guid.NewGuid(); _channelId = Guid.NewGuid(); _channelVersionedId = Guid.NewGuid(); SetupTypesCacheMock <ServiceType>(); SetupTypesCacheMock <ServiceChargeType>(); var serviceVersioned = new ServiceVersioned { Id = _serviceVersionedId, UnificRootId = _serviceId, UnificRoot = new Model.Models.Service() { Id = _serviceId, ServiceServiceChannels = new List <ServiceServiceChannel>() }, Organization = new Model.Models.Organization() }; var channelVersioned = EntityGenerator.CreateEntity <ServiceChannelVersioned, ServiceChannel, ServiceChannelLanguageAvailability>(PublishedId, _channelId, _channelVersionedId); channelVersioned.UnificRoot = new ServiceChannel { Id = _channelId, Versions = new List <ServiceChannelVersioned> { channelVersioned } }; var connectionList = new List <ServiceServiceChannel> { new ServiceServiceChannel { Service = serviceVersioned.UnificRoot, ServiceId = serviceVersioned.UnificRootId, ServiceChannel = channelVersioned.UnificRoot, ServiceChannelId = channelVersioned.UnificRootId } }; translationManagerVModelMockSetup.Setup(t => t.Translate <IVmOpenApiServiceInVersionBase, ServiceVersioned>(It.IsAny <IVmOpenApiServiceInVersionBase>(), It.IsAny <IUnitOfWorkWritable>())) .Returns((IVmOpenApiServiceInVersionBase x, IUnitOfWorkWritable y) => { if (!string.IsNullOrEmpty(x.StatutoryServiceGeneralDescriptionId)) { serviceVersioned.StatutoryServiceGeneralDescriptionId = x.StatutoryServiceGeneralDescriptionId.ParseToGuid(); } serviceVersioned.PublishingStatusId = PublishingStatusCache.Get(x.PublishingStatus); if (x.ServiceNames?.Count > 0) { serviceVersioned.ServiceNames = new List <ServiceName>(); x.ServiceNames.ForEach(n => serviceVersioned.ServiceNames.Add(new ServiceName { Name = n.Value })); } if (!string.IsNullOrEmpty(x.Type)) { serviceVersioned.TypeId = TypeCache.Get <ServiceType>(x.Type); } if (!string.IsNullOrEmpty(x.ServiceChargeType)) { serviceVersioned.ChargeTypeId = TypeCache.Get <ServiceChargeType>(x.ServiceChargeType); } return(serviceVersioned); }); translationManagerVModelMockSetup.Setup(t => t.TranslateAll <VmOpenApiServiceServiceChannelInVersionBase, ServiceServiceChannel>(It.IsAny <List <V7VmOpenApiServiceServiceChannelAstiInBase> >(), It.IsAny <IUnitOfWorkWritable>())) .Returns((List <V7VmOpenApiServiceServiceChannelAstiInBase> x, IUnitOfWorkWritable y) => { var connections = new List <ServiceServiceChannel>(); x.ForEach(c => { var cv = EntityGenerator.CreateEntity <ServiceChannelVersioned, ServiceChannel, ServiceChannelLanguageAvailability>(PublishedId, c.ChannelGuid, _channelVersionedId); cv.UnificRoot = new ServiceChannel { Id = c.ChannelGuid, Versions = new List <ServiceChannelVersioned> { cv } }; var connection = new ServiceServiceChannel { ServiceChannelId = c.ChannelGuid, ServiceChannel = cv.UnificRoot }; if (c.Description?.Count > 0) { connection.ServiceServiceChannelDescriptions = new List <ServiceServiceChannelDescription>(); c.Description.ForEach(d => { var description = new ServiceServiceChannelDescription { Description = d.Value }; connection.ServiceServiceChannelDescriptions.Add(description); }); connections.Add(connection); } }); return(connections); }); ServiceRepoMock.Setup(g => g.All()).Returns((new List <ServiceVersioned> { serviceVersioned }).AsQueryable()); ConnectionRepoMock.Setup(g => g.All()).Returns(connectionList.AsQueryable()); //ServiceChannelRepoMock.Setup(g => g.All()).Returns((new List<ServiceChannelVersioned> { channelVersioned }).AsQueryable()); unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes( It.IsAny <IQueryable <ServiceVersioned> >(), It.IsAny <Func <IQueryable <ServiceVersioned>, IQueryable <ServiceVersioned> > >(), It.IsAny <bool>() )).Returns(new List <ServiceVersioned> { serviceVersioned }.AsQueryable()); unitOfWorkMockSetup.Setup(uw => uw.ApplyIncludes( It.IsAny <IQueryable <ServiceServiceChannel> >(), It.IsAny <Func <IQueryable <ServiceServiceChannel>, IQueryable <ServiceServiceChannel> > >(), It.IsAny <bool>() )).Returns(connectionList.AsQueryable()); VersioningManagerMock.Setup(s => s.GetVersionId <ServiceVersioned>(unitOfWorkMockSetup.Object, _serviceId, PublishingStatus.Published, true)).Returns(_serviceVersionedId); translationManagerMockSetup.Setup(t => t.Translate <ServiceVersioned, VmOpenApiServiceVersionBase>(It.IsAny <ServiceVersioned>())) .Returns((ServiceVersioned sv) => { var vm = new VmOpenApiServiceVersionBase() { Id = sv.UnificRootId, StatutoryServiceGeneralDescriptionId = sv.StatutoryServiceGeneralDescriptionId, PublishingStatus = PublishingStatusCache.GetByValue(sv.PublishingStatusId) }; if (sv.ServiceNames?.Count > 0) { vm.ServiceNames = new List <VmOpenApiLocalizedListItem>(); sv.ServiceNames.ForEach(n => vm.ServiceNames.Add(new VmOpenApiLocalizedListItem { Value = n.Name })); } if (sv.UnificRoot?.ServiceServiceChannels?.Count > 0) { vm.ServiceChannels = new List <V7VmOpenApiServiceServiceChannel>(); sv.UnificRoot.ServiceServiceChannels.ForEach(c => { var channel = new V7VmOpenApiServiceServiceChannel { ServiceChannel = new VmOpenApiItem { Id = c.ServiceChannelId } }; vm.ServiceChannels.Add(channel); }); } return(vm); }); }