public async Task PublishNewVersion(IConnectApiHandler api)
{
if (PublishedId == null)
{
throw new Exception("Not a published collection");
}
if (string.IsNullOrWhiteSpace(Name))
{
throw new CollectionNameMissingException();
}
//if (scope != CollectionScope.Private && string.IsNullOrWhiteSpace(Description))
// throw new CollectionDescriptionMissingException();
if (!Items.Any())
{
throw new CollectionEmptyException();
}
await api.ChangeCollectionName(PublishedId.Value, Name).ConfigureAwait(false);
var version = PublishedVersion.AutoIncrement();
var hasCustomRepo = HasCustomRepo();
if (hasCustomRepo)
{
UpdateRepositoriesFromCustomRepo();
}
var servers = GetServersForPublishing();
await api.PublishNewCollectionVersion(new AddCollectionVersionModel {
Description = Description,
CollectionId = PublishedId.Value,
Version = version,
Dependencies = Items.OfType <ToggleableModProxy>()
.Select(Convert)
.ToList(),
Repositories = Repositories.ToList(),
Servers = servers
}).ConfigureAwait(false);
if (hasCustomRepo)
{
CleanupRepo();
}
UpdatePublishInfo(version);
if (hasCustomRepo)
{
await UploadImageIfAvailable(api).ConfigureAwait(false);
}
}
public async Task UpdatePublishedVersionAsync(string processorName, string aggregateRootTypeName, string aggregateRootId, int publishedVersion)
{
if (publishedVersion == 1)
{
var record = new PublishedVersion()
{
ProcessorName = processorName,
AggregateRootTypeName = aggregateRootTypeName,
AggregateRootId = aggregateRootId,
Version = 1,
CreatedOn = DateTime.UtcNow
};
try
{
await _publishedVersionCollection.GetCollection(aggregateRootId).InsertOneAsync(record);
}
catch (MongoWriteException ex)
{
if (ex.WriteError.Code == 11000 && ex.Message.Contains(nameof(PublishedVersion.ProcessorName)) && ex.Message.Contains(nameof(PublishedVersion.AggregateRootId)) && ex.Message.Contains(nameof(PublishedVersion.Version)))
{
return;
}
var errorMessage = string.Format("Insert aggregate published version has mongo exception, aggregateRootType: {0}, aggregateRootId: {1}", aggregateRootTypeName, aggregateRootId);
_logger.Error(errorMessage, ex);
throw;
}
catch (Exception ex)
{
var errorMessage = string.Format("Insert aggregate published version has unknown exception, aggregateRootType: {0}, aggregateRootId: {1}", aggregateRootTypeName, aggregateRootId);
_logger.Error(errorMessage, ex);
throw;
}
}
else
{
try
{
var builder = Builders <PublishedVersion> .Filter;
var filter = builder.Eq(e => e.ProcessorName, processorName)
& builder.Eq(e => e.AggregateRootId, aggregateRootId)
& builder.Eq(e => e.Version, publishedVersion - 1);
var update = Builders <PublishedVersion> .Update
.Set(e => e.Version, publishedVersion)
.Set(e => e.CreatedOn, DateTime.UtcNow);
await _publishedVersionCollection.GetCollection(aggregateRootId)
.UpdateOneAsync(filter, update);
await _aggregateSnapshotSaver.SaveAsync(aggregateRootId, _typeNameProvider.GetType(aggregateRootTypeName), publishedVersion);
}
catch (MongoException ex)
{
var errorMessage = string.Format("Update aggregate published version has mongo exception, aggregateRootType: {0}, aggregateRootId: {1}", aggregateRootTypeName, aggregateRootId);
_logger.Error(errorMessage, ex);
throw;
}
catch (Exception ex)
{
var errorMessage = string.Format("Update aggregate published version has unknown exception, aggregateRootType: {0}, aggregateRootId: {1}", aggregateRootTypeName, aggregateRootId);
_logger.Error(errorMessage, ex);
throw;
}
}
}
public async Task <AsyncTaskResult> UpdatePublishedVersionAsync(string processorName, string aggregateRootTypeName, string aggregateRootId, int publishedVersion)
{
if (publishedVersion == 1)
{
var record = new PublishedVersion()
{
ProcessorName = processorName,
AggregateRootTypeName = aggregateRootTypeName,
AggregateRootId = aggregateRootId,
Version = 1,
CreatedOn = DateTime.UtcNow
};
try
{
await _publishedVersionCollection.GetCollection(aggregateRootId).InsertOneAsync(record);
return(AsyncTaskResult.Success);
}
catch (MongoWriteException ex)
{
if (ex.WriteError.Code == 11000 && ex.Message.Contains(nameof(record.ProcessorName)) && ex.Message.Contains(nameof(record.AggregateRootId)) && ex.Message.Contains(nameof(record.Version)))
{
return(AsyncTaskResult.Success);
}
_logger.Error("Insert aggregate published version has write exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message));
}
catch (Exception ex)
{
_logger.Error("Insert aggregate published version has unknown exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.Failed, ex.Message));
}
}
else
{
try
{
var builder = Builders <PublishedVersion> .Filter;
var filter = builder.Eq(e => e.ProcessorName, processorName)
& builder.Eq(e => e.AggregateRootId, aggregateRootId)
& builder.Eq(e => e.Version, publishedVersion - 1);
var update = Builders <PublishedVersion> .Update
.Set(e => e.Version, publishedVersion)
.Set(e => e.CreatedOn, DateTime.UtcNow);
await _publishedVersionCollection.GetCollection(aggregateRootId)
.UpdateOneAsync(filter, update);
await _savableAggregateSnapshotter.SaveSnapshotAsync(aggregateRootId, _typeNameProvider.GetType(aggregateRootTypeName), publishedVersion);
return(AsyncTaskResult.Success);
}
catch (MongoException ex)
{
_logger.Error("Update aggregate published version has update exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.IOException, ex.Message));
}
catch (Exception ex)
{
_logger.Error("Update aggregate published version has unknown exception.", ex);
return(new AsyncTaskResult(AsyncTaskStatus.Failed, ex.Message));
}
}
}
