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