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