public VersionStructure SetMainVersion(VersionStructure spec)
{
var newCommitVersion = GetNewCommitVersion(spec);
spec.Versions.Add(newCommitVersion);
return(spec);
}
public void SaveVersionStructure(VersionStructure versionStructure)
{
var version = SetMainVersion(versionStructure);
var versTag = GetLastVersion(version, branch).ToString();
var tag = $"{packageName}.{versionStructure.PackageName}.{versTag}";
var fileFullpath = utils.GetPackageFullPath(string.Empty, versionStructure.PackageName, packageType);
repoVersion.SaveFile(fileFullpath, tag, version);
}
public static IVersionSpec SetVersionStructureWithoutDefaultGithub(VersionStructure versionStructure)
=> new VersionSpec(
"GIT HUB REPO, NO SE UTILIZA EN TEST",
"master",
"build.devops",
"token.github",
"trifenix.connect",
PackageType.nuget,
false,
"*****@*****.**",
"devops",
Mock.GitRepo(),
Mock.GitRepoVersionStructure(versionStructure),
new List <VersionStructure>()
);
public static IGithubRepo <VersionStructure> GitRepoVersionStructure(VersionStructure defaultVersionStructure)
{
var mock = new Mock <IGithubRepo <VersionStructure> >();
Action <string, string, VersionStructure> saveFile = (path, message, element) => Log.AppendLine($"saveFile<VersionStructure> => path : {path} , message : {message}, element : {element.PackageName}");
Func <string, VersionStructure> get = (path) =>
{
Log.AppendLine($"getElement => path : {path}");
return(defaultVersionStructure);
};
mock.Setup(s => s.SaveFile(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <VersionStructure>())).Callback(saveFile);
mock.Setup(s => s.GetElement(It.IsAny <string>())).Returns(get);
return(mock.Object);
}
private static CommitVersion[] GetLastVersion(VersionStructure version, string branch, int number)
{
var commitVersion = new List <CommitVersion>();
var end = version.Versions.Count < number?version.Versions.Count: number;
for (int i = 0; i < end; i++)
{
var lastVersion = GetLastVersion(version, branch);
version.Versions.Remove(lastVersion);
commitVersion.Add(lastVersion);
}
return(commitVersion.ToArray());
}
private static CommitVersion GetLastVersion(VersionStructure version, string branch)
{
var versions = version.Versions.Where(s => s.Branch.Equals(branch));
if (!versions.Any())
{
return(null);
}
var maxSemantinc = versions.Max(s => s.SemanticBaseVersion);
var maxSemanticVersions = versions.Where(s => s.SemanticBaseVersion.Equals(maxSemantinc));
var lastDate = maxSemanticVersions.Max(s => s.LastUpdate);
return(maxSemanticVersions.First(s => s.LastUpdate.Equals(lastDate)));
}
/// <summary>
/// Obtiene la metadata de un modelo
/// </summary>
/// <param name="assembly">Assembly donde se encuentra el modelo connect</param>
/// <param name="version"></param>
/// <param name="versionStructure"></param>
/// <returns></returns>
public static ModelMetaData GetMdm(Assembly assembly, string version, VersionStructure versionStructure)
{
// obtenemos global filter para asignar si es globalfilter la entidad.
var globalFilters = GlobalFilter.GetGlobalFilter(assembly);
// obtiene la metadata de las entidades
var entitiesFirstStep = GetFirstStepEntityCollection(assembly, globalFilters);
// obtiene la documentación de las entidades.
var mainDocumentation = GetMainDocumentation(assembly, entitiesFirstStep);
// obtiene la documentación de los filtros.
var filterProcess = GetFilterProcessDocs(assembly);
// asigna documentación a las entidades.
var entitiesWithDocumentation = entitiesFirstStep.Select(s => Docs.GetEntityWithDocumentation(s, mainDocumentation)).ToList();
// asigna los procesos.
var entitiesWithProcess = entitiesWithDocumentation.Select(s => GetEntityWithProcess(assembly, globalFilters, s, filterProcess)).ToList();
// obtiene las descripciones de las enumeraciones en el assembly.
var enumDescriptions = GetEnumDescriptions(assembly);
// falta asignar los deletes a entities
var md = new ModelMetaData
{
Version = version,
VersionStructure = versionStructure,
GlobalFilters = globalFilters,
EnumDescriptions = enumDescriptions,
DocFilters = filterProcess,
MdmEntities = entitiesWithProcess.ToArray(),
MainDocumentation = mainDocumentation,
Menu = new GroupMenuViewer[] { }
};
return(md);
}
private CommitVersion GetNewCommitVersion(VersionStructure vers)
{
var versions = vers.Versions.ToList();
var versionMasters = versions.Where(MasterWhere).ToList();
var versionReleases = versions.Where(ReleaseWhere).ToList();
// master
var maxMajor = versionMasters.Max(s => s.SemanticBaseVersion.Major);
var versionMasterMajors = versionMasters.Where(s => s.SemanticBaseVersion.Major.Equals(maxMajor)).ToList();
var maxMinor = versionMasterMajors.Max(s => s.SemanticBaseVersion.Minor);
var versionMasterPatchs = versionMasterMajors.Where(s => s.SemanticBaseVersion.Minor.Equals(maxMinor)).ToList();
var maxPatch = versionMasterPatchs.Max(s => s.SemanticBaseVersion.Patch);
var semanticMaster = new Semantic
{
Major = maxMajor,
Minor = maxMinor,
Patch = maxPatch
};
var existsReleases = versionReleases.Any();
// se debe checkear si existe un release con el misma versión.
var maxMajorRelease = existsReleases?versionReleases.Max(s => s.SemanticBaseVersion.Major):0;
var versionReleasesMajors = versionReleases.Where(s => s.SemanticBaseVersion.Major.Equals(maxMajorRelease)).ToList();
var maxMinorRelease = existsReleases?versionReleasesMajors.Max(s => s.SemanticBaseVersion.Minor):0;
var versionReleasesPatchs = versionReleasesMajors.Where(s => s.SemanticBaseVersion.Minor.Equals(maxMinorRelease)).ToList();
var maxPatchRelease = existsReleases?versionReleasesPatchs.Max(s => s.SemanticBaseVersion.Patch):0;
// releases
var semanticRelease = branch.ToLower().Contains("release")?utils.GetSemanticVersionFromRelease(branch):new Semantic {
Major = maxMajorRelease,
Minor = maxMinorRelease,
Patch = maxPatchRelease
};
bool ReleaseIsGreaterThanMaster = false;
if (semanticRelease.Major >= maxMajor && semanticRelease.Minor >= maxMinor && semanticRelease.Patch > maxPatch)
{
ReleaseIsGreaterThanMaster = releaseDependant;
}
else
{
releaseDependant = false;
}
if (!ReleaseIsGreaterThanMaster && branch.ToLower().Contains("release"))
{
throw new Exception("no se puede procesar una rama release menor a la master");
}
if (maxMajorRelease.Equals(semanticRelease.Major) && maxMinorRelease.Equals(semanticRelease.Minor) && maxPatchRelease.Equals(semanticRelease.Patch) && branch.ToLower().Contains("release"))
{
throw new Exception("Ya existe una versión igual en el repotorio de versiones, para release");
}
var branchLabel = GetPreReleaseLabel();
if ((branch.ToLower().Equals("master") || branch.ToLower().Equals("main")) && ReleaseIsGreaterThanMaster)
{
return(new CommitVersion
{
Branch = branch,
Build = build,
DependantRelease = true,
IsFeature = false,
LastUpdate = DateTime.Now,
PreReleaseLabel = string.Empty,
Preview = 0,
SemanticBaseVersion = new Semantic
{
Major = semanticRelease.Major,
Minor = semanticRelease.Minor,
Patch = semanticRelease.Major
}
});
}
if (branch.ToLower().Equals("master") || branch.ToLower().Equals("main"))
{
return(new CommitVersion
{
Branch = branch,
Build = build,
DependantRelease = false,
IsFeature = false,
LastUpdate = DateTime.Now,
PreReleaseLabel = string.Empty,
Preview = 0,
SemanticBaseVersion = new Semantic
{
Major = maxMajor,
Minor = maxMinor,
Patch = maxPatch + 1 // aquí suma.
}
});
}
if (branch.ToLower().Contains("release"))
{
return(new CommitVersion
{
Branch = branch,
Build = build,
DependantRelease = true,
IsFeature = false,
LastUpdate = DateTime.Now,
PreReleaseLabel = branchLabel,
Preview = 0,
SemanticBaseVersion = semanticRelease
});
}
if (branch.ToLower().Contains("develop"))
{
var versionsDevelop = versions.Where(DevelopWhere).Where(s => s.DependantRelease == ReleaseIsGreaterThanMaster).ToList();
var sem = (ReleaseIsGreaterThanMaster) ? semanticRelease : semanticMaster;
var versionSemanticDevelop = versionsDevelop.Where(s => s.SemanticBaseVersion.Equals(sem));
var maxPreview = versionSemanticDevelop.Any()?versionSemanticDevelop.Max(s => s.Preview):0;
return(new CommitVersion
{
Branch = branch,
Build = build,
DependantRelease = ReleaseIsGreaterThanMaster,
IsFeature = false,
LastUpdate = DateTime.Now,
PreReleaseLabel = GetPreReleaseLabel(),
Preview = maxPreview + 1,
SemanticBaseVersion = sem
});
}
var otherVersions = versions.Where(s => s.Branch.Equals(branch)).Where(s => s.DependantRelease == ReleaseIsGreaterThanMaster).ToList();
var semOthers = (ReleaseIsGreaterThanMaster) ? semanticRelease : semanticMaster;
var versionSemanticOThers = otherVersions.Where(s => s.SemanticBaseVersion.Equals(semOthers));
var maxPreviewOThers = versionSemanticOThers.Any()?versionSemanticOThers.Max(s => s.Preview):0;
return(new CommitVersion
{
Branch = branch,
Build = build,
DependantRelease = ReleaseIsGreaterThanMaster,
IsFeature = false,
LastUpdate = DateTime.Now,
PreReleaseLabel = GetPreReleaseLabel(),
Preview = maxPreviewOThers + 1,
SemanticBaseVersion = semOthers
});
}
