Exemplo n.º 1
0
 public static long GetQuantityProvinceByYear(ProvinceQuantityKeys key, int year)
 {
     if (Memory.DicProvinceQuantity.ContainsKey(year))
     {
         if (Memory.DicProvinceQuantity[year].ContainsKey(key))
         {
             return(Memory.DicProvinceQuantity[year][key].Quantity);
         }
     }
     return(0);
 }
Exemplo n.º 2
0
 public static ProvinceQuantity GetProvinceQuantityByDoubleKey(int year, ProvinceQuantityKeys key)
 {
     if (!EntityDic.ProvinceQuantityDic.ContainsKey(year))
     {
         return(null);
     }
     if (!EntityDic.ProvinceQuantityDic[year].ContainsKey(key))
     {
         return(null);
     }
     return(EntityDic.ProvinceQuantityDic[year][key].Clone() as ProvinceQuantity);
 }
Exemplo n.º 3
0
        public static void Set(ProvinceQuantity provinceQuantity)
        {
            var key = new ProvinceQuantityKeys
            {
                ProvinceId = provinceQuantity.ProvinceId,
                SexId      = provinceQuantity.SexId,
                JobId      = provinceQuantity.JobId,
                AgeId      = provinceQuantity.AgeId
            };

            if (!Memory.DicProvinceQuantity.ContainsKey(provinceQuantity.Year))
            {
                Memory.DicProvinceQuantity[provinceQuantity.Year] = new Dictionary <ProvinceQuantityKeys, ProvinceQuantity>();
            }
            Memory.DicProvinceQuantity[provinceQuantity.Year][key] = provinceQuantity;
        }
Exemplo n.º 4
0
        public static void UpdateProvinceQuantity(List <ProvinceQuantity> listData)
        {
            foreach (var provinceQuantity in listData)
            {
                EntityCollection.ProvinceQuantityCollection.Update(provinceQuantity);

                //update to ram
                var key = new ProvinceQuantityKeys
                {
                    ProvinceId = provinceQuantity.ProvinceId,
                    AgeId      = provinceQuantity.AgeId,
                    JobId      = provinceQuantity.JobId,
                    SexId      = provinceQuantity.SexId
                };
                EntityDic.ProvinceQuantityDic[provinceQuantity.Year][key] = provinceQuantity;
            }
        }
Exemplo n.º 5
0
        public static void Remove(ProvinceQuantity provinceQuantity)
        {
            var key = new ProvinceQuantityKeys
            {
                ProvinceId = provinceQuantity.ProvinceId,
                SexId      = provinceQuantity.SexId,
                JobId      = provinceQuantity.JobId,
                AgeId      = provinceQuantity.AgeId
            };

            if (Memory.DicProvinceQuantity.ContainsKey(provinceQuantity.Year))
            {
                if (Memory.DicProvinceQuantity[provinceQuantity.Year].ContainsKey(key))
                {
                    Memory.DicProvinceQuantity[provinceQuantity.Year].Remove(key);
                }
            }
        }
Exemplo n.º 6
0
        public static void LoadProvinceQuantity()
        {
            var listProvinceQuantity = EntityCollection.ProvinceQuantityCollection.ToList();

            foreach (var provinceQuantity in listProvinceQuantity)
            {
                var key = new ProvinceQuantityKeys
                {
                    ProvinceId = provinceQuantity.ProvinceId,
                    AgeId      = provinceQuantity.AgeId,
                    JobId      = provinceQuantity.JobId,
                    SexId      = provinceQuantity.SexId
                };
                if (!ProvinceQuantityDic.ContainsKey(provinceQuantity.Year))
                {
                    ProvinceQuantityDic[provinceQuantity.Year] = new Dictionary <ProvinceQuantityKeys, ProvinceQuantity>();
                }
                ProvinceQuantityDic[provinceQuantity.Year][key] = provinceQuantity;
            }
        }
Exemplo n.º 7
0
        public static ProvinceQuantity CheckExistProvinceQuantity(ProvinceQuantity provinceQuantity)
        {
            if (!EntityDic.ProvinceQuantityDic.ContainsKey(provinceQuantity.Year))
            {
                return(null);
            }
            ProvinceQuantityKeys key = new ProvinceQuantityKeys
            {
                ProvinceId = provinceQuantity.ProvinceId,
                AgeId      = provinceQuantity.AgeId,
                SexId      = provinceQuantity.SexId,
                JobId      = provinceQuantity.JobId
            };

            if (EntityDic.ProvinceQuantityDic[provinceQuantity.Year].ContainsKey(key))
            {
                return(EntityDic.ProvinceQuantityDic[provinceQuantity.Year][key].Clone() as ProvinceQuantity);
            }
            return(null);
        }
Exemplo n.º 8
0
        public static void InsertProvinceQuantity(List <ProvinceQuantity> listData)
        {
            foreach (var provinceQuantity in listData)
            {
                EntityCollection.ProvinceQuantityCollection.Add(provinceQuantity);

                //add to memory ram
                if (!EntityDic.ProvinceQuantityDic.ContainsKey(provinceQuantity.Year))
                {
                    EntityDic.ProvinceQuantityDic[provinceQuantity.Year] = new Dictionary <ProvinceQuantityKeys, ProvinceQuantity>();
                }
                var key = new ProvinceQuantityKeys
                {
                    ProvinceId = provinceQuantity.ProvinceId,
                    AgeId      = provinceQuantity.AgeId,
                    JobId      = provinceQuantity.JobId,
                    SexId      = provinceQuantity.SexId
                };
                EntityDic.ProvinceQuantityDic[provinceQuantity.Year][key] = provinceQuantity;
            }
        }
Exemplo n.º 9
0
        public static void AddBranchQuantity()
        {
            MongoRepository <Branch>   branches  = new MongoRepository <Branch>();
            MongoRepository <Province> provinces = new MongoRepository <Province>();

            MongoRepository <Age> ages = new MongoRepository <Age>();
            MongoRepository <Sex> sexs = new MongoRepository <Sex>();
            MongoRepository <Job> jobs = new MongoRepository <Job>();

            List <ProvinceQuantity> provinceQuantities = new MongoRepository <ProvinceQuantity>().ToList();

            Dictionary <ProvinceQuantityKeys, ProvinceQuantity> provinceQuantitiesDic = new Dictionary <ProvinceQuantityKeys, ProvinceQuantity>();

            foreach (var provinceQuantity in provinceQuantities)
            {
                var keys = new ProvinceQuantityKeys
                {
                    ProvinceId = provinceQuantity.ProvinceId,
                    AgeId      = provinceQuantity.AgeId,
                    SexId      = provinceQuantity.SexId,
                    JobId      = provinceQuantity.JobId
                };
                provinceQuantitiesDic[keys] = provinceQuantity;
            }

            MongoRepository <BranchQuantity> branchQuantities = new MongoRepository <BranchQuantity>();
            var year = 2016;

            foreach (var branch in branches)
            {
                var listProvince = provinces.ToList().Where(p => p.BranchId.ToString() == branch.Id).ToList();

                foreach (var age in ages)
                {
                    foreach (var sex in sexs)
                    {
                        foreach (var job in jobs)
                        {
                            long total = 0;

                            foreach (var province in listProvince)
                            {
                                var key = new ProvinceQuantityKeys
                                {
                                    ProvinceId = province.Id,
                                    AgeId      = age.Id,
                                    SexId      = sex.Id,
                                    JobId      = job.Id
                                };
                                if (provinceQuantitiesDic.ContainsKey(key))
                                {
                                    total += provinceQuantitiesDic[key].Quantity;
                                }
                            }
                            BranchQuantity branchQuantity = new BranchQuantity
                            {
                                BranchId = branch.Id,
                                AgeId    = age.Id,
                                SexId    = sex.Id,
                                JobId    = job.Id,
                                Year     = year,
                                Quantity = total
                            };
                            branchQuantities.Add(branchQuantity);
                        }
                    }
                }
            }
        }
Exemplo n.º 10
0
        public static void UpdateBranchQuantity(List <int> listYear)
        {
            var branches = GetAllBranch();
            var ages     = GetAllAge();
            var sexs     = GetAllSex();
            var jobs     = GetAllJob();

            foreach (var year in listYear)
            {
                foreach (var branch in branches)
                {
                    var provinces = GetProvincesInBranch(branch.Id);

                    foreach (var age in ages)
                    {
                        foreach (var sex in sexs)
                        {
                            foreach (var job in jobs)
                            {
                                long total = 0;

                                foreach (var province in provinces)
                                {
                                    var key = new ProvinceQuantityKeys
                                    {
                                        ProvinceId = province.Id,
                                        AgeId      = age.Id,
                                        SexId      = sex.Id,
                                        JobId      = job.Id
                                    };
                                    var provinceQuantity = GetProvinceQuantityByDoubleKey(year, key);
                                    if (provinceQuantity != null)
                                    {
                                        total += provinceQuantity.Quantity;
                                    }
                                }

                                BranchQuantity branchQuantity = new BranchQuantity
                                {
                                    BranchId = branch.Id,
                                    AgeId    = age.Id,
                                    SexId    = sex.Id,
                                    JobId    = job.Id,
                                    Year     = year,
                                    Quantity = total
                                };
                                var listInsert          = new List <BranchQuantity>();
                                var listUpdate          = new List <BranchQuantity>();
                                var checkBranchQuantity = CheckExistBranchQuantity(branchQuantity);
                                if (checkBranchQuantity == null)
                                {
                                    if (branchQuantity.Quantity > 0)
                                    {
                                        listInsert.Add(branchQuantity);
                                    }
                                }
                                else
                                {
                                    branchQuantity.Id = checkBranchQuantity.Id;
                                    listUpdate.Add(branchQuantity);
                                }

                                if (listInsert.Count > 0)
                                {
                                    InsertBranchQuantity(listInsert);
                                }
                                if (listUpdate.Count > 0)
                                {
                                    UpdateBranchQuantity(listUpdate);
                                }
                            }
                        }
                    }
                }
            }
        }