public Result <RelationOptionsDTO, OperationError> GetAvailableOptions(int fromSystemUsageId, int toSystemUsageId)
{
var operationContext = new SystemRelationOperationContext(new SystemRelationOperationParameters
{
FromSystemUsageId = fromSystemUsageId,
ToSystemUsageId = toSystemUsageId
}, new SystemRelationOperationEntities());
return
(LoadFromSystemUsage(operationContext)
.Bind(LoadToSystemUsage)
.Bind(WithAuthorizedReadAccess)
.Match <Result <RelationOptionsDTO, OperationError> >
(
onSuccess: context =>
{
var fromSystemUsage = context.Entities.FromSystemUsage;
var toSystemUsage = context.Entities.ToSystemUsage;
if (!fromSystemUsage.IsInSameOrganizationAs(toSystemUsage))
{
return new OperationError("source and destination usages are from different organizations", OperationFailure.BadInput);
}
var availableFrequencyTypes = _frequencyService.GetAvailableOptions(fromSystemUsage.OrganizationId).ToList();
var exposedInterfaces = toSystemUsage.GetExposedInterfaces();
var contracts = _contractRepository.GetByOrganizationId(fromSystemUsage.OrganizationId).OrderBy(c => c.Name).ToList();
return new RelationOptionsDTO(fromSystemUsage, toSystemUsage, exposedInterfaces, contracts, availableFrequencyTypes);
},
onFailure: error => error
));
}
public Result <SystemRelation, OperationError> ModifyRelation(
int fromSystemUsageId,
int relationId,
int toSystemUsageId,
string changedDescription,
string changedReference,
int?toInterfaceId,
int?toContractId,
int?toFrequencyId)
{
var operationContext = new SystemRelationOperationContext(
new SystemRelationOperationParameters(fromSystemUsageId, toSystemUsageId, toInterfaceId, toFrequencyId, toContractId),
new SystemRelationOperationEntities());
var originalToSystemUsage = _relationRepository.GetByKey(relationId)?.ToSystemUsage;
if (originalToSystemUsage == null)
{
return(Result <SystemRelation, OperationError> .Failure(OperationFailure.NotFound));
}
return
(LoadFromSystemUsage(operationContext)
.Bind(LoadToSystemUsage)
.Bind(WithAuthorizedModificationAccess)
.Bind(LoadFrequency)
.Bind(LoadInterface)
.Bind(LoadContract)
.Match
(
onSuccess: context =>
{
var fromSystemUsage = context.Entities.FromSystemUsage;
var toSystemUsage = context.Entities.ToSystemUsage;
var frequency = context.Entities.Frequency;
var contract = context.Entities.Contract;
var relationInterface = context.Entities.Interface;
return fromSystemUsage
.ModifyUsageRelation(relationId, toSystemUsage, changedDescription, changedReference, relationInterface, contract, frequency)
.Match <Result <SystemRelation, OperationError> >
(
onSuccess: modifiedRelation =>
{
if (originalToSystemUsage.Id != toSystemUsageId)
{
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(originalToSystemUsage));
}
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(fromSystemUsage));
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(toSystemUsage));
_usageRepository.Save();
return modifiedRelation;
},
onFailure: error => error
);
},
onFailure: error => error
));
}
public Result <SystemRelation, OperationError> AddRelation(
int fromSystemUsageId,
int toSystemUsageId,
int?interfaceId,
string description,
string reference,
int?frequencyId,
int?contractId)
{
var operationContext = new SystemRelationOperationContext(
new SystemRelationOperationParameters(fromSystemUsageId, toSystemUsageId, interfaceId, frequencyId, contractId),
new SystemRelationOperationEntities());
return
(LoadFromSystemUsage(operationContext)
.Bind(LoadToSystemUsage)
.Bind(WithAuthorizedModificationAccess)
.Bind(LoadFrequency)
.Bind(LoadInterface)
.Bind(LoadContract)
.Match
(
onSuccess: context =>
{
var fromSystemUsage = context.Entities.FromSystemUsage;
var toSystemUsage = context.Entities.ToSystemUsage;
var frequency = context.Entities.Frequency;
var contract = context.Entities.Contract;
var relationInterface = context.Entities.Interface;
return fromSystemUsage
.AddUsageRelationTo(toSystemUsage, relationInterface, description, reference, frequency, contract)
.Match <Result <SystemRelation, OperationError> >
(
onSuccess: createdRelation =>
{
_usageRepository.Save();
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(fromSystemUsage));
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(toSystemUsage));
return createdRelation;
},
onFailure: error => error
);
},
onFailure: error => error
));
}
public Result <IEnumerable <ItSystemUsage>, OperationError> GetSystemUsagesWhichCanBeRelatedTo(int fromSystemUsageId, Maybe <string> nameContent, int pageSize)
{
if (pageSize < 1)
{
return(new OperationError("Min page size is 1", OperationFailure.BadInput));
}
if (pageSize > 25)
{
return(new OperationError("Max page size is 25", OperationFailure.BadInput));
}
var operationContext = new SystemRelationOperationContext(new SystemRelationOperationParameters {
FromSystemUsageId = fromSystemUsageId
}, new SystemRelationOperationEntities());
return
(LoadFromSystemUsage(operationContext)
.Bind(WithAuthorizedReadAccess)
.Match <Result <IEnumerable <ItSystemUsage>, OperationError> >
(
onSuccess: context =>
{
var fromUsage = context.Entities.FromSystemUsage;
var systemsInUse = _systemRepository
.GetSystemsInUse(fromUsage.OrganizationId);
var idsOfSystemsInUse = nameContent
.Select(name => systemsInUse.ByPartOfName(name))
.GetValueOrFallback(systemsInUse)
.OrderBy(x => x.Name)
.Take(pageSize)
.Select(x => x.Id)
.ToList();
return _usageRepository
.AsQueryable()
.ByOrganizationId(fromUsage.OrganizationId) //Only usages from same organization
.ExceptEntitiesWithIds(fromSystemUsageId) //do not include "from" system
.Where(u => idsOfSystemsInUse.Contains(u.ItSystemId))
.ToList();
},
onFailure: error => error
));
}
private Result <SystemRelationOperationContext, OperationError> LoadContract(SystemRelationOperationContext context)
{
var toContract = Maybe <ItContract> .None;
var contractId = context.Input.ContractId;
if (contractId.HasValue)
{
toContract = _contractRepository.GetById(contractId.Value);
if (toContract.IsNone)
{
return(new OperationError("Contract id does not point to a valid contract", OperationFailure.BadInput));
}
}
context.Entities.Contract = toContract.GetValueOrDefault();
return(context);
}
public Result <IEnumerable <SystemRelation>, OperationError> GetRelationsFrom(int systemUsageId)
{
var operationContext = new SystemRelationOperationContext(new SystemRelationOperationParameters {
FromSystemUsageId = systemUsageId
}, new SystemRelationOperationEntities());
return
(LoadFromSystemUsage(operationContext)
.Bind(WithAuthorizedReadAccess)
.Match <Result <IEnumerable <SystemRelation>, OperationError> >
(
onSuccess: context => context
.Entities
.FromSystemUsage
.UsageRelations
.ToList(),
onFailure: error => error
));
}
public Result <SystemRelation, OperationFailure> GetRelationFrom(int systemUsageId, int relationId)
{
var operationContext = new SystemRelationOperationContext(new SystemRelationOperationParameters {
FromSystemUsageId = systemUsageId
}, new SystemRelationOperationEntities());
return
(LoadFromSystemUsage(operationContext)
.Bind(WithAuthorizedReadAccess)
.Match
(
onSuccess: context => context
.Entities
.FromSystemUsage
.GetUsageRelation(relationId)
.Select <Result <SystemRelation, OperationFailure> >(relation => relation)
.GetValueOrFallback(OperationFailure.NotFound),
onFailure: error => error.FailureType
));
}
public Result <SystemRelation, OperationFailure> RemoveRelation(int fromSystemUsageId, int relationId)
{
using (var transaction = _transactionManager.Begin(IsolationLevel.ReadCommitted))
{
var operationContext = new SystemRelationOperationContext(new SystemRelationOperationParameters {
FromSystemUsageId = fromSystemUsageId
}, new SystemRelationOperationEntities());
return
(LoadFromSystemUsage(operationContext)
.Bind(WithAuthorizedModificationAccess)
.Match
(
onSuccess: context => context
.Entities
.FromSystemUsage
.RemoveUsageRelation(relationId)
.Match <Result <SystemRelation, OperationFailure> >
(
onSuccess: removedRelation =>
{
var fromSystemUsage = removedRelation.FromSystemUsage;
var toSystemUsage = removedRelation.ToSystemUsage;
_relationRepository.DeleteWithReferencePreload(removedRelation);
_relationRepository.Save();
_usageRepository.Save();
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(fromSystemUsage));
_domainEvents.Raise(new EntityUpdatedEvent <ItSystemUsage>(toSystemUsage));
transaction.Commit();
return removedRelation;
},
onFailure: error =>
{
_logger.Error("Attempt to remove relation from {systemUsageId} with Id {relationId} failed with {error}", fromSystemUsageId, relationId, error);
return error;
}),
onFailure: error => error.FailureType
));
}
}
private Result <SystemRelationOperationContext, OperationError> LoadInterface(SystemRelationOperationContext context)
{
var toInterface = Maybe <ItInterface> .None;
var interfaceId = context.Input.InterfaceId;
if (interfaceId.HasValue)
{
toInterface = _interfaceRepository.GetByKey(interfaceId.Value);
if (toInterface.IsNone)
{
return(new OperationError("The provided interface id does not point to a valid interface", OperationFailure.BadInput));
}
}
context.Entities.Interface = toInterface.GetValueOrDefault();
return(context);
}
private Result <SystemRelationOperationContext, OperationError> LoadFrequency(SystemRelationOperationContext context)
{
var toFrequency = Maybe <RelationFrequencyType> .None;
var frequencyId = context.Input.FrequencyId;
if (frequencyId.HasValue)
{
toFrequency = _frequencyService.GetAvailableOption(context.Entities.FromSystemUsage.OrganizationId, frequencyId.Value);
if (toFrequency.IsNone)
{
return(new OperationError("Frequency type is not available in the organization", OperationFailure.BadInput));
}
}
context.Entities.Frequency = toFrequency.GetValueOrDefault();
return(context);
}
private Result <SystemRelationOperationContext, OperationError> LoadToSystemUsage(SystemRelationOperationContext context)
{
var toSystemUsage = _usageRepository.GetByKey(context.Input.ToSystemUsageId);
if (toSystemUsage == null)
{
return(new OperationError("'To' could not be found", OperationFailure.BadInput));
}
context.Entities.ToSystemUsage = toSystemUsage;
return(context);
}
private Result <SystemRelationOperationContext, OperationError> WithAuthorizedReadAccess(SystemRelationOperationContext context)
{
return(!_authorizationContext.AllowReads(context.Entities.FromSystemUsage)
? Result <SystemRelationOperationContext, OperationError> .Failure(OperationFailure.Forbidden)
: context);
}
private Result <SystemRelationOperationContext, OperationError> LoadFromSystemUsage(SystemRelationOperationContext context)
{
var fromSystemUsage = _usageRepository.GetByKey(context.Input.FromSystemUsageId);
if (fromSystemUsage == null)
{
return(new OperationError("'From' not found", OperationFailure.NotFound));
}
context.Entities.FromSystemUsage = fromSystemUsage;
return(context);
}
