コード例 #1
0
        /// <summary>
        /// Находит синхронизированную работу из пространства Рабочие планы двигаясь вверх по дереву от указанной работы
        /// </summary>
        /// <param name="work"></param>
        /// <returns>работа из пространства Рабочие планы, если не найдена то null</returns>
        private ProjectManagementWork GetTheWorkFromWorkingPlanningSpace(ProjectManagementWork work)
        {
            ProjectManagementWork result = null;

            if (work == null)
            {
                return(result);
            }
            //MacroContext mc = new MacroContext(ServerGateway.Connection);
            // MessageBox.Show(work.ToString());
            if (work.PlanningSpace.ToString() == PlanningSpaceGuidString.WorkingPlans)
            {
                //MessageBox.Show("work from PlanningSpaceGuidString" + work.ToString());
                return(work);
            }
            else
            {
                foreach (var item in Synchronization.GetSynchronizedWorks(work, PlanningSpaceGuidString.WorkingPlans, null))
                {
                    while (result == null)
                    {
                        result = GetTheWorkFromWorkingPlanningSpace(item);
                    }
                }
            }
            if (result == null && work.ParentWork != null)
            {
                result = GetTheWorkFromWorkingPlanningSpace(work.ParentWork);
            }
            return(result);
        }
コード例 #2
0
        //public static dynamic Create_OfficialNote(ReferenceObject referenceObject)
        //{
        //    var officialNoteBase = TryGetFromCache(referenceObject);
        //    if (officialNoteBase != null) return officialNoteBase;
        //    //MessageBox.Show("CreateNew" + List_OfficialNotes_Cache.Count.ToString());
        //    if (referenceObject.Class.Guid.ToString() == OfficialNoteClassStringGuids.SimpleOfficialNoteGuidString)
        //    {
        //        var result = new OfficialNote(referenceObject);
        //        List_OfficialNotes_Cache.Add(result);
        //        //MessageBox.Show("OfficialNote" + List_OfficialNotes_Cache.Count.ToString());
        //        return result;
        //    }
        //    else if (referenceObject.Class.Guid.ToString() == OfficialNoteClassStringGuids.OfficialNoteForProjectCorrectionGuidString)
        //    {
        //        var result = new OfficialNoteForProjectCorrection(referenceObject);
        //        List_OfficialNotes_Cache.Add(result);
        //        //MessageBox.Show("OfficialNoteForProjectCorrection" + List_OfficialNotes_Cache.Count.ToString());
        //        return result;
        //    }
        //    else if (referenceObject.Class.Guid.ToString() == OfficialNoteClassStringGuids.OfficialNoteOverTimeGuidString)
        //    {
        //        var result = new OfficialNoteOvertime(referenceObject);
        //        List_OfficialNotes_Cache.Add(result);
        //        //MessageBox.Show("OfficialNoteOvertime" + List_OfficialNotes_Cache.Count.ToString());
        //        return result;
        //    }
        //    else if (referenceObject.Class.Guid.ToString() == OfficialNoteClassStringGuids.OfficialNoteProcurementGuidString)
        //    {
        //        var result = new OfficialNoteProcurement(referenceObject);
        //        List_OfficialNotes_Cache.Add(result);
        //        //MessageBox.Show("OfficialNoteProcurement" + List_OfficialNotes_Cache.Count.ToString());
        //        return result;
        //    }
        //    //MessageBox.Show("Exception");
        //    throw new Exception("Объект не является допустимой Служебной запиской");
        //    //return null;
        //}

        public static dynamic Create_ProjectManagementWork(ReferenceObject referenceObject)
        {
            ProjectManagementWork projectManagementWork = TryGetFromCache_ProjectManagementWork(referenceObject);

            if (projectManagementWork == null)
            {
                projectManagementWork = new ProjectManagementWork(referenceObject);
                List_ProjectManagementWorks_Cache.Add(projectManagementWork);
            }
            return(projectManagementWork);
        }
コード例 #3
0
        //создаём синхронизацию
        public static void SyncronizeWorks(ProjectManagementWork masterWork, ProjectManagementWork slaveWork)
        {
            ReferenceObject синхронизация = ProjectDependenciesReference.CreateReferenceObject(Class_ProjectDependency);

            синхронизация[SynchronizationParameterGuids.param_DependencyType_Guid].Value = 5;// DependencyType.Synchronization;
            синхронизация[SynchronizationParameterGuids.param_MasterWork_Guid].Value     = masterWork.Guid;
            синхронизация[SynchronizationParameterGuids.param_SlaveWork_Guid].Value      = slaveWork.Guid;
            синхронизация[SynchronizationParameterGuids.param_MasterProject_Guid].Value  = masterWork.Project.Guid;
            синхронизация[SynchronizationParameterGuids.param_SlaveProject_Guid].Value   = slaveWork.Project.Guid;
            синхронизация.EndChanges();
            //return синхронизация;
        }
コード例 #4
0
 private ProjectManagementWork GetTheParentProjectFrom1C(ProjectManagementWork work)
 {
     if (work.IsProjectFrom1C)
     {
         return(work);
     }
     //if (planningSpaceWork.Class.Guid == PM_class_Project_Guid) return planningSpaceWork;
     if (work.ParentWork == null)
     {
         return(null);
     }
     return(GetTheParentProjectFrom1C(work.ParentWork));
 }
コード例 #5
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();
            }
        }
コード例 #6
0
 ProjectManagementWork GetTheProject(ProjectManagementWork work)
 {
     //MessageBox.Show("GetTheProject\n" + work.ToString() + "\n" + work.Class.Guid.ToString() + "\n" + PM_class_Project_Guid.ToString());
     if (work.IsProject)
     {
         return(work);
     }
     if (work.ParentWork == null)
     {
         //MessageBox.Show("work.Parent == null");
         return(work);
     }
     //MessageBox.Show("work.Parent == " + work.Parent.ToString());
     return(GetTheProject(work.ParentWork));
 }
コード例 #7
0
        internal EditReasonNote(ProjectManagementWork work, string editType, string reason, bool needManagerAction = false)
        {
            //#if test
            //            MessageBox.Show("referenceInfo - " + EditReasonNote.ReferenceInfo.ToString());
            //            MessageBox.Show("Reference - " + Reference.ToString());
            //            MessageBox.Show("classObject - " + classObject.ToString());
            //#endif
            ReferenceObject newObject = Reference.CreateReferenceObject(classObject);// создание

            // Параметр "Тип редактирования"
            int editTypeCode = Array.IndexOf(TypeNames, editType);

            newObject[EditReasonNote.ERN_param_EditType_Guid].Value          = editTypeCode;
            newObject[EditReasonNote.ERN_param_Reason_Guid].Value            = reason;
            newObject[EditReasonNote.ERN_param_NeedActionManager_Guid].Value = needManagerAction;
            newObject.SetLinkedObject(EditReasonNote.ERN_link_ToPrjctMgmntN1_Guid, work.ReferenceObject);
            newObject.EndChanges();
            this.ReferenceObject = newObject;
        }
コード例 #8
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);
        }
コード例 #9
0
        private static ProjectManagementWork TryGetFromCache_ProjectManagementWork(ReferenceObject referenceObject)
        {
            var listFoundedDobject = List_ProjectManagementWorks_Cache.Where(on => on.ReferenceObject.SystemFields.Id == referenceObject.SystemFields.Id);

            if (listFoundedDobject == null)
            {
                return(null);
            }
            ProjectManagementWork currentVersion = null;

            foreach (var item in listFoundedDobject)
            {
                if (referenceObject.SystemFields.EditDate != item.LastEditDate)
                {
                    List_ProjectManagementWorks_Cache.Remove(item);
                }
                else
                {
                    currentVersion = item;
                }
            }
            return(currentVersion);
        }
コード例 #10
0
 /// <summary>
 /// Находит кубик из 1С, если не получилось то null
 /// </summary>
 /// <param name="planningSpaceWork"></param>
 /// <returns>кубик из 1С, если не получилось то null</returns>
 private ProjectManagementWork GetTheProjectFrom1C(ProjectManagementWork planningSpaceWork)
 {
     //MessageBox.Show("GetTheProjectFrom1C" + planningSpaceWork.PlanningSpace.ToString() + "\nIsProjectFrom1C = " + planningSpaceWork.IsProjectFrom1C.ToString()+"\n" + planningSpaceWork.Name);
     if (planningSpaceWork.PlanningSpace.ToString() != PlanningSpaceGuidString.WorkingPlans)
     {
         //MessageBox.Show(planningSpaceWork.PlanningSpace.ToString() + " != " + PlanningSpaceGuidString.WorkingPlans);
         planningSpaceWork = GetTheWorkFromWorkingPlanningSpace(planningSpaceWork);
     }
     else
     {
         if (planningSpaceWork.IsProjectFrom1C)
         {
             return(planningSpaceWork);
         }
     }
     //if (planningSpaceWork.Class.Guid == PM_class_Project_Guid) return planningSpaceWork;
     if (planningSpaceWork == null)
     {
         //MessageBox.Show("planningSpaceWork == null");
         return(null);
     }
     //MessageBox.Show("GetTheParentProjectFrom1C" + planningSpaceWork.PlanningSpace.ToString() + planningSpaceWork.Name);
     return(GetTheParentProjectFrom1C(planningSpaceWork));
 }
コード例 #11
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);
        }