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