/// <inheritdoc/>
public async Task <IEnumerable <ReleaseEntity> > Get(string org, string app, string tagName, List <string> buildStatus, List <string> buildResult)
{
List <ReleaseEntity> searchResult = new List <ReleaseEntity>();
try
{
using NpgsqlConnection conn = new NpgsqlConnection(_connectionString);
await conn.OpenAsync();
NpgsqlCommand pgcom = new NpgsqlCommand(checkExistingReleaseSql, conn);
pgcom.Parameters.AddWithValue("_org", NpgsqlDbType.Varchar, org);
pgcom.Parameters.AddWithValue("_app", NpgsqlDbType.Varchar, app);
pgcom.Parameters.AddWithValue("_tagname", NpgsqlDbType.Varchar, tagName);
pgcom.Parameters.AddWithValue("_buildstatus", NpgsqlDbType.Array | NpgsqlDbType.Text, buildStatus ?? (object)DBNull.Value);
pgcom.Parameters.AddWithValue("_buildresult", NpgsqlDbType.Array | NpgsqlDbType.Text, buildResult ?? (object)DBNull.Value);
using (NpgsqlDataReader reader = pgcom.ExecuteReader())
{
while (reader.Read())
{
ReleaseEntity releaseEntity = Deserialize(reader[0].ToString());
searchResult.Add(releaseEntity);
}
}
return(searchResult);
}
catch (Exception e)
{
_logger.LogError(e, "ReleaseRepository // Get(DocumentQueryModel) // Exception");
throw;
}
}
/// <inheritdoc/>
public async Task <ReleaseEntity> Create(ReleaseEntity releaseEntity)
{
try
{
using NpgsqlConnection conn = new NpgsqlConnection(_connectionString);
await conn.OpenAsync();
NpgsqlCommand pgcom = new NpgsqlCommand(insertReleaseSql, conn);
pgcom.Parameters.AddWithValue("buildid", releaseEntity.Build.Id);
pgcom.Parameters.AddWithValue("tagname", releaseEntity.TagName);
pgcom.Parameters.AddWithValue("org", releaseEntity.Org);
pgcom.Parameters.AddWithValue("app", releaseEntity.App);
pgcom.Parameters.AddWithValue("buildstatus", releaseEntity.Build.Status.ToEnumMemberAttributeValue());
pgcom.Parameters.AddWithValue("buildresult", releaseEntity.Build.Result.ToEnumMemberAttributeValue());
pgcom.Parameters.AddWithValue("created", releaseEntity.Created);
pgcom.Parameters.AddWithValue("entity", JsonString(releaseEntity));
await pgcom.ExecuteNonQueryAsync();
return(releaseEntity);
}
catch (Exception e)
{
_logger.LogError(e, "ReleaseRepository // Create // Exception");
throw;
}
}
/// <inheritdoc/>
public async Task <IEnumerable <ReleaseEntity> > Get(DocumentQueryModel query)
{
List <ReleaseEntity> searchResult = new List <ReleaseEntity>();
try
{
using NpgsqlConnection conn = new NpgsqlConnection(_connectionString);
await conn.OpenAsync();
NpgsqlCommand pgcom = new NpgsqlCommand(getReleasesSql, conn);
pgcom.Parameters.AddWithValue("_org", NpgsqlDbType.Varchar, query.Org);
pgcom.Parameters.AddWithValue("_app", NpgsqlDbType.Varchar, query.App);
pgcom.Parameters.AddWithValue("_limit", NpgsqlDbType.Integer, query.Top ?? int.MaxValue);
pgcom.Parameters.AddWithValue("_order_asc_desc", NpgsqlDbType.Varchar, query.SortDirection == SortDirection.Ascending ? "asc" : "desc");
using (NpgsqlDataReader reader = pgcom.ExecuteReader())
{
while (reader.Read())
{
ReleaseEntity releaseEntity = Deserialize(reader[0].ToString());
searchResult.Add(releaseEntity);
}
}
return(searchResult);
}
catch (Exception e)
{
_logger.LogError(e, "ReleaseRepository // Get(DocumentQueryModel) // Exception");
throw;
}
}
/// <inheritdoc/>
public async Task <DeploymentEntity> CreateAsync(DeploymentModel deployment)
{
DeploymentEntity deploymentEntity = new DeploymentEntity();
deploymentEntity.PopulateBaseProperties(_org, _app, _httpContext);
deploymentEntity.TagName = deployment.TagName;
deploymentEntity.EnvironmentName = deployment.Environment.Name;
ReleaseEntity release = await _releaseRepository.GetSucceededReleaseFromDb(
deploymentEntity.Org,
deploymentEntity.App,
deploymentEntity.TagName);
await _applicationInformationService
.UpdateApplicationInformationAsync(_org, _app, release.TargetCommitish, deployment.Environment);
Build queuedBuild = await QueueDeploymentBuild(release, deploymentEntity, deployment.Environment.Hostname);
deploymentEntity.Build = new BuildEntity
{
Id = queuedBuild.Id.ToString(),
Status = queuedBuild.Status,
Started = queuedBuild.StartTime
};
return(await _deploymentRepository.CreateAsync(deploymentEntity));
}
/// <inheritdoc/>
public async Task <IEnumerable <ReleaseEntity> > Get(string org, string buildId)
{
List <ReleaseEntity> searchResult = new List <ReleaseEntity>();
try
{
using NpgsqlConnection conn = new NpgsqlConnection(_connectionString);
await conn.OpenAsync();
NpgsqlCommand pgcom = new NpgsqlCommand(getReleaseSql, conn);
pgcom.Parameters.AddWithValue("_org", NpgsqlDbType.Varchar, org);
pgcom.Parameters.AddWithValue("_buildid", NpgsqlDbType.Varchar, buildId);
using (NpgsqlDataReader reader = pgcom.ExecuteReader())
{
while (reader.Read())
{
ReleaseEntity releaseEntity = Deserialize(reader[0].ToString());
searchResult.Add(releaseEntity);
}
}
return(searchResult);
}
catch (Exception e)
{
_logger.LogError(e, "ReleaseRepository // Get(string org, string buildId) // Exception");
throw;
}
}
/// <inheritdoc/>
public async Task <ReleaseEntity> CreateAsync(ReleaseEntity release)
{
release.PopulateBaseProperties(_org, _app, _httpContext);
await ValidateUniquenessOfRelease(release);
QueueBuildParameters queueBuildParameters = new QueueBuildParameters
{
AppCommitId = release.TargetCommitish,
AppOwner = release.Org,
AppRepo = release.App,
TagName = release.TagName
};
Build queuedBuild = await _azureDevOpsBuildClient.QueueAsync(
queueBuildParameters,
_azureDevOpsSettings.BuildDefinitionId);
release.Build = new BuildEntity
{
Id = queuedBuild.Id.ToString(),
Status = queuedBuild.Status,
Result = BuildResult.None,
Started = queuedBuild.StartTime
};
return(await _releaseRepository.CreateAsync(release));
}
private async Task ValidateUniquenessOfRelease(ReleaseEntity release)
{
SqlQuerySpec sqlQuery = CreateSqlQueryForUniqueness(release);
IEnumerable <ReleaseEntity> existingReleaseEntity = await _releaseRepository.GetWithSqlAsync <ReleaseEntity>(sqlQuery, _org);
if (existingReleaseEntity.Any())
{
throw new HttpRequestWithStatusException("A release with the same properties already exist.")
{
StatusCode = HttpStatusCode.Conflict
};
}
}
/// <inheritdoc/>
public async Task UpdateAsync(ReleaseEntity release, string appOwner)
{
IEnumerable <ReleaseEntity> releaseDocuments = await _releaseRepository.Get(appOwner, release.Build.Id);
ReleaseEntity releaseEntity = releaseDocuments.Single();
releaseEntity.Build.Status = release.Build.Status;
releaseEntity.Build.Result = release.Build.Result;
releaseEntity.Build.Started = release.Build.Started;
releaseEntity.Build.Finished = release.Build.Finished;
await _releaseRepository.Update(releaseEntity);
}
public async Task CreateAsync_Exception()
{
// Arrange
ReleaseEntity releaseEntity = new ReleaseEntity
{
TagName = "1",
Name = "1",
Body = "test-app",
TargetCommitish = "eec136ac2d31cf984d2053df79f181b99c3b4db5"
};
List <string> buildStatus = new List <string>();
buildStatus.Add(BuildStatus.InProgress.ToEnumMemberAttributeValue());
buildStatus.Add(BuildStatus.NotStarted.ToEnumMemberAttributeValue());
List <string> buildResult = new List <string>();
buildResult.Add(BuildResult.Succeeded.ToEnumMemberAttributeValue());
_releaseRepository.Setup(r => r.Get(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
buildStatus,
buildResult)).ReturnsAsync(GetReleases("createdRelease.json"));
ReleaseService releaseService = new ReleaseService(
_httpContextAccessor.Object,
new Mock <IAzureDevOpsBuildClient>().Object,
_releaseRepository.Object,
new TestOptionsMonitor <AzureDevOpsSettings>(GetAzureDevOpsSettings()),
_releaseLogger.Object);
// Act
HttpRequestWithStatusException resultException = null;
try
{
await releaseService.CreateAsync(releaseEntity);
}
catch (HttpRequestWithStatusException e)
{
resultException = e;
}
// Assert
Assert.NotNull(resultException);
Assert.Equal(HttpStatusCode.Conflict, resultException.StatusCode);
}
public Issue CreateIssue(CreateIssue data)
{
//prepare the initial issue model to insert
IssueEntity issueEntity = _mapper.Map <IssueEntity>(data);
ReleaseEntity releaseEntity = null;
if (data.ExistingPlannedReleaseId.HasValue && data.ExistingPlannedReleaseId.Value != 0)
{
//check if the release exists
releaseEntity = _releasesUow.Releases.SingleOrDefault(x => x.Id == data.ExistingPlannedReleaseId.Value);
if (releaseEntity == null)
{
throw new Exception("Invalid release id");
}
else
{
issueEntity.PlannedReleaseId = data.ExistingPlannedReleaseId;
}
}
else if (data.NewPlannedRelease != null)
{
//we can still change to a different isolation level because we haven't done anything with Releases database yet
_releasesUow.SetIsolationLevel(IsolationLevel.ReadCommitted);
releaseEntity = _mapper.Map <ReleaseEntity>(data.NewPlannedRelease);
_releasesUow.Releases.Add(releaseEntity);
_releasesUow.SaveChanges();
issueEntity.PlannedReleaseId = releaseEntity.Id;
}
//add issue to the database
_issuesUow.Issues.Add(issueEntity);
_issuesUow.SaveChanges();
//prepare and return models
var issue = _mapper.Map <Issue>(issueEntity);
if (releaseEntity != null)
{
issue.PlannedRelease = _mapper.Map <Release>(releaseEntity);
}
return(issue);
}
private async Task <Build> QueueDeploymentBuild(
ReleaseEntity release,
DeploymentEntity deploymentEntity,
string environmentHostname)
{
QueueBuildParameters queueBuildParameters = new QueueBuildParameters
{
AppCommitId = release.TargetCommitish,
AppOwner = deploymentEntity.Org,
AppRepo = deploymentEntity.App,
AppEnvironment = deploymentEntity.EnvironmentName,
Hostname = environmentHostname,
TagName = deploymentEntity.TagName
};
return(await _azureDevOpsBuildClient.QueueAsync(
queueBuildParameters,
_azureDevOpsSettings.DeployDefinitionId));
}
public async Task CreateAsync_OK()
{
// Arrange
ReleaseEntity releaseEntity = new ReleaseEntity
{
TagName = "1",
Name = "1",
Body = "test-app",
TargetCommitish = "eec136ac2d31cf984d2053df79f181b99c3b4db5"
};
List <string> buildStatus = new List <string>();
buildStatus.Add(BuildStatus.InProgress.ToEnumMemberAttributeValue());
buildStatus.Add(BuildStatus.NotStarted.ToEnumMemberAttributeValue());
List <string> buildResult = new List <string>();
buildResult.Add(BuildResult.Succeeded.ToEnumMemberAttributeValue());
_releaseRepository.Setup(r => r.Get(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), buildStatus, buildResult)).ReturnsAsync(new List <ReleaseEntity>());
_releaseRepository.Setup(r => r.Create(It.IsAny <ReleaseEntity>())).ReturnsAsync(GetReleases("createdRelease.json").First());
Mock <IAzureDevOpsBuildClient> azureDevOpsBuildClient = new Mock <IAzureDevOpsBuildClient>();
azureDevOpsBuildClient.Setup(b => b.QueueAsync(It.IsAny <QueueBuildParameters>(), It.IsAny <int>())).ReturnsAsync(GetBuild());
ReleaseService releaseService = new ReleaseService(
_httpContextAccessor.Object,
azureDevOpsBuildClient.Object,
_releaseRepository.Object,
new TestOptionsMonitor <AzureDevOpsSettings>(GetAzureDevOpsSettings()),
_releaseLogger.Object);
// Act
ReleaseEntity result = await releaseService.CreateAsync(releaseEntity);
// Assert
_releaseRepository.Verify(r => r.Get(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), buildStatus, buildResult), Times.Once);
_releaseRepository.Verify(r => r.Create(It.IsAny <ReleaseEntity>()), Times.Once);
azureDevOpsBuildClient.Verify(b => b.QueueAsync(It.IsAny <QueueBuildParameters>(), It.IsAny <int>()), Times.Once);
}
public IEnumerable <ReleaseEntity> GetReleases(IEnumerable <DumpEntity> dumpEntities)
{
var result = new List <ReleaseEntity>();
foreach (DumpEntity dump in dumpEntities)
{
ReleaseEntity release = GetRelease(dump);
ReleaseEntity?existingRelease = result.FirstOrDefault(r => r.Name == release.Name && r.Region == release.Region);
if (existingRelease == null)
{
release.Dumps.Add(dump);
result.Add(release);
}
else
{
existingRelease.Dumps.Add(dump);
}
}
return(result);
}
private ReleaseModel MapToReleaseModel(ReleaseEntity releaseEntity)
{
return(new ReleaseModel {
Id = releaseEntity.Id,
Title = releaseEntity.Title,
CountVideoOnline = releaseEntity.Playlist?.Count() ?? 0,
Poster = m_AnilibriaApiService.GetUrl(releaseEntity.Poster),
OnlineVideos = releaseEntity.Playlist?
.Select(
a => new OnlineVideoModel {
HDQuality = a.HD,
Order = a.Id,
SDQuality = a.SD,
FullHDQuality = a.FullHD,
Title = a.Title
}
)
.OrderBy(a => a.Order)
.ToList()
});
}
/// <inheritdoc/>
public async Task UpdateAsync(ReleaseEntity release)
{
SqlQuerySpec sqlQuerySpec = new SqlQuerySpec
{
QueryText = "SELECT * FROM db WHERE db.build.id = @buildId",
Parameters = new SqlParameterCollection
{
new SqlParameter("@buildId", release.Build.Id),
}
};
IEnumerable <ReleaseEntity> releaseDocuments = await _releaseRepository.GetWithSqlAsync <ReleaseEntity>(sqlQuerySpec);
ReleaseEntity releaseEntity = releaseDocuments.Single();
releaseEntity.Build.Status = release.Build.Status;
releaseEntity.Build.Result = release.Build.Result;
releaseEntity.Build.Started = release.Build.Started;
releaseEntity.Build.Finished = release.Build.Finished;
await _releaseRepository.UpdateAsync(releaseEntity);
}
private async Task ValidateUniquenessOfRelease(ReleaseEntity release)
{
List <string> buildStatus = new List <string>();
buildStatus.Add(BuildStatus.InProgress.ToEnumMemberAttributeValue());
buildStatus.Add(BuildStatus.NotStarted.ToEnumMemberAttributeValue());
List <string> buildResult = new List <string>();
buildResult.Add(BuildResult.Succeeded.ToEnumMemberAttributeValue());
IEnumerable <ReleaseEntity> existingReleaseEntity = await _releaseRepository.Get(release.Org, release.App, release.TagName, buildStatus, buildResult);
if (existingReleaseEntity.Any())
{
throw new HttpRequestWithStatusException("A release with the same properties already exist.")
{
StatusCode = HttpStatusCode.Conflict
};
}
}
private ReleaseEntity GetRelease(DumpEntity dump)
{
var nameParts = dump.Name.Split(new[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
var result = new ReleaseEntity
{
Name = nameParts[0],
Region = nameParts[1]
};
if (nameParts.Length > 2)
{
for (var i = 2; i < nameParts.Length; i++)
{
if (string.IsNullOrWhiteSpace(nameParts[i]))
{
continue;
}
var modifierType = (nameParts[i]) switch
{
"Demo" => "Demo",
"Alt" => "Alternative",
_ => "Unknown",
};
if (nameParts[i].StartsWith("Rev"))
{
modifierType = "Release";
}
dump.Modifiers.Add(new DumpModifierEntity
{
Description = nameParts[i],
ModType = modifierType
});
}
}
return(result);
}
/// <inheritdoc/>
public async Task Update(ReleaseEntity releaseEntity)
{
try
{
using NpgsqlConnection conn = new NpgsqlConnection(_connectionString);
await conn.OpenAsync();
NpgsqlCommand pgcom = new NpgsqlCommand(updateReleaseBuildSql, conn);
pgcom.Parameters.AddWithValue("_org", releaseEntity.Org);
pgcom.Parameters.AddWithValue("_buildid", releaseEntity.Build.Id);
pgcom.Parameters.AddWithValue("_buildstatus", releaseEntity.Build.Status.ToEnumMemberAttributeValue());
pgcom.Parameters.AddWithValue("_buildresult", releaseEntity.Build.Result.ToEnumMemberAttributeValue());
pgcom.Parameters.AddWithValue("_entity", JsonString(releaseEntity));
await pgcom.ExecuteNonQueryAsync();
}
catch (Exception e)
{
_logger.LogError(e, "ReleaseRepository // Update // Exception");
throw;
}
}
public async Task CreateAsync_NotStarted_CreatedRelease()
{
ReleaseEntity releaseToReturn = CreateReleaseEntity(BuildStatus.NotStarted, BuildResult.None);
_releaseDbRepoMock.Setup(x => x.GetWithSqlAsync <ReleaseEntity>(It.IsAny <SqlQuerySpec>()))
.ReturnsAsync(new List <ReleaseEntity> {
releaseToReturn
});
ReleaseEntity releaseEntity = new ReleaseEntity
{
TagName = releaseToReturn.TagName,
App = releaseToReturn.App,
Org = releaseToReturn.Org,
};
await _sut.CreateAsync(releaseEntity);
_azureDevOpsBuildServiceMock.Verify(
x => x.QueueAsync(It.IsAny <QueueBuildParameters>(), It.IsAny <int>()),
Times.Never);
_releaseDbRepoMock.Verify(
x => x.CreateAsync(It.IsAny <ReleaseEntity>()),
Times.Never);
}
private SqlQuerySpec CreateSqlQueryForUniqueness(ReleaseEntity release)
{
string resultSucceeded = BuildResult.Succeeded.ToEnumMemberAttributeValue();
string statusInProgress = BuildStatus.InProgress.ToEnumMemberAttributeValue();
string statusNotStarted = BuildStatus.NotStarted.ToEnumMemberAttributeValue();
string queryString = "SELECT * FROM db WHERE " +
"db.org = @org AND " +
"db.app = @app AND " +
"db.tagName = @tagName AND (" +
$"db.build.result = '{resultSucceeded}' OR " +
$"db.build.status = '{statusInProgress}' OR " +
$"db.build.status = '{statusNotStarted}')";
return(new SqlQuerySpec
{
QueryText = queryString,
Parameters = new SqlParameterCollection
{
new SqlParameter("@org", _org),
new SqlParameter("@app", _app),
new SqlParameter("@tagName", release.TagName),
}
});
}
private static string JsonString(ReleaseEntity releaseEntity)
{
return(JsonConvert.SerializeObject(releaseEntity));
}
private void UpdateCachedRelease(Release release, ReleaseEntity releaseEntity, ChangesEntity changesEntity)
{
var blocked = release.BlockedInfo?.Blocked ?? false;
var blockedReason = release.BlockedInfo?.Reason ?? "";
if (blocked && !releaseEntity.Blocked)
{
//TODO: blocked changes!!!!
}
releaseEntity.Blocked = blocked;
releaseEntity.BlockedReason = blockedReason;
if (releaseEntity.Description != release.Description)
{
releaseEntity.Description = release.Description;
}
if (releaseEntity.Type != release.Type)
{
releaseEntity.Type = release.Type;
}
if (releaseEntity.Status != release.Status)
{
releaseEntity.Status = release.Status;
}
if (releaseEntity.Series != release.Series?.TrimEnd())
{
releaseEntity.Series = release.Series;
}
if (releaseEntity.Announce != release.Announce)
{
releaseEntity.Announce = release.Announce;
}
if (releaseEntity.Season != release.Season)
{
releaseEntity.Season = release.Season;
}
releaseEntity.Rating = release.Favorite?.Rating ?? 0;
releaseEntity.Title = release.Names?.FirstOrDefault() ?? "";
releaseEntity.Names = release.Names.ToList();
releaseEntity.Voices = release.Voices.ToList();
releaseEntity.Timestamp = release.Last;
if (releaseEntity.Poster != release.Poster)
{
releaseEntity.Poster = release.Poster;
//invalidate poster's cache
if (m_DataContext.IsFileExists("Poster", release.Id))
{
m_DataContext.DeleteFile("Poster", release.Id);
}
}
if (releaseEntity.Playlist.Count() != release.Playlist.Count())
{
if (!changesEntity.NewOnlineSeries.ContainsKey(release.Id))
{
changesEntity.NewOnlineSeries.Add(release.Id, releaseEntity.Playlist.Count());
}
}
releaseEntity.Playlist = release.Playlist
.Select(
a =>
new PlaylistItemEntity {
Id = a.Id,
HD = a.HD,
SD = a.SD,
FullHD = a.FullHd,
Title = a.Title,
DownloadableHD = a.SrcHd,
DownloadableSD = a.SrcSd
}
)
.ToList();
if (releaseEntity.Torrents.Count() != release.Torrents.Count())
{
if (!changesEntity.NewTorrents.ContainsKey(release.Id))
{
changesEntity.NewTorrents.Add(release.Id, releaseEntity.Torrents.Count());
}
}
for (var i = 0; i < releaseEntity.Torrents.Count(); i++)
{
var oldTorrent = releaseEntity.Torrents.ElementAt(i);
var newTorrent = release.Torrents.ElementAtOrDefault(i);
if (newTorrent == null)
{
break;
}
if (oldTorrent.Size != newTorrent.Size)
{
if (!changesEntity.NewTorrentSeries.ContainsKey(release.Id))
{
changesEntity.NewTorrentSeries.Add(release.Id, new Dictionary <long, string> ());
}
if (!changesEntity.NewTorrentSeries[release.Id].ContainsKey(oldTorrent.Id))
{
changesEntity.NewTorrentSeries[release.Id].Add(oldTorrent.Id, oldTorrent.Size.ToString() ?? "");
}
}
}
releaseEntity.Torrents = release.Torrents
.Select(
a => new TorrentItemEntity {
Id = a.Id,
Completed = a.Completed,
Hash = a.Hash,
Leechers = a.Leechers,
Quality = a.Quality,
Seeders = a.Seeders,
Series = a.Series,
Size = a.Size,
Url = a.Url
}
)
.ToList();
}
