internal List <TransactionDto> getTransactionDtosEC(string storeId)
        {
            List <TransactionDto> result       = new List <TransactionDto>();
            List <Transaction>    transactions = new List <Transaction>();

            transactions = db.Transaction.Where(s => s.ExchangeStoreId == storeId && s.StatusId.Equals("ĐT")).ToList();
            foreach (Transaction transaction in transactions)
            {
                List <TransactionDetail>            details    = db.TransactionDetail.Where(s => s.TransId == transaction.Id).ToList();
                List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();
                foreach (TransactionDetail detail in details)
                {
                    TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                        materialRepository.getSimpleMaterial(detail.MaterialId), detail.Amount, detail.Unit);
                    detailDtos.Add(detailDto);
                }
                TransactionDto dto = new TransactionDto(transaction.Id, storeRepository.getSimpleStoreDto(transaction.ExchangeStoreId),
                                                        storeRepository.getSimpleStoreDto(transaction.StoreId),
                                                        transaction.Time, staffRepository.getSimpleStaff(transaction.StaffId),
                                                        typeRepository.getTransactionType(transaction.TransactionTypeId),
                                                        statusRepository.getStatus(transaction.StatusId), detailDtos);
                result.Add(dto);
            }
            return(result);
        }
        internal TransactionDto updateStateTransaction(string id, String statusId)
        {
            Transaction transaction = db.Transaction.Where(s => s.Id == int.Parse(id)).FirstOrDefault();

            if (transaction != null)
            {
                transaction.StatusId        = statusId;
                db.Entry(transaction).State = Microsoft.EntityFrameworkCore.EntityState.Modified;

                db.SaveChanges();
            }
            List <TransactionDetail>            details    = db.TransactionDetail.Where(s => s.TransId == transaction.Id).ToList();
            List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();

            foreach (TransactionDetail detail in details)
            {
                TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                    materialRepository.getSimpleMaterial(detail.MaterialId), detail.Amount, detail.Unit);
                detailDtos.Add(detailDto);
            }
            TransactionDto result = new TransactionDto(transaction.Id, storeRepository.getSimpleStoreDto(transaction.ExchangeStoreId),
                                                       storeRepository.getSimpleStoreDto(transaction.StoreId),
                                                       transaction.Time, staffRepository.getSimpleStaff(transaction.StaffId),
                                                       typeRepository.getTransactionType(transaction.TransactionTypeId),
                                                       statusRepository.getStatus(transaction.StatusId), detailDtos);

            return(result);
        }
        private TransactionDto GetTransactionDto(Transaction transaction)
        {
            List <TransactionDetail>            details    = transaction.TransactionDetail.ToList();
            List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();

            foreach (TransactionDetail detail in details)
            {
                TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                    materialRepository.getSimpleMaterial(detail.MaterialId), detail.Amount, detail.Unit);
                detailDtos.Add(detailDto);
            }
            TransactionDto dto = new TransactionDto(transaction.Id, storeRepository.getSimpleStoreDto(transaction.ExchangeStoreId),
                                                    storeRepository.getSimpleStoreDto(transaction.StoreId),
                                                    transaction.Time, staffRepository.getSimpleStaff(transaction.StaffId),
                                                    typeRepository.getTransactionType(transaction.TransactionTypeId),
                                                    statusRepository.getStatus(transaction.StatusId), detailDtos);

            return(dto);
        }
Пример #4
0
        public List <TransactionDto> getTransactionDtos(string storeId, string typeId, double startDate, double endDate, int id, int limit)
        {
            List <TransactionDto> result       = new List <TransactionDto>();
            List <transaction>    transactions = new List <transaction>();

            if (typeId == null)
            {
                transactions = db.transactions.Where(s => s.store_id == storeId).ToList();
            }
            else if (startDate == 0 && endDate == 0)
            {
                transactions = db.transactions.Where(s => s.store_id == storeId && s.transaction_type_id == typeId).ToList();
            }
            else
            {
                transactions = db.transactions.Where(s => s.store_id == storeId && s.transaction_type_id == typeId &&
                                                     stampConvert.convertTimeStamp(startDate) <= s.time && s.time <= stampConvert.convertTimeStamp(endDate)).ToList();
            }
            if (id == 0)
            {
                int count = 0;
                foreach (transaction transaction in transactions)
                {
                    List <transaction_detail>           details    = db.transaction_detail.Where(s => s.trans_id == transaction.id).ToList();
                    List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();
                    foreach (transaction_detail detail in details)
                    {
                        TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                            materialRepository.getSimpleMaterial(detail.material_id), detail.amount);
                        detailDtos.Add(detailDto);
                    }
                    TransactionDto dto = new TransactionDto(transaction.id, storeRepository.getSimpleStoreDto(transaction.exchange_store_id),
                                                            storeRepository.getSimpleStoreDto(transaction.store_id),
                                                            transaction.time, staffRepository.getSimpleStaff(transaction.staff.auth_token.ToString()),
                                                            typeRepository.getTransactionType(transaction.transaction_type_id),
                                                            statusRepository.getStatus(transaction.status_id), detailDtos);
                    result.Add(dto);
                    count += 1;
                    if (count >= limit)
                    {
                        break;
                    }
                }
            }
            else
            {
                transaction        member  = transactions.Where(s => s.id == id).FirstOrDefault();
                List <transaction> subList = transactions.GetRange(transactions.IndexOf(member), limit);
                foreach (transaction transaction in subList)
                {
                    List <transaction_detail>           details    = db.transaction_detail.Where(s => s.trans_id == transaction.id).ToList();
                    List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();
                    foreach (transaction_detail detail in details)
                    {
                        TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                            materialRepository.getSimpleMaterial(detail.material_id), detail.amount);
                        detailDtos.Add(detailDto);
                    }
                    TransactionDto dto = new TransactionDto(transaction.id, storeRepository.getSimpleStoreDto(transaction.exchange_store_id),
                                                            storeRepository.getSimpleStoreDto(transaction.store_id),
                                                            transaction.time, staffRepository.getSimpleStaff(transaction.staff_id.ToString()),
                                                            typeRepository.getTransactionType(transaction.transaction_type_id),
                                                            statusRepository.getStatus(transaction.status_id), detailDtos);
                    result.Add(dto);
                }
            }
            return(result);
        }
        public List <TransactionDto> getTransactionDtos(string storeId, string typeId, double startDate, double endDate, int id, int limit)
        {
            List <TransactionDto> result       = new List <TransactionDto>();
            List <Transaction>    transactions = new List <Transaction>();

            if (typeId == null && startDate == 0 && endDate == 0)
            {
                transactions = db.Transaction.Where(s => s.StoreId.ToLower().Equals(storeId.ToLower())).ToList();
            }
            else if (startDate == 0 && endDate == 0)
            {
                transactions = db.Transaction.Where(s => s.StoreId.ToLower().Equals(storeId.ToLower()) && s.TransactionTypeId.ToLower().Equals(typeId.ToLower())).ToList();
            }
            else
            {
                transactions = db.Transaction.Where(s => s.StoreId.ToLower().Equals(storeId.ToLower()) && s.TransactionTypeId.ToLower().Equals(typeId.ToLower()) &&
                                                    startDate <= stampConvert.convertDateTime(s.Time) && stampConvert.convertDateTime(s.Time) <= endDate).ToList();
            }
            if (id == 0)
            {
                int count = 0;
                foreach (Transaction transaction in transactions)
                {
                    List <TransactionDetail>            details    = db.TransactionDetail.Where(s => s.TransId == transaction.Id).ToList();
                    List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();
                    foreach (TransactionDetail detail in details)
                    {
                        TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                            materialRepository.getSimpleMaterial(detail.MaterialId), detail.Amount, detail.Unit);
                        detailDtos.Add(detailDto);
                    }
                    TransactionDto dto = new TransactionDto(transaction.Id, storeRepository.getSimpleStoreDto(transaction.ExchangeStoreId),
                                                            storeRepository.getSimpleStoreDto(transaction.StoreId),
                                                            transaction.Time, staffRepository.getSimpleStaff(transaction.StaffId),
                                                            typeRepository.getTransactionType(transaction.TransactionTypeId),
                                                            statusRepository.getStatus(transaction.StatusId), detailDtos);
                    result.Add(dto);
                    count += 1;
                    if (count >= limit)
                    {
                        break;
                    }
                }
            }
            else
            {
                Transaction        member  = transactions.Where(s => s.Id == id).FirstOrDefault();
                List <Transaction> subList = transactions.GetRange(transactions.IndexOf(member), limit);
                foreach (Transaction transaction in subList)
                {
                    List <TransactionDetail>            details    = db.TransactionDetail.Where(s => s.TransId == transaction.Id).ToList();
                    List <TransactionMaterialAmountDto> detailDtos = new List <TransactionMaterialAmountDto>();
                    foreach (TransactionDetail detail in details)
                    {
                        TransactionMaterialAmountDto detailDto = new TransactionMaterialAmountDto(
                            materialRepository.getSimpleMaterial(detail.MaterialId), detail.Amount, detail.Unit);
                        detailDtos.Add(detailDto);
                    }
                    TransactionDto dto = new TransactionDto(transaction.Id, storeRepository.getSimpleStoreDto(transaction.ExchangeStoreId),
                                                            storeRepository.getSimpleStoreDto(transaction.StoreId),
                                                            transaction.Time, staffRepository.getSimpleStaff(transaction.StaffId),
                                                            typeRepository.getTransactionType(transaction.TransactionTypeId),
                                                            statusRepository.getStatus(transaction.StatusId), detailDtos);
                    result.Add(dto);
                }
            }
            return(result);
        }