Example #1
0
        private JobLifeDto DoItemsBeat(JobLifeDto beat)
        {
            Console.WriteLine("Запущен пересчет товаров");
            //Получить список корпораций с специализациями
            var corporations = Factory.Billing.GetList <CorporationWallet>(c => true, c => c.Specialisations);
            var inflation    = Factory.Settings.GetDecimalValue(SystemSettingsEnum.pre_inflation);

            foreach (var corporation in corporations)
            {
                corporation.LastSkuSold = corporation.SkuSold;
                corporation.SkuSold     = 0;
                corporation.LastKPI     = corporation.CurrentKPI;
                corporation.CurrentKPI  = 0;
                var skus  = Factory.Billing.GetList <Sku>(s => s.CorporationId == corporation.Id, s => s.Nomenklatura.Specialisation);
                var specs = corporation.Specialisations.Select(s => s.SpecialisationId);
                foreach (var sku in skus)
                {
                    sku.Count = sku.SkuBaseCount ?? sku.Nomenklatura.BaseCount;
                    decimal price = 0;
                    if (sku.SkuBasePrice == null)
                    {
                        price = BillingHelper.GetSpecialisationPrice(corporation.Specialisations.FirstOrDefault(s => s.SpecialisationId == sku.Nomenklatura.SpecialisationId && s.CorporationId == sku.CorporationId), sku.Nomenklatura);
                    }
                    else
                    {
                        price = sku.SkuBasePrice ?? 0;
                    }

                    sku.Price = price * inflation;
                }
                Factory.Billing.SaveContext();
                Console.WriteLine($"Корпорация {corporation.Name} обработана");
            }
            return(beat);
        }
Example #2
0
        public string DoBeat(BeatTypes type = BeatTypes.Test, string token = "", bool wait = false)
        {
            var cycle = Factory.Job.GetLastCycle(token);

            if (!cycle.IsActive || cycle == null)
            {
                return("цикл не запущен");
            }
            if (type == BeatTypes.Characters)
            {
                if (!Factory.Job.BlockBilling())
                {
                    throw new BillingException(BillingException);
                }
            }
            var task = Task.Run(() =>
            {
                try
                {
                    var beat          = Factory.Job.GetLastBeatAsNoTracking(cycle.Id, type);
                    var newBeat       = new BillingBeat();
                    newBeat.Number    = beat != null ? beat.Number + 1 : 1;
                    newBeat.StartTime = DateTime.Now.ToUniversalTime();
                    newBeat.CycleId   = cycle.Id;
                    newBeat.BeatType  = (int)type;
                    Factory.Job.AddAndSave(newBeat);
                    var dto = new JobLifeDto
                    {
                        Beat = newBeat
                    };
                    switch ((BeatTypes)newBeat.BeatType)
                    {
                    case BeatTypes.Test:
                        dto.AddHistory("test beat");
                        break;

                    case BeatTypes.Items:
                        dto = DoItemsBeat(dto);
                        break;

                    case BeatTypes.Characters:
                        dto = DoCharactersBeat(dto);
                        break;

                    default:
                        dto.AddHistory("unknown beat type");
                        break;
                    }
                    dto.Beat.FinishTime = DateTime.Now.ToUniversalTime();
                    Factory.Job.AddAndSave(dto.Beat);
                    Factory.Job.AddRangeAndSave(dto.History);
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine(e.ToString());
                    throw;
                }
                finally
                {
                    if (type == BeatTypes.Characters)
                    {
                        if (!Factory.Job.UnblockBilling())
                        {
                            throw new Exception("Биллинг был разблокирован раньше времени");
                        }
                    }
                }
            });

            if (wait)
            {
                task.Wait();
            }
            return($"Пересчет для {cycle.Token}_{cycle.Number} запущен ");
        }
Example #3
0
        private JobLifeDto DoCharactersBeat(JobLifeDto beat)
        {
            Console.WriteLine("Запущен пересчет персонажей");
            var sins = Factory.Billing.GetActiveSins(s => s.Wallet, s => s.Character);

            Console.WriteLine($"Обрабатывается {sins.Count} персонажей");
            var charactersLoaded = false;
            var incomeList       = new ConcurrentQueue <ImportDto>();
            var processedList    = new ConcurrentQueue <ImportDto>();
            var errorList        = new ConcurrentQueue <ImportDto>();
            var lastlsDto        = BillingHelper.GetBeatDto();
            var lsDto            = new JobLifeStyleDto();

            lsDto.lastDto = lastlsDto;
            lsDto.K       = (Factory.Settings.GetDecimalValue(SystemSettingsEnum.karma_k) / 100);
            var taskLoad = Task.Run(() =>
            {
                Console.WriteLine("Пошла внешняя загрузка персонажей");
                LoadCharacters(sins, incomeList);
                Console.WriteLine("Внешняя загрузка персонажей закончена");
                charactersLoaded = true;
            });
            var taskProcess = Task.Run(() =>
            {
                while (!charactersLoaded || !incomeList.IsEmpty)
                {
                    if (!charactersLoaded && incomeList.Count < _bulk)
                    {
                        Thread.Sleep(100);
                        continue;
                    }
                    var parallelList = new List <ImportDto>();
                    ImportDto loaded;
                    while (incomeList.TryDequeue(out loaded))
                    {
                        if (string.IsNullOrEmpty(loaded.ErrorText))
                        {
                            parallelList.Add(loaded);
                        }
                        else
                        {
                            errorList.Enqueue(loaded);
                        }
                    }
                    Console.WriteLine($"Внутренняя обработка пачки из {parallelList.Count} персонажей");
                    ParallelCharacters(parallelList, lsDto, processedList, errorList);
                    Console.WriteLine($"Внутренняя обработка пачки из {parallelList.Count} персонажей");
                }
            });

            Task.WaitAll(taskLoad, taskProcess);
            Console.WriteLine("Пересчеты персонажей закончены, записывается история и ошибки");
            foreach (var error in errorList)
            {
                beat.AddHistory($"ошибка обработки {error.Sin.Character.Model}: {error.ErrorText}");
            }
            try
            {
                var values  = ProcessLifestyle(lsDto);
                var message = $"Значения для lifestyle {values}";
                beat.AddHistory(message);
            }
            catch (Exception e)
            {
                beat.AddHistory(e.ToString());
            }
            return(beat);
        }