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); }
/// <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(); } }
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); }
//создаём синхронизацию 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 синхронизация; }
/// <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); }
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)); }
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)); }
/// <summary> /// Список всех проектов детализаций /// </summary> /// <param name="ЗависимостиДетализации"></param> /// <returns></returns> static public ObservableCollection <ProjectManagementWork> AllDetailingProjects(List <ReferenceObject> ЗависимостиДетализации) { ObservableCollection <ProjectManagementWork> detailingProjects = new ObservableCollection <ProjectManagementWork>(); Guid guidЗависимости = new Guid(); var PMref = WpfApp_DialogueAddSignatories.Model.References.ProjectManagementReference; foreach (var зависимость in ЗависимостиДетализации) { guidЗависимости = зависимость[Synchronization.SynchronizationParameterGuids.param_SlaveProject_Guid].GetGuid(); //var pe = PMref.Find(guidЗависимости); var PMW = new ProjectManagementWork(guidЗависимости); detailingProjects.Add(PMW); } return(detailingProjects); }
/// <summary> /// Use GetSyncronizedWorks /// Возвращает список синхронизированных работ из указанного пространства планирования /// </summary> /// <param name="work"></param> /// <param name="planningSpaceGuidString"></param> /// <param name="returnOnlyMasterWorks"> если true только укрупнения, если false только детализации</param> /// <returns></returns> public static List <ProjectManagementWork> GetSynchronizedWorksFromSpace(ProjectManagementWork work, string planningSpaceGuidString, bool?returnOnlyMasterWorks = null) { string guidStringForSearch = work.Guid.ToString(); List <ReferenceObject> DependenciesObjects = GetDependenciesObjects(returnOnlyMasterWorks, guidStringForSearch); List <ProjectManagementWork> result = new List <ProjectManagementWork>(); foreach (var item in getListGuidObjectsByFilter(DependenciesObjects, work)) { ProjectManagementWork tempWork = new ProjectManagementWork(item); if (tempWork.PlanningSpace.ToString() == planningSpaceGuidString) { result.Add(new ProjectManagementWork(item)); } } return(result); }
/// <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(); //Получаем список объектов, в качестве условия поиска – сформированный фильтр List <ReferenceObject> DependencyObjects = GetDependenciesObjects(returnOnlyMasterWorks, guidStringForSearch); List <ProjectManagementWork> result = new List <ProjectManagementWork>(); 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(new ProjectManagementWork(guid)); } return(result); }
/// <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)); }
/// <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 , Guid?PlanningSpaceForNewRes_Guid = null, Guid?PlanningSpaceForCheck_Guid = null, bool onlyPlanningRes = false) { 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); }
/// <summary> /// Получаем список объектов, в качестве условия поиска – сформированный фильтр /// </summary> /// <param name="filter"></param> /// <param name="work"></param> /// <returns></returns> static private List <Guid> getListGuidObjectsByFilter(List <ReferenceObject> DependencyObjects, ProjectManagementWork work) { 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 DependencyObjects) // выбираем все отличные от исходной работы 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(); return(listSyncWorkGuids); }
static void SynchronizingСomposition(object objBox, ref ObservableCollection <ProjectTreeItem> tree, Boolean IsForAdd) { BoxParam ParamBox = (BoxParam)objBox; ProjectManagementWork PMObject = ParamBox.currentObject; ProjectManagementWork Детализация = ParamBox.Detailing; tree.Add(new ProjectTreeItem(Детализация.ReferenceObject, IsForAdd)); //string text = "Пожалуйста подождите..."; // WaitingHelper.SetText(text); List <ProjectManagementWork> УкрупненияДетализации = Synchronization.GetSynchronizedWorksFromSpace(Детализация, null, false); ProjectManagementWork УкрупнениеДетализации = УкрупненияДетализации.FirstOrDefault(pe => pe.Project == PMObject.Project); #region цикл дочерних работ детализации foreach (var childDetail in Детализация.Children.OfType <ProjectManagementWork>()) { IsForAdd = false; ParamBox.Detailing = childDetail; List <ProjectManagementWork> Укрупнения = Synchronization.GetSynchronizedWorksFromSpace(childDetail, null, false); ProjectElement newPE = null; if (Укрупнения == null || Укрупнения.Count() == 0) { //Для каждой дочерней работы проверяем наличие синхронизации с планом РП //если есть синхронизация с планом РП, то переходим к следующей дочерней работе if (!Укрупнения.Any(pe => pe.Project == PMObject.Project)) { continue; } } else { /* Если синхронизация отсутствует, то создаём новую работу в плане РП * в синхронизированной с Текущей и устанавливаем синхронизацию с дочерней из плана детализации. */ ClassObject TypePE = childDetail.ReferenceObject.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") }; newPE = childDetail.ReferenceObject.CreateCopy(TypePE, УкрупнениеДетализации.ReferenceObject, GuidsLinks, false) as ProjectElement; if (newPE != null) { newPE.RecalcResourcesWorkLoad(); newPE.EndChanges(); //amountCreate++; IsForAdd = true; // text = string.Format("Добавление элемента проекта {0}", newPE.ToString()); // WaitingHelper.SetText(text); if (ParamBox.IsCopyRes) { ProjectManagementWork.СкопироватьИспользуемыеРесурсы_изЭлементаПроекта_вЭлементПроекта (newPE, childDetail.ReferenceObject, newPE.Project[ProjectManagementWork.PM_param_PlanningSpace_GUID].GetGuid(), onlyPlanningRes: ParamBox.IsCopyPlan); } SyncronizeWorks(new ProjectManagementWork(newPE), childDetail); } } SynchronizingСomposition(ParamBox, ref tree, IsForAdd); } #endregion }
/// <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())); }