Esempio n. 1
0
        /// <summary>
        /// Добавляет программу обслуживания для чеков заданного типа (A,B,C и т.д.)
        /// </summary>
        /// <param name="currentCheckType">Тип чека, для которого составляется программа</param>
        /// <param name="nextCheckType">Тип вышестоящего чека</param>
        /// <param name="schedule">являются чеки плановыми или входят в программу по хранению</param>
        /// <param name="grouping">Указывает нужно ли группировать чеки по части порогового значения</param>
        /// <param name="subResource">Часть порогового значения, по которой будет выполнятся расчет и/или группировка чеков</param>
        private void AddMaintenanceProgram(MaintenanceCheckType currentCheckType,
                                           MaintenanceCheckType nextCheckType,
                                           bool schedule, bool grouping,
                                           LifelengthSubResource subResource)
        {
            //Ресурс выполнения
            int nextCheckResource = -1;
            List <MaintenanceCheck> currentTypeChecks = new List <MaintenanceCheck>();

            foreach (MaintenanceCheck liminationItem in _liminationItems)
            {
                if (liminationItem.CheckType.ItemId == currentCheckType.ItemId)
                {
                    currentTypeChecks.Add(liminationItem);
                }
                else if (nextCheckResource == -1 && nextCheckType != MaintenanceCheckType.Unknown && liminationItem.CheckType == nextCheckType)
                {
                    if (liminationItem.Interval.GetSubresource(subResource) != null)
                    {
                        nextCheckResource = nextCheckResource == -1
                            ? Convert.ToInt32(liminationItem.Interval.GetSubresource(subResource))
                            : Math.Min(Convert.ToInt32(liminationItem.Interval.GetSubresource(subResource)), nextCheckResource);
                    }
                }
            }
            MaintenanceProgramControlItem maintenanceScheduleItem =
                new MaintenanceProgramControlItem(currentTypeChecks,
                                                  Convert.ToInt32(_liminationItems[0].Interval.GetSubresource(_subResource)),
                                                  schedule,
                                                  grouping,
                                                  subResource,
                                                  nextCheckResource);

            flowLayoutPanelContainer.Controls.Add(maintenanceScheduleItem);
        }
 /// <summary>
 ///
 /// </summary>
 public MaintenanceCheckRecordGroup(bool schedule, bool grouping, LifelengthSubResource resource, int numGroup)
     : this()
 {
     Schedule           = schedule;
     Grouping           = grouping;
     Resource           = resource;
     GroupComplianceNum = numGroup;
 }
Esempio n. 3
0
        /// <summary>
        /// Прибавляет заданную наработку к указанному параметру
        /// </summary>
        public void Add(LifelengthSubResource subResource, int source)
        {
            // прибавляем к this
            // null + cycles = cycles
            // cycles + null = cycles
            // null + null = null
            // cycles + cycles = cycles + cycles
            switch (subResource)
            {
            case LifelengthSubResource.Minutes:
                if (TotalMinutes == null)
                {
                    TotalMinutes = source;
                }
                else
                {
                    TotalMinutes += source;
                }
                break;

            case LifelengthSubResource.Hours:
                if (TotalMinutes == null)
                {
                    TotalMinutes = source * 60;
                }
                else
                {
                    TotalMinutes += source * 60;
                }
                break;

            case LifelengthSubResource.Cycles:
                if (Cycles == null)
                {
                    Cycles = source;
                }
                else
                {
                    Cycles += source;
                }
                break;

            case LifelengthSubResource.Calendar:
                if (Days == null)
                {
                    Days = source;
                }
                else
                {
                    Days += source;
                }
                break;

            default:
                break;
            }
        }
Esempio n. 4
0
 ///<summary>
 /// Выставляет параметры контрола
 ///</summary>
 ///<param name="programChecks">Чеки из которых будет составлена программа обслуживания</param>
 ///<param name="schedule">являются чеки плановыми, или это чеки по программе хранения</param>
 ///<param name="grouping">Указывает нужно ли группировать чеки по части порогового значения</param>
 ///<param name="subResource">Часть порогового значения, по которой будет выполнятся расчет и/или группировка чеков</param>
 public void SetParameters(IEnumerable <MaintenanceCheck> programChecks, bool schedule, bool grouping, LifelengthSubResource subResource)
 {
     _schedule        = schedule;
     _grouping        = grouping;
     _subResource     = subResource;
     _liminationItems =
         programChecks.Where(i => i.Schedule == _schedule && i.Grouping == _grouping)
         .OrderBy(i => i.Interval.GetSubresource(_subResource))
         .ToList();
     UpdateInformation();
 }
Esempio n. 5
0
        /*
         *  Методы
         */

        #region public MaintenanceCheck()

        public MaintenanceCheck()
        {
            _grouping           = true;
            _subResource        = LifelengthSubResource.Hours;
            SmartCoreObjectType = SmartCoreType.MaintenanceCheck;
            ItemId            = -1;
            Kits              = new CommonCollection <AccessoryRequired>();
            _threshold        = new MaintenanceCheckThreshold();
            _nextPerformances = new List <NextPerformance>();

            PrintInWorkPackage = true;
        }
        /// <summary>
        /// Возвращает дату самого последнего выполнения в данной коллекции групп чеков
        /// </summary>
        /// <returns></returns>
        public DateTime GetLastComplianceDateOfCheckWithHigherType(bool schedule, LifelengthSubResource subResource,
                                                                   bool grouping, MaintenanceCheckType checkType)
        {
            List <DateTime> dates =
                _checkGroupItems.SelectMany(item => item.Checks)
                .Where(c => c.Schedule == schedule &&
                       c.Resource == subResource &&
                       c.Grouping == grouping &&
                       c.CheckType.Priority > checkType.Priority)
                .SelectMany(c => c.PerformanceRecords)
                .Select(r => r.RecordDate)
                .OrderByDescending(d => d)
                .ToList();

            return(dates.Count > 0 ? dates.First() : DateTimeExtend.GetCASMinDateTime());
        }
Esempio n. 7
0
        ///<summary>
        ///</summary>
        ///<param name="maintenanceLiminationItems"></param>
        ///<param name="minCheckResource"></param>
        ///<param name="schedule">являются чеки плановыми, или это чеки по программе хранения</param>
        ///<param name="upperCheckTypeMinResource">минимльный ресурс вышестоящего типа чеков</param>
        ///<param name="grouping">Указывает нужно ли группировать чеки по части порогового значения</param>
        ///<param name="subResource">Часть порогового значения, по которой будет выполнятся расчет и/или группировка чеков</param>
        public MaintenanceProgramControlItem(List <MaintenanceCheck> maintenanceLiminationItems,
                                             int minCheckResource,
                                             bool schedule,
                                             bool grouping,
                                             LifelengthSubResource subResource,
                                             int upperCheckTypeMinResource) : this()
        {
            _maintenanceCheckItems = maintenanceLiminationItems;
            _minCheckResource      = minCheckResource;
            _schedule = schedule;
            _grouping = grouping;
            _upperCheckTypeMinResource = upperCheckTypeMinResource;
            _subResource = subResource;

            UpdateInformation();
        }
Esempio n. 8
0
        /// <summary>
        /// Возвращает последнюю выполненную группу чеков, чеки которой имеют заданные парамерты
        /// </summary>
        /// <param name="checks"></param>
        /// <param name="schedule">Чеки плановые или по программе хранения</param>
        /// <param name="aircraftId">Родительское ВС чеков</param>
        /// <param name="grouping">Чеки групповые или нет</param>
        /// <param name="resource">По какому из ресурсов (часы, циклы или календарь) группируются чеки</param>
        /// <param name="checkType">Тип чека (A B C D)</param>
        /// <returns></returns>
        public static MaintenanceCheckComplianceGroup GetLastComplianceCheckGroup(this ICommonCollection <MaintenanceCheck> checks,
                                                                                  bool schedule, int aircraftId,
                                                                                  bool grouping = true,
                                                                                  LifelengthSubResource resource = LifelengthSubResource.Hours,
                                                                                  MaintenanceCheckType checkType = null)
        {
            int last = 0;
            var aircraftScheduleChecks = checks.Where(c => c.Schedule == schedule &&
                                                      c.ParentAircraftId == aircraftId &&
                                                      c.Grouping == grouping &&
                                                      c.Resource == resource).ToList();

            if (checkType != null)
            {
                aircraftScheduleChecks = aircraftScheduleChecks.Where(c => c.CheckType == checkType).ToList();
            }

            foreach (MaintenanceCheck checkItem in aircraftScheduleChecks)
            {
                if (checkItem.LastPerformance != null && last < checkItem.LastPerformance.NumGroup)
                {
                    last = checkItem.LastPerformance.NumGroup;
                }
            }

            if (last <= 0)
            {
                return(null);
            }

            var lastComplianceGroup = new MaintenanceCheckComplianceGroup(schedule);

            foreach (MaintenanceCheck checkItem in aircraftScheduleChecks)
            {
                if (checkItem.LastPerformance != null && last == checkItem.LastPerformance.NumGroup)
                {
                    lastComplianceGroup.Checks.Add(checkItem);
                }
            }

            if (lastComplianceGroup.GetMaxIntervalCheck() == null)
            {
                return(null);
            }
            lastComplianceGroup.Sort();
            return(lastComplianceGroup);
        }
 /// <summary>
 /// Возвращает чек с минимальным интервалом
 /// </summary>
 public MaintenanceCheck GetMinStepCheck(bool schedule, bool grouping, LifelengthSubResource resource, MaintenanceCheckType mct = null)
 {
     if (mct != null)
     {
         List <MaintenanceCheck> list =
             (from check in Items
              where check.Schedule == schedule &&
              check.Grouping == grouping &&
              check.Resource == resource &&
              check.CheckType == mct
              orderby check.Interval.GetSubresource(resource)
              select check).ToList();
         return(list.FirstOrDefault());
     }
     else
     {
         List <MaintenanceCheck> list =
             (from check in Items
              where check.Schedule == schedule && check.Grouping == grouping && check.Resource == resource
              orderby check.Interval.GetSubresource(resource)
              select check).ToList();
         return(list.FirstOrDefault());
     }
 }
Esempio n. 10
0
        /// <summary>
        /// Возвращает значение, показывающее является ли значение элемента управления допустимым
        /// </summary>
        /// <returns></returns>
        private bool ValidateData(out string message)
        {
            message = "";
            if (_comboBoxCheckType.SelectedItem == null)
            {
                message = "Select check type";
                return(false);
            }

            if (comboBoxMainSource.SelectedItem == null ||
                !(comboBoxMainSource.SelectedItem is LifelengthSubResource))
            {
                message = "Not set main source";
                return(false);
            }

            LifelengthSubResource sub = (LifelengthSubResource)comboBoxMainSource.SelectedItem;

            int?subSource = _lifelengthViewerInterval.Lifelength.GetSubresource(sub);

            if (subSource == null || subSource == 0)
            {
                message = "Enter correct interval." +
                          "\n" + sub + " must be > 0.";
                return(false);
            }

            #region проверка на кратность интервала
            if (checkBoxGrouping.Checked)
            {
                //(для групповых чеков)

                //поиск минимального чека по заданному типу программы обслуживания
                MaintenanceCheck mc = _allMaintenanceChecks.GetMinStepCheck(checkBoxSchedule.Checked, checkBoxGrouping.Checked, sub);
                //если минимальный чек есть, то производится проверка на кратность интервала
                if (mc != null && mc.ItemId != _maintenanceLiminationItem.ItemId)
                {
                    int?minStep = mc.Interval.GetSubresource(sub);
                    if (minStep == null || minStep < 0)
                    {
                        return(true);
                    }
                    if (subSource > minStep && (subSource.Value % minStep.Value) > 0)
                    {
                        //интервал редактируемого чека больше интервала минимального чека
                        message = "interval of check must be a multiple of " + minStep.Value;
                        return(false);
                    }
                    if (subSource < minStep && (minStep.Value % subSource.Value) > 0)
                    {
                        //интервал редактируемого чека меньше интервала минимального чека
                        message = "interval of check must be a fraction of " + minStep.Value;
                        return(false);
                    }
                }
                //если минимального чека нет, то интевал редактируемого чека и будет минимальным
            }
            #endregion

            #region Проверка корректности данных, зависящих от выполнения другого чека
            //if (checkBoxDependet.Checked)
            //{
            //    if(comboBoxWhickDependetChecks.SelectedItem == null)
            //    {
            //        message = "Not set check, which depends current check";
            //        return false;
            //    }
            //    if (comboBoxDependedSource.SelectedItem == null)
            //    {
            //        message = "Not set depended source";
            //        return false;
            //    }
            //    if (comboBoxMainSource.SelectedItem == null)
            //    {
            //        message = "Not set main source";
            //        return false;
            //    }

            //    LifelengthSubResource depends =
            //        (LifelengthSubResource)comboBoxDependedSource.SelectedItem;
            //    LifelengthSubResource main =
            //        (LifelengthSubResource) comboBoxMainSource.SelectedItem;
            //    if(depends == main)
            //    {
            //        message = "Main and Dependent resources should not be equal";
            //        return false;
            //    }

            //    MaintenanceCheck wdmc = (MaintenanceCheck) comboBoxWhickDependetChecks.SelectedItem;
            //    int? whichDepends = wdmc.Interval.GetSubresource(depends);

            //    if (whichDepends == null || whichDepends == 0)
            //    {
            //        message = "In check, on which depends the execution of the check is not specified dependent resources";
            //        return false;
            //    }
            //}
            #endregion

            return(true);
        }
Esempio n. 11
0
 /// <summary>
 ///
 /// </summary>
 public MaintenanceCheckRecordGroup(bool schedule, bool grouping, LifelengthSubResource resource) : this()
 {
     Schedule = schedule;
     Grouping = grouping;
     Resource = resource;
 }