public void Approve(PurchasingViewModel purchasing, int userID)
        {
            using (var trans = _unitOfWork.BeginTransaction())
            {
                try
                {
                    DateTime serverTime = DateTime.Now;

                    Reference transactionReferenceTable = _referenceRepository.GetMany(c => c.Code == DbConstant.REF_TRANSTBL_PURCHASING).FirstOrDefault();

                    List <PurchasingDetail> listPurchasingDetail = _purchasingDetailRepository
                                                                   .GetMany(c => c.PurchasingId == purchasing.Id).ToList();
                    foreach (var purchasingDetail in listPurchasingDetail)
                    {
                        Sparepart sparepartDB = _sparepartRepository.GetById(purchasingDetail.SparepartId);

                        for (int i = 1; i <= purchasingDetail.Qty; i++)
                        {
                            if (!string.IsNullOrEmpty(purchasingDetail.SerialNumber))
                            {
                                SpecialSparepartDetail wd = new SpecialSparepartDetail();
                                wd.PurchasingDetail = purchasingDetail;
                                wd.SerialNumber     = purchasingDetail.SerialNumber;
                                wd.CreateUserId     = userID;
                                wd.CreateDate       = serverTime;
                                wd.ModifyUserId     = userID;
                                wd.ModifyDate       = serverTime;
                                wd.SparepartId      = sparepartDB.Id;
                                wd.Status           = (int)DbConstant.WheelDetailStatus.Ready;

                                _specialSparepartDetailRepository.AttachNavigation(purchasingDetail.CreateUser);
                                _specialSparepartDetailRepository.AttachNavigation(purchasingDetail.ModifyUser);
                                _specialSparepartDetailRepository.AttachNavigation(purchasingDetail);
                                _specialSparepartDetailRepository.AttachNavigation(purchasingDetail.Sparepart);;
                                _specialSparepartDetailRepository.Add(wd);
                            }
                        }

                        purchasingDetail.Status       = (int)DbConstant.PurchasingStatus.Active;
                        purchasingDetail.QtyRemaining = purchasingDetail.Qty;
                        _purchasingDetailRepository.AttachNavigation(purchasingDetail.CreateUser);
                        _purchasingDetailRepository.AttachNavigation(purchasingDetail.ModifyUser);
                        _purchasingDetailRepository.AttachNavigation(purchasingDetail.Purchasing);
                        _purchasingDetailRepository.AttachNavigation(purchasingDetail.Sparepart);
                        _purchasingDetailRepository.Update(purchasingDetail);

                        Sparepart sparepart = _sparepartRepository.GetById(purchasingDetail.SparepartId);
                        sparepart.StockQty += purchasingDetail.Qty;

                        _sparepartRepository.AttachNavigation(sparepart.CreateUser);
                        _sparepartRepository.AttachNavigation(sparepart.ModifyUser);
                        _sparepartRepository.AttachNavigation(sparepart.CategoryReference);
                        _sparepartRepository.AttachNavigation(sparepart.UnitReference);
                        _sparepartRepository.Update(sparepart);

                        SparepartStockCard stockCard = new SparepartStockCard();
                        stockCard.CreateUserId     = userID;
                        stockCard.PurchaseDate     = serverTime;
                        stockCard.PrimaryKeyValue  = purchasing.Id;
                        stockCard.ReferenceTableId = transactionReferenceTable.Id;
                        stockCard.SparepartId      = sparepart.Id;
                        stockCard.Description      = "Purchasing";
                        stockCard.QtyIn            = purchasingDetail.Qty;
                        stockCard.QtyInPrice       = Convert.ToDouble(purchasingDetail.Price * purchasingDetail.Qty);
                        SparepartStockCard lastStockCard  = _sparepartStokCardRepository.RetrieveLastCard(sparepart.Id);
                        double             lastStock      = 0;
                        double             lastStockPrice = 0;
                        if (lastStockCard != null)
                        {
                            lastStock      = lastStockCard.QtyLast;
                            lastStockPrice = lastStockCard.QtyLastPrice;
                        }
                        stockCard.QtyFirst      = lastStock;
                        stockCard.QtyFirstPrice = lastStockPrice;
                        stockCard.QtyLast       = lastStock + stockCard.QtyIn;
                        stockCard.QtyLastPrice  = lastStockPrice + stockCard.QtyInPrice;
                        _sparepartStokCardRepository.AttachNavigation(stockCard.CreateUser);
                        _sparepartStokCardRepository.AttachNavigation(stockCard.Sparepart);
                        _sparepartStokCardRepository.AttachNavigation(stockCard.ReferenceTable);
                        stockCard = _sparepartStokCardRepository.Add(stockCard);
                        _unitOfWork.SaveChanges();


                        SparepartStockCardDetail stockCardDtail = new SparepartStockCardDetail();
                        stockCardDtail.ParentStockCard = stockCard;
                        stockCardDtail.PricePerItem    = Convert.ToDouble(purchasingDetail.Price);
                        stockCardDtail.QtyIn           = purchasingDetail.Qty;
                        stockCardDtail.QtyInPrice      = Convert.ToDouble(purchasingDetail.Price * purchasingDetail.Qty);
                        SparepartStockCardDetail lastStockCardDetail = _sparepartStokCardDetailRepository.RetrieveLastCardDetailByPurchasingId(sparepart.Id, purchasing.Id);
                        double lastStockDetail      = 0;
                        double lastStockDetailPrice = 0;
                        if (lastStockCardDetail != null)
                        {
                            lastStockDetail      = lastStockCardDetail.QtyLast;
                            lastStockDetailPrice = lastStockCardDetail.QtyLastPrice;
                        }
                        stockCardDtail.QtyFirst      = lastStockDetail;
                        stockCardDtail.QtyFirstPrice = lastStockDetailPrice;
                        stockCardDtail.QtyLast       = lastStockDetail + stockCardDtail.QtyIn;
                        stockCardDtail.QtyLastPrice  = lastStockDetailPrice + stockCardDtail.QtyInPrice;
                        stockCardDtail.PurchasingId  = purchasing.Id;
                        _sparepartStokCardDetailRepository.AttachNavigation(stockCardDtail.ParentStockCard);
                        _sparepartStokCardDetailRepository.Add(stockCardDtail);
                        _unitOfWork.SaveChanges();
                    }

                    Reference refSelected = _referenceRepository.GetById(purchasing.PaymentMethodId);
                    purchasing.Status = (int)DbConstant.PurchasingStatus.Active;
                    if (refSelected != null &&
                        (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_EKONOMI ||
                         refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_BCA1 ||
                         refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_BCA2 ||
                         refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_KAS)
                        )
                    {
                        purchasing.TotalHasPaid = purchasing.TotalPrice;
                    }

                    if (purchasing.TotalHasPaid != purchasing.TotalPrice)
                    {
                        purchasing.PaymentStatus = (int)DbConstant.PaymentStatus.NotSettled;
                    }
                    else
                    {
                        purchasing.PaymentStatus = (int)DbConstant.PaymentStatus.Settled;
                    }
                    Purchasing entity = _purchasingRepository.GetById(purchasing.Id);
                    //Map(purchasing, entity);
                    entity.PaymentStatus   = purchasing.PaymentStatus;
                    entity.Status          = purchasing.Status;
                    entity.TotalHasPaid    = purchasing.TotalHasPaid;
                    entity.TotalPrice      = purchasing.TotalPrice;
                    entity.PaymentMethodId = purchasing.PaymentMethodId;
                    _purchasingRepository.AttachNavigation(entity.CreateUser);
                    _purchasingRepository.AttachNavigation(entity.ModifyUser);
                    _purchasingRepository.AttachNavigation(entity.PaymentMethod);
                    _purchasingRepository.AttachNavigation(entity.Supplier);
                    _purchasingRepository.Update(entity);
                    _unitOfWork.SaveChanges();

                    Transaction transaction = new Transaction();
                    transaction.TransactionDate  = purchasing.Date;
                    transaction.TotalPayment     = Convert.ToDouble(purchasing.TotalHasPaid);
                    transaction.TotalTransaction = Convert.ToDouble(purchasing.TotalPrice);
                    transaction.ReferenceTableId = transactionReferenceTable.Id;
                    transaction.PrimaryKeyValue  = purchasing.Id;
                    transaction.CreateDate       = serverTime;
                    transaction.CreateUserId     = userID;
                    transaction.ModifyUserId     = userID;
                    transaction.ModifyDate       = serverTime;
                    transaction.Status           = (int)DbConstant.DefaultDataStatus.Active;
                    transaction.Description      = "Pembelian sparepart";
                    transaction.PaymentMethodId  = purchasing.PaymentMethodId;

                    _transactionRepository.AttachNavigation(transaction.CreateUser);
                    _transactionRepository.AttachNavigation(transaction.ModifyUser);
                    _transactionRepository.AttachNavigation(transaction.PaymentMethod);
                    _transactionRepository.AttachNavigation(transaction.ReferenceTable);
                    Transaction transactionInserted = _transactionRepository.Add(transaction);
                    _unitOfWork.SaveChanges();

                    switch (refSelected.Code)
                    {
                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_EKONOMI:
                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_BCA1:
                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_BCA2:
                    {
                        // Bank Kredit --> Karena berkurang
                        TransactionDetail detailBank = new TransactionDetail();
                        detailBank.Credit = purchasing.TotalHasPaid;
                        if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_EKONOMI)
                        {
                            detailBank.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.02.01").FirstOrDefault().Id;
                        }
                        else if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_BCA1)
                        {
                            detailBank.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.02.02").FirstOrDefault().Id;
                        }
                        else if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_BANK_BCA2)
                        {
                            detailBank.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.02.03").FirstOrDefault().Id;
                        }
                        detailBank.ParentId = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailBank.Journal);
                        _transactionDetailRepository.AttachNavigation(detailBank.Parent);
                        _transactionDetailRepository.Add(detailBank);
                        break;
                    }

                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_KAS:
                        // Kas Kredit --> Karena berkurang
                        TransactionDetail detailKas = new TransactionDetail();
                        detailKas.Credit    = purchasing.TotalHasPaid;
                        detailKas.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.01.01").FirstOrDefault().Id;
                        detailKas.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailKas.Journal);
                        _transactionDetailRepository.AttachNavigation(detailKas.Parent);
                        _transactionDetailRepository.Add(detailKas);
                        break;

                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_KAS:
                        // Kas Kredit --> Karena berkurang
                        TransactionDetail detailKasKarenaUangMuka = new TransactionDetail();
                        detailKasKarenaUangMuka.Credit    = purchasing.TotalHasPaid;
                        detailKasKarenaUangMuka.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.01.01").FirstOrDefault().Id;
                        detailKasKarenaUangMuka.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailKasKarenaUangMuka.Journal);
                        _transactionDetailRepository.AttachNavigation(detailKasKarenaUangMuka.Parent);
                        _transactionDetailRepository.Add(detailKasKarenaUangMuka);

                        // Uang Muka Debit --> Karena bertambah
                        TransactionDetail detailUangMukaBertambahKarenaKas = new TransactionDetail();
                        detailUangMukaBertambahKarenaKas.Debit     = purchasing.TotalHasPaid;
                        detailUangMukaBertambahKarenaKas.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.05.01.01").FirstOrDefault().Id;
                        detailUangMukaBertambahKarenaKas.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailUangMukaBertambahKarenaKas.Journal);
                        _transactionDetailRepository.AttachNavigation(detailUangMukaBertambahKarenaKas.Parent);
                        _transactionDetailRepository.Add(detailUangMukaBertambahKarenaKas);

                        // Uang Muka Kredit --> Karena berkurang
                        TransactionDetail detailUangMukaBerkurangKarenaKas = new TransactionDetail();
                        detailUangMukaBerkurangKarenaKas.Credit    = purchasing.TotalHasPaid;
                        detailUangMukaBerkurangKarenaKas.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.05.01.01").FirstOrDefault().Id;
                        detailUangMukaBerkurangKarenaKas.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailUangMukaBerkurangKarenaKas.Journal);
                        _transactionDetailRepository.AttachNavigation(detailUangMukaBerkurangKarenaKas.Parent);
                        _transactionDetailRepository.Add(detailUangMukaBerkurangKarenaKas);
                        break;

                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_EKONOMI:
                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_BCA1:
                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_BCA2:
                    {
                        // Bank Kredit --> Karena berkurang
                        TransactionDetail detailBankKarenaUangMuka = new TransactionDetail();
                        detailBankKarenaUangMuka.Credit = purchasing.TotalHasPaid;
                        if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_EKONOMI)
                        {
                            detailBankKarenaUangMuka.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.02.01").FirstOrDefault().Id;
                        }
                        else if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_BCA1)
                        {
                            detailBankKarenaUangMuka.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.02.02").FirstOrDefault().Id;
                        }
                        else if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_BCA2)
                        {
                            detailBankKarenaUangMuka.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.02.03").FirstOrDefault().Id;
                        }
                        detailBankKarenaUangMuka.ParentId = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailBankKarenaUangMuka.Journal);
                        _transactionDetailRepository.AttachNavigation(detailBankKarenaUangMuka.Parent);
                        _transactionDetailRepository.Add(detailBankKarenaUangMuka);

                        // Uang Muka Debit --> Karena bertambah
                        TransactionDetail detailUangMukaBertambahKarenaBank = new TransactionDetail();
                        detailUangMukaBertambahKarenaBank.Debit     = purchasing.TotalHasPaid;
                        detailUangMukaBertambahKarenaBank.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.05.01.01").FirstOrDefault().Id;
                        detailUangMukaBertambahKarenaBank.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailUangMukaBertambahKarenaBank.Journal);
                        _transactionDetailRepository.AttachNavigation(detailUangMukaBertambahKarenaBank.Parent);
                        _transactionDetailRepository.Add(detailUangMukaBertambahKarenaBank);

                        // Uang Muka Kredit --> Karena berkurang
                        TransactionDetail detailUangMukaBerkurangKarenaBank = new TransactionDetail();
                        detailUangMukaBerkurangKarenaBank.Credit    = purchasing.TotalHasPaid;
                        detailUangMukaBerkurangKarenaBank.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.05.01.01").FirstOrDefault().Id;
                        detailUangMukaBerkurangKarenaBank.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(detailUangMukaBerkurangKarenaBank.Journal);
                        _transactionDetailRepository.AttachNavigation(detailUangMukaBerkurangKarenaBank.Parent);
                        _transactionDetailRepository.Add(detailUangMukaBerkurangKarenaBank);
                        break;
                    }

                    case DbConstant.REF_PURCHASE_PAYMENTMETHOD_UTANG:
                        TransactionDetail utang = new TransactionDetail();
                        utang.Credit    = purchasing.TotalPrice - purchasing.TotalHasPaid;
                        utang.JournalId = _journalMasterRepository.GetMany(j => j.Code == "2.01.01.01").FirstOrDefault().Id;
                        utang.ParentId  = transactionInserted.Id;

                        _transactionDetailRepository.AttachNavigation(utang.Journal);
                        _transactionDetailRepository.AttachNavigation(utang.Parent);
                        _transactionDetailRepository.Add(utang);
                        break;
                    }

                    if (refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_EKONOMI ||
                        refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_BCA1 ||
                        refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_BANK_BCA2 ||
                        refSelected.Code == DbConstant.REF_PURCHASE_PAYMENTMETHOD_UANGMUKA_KAS)
                    {
                        if (purchasing.TotalPrice > purchasing.TotalHasPaid)
                        {
                            // Utang Kredit --> Karena bertambah
                            TransactionDetail utang = new TransactionDetail();
                            utang.Credit    = purchasing.TotalPrice - purchasing.TotalHasPaid;
                            utang.JournalId = _journalMasterRepository.GetMany(j => j.Code == "2.01.01.01").FirstOrDefault().Id;
                            utang.ParentId  = transactionInserted.Id;

                            _transactionDetailRepository.AttachNavigation(utang.Journal);
                            _transactionDetailRepository.AttachNavigation(utang.Parent);
                            _transactionDetailRepository.Add(utang);
                        }
                    }

                    // Sparepart Debit --> Karena bertambah
                    TransactionDetail detailSparepart = new TransactionDetail();
                    detailSparepart.Debit     = purchasing.TotalPrice;
                    detailSparepart.JournalId = _journalMasterRepository.GetMany(j => j.Code == "1.01.04.01").FirstOrDefault().Id;
                    detailSparepart.ParentId  = transactionInserted.Id;

                    _transactionDetailRepository.AttachNavigation(detailSparepart.Journal);
                    _transactionDetailRepository.AttachNavigation(detailSparepart.Parent);
                    _transactionDetailRepository.Add(detailSparepart);

                    _unitOfWork.SaveChanges();

                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    throw;
                }
            }
        }
示例#2
0
        public void InsertSparepartManualTransaction(SparepartManualTransactionViewModel sparepartManualTransaction, decimal totalPrice, int userId)
        {
            using (var trans = _unitOfWork.BeginTransaction())
            {
                try
                {
                    DateTime serverTime = DateTime.Now;
                    sparepartManualTransaction.CreateDate      = serverTime;
                    sparepartManualTransaction.CreateUserId    = userId;
                    sparepartManualTransaction.ModifyDate      = serverTime;
                    sparepartManualTransaction.ModifyUserId    = userId;
                    sparepartManualTransaction.TransactionDate = serverTime;
                    sparepartManualTransaction.QtyRemaining    = sparepartManualTransaction.Qty;
                    Reference updateType       = _referenceRepository.GetById(sparepartManualTransaction.UpdateTypeId);
                    Sparepart sparepartUpdated = _sparepartRepository.GetById(sparepartManualTransaction.SparepartId);
                    if (updateType != null && sparepartUpdated != null)
                    {
                        SparepartManualTransaction entity = new SparepartManualTransaction();
                        Map(sparepartManualTransaction, entity);

                        _sparepartManualTransactionRepository.AttachNavigation(entity.CreateUser);
                        _sparepartManualTransactionRepository.AttachNavigation(entity.ModifyUser);
                        _sparepartManualTransactionRepository.AttachNavigation(entity.Sparepart);
                        _sparepartManualTransactionRepository.AttachNavigation(entity.UpdateType);
                        SparepartManualTransaction manualTransaction = _sparepartManualTransactionRepository.Add(entity);
                        _unitOfWork.SaveChanges();

                        Reference          transactionReferenceTable = _referenceRepository.GetMany(c => c.Code == DbConstant.REF_TRANSTBL_SPAREPARTMANUAL).FirstOrDefault();
                        SparepartStockCard stockCard = new SparepartStockCard();
                        stockCard.CreateUserId     = userId;
                        stockCard.PurchaseDate     = serverTime;
                        stockCard.PrimaryKeyValue  = manualTransaction.Id;
                        stockCard.ReferenceTableId = transactionReferenceTable.Id;
                        stockCard.SparepartId      = manualTransaction.SparepartId;

                        if (updateType.Code == DbConstant.REF_SPAREPART_TRANSACTION_MANUAL_TYPE_PLUS)
                        {
                            stockCard.Description = "Penambahan stok awal";

                            sparepartUpdated.StockQty += sparepartManualTransaction.Qty;
                            stockCard.QtyIn            = sparepartManualTransaction.Qty;
                            stockCard.QtyInPrice       = (sparepartManualTransaction.Qty * sparepartManualTransaction.Price).AsDouble();

                            for (int i = 1; i <= sparepartManualTransaction.Qty; i++)
                            {
                                if (!string.IsNullOrEmpty(sparepartManualTransaction.SerialNumber))
                                {
                                    SpecialSparepartDetail wDetail = new SpecialSparepartDetail();
                                    wDetail.Sparepart = manualTransaction.Sparepart;
                                    wDetail.SparepartManualTransaction = manualTransaction;
                                    wDetail.SerialNumber = sparepartManualTransaction.SerialNumber;
                                    wDetail.CreateDate   = serverTime;
                                    wDetail.CreateUserId = userId;
                                    wDetail.ModifyUserId = userId;
                                    wDetail.ModifyDate   = serverTime;
                                    wDetail.Status       = (int)DbConstant.WheelDetailStatus.Ready;

                                    _specialSparepartDetailRepository.AttachNavigation(manualTransaction.CreateUser);
                                    _specialSparepartDetailRepository.AttachNavigation(manualTransaction.ModifyUser);
                                    _specialSparepartDetailRepository.AttachNavigation(manualTransaction.Sparepart);
                                    _specialSparepartDetailRepository.AttachNavigation(manualTransaction);
                                    _specialSparepartDetailRepository.Add(wDetail);

                                    _unitOfWork.SaveChanges();
                                }
                            }
                        }
                        else if (updateType.Code == DbConstant.REF_SPAREPART_TRANSACTION_MANUAL_TYPE_MINUS)
                        {
                            stockCard.Description      = "Pengurangan stok awal";
                            sparepartUpdated.StockQty -= sparepartManualTransaction.Qty;
                            stockCard.QtyOut           = sparepartManualTransaction.Qty;
                            stockCard.QtyOutPrice      = (sparepartManualTransaction.Qty * sparepartManualTransaction.Price).AsDouble();
                        }

                        SparepartStockCard lastStockCard  = _sparepartStockCardRepository.RetrieveLastCard(manualTransaction.SparepartId);
                        double             lastStock      = 0;
                        double             lastStockPrice = 0;
                        if (lastStockCard != null)
                        {
                            lastStock      = lastStockCard.QtyLast;
                            lastStockPrice = lastStockCard.QtyLastPrice;
                        }
                        stockCard.QtyFirst      = lastStock;
                        stockCard.QtyFirstPrice = lastStockPrice;
                        stockCard.QtyLast       = lastStock + (stockCard.QtyIn - stockCard.QtyOut);
                        stockCard.QtyLastPrice  = lastStockPrice + (stockCard.QtyInPrice - stockCard.QtyOutPrice);

                        _sparepartStockCardRepository.AttachNavigation(stockCard.CreateUser);
                        _sparepartStockCardRepository.AttachNavigation(stockCard.Sparepart);
                        _sparepartStockCardRepository.AttachNavigation(stockCard.ReferenceTable);
                        stockCard = _sparepartStockCardRepository.Add(stockCard);
                        _unitOfWork.SaveChanges();

                        SparepartStockCardDetail stockCardDetail = new SparepartStockCardDetail();
                        stockCardDetail.ParentStockCard = stockCard;
                        stockCardDetail.PricePerItem    = Convert.ToDouble(manualTransaction.Price);
                        stockCardDetail.QtyIn           = manualTransaction.Qty;
                        stockCardDetail.QtyInPrice      = Convert.ToDouble(manualTransaction.Price * manualTransaction.Qty);
                        stockCardDetail.QtyOut          = 0;
                        stockCardDetail.QtyOutPrice     = 0;
                        SparepartStockCardDetail lastStockCardDetail = _sparepartStockCardDetailRepository.RetrieveLastCardDetailByPurchasingId(manualTransaction.SparepartId, manualTransaction.Id);
                        double lastStockDetail      = 0;
                        double lastStockDetailPrice = 0;
                        if (lastStockCardDetail != null)
                        {
                            lastStockDetail      = lastStockCardDetail.QtyLast;
                            lastStockDetailPrice = lastStockCardDetail.QtyLastPrice;
                        }
                        stockCardDetail.QtyFirst      = lastStockDetail;
                        stockCardDetail.QtyFirstPrice = lastStockDetailPrice;
                        stockCardDetail.QtyLast       = manualTransaction.Qty;
                        stockCardDetail.QtyLastPrice  = Convert.ToDouble(manualTransaction.Price * manualTransaction.Qty);
                        stockCardDetail.SparepartManualTransactionId = manualTransaction.Id;
                        _sparepartStockCardDetailRepository.AttachNavigation(stockCardDetail.ParentStockCard);
                        _sparepartStockCardDetailRepository.Add(stockCardDetail);

                        _sparepartRepository.AttachNavigation(sparepartUpdated.CreateUser);
                        _sparepartRepository.AttachNavigation(sparepartUpdated.ModifyUser);
                        _sparepartRepository.AttachNavigation(sparepartUpdated.CategoryReference);
                        _sparepartRepository.AttachNavigation(sparepartUpdated.UnitReference);
                        _sparepartRepository.Update(sparepartUpdated);
                        _unitOfWork.SaveChanges();
                        trans.Commit();
                    }
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    throw;
                }
            }
        }