public async Task <IActionResult> AddDeposit([FromBody] AddDepositRequest request)
        {
            string method = nameof(AddDeposit);

            LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method, request);
            SingleResponse <object> response = new SingleResponse <object>();

            try
            {
                if (!request.CheckValidation(response))
                {
                    return(response.ToHttpResponse(Logger, method));
                }

                var deposit   = request.ToEntity(false);
                var purchases = request.ToPurchaseEntity();
                if (purchases.Sum(x => x.amount) != deposit.amount)
                {
                    response.ErrorCode    = (int)ErrorHandler.ErrorCode.BadRequest;
                    response.ErrorMessage = Constants.MessageText.PurcheseAmountSumError;
                    return(response.ToHttpResponse(Logger, method));
                }
                deposit.purchases = purchases;
                DbContext.Add(deposit);
                int save = await DbContext.SaveChangesAsync();

                if (save == 0)
                {
                    response.ErrorCode = (int)ErrorHandler.ErrorCode.DbSaveNotDone;
                    return(response.ToHttpResponse(Logger, method));
                }
                var entity_list = new List <Deposit> {
                    deposit
                }
                .Select(x => new
                {
                    x.account_id,
                    x.account_name,
                    x.cancel_cost,
                    x.count,
                    x.date,
                    x.fund_name,
                    x.id,
                    x.issue_cost,
                    x.purchases_count,
                    x.status,
                    x.unit_cost_id,
                    x.amount,
                    x.create_date,
                    x.creator_id
                }).First();
                response.Model     = entity_list;
                response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
            }
            catch (Exception ex)
            {
                LogHandler.LogError(Logger, response, method, ex);
            }
            return(response.ToHttpResponse(Logger, method));
        }
Esempio n. 2
0
 public IHttpActionResult Add(AddDepositRequest request)
 {
     try
     {
         var baseLocalhostUrl      = String.Format("{0}://{1}", Request.RequestUri.Scheme, Request.RequestUri.Authority);
         var domainCustomerDeposit = Mapper.Map <DomainCustomerDeposit>(request);
         var result = _customerDepositService.Add(domainCustomerDeposit, request.MonthCount, request.Email, baseLocalhostUrl, ModelState);
         if (result.ModelState != null && !result.ModelState.IsValid)
         {
             return(BadRequest(result.ModelState));
         }
         return(Ok(result.DocPath));
     }
     catch (BankClientException ex)
     {
         return(BadRequest(ex.Message));
     }
     catch (Exception ex)
     {
         return(InternalServerError(ex));
     }
 }
        public async Task <IActionResult> EditDeposit([FromBody] AddDepositRequest request)
        {
            string method = nameof(EditDeposit);

            LogHandler.LogMethod(LogHandler.EventType.Call, Logger, method, request);
            SingleResponse <object> response = new SingleResponse <object>();

            try
            {
                if (!request.CheckValidation(response))
                {
                    return(response.ToHttpResponse(Logger, method));
                }

                var entity = request.ToEntity(true);

                var existingEntity = await DbContext.GetDeposits(null, null, null, request.id).Include(x => x.purchases).FirstAsync();

                if (existingEntity == null)
                {
                    response.ErrorCode = (int)ErrorHandler.ErrorCode.NoContent;
                    return(response.ToHttpResponse(Logger, method));
                }

                existingEntity.account_id   = entity.account_id;
                existingEntity.status       = entity.status;
                existingEntity.unit_cost_id = entity.unit_cost_id;
                existingEntity.status       = entity.status;
                existingEntity.count        = entity.count;
                existingEntity.amount       = entity.amount;


                var purchases_request = request.ToPurchasesRequest(true);
                if (purchases_request.Sum(x => x.amount) != existingEntity.amount)
                {
                    response.ErrorCode    = (int)ErrorHandler.ErrorCode.BadRequest;
                    response.ErrorMessage = Constants.MessageText.PurcheseAmountSumError;
                    return(response.ToHttpResponse(Logger, method));
                }
                LogHandler.LogMethod(LogHandler.EventType.Operation, Logger, method, purchases_request);
                var purchases_old         = DbContext.GetPurchases(null, request.id);
                var purchase_ids_to_delet = purchases_old.Select(x => x.id).Where(x => !purchases_request.Select(y => y.id).Contains(x));
                var purchase_ids_new      = purchases_request.Select(x => x.id).Where(x => !purchases_old.Select(y => y.id).Contains(x));

                foreach (var purchase_id_to_delet in purchase_ids_to_delet)
                {
                    var purchase_delet = await DbContext.GetPurchase(new Purchase { id = purchase_id_to_delet });

                    DbContext.Remove(purchase_delet);
                }
                foreach (var purchase_request in purchases_request.Where(x => purchase_ids_new.Distinct().Contains(x.id)))
                {
                    var purchases_new = purchase_request.ToEntity();
                    existingEntity.purchases.Add(purchases_new);
                }

                int save = await DbContext.SaveChangesAsync();

                if (save == 0)
                {
                    response.ErrorCode = (int)ErrorHandler.ErrorCode.DbSaveNotDone;
                    return(response.ToHttpResponse(Logger, method));
                }
                var entity_list = new List <Deposit> {
                    entity
                }
                .Select(x => new
                {
                    x.account_id,
                    x.account_name,
                    x.cancel_cost,
                    x.count,
                    x.date,
                    x.fund_name,
                    x.id,
                    x.issue_cost,
                    x.purchases_count,
                    x.status,
                    x.unit_cost_id,
                    x.amount,
                    x.create_date,
                    x.creator_id
                }).First();
                response.Model     = entity_list;
                response.ErrorCode = (int)ErrorHandler.ErrorCode.OK;
            }
            catch (Exception ex)
            {
                LogHandler.LogError(Logger, response, method, ex);
            }
            return(response.ToHttpResponse(Logger, method));
        }