/// <summary>
/// Builds a <see cref="FilterDefinition{BsonDocument}" /> corresponding to the <see cref="CommitVersion" /> supplied
/// </summary>
/// <param name="commit">A <see cref="CommitVersion" /></param>
/// <returns>A <see cref="FilterDefinition{BsonDocument}" /> corresponding to the <see cref="CommitVersion" /></returns>
public static FilterDefinition <BsonDocument> ToFilter(this CommitVersion commit)
{
var builder = Builders <BsonDocument> .Filter;
var filter = builder.Gte(VersionConstants.COMMIT, commit.Value);
return(filter);
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey eventSourceKey, CommitVersion commitVersion)
{
using (var es = _database.GetContext())
{
return(BuildCommits(es.Commits.Include(c => c.Events).Where(c => c.Id >= (long)commitVersion.Value && c.EventSourceId == eventSourceKey.Id.Value && c.EventSourceArtifact == eventSourceKey.Artifact.Value).OrderBy(c => c.Id)));
}
}
public string SetPackageJsonNpmVersion(Dependency dependency, CommitVersion commit, string folder)
{
var pathPackageJson = Path.Combine(folder, dependency.pathPackageSettings);
var jsn = StringUtils.ReadAllText(pathPackageJson);
var version = commit.ToString();
var jobject = JsonConvert.DeserializeObject(jsn) as JObject;
var dependenciesArray = jobject["dependencies"];
var divisor = packageName.Split('_');
var packageJson = $"@{divisor[0]}/{divisor[1]}";
if (dependenciesArray != null && dependenciesArray.HasValues)
{
var packageExists = dependenciesArray.Any(s => ((JProperty)s).Name.Equals(packageJson));
if (packageExists)
{
var tkn = (JProperty)dependenciesArray.First(s => ((JProperty)s).Name.Equals(packageJson));
tkn.Value = $"^{version}";
}
}
var devDependenciesArray = jobject["devDependencies"];
if (devDependenciesArray != null && devDependenciesArray.HasValues)
{
var packageExists = devDependenciesArray.Any(s => ((JProperty)s).Name.Equals(packageJson));
if (packageExists)
{
var tkn = (JProperty)devDependenciesArray.First(s => ((JProperty)s).Name.Equals(packageJson));
tkn.Value = $"^{version}";
}
}
var peerDependenciesArray = jobject["peerDependencies"];
if (peerDependenciesArray != null && peerDependenciesArray.HasValues)
{
var packageExists = peerDependenciesArray.Any(s => ((JProperty)s).Name.Equals(packageJson));
if (packageExists)
{
var tkn = (JProperty)peerDependenciesArray.First(s => ((JProperty)s).Name.Equals(packageJson));
tkn.Value = $"^{version}";
}
}
return(jobject.ToString());
}
public string SetCsProjNugetVersion(Dependency dependency, CommitVersion commit, string folder)
{
var pathCsproj = Path.Combine(folder, dependency.pathPackageSettings);
var version = commit.ToString();
var xmlDoc = new XmlDocument();
xmlDoc.Load(pathCsproj);
for (int i = 0; i < xmlDoc.DocumentElement.ChildNodes.Count; i++)
{
var node = xmlDoc.DocumentElement.ChildNodes.Item(i);
if (node.Name.Equals("ItemGroup"))
{
var nodes = node.ChildNodes;
for (int x = 0; x < nodes.Count; x++)
{
var nodePackage = nodes.Item(x);
if (nodePackage.Name.Equals("PackageReference"))
{
var attributes = nodePackage.Attributes;
var attrInclude = attributes["Include"];
if (attrInclude != null && attrInclude.Value.Equals(packageName))
{
attributes["Version"].Value = $"{version}";
}
}
}
}
}
return(ToXmlString(xmlDoc));
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey eventSource, CommitVersion commitVersion)
{
return(GetCommits(QueryCommitsFor(_ => _.EventSourceId == eventSource.Id.Value && _.EventSourceArtifact == eventSource.Artifact.Value && _.CommitNumber >= commitVersion.Value),
$"Fetching commits on for event source { eventSource.Id.Value } of artifact:{ eventSource.Artifact.Value} after {commitVersion.ToString()}"));
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey key, CommitVersion commitVersion)
{
return(new Commits(_commits.Where(c => c.Source.Key == key && c.Source.Version.Commit >= commitVersion).ToList()));
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey eventSource, CommitVersion commitVersion)
{
ThrowIfDisposed();
return(_event_committer_and_fetcher.FetchFrom(eventSource, commitVersion));
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey eventSourceKey, CommitVersion commitVersion)
{
return(new Commits(FetchAllCommits().Where(_ => _.Source.Version.Commit >= commitVersion && _.Source.Artifact.Equals(eventSourceKey.Artifact) && _.Source.EventSource.Equals(eventSourceKey.Id))));
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey eventSource, CommitVersion commitVersion)
{
return(_eventCommitterAndFetcher.FetchFrom(eventSource, commitVersion));
}
private bool UpdateGithub(Dependency dependency, CommitVersion version, Action <string> eventMessage)
{
var gh = new GitHubRepo(new StringUtils().SetGithubToken(dependency.GithubHttp, token, userGithub), this.branch, this.userGithub, this.mail);
string folder;
try
{
folder = gh.Clone();
}
catch (Exception e)
{
eventMessage?.Invoke($"{dependency.PackageName} fallo al clonar con la rama {branch} desde {dependency.GithubHttp}");
eventMessage?.Invoke($"este es el mensaje de error:");
eventMessage?.Invoke($"{e.Message}");
return(false);
}
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($"{dependency.PackageName} es clonado en la carpeta temporal desde {dependency.GithubHttp}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($"{folder}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($" Desde url Github : {dependency.GithubHttp}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
string contentFile;
eventMessage?.Invoke($"Se obtiene {dependency.pathPackageSettings}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
if (packageType == PackageType.npm)
{
contentFile = SetPackageJsonNpmVersion(dependency, version, folder);
}
else
{
contentFile = SetCsProjNugetVersion(dependency, version, folder);
}
eventMessage?.Invoke($"{dependency.pathPackageSettings} procesado");
Exception exception = null;
var intentos = 0;
while (intentos <= 3)
{
try
{
gh.SaveFile(dependency.pathPackageSettings, $"{packageName}.{version}", contentFile);
}
catch (Exception exc)
{
if (exc.Message.ToLower().Contains("nothing to commit"))
{
break;
}
exception = exc;
Thread.Sleep(2000);
gh.Cloned = string.Empty;
intentos++;
try
{
folder = gh.Clone();
}
catch (Exception e)
{
eventMessage?.Invoke($"{dependency.PackageName} fallo al clonar con la rama {branch} desde {dependency.GithubHttp}");
eventMessage?.Invoke($"este es el mensaje de error:");
eventMessage?.Invoke($"{e.Message}");
}
if (packageType == PackageType.npm)
{
contentFile = SetPackageJsonNpmVersion(dependency, version, folder);
}
else
{
contentFile = SetCsProjNugetVersion(dependency, version, folder);
}
eventMessage?.Invoke($"Se limpia carpeta temporal para reintento = {intentos}, mensaje = {exc.Message}");
}
}
if (exception != null)
{
throw exception;
}
eventMessage?.Invoke($"El paquete {dependency.PackageName} ha actualizado {packageName} a {version}");
return(true);
}
public Commits FetchFrom(EventSourceKey eventSourceKey, CommitVersion commitVersion)
{
return(new Commits(new CommittedEventStream[0]));
}
/// <inheritdoc />
public Commits FetchFrom(EventSourceKey eventSourceKey, CommitVersion commitVersion)
{
return(FindCommitsWithSorting(eventSourceKey.ToFilter() & commitVersion.ToFilter()));
}
