Example #1
0
        public Task <Result> Add(MarkupPolicyData policyData)
        {
            return(ValidatePolicy(policyData)
                   .Bind(SavePolicy));


            async Task <Result> SavePolicy()
            {
                var now = _dateTimeProvider.UtcNow();

                var(type, counterpartyId, agencyId, agentId) = policyData.Scope;

                var policy = new MarkupPolicy
                {
                    Description      = policyData.Settings.Description,
                    Order            = policyData.Settings.Order,
                    ScopeType        = type,
                    Target           = policyData.Target,
                    AgencyId         = agencyId,
                    CounterpartyId   = counterpartyId,
                    AgentId          = agentId,
                    TemplateSettings = policyData.Settings.TemplateSettings,
                    Currency         = policyData.Settings.Currency,
                    Created          = now,
                    Modified         = now,
                    TemplateId       = policyData.Settings.TemplateId
                };

                _context.MarkupPolicies.Add(policy);
                await _context.SaveChangesAsync();

                return(Result.Success());
            }
        }
Example #2
0
        public async Task <IActionResult> AddPolicy([FromBody] MarkupPolicyData policyData)
        {
            var(_, isFailure, error) = await _policyManager.Add(policyData);

            if (isFailure)
            {
                return(BadRequest(ProblemDetailsBuilder.Build(error)));
            }

            return(NoContent());
        }
        public async Task <Result> Add(MarkupPolicyData policyData)
        {
            var destinationScopeType = await GetDestinationScopeType(policyData.Settings.DestinationScopeId);

            if (destinationScopeType.IsFailure)
            {
                return(Result.Failure(destinationScopeType.Error));
            }

            var(_, isFailure, markupPolicy, error) = await ValidatePolicy(policyData)
                                                     .Map(SavePolicy)
                                                     .Tap(p => WriteAuditLog(p, MarkupPolicyEventOperationType.Created));

            if (isFailure)
            {
                return(Result.Failure(error));
            }

            return(await UpdateDisplayedMarkupFormula(markupPolicy));


            async Task <MarkupPolicy> SavePolicy()
            {
                var now = _dateTimeProvider.UtcNow();

                var(type, agencyId, agentId, agentScopeId) = policyData.Scope;
                var settings = policyData.Settings;

                var policy = new MarkupPolicy
                {
                    Description          = settings.Description,
                    Order                = settings.Order,
                    Target               = policyData.Target,
                    TemplateSettings     = settings.TemplateSettings,
                    Currency             = settings.Currency,
                    Created              = now,
                    Modified             = now,
                    TemplateId           = settings.TemplateId,
                    SubjectScopeType     = type,
                    SubjectScopeId       = agentScopeId,
                    DestinationScopeId   = settings.DestinationScopeId,
                    DestinationScopeType = destinationScopeType.Value
                };

                _context.MarkupPolicies.Add(policy);
                await _context.SaveChangesAsync();

                return(policy);
            }
        }