public async Task <FilterCurrSaleExDecDto> GetListExDecSalesByExdecId(FilterCurrSaleExDecDto filterDto)
        {
            var asQueryable = _currencySaleExDecRepository
                              .GetEntities()
                              .Where(x => x.ExDeclarationId == filterDto.Id)
                              .AsQueryable();
            var count = (int)Math.Ceiling(asQueryable.Count() / (double)filterDto.TakeEntity);
            var pager = Pager.Builder(count, filterDto.PageId, filterDto.TakeEntity);
            var list  = await asQueryable.Paging(pager).ToListAsync();

            filterDto.CurrencySaleExDecs = new List <CurrencySaleExDecDto>();
            foreach (var item in list)
            {
                var currencySaleItem = await _currencySaleRepository.GetCurrencyByIdIncludesCustomerAndBroker(item.CurrencySaleId);

                var exDec = await _exdeclarationRepository.GetEntityById(item.ExDeclarationId);

                filterDto.CurrencySaleExDecs.Add(new CurrencySaleExDecDto()
                {
                    Id           = item.Id,
                    CurrSaleDate = currencySaleItem.SaleDate,
                    BrokerName   = currencySaleItem.Broker.Name + " (" + currencySaleItem.Broker.Title + ") ",
                    CustomerName = currencySaleItem.Customer.Name,
                    ExDecCode    = exDec.ExchangeDeclarationCode,
                    Price        = item.Price
                });
            }
            return(filterDto.SetCurrencySaleExDec(filterDto.CurrencySaleExDecs).SetPaging(pager));
        }
        public async Task <FilterCurrSalePiDto> GetListExDecSalesByPiDetailId(FilterCurrSalePiDto filterDto)
        {
            var piDetailIdList = _piDetailRepository
                                 .GetEntities()
                                 .Where(x => x.PeroformaInvoiceId == filterDto.Id)
                                 .Select(x => x.Id);
            var asQueryable = _currPiDetailRepository
                              .GetEntities()
                              .Include(X => X.CurrencySale)
                              .Where(x => piDetailIdList.Contains((long)x.PeroformaInvoiceDetailId))
                              .AsQueryable();

            //var listOfRoleId = user.Roles.Select(r => r.RoleId);
            //var roles = db.Roles.Where(r => listOfRoleId.Contains(r.RoleId));
            var count = (int)Math.Ceiling(asQueryable.Count() / (double)filterDto.TakeEntity);
            var pager = Pager.Builder(count, filterDto.PageId, filterDto.TakeEntity);
            var list  = await asQueryable.Paging(pager).ToListAsync();

            filterDto.CurrencySaleDetailPi = new List <CurrencySaleDetailPiDto>();
            foreach (var item in list)
            {
                var currencySaleItem = await _currencySaleRepository.GetCurrencyByIdIncludesCustomerAndBroker(item.CurrencySaleId);

                var peroformaInvoice = await _piRepository.GetEntityById(filterDto.Id);

                filterDto.CurrencySaleDetailPi.Add(new CurrencySaleDetailPiDto()
                {
                    Id                 = item.Id,
                    BrokerName         = currencySaleItem.Broker.Name + " (" + currencySaleItem.Broker.Title + ") ",
                    CurrSaleDate       = currencySaleItem.SaleDate,
                    CustomerName       = currencySaleItem.Customer.Name,
                    Price              = item.Price,
                    ProfitLossAmount   = item.ProfitLossAmount,
                    PiCode             = peroformaInvoice.PiCode,
                    SellPriceCurrency  = item.CurrencySale.SalePricePerUnit,
                    SellPriceCommodity = peroformaInvoice.BasePrice
                });
            }
            return(filterDto.SetCurrencySaleExDec(filterDto.CurrencySaleDetailPi).SetPaging(pager));
        }
Ejemplo n.º 3
0
        public async Task <CurrencySaleDto> GetViewDataFromCurrency(ICurrencySaleRepository saleRepository, ICurrencySalePiDetailRepository salePiDetailRepository, CurrencySale currencySale)
        {
            //var currencySaleItem = (CurrencyType)_currencySale.CurrencyType == CurrencyType.CarrencySales ? await _saleRepository.GetCurrencyByIdIncludesCustomerAndBroker(_currencySale.Id) : await _saleRepository.GetCurrencyByIdIncludesBroker(_currencySale.Id);
            var currencySaleItem = await saleRepository.GetCurrencyByIdIncludesCustomerAndBroker(currencySale.Id);

            var sumProfit = (CurrencyType)currencySale.CurrencyType == CurrencyType.CarrencySales ? await salePiDetailRepository.GetSumProfitLost(currencySale.Id) :0;

            var filterDto = new CurrencySaleDto()
            {
                Id               = currencySale.Id,
                BrokerName       = currencySaleItem.Broker.Name + " (" + currencySaleItem.Broker.Title + ") ",
                CurrSaleDate     = currencySaleItem.SaleDate,
                CustomerName     = currencySaleItem.Customer.Name,
                Price            = currencySale.SalePrice,
                ProfitLossAmount = sumProfit,
                SalePricePerUnit = currencySale.SalePricePerUnit,
                TransferPrice    = currencySale.TransferPrice,
                TransferType     = (CurrencyTransferType)currencySale.TransferType,
                CurrencyType     = (CurrencyType)currencySale.CurrencyType
            };

            return(filterDto);
        }
        public async Task <FilterCurrSaleCustomerListDto> GetListSalesByCustomerId(long customerId, long financialPeriodId)
        {
            var financial = await _financialPeriodRepository.GetEntityById(financialPeriodId);

            var filterOutput        = new FilterCurrSaleCustomerListDto();
            var currencyAsQueryable = _saleRepository
                                      .GetEntities()
                                      .Where(x => x.CustomerId == customerId &&
                                             (x.SaleDate >= financial.FromDate && x.SaleDate < financial.ToDate))
                                      .AsQueryable();

            currencyAsQueryable = currencyAsQueryable.OrderByDescending(x => x.SaleDate);
            var count = (int)Math.Ceiling(currencyAsQueryable.Count() / (double)filterOutput.TakeEntity);
            var pager = Pager.Builder(count, filterOutput.PageId, filterOutput.TakeEntity);
            var list  = await currencyAsQueryable.Paging(pager).ToListAsync();

            filterOutput.Entities = new List <CurrencySaleDto>();
            foreach (var item in list)
            {
                var currencySaleItem = await _saleRepository.GetCurrencyByIdIncludesCustomerAndBroker(item.Id);

                var sumProfit = await _salePiDetailRepository.GetSumProfitLost(item.Id);

                filterOutput.Entities.Add(new CurrencySaleDto
                {
                    Id               = item.Id,
                    BrokerName       = currencySaleItem.Broker.Name + " (" + currencySaleItem.Broker.Title + ") ",
                    CurrSaleDate     = currencySaleItem.SaleDate,
                    CustomerName     = currencySaleItem.Customer.Name,
                    Price            = item.SalePrice,
                    ProfitLossAmount = sumProfit,
                    SalePricePerUnit = item.SalePricePerUnit,
                    TransferPrice    = item.TransferPrice,
                });
            }
            return((FilterCurrSaleCustomerListDto)filterOutput.SetEntitiesDto(filterOutput.Entities).SetPaging(pager));
        }