public IServiceResultWrap SaveRelations([FromBody] VmRelations model)
{
return(serviceManager.CallService(
() => new ServiceLocalizedResultWrap()
{
Data = new VmServiceAndChannelResult()
{
ConnectedServices = serviceAndChannelService.SaveServiceAndChannels(model),
}
},
new Dictionary <Type, string>()
{
{ typeof(string), MessageAddServiceAndChannel },
{ typeof(RoleActionException), MessageAddServiceAndChannelRole }
}));
}
public List <IVmBase> SaveServiceAndChannels(VmRelations relations)
{
var result = new List <IVmBase>();
Dictionary <Guid, Guid> serviceVersion = new Dictionary <Guid, Guid>();
contextManager.ExecuteWriter(unitOfWork =>
{
IQueryable <Guid> supportedChannelIds = null;
var userOrgs = userOrganizationService.GetUserCompleteOrgStructure(unitOfWork);
if (userOrganizationService.UserHighestRole(userOrgs) != UserRoleEnum.Eeva)
{
var schvRep = unitOfWork.CreateRepository <IServiceChannelVersionedRepository>();
var userOrgsIds = userOrgs.SelectMany(i => i).Select(i => i.OrganizationId).ToList();
var psPublished = typesCache.Get <PublishingStatusType>(PublishingStatus.Published.ToString());
var psCommonForAll = typesCache.Get <ServiceChannelConnectionType>(ServiceChannelConnectionTypeEnum.CommonForAll.ToString());
var channelIds = relations.ServiceAndChannelRelations.SelectMany(r => r.ChannelRelations).Select(ch => ch.ConnectedChannel.Id);
var channels = schvRep.All().Where(i => channelIds.Contains(i.Id));
var supportedChannels = channels.Where(ch => (userOrgsIds.Contains(ch.OrganizationId) || (ch.PublishingStatusId == psPublished && ch.ConnectionTypeId == psCommonForAll)));
supportedChannelIds = supportedChannels.Select(ch => ch.UnificRootId);
}
SetTranslatorLanguage(relations);
relations.ServiceAndChannelRelations = relations.ServiceAndChannelRelations.Distinct(new RelationComparer()).ToList();
relations.ServiceAndChannelRelations.ForEach(i => i.ChannelRelations = i.ChannelRelations.Distinct(new RelationChannelsComparer()).ToList());
var serviceVersionedRep = unitOfWork.CreateRepository <IServiceVersionedRepository>();
var serviceVersionedIds = relations.ServiceAndChannelRelations.Select(sv => sv.Id).ToList();
var unificRootIds = serviceVersionedRep.All().Where(sv => serviceVersionedIds.Contains(sv.Id)).ToDictionary(k => k.Id, v => v.UnificRootId);
foreach (var item in relations.ServiceAndChannelRelations)
{
if (!item.Id.IsAssigned() || !unificRootIds.ContainsKey(item.Id.Value))
{
continue;
}
item.UnificRootId = unificRootIds[item.Id.Value];
item.ChannelRelations.ForEach(chs => chs.Service = unificRootIds[item.Id.Value]);
}
var relationData = TranslationManagerToEntity.TranslateAll <VmServiceChannelRelation, Service>(relations.ServiceAndChannelRelations, unitOfWork);
serviceVersion = unitOfWork.TranslationCloneCache.GetFromCachedSet <ServiceVersioned>().ToDictionary(i => i.OriginalEntity.Id, i => i.ClonedEntity.Id);
foreach (var service in relationData)
{
var supportedServiceServiceChannels = supportedChannelIds == null
? service.ServiceServiceChannels
: service.ServiceServiceChannels.Where(ch => supportedChannelIds.Contains(ch.ServiceChannelId)).ToList();
service.ServiceServiceChannels = dataUtils.UpdateCollectionForReferenceTable(unitOfWork, supportedServiceServiceChannels, query => query.ServiceId == service.Id, channel => channel.ServiceChannelId);
UpdateDigitalAuthorizationCollection(unitOfWork, service.ServiceServiceChannels);
}
unitOfWork.Save();
});
contextManager.ExecuteReader(unitOfWork =>
{
var serviceCloneData = new Dictionary <Guid, string>();
relations.ServiceAndChannelRelations.ForEach(service =>
{
if (serviceVersion.ContainsKey(service.Id.Value))
{
serviceCloneData.Add(serviceVersion[service.Id.Value], service.ConnectedServiceId);
}
});
var cloneServiceIds = serviceCloneData.Select(y => y.Key).ToList();
var serviceRep = unitOfWork.CreateRepository <IServiceVersionedRepository>();
var resultTemp = unitOfWork.ApplyIncludes(serviceRep.All().Where(x => cloneServiceIds.Contains(x.Id)), q =>
q.Include(i => i.ServiceNames).ThenInclude(i => i.Type)
.Include(i => i.UnificRoot).ThenInclude(i => i.ServiceServiceChannels).ThenInclude(i => i.ServiceChannel).ThenInclude(i => i.Versions).ThenInclude(i => i.ServiceChannelNames).ThenInclude(i => i.Type)
.Include(i => i.UnificRoot).ThenInclude(i => i.ServiceServiceChannels).ThenInclude(i => i.ServiceChannel).ThenInclude(i => i.Versions).ThenInclude(i => i.Type)
.Include(i => i.UnificRoot).ThenInclude(i => i.ServiceServiceChannels).ThenInclude(i => i.ServiceServiceChannelDescriptions).ThenInclude(i => i.Type)
.Include(i => i.UnificRoot).ThenInclude(i => i.ServiceServiceChannels).ThenInclude(i => i.ServiceServiceChannelDigitalAuthorizations).ThenInclude(i => i.DigitalAuthorization)
);
var cloneServices = TranslationManagerToVm.TranslateAll <ServiceVersioned, VmServiceRelationListItem>(resultTemp).Cast <IVmServiceListItem>().ToList();
cloneServices.ForEach(service =>
{
if (serviceCloneData.ContainsKey(service.Id))
{
result.Add(new VmConnectedService()
{
UiId = serviceCloneData[service.Id], Service = service
});
}
});
});
return(result);
}
