예제 #1
0
        public async Task <IActionResult> Handle(GetOpportunityQuery request, CancellationToken cancellationToken)
        {
            try
            {
                var tradersList = await _userRepository.GetCompanyTraders(request.CompanyId);

                var products = await _productRepository.GetAllProductsAsync(request.CompanyId, new List <string> {
                    "", "", ""
                });

                var leads = await _leadRepository.GetAllLeadsAsync(request.CompanyId, new DateTime(2000, 01, 01), new DateTime(2999, 12, 31));

                var opportunity = await _opportunityRepository.GetOpportunityAsync(request.OpportunityId, request.CompanyId);

                if (opportunity != null && opportunity.TraderId != request.UserId)
                {
                    if (!(await PermissionMonitor.CheckPermissionsAsync(_userRepository, request.UserId, "Modyfikacja cudzych szans sprzedaży")))
                    {
                        return(new JsonResult(new ApiResponse <object>
                        {
                            Data = null,
                            Code = 403,
                            ErrorMessage = "Brak uprawnień"
                        }));
                    }
                }

                var oppoRes = new SellOpportunityDetailsDto();

                if (request.OpportunityId > 0)
                {
                    oppoRes = new SellOpportunityDetailsDto
                    {
                        Id        = opportunity.Id,
                        Lead      = opportunity.Lead.Name + "," + opportunity.Lead.NIP,
                        Positions = new List <SellOpportunityPositionDetailsDto>(),
                        Status    = opportunity.Status.Name,
                        Trader    = opportunity.Trader.FirstName + " " + opportunity.Trader.LastName
                    };

                    var counter = 1;
                    foreach (var position in opportunity.Positions)
                    {
                        oppoRes.Positions.Add(new SellOpportunityPositionDetailsDto
                        {
                            Deleted           = false,
                            GrossValue        = position.GrossValue,
                            Id                = position.Id,
                            LocalId           = counter,
                            Markup            = position.Markup,
                            NetValue          = position.NetValue,
                            Product           = position.Product.Name,
                            Quantity          = position.Quantity,
                            VatValue          = position.VatValue,
                            UnitOfMeasurement = position.Product.UnitOfMeasurement
                        });
                        counter += 1;
                    }
                }
                else
                {
                    oppoRes = new SellOpportunityDetailsDto
                    {
                        Lead      = "",
                        Positions = new List <SellOpportunityPositionDetailsDto>(),
                        Status    = "",
                        Trader    = ""
                    };
                }

                var response = new SellOpportunityDetailsResponseDto
                {
                    CompanyTraders = tradersList.Select(x => (x.FirstName + " " + x.LastName)).ToList(),
                    Leads          = leads.Select(x => (x.Name + "," + x.NIP)).ToList(),
                    Products       = products.Select(x => new ProductForListDto
                    {
                        Id                = x.Id,
                        Name              = x.Name,
                        MarkupRate        = x.MarkupRate,
                        UnitOfMeasurement = x.UnitOfMeasurement,
                        UnitValue         = x.UnitValue,
                        VatRate           = x.VatRate
                    }).ToList(),
                    SellOpportunity = oppoRes
                };

                return(new JsonResult(new ApiResponse <SellOpportunityDetailsResponseDto>
                {
                    Data = response,
                    Code = 200,
                    ErrorMessage = ""
                }));
            }
            catch
            {
                return(new JsonResult(new ApiResponse <object>
                {
                    Data = null,
                    Code = 500,
                    ErrorMessage = "Nastąpił problem z serwerem, skontaktuj się z działem IT."
                }));
            }
        }
예제 #2
0
        public async Task <IActionResult> Handle(UpsertOpportunityCommand request, CancellationToken cancellationToken)
        {
            try
            {
                var validator = new SellOpportunityDetailsValidator();
                var result    = validator.Validate(request.SellOpportunity);

                if (!result.IsValid)
                {
                    var errorMsg = "";

                    foreach (var err in result.Errors)
                    {
                        errorMsg += err.ErrorMessage + "\r\n";
                    }

                    return(new JsonResult(new ApiResponse <object>
                    {
                        Data = null,
                        Code = 406,
                        ErrorMessage = errorMsg
                    }));
                }

                var opportunity = await _opportunityRepository.GetOpportunityAsync(request.SellOpportunity.Id, request.CompanyId);

                if (opportunity == null)
                {
                    opportunity                  = new SellOpportunityHeader();
                    opportunity.Id               = 0;
                    opportunity.CreateDate       = DateTime.Now;
                    opportunity.ModificationDate = opportunity.CreateDate;
                    opportunity.Positions        = new List <SellOpportunityPosition>();
                    opportunity.CompanyId        = request.CompanyId;
                }
                if (opportunity.Id > 0)
                {
                    opportunity.ModificationDate = DateTime.Now;
                }

                opportunity.Status = (await _opportunityStatusRepository.GetOpportunityStatusesAsync()).FirstOrDefault(x => x.Name == request.SellOpportunity.Status);
                opportunity.Lead   = await _leadRepository.GetLeadByNameAsync(request.SellOpportunity.Lead, request.CompanyId);

                opportunity.SumGrossValue  = 0;
                opportunity.SumMarkupValue = 0;
                opportunity.SumNetValue    = 0;
                opportunity.SumVatValue    = 0;
                opportunity.Trader         = await _userRepository.GetUserByNameAsync(request.SellOpportunity.Trader, request.CompanyId);

                foreach (var positionDto in request.SellOpportunity.Positions)
                {
                    if (!positionDto.Deleted)
                    {
                        if (positionDto.Id > 0)
                        {
                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].ModificationDate = opportunity.ModificationDate;
                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].NetValue         = positionDto.NetValue;
                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].Product          = await _productRepository.GetProductByNameAsync(positionDto.Product, request.CompanyId);

                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].Quantity   = positionDto.Quantity;
                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].VatValue   = positionDto.VatValue;
                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].Markup     = positionDto.Markup;
                            opportunity.Positions[opportunity.Positions.FindIndex(x => x.Id == positionDto.Id)].GrossValue = positionDto.GrossValue;
                        }
                        else
                        {
                            var position = new SellOpportunityPosition
                            {
                                Id                = 0,
                                CreateDate        = opportunity.CreateDate,
                                GrossValue        = positionDto.GrossValue,
                                Markup            = positionDto.Markup,
                                VatValue          = positionDto.VatValue,
                                ModificationDate  = opportunity.CreateDate,
                                NetValue          = positionDto.NetValue,
                                OpportunityHeader = opportunity,
                                Product           = await _productRepository.GetProductByNameAsync(positionDto.Product, request.CompanyId),
                                Quantity          = positionDto.Quantity
                            };
                            opportunity.Positions.Add(position);
                        }

                        opportunity.SumNetValue    += positionDto.NetValue;
                        opportunity.SumGrossValue  += positionDto.GrossValue;
                        opportunity.SumMarkupValue += positionDto.Markup;
                        opportunity.SumVatValue    += positionDto.VatValue;
                    }
                    else
                    {
                        await _opportunityRepository.RemoveOpportunityPositionAsync(positionDto.Id);
                    }
                }


                if (opportunity.Id == 0)
                {
                    opportunity = await _opportunityRepository.AddOpportunityAsync(opportunity);
                }
                else
                {
                    opportunity = await _opportunityRepository.UpdateAsync(opportunity);
                }

                if (opportunity != null)
                {
                    return(new JsonResult(new ApiResponse <object>
                    {
                        Data = null,
                        Code = 201,
                        ErrorMessage = ""
                    }));
                }
                else
                {
                    return(new JsonResult(new ApiResponse <object>
                    {
                        Data = null,
                        Code = 400,
                        ErrorMessage = "Coś poszło nie tak, sprawdź dane i spróbuj ponownie."
                    }));
                }
            }
            catch
            {
                return(new JsonResult(new ApiResponse <object>
                {
                    Data = null,
                    Code = 500,
                    ErrorMessage = "Nastąpił problem z serwerem, skontaktuj się z działem IT."
                }));
            }
        }