public static MainTask Convert(this T_E_MainTask iEntity)
{
if (iEntity == null)
{
return(null);
}
return(new MainTask
{
Comments = iEntity.Comments,
CompletedDate = iEntity.CompletedDate,
CreationDate = iEntity.CreationDate,
CreationUserGUID = iEntity.CreationUserGUID,
Description = iEntity.Description,
Status = (MainTaskStatusEnum)iEntity.StatusRef,
MainTaskId = iEntity.MainTaskId,
Name = iEntity.Name,
ObjectifCloseDate = iEntity.ObjectifCloseDate,
OpenedDate = iEntity.OpenedDate,
PackageId = iEntity.PackageId,
Priority = iEntity.Priority,
ExternalProjectId = iEntity.ExternalProjectId,
RequestUserGUID = iEntity.RequestUserGUID,
StartDate = iEntity.StartDate,
TaskType = (MainTaskTypeEnum)iEntity.TaskTypeRef,
});
}
public void MoveUpMainTaskPriority(MainTask iMainTask)
{
if (iMainTask == null)
{
throw new Exception("La tâche est nulle");
}
if (iMainTask.Priority != null)
{
if (iMainTask.Priority < 0)
{
throw new Exception("La priorité doit être positive");
}
if (iMainTask.Priority == 1)
{
throw new Exception("La priorité est déjà maximale");
}
}
using (var ts = new TransactionScope())
{
var theTask = DBReleaseDataService.GetMainTaskById(iMainTask.MainTaskId);
int? thePriority = 1;
T_E_MainTask previousTask = null;
if (theTask.Priority != null)
{
thePriority = theTask.Priority - 1;
previousTask = DBReleaseDataService.GetSingleOrDefault <T_E_MainTask>(x => x.Priority == iMainTask.Priority - 1);
}
else
{
previousTask = DBReleaseDataService.GetSingleOrDefault <T_E_MainTask>(x => x.Priority == 1);
var taskWithPriority = DBReleaseDataService.GetList <T_E_MainTask>(x => x.Priority != null && x.Priority != 1).Enum().OrderByDescending(x => x.Priority).Enum().Select(x => x.Convert()).Enum().ToList();
foreach (var taskPriority in taskWithPriority.Enum())
{
MoveDownMainTaskPriority(taskPriority);
}
}
theTask.Priority = thePriority;
DBReleaseDataService.Update(theTask);
if (previousTask != null)
{
previousTask.Priority += 1;
DBReleaseDataService.Update(previousTask);
}
ts.Complete();
}
}
public void MoveDownMainTaskPriority(MainTask iMainTask)
{
if (iMainTask == null)
{
throw new Exception("La tâche est nulle");
}
if (iMainTask.Priority < 0)
{
throw new Exception("La priorité doit être positive");
}
using (var ts = new TransactionScope())
{
var theTask = DBReleaseDataService.GetMainTaskById(iMainTask.MainTaskId);
T_E_MainTask followingTask = null;
int? thePriority;
if (theTask.Priority != null)
{
thePriority = theTask.Priority + 1;
followingTask = DBReleaseDataService.GetSingleOrDefault <T_E_MainTask>(x => x.Priority == iMainTask.Priority + 1);
}
else
{
var lastPriority = DBReleaseDataService.GetQuery <T_E_MainTask>(null).Max(x => x.Priority);
if (lastPriority == null)
{
thePriority = 1;
}
else
{
thePriority = lastPriority + 1;
}
}
theTask.Priority = thePriority;
DBReleaseDataService.Update(theTask);
if (followingTask != null)
{
followingTask.Priority -= 1;
DBReleaseDataService.Update(followingTask);
}
ts.Complete();
}
}
public static void Merge(this T_E_MainTask iEntity, MainTask iObj)
{
iEntity.Comments = iObj.Comments;
iEntity.CompletedDate = iObj.CompletedDate;
iEntity.CreationDate = iObj.CreationDate;
iEntity.CreationUserGUID = iObj.CreationUserGUID;
iEntity.Description = iObj.Description;
iEntity.StatusRef = (short)iObj.Status;
iEntity.MainTaskId = iObj.MainTaskId;
iEntity.Name = iObj.Name;
iEntity.ObjectifCloseDate = iObj.ObjectifCloseDate;
iEntity.OpenedDate = iObj.OpenedDate;
iEntity.PackageId = iObj.PackageId;
iEntity.Priority = iObj.Priority;
iEntity.ExternalProjectId = iObj.ExternalProjectId;
iEntity.RequestUserGUID = iObj.RequestUserGUID;
iEntity.TaskTypeRef = (short)iObj.TaskType;
}
public void UpdateMainTask(MainTask iMainTask)
{
if (iMainTask == null)
{
throw new Exception("La tâche principale est null");
}
if (iMainTask.MainTaskId < 1)
{
throw new Exception("L'id de la tâche est invalide");
}
if (iMainTask.TaskType == MainTaskTypeEnum.ProjectDeveloppement && iMainTask.ExternalProjectId == null)
{
throw new Exception("Une tâche de type projet requiert un numéro de projet");
}
var originalMainTask = GetMainTaskById(iMainTask.MainTaskId, GranularityEnum.Full);
if (originalMainTask.Status != iMainTask.Status)
{
throw new Exception("Pour un changement de status, cette fonction n'est pas supportée");
}
if (originalMainTask.Status != MainTaskStatusEnum.Dev &&
originalMainTask.Status != MainTaskStatusEnum.Requested &&
originalMainTask.Status != MainTaskStatusEnum.Waiting)
{
throw new Exception("Le statut actuel de la tâche ne permet pas de modification");
}
//Suppression du package
if (originalMainTask.PackageId != null && iMainTask.PackageId == null)
{
//Package lock
if (originalMainTask.Package.IsLocked)
{
throw new Exception("La tâche ne peut pas sortir d'un package verrouillé");
}
//Tâche entammée
if (originalMainTask.Status == MainTaskStatusEnum.Dev)
{
if (originalMainTask.SubTasks.Any(x => x.Progression != 0))
{
throw new Exception("Le Package ne peut pas être retiré de la tâche avec un avancement différent de 0");
}
else
{
iMainTask.Status = MainTaskStatusEnum.Waiting;
}
}
else if (originalMainTask.Status != MainTaskStatusEnum.Waiting && originalMainTask.Status != MainTaskStatusEnum.Requested)
{
throw new Exception("Le statut de la tâche ne permet pas de sortir du package");
}
}
//Affectation de package
else if (originalMainTask.PackageId == null && iMainTask.PackageId != null)
{
var affectedPackage = GetPackageById((long)iMainTask.PackageId, GranularityEnum.Nude);
if (affectedPackage.Status == PackageStatusEnum.Developpement)
{
iMainTask.Status = MainTaskStatusEnum.Dev;
iMainTask.OpenedDate = DateTime.Now;
}
else if (affectedPackage.Status == PackageStatusEnum.Canceled ||
affectedPackage.Status == PackageStatusEnum.Production ||
affectedPackage.Status == PackageStatusEnum.Staging)
{
throw new Exception("Il n'est pas possible d'affecter une tâche au package avec ce status");
}
else if (affectedPackage.Status == PackageStatusEnum.Waiting)
{
//ne rien faire
}
else
{
throw new Exception(affectedPackage.Status.ToStringWithEnumName());
}
}
//Changement de package
else if (originalMainTask.PackageId != iMainTask.PackageId && iMainTask.PackageId != null)
{
iMainTask.SubTasks = originalMainTask.SubTasks;
if (!IsMainTaskCanJoinThisPackage(iMainTask.MainTaskId, (long)iMainTask.PackageId))
{
throw new Exception("Cette tâche ne peut pas être attachée à ce package");
}
}
using (var ts = new TransactionScope())
{
//MAINTASK
var mainTaskEntity = new T_E_MainTask();
mainTaskEntity.Merge(iMainTask);
DBReleaseDataService.UpdateMainTask(mainTaskEntity);
//PRODUCTLINE
var originalProductLineTaskList = GetProductLineByMainTaskId(iMainTask.MainTaskId);
var productLineComparator = new ListComparator <ProductLine, ProductLine>(originalProductLineTaskList, x => x.ProductLineId, iMainTask.ProductLines, x => x.ProductLineId);
//Add
foreach (var productLineItem in productLineComparator.NewList.Enum())
{
var productLineTaskEntity = new T_E_ProductLineTask();
productLineTaskEntity.ProductLineTaskId = -1;
productLineTaskEntity.MainTaskId = iMainTask.MainTaskId;
productLineTaskEntity.ProductLineId = productLineItem.ProductLineId;
DBProductDataService.Add <T_E_ProductLineTask>(productLineTaskEntity);
}
//Delete
foreach (var productLineItem in productLineComparator.RemovedList.Enum())
{
var productLineTaskEntity = DBProductDataService.GetSingleOrDefault <T_E_ProductLineTask>(x => x.MainTaskId == iMainTask.MainTaskId && x.ProductLineId == productLineItem.ProductLineId);
DBReleaseDataService.DeleteProductLineTask(productLineTaskEntity.ProductLineTaskId);
}
ts.Complete();
}
}
private void UpdateMainTaskStatus(MainTask iMainTask, MainTaskStatusEnum iNewStatus)
{
if (iMainTask == null)
{
throw new Exception("La tâche principale est null");
}
if (iMainTask.MainTaskId < 1)
{
throw new Exception("L'id de la tâche est invalide");
}
var originalMainTask = GetMainTaskById(iMainTask.MainTaskId, GranularityEnum.Full);
//Validation workflow status
if (originalMainTask.Status == MainTaskStatusEnum.Requested &&
iNewStatus != MainTaskStatusEnum.Waiting && iNewStatus != MainTaskStatusEnum.Canceled)
{
throw new Exception("Le changement de status de la tâche n'est pas permis");
}
else if (originalMainTask.Status == MainTaskStatusEnum.Waiting &&
iNewStatus != MainTaskStatusEnum.Dev && iNewStatus != MainTaskStatusEnum.Canceled)
{
throw new Exception("Le changement de status de la tâche n'est pas permis");
}
else if (originalMainTask.Status == MainTaskStatusEnum.Dev &&
iNewStatus != MainTaskStatusEnum.Waiting && iNewStatus != MainTaskStatusEnum.Staging && iNewStatus != MainTaskStatusEnum.Completed && iNewStatus != MainTaskStatusEnum.Canceled)
{
throw new Exception("Le changement de status de la tâche n'est pas permis");
}
else if (originalMainTask.Status == MainTaskStatusEnum.Staging &&
iNewStatus != MainTaskStatusEnum.Dev && iNewStatus != MainTaskStatusEnum.Completed && iNewStatus != MainTaskStatusEnum.Canceled)
{
throw new Exception("Le changement de status de la tâche n'est pas permis");
}
else if (originalMainTask.Status == MainTaskStatusEnum.Completed)
{
throw new Exception("Le changement de status de la tâche n'est pas permis");
}
else if (originalMainTask.Status == MainTaskStatusEnum.Canceled && iNewStatus != MainTaskStatusEnum.Waiting)
{
throw new Exception("Le changement de status de la tâche n'est pas permis pour les tâches annulées");
}
//CONDITION DE CHANGEMENT DE STATUS
//Demande
if (iNewStatus == MainTaskStatusEnum.Requested)
{
throw new Exception("Ce status n'est pas possible en modification");
}
//En cours
else if (iNewStatus == MainTaskStatusEnum.Dev)
{
//package obligatoire
if (originalMainTask.PackageId == null)
{
throw new Exception("Le package est obligatoire pour ouvrir la tâche {0}".FormatString(originalMainTask.MainTaskIdString));
}
//Gamme
if (originalMainTask.ProductLines.IsNullOrEmpty())
{
throw new Exception("La gamme est obligatoire pour ouvrir la tâche {0}".FormatString(originalMainTask.MainTaskIdString));
}
//Project
if (originalMainTask.SubTasks.IsNullOrEmpty())
{
throw new Exception("La définition des sous tâches est obligatoire pour ouvrir la tâche {0}".FormatString(originalMainTask.MainTaskIdString));
}
//Vérification qu'il y a pas d'autre
if (IsProjectTaskAlreadyInProgress(originalMainTask))
{
throw new Exception("Cette tâche ne peut pas être ouverte car un projet est déjà utilisé sur une tâche ouverte");
}
}
//Terminée
else if (iNewStatus == MainTaskStatusEnum.Completed)
{
//Sous tâche obligatoire
if (!originalMainTask.SubTasks.Any())
{
throw new Exception("La tâche ne peut pas être complété sans sous tâches");
}
//Progression de toutes les sous-tâches doivent être à 100%
var sumProgression = decimal.Divide(originalMainTask.SubTasks.Enum().Sum(x => x.Progression), originalMainTask.SubTasks.Count);
if (sumProgression != 100)
{
throw new Exception("Toutes les tâches doivent être terminées à 100%");
}
}
//Test
else if (iNewStatus == MainTaskStatusEnum.Staging)
{
//Sous tâche obligatoire
if (!originalMainTask.SubTasks.Any())
{
throw new Exception("La tâche ne peut pas être testé sans sous tâches");
}
//Progression de toutes les sous-tâches doivent être à 100%
var sumProgression = decimal.Divide(originalMainTask.SubTasks.Enum().Sum(x => x.Progression), originalMainTask.SubTasks.Count);
if (sumProgression != 100)
{
throw new Exception("Toutes les tâches doivent être terminées à 100%");
}
}
//Waiting
else if (iNewStatus == MainTaskStatusEnum.Staging)
{
//Progression de toutes les sous-tâches doivent être à 0%
var sumProgression = decimal.Divide(originalMainTask.SubTasks.Enum().Sum(x => x.Progression), originalMainTask.SubTasks.Count);
if (originalMainTask.SubTasks.Exists(x => x.Progression != 0))
{
throw new Exception("Toutes les tâches doivent être à avancement de 0%");
}
}
//Modification
if (iNewStatus == MainTaskStatusEnum.Dev)
{
originalMainTask.OpenedDate = DateTime.Now;
}
else if (iNewStatus == MainTaskStatusEnum.Staging)
{
originalMainTask.Priority = null;
}
else if (iNewStatus == MainTaskStatusEnum.Completed)
{
originalMainTask.CompletedDate = DateTime.Now;
originalMainTask.Priority = null;
}
else if (iNewStatus == MainTaskStatusEnum.Canceled)
{
originalMainTask.Priority = null;
originalMainTask.PackageId = null;
}
//Application du nouveau status
var entity = new T_E_MainTask();
originalMainTask.Status = iNewStatus;
entity.Merge(originalMainTask);
DBReleaseDataService.UpdateMainTask(entity);
}
public long AddMainTask(MainTask iMainTask)
{
if (iMainTask == null)
{
throw new Exception("La tâche principale est null");
}
if (iMainTask.TaskType == MainTaskTypeEnum.ProjectDeveloppement && iMainTask.ExternalProjectId == null)
{
throw new Exception("Une tâche de type projet requiert un numéro de projet");
}
if (iMainTask.Status != MainTaskStatusEnum.Requested &&
iMainTask.Status != MainTaskStatusEnum.Waiting)
{
throw new Exception("Le statut ne permet pas la création de la tâche");
}
if (iMainTask.Status == MainTaskStatusEnum.Requested && iMainTask.PackageId != null)
{
throw new Exception("Le statut requested ne permet l'attachement à un package");
}
long newMainTaskId = 0;
using (var ts = new TransactionScope())
{
if (iMainTask.PackageId != null)
{
var affectedPackage = GetPackageById((long)iMainTask.PackageId, GranularityEnum.Nude);
if (affectedPackage.Status == PackageStatusEnum.Developpement)
{
iMainTask.Status = MainTaskStatusEnum.Dev;
iMainTask.OpenedDate = DateTime.Now;
}
else if (affectedPackage.Status == PackageStatusEnum.Canceled ||
affectedPackage.Status == PackageStatusEnum.Production ||
affectedPackage.Status == PackageStatusEnum.Staging)
{
throw new Exception("Il n'est pas possible d'affecter une tâche au package avec ce status");
}
else if (affectedPackage.Status == PackageStatusEnum.Waiting)
{
//ne rien faire
}
else
{
throw new Exception(affectedPackage.Status.ToStringWithEnumName());
}
}
var entity = new T_E_MainTask();
entity.Merge(iMainTask);
newMainTaskId = DBReleaseDataService.AddMainTask(entity);
//SubTask
foreach (var subTaskItem in iMainTask.SubTasks.Enum())
{
subTaskItem.MainTaskId = newMainTaskId;
AddSubTask(subTaskItem);
}
//ProductLine
foreach (var productLineItem in iMainTask.ProductLines.Enum())
{
var productLineTaskEntity = new T_E_ProductLineTask();
productLineTaskEntity.ProductLineTaskId = -1;
productLineTaskEntity.MainTaskId = newMainTaskId;
productLineTaskEntity.ProductLineId = productLineItem.ProductLineId;
DBProductDataService.Add <T_E_ProductLineTask>(productLineTaskEntity);
}
ts.Complete();
}
return(newMainTaskId);
}
