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()));
}