/// <summary>
/// 比较
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <typeparam name="TKey">标识类型</typeparam>
/// <param name="newList">新实体集合</param>
/// <param name="oldList">旧实体集合</param>
public static ListCompareResult <TEntity, TKey> Compare <TEntity, TKey>(this IEnumerable <TEntity> newList, IEnumerable <TEntity> oldList)
where TEntity : IKey <TKey>
{
var comparator = new ListComparator <TEntity, TKey>();
return(comparator.Compare(newList, oldList));
}
public void AddAndUpdateExternalProjectFromFile()
{
var PDCExcelFileDataService = new Service.PDCExcelFile.Data.DataService();
var externalProjectFromFileList = PDCExcelFileDataService.GetExternalProjectListFromFile(PDCFILEPATH).Enum().Where(x => x.Status == ExternalProjectStatusEnum.InProgress).Enum().ToList();
var orginalExternalProjectList = DBReleaseDataService.GetList <T_E_ExternalProject>().Enum().Select(x => x.Convert()).Enum().ToList();
var comparator = new ListComparator <ExternalProject, ExternalProject>(orginalExternalProjectList, x => x.ProjectNumber.ToLower(), externalProjectFromFileList, x => x.ProjectNumber.ToLower());
//Nouveau
foreach (var item in comparator.NewList.Enum())
{
item.Type = ExternalProjectTypeEnum.PDC;
item.ExternalProjectId = -1;
AddExternalProject(item);
}
//Update
foreach (var item in comparator.CommonPairList.Enum())
{
var originalIem = item.Key;
var newItem = item.Value;
newItem.ExternalProjectId = originalIem.ExternalProjectId;
newItem.IsProcessed = originalIem.IsProcessed;
newItem.Type = originalIem.Type;
UpdatexternalProject(newItem);
}
}
public void Compare_ShouldReturnAmountOfTheValuesFromListOneInListTwo(IEnumerable <int> firstList, IEnumerable <int> secondList, int expectedResult)
{
var testee = new ListComparator();
var result = testee.Compare(firstList, secondList);
result.Should().Be(expectedResult);
}
public Tuple <string, string, string, string> GetAddedDeletedControlConstant()
{
//Control
var addedControlList = GetAddedControlList();
var deletedControlList = GetDeletedControlList();
if (addedControlList.Exists2(x => x.ProjectVersion > GetProjectSettings().ProjectVersion))
{
throw new Exception("Il existe dans la table des controles ajoutés, des controles de version supérieur");
}
if (deletedControlList.Exists2(x => x.ProjectVersion > GetProjectSettings().ProjectVersion))
{
throw new Exception("Il existe dans la table des controles supprimés, des controles de version supérieur");
}
var controlBuildResult = BuildControlListFromVersion(new List <ControlState>(), Math.Truncate(GetProjectSettings().ProjectVersion));
var controlComparator = new ListComparator <ControlState, ControlState>(controlBuildResult.Item1, x => x.Name, GetCurrentControlStateList(), x => x.Name);
var addedControlString = GetAddedControlString(controlComparator.NewList, GetProjectSettings().ProjectVersion);
var deletedControlString = GetDeletedControlString(controlComparator.RemovedList, GetProjectSettings().ProjectVersion);
//Constant
var addedConstantList = GetAddedConstantList();
var deletedConstantList = GetDeletedConstantList();
if (addedConstantList.Exists2(x => x.ProjectVersion > GetProjectSettings().ProjectVersion))
{
throw new Exception("Il existe dans la table des constantes ajoutées, des controles de version supérieur");
}
if (deletedConstantList.Exists2(x => x.ProjectVersion > GetProjectSettings().ProjectVersion))
{
throw new Exception("Il existe dans la table des constantes supprimées, des controles de version supérieur");
}
var constantBuildResult = BuildConstantListFromVersion(new List <ConstantState>(), Math.Truncate(GetProjectSettings().ProjectVersion));
var constantComparator = new ListComparator <ConstantState, ConstantState>(constantBuildResult, x => x.Name, GetCurrentConstantList(), x => x.Name);
var addedConstantString = GetAddedConstantString(constantComparator.NewList, GetProjectSettings().ProjectVersion);
var deletedConstantString = GetDeletedConstantString(constantComparator.RemovedList, GetProjectSettings().ProjectVersion);
return(new Tuple <string, string, string, string>(addedControlString, deletedControlString, addedConstantString, deletedConstantString));
}
/// <summary>
/// 测试初始化
/// </summary>
public ListComparatorTest()
{
_comparator = new ListComparator <AggregateRootSample, Guid>();
}
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();
}
}
public void ComparatorTest()
{
//class
var carList = new List <car>();
carList.Add(new car()
{
id = "1", power = 2
});
carList.Add(new car()
{
id = "3", power = 2
});
var carList2 = new List <car2>();
carList2.Add(new car2()
{
id = "1", power = 2
});
carList2.Add(new car2()
{
id = "4", power = 2
});
var carComparator = new ListComparator <car, car2>(carList, x => x.id, carList2, x => x.id);
if (carComparator.CommonList.Count != 1)
{
throw new Exception();
}
if (carComparator.NewList.Count != 1)
{
throw new Exception();
}
if (carComparator.RemovedList.Count != 1)
{
throw new Exception();
}
if (carComparator.IsOnlyCommon())
{
throw new Exception();
}
//class avec doublons
var carList5 = new List <car>();
carList5.Add(new car()
{
id = "1", power = 2
});
carList5.Add(new car()
{
id = "1", power = 2
});
carList5.Add(new car()
{
id = "3", power = 2
});
var carList6 = new List <car2>();
carList6.Add(new car2()
{
id = "1", power = 2
});
carList6.Add(new car2()
{
id = "4", power = 2
});
bool errorRaised = false;
try
{
var carComparator7 = new ListComparator <car, car2>(carList5, x => x.id, carList6, x => x.id);
}
catch (Exception)
{
errorRaised = true;
}
if (errorRaised == false)
{
throw new Exception();
}
//enum
var carList3 = new List <carEnum?>();
carList3.Add(carEnum.peugeot);
carList3.Add(carEnum.renault);
var carList4 = new List <carEnum?>();
carList4.Add(carEnum.peugeot);
carList4.Add(carEnum.tata);
var carComparator2 = new ListComparator <carEnum?, carEnum?>(carList3, x => x, carList4, x => x);
if (carComparator2.CommonList.Count != 1)
{
throw new Exception();
}
if (carComparator2.NewList.Count != 1)
{
throw new Exception();
}
if (carComparator2.RemovedList.Count != 1)
{
throw new Exception();
}
if (carComparator2.IsOnlyCommon())
{
throw new Exception();
}
}
public static Tuple <List <AddedControlManaged>, List <DeletedControlManaged>, List <AddedConstantManaged>, List <DeletedConstantManaged> > GetAddedDeletedControlConstant(this Project iProject)
{
//Control
var addedControlList = iProject.GetAddedControlList();
var deletedControlList = iProject.GetDeletedControlList();
if (addedControlList.Exists2(x => x.ProjectVersion > SettingsManager.GetProjectSettings(iProject).ProjectVersion))
{
throw new Exception("Il existe dans la table des controles ajoutés, des controles de version supérieur");
}
if (deletedControlList.Exists2(x => x.ProjectVersion > SettingsManager.GetProjectSettings(iProject).ProjectVersion))
{
throw new Exception("Il existe dans la table des controles supprimés, des controles de version supérieur");
}
var controlBuildResult = iProject.BuildControlListFromVersion(new List <ControlState>(), Math.Truncate(SettingsManager.GetProjectSettings(iProject).ProjectVersion));
var controlComparator = new ListComparator <ControlState, ControlState>(controlBuildResult.Item1, x => x.Name, GetCurrentControlStateList(iProject), x => x.Name);
var addedControlManagedList = new List <AddedControlManaged>();
foreach (var item in controlComparator.NewList.Enum())
{
addedControlManagedList.Add(new AddedControlManaged()
{
ControlName = item.Name, Message = "", ProjectVersion = SettingsManager.GetProjectSettings(iProject).ProjectVersion
});
}
var deletedControlManagedList = new List <DeletedControlManaged>();
foreach (var item in controlComparator.RemovedList.Enum())
{
deletedControlManagedList.Add(new DeletedControlManaged()
{
ControlName = item.Name, Message = "", ProjectVersion = SettingsManager.GetProjectSettings(iProject).ProjectVersion
});
}
//Constant
var addedConstantList = iProject.GetAddedConstantList();
var deletedConstantList = iProject.GetDeletedConstantList();
if (addedConstantList.Exists2(x => x.ProjectVersion > SettingsManager.GetProjectSettings(iProject).ProjectVersion))
{
throw new Exception("Il existe dans la table des constantes ajoutées, des controles de version supérieur");
}
if (deletedConstantList.Exists2(x => x.ProjectVersion > SettingsManager.GetProjectSettings(iProject).ProjectVersion))
{
throw new Exception("Il existe dans la table des constantes supprimées, des controles de version supérieur");
}
var constantBuildResult = iProject.BuildConstantListFromVersion(new List <ConstantState>(), Math.Truncate(SettingsManager.GetProjectSettings(iProject).ProjectVersion));
var constantComparator = new ListComparator <ConstantState, ConstantState>(constantBuildResult, x => x.Name, GetCurrentConstantList(iProject), x => x.Name);
var addedConstantManagedList = new List <AddedConstantManaged>();
foreach (var item in constantComparator.NewList.Enum())
{
addedConstantManagedList.Add(new AddedConstantManaged()
{
ConstantName = item.Name, ProjectVersion = SettingsManager.GetProjectSettings(iProject).ProjectVersion
});
}
var deletedConstantManagedList = new List <DeletedConstantManaged>();
foreach (var item in constantComparator.NewList.Enum())
{
deletedConstantManagedList.Add(new DeletedConstantManaged()
{
ConstantName = item.Name, ProjectVersion = SettingsManager.GetProjectSettings(iProject).ProjectVersion
});
}
return(new Tuple <List <AddedControlManaged>, List <DeletedControlManaged>, List <AddedConstantManaged>, List <DeletedConstantManaged> >(addedControlManagedList, deletedControlManagedList, addedConstantManagedList, deletedConstantManagedList));
}
public List <Tuple <string, ProjectDetails, ImportedDataTable> > GetImportedDataTableFromPackage(EnvironmentEnum iSourceEnvironment, EnvironmentEnum iDestinationEnvironment, Package iPackageDeployToStaging)
{
var result = new List <Tuple <string, ProjectDetails, ImportedDataTable> >();
var host = new EngineHost(HostEnvironment.CreateDefaultEnvironment(false));
var sourceGroupManager = host.CreateGroupManager();
var sourceProjectManager = host.CreateProjectManager();
var sourceGroup = sourceGroupManager.OpenGroup(iSourceEnvironment);
var packageDistinctProjectGUIDList = iPackageDeployToStaging.SubTasks.Where(x => x.ProjectGUID != null).GroupBy(x => x.ProjectGUID).Select(x => (Guid?)x.First().ProjectGUID).ToList();
var packageDistinctProjectDetailsList = new List <ProjectDetails>();
foreach (var item in packageDistinctProjectGUIDList)
{
if (item != null)
{
packageDistinctProjectDetailsList.Add(sourceGroup.Projects.GetProject((Guid)item));
}
}
//Bouclage sur les projets source inclus dans le package
var projectDevCounter = 1;
foreach (var projectItem in packageDistinctProjectDetailsList.Enum())
{
var message = "Récupération des tables dev du package, Projet {0}/{1} : {2}".FormatString(projectDevCounter, packageDistinctProjectDetailsList.Count(), projectItem.Name);
ReportProgress(message);
sourceProjectManager.OpenProject(sourceGroup, projectItem);
var project = sourceProjectManager.Project;
var importedDataTables = project.GetImportedDataTableList();
foreach (var tableItem in importedDataTables.Enum())
{
result.Add(new Tuple <string, ProjectDetails, ImportedDataTable>(iSourceEnvironment.GetName("FR"), projectItem, tableItem));
}
sourceProjectManager.CloseProject(false);
projectDevCounter++;
}
//fermeture du groupe
sourceGroupManager.CloseGroup();
//Récupère les projets de la destination non impacté par le package
var destinationGroupManager = host.CreateGroupManager();
var destinationProjectManager = host.CreateProjectManager();
var destinationGroup = destinationGroupManager.OpenGroup(iDestinationEnvironment);
var openedStagingProjectlist = destinationGroup.GetOpenedProjectList();
if (openedStagingProjectlist.IsNotNullAndNotEmpty())
{
throw new Exception("Certains projets du groupe '{0}' sont ouverts. L'analyse n'est donc pas possible.".FormatString(destinationGroup.Name) + Environment.NewLine + Environment.NewLine + openedStagingProjectlist.Select(x => x.Name).Concat(Environment.NewLine));
}
var projectStagingComparator = new ListComparator <ProjectDetails, ProjectDetails>(destinationGroup.GetProjectList(), x => x.Name, packageDistinctProjectDetailsList, x => x.Name);
var projetPreprodCounter = 1;
foreach (var projectItem in projectStagingComparator.RemovedList.Enum())
{
var message = "Récupération des tables préprod du package, Projet {0}/{1} : {2}".FormatString(projetPreprodCounter, projectStagingComparator.RemovedList.Count(), projectItem.Name);
ReportProgress(message);
destinationProjectManager.OpenProject(destinationGroup, projectItem);
var project = destinationProjectManager.Project;
var importedDataTables = project.GetImportedDataTableList();
foreach (var tableItem in importedDataTables.Enum())
{
result.Add(new Tuple <string, ProjectDetails, ImportedDataTable>(iDestinationEnvironment.GetName("FR"), projectItem, tableItem));
}
destinationProjectManager.CloseProject(false);
projetPreprodCounter++;
}
//fermeture du groupe
destinationGroupManager.CloseGroup();
return(result);
}
