示例#1
0
 public IEnumerable <MaintenancePlanDto> FindMaintenancePlanByParams(Period period, string userLogin)
 {
     return(Session.CreateSQLQuery(planQuery + @"
         INNER JOIN Users u ON u.[login] = :login
         INNER JOIN UserPlants AS up ON up.UserId = u.UserId AND up.PlantId = mo.PlantId
         INNER JOIN UserObjectGroups AS ug ON ug.UserId = u.UserId AND ug.ObjectGroupId = mo.ObjectGroupId
         WHERE  p.MaintenanceDate between :start and :end and isnull(mo.Site,0) = isnull(u.Site,isnull(mo.Site,0))
         ")
            .SetParameter("start", period.Start())
            .SetParameter("end", period.End())
            .SetParameter("login", userLogin)
            .SetResultTransformer(Transformers.AliasToBean <MaintenancePlanDto>())
            .List <MaintenancePlanDto>());
 }
示例#2
0
        /// <summary>
        /// Спланировать работы по обслуживанию
        /// </summary>
        /// <param name="period">Период планирования</param>
        /// <param name="offer">Предложение обслуживания</param>
        /// <param name="offerReason">Причина предложения</param>
        public void PlanningMaintenance(Period period, MaintenanceType offer = null, MaintenanceReason offerReason = null)
        {
            //если оборудование не эксплуатируется, то ничего не планируем
            if (CurrentOperatingState != OperatingState.Operating)
            {
                return;
            }


            //проверяем предыдущий период если план невыполнен то переносим в след период
            var prevPlan = plans.FirstOrDefault(x => x.MaintenanceDate >= period.Prev().Start() && x.MaintenanceDate <= period.Prev().End());

            if (prevPlan != null && !maintenance.Any(x => x.StartMaintenance >= period.Prev().Start() && x.StartMaintenance <= period.Prev().End()))
            {
                plans.Add(new MaintenancePlan(
                              this,
                              prevPlan.MaintenanceType,
                              period.Start(),
                              true,
                              false,
                              prevPlan.OfferReason
                              ));

                return;
            }

            ///сортируем интервалы по величине ремонта (самый крупный будет первым)
            var intervals = Intervals.ToList();

            intervals.Sort();

            var intervalsMap = intervals.ToDictionary(x => x.MaintenanceType.Id);
            var lastDateMap  = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id, x => x.LastMaintenanceDate);
            var lastUsageMap = LastMaintenance.ToDictionary(x => x.MaintenanceType.Id, x => x.UsageFromLastMaintenance);

            var hours = period.Hours();

            intervals.Any(interval =>
            {
                var type = interval.MaintenanceType.Id;

                if (!lastUsageMap.ContainsKey(type))
                {
                    var newLast = new LastMaintenance(interval.MaintenanceType, null, null)
                    {
                        Object = this
                    };

                    lastMaintenance.Add(newLast);
                    lastUsageMap.Add(type, 0);
                    lastDateMap.Add(type, null);
                }

                //проверка по наработке
                if (interval.MinUsage != null)
                {
                    var fork        = interval.MaxUsage - interval.MinUsage;
                    var targetUsage = fork >= 5000 ? interval.MinUsage.Value + fork / 2 : interval.MinUsage.Value;

                    if (lastUsageMap[type].Value >= targetUsage)
                    {
                        //дата проведения обслуживания
                        var date = period.Start().AddDays((interval.MinUsage.Value - lastUsageMap[type].Value) / 24);

                        //если дата ремонта выходит за пределы периода, то устонавливаем её в пределы периода
                        if (date > period.End())
                        {
                            date = period.End();
                        }
                        if (date < period.Start())
                        {
                            date = period.Start();
                        }

                        plans.Add(new MaintenancePlan(this, interval.MaintenanceType, date));

                        return(true);
                    }
                }

                //проверка по времени
                if (interval.PeriodQuantity != null)
                {
                    //todo сделать проверку интервалов по времени
                }

                //проверка по предложению
                if (offer != null && offer.Id == type)
                {
                    plans.Add(new MaintenancePlan(this, interval.MaintenanceType, period.Start(), false, true, offerReason));

                    return(true);
                }

                return(false);
            });
        }
        public void Plan()
        {
            var period = new Period(201802);

            repository.All <MaintenanceObject>()
            .ToList().ForEach(x =>
            {
                var plan = x.Plans.FirstOrDefault(p => p.MaintenanceDate >= period.Start() && p.MaintenanceDate <= period.End());

                if (plan == null)
                {
                    x.PlanningMaintenance(period);
                    repository.Save(x);
                }
            });
        }