コード例 #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
        /// <summary>
        /// Use GetSyncronizedWorks
        /// Возвращает список синхронизированных работ из указанного пространства планирования
        /// </summary>
        /// <param name="work"></param>
        /// <param name="planningSpaceGuidString"></param>
        /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
        /// <returns></returns>
        public static List <ReferenceObject> GetSynchronizedWorksFromSpace(ReferenceObject work,
                                                                           string planningSpaceGuidString, bool?returnOnlyMasterWorks = null)
        {
            if (string.IsNullOrEmpty(planningSpaceGuidString))
            {
                planningSpaceGuidString = Guid.Empty.ToString();
            }

            string guidStringForSearch = work.SystemFields.Guid.ToString();
            List <ReferenceObject> DependenciesObjects = GetDependenciesObjects(returnOnlyMasterWorks, guidStringForSearch);

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

            foreach (var guidPE in getListGuidObjectsByFilter(DependenciesObjects, work))
            {
                var PE = References.ProjectManagementReference.Find(guidPE);

                if (PE == null)
                {
                    continue;
                }

                ProjectManagementWork tempWork = new ProjectManagementWork(PE);

                if (tempWork.PlanningSpace.ToString() == planningSpaceGuidString)
                {
                    result.Add(References.ProjectManagementReference.Find(guidPE));
                }
            }
            return(result);
        }
コード例 #3
0
        private static ProjectManagementWork TryGetFromCache_ProjectManagementWork(ReferenceObject referenceObject)
        {
            List <ProjectManagementWork> listFoundedObject = new List <ProjectManagementWork>();

            foreach (var item in List_ProjectManagementWorks_Cache)
            {
                if (item.ReferenceObject.SystemFields.Id == referenceObject.SystemFields.Id)
                {
                    listFoundedObject.Add(item);
                }
            }
            //var listFoundedDobject = List_ProjectManagementWorks_Cache.Where(on => on.ReferenceObject.SystemFields.Id == referenceObject.SystemFields.Id).ToList();
            if (listFoundedObject == null)
            {
                return(null);
            }
            ProjectManagementWork currentVersion = null;

            foreach (var item in listFoundedObject)
            {
                if (referenceObject.SystemFields.EditDate != item.LastEditDate)
                {
                    List_ProjectManagementWorks_Cache.Remove(item);
                }
                else
                {
                    currentVersion = item;
                }
            }
            return(currentVersion);
        }
コード例 #4
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.GetSynchronizedWorksFromSpace(work, PlanningSpaceGuidString.WorkingPlans))
                //foreach (var item in Synchronization.GetSynchronizedWorksFromSpace(work, PlanningSpaceGuidString.WorkingPlans))
                {
                    while (result == null)
                    {
                        result = GetTheWorkFromWorkingPlanningSpace(item);
                    }
                }
            }
            if (result == null && work.ParentWork != null)
            {
                result = GetTheWorkFromWorkingPlanningSpace(work.ParentWork);
            }
            return(result);
        }
コード例 #5
0
        /// <summary>
        /// Use GetSyncronizedWorks
        /// Возвращает список синхронизированных работ из указанного пространства планирования
        /// </summary>
        /// <param name="work"></param>
        /// <param name="planningSpaceGuidString"></param>
        /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
        /// <returns></returns>
        public static List <ReferenceObject> GetSynchronizedWorksFromSpace(ProjectManagementWork work,
                                                                           string planningSpaceGuidString, bool?returnOnlyMasterWorks = null)
        {
            if (string.IsNullOrEmpty(planningSpaceGuidString))
            {
                planningSpaceGuidString = Guid.Empty.ToString();
            }

            return(GetSynchronizedWorksFromSpace(work.ReferenceObject, planningSpaceGuidString, returnOnlyMasterWorks));
        }
コード例 #6
0
        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);
        }
コード例 #7
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);
        }
コード例 #8
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));
 }
コード例 #9
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));
 }
コード例 #10
0
        private ReferenceObject syncComposition(TreeViewModel pe_treeItem, bool IsCopyRes, bool IsCopyOnlyPlan /*, ref int amountAddObjects*/)
        {
            #region
            //Объект   для синхронизации
            if (pe_treeItem.IsObjectToSync /* && (bool)pe_treeItem.IsSelectObjToSynch*/)
            {
                /* Если синхронизация отсутствует, то создаём новую работу в плане РП
                 * в синхронизированной с Текущей и устанавливаем синхронизацию с дочерней из плана детализации.
                 */

                ClassObject TypePE = pe_treeItem.ProjectElement.Class;

                List <Guid> GuidsLinks = new List <Guid>()
                {
                    new Guid("063df6fa-3889-4300-8c7a-3ce8408a931a"),
                    new Guid("68989495-719e-4bf3-ba7c-d244194890d5"), new Guid("751e602a-3542-4482-af40-ad78f90557ad"),
                    new Guid("df3401e2-7dc6-4541-8033-0188a8c4d4bf"), new Guid("58d2e256-5902-4ed4-a594-cf2ba7bd4770")
                    , new Guid("0e1f8984-5ebe-4779-a9cd-55aa9c984745"), new Guid("79b01004-3c10-465a-a6fb-fe2aa95ae5b8")
                    , new Guid("339ffc33-55b2-490f-b608-a910c1f59f51")
                };


                var newPE = ProjectManagementWork.CopyPE(pe_treeItem.ProjectElement, pe_treeItem.PEForSync, GuidsLinks);

                if (newPE != null)
                {
                    //amountAddObjects++;

                    ProjectManagementWork.RecalcResourcesWorkLoad(newPE);

                    if (IsCopyRes)
                    {
                        ProjectManagementWork.СкопироватьИспользуемыеРесурсы_изЭлементаПроекта_вЭлементПроекта
                            (newPE, pe_treeItem.ProjectElement, onlyPlanningRes: IsCopyOnlyPlan, PlanningSpaceForNewRes_Guid: ProjectManagementWork.GetProject(newPE)[ProjectManagementWork.PM_param_PlanningSpace_GUID].GetGuid());
                    }

                    Synchronization.SyncronizeWorks(newPE, pe_treeItem.ProjectElement);

                    return(newPE);
                }
            }
            #endregion
            return(null);
        }
コード例 #11
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));
 }
コード例 #12
0
        /// <summary>
        /// Возвращает список синхронизированных работ из указанного пространства планирования
        /// </summary>
        /// <param name="work"></param>
        /// <param name="planningSpaceGuidString"></param>
        /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
        /// <returns></returns>
        public static List <ReferenceObject> GetSynchronizedWorks(ReferenceObject work, bool?returnOnlyMasterWorks)
        {
            //if (string.IsNullOrEmpty(planningSpaceGuidString))
            //    planningSpaceGuidString = Guid.Empty.ToString();

            string guidStringForSearch = work.SystemFields.Guid.ToString();

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

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

            //bool isNeedToFilterByPlanningSpace = !string.IsNullOrWhiteSpace(planningSpaceGuidString);
            foreach (var guid in getListGuidObjectsByFilter(DependencyObjects, work))
            {
                ProjectManagementWork tempWork = new ProjectManagementWork(guid);
                //if (isNeedToFilterByPlanningSpace && tempWork.PlanningSpace.ToString() != planningSpaceGuidString)
                //{
                //    continue;
                //}
                result.Add(References.ProjectManagementReference.Find(guid));
            }
            return(result);
        }
コード例 #13
0
 /// <summary>
 /// Получаем список объектов, в качестве условия поиска – сформированный фильтр
 /// </summary>
 /// <param name="filter"></param>
 /// <param name="work"></param>
 /// <returns></returns>
 static private List <Guid> getListGuidObjectsByFilter(List <ReferenceObject> DependencyObjects, ProjectManagementWork work)
 {
     return(getListGuidObjectsByFilter(DependencyObjects, work.ReferenceObject));
 }
コード例 #14
0
        /// <summary>
        /// Метод копирования используемых ресурсов
        /// </summary>
        /// <param name="owner">Элемент проекта в который копируем используемые ресурсы</param>
        /// <param name="whence">Элемент проекта с которого копируем используемые ресурс</param>
        /// <param name="PlanningSpaceForNewRes_Guid">Пространство планирования для новых ресурсов</param>
        /// <param name="PlanningSpaceForCheck_Guid">Копировать ресурсы только из этого пространства планирования</param>
        /// <returns></returns>
        public static bool СкопироватьИспользуемыеРесурсы_изЭлементаПроекта_вЭлементПроекта(ReferenceObject owner, ReferenceObject whence
                                                                                            , bool onlyPlanningRes, Guid?PlanningSpaceForNewRes_Guid = null, Guid?PlanningSpaceForCheck_Guid = null)
        {
            if (owner == null || whence == null)
            {
                return(false);
            }

            //получение списка используемых ресурсов с детализации
            var usedResources = ProjectManagementWork.GetLinkedUsedNonConsumableResources(whence, onlyPlanningRes)
                                .Where(UseRes =>
            {
                var currentGuidPlanningSpaceRes = UsedResource.GetPlanningSpaceUsedResource(UseRes.ReferenceObject);

                if (PlanningSpaceForCheck_Guid != null && PlanningSpaceForCheck_Guid != currentGuidPlanningSpaceRes)
                {
                    return(false);
                }


                ReferenceObject NonExpendableResource = null;

                //Получаем Ресурс из справочника Ресурсы
                NonExpendableResource = UsedResource.GetResourcesLink(UseRes.ReferenceObject);

                if (NonExpendableResource == null)
                {
                    //MessageBox.Show("NonExpendableResource == null");
                    return(false);
                }

                //Проверка ресурса на тип
                switch (NonExpendableResource.Class.Name)
                {
                case "Оборудование и оснастка":
                    { return(false); }

                case "Оснащение":
                    { return(false); }

                case "Комплектующие":
                    { return(false); }

                case "Ресурсы материалов":
                    { return(false); }
                }

                return(true);
            }).ToList();

            if (usedResources.Count() == 0)
            {
                return(true);
            }

            var result = new List <ReferenceObject>(usedResources.Count);

            //цикл копирования используемых ресурсов с детализации, в справочник используемыее ресурсы
            foreach (var usedResource in usedResources)
            {
                //Здесь дописать копирование нужных параметров и связей
                var newResourceUsed = usedResource.ReferenceObject.CreateCopy(usedResource.ReferenceObject.Class);

                // var newResourceUsed = ResourceUsed.CreateReferenceObject(null, ResourceUsed.Classes.Find(Dinamika.Guids.ResourceUsedReference.TypeNonExpendableResourcesUsedReferenceObject_Guid));

                /*
                 * //Получаем Ресурс из справочника Ресурсы
                 * var NonExpendableResource = usedResource.GetObject(Guids.ResourceUsedReference.Links.ResourcesLink_Guid);
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.Name_Guid].Value = usedResource[Guids.ResourceUsedReference.Name_Guid].Value;
                 *
                 * if (NonExpendableResource != null)
                 *  newResourceUsed.SetLinkedObject(Guids.ResourceUsedReference.Links.ResourcesLink_Guid, NonExpendableResource);
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.Number_Guid].Value = usedResource[Guids.ResourceUsedReference.Number_Guid].Value;
                 *
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.BeginDate_Guid].Value = usedResource[Guids.ResourceUsedReference.BeginDate_Guid].Value;
                 * newResourceUsed[Guids.ResourceUsedReference.EndDate_Guid].Value = usedResource[Guids.ResourceUsedReference.EndDate_Guid].Value;
                 *
                 * newResourceUsed[Guids.ResourceUsedReference.FactValue_Guid].Value = usedResource[Guids.ResourceUsedReference.FactValue_Guid].Value;
                 * newResourceUsed[Guids.ResourceUsedReference.FixNumber_Guid].Value = usedResource[Guids.ResourceUsedReference.FixNumber_Guid].Value;
                 */

                if (PlanningSpaceForNewRes_Guid != null && PlanningSpaceForNewRes_Guid != Guid.Empty)
                {
                    if (!newResourceUsed.Changing)
                    {
                        newResourceUsed.BeginChanges();
                    }
                }
                {
                    newResourceUsed[UsedResource.param_PlanningSpace_Guid].Value = PlanningSpaceForNewRes_Guid;
                }
                //else
                //newResourceUsed[Guids.ResourceUsedReference.PlanningSpace_Guid].Value = Project(owner)[Dinamika.Guids.ProjectManagementReference.TypeProjectElement.PlanningSpace_Guid].Value;

                /*
                 *              //в библиотеке TF - isActual
                 *              newResourceUsed[Guids.ResourceUsedReference.FactValue_Guid].Value = usedResource[Guids.ResourceUsedReference.FactValue_Guid].Value;
                 *
                 *              //ResourceGroupLin
                 *              newResourceUsed.SetLinkedObject(Guids.ResourceUsedReference.Links.ResourceGroup_Nto1_Guid, usedResource.GetResourceGroupLink());
                 *
                 *              newResourceUsed[Guids.ResourceUsedReference.Workload_Guid].Value = usedResource[Guids.ResourceUsedReference.Workload_Guid].Value;
                 */
                newResourceUsed.EndChanges();


                //WaitingHelper.SetText(string.Format("Добавление ресурса {0} в элемент проекта {1}", newResourceUsed.ToString(), owner.ToString()));

                // newResourceUsed.Reload();

                result.Add(newResourceUsed);
            }


            //подключаем используемые ресурсы к элемент укрумения
            if (CanEditObject(owner) == false)
            {
                return(false);
            }

            owner.BeginChanges();

            foreach (var newResource in result)
            {
                // if (newResource.Changing)
                //     newResource.EndChanges();
                ProjectManagementWork.AddResource(owner, newResource);
                //owner.AddLinkedObject(Guids.ProjectManagementReference.TypeProjectElement.Links.ProjectElementResLinks_1toN_Guid, newResource);
            }

            owner.EndChanges();

            owner.Unlock();

            //пересчитываем суммарные трудозатраты
            RecalcResourcesWorkLoad(owner);

            return(true);
        }
コード例 #15
0
        //создаём синхронизацию
        public static void SyncronizeWorks(ReferenceObject masterWork, ReferenceObject slaveWork)
        {
            ReferenceObject синхронизация = ProjectDependenciesReference.CreateReferenceObject(Class_ProjectDependency);

            синхронизация[SynchronizationParameterGuids.param_DependencyType_Guid].Value = 5;// DependencyType.Synchronization;
            синхронизация[SynchronizationParameterGuids.param_MasterWork_Guid].Value     = masterWork.SystemFields.Guid;
            синхронизация[SynchronizationParameterGuids.param_SlaveWork_Guid].Value      = slaveWork.SystemFields.Guid;
            синхронизация[SynchronizationParameterGuids.param_MasterProject_Guid].Value  = ProjectManagementWork.GetProject(masterWork).SystemFields.Guid;
            синхронизация[SynchronizationParameterGuids.param_SlaveProject_Guid].Value   = ProjectManagementWork.GetProject(slaveWork).SystemFields.Guid;
            синхронизация.EndChanges();
            //return синхронизация;
        }
コード例 #16
0
        //static MainWindowViewModel MainWindowViewModel = null;


        //создаём синхронизацию
        public static void SyncronizeWorks(ProjectManagementWork masterWork, ProjectManagementWork slaveWork)
        {
            SyncronizeWorks(masterWork.ReferenceObject, slaveWork.ReferenceObject);
        }
コード例 #17
0
 /// <summary>
 /// Получить список зависимостей типа синхранизация
 /// </summary>
 /// <param name="returnOnlyMasterWorks">true - список зависимостей (укрупнение)</param>
 /// <param name="work"></param>
 /// <returns></returns>
 public static List <ReferenceObject> GetDependenciesObjects(bool?returnOnlyMasterWorks, ProjectManagementWork work)
 {
     return(GetDependenciesObjects(returnOnlyMasterWorks, work.Guid.ToString()));
 }
コード例 #18
0
 /// <summary>
 /// Возвращает список синхронизированных работ из указанного пространства планирования
 /// </summary>
 /// <param name="work"></param>
 /// <param name="planningSpaceGuidString"></param>
 /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param>
 /// <returns></returns>
 public static List <ReferenceObject> GetSynchronizedWorks(ProjectManagementWork work, bool?returnOnlyMasterWorks)
 {
     return(GetSynchronizedWorks(work.ReferenceObject, returnOnlyMasterWorks));
 }