public void InsertFirstBalance(BalanceJournalViewModel parent,
            List<BalanceJournalDetailViewModel> details, int userId)
        {
            BalanceJournal entity = new BalanceJournal();
            Map(parent, entity);
            entity.IsFirst = true;
            entity.Status = (int)DbConstant.DefaultDataStatus.Active;
            entity.CreateUserId = entity.ModifyUserId = userId;
            entity.CreateDate = entity.ModifyDate = DateTime.Now;
            _balanceJournalRepository.AttachNavigation<User>(entity.CreateUser);
            _balanceJournalRepository.AttachNavigation<User>(entity.ModifyUser);
            entity = _balanceJournalRepository.Add(entity);
            _unitOfWork.SaveChanges();

            foreach (var balanceDetail in details)
            {
                BalanceJournalDetail newDetailEntity = new BalanceJournalDetail();
                Map(balanceDetail, newDetailEntity);
                newDetailEntity.ParentId = entity.Id;
                _balanceJournalDetailRepository.AttachNavigation<BalanceJournal>(newDetailEntity.Parent);
                _balanceJournalDetailRepository.AttachNavigation<JournalMaster>(newDetailEntity.Journal);
                _balanceJournalDetailRepository.Add(newDetailEntity);
            }
            _unitOfWork.SaveChanges();
        }
        public void RecalculateBalanceJournal(int month, int year, int userId)
        {
            // harus pake using, dibiarin aja gak usah try catch commit rollback, kata nya sih udah otomatis
            using (var trans = _unitOfWork.BeginTransaction())
            {
                try
                {
                    BalanceJournalViewModel prevCalculated = RetrieveBalanceJournalHeader(month, year);
                    if (prevCalculated != null)
                    {
                        DeleteBalanceJournal(prevCalculated.Id, userId);
                    }

                    DateTime firstDay = new DateTime(year, month, 1);
                    DateTime lastDay = firstDay.AddMonths(1).AddSeconds(-1);
                    DateTime prevMonth = firstDay.AddDays(-1);

                    List<JournalMaster> listAllJournal = _journalMasterRepository.GetAll().ToList();
                    List<JournalMasterViewModel> mappedListAllJournal = new List<JournalMasterViewModel>();
                    Map(listAllJournal, mappedListAllJournal);

                    Reference catJournalService = _referenceRepository.GetMany(r => r.Code == DbConstant.REF_CAT_JOURNAL_SERVICE).FirstOrDefault();
                    Reference catJournalCost = _referenceRepository.GetMany(r => r.Code == DbConstant.REF_CAT_JOURNAL_COST).FirstOrDefault();
                    Reference catJournalIncome = _referenceRepository.GetMany(r => r.Code == DbConstant.REF_CAT_JOURNAL_INCOME).FirstOrDefault();

                    List<string> catJournalServiceCodeList = _referenceRepository.GetMany(r => r.ParentId == catJournalService.Id).Select(r => r.Value).ToList();
                    List<string> catJournalCostCodeList = _referenceRepository.GetMany(r => r.ParentId == catJournalCost.Id).Select(r => r.Value).ToList();
                    List<string> catJournalIncomeCodeList = _referenceRepository.GetMany(r => r.ParentId == catJournalIncome.Id).Select(r => r.Value).ToList();

                    // calculate neraca
                    // ------------------------------------------------------------------------------
                    // List semua akun jurnal dari tabel transaksi
                    List<TransactionDetail> listTransaction = _transactionDetailRepository.GetMany(t =>
                        t.Parent.TransactionDate >= firstDay && t.Parent.TransactionDate <= lastDay &&
                        t.Parent.Status == (int)DbConstant.DefaultDataStatus.Active).ToList();

                    var journalTransactionList = listTransaction.DistinctBy(t => t.JournalId).Select(t => t.JournalId);
                    List<BalanceJournalDetailViewModel> tempListBalanceDetailViewModel = new List<BalanceJournalDetailViewModel>();
                    foreach (var item in journalTransactionList)
                    {
                        BalanceJournalDetailViewModel detailViewModel = new BalanceJournalDetailViewModel();
                        detailViewModel.JournalId = item;
                        tempListBalanceDetailViewModel.Add(detailViewModel);
                    }
                    // end init semua akun

                    // 1. Ambil Saldo Awal dari Saldo Akhir Bulan Sebelumnya
                    BalanceJournal lastJournal = _balanceJournalRepository.GetMany(bj =>
                        bj.Month == prevMonth.Month && bj.Year == prevMonth.Year &&
                        bj.Status == (int)DbConstant.DefaultDataStatus.Active).FirstOrDefault();

                    if (lastJournal != null)
                    {
                        // check apakah semua jurnal di last journal ada di temp list
                        List<BalanceJournalDetail> lastJournalDetail = _balanceJournalDetailRepository.GetMany(bjd => bjd.ParentId == lastJournal.Id).ToList();
                        foreach (var item in lastJournalDetail)
                        {
                            if (tempListBalanceDetailViewModel.Where(temp => temp.JournalId == item.JournalId).Count() == 0)
                            {
                                JournalMasterViewModel mappedJournal = new JournalMasterViewModel();
                                tempListBalanceDetailViewModel.Add(new BalanceJournalDetailViewModel
                                {
                                    Journal = Map(item.Journal, mappedJournal),
                                    JournalId = item.JournalId
                                });
                            }
                        }

                        // update temp list untuk saldo awal
                        foreach (var item in tempListBalanceDetailViewModel)
                        {
                            BalanceJournalDetail entityDetail = lastJournalDetail.Where(i => i.JournalId == item.JournalId).FirstOrDefault();
                            if (entityDetail == null) continue;

                            item.FirstDebit = entityDetail.LastDebit;
                            item.FirstCredit = entityDetail.LastCredit;
                        }
                    }

                    // 2. Ambil mutasi Debet Kredit dari transaksi bulan berjalan
                    foreach (var item in listTransaction)
                    {
                        if (tempListBalanceDetailViewModel.Where(t => t.JournalId == item.JournalId).Count() == 0)
                        {
                            tempListBalanceDetailViewModel.Add(new BalanceJournalDetailViewModel
                            {
                                JournalId = item.JournalId
                            });
                        }

                        BalanceJournalDetailViewModel currentViewModel = tempListBalanceDetailViewModel.Where(t => t.JournalId == item.JournalId).FirstOrDefault();
                        int currentIndex = tempListBalanceDetailViewModel.IndexOf(currentViewModel);
                        currentViewModel.MutationDebit = (currentViewModel.MutationDebit ?? 0);
                        currentViewModel.MutationCredit = (currentViewModel.MutationCredit ?? 0);
                        currentViewModel.ReconciliationDebit = (currentViewModel.ReconciliationDebit ?? 0);
                        currentViewModel.ReconciliationCredit = (currentViewModel.ReconciliationCredit ?? 0);

                        if (!item.Parent.IsReconciliation)
                        {
                            currentViewModel.MutationCredit += (item.Credit ?? 0);
                            currentViewModel.MutationDebit += (item.Debit ?? 0);
                        }
                        else
                        {
                            currentViewModel.ReconciliationDebit += (item.Debit ?? 0);
                            currentViewModel.ReconciliationCredit += (item.Credit ?? 0);
                        }

                        tempListBalanceDetailViewModel[currentIndex] = currentViewModel;
                    }

                    // 4. Hitung Saldo Akhir
                    decimal? incomeAmount = 0;
                    decimal? serviceAmount = 0;
                    decimal? costAmount = 0;
                    List<string> cachedCode = new List<string>();
                    foreach (var item in tempListBalanceDetailViewModel)
                    {
                        // update saldo awal (saldo akhir + mutasi)
                        item.BalanceAfterMutationDebit = (item.MutationDebit ?? 0);
                        item.BalanceAfterMutationCredit = (item.MutationCredit ?? 0);

                        decimal totalAfterReconciliation =
                            ((item.BalanceAfterMutationDebit ?? 0) + (item.ReconciliationDebit ?? 0)) -
                            ((item.BalanceAfterMutationCredit ?? 0) + (item.ReconciliationCredit ?? 0));
                        if (totalAfterReconciliation > 0)
                        {
                            item.BalanceAfterReconciliationDebit = totalAfterReconciliation;
                            item.BalanceAfterReconciliationCredit = 0;
                        }
                        else
                        {
                            item.BalanceAfterReconciliationDebit = 0;
                            item.BalanceAfterReconciliationCredit = Math.Abs(totalAfterReconciliation);
                        }

                        item.LastDebit = (item.FirstDebit ?? 0) + item.BalanceAfterReconciliationDebit;
                        item.LastCredit = (item.FirstCredit ?? 0) + item.BalanceAfterReconciliationCredit;
                    }

                    // 5. Insert Keb Balance Header & Balance Detail
                    BalanceJournal newBalanceHeader = new BalanceJournal();
                    newBalanceHeader.Month = month;
                    newBalanceHeader.Year = year;
                    newBalanceHeader.Status = (int)DbConstant.DefaultDataStatus.Active;
                    newBalanceHeader.CreateDate = newBalanceHeader.ModifyDate = DateTime.Now;
                    newBalanceHeader.CreateUserId = newBalanceHeader.ModifyUserId = userId;
                    _balanceJournalRepository.AttachNavigation<User>(newBalanceHeader.CreateUser);
                    _balanceJournalRepository.AttachNavigation<User>(newBalanceHeader.ModifyUser);
                    newBalanceHeader = _balanceJournalRepository.Add(newBalanceHeader);
                    _unitOfWork.SaveChanges();

                    foreach (var item in tempListBalanceDetailViewModel)
                    {
                        item.Journal = null;
                        BalanceJournalDetail newBalanceDetail = new BalanceJournalDetail();
                        Map(item, newBalanceDetail);
                        newBalanceDetail.ParentId = newBalanceHeader.Id;
                        _balanceJournalDetailRepository.AttachNavigation<BalanceJournal>(newBalanceDetail.Parent);
                        _balanceJournalDetailRepository.AttachNavigation<JournalMaster>(newBalanceDetail.Journal);
                        _balanceJournalDetailRepository.Add(newBalanceDetail);
                    }

                    _unitOfWork.SaveChanges();

                    List<BalanceJournalDetailViewModel> mappedResult = RetrieveBalanceJournalDetailsByHeaderId(newBalanceHeader.Id);

                    foreach (var item in tempListBalanceDetailViewModel)
                    {
                        foreach (var journalIncomeCode in catJournalIncomeCodeList)
                        {
                            List<int> cachedItems = new List<int>();
                            foreach (var itemBalance in mappedResult.Where(m => !m.IsChecked))
                            {
                                if (IsCurrentJournalValid(itemBalance.Journal, journalIncomeCode))
                                {
                                    decimal currentAmount = (itemBalance.LastCredit ?? 0) - (itemBalance.LastDebit ?? 0);
                                    incomeAmount += currentAmount;

                                    cachedItems.Add(itemBalance.Id);
                                }
                            }

                            foreach (var iCache in cachedItems)
                            {
                                BalanceJournalDetailViewModel current = mappedResult.Where(m => m.Id == iCache).FirstOrDefault();
                                int iCacheIndex = mappedResult.IndexOf(current);
                                current.IsChecked = true;
                                mappedResult[iCacheIndex] = current;
                            }
                        }

                        foreach (var journalServiceCode in catJournalServiceCodeList)
                        {
                            List<int> cachedItems = new List<int>();
                            foreach (var itemBalance in mappedResult.Where(m => !m.IsChecked))
                            {
                                if (IsCurrentJournalValid(itemBalance.Journal, journalServiceCode))
                                {
                                    decimal currentAmount = (itemBalance.LastCredit ?? 0) - (itemBalance.LastDebit ?? 0);
                                    serviceAmount += currentAmount;

                                    cachedItems.Add(itemBalance.Id);
                                }
                            }

                            foreach (var iCache in cachedItems)
                            {
                                BalanceJournalDetailViewModel current = mappedResult.Where(m => m.Id == iCache).FirstOrDefault();
                                int iCacheIndex = mappedResult.IndexOf(current);
                                current.IsChecked = true;
                                mappedResult[iCacheIndex] = current;
                            }
                        }

                        foreach (var journalCostCode in catJournalCostCodeList)
                        {
                            List<int> cachedItems = new List<int>();
                            foreach (var itemBalance in mappedResult.Where(m => !m.IsChecked))
                            {
                                if (IsCurrentJournalValid(itemBalance.Journal, journalCostCode))
                                {
                                    decimal currentAmount = (itemBalance.LastCredit ?? 0) - (itemBalance.LastDebit ?? 0);
                                    costAmount += currentAmount;

                                    cachedItems.Add(itemBalance.Id);
                                }
                            }

                            foreach (var iCache in cachedItems)
                            {
                                BalanceJournalDetailViewModel current = mappedResult.Where(m => m.Id == iCache).FirstOrDefault();
                                int iCacheIndex = mappedResult.IndexOf(current);
                                current.IsChecked = true;
                                mappedResult[iCacheIndex] = current;
                            }
                        }
                    }

                    //profitloss
                    decimal? profitLossAmount = incomeAmount + serviceAmount + costAmount;
                    BalanceJournalDetail profitDetail = new BalanceJournalDetail();
                    profitDetail.ParentId = newBalanceHeader.Id;
                    JournalMasterViewModel profitLossCurrentMonthJournal = mappedListAllJournal.Where(j => j.Code == "2.03.05").FirstOrDefault();
                    profitDetail.JournalId = profitLossCurrentMonthJournal.Id;
                    if (profitLossAmount > 0)
                    {
                        profitDetail.LastDebit = profitLossAmount;
                    }
                    else
                    {
                        profitDetail.LastCredit = Math.Abs(profitLossAmount.Value);
                    }
                    _balanceJournalDetailRepository.AttachNavigation<BalanceJournal>(profitDetail.Parent);
                    _balanceJournalDetailRepository.AttachNavigation<JournalMaster>(profitDetail.Journal);
                    _balanceJournalDetailRepository.Add(profitDetail);
                    _unitOfWork.SaveChanges();

                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    throw ex;
                }
            }
        }
        public void UpdateFirstBalance(BalanceJournalViewModel parent,
            List<BalanceJournalDetailViewModel> details, int userId)
        {
            BalanceJournal entity = _balanceJournalRepository.GetById(parent.Id);
            Map(parent, entity);
            entity.ModifyUserId = userId;
            entity.ModifyDate = DateTime.Now;
            _balanceJournalRepository.AttachNavigation<User>(entity.CreateUser);
            _balanceJournalRepository.AttachNavigation<User>(entity.ModifyUser);
            _balanceJournalRepository.Update(entity);
            _unitOfWork.SaveChanges();

            foreach (var balanceDetail in details)
            {
                if(balanceDetail.Id > 0)
                {
                    BalanceJournalDetail detailEntity = _balanceJournalDetailRepository.GetById(balanceDetail.Id);
                    Map(balanceDetail, detailEntity);
                    _balanceJournalDetailRepository.AttachNavigation<BalanceJournal>(detailEntity.Parent);
                    _balanceJournalDetailRepository.AttachNavigation<JournalMaster>(detailEntity.Journal);
                    _balanceJournalDetailRepository.Update(detailEntity);
                }
                else
                {
                    BalanceJournalDetail detailEntity = new BalanceJournalDetail();
                    Map(balanceDetail, detailEntity);
                    detailEntity.ParentId = entity.Id;
                    _balanceJournalDetailRepository.AttachNavigation<BalanceJournal>(detailEntity.Parent);
                    _balanceJournalDetailRepository.AttachNavigation<JournalMaster>(detailEntity.Journal);
                    _balanceJournalDetailRepository.Add(detailEntity);
                }
            }
            _unitOfWork.SaveChanges();
        }
        public static void DataImporter()
        {
            BrawijayaWorkshopDbContext contextTemp = new BrawijayaWorkshopDbContext(
                new MySqlConnection(ConfigurationManager.ConnectionStrings["TempConn"].ConnectionString), true);

            BrawijayaWorkshopDbContext contextDest = new BrawijayaWorkshopDbContext(
                new MySqlConnection(ConfigurationManager.ConnectionStrings["DestConn"].ConnectionString), true);
            contextDest.Database.CreateIfNotExists();

            //get all data from temp db
            List<ApplicationModul> ApplicationModulList = contextTemp.ApplicationModuls.ToList();
            List<Role> RoleList = contextTemp.Roles.ToList();
            List<Setting> SettingList = contextTemp.Settings.ToList();
            List<Reference> ReferenceList = contextTemp.References.ToList();
            List<User> UserList = contextTemp.Users.ToList();
            List<JournalMaster> JournalMasterList = contextTemp.JournalMasters.ToList();
            List<Brand> BrandList = contextTemp.Brands.ToList();
            List<BrawijayaWorkshop.Database.Entities.Type> TypeList = contextTemp.Types.ToList();
            List<City> CityList = contextTemp.Cities.ToList();

            List<RoleAccess> RoleAccessList = contextTemp.RoleAccesses.ToList();
            List<UserRole> UserRoleList = contextTemp.UserRoles.ToList();

            List<Customer> CustomerList = contextTemp.Customers.ToList();
            List<VehicleGroup> VehicleGroupList = contextTemp.VehicleGroups.ToList();
            List<Vehicle> VehicleList = contextTemp.Vehicles.ToList();
            List<VehicleDetail> VehicleDetailList = contextTemp.VehicleDetails.ToList();

            List<Mechanic> MechanicList = contextTemp.Mechanics.ToList();

            List<Supplier> SupplierList = contextTemp.Suppliers.ToList();
            List<Sparepart> SparepartList = contextTemp.Spareparts.ToList();
            List<SpecialSparepart> SpecialSparepartList = contextTemp.Wheels.ToList();

            List<SparepartManualTransaction> SparepartManualTransactionList = contextTemp.SparepartManualTransactions.ToList();
            List<Purchasing> PurchasingList = contextTemp.Purchasings.ToList();
            List<PurchasingDetail> PurchasingDetailList = contextTemp.PurchasingDetails.ToList();
            List<PurchaseReturn> PurchaseReturnList = contextTemp.PurchaseReturns.ToList();
            List<PurchaseReturnDetail> PurchaseReturnDetailList = contextTemp.PurchaseReturnDetails.ToList();

            List<SparepartDetail> SparepartDetailList = contextTemp.SparepartDetails.ToList();
            List<SpecialSparepartDetail> SpecialSparepartDetailList = contextTemp.WheelDetails.ToList();
            List<VehicleWheel> VehicleWheelList = contextTemp.VehicleWheels.ToList();

            List<UsedGood> UsedGoodList = contextTemp.UsedGoods.ToList();
            List<UsedGoodTransaction> UsedGoodTransactionList = contextTemp.UsedGoodsTransactions.ToList();

            List<GuestBook> GuestBookList = contextTemp.GuestBooks.ToList();

            List<SPK> SPKList = contextTemp.SPKs.ToList();
            List<SPKDetailSparepart> SPKDetailSparepartList = contextTemp.SPKDetailSpareparts.ToList();
            List<SPKDetailSparepartDetail> SPKDetailSparepartDetailList = contextTemp.SPKDetailSparepartDetails.ToList();
            List<SPKSchedule> SPKScheduleList = contextTemp.SPKSchedules.ToList();
            List<WheelExchangeHistory> WheelExchangeHistoryList = contextTemp.WheelExchangeHistories.ToList();

            List<Invoice> InvoiceList = contextTemp.Invoices.ToList();
            List<InvoiceDetail> InvoiceDetailList = contextTemp.InvoiceDetails.ToList();
            List<SalesReturn> SalesReturnList = contextTemp.SalesReturns.ToList();
            List<SalesReturnDetail> SalesReturnDetailList = contextTemp.SalesReturnDetails.ToList();

            List<Transaction> TransactionList = contextTemp.Transactions.ToList();
            List<TransactionDetail> TransactionDetailList = contextTemp.TransactionDetails.ToList();

            List<BalanceJournal> BalanceJournalList = contextTemp.BalanceJournals.ToList();
            List<BalanceJournalDetail> BalanceJournalDetailList = contextTemp.BalanceJournalDetails.ToList();

            Dictionary<int, int> dictAppModul = new Dictionary<int, int>();
            Dictionary<int, int> dictRole = new Dictionary<int, int>();
            Dictionary<int, int> dictUser = new Dictionary<int, int>();
            Dictionary<int, int> dictCity = new Dictionary<int, int>();
            Dictionary<int, int> dictReference = new Dictionary<int, int>();
            Dictionary<int, int> dictJournalMaster = new Dictionary<int, int>();
            Dictionary<int, int> dictBrand = new Dictionary<int, int>();
            Dictionary<int, int> dictType = new Dictionary<int, int>();
            Dictionary<int, int> dictCustomer = new Dictionary<int, int>();
            Dictionary<int, int> dictVehicleGroup = new Dictionary<int, int>();
            Dictionary<int, int> dictVehicle = new Dictionary<int, int>();
            Dictionary<int, int> dictMechanic = new Dictionary<int, int>();
            Dictionary<int, int> dictSupplier = new Dictionary<int, int>();
            Dictionary<int, int> dictSparepart = new Dictionary<int, int>();
            Dictionary<int, int> dictSpecialSparepart = new Dictionary<int, int>();
            Dictionary<int, int> dictSpManualTrans = new Dictionary<int, int>();
            Dictionary<int, int> dictPurchasing = new Dictionary<int, int>();
            Dictionary<int, int> dictPurchasingDetail = new Dictionary<int, int>();
            Dictionary<int, int> dictPurchaseReturn = new Dictionary<int, int>();
            Dictionary<int, int> dictSparepartDetail = new Dictionary<int, int>();
            Dictionary<int, int> dictSpecialSparepartDetail = new Dictionary<int, int>();
            Dictionary<int, int> dictUsedGood = new Dictionary<int, int>();
            Dictionary<int, int> dictSPK = new Dictionary<int, int>();
            Dictionary<int, int> dictSPKDetailSparepart = new Dictionary<int, int>();
            Dictionary<int, int> dictSPKDetailSparepartDetail = new Dictionary<int, int>();
            Dictionary<int, int> dictInvoice = new Dictionary<int, int>();
            Dictionary<int, int> dictInvoiceDetail = new Dictionary<int, int>();
            Dictionary<int, int> dictSalesReturn = new Dictionary<int, int>();
            Dictionary<int, int> dictTransaction = new Dictionary<int, int>();
            Dictionary<int, int> dictBalanceJournal = new Dictionary<int, int>();

            //applicationmodul
            Console.Write("\nImporting table ApplicationModul");

            foreach (var item in ApplicationModulList)
            {
                int itemOldId = item.Id;
                item.Id = -1;
                ApplicationModul newItem = contextDest.ApplicationModuls.Add(item);
                contextDest.SaveChanges();

                dictAppModul.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table ApplicationModul done, " + ApplicationModulList.Count + " records imported");

            //role
            Console.Write("\nImporting table Role");

            foreach (var item in RoleList)
            {
                int itemOldId = item.Id;
                item.Id = -1;
                Role newItem = contextDest.Roles.Add(item);
                contextDest.SaveChanges();

                dictRole.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Role done, " + RoleList.Count + " records imported");

            //setting
            Console.Write("\nImporting table setting");

            foreach (var item in SettingList)
            {
                contextDest.Settings.Add(item);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table setting done, " + SettingList.Count + " records imported");

            //reference
            Console.Write("\nImporting table Reference");

            foreach (var item in ReferenceList)
            {
                int itemOldId = item.Id;
                Reference newItem = new Reference
                {
                    Id = -1,
                    Code = item.Code,
                    Description = item.Description,
                    Name = item.Name,
                    ParentId = item.ParentId,
                    Value = item.Value
                };

                if (item.ParentId > 0)
                {
                    int newParentId = dictReference[item.ParentId.Value];
                    newItem.ParentId = newParentId;
                }

                Reference insertedReference = contextDest.References.Add(newItem);
                contextDest.SaveChanges();

                dictReference.Add(itemOldId, insertedReference.Id);
            }

            Console.Write("\nImporting table Reference done, " + ReferenceList.Count + " records imported");

            //user
            Console.Write("\nImporting table User");

            foreach (var item in UserList)
            {
                int itemOldId = item.Id;
                item.Id = -1;
                User newItem = contextDest.Users.Add(item);
                contextDest.SaveChanges();

                dictUser.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table User done, " + UserList.Count + " records imported");

            //journalMaster
            Console.Write("\nImporting table JournalMaster");

            foreach (var item in JournalMasterList)
            {
                int itemOldId = item.Id;
                JournalMaster newItem = new JournalMaster
                {
                    Id = -1,
                    Code = item.Code,
                    Name = item.Name,
                    ParentId = item.ParentId,
                };

                if (item.ParentId > 0)
                {
                    int newParentId = dictJournalMaster[item.ParentId.Value];
                    newItem.ParentId = newParentId;
                }

                JournalMaster insertedJournalMaster = contextDest.JournalMasters.Add(newItem);
                contextDest.SaveChanges();

                dictJournalMaster.Add(itemOldId, insertedJournalMaster.Id);
            }

            Console.Write("\nImporting table JournalMaster done, " + JournalMasterList.Count + " records imported");

            //brand
            Console.Write("\nImporting table Brand");

            foreach (var item in BrandList)
            {
                int itemOldId = item.Id;
                item.Id = -1;
                Brand newItem = contextDest.Brands.Add(item);
                contextDest.SaveChanges();

                dictBrand.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Brand done, " + BrandList.Count + " records imported");

            //type
            Console.Write("\nImporting table Type");

            foreach (var item in TypeList)
            {
                int itemOldId = item.Id;
                item.Id = -1;
                BrawijayaWorkshop.Database.Entities.Type newItem = contextDest.Types.Add(item);
                contextDest.SaveChanges();

                dictType.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Type done, " + TypeList.Count + " records imported");

            //city
            Console.Write("\nImporting table City");

            foreach (var item in CityList)
            {
                int itemOldId = item.Id;
                item.Id = -1;
                City newItem = contextDest.Cities.Add(item);
                contextDest.SaveChanges();

                dictCity.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table City done, " + CityList.Count + " records imported");

            //role access
            Console.Write("\nImporting table RoleAccess");

            foreach (var item in RoleAccessList)
            {
                RoleAccess newItem = new RoleAccess();
                int role = dictRole[item.RoleId];
                int appModul = dictAppModul[item.ApplicationModulId];

                newItem.Id = -1;
                newItem.RoleId = role;
                newItem.ApplicationModulId = appModul;
                newItem.AccessCode = item.AccessCode;
                contextDest.RoleAccesses.Add(newItem);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table RoleAccess done, " + RoleAccessList.Count + " records imported");

            //user role
            Console.Write("\nImporting table UserRole");

            foreach (var item in UserRoleList)
            {
                UserRole newItem = new UserRole();
                int role = dictRole[item.RoleId];
                int user = dictUser[item.UserId];

                newItem.Id = -1;
                newItem.RoleId = role;
                newItem.UserId = user;
                contextDest.UserRoles.Add(newItem);
            }

            Console.Write("\nImporting table UserRole done, " + UserRoleList.Count + " records imported");

            //customer
            Console.Write("\nImporting table Customer");

            foreach (var item in CustomerList)
            {
                int itemOldId = item.Id;
                Customer newItem = new Customer();
                int city = dictCity[item.CityId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.CityId = city;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.Address = item.Address;
                newItem.Code = item.Code;
                newItem.CompanyName = item.CompanyName;
                newItem.ContactPerson = item.ContactPerson;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.PhoneNumber = item.PhoneNumber;
                newItem.Status = item.Status;
                newItem = contextDest.Customers.Add(newItem);
                contextDest.SaveChanges();

                dictCustomer.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Customer done, " + CustomerList.Count + " records imported");

            //vehicle group
            Console.Write("\nImporting table VehicleGroup");

            foreach (var item in VehicleGroupList)
            {
                int itemOldId = item.Id;
                VehicleGroup newItem = new VehicleGroup();
                int customer = dictCustomer[item.CustomerId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.CustomerId = customer;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Name = item.Name;
                newItem.Status = item.Status;
                newItem = contextDest.VehicleGroups.Add(newItem);
                contextDest.SaveChanges();

                dictVehicleGroup.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table VehicleGroup done, " + VehicleGroupList.Count + " records imported");

            //vehicle
            Console.Write("\nImporting table Vehicle");

            foreach (var item in VehicleList)
            {
                int itemOldId = item.Id;
                Vehicle newItem = new Vehicle();
                int customer = dictCustomer[item.CustomerId];
                int vehicleGroup = dictVehicleGroup[item.VehicleGroupId];
                int brand = dictBrand[item.BrandId];
                int type = dictType[item.TypeId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.CustomerId = customer;
                newItem.VehicleGroupId = vehicleGroup;
                newItem.BrandId = brand;
                newItem.TypeId = type;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.ActiveLicenseNumber = item.ActiveLicenseNumber;
                newItem.Code = item.Code;
                newItem.CreateDate = item.CreateDate;
                newItem.Kilometers = item.Kilometers;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem.YearOfPurchase = item.YearOfPurchase;
                newItem = contextDest.Vehicles.Add(newItem);
                contextDest.SaveChanges();

                dictVehicle.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Vehicle done, " + VehicleList.Count + " records imported");

            //vehicle detail
            Console.Write("\nImporting table VehicleDetail");

            foreach (var item in VehicleDetailList)
            {
                VehicleDetail newItem = new VehicleDetail();
                int vehicle = dictVehicle[item.VehicleId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.VehicleId = vehicle;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ExpirationDate = item.ExpirationDate;
                newItem.LicenseNumber = item.LicenseNumber;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                contextDest.VehicleDetails.Add(newItem);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table VehicleDetail done, " + VehicleDetailList.Count + " records imported");

            //mechanic
            Console.Write("\nImporting table Mechanic");

            foreach (var item in MechanicList)
            {
                int itemOldId = item.Id;
                Mechanic newItem = new Mechanic();
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.Address = item.Address;
                newItem.BaseFee = item.BaseFee;
                newItem.Code = item.Code;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Name = item.Name;
                newItem.PhoneNumber = item.PhoneNumber;
                newItem.Status = item.Status;
                newItem = contextDest.Mechanics.Add(newItem);
                contextDest.SaveChanges();

                dictMechanic.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Mechanic done, " + MechanicList.Count + " records imported");

            //supplier
            Console.Write("\nImporting table Supplier");

            foreach (var item in SupplierList)
            {
                int itemOldId = item.Id;
                Supplier newItem = new Supplier();
                int city = dictCity[item.CityId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.CityId = city;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.Address = item.Address;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Name = item.Name;
                newItem.PhoneNumber = item.PhoneNumber;
                newItem.Status = item.Status;
                newItem = contextDest.Suppliers.Add(newItem);
                contextDest.SaveChanges();

                dictSupplier.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Supplier done, " + SupplierList.Count + " records imported");

            //sparepart
            Console.Write("\nImporting table Sparepart");

            foreach (var item in SparepartList)
            {
                int itemOldId = item.Id;
                Sparepart newItem = new Sparepart();
                int category = dictReference[item.CategoryReferenceId];
                int unit = dictReference[item.UnitReferenceId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.CategoryReferenceId = category;
                newItem.UnitReferenceId = unit;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.Code = item.Code;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Name = item.Name;
                newItem.Status = item.Status;
                newItem.StockQty = item.StockQty;
                newItem = contextDest.Spareparts.Add(newItem);
                contextDest.SaveChanges();

                dictSparepart.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Sparepart done, " + SparepartList.Count + " records imported");

            //special sparepart
            Console.Write("\nImporting table SpecialSparepart");

            foreach (var item in SpecialSparepartList)
            {
                int itemOldId = item.Id;
                SpecialSparepart newItem = new SpecialSparepart();
                int category = dictReference[item.ReferenceCategoryId];
                int sparepart = dictSparepart[item.SparepartId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.ReferenceCategoryId = category;
                newItem.SparepartId = sparepart;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.Wheels.Add(newItem);
                contextDest.SaveChanges();

                dictSpecialSparepart.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SpecialSparepart done, " + SpecialSparepartList.Count + " records imported");

            //sparepart manual trans
            Console.Write("\nImporting table SparepartManualTransaction");

            foreach (var item in SparepartManualTransactionList)
            {
                int itemOldId = item.Id;
                SparepartManualTransaction newItem = new SparepartManualTransaction();
                int sparepart = dictSparepart[item.SparepartId];
                int type = dictReference[item.UpdateTypeId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.SparepartId = sparepart;
                newItem.UpdateTypeId = type;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Price = item.Price;
                newItem.Qty = item.Qty;
                newItem.Remark = item.Remark;
                newItem.TransactionDate = item.TransactionDate;
                newItem = contextDest.SparepartManualTransactions.Add(newItem);
                contextDest.SaveChanges();

                dictSpManualTrans.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SparepartManualTransaction done, " + SparepartManualTransactionList.Count + " records imported");

            //purchasing
            Console.Write("\nImporting table Purchasing");

            foreach (var item in PurchasingList)
            {
                int itemOldId = item.Id;
                Purchasing newItem = new Purchasing();
                int paymentMethod = dictReference[item.PaymentMethodId];
                int supplier = dictSupplier[item.SupplierId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.PaymentMethodId = paymentMethod;
                newItem.SupplierId = supplier;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.Code = item.Code;
                newItem.CreateDate = item.CreateDate;
                newItem.Date = item.Date;
                newItem.ModifyDate = item.ModifyDate;
                newItem.PaymentStatus = item.PaymentStatus;
                newItem.Status = item.Status;
                newItem.TotalHasPaid = item.TotalHasPaid;
                newItem.TotalPrice = item.TotalPrice;
                newItem = contextDest.Purchasings.Add(newItem);
                contextDest.SaveChanges();

                dictPurchasing.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table InvPurchasingoice done, " + PurchasingList.Count + " records imported");

            //purchasing detail
            Console.Write("\nImporting table PurchasingDetail");

            foreach (var item in PurchasingDetailList)
            {
                int itemOldId = item.Id;
                PurchasingDetail newItem = new PurchasingDetail();
                int purchasing = dictPurchasing[item.PurchasingId];
                int sparepart = dictSparepart[item.SparepartId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.PurchasingId = purchasing;
                newItem.SparepartId = sparepart;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Price = item.Price;
                newItem.Qty = item.Qty;
                newItem.SerialNumber = item.SerialNumber;
                newItem.Status = item.Status;
                newItem = contextDest.PurchasingDetails.Add(newItem);
                contextDest.SaveChanges();

                dictPurchasingDetail.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table PurchasingDetail done, " + PurchasingDetailList.Count + " records imported");

            //purchasing return
            Console.Write("\nImporting table PurchaseReturn");

            foreach (var item in PurchaseReturnList)
            {
                int itemOldId = item.Id;
                PurchaseReturn newItem = new PurchaseReturn();
                int purchasing = dictPurchasing[item.PurchasingId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.PurchasingId = purchasing;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.Code = item.Code;
                newItem.CreateDate = item.CreateDate;
                newItem.Date = item.Date;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.PurchaseReturns.Add(newItem);
                contextDest.SaveChanges();

                dictPurchaseReturn.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table PurchaseReturn done, " + PurchaseReturnList.Count + " records imported");

            //purchasing return detail
            Console.Write("\nImporting table PurchaseReturnDetail");

            foreach (var item in PurchaseReturnDetailList)
            {
                int itemOldId = item.Id;
                PurchaseReturnDetail newItem = new PurchaseReturnDetail();
                int purchaseReturn = dictPurchaseReturn[item.PurchaseReturnId];
                int pDetail = dictPurchasingDetail[item.PurchasingDetailId];
                int spDetail = dictSparepartDetail[item.SparepartDetailId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.PurchaseReturnId = purchaseReturn;
                newItem.PurchasingDetailId = pDetail;
                newItem.SparepartDetailId = spDetail;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                contextDest.PurchaseReturnDetails.Add(newItem);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table PurchaseReturnDetail done, " + PurchaseReturnDetailList.Count + " records imported");

            //sparepart detail
            Console.Write("\nImporting table SparepartDetail");

            foreach (var item in SparepartDetailList)
            {
                int itemOldId = item.Id;
                SparepartDetail newItem = new SparepartDetail();
                int sparepart = dictSparepart[item.SparepartId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.SparepartId = sparepart;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                if (item.PurchasingDetailId.HasValue && item.PurchasingDetailId != null && item.PurchasingDetailId > 0)
                {
                    int pDetail = dictPurchasingDetail[item.PurchasingDetailId.Value];
                    newItem.PurchasingDetailId = pDetail;
                }
                if (item.SparepartManualTransactionId.HasValue && item.SparepartManualTransactionId != null && item.SparepartManualTransactionId > 0)
                {
                    int spManualTrans = dictSpManualTrans[item.SparepartManualTransactionId.Value];
                    newItem.SparepartManualTransactionId = spManualTrans;
                }

                newItem.Code = item.Code;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.SparepartDetails.Add(newItem);
                contextDest.SaveChanges();

                dictSparepartDetail.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SparepartDetail done, " + SparepartDetailList.Count + " records imported");

            //special sparepart detail
            Console.Write("\nImporting table SpecialSparepartDetail");

            foreach (var item in SpecialSparepartDetailList)
            {
                int itemOldId = item.Id;
                SpecialSparepartDetail newItem = new SpecialSparepartDetail();
                int spDetail = dictSparepartDetail[item.SparepartDetailId];
                int ssp = dictSpecialSparepart[item.SpecialSparepartId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.SparepartDetailId = spDetail;
                newItem.SpecialSparepartId = ssp;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.Kilometers = item.Kilometers;
                newItem.ModifyDate = item.ModifyDate;
                newItem.SerialNumber = item.SerialNumber;
                newItem.Status = item.Status;
                newItem = contextDest.WheelDetails.Add(newItem);
                contextDest.SaveChanges();

                dictSpecialSparepartDetail.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SpecialSparepartDetail done, " + SpecialSparepartDetailList.Count + " records imported");

            //vehicle wheel
            Console.Write("\nImporting table VehicleWheel");

            foreach (var item in VehicleWheelList)
            {
                VehicleWheel newItem = new VehicleWheel();
                int vehicle = dictVehicle[item.VehicleId];
                int sspDetail = dictSpecialSparepartDetail[item.WheelDetailId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.VehicleId = vehicle;
                newItem.WheelDetailId = sspDetail;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Notes = item.Notes;
                newItem.Status = item.Status;
                contextDest.VehicleWheels.Add(newItem);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table VehicleWheel done, " + VehicleWheelList.Count + " records imported");

            //used good
            Console.Write("\nImporting table UsedGood");

            foreach (var item in UsedGoodList)
            {
                int itemOldId = item.Id;
                UsedGood newItem = new UsedGood();
                int sparepart = dictSparepart[item.SparepartId];

                newItem.Id = -1;
                newItem.SparepartId = sparepart;

                newItem.Stock = item.Stock;
                newItem.Status = item.Status;
                newItem = contextDest.UsedGoods.Add(newItem);
                contextDest.SaveChanges();

                dictUsedGood.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table UsedGood done, " + UsedGoodList.Count + " records imported");

            //used good trans
            Console.Write("\nImporting table UsedGoodTransaction");

            foreach (var item in UsedGoodTransactionList)
            {
                UsedGoodTransaction newItem = new UsedGoodTransaction();
                int type = dictReference[item.TypeReferenceId];
                int usedGood = dictUsedGood[item.UsedGoodId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.TypeReferenceId = type;
                newItem.UsedGoodId = usedGood;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.ItemPrice = item.ItemPrice;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Qty = item.Qty;
                newItem.Remark = item.Remark;
                newItem.TotalPrice = item.TotalPrice;
                newItem.TransactionDate = item.TransactionDate;
                contextDest.UsedGoodsTransactions.Add(newItem);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table UsedGoodTransaction done, " + UsedGoodTransactionList.Count + " records imported");

            //guest book
            Console.Write("\nImporting table GuestBook");

            foreach (var item in GuestBookList)
            {
                GuestBook newItem = new GuestBook();
                int vehicle = dictVehicle[item.VehicleId];
                int userCreate = dictUser[item.CreateUserId];
                int userModified = dictUser[item.ModifyUserId];

                newItem.Id = -1;
                newItem.VehicleId = vehicle;
                newItem.CreateUserId = userCreate;
                newItem.ModifyUserId = userModified;

                newItem.CreateDate = item.CreateDate;
                newItem.Description = item.Description;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                contextDest.GuestBooks.Add(newItem);
            }
            contextDest.SaveChanges();

            Console.Write("\nImporting table GuestBook done, " + GuestBookList.Count + " records imported");

            //SPK
            Console.Write("\nImporting table SPK");

            foreach (var item in SPKList)
            {
                int itemOldId = item.Id;

                SPK newItem = new SPK();

                newItem.Id = -1;
                newItem.VehicleId = dictVehicle[item.VehicleId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];
                newItem.VehicleGroupId = dictVehicleGroup[item.VehicleGroupId];
                newItem.CategoryReferenceId = dictReference[item.CategoryReferenceId];

                if (item.SPKParentId > 0)
                {
                    newItem.SPKParentId = dictSPK[item.SPKParentId.Value];
                }

                newItem.Description = item.Description;
                newItem.Code = item.Code;
                newItem.isContractWork = item.isContractWork;
                newItem.Contractor = item.Contractor;
                newItem.ContractWorkFee = item.ContractWorkFee;
                newItem.DueDate = item.DueDate;
                newItem.Kilometers = item.Kilometers;
                newItem.StatusApprovalId = item.StatusApprovalId;
                newItem.StatusCompletedId = item.StatusCompletedId;
                newItem.StatusPrintId = item.StatusPrintId;
                newItem.StatusOverLimit = item.StatusOverLimit;
                newItem.Subtotal = item.Subtotal;
                newItem.TotalMechanicFee = item.TotalMechanicFee;
                newItem.TotalSparepartPrice = item.TotalSparepartPrice;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                SPK insertedSPK = contextDest.SPKs.Add(newItem);
                contextDest.SaveChanges();

                dictSPK.Add(itemOldId, insertedSPK.Id);
            }

            Console.Write("\nImporting table SPK done, " + SPKList.Count + " records imported");

            //spk detail sparepart
            Console.Write("\nImporting table SPKDetailSparepart");

            foreach (var item in SPKDetailSparepartList)
            {
                int itemOldId = item.Id;
                SPKDetailSparepart newItem = new SPKDetailSparepart();

                newItem.Id = -1;
                newItem.SparepartId = dictSparepart[item.SparepartId];
                newItem.SPKId = dictSPK[item.SPKId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.TotalPrice = item.TotalPrice;
                newItem.TotalQuantity = item.TotalQuantity;
                newItem.TotalPriceAfterCommission = item.TotalPriceAfterCommission;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.SPKDetailSpareparts.Add(newItem);
                contextDest.SaveChanges();

                dictSPKDetailSparepart.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SPKDetailSparepart done, " + SPKDetailSparepartList.Count + " records imported");

            //spk detail sparepart detail
            Console.Write("\nImporting table SPKDetailSparepartDetail");

            foreach (var item in SPKDetailSparepartDetailList)
            {
                int itemOldId = item.Id;
                SPKDetailSparepartDetail newItem = new SPKDetailSparepartDetail();

                newItem.Id = -1;
                newItem.SparepartDetailId = dictSparepartDetail[item.SparepartDetailId];
                newItem.SPKDetailSparepartId = dictSPKDetailSparepart[item.SPKDetailSparepartId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.SPKDetailSparepartDetails.Add(newItem);
                contextDest.SaveChanges();

                dictSPKDetailSparepartDetail.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SPKDetailSparepartDetail done, " + SPKDetailSparepartDetailList.Count + " records imported");

            //spk schedule
            Console.Write("\nImporting table SPKSchedule");

            foreach (var item in SPKScheduleList)
            {
                int itemOldId = item.Id;
                SPKSchedule newItem = new SPKSchedule();

                newItem.Id = -1;
                newItem.SPKId = dictSPK[item.SPKId];
                newItem.MechanicId = dictSPKDetailSparepart[item.MechanicId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.Description = item.Description;
                newItem.Date = item.Date;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.SPKSchedules.Add(newItem);
                contextDest.SaveChanges();
            }

            Console.Write("\nImporting table SPKSchedule done, " + SPKScheduleList.Count + " records imported");

            //wheel exchange history
            Console.Write("\nImporting table WheelExchangeHistory");

            foreach (var item in WheelExchangeHistoryList)
            {
                int itemOldId = item.Id;
                WheelExchangeHistory newItem = new WheelExchangeHistory();

                newItem.Id = -1;
                newItem.SPKId = dictSPK[item.SPKId];
                newItem.OriginalWheelId = dictSpecialSparepartDetail[item.OriginalWheelId];
                newItem.ReplaceWheelId = dictSpecialSparepartDetail[item.ReplaceWheelId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;
                newItem = contextDest.WheelExchangeHistories.Add(newItem);
                contextDest.SaveChanges();
            }

            Console.Write("\nImporting table WheelExchangeHistory done, " + WheelExchangeHistoryList.Count + " records imported");

            //invoice
            Console.Write("\nImporting table Invoice");

            foreach (var item in InvoiceList)
            {
                int itemOldId = item.Id;
                Invoice newItem = new Invoice();

                newItem.Id = -1;
                newItem.SPKId = dictSPK[item.SPKId];
                newItem.PaymentMethodId = dictReference[item.PaymentMethodId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.Code = item.Code;
                newItem.TotalPrice = item.TotalPrice;
                newItem.TotalHasPaid = item.TotalHasPaid;
                newItem.TotalService = item.TotalService;
                newItem.TotalFeeService = item.TotalFeeService;
                newItem.TotalServicePlusFee = item.TotalServicePlusFee;
                newItem.TotalSparepart = item.TotalSparepart;
                newItem.TotalFeeSparepart = item.TotalFeeSparepart;
                newItem.TotalSparepartPlusFee = item.TotalSparepartPlusFee;
                newItem.TotalValueAdded = item.TotalValueAdded;
                newItem.TotalSparepartAndService = item.TotalSparepartAndService;
                newItem.PaymentStatus = item.PaymentStatus;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                Invoice insertedInvoice = contextDest.Invoices.Add(newItem);
                contextDest.SaveChanges();

                dictInvoice.Add(itemOldId, insertedInvoice.Id);
            }

            Console.Write("\nImporting table Invoice done, " + InvoiceList.Count + " records imported");

            //invoice detail
            Console.Write("\nImporting table InvoiceDetail");

            foreach (var item in InvoiceDetailList)
            {
                int itemOldId = item.Id;
                InvoiceDetail newItem = new InvoiceDetail();

                newItem.Id = -1;
                newItem.InvoiceId = dictInvoice[item.InvoiceId];
                newItem.SPKDetailSparepartDetailId = dictReference[item.SPKDetailSparepartDetailId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.FeePctg = item.FeePctg;
                newItem.SubTotalPrice = item.SubTotalPrice;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                newItem = contextDest.InvoiceDetails.Add(newItem);
                contextDest.SaveChanges();

                dictInvoiceDetail.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table InvoiceDetail done, " + InvoiceDetailList.Count + " records imported");

            //sales return
            Console.Write("\nImporting table SalesReturn");

            foreach (var item in SalesReturnList)
            {
                int itemOldId = item.Id;
                SalesReturn newItem = new SalesReturn();

                newItem.Id = -1;
                newItem.InvoiceId = dictInvoice[item.InvoiceId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.Code = item.Code;
                newItem.Date = item.Date;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                newItem = contextDest.SalesReturns.Add(newItem);
                contextDest.SaveChanges();

                dictSalesReturn.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table SalesReturn done, " + SalesReturnList.Count + " records imported");

            //sales return detail
            Console.Write("\nImporting table SalesReturnDetail");

            foreach (var item in SalesReturnDetailList)
            {
                int itemOldId = item.Id;
                SalesReturnDetail newItem = new SalesReturnDetail();

                newItem.Id = -1;
                newItem.SalesReturnId = dictSalesReturn[item.SalesReturnId];
                newItem.InvoiceDetailId = dictInvoiceDetail[item.InvoiceDetailId];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                newItem = contextDest.SalesReturnDetails.Add(newItem);
                contextDest.SaveChanges();
            }

            Console.Write("\nImporting table SalesReturnDetail done, " + SalesReturnDetailList.Count + " records imported");

            //transaction
            Console.Write("\nImporting table Transaction");

            foreach (var item in TransactionList)
            {
                int itemOldId = item.Id;
                Transaction newItem = new Transaction();

                newItem.Id = -1;
                newItem.ReferenceTableId = dictReference[item.ReferenceTableId];
                newItem.PaymentMethodId = dictReference[item.PaymentMethodId.Value];
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.PrimaryKeyValue = item.PrimaryKeyValue;
                newItem.TotalTransaction = item.TotalTransaction;
                newItem.TotalPayment = item.TotalPayment;
                newItem.Description = item.Description;
                newItem.IsReconciliation = item.IsReconciliation;
                newItem.TransactionDate = item.TransactionDate;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                newItem = contextDest.Transactions.Add(newItem);
                contextDest.SaveChanges();

                dictTransaction.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table Transaction done, " + TransactionList.Count + " records imported");

            //transaction detail
            Console.Write("\nImporting table TransactionDetail");

            foreach (var item in TransactionDetailList)
            {
                int itemOldId = item.Id;

                TransactionDetail newItem = new TransactionDetail();

                newItem.Id = -1;
                newItem.JournalId = dictJournalMaster[item.JournalId];
                newItem.ParentId = dictTransaction[item.ParentId];
                //newItem.CreateUserId = dictUser[item.CreateUserId];
                //newItem.ModifyUserId = dictUser[item.ModifyUserId];

                //newItem.CreateDate = item.CreateDate;
                //newItem.ModifyDate = item.ModifyDate;
                //newItem.Status = item.Status;

                newItem = contextDest.TransactionDetails.Add(newItem);
                contextDest.SaveChanges();
            }

            Console.Write("\nImporting table TransactionDetail done, " + TransactionDetailList.Count + " records imported");

            //balance journal
            Console.Write("\nImporting table BalanceJournal");

            foreach (var item in BalanceJournalList)
            {
                int itemOldId = item.Id;
                BalanceJournal newItem = new BalanceJournal();

                newItem.Id = -1;
                newItem.CreateUserId = dictUser[item.CreateUserId];
                newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.Month = item.Month;
                newItem.Year = item.Year;
                newItem.IsFirst = item.IsFirst;
                newItem.CreateDate = item.CreateDate;
                newItem.ModifyDate = item.ModifyDate;
                newItem.Status = item.Status;

                newItem = contextDest.BalanceJournals.Add(newItem);
                contextDest.SaveChanges();

                dictBalanceJournal.Add(itemOldId, newItem.Id);
            }

            Console.Write("\nImporting table BalanceJournal done, " + BalanceJournalList.Count + " records imported");

            //balance journal detail
            Console.Write("\nImporting table BalanceJournalDetail");

            foreach (var item in BalanceJournalDetailList)
            {
                int itemOldId = item.Id;
                BalanceJournalDetail newItem = new BalanceJournalDetail();

                newItem.Id = -1;
                newItem.JournalId = dictJournalMaster[item.JournalId];
                newItem.ParentId = dictBalanceJournal[item.ParentId];
                //newItem.CreateUserId = dictUser[item.CreateUserId];
                //newItem.ModifyUserId = dictUser[item.ModifyUserId];

                newItem.FirstDebit = item.FirstDebit;
                newItem.FirstCredit = item.FirstCredit;
                newItem.MutationDebit = item.MutationDebit;
                newItem.MutationCredit = item.MutationCredit;
                newItem.BalanceAfterMutationDebit = item.BalanceAfterMutationDebit;
                newItem.BalanceAfterMutationCredit = item.BalanceAfterMutationCredit;
                newItem.ReconciliationDebit = item.ReconciliationDebit;
                newItem.ReconciliationCredit = item.ReconciliationCredit;
                newItem.BalanceAfterReconciliationDebit = item.BalanceAfterReconciliationDebit;
                newItem.BalanceAfterReconciliationCredit = item.BalanceAfterReconciliationCredit;
                newItem.ProfitLossDebit = item.ProfitLossDebit;
                newItem.ProfitLossCredit = item.ProfitLossCredit;
                newItem.LastDebit = item.LastDebit;
                newItem.LastCredit = item.LastCredit;
                //newItem.CreateDate = item.CreateDate;
                //newItem.ModifyDate = item.ModifyDate;
                //newItem.Status = item.Status;

                newItem = contextDest.BalanceJournalDetails.Add(newItem);
                contextDest.SaveChanges();
            }

            Console.Write("\nImporting table BalanceJournalDetail done, " + BalanceJournalDetailList.Count + " records imported");

            Console.Write("MOTHA F****N DONE!");
            Console.Read();
        }