Пример #1
0
        private static MaintenanceCheckGroupCollection GetCheckByGroupNum(List <MaintenanceCheckGroupByType> groupChecks, int num, int?minStep, bool schedule)
        {
            if (minStep == null || groupChecks == null)
            {
                return(null);
            }

            int tableInterval = num * minStep.Value;
            MaintenanceCheckGroupCollection groupCollection = new MaintenanceCheckGroupCollection();

            foreach (MaintenanceCheckGroupByType groupCheck in groupChecks)
            {
                int localInterval = tableInterval;
                if (groupCheck.CheckCycle <= tableInterval)
                {
                    localInterval = tableInterval % groupCheck.CheckCycle;
                    if (localInterval == 0)
                    {
                        //если локальный интервал равен нулю
                        //то программа обслуживания находится на
                        //границе выполнения данного типа чеков (н: всех чеков А)
                        //Поэтому в след. группу выполнения надо включить все чеки
                        //данного типа.
                        //На след. шаге к данной группе должен быть добавлен хотя бы один чек вышестоящего типа
                        //(н: B или C)
                        foreach (MaintenanceCheck check in groupCheck.Checks)
                        {
                            check.Tag = num;
                            groupCollection.Add(check, num);
                        }
                    }
                }
                if (localInterval == 0)
                {
                    continue;
                }
                foreach (MaintenanceCheck check in groupCheck.Checks)
                {
                    check.Tag = num;
                    if (schedule)
                    {
                        if (localInterval % check.Interval.Hours == 0)
                        {
                            groupCollection.Add(check, num);
                        }
                    }
                    else
                    {
                        if (localInterval % check.Interval.Days == 0)
                        {
                            groupCollection.Add(check, num);
                        }
                    }
                }
            }
            return(groupCollection);
        }
Пример #2
0
        private static MaintenanceCheckGroupCollection GetCheckBySource(List <MaintenanceCheckGroupByType> groupChecks, int?lifeLenghtResource, int?minStep, bool schedule)
        {
            if (lifeLenghtResource == null ||
                lifeLenghtResource == 0 ||
                groupChecks == null ||
                minStep == null)
            {
                return(null);
            }

            if (lifeLenghtResource < minStep)
            {
                lifeLenghtResource = minStep;
            }

            int tableInterval = lifeLenghtResource.Value;
            int intervalGroupNum;
            MaintenanceCheckGroupCollection groupCollection = new MaintenanceCheckGroupCollection();

            foreach (MaintenanceCheckGroupByType groupCheck in groupChecks)
            {
                int localInterval = tableInterval;
                if (groupCheck.CheckCycle <= tableInterval)
                {
                    localInterval    = tableInterval % groupCheck.CheckCycle;
                    intervalGroupNum = (lifeLenghtResource.Value - (lifeLenghtResource.Value % groupCheck.CheckCycle)) / minStep.Value;

                    foreach (MaintenanceCheck check in groupCheck.Checks)
                    {
                        check.ComplianceGroupNum = intervalGroupNum;
                        groupCollection.Add(check, check.ComplianceGroupNum);
                    }
                }
                if (localInterval == 0)
                {
                    continue;
                }
                if (schedule)
                {
                    //взятие всех чеков, интервал выполнения которых, меньше заданной наработки
                    List <MaintenanceCheck> checks = (from check in groupCheck.Checks
                                                      where
                                                      check.Interval.Hours <= localInterval
                                                      orderby check.Interval.Hours ascending
                                                      select check).ToList();
                    //если таковые чеки есть, то минусуется интервал их выполнения от текущей нарабтки
                    //возвращая таким образом остаток
                    if (checks.Count != 0)
                    {
                        intervalGroupNum = (lifeLenghtResource.Value - (lifeLenghtResource.Value % checks[0].Interval.Hours.Value)) / minStep.Value;
                        int groupNum;
                        foreach (MaintenanceCheck maintenanceCheck in checks)
                        {
                            groupNum = (lifeLenghtResource.Value - (lifeLenghtResource.Value % maintenanceCheck.Interval.Hours.Value)) / minStep.Value;
                            if (groupNum == intervalGroupNum)
                            {
                                maintenanceCheck.ComplianceGroupNum = intervalGroupNum;
                                groupCollection.Add(maintenanceCheck, maintenanceCheck.ComplianceGroupNum);
                            }
                        }
                    }
                }
                else
                {
                    //взятие всех чеков, интервал выполнения которых, меньше заданной наработки
                    List <MaintenanceCheck> checks = (from check in groupCheck.Checks
                                                      where
                                                      check.Interval.Days <= localInterval
                                                      orderby check.Interval.Days ascending
                                                      select check).ToList();
                    //если таковые чеки есть, то минусуется интервал их выполнения от ткеущей нарабтки
                    //возвращая таким образом остаток
                    if (checks.Count != 0)
                    {
                        intervalGroupNum = (lifeLenghtResource.Value - (lifeLenghtResource.Value % checks[0].Interval.Days.Value)) / minStep.Value;
                        int groupNum = 0;
                        foreach (MaintenanceCheck maintenanceCheck in checks)
                        {
                            if (maintenanceCheck.Interval.Days != null)
                            {
                                groupNum = (lifeLenghtResource.Value - (lifeLenghtResource.Value % maintenanceCheck.Interval.Days.Value)) / minStep.Value;
                            }
                            if (groupNum == intervalGroupNum)
                            {
                                maintenanceCheck.ComplianceGroupNum = intervalGroupNum;
                                groupCollection.Add(maintenanceCheck, maintenanceCheck.ComplianceGroupNum);
                            }
                        }
                    }
                }
            }
            return(groupCollection);
        }
Пример #3
0
        /// <summary>
        /// Сортирует чеки по интервалу выполнения в зависимости от свойства Schedule,
        /// группирует по MaintenanceCheckType (A, B, C, D, etc),
        /// и проставляет связи между группами по приоритету MaintenanceCheckType
        /// </summary>
        public static MaintenanceCheckGroupCollection[] GroupingCheckByType(this ICommonCollection <MaintenanceCheck> maintenanceChecks, bool schedule,
                                                                            bool?grouping = null, LifelengthSubResource?resource = null)
        {
            //Фильтрация чеков по Schedule и упорядочивание по приоритету и группировка по названию типа
            IEnumerable <MaintenanceCheck> preFilteredChecks = maintenanceChecks.Where(c => c.Schedule == schedule);

            if (grouping != null)
            {
                preFilteredChecks = preFilteredChecks.Where(c => c.Grouping == grouping);
            }
            if (resource != null)
            {
                preFilteredChecks = preFilteredChecks.Where(c => c.Resource == resource);
            }
            IEnumerable <IGrouping <MaintenanceCheckType, MaintenanceCheck> > filteredBySchedule =
                preFilteredChecks.OrderBy(c => c.CheckType.Priority)
                .GroupBy(c => c.CheckType);
            //Формирование групп чеков по типам (A,B,C) с дополнительными критериями
            //1. Плановый чек/чек по хранению
            //2. Групповой/Одиночный
            //3. Основной ресурс (Часы/Циклы/Дни)
            List <MaintenanceCheckGroupCollection> checkGroupsCollections = new List <MaintenanceCheckGroupCollection>();

            foreach (IGrouping <MaintenanceCheckType, MaintenanceCheck> checks in filteredBySchedule)
            {
                foreach (MaintenanceCheck check in checks)
                {
                    //Поиск коллекции групп, в которую входят группы с нужными критериями
                    //по плану, группировка и основному ресурсу
                    MaintenanceCheckGroupCollection collection = checkGroupsCollections
                                                                 .FirstOrDefault(g => g.Schedule == check.Schedule &&
                                                                                 g.Grouping == check.Grouping &&
                                                                                 g.Resource == check.Resource);
                    if (collection != null)
                    {
                        //Коллекция найдена
                        //Поиск в ней группы чеков с нужным типом
                        MaintenanceCheckGroupByType groupByType = collection.FirstOrDefault(g => g.CheckType == check.CheckType);
                        if (groupByType != null)
                        {
                            groupByType.Checks.Add(check);
                        }
                        else
                        {
                            //Группы с нужным типом нет
                            //Инициализация и добавление
                            groupByType = new MaintenanceCheckGroupByType(check.Schedule)
                            {
                                Grouping  = check.Grouping,
                                Resource  = check.Resource,
                                CheckType = check.CheckType,
                            };
                            groupByType.Checks.Add(check);
                            collection.Add(groupByType);
                        }
                    }
                    else
                    {
                        //Коллекции с нужными критериями нет
                        //Созадние и добавление
                        collection = new MaintenanceCheckGroupCollection
                        {
                            Schedule = check.Schedule,
                            Grouping = check.Grouping,
                            Resource = check.Resource,
                        };
                        MaintenanceCheckGroupByType groupByType = new MaintenanceCheckGroupByType(check.Schedule)
                        {
                            Grouping  = check.Grouping,
                            Resource  = check.Resource,
                            CheckType = check.CheckType,
                        };
                        groupByType.Checks.Add(check);
                        collection.Add(groupByType);
                        checkGroupsCollections.Add(collection);
                    }
                }
            }
            //Упорядочивание каждой группы по ресурсам выполнения и проставление связей между ними
            foreach (MaintenanceCheckGroupCollection collection in checkGroupsCollections)
            {
                foreach (MaintenanceCheckGroupByType groupByType in collection)
                {
                    groupByType.Sort();

                    MaintenanceCheckGroupByType last =
                        collection.LastOrDefault(gbt => gbt.CheckType.Priority < groupByType.CheckType.Priority);
                    if (last != null)
                    {
                        last.ParentGroup = groupByType;
                        last.CheckCycle  = groupByType.MinIntervalByResource();
                    }

                    groupByType.ParentGroup = null;
                    groupByType.CheckCycle  = groupByType.MaxIntervalByResource();
                }
            }
            return(checkGroupsCollections.ToArray());
        }