/// <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();
}
}
/// <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);
}
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="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);
}
/// <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));
}
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);
}
/// <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));
}
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);
}
/// <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="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);
}
/// <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));
}
/// <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);
}
//создаём синхронизацию
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 синхронизация;
}
//static MainWindowViewModel MainWindowViewModel = null;
//создаём синхронизацию
public static void SyncronizeWorks(ProjectManagementWork masterWork, ProjectManagementWork slaveWork)
{
SyncronizeWorks(masterWork.ReferenceObject, slaveWork.ReferenceObject);
}
/// <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()));
}
/// <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));
}