示例#1
0
        /// <summary>
        /// Удаляет синхронизацию между указанными работами
        /// </summary>
        /// <param name="masterWork"></param>
        /// <param name="slaveWork"></param>
        public static void DeleteSynchronisationBetween(ProjectManagementWork masterWork, ProjectManagementWork slaveWork)
        {
            Filter filter = new Filter(ProjectDependenciesReferenceInfo);

            AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_DependencyType_Guid, 5, (int)LogicalOperator.And);

            // Условие: в названии содержится "является укрупнением"
            string masterWorkGuidStringForSearch = masterWork.Guid.ToString();

            // Условие: в названии содержится "является детализацией"
            string slaveWorkGuidStringForSearch = slaveWork.Guid.ToString();

            ReferenceObjectTerm termSlaveWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_SlaveWork_Guid,
                                                                     slaveWorkGuidStringForSearch, (int)LogicalOperator.And);

            //Получаем список объектов, в качестве условия поиска – сформированный фильтр
            List <ReferenceObject> listObj = ProjectDependenciesReference.Find(filter);

            //#if test
            //            MessageBox.Show(filter.ToString() + "\nlistObj.Count = " + listObj.Count.ToString());
            //#endif
            foreach (var item in listObj) // удаляем всё что нашли
            {
                item.Delete();
            }
        }
示例#2
0
        public static List <ReferenceObject> GetDependenciesObjects(bool?returnOnlyMasterWorks, string guidStringForSearch)
        {
            Filter filter = new Filter(ProjectDependenciesReferenceInfo);

            AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_DependencyType_Guid, 5, (int)LogicalOperator.And);

            // Условие: в названии содержится "является укрупнением"
            //ReferenceObjectTerm termMasterWork = new ReferenceObjectTerm(LogicalOperator.Or);

            ReferenceObjectTerm termMasterWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_MasterWork_Guid, guidStringForSearch);

            // Условие: в названии содержится "является детализацией"
            ReferenceObjectTerm termSlaveWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_SlaveWork_Guid,
                                                                     guidStringForSearch, (int)LogicalOperator.Or);

            // Группируем условия в отдельную группу (другими словами добавляем скобки)
            TermGroup group1 = filter.Terms.GroupTerms(new Term[] { termMasterWork, termSlaveWork });

            //редактируем при необходимости
            if (returnOnlyMasterWorks != null)
            {
                if (!(bool)returnOnlyMasterWorks)
                {
                    group1.Remove(termSlaveWork);
                }
                else
                {
                    group1.Remove(termMasterWork);
                }
            }

            return(ProjectDependenciesReference.Find(filter));
        }
示例#3
0
        /// <summary>
        /// Возвращает список синхронизированных работ из указанного пространства планирования
        /// </summary>
        /// <param name="work"></param>
        /// <param name="planningSpaceGuidString"></param>
        /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
        /// <returns></returns>
        public static List <ProjectManagementWork> GetSynchronizedWorksInProject(ProjectManagementWork work, ProjectManagementWork project,
                                                                                 bool?returnOnlyMasterWorks = null)
        {
            string guidWorkForSearch    = work.Guid.ToString();
            string guidProjectForSearch = project.Guid.ToString();

            Filter filter = new Filter(ProjectDependenciesReferenceInfo);

            AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_DependencyType_Guid, 5, (int)LogicalOperator.And);
            // Условие: в названии содержится "является укрупнением"
            //ReferenceObjectTerm termMasterWork = new ReferenceObjectTerm(LogicalOperator.Or);
            ReferenceObjectTerm termMasterWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_MasterWork_Guid, guidWorkForSearch);

            ReferenceObjectTerm termSlaveProjectWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_SlaveProject_Guid,
                                                                            guidProjectForSearch, (int)LogicalOperator.And);

            // Условие: в названии содержится "является детализацией"
            ReferenceObjectTerm termSlaveWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_SlaveWork_Guid,
                                                                     guidWorkForSearch, (int)LogicalOperator.Or);

            ReferenceObjectTerm termMasterProjectWork = AddTermByGuidParamPE(ref filter, SynchronizationParameterGuids.param_MasterProject_Guid,
                                                                             guidProjectForSearch, (int)LogicalOperator.And);

            // Группируем условия в отдельную группу (другими словами добавляем скобки)
            TermGroup group1 = filter.Terms.GroupTerms(new Term[] { termMasterWork, termSlaveProjectWork });
            TermGroup group2 = filter.Terms.GroupTerms(new Term[] { termSlaveWork, termMasterProjectWork });

            //редактируем при необходимости
            if (returnOnlyMasterWorks != null)
            {
                if ((bool)returnOnlyMasterWorks)
                {
                    group1.Clear();
                }
                else
                {
                    group2.Clear();
                }
            }

            //Получаем список объектов, в качестве условия поиска – сформированный фильтр
            List <ReferenceObject> DependencyObjects = ProjectDependenciesReference.Find(filter);

            List <ProjectManagementWork> result = new List <ProjectManagementWork>();

            foreach (var item in getListGuidObjectsByFilter(DependencyObjects, work))
            {
                ProjectManagementWork tempWork = new ProjectManagementWork(item);
                result.Add(new ProjectManagementWork(item));
            }
            return(result);
        }
示例#4
0
        /// <summary>
        /// Удаляет синхронизацию между указанными работами
        /// </summary>
        /// <param name="masterWork"></param>
        /// <param name="slaveWork"></param>
        public static void DeleteSynchronisationBetween(ProjectManagementWork masterWork, ProjectManagementWork slaveWork)
        {
            Filter filter = new Filter(ProjectDependenciesReferenceInfo);
            // Условие: тип зависимости "синхронизация"
            ReferenceObjectTerm termSyncType = new ReferenceObjectTerm(filter.Terms, LogicalOperator.And);

            // устанавливаем параметр
            termSyncType.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_DependencyType_Guid));
            // устанавливаем оператор сравнения
            termSyncType.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termSyncType.Value = 5;

            // Условие: в названии содержится "является укрупнением"
            string masterWorkGuidStringForSearch = masterWork.Guid.ToString();

            ReferenceObjectTerm termMasterWork = new ReferenceObjectTerm(filter.Terms);

            // устанавливаем параметр
            termMasterWork.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_MasterWork_Guid));
            // устанавливаем оператор сравнения
            termMasterWork.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termMasterWork.Value = masterWorkGuidStringForSearch;

            // Условие: в названии содержится "является детализацией"
            string slaveWorkGuidStringForSearch = slaveWork.Guid.ToString();
            ReferenceObjectTerm termSlaveWork   = new ReferenceObjectTerm(filter.Terms, LogicalOperator.And);

            //ReferenceObjectTerm term1 = new ReferenceObjectTerm(filter.Terms, LogicalOperator.Or);
            // устанавливаем параметр
            termSlaveWork.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_SlaveWork_Guid));
            // устанавливаем оператор сравнения
            termSlaveWork.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termSlaveWork.Value = slaveWorkGuidStringForSearch;


            //Получаем список объектов, в качестве условия поиска – сформированный фильтр
            List <ReferenceObject> listObj = ProjectDependenciesReference.Find(filter);

            //#if test
            //            MessageBox.Show(filter.ToString() + "\nlistObj.Count = " + listObj.Count.ToString());
            //#endif
            foreach (var item in listObj) // удаляем всё что нашли
            {
                item.Delete();
            }
        }
示例#5
0
        /// <summary>
        /// Возвращает список синхронизированных работ из указанного пространства планирования
        /// </summary>
        /// <param name="work"></param>
        /// <param name="planningSpaceGuidString"></param>
        /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
        /// <returns></returns>
        public static List <ProjectManagementWork> GetSynchronizedWorks(ProjectManagementWork work, string planningSpaceGuidString, bool?returnOnlyMasterWorks)
        {
            string guidStringForSearch = work.Guid.ToString();
            Filter filter = GetFilter(returnOnlyMasterWorks, guidStringForSearch);

            //Получаем список объектов, в качестве условия поиска – сформированный фильтр
            List <ReferenceObject> listObj           = ProjectDependenciesReference.Find(filter);
            List <Guid>            listSyncWorkGuids = new List <Guid>();

            //#if test
            //            MessageBox.Show(filter.ToString() + "\nlistObj.Count = " + listObj.Count.ToString());
            //#endif
            foreach (var item in listObj) // выбираем все отличные от исходной работы guids
            {
                Guid slaveGuid  = item[SynchronizationParameterGuids.param_SlaveWork_Guid].GetGuid();
                Guid masterGuid = item[SynchronizationParameterGuids.param_MasterWork_Guid].GetGuid();
                if (slaveGuid != work.Guid)
                {
                    listSyncWorkGuids.Add(slaveGuid);
                }
                if (masterGuid != work.Guid)
                {
                    listSyncWorkGuids.Add(masterGuid);
                }
            }
            listSyncWorkGuids = listSyncWorkGuids.Distinct().ToList();
            List <ProjectManagementWork> result = new List <ProjectManagementWork>();
            bool isNeedToFilterByPlanningSpace  = !string.IsNullOrWhiteSpace(planningSpaceGuidString);

            foreach (var item in listSyncWorkGuids)
            {
                ProjectManagementWork tempWork = new ProjectManagementWork(item);
                if (isNeedToFilterByPlanningSpace && tempWork.PlanningSpace.ToString() != planningSpaceGuidString)
                {
                    continue;
                }
                result.Add(new ProjectManagementWork(item));
            }
            return(result);
        }
示例#6
0
        /// <summary>
        /// Возвращает список синхронизированных работ из указанного пространства планирования
        /// </summary>
        /// <param name="work"></param>
        /// <param name="planningSpaceGuidString"></param>
        /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
        /// <returns></returns>
        public static List <ProjectManagementWork> GetSynchronizedWorksInProject(ProjectManagementWork work, ProjectManagementWork project, bool?returnOnlyMasterWorks = null)
        {
            string guidWorkForSearch    = work.Guid.ToString();
            string guidProjectForSearch = project.Guid.ToString();
            Filter filter = new Filter(ProjectDependenciesReferenceInfo);
            // Условие: тип зависимости "синхронизация"
            ReferenceObjectTerm termSyncType = new ReferenceObjectTerm(filter.Terms, LogicalOperator.And);

            // устанавливаем параметр
            termSyncType.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_DependencyType_Guid));
            // устанавливаем оператор сравнения
            termSyncType.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termSyncType.Value = 5;// DependencyType.Synchronization;

            // Условие: в названии содержится "является укрупнением"
            //ReferenceObjectTerm termMasterWork = new ReferenceObjectTerm(LogicalOperator.Or);

            ReferenceObjectTerm termMasterWork = new ReferenceObjectTerm(filter.Terms);

            // устанавливаем параметр
            termMasterWork.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_MasterWork_Guid));
            // устанавливаем оператор сравнения
            termMasterWork.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termMasterWork.Value = guidWorkForSearch;

            ReferenceObjectTerm termSlaveProjectWork = new ReferenceObjectTerm(filter.Terms, LogicalOperator.And);

            // устанавливаем параметр
            termSlaveProjectWork.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_SlaveProject_Guid));
            // устанавливаем оператор сравнения
            termSlaveProjectWork.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termSlaveProjectWork.Value = guidProjectForSearch;

            // Условие: в названии содержится "является детализацией"
            ReferenceObjectTerm termSlaveWork = new ReferenceObjectTerm(filter.Terms, LogicalOperator.Or);

            //ReferenceObjectTerm term1 = new ReferenceObjectTerm(filter.Terms, LogicalOperator.Or);
            // устанавливаем параметр
            termSlaveWork.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_SlaveWork_Guid));
            // устанавливаем оператор сравнения
            termSlaveWork.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termSlaveWork.Value = guidWorkForSearch;

            ReferenceObjectTerm termMasterProjectWork = new ReferenceObjectTerm(filter.Terms, LogicalOperator.And);

            // устанавливаем параметр
            termMasterProjectWork.Path.AddParameter(ProjectDependenciesReference.ParameterGroup.OneToOneParameters.Find(SynchronizationParameterGuids.param_MasterProject_Guid));
            // устанавливаем оператор сравнения
            termMasterProjectWork.Operator = ComparisonOperator.Equal;
            // устанавливаем значение для оператора сравнения
            termMasterProjectWork.Value = guidProjectForSearch;

            // Группируем условия в отдельную группу (другими словами добавляем скобки)
            TermGroup group1 = filter.Terms.GroupTerms(new Term[] { termMasterWork, termSlaveProjectWork });
            TermGroup group2 = filter.Terms.GroupTerms(new Term[] { termSlaveWork, termMasterProjectWork });

            //редактируем при необходимости
            if (returnOnlyMasterWorks != null)
            {
                if ((bool)returnOnlyMasterWorks)
                {
                    group1.Clear();
                }
                else
                {
                    group2.Clear();
                }
            }

            //Получаем список объектов, в качестве условия поиска – сформированный фильтр
            List <ReferenceObject> listObj           = ProjectDependenciesReference.Find(filter);
            List <Guid>            listSyncWorkGuids = new List <Guid>();

            //#if test
            //            System.Windows.Forms.MessageBox.Show(filter.ToString() + "\nlistObj.Count = " + listObj.Count.ToString());
            //#endif
            foreach (var item in listObj) // выбираем все отличные от исходной работы guids
            {
                Guid slaveGuid  = item[SynchronizationParameterGuids.param_SlaveWork_Guid].GetGuid();
                Guid masterGuid = item[SynchronizationParameterGuids.param_MasterWork_Guid].GetGuid();
                if (slaveGuid != work.Guid)
                {
                    listSyncWorkGuids.Add(slaveGuid);
                }
                if (masterGuid != work.Guid)
                {
                    listSyncWorkGuids.Add(masterGuid);
                }
            }
            listSyncWorkGuids = listSyncWorkGuids.Distinct().ToList();
            List <ProjectManagementWork> result = new List <ProjectManagementWork>();

            foreach (var item in listSyncWorkGuids)
            {
                ProjectManagementWork tempWork = new ProjectManagementWork(item);
                result.Add(new ProjectManagementWork(item));
            }
            return(result);
        }