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