public void Sync(SyncFromMainToDepartment syncFromMainToDepartment)
        {
            IList prdMasterUpdateList = new ArrayList();
            IList needUpdateStocks = new ArrayList();
            IList needAddNewStocks = new ArrayList();
            // fix departmentStock first

            IList deptStockTemps = syncFromMainToDepartment.DepartmentStockTemps;
            if (deptStockTemps != null && deptStockTemps.Count > 0)
            {
                DepartmentStockOut deptStockOut = new DepartmentStockOut();
                object maxDSOId = DepartmentStockOutDAO.SelectSpecificType(null,
                                                                           Projections.Max(
                                                                               "DepartmentStockOutPK.StockOutId"));
                long maxDeptStockOutId = (maxDSOId != null ? (long) maxDSOId + 1 : 1);

                object maxDetId = DepartmentStockOutDetailDAO.SelectSpecificType(null,
                                                                                 Projections.Max("DepartmentStockOutDetailPK.StockOutDetailId"));
                long maxDeptStockOutDetId = (maxDetId != null ? (long) maxDetId + 1 : 1);
                deptStockOut.DepartmentStockOutPK = new DepartmentStockOutPK
                                                        {
                                                            DepartmentId = CurrentDepartment.Get().DepartmentId,
                                                            StockOutId = maxDeptStockOutId

                                                        };
                deptStockOut.DefectStatus = new StockDefectStatus {DefectStatusId = 5}; // xuat tra ve nha san xuat
                deptStockOut.ConfirmFlg = 1; // can xac nhan tu kho chinh

                deptStockOut.StockOutDate = DateTime.Now;
                deptStockOut.CreateDate = DateTime.Now;
                deptStockOut.UpdateDate = DateTime.Now;
                deptStockOut.CreateId = ClientInfo.getInstance().LoggedUser.Name;
                deptStockOut.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                deptStockOut.DepartmentStockOutDetails = new ArrayList();
                foreach (DepartmentStockTemp deptStockTemp in deptStockTemps)
                {

                    // find the stock checking
                    DepartmentStockTemp processedDeptStockTemp =
                    DepartmentStockTempDAO.FindById(deptStockTemp.DepartmentStockTempPK);

                    // if exist, then check whether was it processed.
                    if(processedDeptStockTemp!=null)
                    {
                        // if processed
                        if(processedDeptStockTemp.Fixed == 1)
                        {
                            continue; // process to next stock checking row
                        }
                    }
                    else // not exist, maybe error ..
                    {
                        continue; // process to next stock checking row
                    }

                    long realQty = deptStockTemp.GoodQuantity + deptStockTemp.ErrorQuantity +
                                   deptStockTemp.DamageQuantity +
                                   deptStockTemp.LostQuantity + deptStockTemp.UnconfirmQuantity;
                    if (realQty < deptStockTemp.Quantity)
                    {
                        long returnToStockQty = deptStockTemp.Quantity - realQty;
                        DepartmentStockOutDetail deptSODet = new DepartmentStockOutDetail();
                        deptSODet.DepartmentStockOutDetailPK = new DepartmentStockOutDetailPK();
                        deptSODet.DepartmentStockOutDetailPK.DepartmentId = CurrentDepartment.Get().DepartmentId;
                        deptSODet.DepartmentStockOutDetailPK.StockOutDetailId = maxDeptStockOutDetId++;
                        /*deptSODet.StockOutDetailId = maxDeptStockOutDetId++;*/
                        deptSODet.Product = deptStockTemp.Product;
                        deptSODet.ProductMaster = deptStockTemp.ProductMaster;
                        deptSODet.DepartmentStockOut = deptStockOut;
                        deptSODet.Description = "Số liệu dư được xuất về nhà sản xuất hủy";
                        deptSODet.CreateDate = DateTime.Now;
                        deptSODet.UpdateDate = DateTime.Now;
                        deptSODet.CreateId = ClientInfo.getInstance().LoggedUser.Name;
                        deptSODet.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                        deptSODet.StockOutId = deptStockOut.DepartmentStockOutPK.StockOutId;
                        deptSODet.DepartmentId = deptStockOut.DepartmentStockOutPK.DepartmentId;

                        deptSODet.GoodQuantity = returnToStockQty;
                        deptSODet.Quantity = returnToStockQty;
                        deptSODet.DefectStatus = new StockDefectStatus {DefectStatusId = 5}; // xuat tra ve nha san xuat
                        deptStockOut.DepartmentStockOutDetails.Add(deptSODet);
                    }
                    DepartmentStockPK stockPk = new DepartmentStockPK
                                                    {
                                                        DepartmentId = deptStockTemp.DepartmentStockTempPK.DepartmentId,
                                                        ProductId = deptStockTemp.DepartmentStockTempPK.ProductId
                                                    };
                    DepartmentStock stock = DepartmentStockDAO.FindById(stockPk);

                    if (stock != null)
                    {
                        prdMasterUpdateList.Add(stock.Product.ProductMaster);
                        long differGoodQty = stock.Quantity - deptStockTemp.Quantity;
                        stock.GoodQuantity = deptStockTemp.GoodQuantity + differGoodQty;
                        if(deptStockTemp.GoodQuantity > deptStockTemp.Quantity) // stock them vo
                        {
                            // lay so luong nguyen thuy de co the cong them khi stock in vao cua hang
                            stock.GoodQuantity = stock.Quantity;
                        }
                        stock.ErrorQuantity = deptStockTemp.ErrorQuantity;
                        stock.LostQuantity = deptStockTemp.LostQuantity;
                        stock.DamageQuantity = deptStockTemp.DamageQuantity;
                        stock.UnconfirmQuantity = deptStockTemp.UnconfirmQuantity;
                        stock.Quantity = stock.GoodQuantity + stock.ErrorQuantity + stock.LostQuantity +
                                         stock.DamageQuantity + stock.UnconfirmQuantity;
                        needUpdateStocks.Add(stock);
                    }

                    deptStockTemp.DelFlg = 1;
                    processedDeptStockTemp.Fixed = 1;
                    processedDeptStockTemp.DelFlg = 1;
                    DepartmentStockTempDAO.Update(processedDeptStockTemp);
                }
                if (deptStockOut.DepartmentStockOutDetails.Count > 0)
                {
                    DepartmentStockOutDAO.Add(deptStockOut);
                    foreach (DepartmentStockOutDetail detail in deptStockOut.DepartmentStockOutDetails)
                    {
                        DepartmentStockOutDetailDAO.Add(detail);
                    }
                }
            }

            IList stockOutList = syncFromMainToDepartment.StockOutList;
            long deptId = syncFromMainToDepartment.Department.DepartmentId;
            string deptStr = "000";
            if(deptId > 9999)
            {
                deptStr = deptId.ToString();
            }
            else
            {
               deptStr = string.Format("{0:000}", deptId);
            }

            string dateStr = DateTime.Now.ToString("yyMMdd");
            var criteria = new ObjectCriteria();
            if(deptId > 9999)
            {
                criteria.AddGreaterCriteria("DepartmentStockInPK.StockInId", dateStr + deptStr + "000");
            }
            else
            {
                criteria.AddGreaterCriteria("DepartmentStockInPK.StockInId", dateStr + deptStr + "00000");
            }

            var maxId = DepartmentStockInDAO.SelectSpecificType(criteria, Projections.Max("DepartmentStockInPK.StockInId"));

            var stockInId ="";
            if(deptId > 9999)
            {
                stockInId = maxId == null ? dateStr + deptStr + "001" : string.Format("{0:00000000000000}", (Int64.Parse(maxId.ToString()) + 1));
            }
            else
            {
                stockInId = maxId == null ? dateStr + deptStr + "00001" : string.Format("{0:00000000000000}", (Int64.Parse(maxId.ToString()) + 1));
            }

            long nextDeptStockInId = Int64.Parse(stockInId);
            foreach (StockOut stockOut in stockOutList)
            {
                // convert stock out to department stock in
                DepartmentStockInMapper mapper = new DepartmentStockInMapper();
                DepartmentStockIn data = mapper.Convert(stockOut);
                data.Department = syncFromMainToDepartment.Department;
                // sync department stock in
                data.DepartmentStockInPK.StockInId = string.Format("{0:00000000000000}",nextDeptStockInId++);
                /*DepartmentStockIn DepartmentStockIn = DepartmentStockInDAO.FindById(data.DepartmentStockInPK);
                if (DepartmentStockIn == null)
                {
                    DepartmentStockInDAO.Add(data);
                }*/
                StockOut oldStockOut = StockOutDAO.FindById(stockOut.StockoutId);
                if (oldStockOut == null)
                {
                    StockOutDAO.Add(stockOut);
                    DepartmentStockInDAO.Add(data);
                }
                else
                {
                    //ObjectCriteria criteria = new ObjectCriteria();

                    // currently we do not accept update stock in
                    continue;
                    // amend for debug
                    //DepartmentStockInDAO.Update(data);
                }

                // sync department stock in detail
                IList productMasterIds = new ArrayList();
                IList productIds = new ArrayList();
                IList priceList = new ArrayList();
                IList whosalePriceList = new ArrayList();
                IList quantityList = new ArrayList();

                // put master data first
                foreach (DepartmentStockInDetail detail in data.DepartmentStockInDetails)
                {
                    detail.DepartmentStockInDetailPK.StockInId = data.DepartmentStockInPK.StockInId;
                    if (detail.Product.ProductMaster.ProductColor != null)
                    {
                        ProductColor color = ProductColorDAO.FindById(detail.Product.ProductMaster.ProductColor.ColorId);
                        if (color == null)
                        {
                            ProductColorDAO.Add(detail.Product.ProductMaster.ProductColor);
                        }
                    }
                    if (detail.Product.ProductMaster.ProductSize != null)
                    {
                        ProductSize size = ProductSizeDAO.FindById(detail.Product.ProductMaster.ProductSize.SizeId);
                        if (size == null)
                        {
                            ProductSizeDAO.Add(detail.Product.ProductMaster.ProductSize);
                        }
                    }
                    ProductType Type = ProductTypeDAO.FindById(detail.Product.ProductMaster.ProductType.TypeId);
                    if (detail.Product.ProductMaster.ProductType != null)
                    {
                        if (Type == null)
                        {
                            ProductTypeDAO.Add(detail.Product.ProductMaster.ProductType);
                        }
                    }
                    if (detail.Product.ProductMaster.Country != null)
                    {
                        Country Country = CountryDAO.FindById(detail.Product.ProductMaster.Country.CountryId);
                        if (Country == null)
                        {
                            CountryDAO.Add(detail.Product.ProductMaster.Country);
                        }
                    }
                    if (detail.Product.ProductMaster.Distributor != null)
                    {
                        Distributor Distributor =
                            DistributorDAO.FindById(detail.Product.ProductMaster.Distributor.DistributorId);
                        if (Distributor == null)
                        {
                            DistributorDAO.Add(detail.Product.ProductMaster.Distributor);
                        }
                    }
                    if (detail.Product.ProductMaster.Packager != null)
                    {
                        Packager Packager = PackagerDAO.FindById(detail.Product.ProductMaster.Packager.PackagerId);
                        if (Packager == null)
                        {
                            PackagerDAO.Add(detail.Product.ProductMaster.Packager);
                        }
                    }
                    if (detail.Product.ProductMaster.Manufacturer != null)
                    {
                        Manufacturer Manufacturer =
                            ManufacturerDAO.FindById(detail.Product.ProductMaster.Manufacturer.ManufacturerId);
                        if (Manufacturer == null)
                        {
                            ManufacturerDAO.Add(detail.Product.ProductMaster.Manufacturer);
                        }
                    }

                    //ProductMaster ProductMaster = ProductMasterDAO.FindById(detail.Product.ProductMaster.ProductMasterId);
                    ProductMaster ProductMaster = GetProductMaster(detail.Product.ProductMaster,prdMasterUpdateList);
                    if (ProductMaster == null)
                    {
                        ProductMasterDAO.Add(detail.Product.ProductMaster);
                    }
                    else
                    {

                        ProductMaster.Country = detail.Product.ProductMaster.Country;
                        ProductMaster.Packager = detail.Product.ProductMaster.Packager;
                        ProductMaster.ProductColor = detail.Product.ProductMaster.ProductColor;
                        ProductMaster.ProductFullName = detail.Product.ProductMaster.ProductFullName;
                        ProductMaster.ProductName = detail.Product.ProductMaster.ProductName;
                        ProductMaster.ProductSize = detail.Product.ProductMaster.ProductSize;
                        ProductMaster.ProductType = detail.Product.ProductMaster.ProductType;
                        ProductMaster.UpdateDate = detail.Product.ProductMaster.UpdateDate;
                        ProductMaster.UpdateId = detail.Product.ProductMaster.UpdateId;
                        ProductMaster.CreateDate = detail.Product.ProductMaster.CreateDate;
                        ProductMaster.CreateId = detail.Product.ProductMaster.CreateId;
                        ProductMaster.Distributor = detail.Product.ProductMaster.Distributor;
                        ProductMaster.Manufacturer = detail.Product.ProductMaster.Manufacturer;
                        ProductMaster.ImagePath = detail.Product.ProductMaster.ImagePath;
                        ProductMaster.ExclusiveKey = detail.Product.ProductMaster.ExclusiveKey;
                        ProductMasterDAO.Update(ProductMaster);
                    }
                    if (!productMasterIds.Contains(detail.Product.ProductMaster.ProductMasterId))
                    {
                        productMasterIds.Add(detail.Product.ProductMaster.ProductMasterId);
                        priceList.Add(detail.Price);
                        whosalePriceList.Add(detail.OnStorePrice);
                    }

                    Product Product = ProductDAO.FindById(detail.Product.ProductId);
                    if (Product == null)
                    {
                        ProductDAO.Add(detail.Product);
                    }
                    else
                    {
                        Product.UpdateDate = detail.Product.UpdateDate;
                        Product.UpdateId = detail.Product.UpdateId;
                        Product.CreateDate = detail.Product.CreateDate;
                        Product.CreateId = detail.Product.CreateId;
                        Product.ProductMaster = detail.Product.ProductMaster;
                        Product.Quantity = detail.Product.Quantity;
                        Product.Price = detail.Product.Price;
                        ProductDAO.Update(Product);
                    }

                    if (!productIds.Contains(detail.Product.ProductId))
                    {
                        productIds.Add(detail.Product.ProductId);
                        quantityList.Add(detail.Quantity);
                    }

                    DepartmentStockInDetail DepartmentStockInDetail =
                        DepartmentStockInDetailDAO.FindById(detail.DepartmentStockInDetailPK);
                    if (DepartmentStockInDetail == null)
                    {
                        DepartmentStockInDetailDAO.Add(detail);
                    }
                    else
                    {
                        DepartmentStockInDetail.UpdateDate = detail.UpdateDate;
                        DepartmentStockInDetail.UpdateId = detail.UpdateId;
                        DepartmentStockInDetail.CreateDate = detail.CreateDate;
                        DepartmentStockInDetail.CreateId = detail.CreateId;
                        DepartmentStockInDetail.Quantity = DepartmentStockInDetail.Quantity;
                        DepartmentStockInDetail.Price = DepartmentStockInDetail.Price;

                        DepartmentStockInDetailDAO.Update(DepartmentStockInDetail);
                    }
                }

                // update price
                if (productMasterIds.Count > 0)
                {
                    /*IList NotDupPMList = new ArrayList();
                    NotDupPMList = CreateNotDuplicateList(productMasterIds);*/
                    var objectCriteria = new ObjectCriteria();
                    objectCriteria.AddEqCriteria("DelFlg", CommonConstants.DEL_FLG_NO);
                    objectCriteria.AddEqCriteria("DepartmentPricePK.DepartmentId", (long)0);
                    objectCriteria.AddSearchInCriteria("DepartmentPricePK.ProductMasterId", productMasterIds);
                    IList deptPriceList = DepartmentPriceDAO.FindAll(objectCriteria);
                    int i = 0;
                    IList newPriceList = new ArrayList();
                    foreach (string productMasterId in productMasterIds)
                    {
                        DepartmentPrice price = null;
                        bool found = false;
                        foreach (DepartmentPrice price1 in deptPriceList)
                        {
                            if (price1.DepartmentPricePK.ProductMasterId.Equals(productMasterId))
                            {
                                //price = price1;
                                found = true;
                                price1.Price = (Int64)priceList[i];
                                price1.WholeSalePrice = (Int64) whosalePriceList[i];
                                break;
                            }
                        }
                        if (!found)
                        {
                            foreach (DepartmentPrice price1 in newPriceList)
                            {
                                if (price1.DepartmentPricePK.ProductMasterId.Equals(productMasterId))
                                {
                                    //price = price1;
                                    found = true;
                                    price1.Price = (Int64) priceList[i];
                                    price1.WholeSalePrice = (Int64) whosalePriceList[i];
                                    break;
                                }
                            }
                        }
                        //if (price == null)
                        if (!found)
                        {
                            price = new DepartmentPrice
                            {
                                DepartmentPricePK = new DepartmentPricePK { DepartmentId = 0, ProductMasterId = productMasterId },
                                Price = (Int64)priceList[i],
                                WholeSalePrice = (Int64)whosalePriceList[i],
                                CreateDate = DateTime.Now,
                                CreateId = ClientInfo.getInstance().LoggedUser.Name,
                                UpdateDate = DateTime.Now,
                                UpdateId = ClientInfo.getInstance().LoggedUser.Name
                            };
                            newPriceList.Add(price);
                            //DepartmentPriceDAO.Add(price);
                        }
                        /*else
                        {
                            price.UpdateDate = DateTime.Now;
                            price.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                            DepartmentPriceDAO.Update(price);
                        }*/
                        i++;
                    }
                    // patch for update stock
                        try
                        {
                            foreach (DepartmentPrice price in deptPriceList)
                            {
                                DepartmentPriceDAO.Update(price);
                            }
                            foreach (DepartmentPrice price in newPriceList)
                            {
                                DepartmentPriceDAO.Add(price);
                            }
                        }
                        catch (Exception)
                        {

                        }
                }

                // mix 2 lists
                // find lack productIds
                IList lackProductIds = new ArrayList();
                if(productIds.Count > 0)
                {
                    foreach (string productId in productIds)
                    {
                        bool hasFound = false;
                        foreach (DepartmentStock departmentStock in needUpdateStocks)
                        {
                            if(productId.Equals(departmentStock.DepartmentStockPK.ProductId))
                            {
                                hasFound = true;
                                break;
                            }
                        }
                        if(!hasFound)
                        {
                            lackProductIds.Add(productId);
                        }
                    }
                /*}

                if (productIds.Count > 0)
                {*/
                    if (lackProductIds.Count > 0)
                    {
                        var objectCrit1 = new ObjectCriteria();
                        objectCrit1.AddEqCriteria("DelFlg", CommonConstants.DEL_FLG_NO);
                        objectCrit1.AddEqCriteria("DepartmentStockPK.DepartmentId",
                                                  data.DepartmentStockInPK.DepartmentId);

                        objectCrit1.AddSearchInCriteria("DepartmentStockPK.ProductId", lackProductIds);
                        IList stockList = DepartmentStockDAO.FindAll(objectCrit1);
                        if(stockList!= null && stockList.Count > 0)
                        {
                            foreach (DepartmentStock departmentStock in stockList)
                            {
                                needUpdateStocks.Add(departmentStock);
                            }
                        }
                    }
                    int i = 0;
                    foreach (string productId in productIds)
                    {
                        DepartmentStock stock = null;
                        foreach (DepartmentStock needUpdateStock in needUpdateStocks)
                        {
                            if (needUpdateStock.DepartmentStockPK.ProductId.Equals(productId))
                            {
                                stock = needUpdateStock;
                                //stock.Quantity += (Int64)quantityList[i];
                                needUpdateStock.GoodQuantity += (Int64)quantityList[i];
                                needUpdateStock.Quantity += (Int64)quantityList[i];
                                break;
                            }
                        }
                        if (stock == null)
                        {
                            // check in add new stock
                            foreach (DepartmentStock newStock in needAddNewStocks)
                            {
                                if(newStock.DepartmentStockPK.ProductId.Equals(productId))
                                {
                                    stock = newStock;
                                    //stock.Quantity += (Int64)quantityList[i];
                                    newStock.GoodQuantity += (Int64)quantityList[i];
                                    newStock.Quantity += (Int64)quantityList[i];
                                    break;
                                }
                            }
                            // if not found in addnewStock so we create new stock
                            if (stock == null)
                            {
                                stock = new DepartmentStock
                                            {
                                                DepartmentStockPK =
                                                    new DepartmentStockPK
                                                        {
                                                            DepartmentId = data.DepartmentStockInPK.DepartmentId,
                                                            ProductId = productId
                                                        },
                                                Quantity = (Int64) quantityList[i],
                                                GoodQuantity = (Int64) quantityList[i],
                                                CreateDate = DateTime.Now,
                                                CreateId = ClientInfo.getInstance().LoggedUser.Name,
                                                UpdateDate = DateTime.Now,
                                                UpdateId = ClientInfo.getInstance().LoggedUser.Name
                                            };
                                needAddNewStocks.Add(stock);
                            }
                            /*try
                            {
                                stock = new DepartmentStock
                                {
                                    DepartmentStockPK = new DepartmentStockPK { DepartmentId = data.DepartmentStockInPK.DepartmentId, ProductId = productId },
                                    Quantity = (Int64)quantityList[i],
                                    GoodQuantity = (Int64)quantityList[i],
                                    CreateDate = DateTime.Now,
                                    CreateId = ClientInfo.getInstance().LoggedUser.Name,
                                    UpdateDate = DateTime.Now,
                                    UpdateId = ClientInfo.getInstance().LoggedUser.Name
                                };
                                DepartmentStockDAO.Add(stock);
                            }
                            catch (Exception)
                            {

                            }*/

                        }
                        /*else
                        {
                            stock.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                            stock.UpdateDate = DateTime.Now;
                            DepartmentStockDAO.Update(stock);
                        }*/
                        i++;
                    }
                }

            }

            // update stock
            foreach (DepartmentStock stock in needUpdateStocks)
            {
                    stock.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                    stock.UpdateDate = DateTime.Now;
                    DepartmentStockDAO.Update(stock);
            }
            // add new stock
            foreach (DepartmentStock addNewStock in needAddNewStocks)
            {
                DepartmentStockDAO.Add(addNewStock);
            }

            // update common data

            if (syncFromMainToDepartment.Department != null)
            {
                Department dept = DepartmentDAO.FindById(syncFromMainToDepartment.Department.DepartmentId);
                if (dept == null)
                {
                    DepartmentDAO.Add(syncFromMainToDepartment.Department);
                }
                else
                {
                    //dept.Active = data.Department.Active;
                    dept.Address = syncFromMainToDepartment.Department.Address;
                    dept.DepartmentName = syncFromMainToDepartment.Department.DepartmentName;
                    dept.ManagerId = syncFromMainToDepartment.Department.ManagerId;
                    dept.StartDate = syncFromMainToDepartment.Department.StartDate;
                    DepartmentDAO.Update(dept);
                }
                foreach (Employee employee in syncFromMainToDepartment.Department.Employees)
                {
                    Employee emp = EmployeeDAO.FindById(employee.EmployeePK);
                    if (emp == null)
                    {
                        EmployeeDAO.Add(employee);
                        if (employee.EmployeeInfo != null)
                        {
                            EmployeeDetailDAO.Add(employee.EmployeeInfo);
                        }
                    }
                    else
                    {
                        emp.DelFlg = employee.DelFlg;
                        EmployeeDAO.Update(emp);
                        if (employee.EmployeeInfo != null)
                        {
                            EmployeeDetailDAO.Update(employee.EmployeeInfo);
                        }
                    }
                }
            }

            if(syncFromMainToDepartment.UserInfoList!=null && syncFromMainToDepartment.UserInfoList.Count > 0)
            {
                IList needCreateRoleList = new ArrayList();
                IList needCheckRoleList = new ArrayList();
                IList roleList = RoleDAO.FindAll();

                foreach (LoginModel model in syncFromMainToDepartment.UserInfoList)
                {
                    foreach (RoleModel role in model.Roles)
                    {
                        needCheckRoleList.Add(role);
                    }
                }

                // check role
                foreach (RoleModel roleModel in needCheckRoleList)
                {
                    bool hasFound = false;
                    foreach (RoleModel existRole in roleList)
                    {
                        if (existRole.Id == roleModel.Id)
                        {
                            if (!existRole.Name.Equals(roleModel.Name)) existRole.Name = roleModel.Name;
                            hasFound = true;
                            break;
                        }
                    }

                    if (!hasFound)
                        {
                            bool addedToCreateList = false;
                            foreach (RoleModel needCreateRole in needCreateRoleList)
                            {
                                if(roleModel.Id == needCreateRole.Id)
                                {
                                    addedToCreateList = true;
                                    break;
                                }
                            }
                            if (!addedToCreateList) needCreateRoleList.Add(roleModel);
                        }

                }
                foreach (RoleModel model in roleList)
                {
                    RoleDAO.Update(model);
                }
                foreach (RoleModel model in needCreateRoleList)
                {
                    RoleDAO.Add(model);
                }
                foreach (LoginModel model in syncFromMainToDepartment.UserInfoList)
                {

                    LoginModel dbUserModel = LoginDAO.FindById(model.Username);
                    if (dbUserModel != null)
                    {
                        dbUserModel.Username = model.Username;
                        if (!dbUserModel.Password.Equals(model.Password))
                        {
                            if (DateTime.Compare(dbUserModel.UpdateDate, model.UpdateDate) < 0)
                            {
                                dbUserModel.Password = model.Password;
                            }
                        }
                        dbUserModel.Roles = model.Roles;
                        dbUserModel.EmployeeInfo = model.EmployeeInfo;
                        dbUserModel.Suspended = model.Suspended;
                        dbUserModel.Deleted = model.Deleted;

                        LoginDAO.Update(dbUserModel);
                    }
                    else
                    {
                        LoginDAO.Add(model);
                    }
                }
            }
        }
        public void Sync(SyncFromMainToDepartment syncFromMainToDepartment)
        {
            IList prdMasterUpdateList = new ArrayList();
            IList needUpdateStocks = new ArrayList();
            // fix departmentStock first

            IList deptStockTemps = syncFromMainToDepartment.DepartmentStockTemps;
            if (deptStockTemps != null && deptStockTemps.Count > 0)
            {
                DepartmentStockOut deptStockOut = new DepartmentStockOut();
                object maxDSOId = DepartmentStockOutDAO.SelectSpecificType(null,
                                                                           Projections.Max(
                                                                               "DepartmentStockOutPK.StockOutId"));
                long maxDeptStockOutId = (maxDSOId != null ? (long) maxDSOId + 1 : 1);

                object maxDetId = DepartmentStockOutDetailDAO.SelectSpecificType(null,
                                                                                 Projections.Max("StockOutDetailId"));
                long maxDeptStockOutDetId = (maxDetId != null ? (long) maxDetId + 1 : 1);
                deptStockOut.DepartmentStockOutPK = new DepartmentStockOutPK
                                                        {
                                                            DepartmentId = CurrentDepartment.Get().DepartmentId,
                                                            StockOutId = maxDeptStockOutId

                                                        };
                deptStockOut.DefectStatus = new StockDefectStatus {DefectStatusId = 5}; // xuat tra ve nha san xuat
                deptStockOut.ConfirmFlg = 1; // can xac nhan tu kho chinh

                deptStockOut.StockOutDate = DateTime.Now;
                deptStockOut.CreateDate = DateTime.Now;
                deptStockOut.UpdateDate = DateTime.Now;
                deptStockOut.CreateId = ClientInfo.getInstance().LoggedUser.Name;
                deptStockOut.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                deptStockOut.DepartmentStockOutDetails = new ArrayList();
                foreach (DepartmentStockTemp deptStockTemp in deptStockTemps)
                {
                    long realQty = deptStockTemp.GoodQuantity + deptStockTemp.ErrorQuantity +
                                   deptStockTemp.DamageQuantity +
                                   deptStockTemp.LostQuantity + deptStockTemp.UnconfirmQuantity;
                    if (realQty < deptStockTemp.Quantity)
                    {
                        long returnToStockQty = deptStockTemp.Quantity - realQty;
                        DepartmentStockOutDetail deptSODet = new DepartmentStockOutDetail();
                        deptSODet.StockOutDetailId = maxDeptStockOutDetId++;
                        deptSODet.Product = deptStockTemp.Product;
                        deptSODet.ProductMaster = deptStockTemp.ProductMaster;
                        deptSODet.DepartmentStockOut = deptStockOut;
                        deptSODet.Description = "Số liệu dư được xuất về nhà sản xuất hủy";
                        deptSODet.CreateDate = DateTime.Now;
                        deptSODet.UpdateDate = DateTime.Now;
                        deptSODet.CreateId = ClientInfo.getInstance().LoggedUser.Name;
                        deptSODet.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                        deptSODet.StockOutId = deptStockOut.DepartmentStockOutPK.StockOutId;
                        deptSODet.DepartmentId = deptStockOut.DepartmentStockOutPK.DepartmentId;

                        deptSODet.GoodQuantity = returnToStockQty;
                        deptSODet.Quantity = returnToStockQty;
                        deptSODet.DefectStatus = new StockDefectStatus {DefectStatusId = 5}; // xuat tra ve nha san xuat
                        deptStockOut.DepartmentStockOutDetails.Add(deptSODet);
                    }
                    DepartmentStockPK stockPk = new DepartmentStockPK
                                                    {
                                                        DepartmentId = deptStockTemp.DepartmentStockTempPK.DepartmentId,
                                                        ProductId = deptStockTemp.DepartmentStockTempPK.ProductId
                                                    };
                    DepartmentStock stock = DepartmentStockDAO.FindById(stockPk);

                    if (stock != null)
                    {
                        prdMasterUpdateList.Add(stock.Product.ProductMaster);
                        long differGoodQty = stock.Quantity - deptStockTemp.Quantity;
                        stock.GoodQuantity = deptStockTemp.GoodQuantity + differGoodQty;
                        if(deptStockTemp.GoodQuantity > deptStockTemp.Quantity) // stock them vo
                        {
                            // lay so luong nguyen thuy de co the cong them khi stock in vao cua hang
                            stock.GoodQuantity = stock.Quantity;
                        }
                        stock.ErrorQuantity = deptStockTemp.ErrorQuantity;
                        stock.LostQuantity = deptStockTemp.LostQuantity;
                        stock.DamageQuantity = deptStockTemp.DamageQuantity;
                        stock.UnconfirmQuantity = deptStockTemp.UnconfirmQuantity;
                        stock.Quantity = stock.GoodQuantity + stock.ErrorQuantity + stock.LostQuantity +
                                         stock.DamageQuantity + stock.UnconfirmQuantity;
                        needUpdateStocks.Add(stock);
                    }
                    deptStockTemp.DelFlg = 1;
                    DepartmentStockTempDAO.Update(deptStockTemp);
                }
                if (deptStockOut.DepartmentStockOutDetails.Count > 0)
                {
                    DepartmentStockOutDAO.Add(deptStockOut);
                    foreach (DepartmentStockOutDetail detail in deptStockOut.DepartmentStockOutDetails)
                    {
                        DepartmentStockOutDetailDAO.Add(detail);
                    }
                }
            }

            IList stockOutList = syncFromMainToDepartment.StockOutList;

            string deptStr = string.Format("{0:000}", syncFromMainToDepartment.Department.DepartmentId);
            string dateStr = DateTime.Now.ToString("yyMMdd");
            var criteria = new ObjectCriteria();
            criteria.AddGreaterCriteria("DepartmentStockInPK.StockInId", dateStr + deptStr + "00000");
            var maxId = DepartmentStockInDAO.SelectSpecificType(criteria, Projections.Max("DepartmentStockInPK.StockInId"));

            var stockInId = maxId == null ? dateStr + deptStr + "00001" : string.Format("{0:00000000000000}", (Int64.Parse(maxId.ToString()) + 1));
            long nextDeptStockInId = Int64.Parse(stockInId);
            foreach (StockOut stockOut in stockOutList)
            {
                // convert stock out to department stock in
                DepartmentStockInMapper mapper = new DepartmentStockInMapper();
                DepartmentStockIn data = mapper.Convert(stockOut);
                data.Department = syncFromMainToDepartment.Department;
                // sync department stock in
                data.DepartmentStockInPK.StockInId = string.Format("{0:00000000000000}",nextDeptStockInId++);
                /*DepartmentStockIn DepartmentStockIn = DepartmentStockInDAO.FindById(data.DepartmentStockInPK);
                if (DepartmentStockIn == null)
                {
                    DepartmentStockInDAO.Add(data);
                }*/
                StockOut oldStockOut = StockOutDAO.FindById(stockOut.StockoutId);
                if (oldStockOut == null)
                {
                    StockOutDAO.Add(stockOut);
                    DepartmentStockInDAO.Add(data);
                }
                else
                {
                    //ObjectCriteria criteria = new ObjectCriteria();

                    // currently we do not accept update stock in
                    continue;
                    // amend for debug
                    //DepartmentStockInDAO.Update(data);
                }

                // sync department stock in detail
                IList productMasterIds = new ArrayList();
                IList productIds = new ArrayList();
                IList priceList = new ArrayList();
                IList quantityList = new ArrayList();

                // put master data first
                foreach (DepartmentStockInDetail detail in data.DepartmentStockInDetails)
                {
                    detail.DepartmentStockInDetailPK.StockInId = data.DepartmentStockInPK.StockInId;
                    if (detail.Product.ProductMaster.ProductColor != null)
                    {
                        ProductColor color = ProductColorDAO.FindById(detail.Product.ProductMaster.ProductColor.ColorId);
                        if (color == null)
                        {
                            ProductColorDAO.Add(detail.Product.ProductMaster.ProductColor);
                        }
                    }
                    if (detail.Product.ProductMaster.ProductSize != null)
                    {
                        ProductSize Size = ProductSizeDAO.FindById(detail.Product.ProductMaster.ProductSize.SizeId);
                        if (Size == null)
                        {
                            ProductSizeDAO.Add(detail.Product.ProductMaster.ProductSize);
                        }
                    }
                    if (detail.Product.ProductMaster.ProductType != null)
                    {
                        ProductType Type = ProductTypeDAO.FindById(detail.Product.ProductMaster.ProductType.TypeId);
                        if (Type == null)
                        {
                            ProductTypeDAO.Add(detail.Product.ProductMaster.ProductType);
                        }
                    }
                    if (detail.Product.ProductMaster.Country != null)
                    {
                        Country Country = CountryDAO.FindById(detail.Product.ProductMaster.Country.CountryId);
                        if (Country == null)
                        {
                            CountryDAO.Add(detail.Product.ProductMaster.Country);
                        }
                    }
                    if (detail.Product.ProductMaster.Distributor != null)
                    {
                        Distributor Distributor =
                            DistributorDAO.FindById(detail.Product.ProductMaster.Distributor.DistributorId);
                        if (Distributor == null)
                        {
                            DistributorDAO.Add(detail.Product.ProductMaster.Distributor);
                        }
                    }
                    if (detail.Product.ProductMaster.Packager != null)
                    {
                        Packager Packager = PackagerDAO.FindById(detail.Product.ProductMaster.Packager.PackagerId);
                        if (Packager == null)
                        {
                            PackagerDAO.Add(detail.Product.ProductMaster.Packager);
                        }
                    }
                    if (detail.Product.ProductMaster.Manufacturer != null)
                    {
                        Manufacturer Manufacturer =
                            ManufacturerDAO.FindById(detail.Product.ProductMaster.Manufacturer.ManufacturerId);
                        if (Manufacturer == null)
                        {
                            ManufacturerDAO.Add(detail.Product.ProductMaster.Manufacturer);
                        }
                    }

                    //ProductMaster ProductMaster = ProductMasterDAO.FindById(detail.Product.ProductMaster.ProductMasterId);
                    ProductMaster ProductMaster = GetProductMaster(detail.Product.ProductMaster,prdMasterUpdateList);
                    if (ProductMaster == null)
                    {
                        ProductMasterDAO.Add(detail.Product.ProductMaster);
                    }
                    else
                    {

                        ProductMaster.Country = detail.Product.ProductMaster.Country;
                        ProductMaster.Packager = detail.Product.ProductMaster.Packager;
                        ProductMaster.ProductColor = detail.Product.ProductMaster.ProductColor;
                        ProductMaster.ProductFullName = detail.Product.ProductMaster.ProductFullName;
                        ProductMaster.ProductName = detail.Product.ProductMaster.ProductName;
                        ProductMaster.ProductSize = detail.Product.ProductMaster.ProductSize;
                        ProductMaster.ProductType = detail.Product.ProductMaster.ProductType;
                        ProductMaster.UpdateDate = detail.Product.ProductMaster.UpdateDate;
                        ProductMaster.UpdateId = detail.Product.ProductMaster.UpdateId;
                        ProductMaster.CreateDate = detail.Product.ProductMaster.CreateDate;
                        ProductMaster.CreateId = detail.Product.ProductMaster.CreateId;
                        ProductMaster.Distributor = detail.Product.ProductMaster.Distributor;
                        ProductMaster.Manufacturer = detail.Product.ProductMaster.Manufacturer;
                        ProductMaster.ImagePath = detail.Product.ProductMaster.ImagePath;
                        ProductMaster.ExclusiveKey = detail.Product.ProductMaster.ExclusiveKey;
                        ProductMasterDAO.Update(ProductMaster);
                    }
                    if (!productMasterIds.Contains(detail.Product.ProductMaster.ProductMasterId))
                    {
                        productMasterIds.Add(detail.Product.ProductMaster.ProductMasterId);
                        priceList.Add(detail.Price);
                    }

                    Product Product = ProductDAO.FindById(detail.Product.ProductId);
                    if (Product == null)
                    {
                        ProductDAO.Add(detail.Product);
                    }
                    else
                    {
                        Product.UpdateDate = detail.Product.UpdateDate;
                        Product.UpdateId = detail.Product.UpdateId;
                        Product.CreateDate = detail.Product.CreateDate;
                        Product.CreateId = detail.Product.CreateId;
                        Product.ProductMaster = detail.Product.ProductMaster;
                        Product.Quantity = detail.Product.Quantity;
                        Product.Price = detail.Product.Price;
                        ProductDAO.Update(Product);
                    }

                    if (!productIds.Contains(detail.Product.ProductId))
                    {
                        productIds.Add(detail.Product.ProductId);
                        quantityList.Add(detail.Quantity);
                    }

                    DepartmentStockInDetail DepartmentStockInDetail =
                        DepartmentStockInDetailDAO.FindById(detail.DepartmentStockInDetailPK);
                    if (DepartmentStockInDetail == null)
                    {
                        DepartmentStockInDetailDAO.Add(detail);
                    }
                    else
                    {
                        DepartmentStockInDetail.UpdateDate = detail.UpdateDate;
                        DepartmentStockInDetail.UpdateId = detail.UpdateId;
                        DepartmentStockInDetail.CreateDate = detail.CreateDate;
                        DepartmentStockInDetail.CreateId = detail.CreateId;
                        DepartmentStockInDetail.Quantity = DepartmentStockInDetail.Quantity;
                        DepartmentStockInDetail.Price = DepartmentStockInDetail.Price;

                        DepartmentStockInDetailDAO.Update(DepartmentStockInDetail);
                    }
                }

                // update price
                if (productMasterIds.Count > 0)
                {
                    var objectCriteria = new ObjectCriteria();
                    objectCriteria.AddEqCriteria("DelFlg", CommonConstants.DEL_FLG_NO);
                    objectCriteria.AddEqCriteria("DepartmentPricePK.DepartmentId", (long)0);
                    objectCriteria.AddSearchInCriteria("DepartmentPricePK.ProductMasterId", productMasterIds);
                    IList deptPriceList = DepartmentPriceDAO.FindAll(objectCriteria);
                    int i = 0;
                    foreach (string productMasterId in productMasterIds)
                    {
                        DepartmentPrice price = null;
                        foreach (DepartmentPrice price1 in deptPriceList)
                        {
                            if (price1.DepartmentPricePK.ProductMasterId.Equals(productMasterId))
                            {
                                price = price1;
                                price.Price = (Int64)priceList[i];
                                break;
                            }
                        }
                        if (price == null)
                        {
                            price = new DepartmentPrice
                            {
                                DepartmentPricePK = new DepartmentPricePK { DepartmentId = 0, ProductMasterId = productMasterId },
                                Price = (Int64)priceList[i],
                                CreateDate = DateTime.Now,
                                CreateId = ClientInfo.getInstance().LoggedUser.Name,
                                UpdateDate = DateTime.Now,
                                UpdateId = ClientInfo.getInstance().LoggedUser.Name
                            };
                            DepartmentPriceDAO.Add(price);
                        }
                        else
                        {
                            price.UpdateDate = DateTime.Now;
                            price.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                            DepartmentPriceDAO.Update(price);
                        }
                        i++;
                    }
                }

                // mix 2 lists
                // find lack productIds
                IList lackProductIds = new ArrayList();
                if(productIds.Count > 0)
                {
                    foreach (string productId in productIds)
                    {
                        bool hasFound = false;
                        foreach (DepartmentStock departmentStock in needUpdateStocks)
                        {
                            if(productId.Equals(departmentStock.DepartmentStockPK.ProductId))
                            {
                                hasFound = true;
                                break;
                            }
                        }
                        if(!hasFound)
                        {
                            lackProductIds.Add(productId);
                        }
                    }
                }

                if (productIds.Count > 0)
                {
                    if (lackProductIds.Count > 0)
                    {
                        var objectCrit1 = new ObjectCriteria();
                        objectCrit1.AddEqCriteria("DelFlg", CommonConstants.DEL_FLG_NO);
                        objectCrit1.AddEqCriteria("DepartmentStockPK.DepartmentId",
                                                  data.DepartmentStockInPK.DepartmentId);

                        objectCrit1.AddSearchInCriteria("DepartmentStockPK.ProductId", productIds);
                        IList stockList = DepartmentStockDAO.FindAll(objectCrit1);
                        if(stockList!= null && stockList.Count > 0)
                        {
                            foreach (DepartmentStock departmentStock in stockList)
                            {
                                needUpdateStocks.Add(departmentStock);
                            }
                        }
                    }
                    int i = 0;
                    foreach (string productId in productIds)
                    {
                        DepartmentStock stock = null;
                        foreach (DepartmentStock needUpdateStock in needUpdateStocks)
                        {
                            if (needUpdateStock.DepartmentStockPK.ProductId.Equals(productId))
                            {
                                stock = needUpdateStock;
                                //stock.Quantity += (Int64)quantityList[i];
                                stock.GoodQuantity += (Int64)quantityList[i];
                                stock.Quantity += (Int64)quantityList[i];
                                break;
                            }
                        }
                        if (stock == null)
                        {
                            stock = new DepartmentStock
                            {
                                DepartmentStockPK = new DepartmentStockPK { DepartmentId = data.DepartmentStockInPK.DepartmentId, ProductId = productId },
                                Quantity = (Int64)quantityList[i],
                                GoodQuantity = (Int64)quantityList[i],
                                CreateDate = DateTime.Now,
                                CreateId = ClientInfo.getInstance().LoggedUser.Name,
                                UpdateDate = DateTime.Now,
                                UpdateId = ClientInfo.getInstance().LoggedUser.Name
                            };
                            DepartmentStockDAO.Add(stock);
                        }
                        /*else
                        {
                            stock.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                            stock.UpdateDate = DateTime.Now;
                            DepartmentStockDAO.Update(stock);
                        }*/
                        i++;
                    }
                }
                // update stock
                foreach (DepartmentStock stock in needUpdateStocks)
                {
                    stock.UpdateId = ClientInfo.getInstance().LoggedUser.Name;
                    stock.UpdateDate = DateTime.Now;
                    DepartmentStockDAO.Update(stock);
                }

                if (data.Department != null)
                {
                    Department dept = DepartmentDAO.FindById(data.Department.DepartmentId);
                    if (dept == null)
                    {
                        DepartmentDAO.Add(data.Department);
                    }
                    else
                    {
                        //dept.Active = data.Department.Active;
                        dept.Address = data.Department.Address;
                        dept.DepartmentName = data.Department.DepartmentName;
                        dept.ManagerId = data.Department.ManagerId;
                        dept.StartDate = data.Department.StartDate;
                        DepartmentDAO.Update(dept);
                    }
                    foreach (Employee employee in data.Department.Employees)
                    {
                        Employee emp = EmployeeDAO.FindById(employee.EmployeePK);
                        if (emp == null)
                        {
                            EmployeeDAO.Add(employee);
                            if (employee.EmployeeInfo != null)
                            {
                                EmployeeDetailDAO.Add(employee.EmployeeInfo);
                            }
                        }
                        else
                        {
                            emp.DelFlg = employee.DelFlg;
                            EmployeeDAO.Update(emp);
                            if (employee.EmployeeInfo != null)
                            {
                                EmployeeDetailDAO.Update(employee.EmployeeInfo);
                            }
                        }
                    }
                }

            }
        }