/// <summary>
/// Функция считывает ресурсы из объекта ДГ и добавляет их в справочники
/// </summary>
/// <param name="obj">Объект PLM, из которого происходит чтение</param>
/// <param name="strTask">Объект - структура задачи, в которую будут записаны ресурсы</param>
public void TransferResources(GanttItem gt, ref clTask strTask)
{
if (gt.ItemType != GanttItemType.TaskItem) return;
strTask.lResourceTask.Clear();
var task = (TaskItem)gt;
foreach (var resrel in task.Resources)
{
var resitem = resrel.Resource;
// Создание структуры трудовых ресурсов (для задачи)
stResource strResource = new stResource();
strResource.Res = resitem;
strResource.unit = 1;
var ioRes = GetIObyGT(resitem);
if (ioRes == null)
{
// Создание структуры трудовых ресурсов (для справочника)
stResource elemResource = new stResource();
elemResource.Res = resitem;
elemResource.objResurce = null;
// Запись нового ресурса в словарь ресурсов
dictResource.Add(elemResource);
}
else
{
strResource.responsible = IsRespUser(strTask, ioRes);
}
strResource.objResurce = ioRes;
// Запись в список трудовых ресурсов в структуре strTask
strTask.lResourceTask.Add(strResource);
}
}
/// <summary>
/// Парсинг данных из одной записи объекта ПЛМ Базовый план и сохранение их в справочнике.
/// </summary>
private void CollectSinglePlan(InfoObject taskobj, int revNumber)
{
var revisionTask = taskobj.CreateRevisionProxyByNumber(revNumber, true);
clTask strTask = new clTask();
strTask.externalTask = false;
// Заполнение структуры данных
strTask.Obj = taskobj;
strTask.Dates.DataBegTask = revisionTask.GetValue<DateTime>("StartDate");
strTask.Dates.DataEndTask = revisionTask.GetValue<DateTime>("FinishDate");
strTask.TaskName = revisionTask.GetValue<string>("TaskName"); // taskobj["TaskName"].ToString();
strTask.idPlm = revisionTask.Id;
strTask.Dates.TypeOfDuration = revisionTask.GetValue<NamedValue>("TypeOfDuration");
strTask.Dates.Duration = revisionTask.GetValue<float>("Duration");
if (!dictPlanRecords.ContainsKey(taskobj)) dictPlanRecords.Add(taskobj, strTask);
}
/// <summary>
/// Функция считывает ресурсы при первичном чтении объекта из PLM и добавляет их в справочники
/// </summary>
/// <param name="obj">Объект PLM, из которого происходит чтение</param>
/// <param name="strTask">Объект - структура задачи, в которую будут записаны ресурсы</param>
public void AddResource(InfoObject obj, ref clTask strTask)
{
// Список трудовых ресурсов, входящих в текущую задачу из таблицы "Ресурсы:"
var ResourcesTasks = obj.GetAttribute("Resources",
AttributeDefBase.DataTypeEnum.CollectionOfElements);
if (ResourcesTasks.CollectionElements.Count == 0) return;
// Создание списка трудовых ресурсов для текущей задачи
foreach (var resourc in ResourcesTasks.CollectionElements)
{
// Создание структуры трудовых ресурсов (для задачи)
stResource strResource = new stResource();
// Заполнение структуры stResource(ресурсы)
strResource.objResurce = resourc.GetValue<InfoObject>("ResourceLink");
strResource.responsible = IsRespUser(strTask, strResource.objResurce);
strResource.unit = 1;
// Проверка наличия ресурса в словаре ресурсов dictResource
var gtRes = GetGTbyIO(strResource.objResurce);
if (gtRes == null)
{
// Создание структуры трудовых ресурсов (для справочника)
stResource elemResource = new stResource();
elemResource.objResurce = strResource.objResurce;
// Краткое название ресурса
var shortName = strResource.GetResourceNamePLM();
// Создание нового ресурса
gtRes = this.GanttDiag.AddResource(shortName);
// Задание календаря
InfoObject resCalendar = strResource.objResurce.GetValue<InfoObject>("BasicCalendar");
gtRes.CalendarKey = ParentHelper.GetCalendarKey(resCalendar);
elemResource.Res = gtRes;
// Запись нового ресурса в словарь ресурсов
dictResource.Add(elemResource);
}
strResource.Res = gtRes;
// Запись в список трудовых ресурсов в структуре strTask
strTask.lResourceTask.Add(strResource);
}
}
public void NewGroup(GanttItem task)
{
clTask newStGroup; // Структура новой группы
dictTasks.TryGetValue(task.Key, out newStGroup);
if (newStGroup == null)
newStGroup = new clTask();
int index = mainList.IndexOf(newStGroup);
newStGroup.bGroup = true;
newStGroup.TaskName = task.Text;
newStGroup.keyGantt = task.Key;
newStGroup.externalTask = false;
newStGroup.Dates.RuleForStartDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
// InternalCalculation1 - Вычислять начало
newStGroup.Dates.DataBegTask = DateTime.MinValue;
newStGroup.Dates.RuleForFinishDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
newStGroup.Dates.DataEndTask = DateTime.MinValue;
// Календарь переприсваивать не надо - пусть остаётся тот же, который был при импорте
// Признак Вехи переприсваивать не надо - пусть остаётся тот же, который был при импорте
if (index == -1)
// Новая группа
{
// Новая запись в словаре
dictTasks.Add(newStGroup.keyGantt, newStGroup);
// Новая запись в списке
mainList.Add(newStGroup);
index = mainList.IndexOf(newStGroup);
}
if (((GroupItem)task).ChildItems.Count() == 0)
{
// Создание новой задачи
TaskItem gt = this.GanttDiag.AddTask(DateTime.Now, DateTime.Now.AddDays(1), "Новая задача", GetNextOrder());
((GroupItem)task).AddChild(gt);
NewTask(gt);
}
foreach (var ts in ((GroupItem)task).ChildItems)
{
if (ts.ItemType == GanttItemType.GroupItem)
NewGroup(ts);
else
{
clTask strTask = null;
int ind = -1;
if (FindStOnKeyGantt(ts.Key, ref strTask, ref ind))
{
newStGroup.lChildrTask.Add(strTask);
}
NewTask(ts);
}
}
if (task.ParentItem == null) // Нет родительской группы
{
// Назначение основной группы - родительской для newStGroup
this.GanttDiag.Groups[0].AddChild(task);
}
else
{
// Запись в список родительских задач в структуре newStGroup
HelperClasses.stParentTask stPT = new HelperClasses.stParentTask(); // Структура родительской группы
clTask rabStTask = new clTask(); // Структура данных родительской группы
if (dictTasks.TryGetValue(task.ParentItem.Key, out rabStTask))
{
// Данные родительской группы rabStTask для группы newStTask определены
var ind = mainList.IndexOf(rabStTask);
// Поиск и удаление данных в дочерних задачах задачи newStTask
FindDelChlidSt(newStGroup.keyGantt);
stPT.Obj = rabStTask.Obj; // ИО родителской группы
stPT.IsPrimary = true; // Признак основной родительской задачи
stPT.keyGantt = rabStTask.keyGantt;
stPT.TaskName = rabStTask.TaskName;
stPT.idPlm = rabStTask.idPlm;
newStGroup.lParentTask.Add(stPT);
// Дополнение новой задачи в список дочерних
rabStTask.lChildrTask.Add(rabStTask);
// Замена в словаре
dictTasks[task.ParentItem.Key] = rabStTask;
// Замена в списке
mainList[ind] = rabStTask;
}
}
}
/// <summary>
/// Чтение данных объекта диаграммы для закладки "Состав задачи" задачи
/// </summary>
/// <param name="gtTask"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabComposition(GanttItem gtTask)
{
InfoObject Obj;
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtTask.Key, out curSt);
Obj = curSt.Obj;
ICollection<CollectionElement> listTabSb;
EntityAttribute attr;
CollectionElement item;
if (gtTask.ItemType == GanttItemType.GroupItem)
{
// SubTaskList - Состоит из
listTabSb = Obj.GetAttribute("SubTaskList").CollectionElements;
listTabSb.Clear();
// Атрибут таблицы "Состоит из:"
attr = Obj.GetAttribute("SubTaskList");
int i = 0;
clTask childSt;
foreach (var chlid in ((GroupItem)gtTask).ChildItems)
{
// Поиск структуры chlidSt для текущей дочерней задачи из группы
dictTasks.TryGetValue(chlid.Key, out childSt);
FindChild(Obj, childSt);
// Строка таблицы
item = attr.CreateCollectionElement();
// Запись номера задачи "По порядку"
i++;
item["Order"] = i;
// Запись ссылки на объект PLM
item["ProjectTask"] = childSt.Obj;
attr.CollectionElements.Add(item);
}
listTabSb = Obj.GetAttribute("SubTaskList").CollectionElements;
}
}
/// <summary>
/// Заполнение данных объекта PLM в таблице Ресурсы закладки "Расчёт"
/// </summary>
/// <param name="gtTask"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabResources(GanttItem gtTask)
{
// Обновляем ресурсы только у задач (не у групп)
if (gtTask.ItemType != GanttItemType.TaskItem) return;
InfoObject Obj;
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtTask.Key, out curSt);
Obj = curSt.Obj;
var attr = Obj.GetAttribute("Resources");
attr.CollectionElements.Clear();
// Поиск контейнера, содержащего ресурсы
DataContainer ResourceCont = null;
foreach (var resource in curSt.lResourceTask)
if (resource.objResurce != null)
{
ResourceCont = resource.objResurce.Container;
break;
}
foreach (var resource in curSt.lResourceTask)
{
var objResurce = resource.objResurce;
if (objResurce == null && ResourceCont != null)
{
objResurce = new InfoObject(ResourceCont, @"InfoObjects\WORKORG\Resources\Resource\WorkingResource");
objResurce["ResourceName"] = resource.GetResourceNameGantt();
objResurce["ShortResourceName"] = resource.GetResourceNameGantt();
objResurce["BasicCalendar"] = Obj.GetValue<InfoObject>("Calendar");
objResurce.Save();
}
if (objResurce != null)
{
var item = attr.CreateCollectionElement();
item["ResourceLink"] = objResurce;
attr.CollectionElements.Add(item);
}
}
}
/// <summary>
/// Чтение данных объекта диаграммы для закладки "Даты" задачи
/// </summary>
/// <param name="gtItem"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabDates(GanttItem gtItem)
{
InfoObject Obj;
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtItem.Key, out curSt);
Obj = curSt.Obj;
// RuleForStartDate - Правило для Даты начала
Obj["RuleForStartDate"] = curSt.Dates.RuleForStartDate;
// InternalCalculation1 - Вычислять начало
// StartDate - Дата начала
var nDate = gtItem.StartDate;
if (gtItem.ItemType == GanttItemType.GroupItem)
nDate = (gtItem as GroupItem).StartDatePlan;
if (curSt.Dates.DataBegTask != nDate)
Obj["StartDate"] = nDate;
// RuleForDurationDate - Правило для Длительности
// InternalCalculation2 - Вычислять длительность
// TypeOfDuration - Ед.изм (дни/часы)
if (gtItem.ItemType == GanttItemType.TaskItem)
{
if (((TaskItem)gtItem).DurationType == TaskItem.DurationTypes.FullWorkingDays)
{
// Ед.изм - дни
Obj["Duration"] = gtItem.Duration.TotalDays;
Obj["TypeOfDuration"] = Service.GetNamedValue(@"WORKORG\TypeOfDuration\Days");
}
else
{
// Ед.изм - часы
Obj["Duration"] = gtItem.Duration.TotalHours;
Obj["TypeOfDuration"] = Service.GetNamedValue(@"WORKORG\TypeOfDuration\Hours");
}
}
// RuleForFinishDate - Правило для Даты окончания
Obj["RuleForFinishDate"] = curSt.Dates.RuleForFinishDate;
// InternalCalculation3 - Вычислять окончание
// FinishDate - Дата окончания
nDate = gtItem.EndDate;
if (gtItem.ItemType == GanttItemType.GroupItem)
nDate = (gtItem as GroupItem).EndDatePlan;
if (curSt.Dates.DataEndTask != nDate)
Obj["FinishDate"] = nDate;
// Calendar - Календарь
Obj["Calendar"] = curSt.Dates.calendar;
// Percentage - Процент завершения
Obj["Percentage"] = curSt.Dates.Percentage;
// IsApprox - Приблизительная оценка
// ProjectTaskLinks - Временны́е зависимости
ICollection<CollectionElement> timeDependencies = Obj.GetAttribute("ProjectTaskLinks").CollectionElements;
timeDependencies.Clear();
// Атрибут таблицы "Временны́е зависимости"
var attr = Obj.GetAttribute("ProjectTaskLinks");
foreach (var dep in curSt.Dates.lDependentTask)
{
// Строка таблицы
var item = attr.CreateCollectionElement();
item["ProjectTask"] = dep.Obj;
item["ProjectTaskLinkType"] = dep.ProjectTaskLinkType;
item["Delay"] = dep.Delay;
item["IsStrict"] = (dep.IsStrict == 1);
attr.CollectionElements.Add(item);
}
}
/// <summary>
/// Чтение данных объекта диаграммы для закладки "Свойства" задачи
/// </summary>
/// <param name="gtTask"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabProperty(GanttItem gtTask)
{
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtTask.Key, out curSt);
// KindOfTask - вид
// TaskName - наименование
curSt.TaskName = gtTask.Text;
// ResponsibleExecutive - ответственный исполнитель
// Urgency - срочность
// Priority - приоритет
// Status - статус
// PrognosedResourceExpenses - затраты по плану
// Id - идентификатор
}
private void SaveGroupPlm(clTask st, GanttItem gr)
{
st.Obj["TaskName"] = gr.Text;
st.Obj["Content"] = gr.Description;
// Заполнение закладки "Ограничения" для задачи
st.Obj["StartDateNoEarlierThan"] = st.Constraints.StartDateNoEarlierThan;
st.Obj["StartDateNoLaterThan"] = st.Constraints.StartDateNoLaterThan;
st.Obj["FinishDateNotEarlierThan"] = st.Constraints.FinishDateNotEarlierThan;
st.Obj["FinishDateNoLaterThan"] = st.Constraints.FinishDateNoLaterThan;
// Замена ответственного
var userRes = (User)gr.GetProperty("Responsible");
var ResponsibleExecutive = st.Obj.GetValue<User>("ResponsibleExecutive");
if (userRes != null && userRes != ResponsibleExecutive)
st.Obj["ResponsibleExecutive"] = userRes;
// Замена Идентификатора
var Identity = (string)gr.GetProperty("Identity");
if (Identity != null)
st.Obj["Id"] = Identity;
TaskItem.TaskPriorities Priority;
TaskItem.TaskStates status;
if (gr is TaskItem)
{
Priority = (gr as TaskItem).Priority;
status = (gr as TaskItem).Status;
}
else
{
Priority = (gr as GroupItem).Priority;
status = (gr as GroupItem).Status;
}
var oldDGpriority = st.GetDGPriority();
if (oldDGpriority != Priority)
st.Obj["Priority"] = st.GetPLMPriority(Priority);
if (status != TaskItem.TaskStates.Undefined)
st.Obj["State"] = this.GetStatusPLM(status);
FillTabProperty(gr);
FillTabDates(gr);
FillTabResources(gr);
FillTabComposition(gr);
st.Obj.Save();
Service.UI.RefreshObject(st.Obj);
}
/// <summary>
/// Функция определяет, соответствует ли ресурс Ответственному
/// </summary>
/// <param name="key">Объект ДГ, по которому происходит поиск</param>
private bool IsRespUser(clTask strTask, InfoObject objResurce)
{
bool result = false;
// Определение ИО из User
if (strTask.ResponsibleUser != null)
{
var userRes = strTask.ResponsibleUser.GetValue<InfoObject>("WorkingResource");
if (userRes != null && objResurce.Id == userRes.Id)
result = true;
}
return result;
}
/// <summary>
/// Чтение данных из объекта ПЛМ.
/// Создание списка всех задач, входящих в выбранный объект, включаяя задачи, находящиеся вне объекта.
/// Объекты могут содержать дерево задач (Задача, Группа задач, Проект) - в этом случае DoOperChildren = true,
/// а могут содержать плоский список задач (Ресурсы, Задачи сотрудника) - в этом случае DoOperChildren = false.
/// </summary>
/// <param name="obj">Объект, который будет считан</param>
/// <param name="DoReadChildren">Признак - формировать объекты Гантта изи входящих задач или нет</param>
/// <returns> List<stTask> - расширенных список задач </returns>
private clTask AddTasks2List(InfoObject obj, bool DoOperChildren, clTask ParentTask)
{
clTask strTask = new clTask();// Структура дочерней задачи
strTask.ParentTask = ParentTask;
strTask.externalTask = false;
strTask.Dates.bData = false;
strTask.FillclTask(obj);
strTask.Dates.lDependentTask = CreateDepedent(strTask.Obj);
// Список родительских задач(ParentTasks) для задачи obj из таблицы "Входит в:"
var ParentTasks = obj.GetAttribute("ParentList", AttributeDefBase.DataTypeEnum.CollectionOfElements);
if (ParentTasks != null)
{
// Создание списка родительских задач в структуре strTask
foreach (var task in ParentTasks.CollectionElements)
{
// Запись в список родительских задач в структуре strTask
HelperClasses.stParentTask stPT = new HelperClasses.stParentTask();
stPT.Obj = task.GetValue<InfoObject>("ProjectTask");
stPT.IsPrimary = task.GetValue<bool>("IsPrimary");
// Наименование задачи
stPT.TaskName = stPT.Obj["TaskName"].ToString();
// Идентификатор объекта из PLM
stPT.idPlm = stPT.Obj.Id;
strTask.lParentTask.Add(stPT);
}
}
ResourceWorker.AddResource(obj, ref strTask);
mainList.Add(strTask);
if (DoOperChildren)
{
// Если установлен ShowTopLevel, то из ПЛМ считается только один уровень задач
DoOperChildren = !this.ShowTopLevel;
// Список дочерних задач для задачи obj - listChildr из таблицы "Состоит из:"
var listChildr = obj.GetAttribute("SubTaskList").CollectionElements.ToList();
strTask.bGroup = (listChildr.Count() != 0);
// Сортировка дочерних задач по Order
listChildr = listChildr.OrderBy(pet => pet.GetValue<int>("Order")).ToList();
// Создание списка дочерних задач в структуре strTask
foreach (var lC in listChildr)
{
// Дочерняя задача для задачи obj
InfoObject childObj = lC.GetValue<InfoObject>("ProjectTask");
strTask.lChildrTask.Add(AddTasks2List(childObj, DoOperChildren, strTask));
}
}
else
strTask.bGroup = false;
return strTask;
}
/// <summary>
/// Создание списка всех задач, входящих в выбранный проект,
/// включаяя задачи, находящиеся вне проекта
/// </summary>
/// <returns> List<stTask> - расширенных список задач </returns>
private void AddExternalTask()
{
List<clTask> curList = new List<clTask>();
foreach (var st in mainList)
{
InfoObject obj = st.Obj;
// Определение наличия зависимостей для задачи ts
if (st.Dates.lDependentTask.Count != 0)
{
foreach (var dt in st.Dates.lDependentTask)
{
// Проверка наличия текущей задачи в списке структур всех задач, входящих в выбранный проект
var st1 = mainList.FirstOrDefault(cur => cur.Obj == dt.Obj);
if (st1 == null)
{
// Проверка наличия текущей задачи в новом списке списке структур задач
st1 = curList.FirstOrDefault(cur => cur.Obj == dt.Obj);
if (st1 == null)
{
// Структура дочерней задачи
clTask strTask = new clTask();
strTask.externalTask = true;
strTask.FillclTask(dt.Obj);
strTask.nOrder = GetNextOrder();
curList.Insert(0, strTask);
}
}
}
}
curList.Add(st);
}
// Очистка предыдущего списка задач
mainList.Clear();
// Копирование расширенного списка задач
mainList.AddRange(curList);
return;
}
public bool DictTasksGetVal(String Key, out clTask value)
{
return dictTasks.TryGetValue(Key, out value);
}
public String FindParentObjKey(clTask task)
{
String groupKey = null;
// определяем родителя задачи
var ParentTask = task.ParentTask;
// Было определение родителя по первичному
//var ParentTask = task.lParentTask.Where(o => o.IsPrimary == true).FirstOrDefault();
if (ParentTask != null && ParentTask.Obj != null)
{
var ParentTaskInList = mainList.FirstOrDefault(o => o.Obj == ParentTask.Obj);
if (ParentTaskInList != null)
groupKey = ParentTaskInList.keyGantt;
}
return groupKey;
}
public void DictTasksAdd(String keyGantt, clTask strTask)
{
if (!dictTasks.ContainsKey(keyGantt))
dictTasks.Add(keyGantt, strTask);
}
/// <summary>
/// Функция обновляет данные задачи в хранилище mainList
/// </summary>
/// <param name="task">объект диаграммы</param>
public void NewTask(GanttItem task)
{
clTask newStTask;
dictTasks.TryGetValue(task.Key, out newStTask);
if (newStTask == null)
newStTask = new clTask();
int index = mainList.IndexOf(newStTask);
newStTask.bGroup = false;
newStTask.TaskName = task.Text;
newStTask.keyGantt = task.Key;
newStTask.externalTask = false;
newStTask.Dates.RuleForStartDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
// InternalCalculation1 - Вычислять начало
newStTask.Dates.DataBegTask = DateTime.MinValue;
newStTask.Dates.RuleForFinishDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
newStTask.Dates.DataEndTask = DateTime.MinValue;
newStTask.nOrder = GetNextOrder();
// Календарь
if ((task as TaskItem).Calendar == null) newStTask.Dates.calendar = null;
else newStTask.Dates.calendar = this.CalendarsWorker.GetPLMCalendarByCalendarKey((task as TaskItem).Calendar.Key);
newStTask.SetMilestone((task as TaskItem).IsMilestone); // Признак Вехи
// Ограничения
newStTask.Constraints.StartDateNoEarlierThan = CheckDate((task as TaskItem).EarliestStartDate);
newStTask.Constraints.StartDateNoLaterThan = CheckDate((task as TaskItem).LatestStartDate);
newStTask.Constraints.FinishDateNotEarlierThan = CheckDate((task as TaskItem).EarliestEndDate);
newStTask.Constraints.FinishDateNoLaterThan = CheckDate((task as TaskItem).LatestEndDate);
// Процент завершения
newStTask.Dates.Percentage = (int)((KS.Gantt.TaskItem)task).PercentDonePercent;
if (task.ParentItem == null)
{
// Назначение основной группы - родительской для newStTask
if (this.GanttDiag.Groups.Count > 0)
this.GanttDiag.Groups[0].AddChild(task);
}
else
{
// Запись в список родительских задач в структуре newStTask
HelperClasses.stParentTask stPT = new HelperClasses.stParentTask(); // Структура родительской группы
clTask parentStTask = new clTask(); // Данные родительской задачи
if (dictTasks.TryGetValue(task.ParentItem.Key, out parentStTask) == true)
// Родительская задача существует
{
HelperClasses.stParentTask stParent = newStTask.lParentTask.Find(
delegate(HelperClasses.stParentTask bk)
{
return bk.keyGantt == parentStTask.keyGantt;
}
);
if (stParent.TaskName == null)
{
// Индекс записи данных родительской задачи в списке mainList
var ind = mainList.IndexOf(parentStTask);
stPT.IsPrimary = true; // Признак основной родительской задачи
stPT.Obj = parentStTask.Obj; // ИО родителской группы
stPT.keyGantt = parentStTask.keyGantt;
stPT.TaskName = parentStTask.TaskName;
stPT.idPlm = parentStTask.idPlm;
newStTask.lParentTask.Add(stPT);
// Поиск и удаление данных во всех дочерних задачах задачи newStTask
FindDelChlidSt(newStTask.keyGantt);
// Дополнение новой задачи в список дочерних для родительской
parentStTask.lChildrTask.Add(newStTask);
// Замена в словаре
dictTasks[task.ParentItem.Key] = parentStTask;
// Замена в списке (обновление данных родительской задачи)
mainList[ind] = parentStTask;
}
}
}
// Ресурсы
ResourceWorker.TransferResources(task, ref newStTask);
// Временные зависимости
clTask depStTask;
newStTask.Dates.lDependentTask.Clear();
foreach (var dp in ((TaskItem)task).Dependencies)
{
// Переносим только жёсткие зависимости
if (dp.TaskRelationMode == TaskRelationModes.Soft) continue;
stDependents stDep = new stDependents();
if (dictTasks.TryGetValue(dp.TaskKey, out depStTask))
{
stDep.Obj = depStTask.Obj;
stDep.idPlm = depStTask.Obj.Id;
stDep.TaskName = dp.Task.Text;
stDep.typeGantt = dp.TaskRelationType;
// Задание значения Тип временной зависимости для PLM
if (stDep.typeGantt == TaskRelationTypes.EndStart)
// Следует после (Окончание-начало)
stDep.ProjectTaskLinkType =
Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l1");
else if (stDep.typeGantt == TaskRelationTypes.StartStart)
// Начать вместе с (Начало-начало)
stDep.ProjectTaskLinkType =
Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l2");
else if (stDep.typeGantt == TaskRelationTypes.EndEnd)
// Завершить вместе с (Окончание-окончание)
stDep.ProjectTaskLinkType =
Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l3");
else
// Завершить до (Начало-окончание)
stDep.ProjectTaskLinkType = Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l4");
// Запаздывание (календарное)
stDep.Delay = dp.DelayDays;
// Ед.изм (дни/часы) - было depStTask.Dates.TypeOfDuration
stDep.DelayType = (dp.DelayDurationType == TaskItem.DurationTypes.FullWorkingDays ?
Service.GetNamedValue(@"WORKORG\TypeOfDuration\Days") : Service.GetNamedValue(@"WORKORG\TypeOfDuration\Hours"));
stDep.IsStrict = (task as TaskItem).ASAP ? 1 : 0;
// Использовать календарь от
stDep.UseTaskCalendar = true;
newStTask.Dates.lDependentTask.Add(stDep);
}
}
if (newStTask.Obj == null)
{
// Новая задача
if (dictTasks.ContainsKey(newStTask.keyGantt) == false)
{
dictTasks.Add(newStTask.keyGantt, newStTask);
mainList.Add(newStTask);
}
}
else
{
// Старая задача
mainList[index] = newStTask;
dictTasks[newStTask.keyGantt] = newStTask;
}
}
/// <summary>
/// Поиск ИО, у которого в таблице "Состоит из" находится ИО из chlidSt
/// и удаление из таблицы ИО в PLM записи о ИО из chlidSt
/// </summary>
/// <param name="Obj"></param>ИО PLM, в таблицу которого будет вставляться
/// <param name="chlidSt"></param>структура задачи ИО, которого надо найти
void FindChild(InfoObject Obj, clTask childSt)
{
var lChildr = mainList.Where(o => o.lChildrTask.Count() != 0).ToArray();
foreach (clTask curSt in lChildr)
{
for (int i = 0; i < curSt.lChildrTask.Count; i++)
{
// Есть задачи, входящие в таблицу "Состоит из"
var curChlidSt = curSt.lChildrTask[i];
if (childSt.idPlm == curChlidSt.idPlm)
// В таблице "Состоит из" есть запись о ИО из chlidSt
{
if (Obj.Id != curSt.idPlm)
// Дочерняя задача была перемещена из curSt.Obj в Obj
{
// Удаление строки из таблицы "Состоит из" curSt.Obj
var listTabSb = curSt.Obj.GetAttribute("SubTaskList");
if (listTabSb == null) continue;
foreach (var item in listTabSb.CollectionElements)
{
InfoObject io = item.GetValue<InfoObject>("ProjectTask");
if (io != null && io.Id == childSt.idPlm)
listTabSb.CollectionElements.Remove(item);
}
/* TODO remove after test
for (int j = 0; j < listTabSb.Count; j++)
{
InfoObject io = (InfoObject)listTabSb.ElementAt(j)["ProjectTask"];
if (io != null && io.Id == chlidSt.idPlm)
{
listTabSb.Remove(listTabSb.ElementAt(j));
}
} */
}
}
}
}
}
private Template GetTaskTypePlm(clTask stObj)
{
Template kind = null;
if (stObj.bGroup == true)
kind = Service.GetTemplate(@"InfoObjects\WORKORG\TaskKinds\TaskSet");
else
kind = Service.GetTemplate(@"InfoObjects\WORKORG\TaskKinds\Task");
if (stObj.IsMilestone())
kind = Service.GetTemplate(@"InfoObjects\WORKORG\TaskKinds\Milestone");
return kind;
}
