public List <OptionInfoModel> GetInterlockOptionInfo(string InterlockProductNo)
        {
            List <OptionInfoModel> optionList = new List <OptionInfoModel>();

            Interface.Elevenia.ServiceInterface sInterface = new Interface.Elevenia.ServiceInterface();
            CommonResponse res = new CommonResponse();

            res = sInterface.ProductStockInfo(InterlockProductNo);

            if (res.ResultCd == CommonResponse.ReturnType.Success)
            {
                try
                {
                    XDocument document = XDocument.Parse(res.ResultMsg);

                    var query = from opt in document.Elements("ProductStocks").Elements("ProductStock")
                                select new OptionInfoModel()
                    {
                        InterlockSKUCode = (string)opt.Element("prdStckNo"),
                        ColValue0        = (string)opt.Element("mixDtlOptNm"),
                        ColCount         = (int)opt.Element("stckQty"),
                        UseYn            = (string)opt.Element("prdStckStatCd") == "01" ? "Y" : "N"
                    };
                    optionList = query.ToList();
                }
                catch (Exception ex)
                {
                    //exception processing..
                }
            }

            return(optionList);
        }
        private CommonResponse ModifyProductOption(ProductModel product)
        {
            int modifyCnt = 0;

            CommonResponse res = new CommonResponse();

            Wave.Interface.Elevenia.ServiceInterface sInterface = new Interface.Elevenia.ServiceInterface();

            EleveniaProductSkuInfo InterlockSkuInfo = new EleveniaProductSkuInfo();
            List <OptionInfoModel> InterlockOptionList;

            InterlockOptionList = InterlockSkuInfo.GetInterlockOptionInfo(product.ProductMapping.IntelockProductNo);

            if (product.ProductOption.Count != InterlockOptionList.Count)
            {
                modifyCnt++;
            }

            // compare product.ProductOption with InterlockOptionList
            // ....

            if (modifyCnt > 0)
            {
                SetOptionModifyParams(product);
                res = sInterface.ProductOptModify(product.RegistParams, product.ProductMapping.IntelockProductNo);
            }

            return(res);
        }
        private CommonResponse ModifyProductInfo(ProductModel product)
        {
            CommonResponse res = new CommonResponse();

            Interface.Elevenia.ServiceInterface sInterface = new Interface.Elevenia.ServiceInterface();

            SetModifyInfoParams(product);
            res = sInterface.ProductInfoModify(product.RegistParams, product.ProductMapping.IntelockProductNo);

            return(res);
        }
        public CommonResponse ProductRegist(ProductModel product)
        {
            Interface.Elevenia.ServiceInterface sInterface = new Interface.Elevenia.ServiceInterface();
            CommonResponse res = new CommonResponse();

            if (!ValidateRegist(product))
            {
                res.ResultCd  = CommonResponse.ReturnType.Error;
                res.ResultMsg = "Essential information is missing.[27]";
                return(res);
            }

            SetRegistParams(product);

            res = sInterface.ProductRegist(product.RegistParams);

            if (res.ResultCd != CommonResponse.ReturnType.Success)
            {
                return(res);
            }

            product.ProductMapping.IntelockProductNo = res.ResultID;

            try
            {
                db.ProductMappings.Add(new ProductMapping {
                    ProductNo          = product.ProductNo,
                    InterlockId        = (int)InterlockId.Elevenia,
                    InterlockProductNo = product.ProductMapping.IntelockProductNo,
                    SalePrice          = product.SelPrc,
                    StatusCd           = product.StatusCd
                });

                db.SaveChanges();
            }
            catch (Exception ex)
            {
                res.ResultCd  = CommonResponse.ReturnType.Error;
                res.ResultMsg = "ProductRegist Exception.[60]" + ex.ToString();
            }

            return(res);
        }
        public void BatchSync()
        {
            Interface.Elevenia.ServiceInterface eleveniaInterface = new Interface.Elevenia.ServiceInterface();
            CommonResponse res = new CommonResponse();

            var productList = (from a in db.ProductModifyInfos
                               where a.InterlockId == (int)InterlockId.Elevenia && a.LastModified > LastSyncTime
                               select new
            {
                a.ProductNo,
                a.SyncType
            }).ToList();

            foreach (var product in productList)
            {
                try
                {
                    res = ExecuteProductInterlock(product.ProductNo, product.SyncType);

                    if (res.ResultCd == CommonResponse.ReturnType.ErrorModify || res.ResultCd == CommonResponse.ReturnType.Error)
                    {
                        throw new Exception(res.ResultMsg);
                    }
                }
                catch (Exception ex)
                {
                    db.InterlockProcessLogs.Add(new InterlockProcessLog
                    {
                        ProductNo   = product.ProductNo,
                        InterlockId = (int)InterlockId.Elevenia,
                        RequestTime = DateTime.Now.AddMinutes(1),
                        SyncLevel   = product.SyncType,
                        ResultMsg   = ex.ToString()
                    });

                    db.SaveChanges();
                }
            }
        }
        private CommonResponse ModifyPrice(ProductModel product)
        {
            Wave.Interface.Elevenia.ServiceInterface sInterface = new Interface.Elevenia.ServiceInterface();

            CommonResponse res = new CommonResponse(CommonResponse.ReturnType.Error);

            try
            {
                res = sInterface.ProductPriceModify(product.ProductMapping.IntelockProductNo, product.SelPrc.ToString());
                if (res.ResultCd == CommonResponse.ReturnType.Success)
                {
                    res = setProductMapping(product.ProductNo, (int)InterlockId.Elevenia, product.SelPrc);
                }
            }
            catch (Exception ex)
            {
                res.ResultMsg = ex.ToString();
            }


            return(res);
        }
        //public void BatchSaleStop()
        //{
        //    Interface.Elevenia.ServiceInterface eleveniaInterface = new Interface.Elevenia.ServiceInterface();
        //    CommonResponse res = new CommonResponse();



        //    List<ProductModel> saleStopProducts = (from a in db.ProductModifyInfos
        //                                           join b in db.ProductMappings
        //                                           on a.ProductNo equals b.ProductNo
        //                                           where a.LastModified > LastSyncTime
        //                                           && a.InterlockId == (int)InterlockId.Elevenia
        //                                           && b.InterlockId == (int)InterlockId.Elevenia
        //                                           && (int)SyncType.SaleStop == (a.SyncType & (int)SyncType.SaleStop)
        //                                           select new ProductModel
        //                                           {
        //                                               ProductNo = a.ProductNo,
        //                                               ProductMapping = new ProductMappingModel { IntelockProductNo = b.InterlockProductNo }
        //                                           }).ToList();


        //    EleveniaProductModify eModify = new EleveniaProductModify();
        //    foreach (ProductModel saleStopProduct in saleStopProducts)
        //    {
        //        try
        //        {
        //            res = eModify.SaleStop(saleStopProduct);

        //            if (res.ResultCd == CommonResponse.ReturnType.Error)
        //            {
        //                throw new Exception(res.ResultMsg);
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            //Abnormal processing
        //            db.InterlockProcessLogs.Add(new InterlockProcessLog
        //            {
        //                ProductNo = saleStopProduct.ProductNo,
        //                InterlockId = (int)InterlockId.Elevenia,
        //                InterlockProductNo = saleStopProduct.ProductMapping.IntelockProductNo,
        //                RequestTime = DateTime.Now,
        //                SyncLevel = (int)SyncType.SaleStop,
        //                ResultMsg = ex.ToString()
        //            });

        //            db.SaveChanges();
        //        }

        //    }
        //}
        #endregion

        public void BatchProcessLog()
        {
            Interface.Elevenia.ServiceInterface eleveniaInterface = new Interface.Elevenia.ServiceInterface();
            CommonResponse        res     = new CommonResponse();
            EleveniaProductModify eModify = new EleveniaProductModify();

            //Re-interlocking 3 days
            DateTime requestTime = DateTime.Now.AddDays(-3);
            List <InterlockProcessLog> interlockProcessLogs = db.InterlockProcessLogs
                                                              .Where(a => a.RequestTime > requestTime && a.RollbackTime == null).ToList();

            foreach (InterlockProcessLog interlockProcessLog in interlockProcessLogs)
            {
                try
                {
                    res = ExecuteProductInterlock(interlockProcessLog.ProductNo, interlockProcessLog.SyncLevel);
                }
                catch (Exception ex)
                {
                    res.ResultCd  = CommonResponse.ReturnType.Error;
                    res.ResultMsg = ex.ToString();
                }

                if (res.ResultCd == CommonResponse.ReturnType.Success)
                {
                    interlockProcessLog.RollbackTime    = DateTime.Now;
                    db.Entry(interlockProcessLog).State = System.Data.Entity.EntityState.Modified;
                    db.SaveChanges();
                }
                else
                {
                    interlockProcessLog.ResultMsg       = res.ResultMsg;
                    db.Entry(interlockProcessLog).State = System.Data.Entity.EntityState.Modified;
                    db.SaveChanges();
                }
            }
        }
        private CommonResponse SaleStop(ProductModel product)
        {
            Wave.Interface.Elevenia.ServiceInterface sInterface = new Interface.Elevenia.ServiceInterface();

            CommonResponse res = new CommonResponse();

            try
            {
                res = sInterface.ProductSaleStopModify(product.ProductMapping.IntelockProductNo);

                if (res.ResultCd == CommonResponse.ReturnType.Success)
                {
                    res = setProductMapping(product.ProductNo, (int)InterlockId.Elevenia, StatusCd.STOPSALE.ToString());
                }
            }
            catch (Exception ex)
            {
                res.ResultCd  = Common.CommonResponse.ReturnType.Error;
                res.ResultMsg = ex.ToString();
            }


            return(res);
        }