public async Task <int> SendMessage(Message message, User activeUser)
{
IEnumerable <int> recipientIds = new List <int>();
message.SenderUserId = activeUser.Id;
using (var trans = TransactionScopeFactory.Create())
{
if (!await MessageRepo.UserIsChannelMember(message.ChannelId, activeUser.Id))
{
throw new CritterException($"Could not send that message, recipient does not exist!",
$"Invalid channel provided - channel: {message.ChannelId}, sender: {message.SenderUserId}",
System.Net.HttpStatusCode.BadRequest);
}
recipientIds = await MessageRepo.GetAllChannelMemberIds(message.ChannelId);
message.Id = await MessageRepo.CreateMessage(message, recipientIds.Where(id => id != activeUser.Id), activeUser.Id);
trans.Complete();
}
await Task.WhenAll(
recipientIds.Select(async userId =>
await(SignalRHubContext?.Clients?.Group(NotificationHub.GetUserGroupIdentifier(userId))
?.ReceiveNotification(
new NewMessageAlert(new MessageDetails()
{
Message = message, SenderUsername = activeUser.Username
}, message.ChannelId)
) ?? Task.CompletedTask)
)
);;
return(message.Id);
}
public async Task PurchaseShopItem(int itemId, User activeUser)
{
using (var trans = TransactionScopeFactory.Create())
{
(ShopItem shopItem, InventoryItem item)purchaseItem = (await ShopRepo.RetrieveShopItemByItemId(itemId)).FirstOrDefault();
if (purchaseItem.shopItem?.Price > 0 && activeUser.Cash >= purchaseItem.shopItem.Price)
{
var userChanges = new List <(int UserId, int CashDelta)> {
(activeUser.Id, (-1) * purchaseItem.shopItem.Price.Value)
};
if (purchaseItem.item.OwnerUserId != null)
{
userChanges.Add((purchaseItem.item.OwnerUserId.Value, purchaseItem.shopItem.Price.Value));//owner can be null if NPC shop
}
await UserDomain.ChangeUsersCash(userChanges);
await InventoryDomain.TransferItemOwner(activeUser.Id, purchaseItem.item.Id, purchaseItem.item.OwnerUserId);
if (!await ShopRepo.RemoveShopItem(itemId))
{
throw new CritterException("Couldn't purchase item!", $"Failed to remove {itemId} from its shop", System.Net.HttpStatusCode.Conflict);
}
}
trans.Complete();
}
}
public async Task TransferItemOwner(int?recipientUserId, int itemId, int?ownerId)
{
using (var trans = TransactionScopeFactory.Create())
{
if (!(await InventoryRepo.UpdateItemOwner(itemId, recipientUserId, ownerId)))
{
throw new CritterException("Could not transfer item ownership!",
$"Something went wrong with item {itemId}, trying to move to user {recipientUserId} from {ownerId}", System.Net.HttpStatusCode.Conflict);
}
trans.Complete();
}
}
public async Task ExecuteAsync(AddImageAssetCommand command, IExecutionContext executionContext)
{
var imageAsset = new ImageAsset();
imageAsset.FileDescription = command.Title;
imageAsset.FileName = SlugFormatter.ToSlug(command.Title);
imageAsset.DefaultAnchorLocation = command.DefaultAnchorLocation;
_entityTagHelper.UpdateTags(imageAsset.ImageAssetTags, command.Tags, executionContext);
_entityAuditHelper.SetCreated(imageAsset, executionContext);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
// if adding, save this up front
_dbContext.ImageAssets.Add(imageAsset);
await _imageAssetFileService.SaveAsync(command.File, imageAsset, nameof(command.File));
command.OutputImageAssetId = imageAsset.ImageAssetId;
scope.Complete();
}
await _messageAggregator.PublishAsync(new ImageAssetAddedMessage()
{
ImageAssetId = imageAsset.ImageAssetId
});
}
public async Task ExecuteAsync(DeleteImageAssetCommand command, IExecutionContext executionContext)
{
var imageAsset = await _dbContext
.ImageAssets
.FilterById(command.ImageAssetId)
.SingleOrDefaultAsync();
if (imageAsset != null)
{
imageAsset.IsDeleted = true;
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(ImageAssetEntityDefinition.DefinitionCode, imageAsset.ImageAssetId), executionContext);
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_imageAssetCache.Clear(command.ImageAssetId);
await _messageAggregator.PublishAsync(new ImageAssetDeletedMessage()
{
ImageAssetId = command.ImageAssetId
});
}
}
public async Task ExecuteAsync(UpdateImageAssetCommand command, IExecutionContext executionContext)
{
bool hasNewFile = command.File != null;
var imageAsset = await _dbContext
.ImageAssets
.Include(a => a.ImageAssetTags)
.ThenInclude(a => a.Tag)
.FilterById(command.ImageAssetId)
.SingleOrDefaultAsync();
imageAsset.FileDescription = command.Title;
imageAsset.FileName = SlugFormatter.ToSlug(command.Title);
imageAsset.DefaultAnchorLocation = command.DefaultAnchorLocation;
_entityTagHelper.UpdateTags(imageAsset.ImageAssetTags, command.Tags, executionContext);
_entityAuditHelper.SetUpdated(imageAsset, executionContext);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
if (hasNewFile)
{
await _imageAssetFileService.SaveAsync(command.File, imageAsset, nameof(command.File));
}
await _dbContext.SaveChangesAsync();
scope.Complete();
}
if (hasNewFile)
{
await _imageAssetFileCache.ClearAsync(imageAsset.ImageAssetId);
}
_imageAssetCache.Clear(imageAsset.ImageAssetId);
}
public async Task ExecuteAsync(DeleteCustomEntityDraftVersionCommand command, IExecutionContext executionContext)
{
var draft = await _dbContext
.CustomEntityVersions
.Include(v => v.CustomEntity)
.SingleOrDefaultAsync(v => v.CustomEntityId == command.CustomEntityId &&
v.WorkFlowStatusId == (int)WorkFlowStatus.Draft);
if (draft != null)
{
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityUpdatePermission>(draft.CustomEntity.CustomEntityDefinitionCode);
var definitionCode = draft.CustomEntity.CustomEntityDefinitionCode;
var versionId = draft.CustomEntityVersionId;
using (var scope = _transactionScopeFactory.Create())
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(CustomEntityVersionEntityDefinition.DefinitionCode, draft.CustomEntityVersionId));
_dbContext.CustomEntityVersions.Remove(draft);
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_customEntityCache.Clear(definitionCode, command.CustomEntityId);
await _messageAggregator.PublishAsync(new CustomEntityDraftVersionDeletedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityDefinitionCode = definitionCode,
CustomEntityVersionId = versionId
});
}
}
public async Task ExecuteAsync(SetupCofoundryCommand command, IExecutionContext executionContext)
{
var settings = await _queryExecutor.ExecuteAsync(new GetSettingsQuery <InternalSettings>());
if (settings.IsSetup)
{
throw new InvalidOperationException("Site is already set up.");
}
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
var userId = await CreateAdminUser(command);
var impersonatedUserContext = await GetImpersonatedUserContext(executionContext, userId);
var settingsCommand = await _queryExecutor.ExecuteAsync(new GetUpdateCommandQuery <UpdateGeneralSiteSettingsCommand>());
settingsCommand.ApplicationName = command.ApplicationName;
await _commandExecutor.ExecuteAsync(settingsCommand, impersonatedUserContext);
// Take the opportunity to break the cache in case any additional install scripts have been run since initialization
_objectCacheFactory.Clear();
// Setup Complete
await _commandExecutor.ExecuteAsync(new MarkAsSetUpCommand(), impersonatedUserContext);
scope.Complete();
}
}
public async Task ExecuteAsync(AddDocumentAssetCommand command, IExecutionContext executionContext)
{
var documentAsset = new DocumentAsset();
documentAsset.Title = command.Title;
documentAsset.Description = command.Description ?? string.Empty;
documentAsset.FileName = SlugFormatter.ToSlug(command.Title);
_entityTagHelper.UpdateTags(documentAsset.DocumentAssetTags, command.Tags, executionContext);
_entityAuditHelper.SetCreated(documentAsset, executionContext);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
_dbContext.DocumentAssets.Add(documentAsset);
await _documentAssetCommandHelper.SaveFile(command.File, documentAsset);
command.OutputDocumentAssetId = documentAsset.DocumentAssetId;
scope.Complete();
}
await _messageAggregator.PublishAsync(new DocumentAssetAddedMessage()
{
DocumentAssetId = documentAsset.DocumentAssetId
});
}
public async Task ExecuteAsync(DeleteCustomEntityCommand command, IExecutionContext executionContext)
{
var customEntity = await _dbContext
.CustomEntities
.SingleOrDefaultAsync(p => p.CustomEntityId == command.CustomEntityId);
if (customEntity != null)
{
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityDeletePermission>(customEntity.CustomEntityDefinitionCode);
using (var scope = _transactionScopeFactory.Create())
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(customEntity.CustomEntityDefinitionCode, customEntity.CustomEntityId));
_dbContext.CustomEntities.Remove(customEntity);
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_customEntityCache.Clear(customEntity.CustomEntityDefinitionCode, command.CustomEntityId);
await _messageAggregator.PublishAsync(new CustomEntityDeletedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityDefinitionCode = customEntity.CustomEntityDefinitionCode
});
}
}
public async Task ExecuteAsync(DeleteDocumentAssetCommand command, IExecutionContext executionContext)
{
var documentAsset = await _dbContext
.DocumentAssets
.FilterById(command.DocumentAssetId)
.SingleOrDefaultAsync();
if (documentAsset != null)
{
documentAsset.IsDeleted = true;
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(DocumentAssetEntityDefinition.DefinitionCode, documentAsset.DocumentAssetId));
await _dbContext.SaveChangesAsync();
scope.Complete();
}
await _messageAggregator.PublishAsync(new DocumentAssetAddedMessage()
{
DocumentAssetId = command.DocumentAssetId
});
}
}
public async Task ExecuteAsync(PublishPageCommand command, IExecutionContext executionContext)
{
var pageVersions = await QueryVersions(command).ToListAsync();
using (var scope = _transactionScopeFactory.Create())
{
// Find the published one and make it appPageroved
var publishedVersion = pageVersions.SingleOrDefault(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Published);
if (publishedVersion != null)
{
publishedVersion.WorkFlowStatusId = (int)WorkFlowStatus.Approved;
await _dbContext.SaveChangesAsync();
}
// Find the draft page and make it published
SetDraftVersionPublished(command, pageVersions);
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_pageCache.Clear();
await _messageAggregator.PublishAsync(new PagePublishedMessage()
{
PageId = command.PageId
});
}
public async Task SaveFile(IUploadedFile uploadedFile, DocumentAsset documentAsset)
{
using (var inputSteam = await uploadedFile.OpenReadStreamAsync())
{
bool isNew = documentAsset.DocumentAssetId < 1;
documentAsset.FileExtension = Path.GetExtension(uploadedFile.FileName).TrimStart('.');
documentAsset.FileSizeInBytes = Convert.ToInt32(inputSteam.Length);
documentAsset.ContentType = uploadedFile.MimeType;
// Save at this point if it's a new image
if (isNew)
{
await _dbContext.SaveChangesAsync();
}
var fileName = Path.ChangeExtension(documentAsset.DocumentAssetId.ToString(), documentAsset.FileExtension);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
// Save the raw file directly
await CreateFileAsync(isNew, fileName, inputSteam);
if (!isNew)
{
await _dbContext.SaveChangesAsync();
}
scope.Complete();
}
}
}
public async Task ExecuteAsync(DeletePageCommand command, IExecutionContext executionContext)
{
var page = await _dbContext
.Pages
.SingleOrDefaultAsync(p => p.PageId == command.PageId);
if (page != null)
{
page.IsDeleted = true;
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(PageEntityDefinition.DefinitionCode, command.PageId), executionContext);
await _dbContext.SaveChangesAsync();
await _pageStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.PageId);
scope.Complete();
}
_pageCache.Clear(command.PageId);
await _messageAggregator.PublishAsync(new PageDeletedMessage()
{
PageId = command.PageId
});
}
}
public async Task ExecuteAsync(UpdatePageDraftVersionCommand command, IExecutionContext executionContext)
{
var draft = await GetDraftVersion(command.PageId).SingleOrDefaultAsync();
using (var scope = _transactionScopeFactory.Create())
{
draft = await CreateDraftIfRequiredAsync(command.PageId, draft);
UpdateDraft(command, draft);
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_pageCache.Clear(command.PageId);
await _messageAggregator.PublishAsync(new PageDraftVersionUpdatedMessage()
{
PageId = command.PageId,
PageVersionId = draft.PageVersionId
});
if (command.Publish)
{
await _commandExecutor.ExecuteAsync(new PublishPageCommand(draft.PageId));
}
}
public async Task <Pet> CreatePet(Pet pet, User user)
{
using (var trans = TransactionScopeFactory.Create())
{
var color = (await CfgRepo.RetrieveColorsByIds(pet.ColorId)).FirstOrDefault();
var species = (await CfgRepo.RetrieveSpeciesByIds(pet.SpeciesId)).FirstOrDefault();
await validatePet(pet, color, species, user);
pet.Level = 0;
pet.OwnerUserId = user.Id;
pet.BaseHealthPoints = species.BaseHealthPoints;
pet.HealthPoints = species.BaseHealthPoints; //todo pet stats STR DEX WIS CHAR INT CON luck????
pet.FoodBasis = species.FoodBasis;
pet.FoodLevel = species.FoodBasis;
pet.LastFoodUpdate = DateTime.UtcNow;
try
{
pet.Id = await PetRepo.CreatePet(pet, pet.OwnerUserId);
}
catch (Exception ex)
{
throw new CritterException("Could not create pet, please try again!", "Something went wrong unexpectedly at the DB level", System.Net.HttpStatusCode.InternalServerError, ex, LogLevel.Critical);
}
//todo verify configs
trans.Complete();
}
pet = (await RetrievePets(pet.Id)).FirstOrDefault();
return(pet);
}
public async Task ExecuteAsync(DeleteWebDirectoryCommand command, IExecutionContext executionContext)
{
var webDirectory = await _dbContext
.WebDirectories
.Include(w => w.ChildWebDirectories)
.SingleOrDefaultAsync(w => w.WebDirectoryId == command.WebDirectoryId);
if (webDirectory != null)
{
if (!webDirectory.ParentWebDirectoryId.HasValue)
{
throw new ValidationException("Cannot delete the root web directory.");
}
webDirectory.IsActive = false;
using (var scope = _transactionScopeFactory.Create())
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(WebDirectoryEntityDefinition.DefinitionCode, webDirectory.WebDirectoryId));
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_cache.Clear();
}
}
public async Task ExecuteAsync(AddPageCommand command, IExecutionContext executionContext)
{
// Custom Validation
await ValidateIsPageUniqueAsync(command, executionContext);
var page = await MapPage(command, executionContext);
_dbContext.Pages.Add(page);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _dbContext.SaveChangesAsync();
await _pageStoredProcedures.UpdatePublishStatusQueryLookupAsync(page.PageId);
scope.Complete();
}
_pageCache.ClearRoutes();
// Set Ouput
command.OutputPageId = page.PageId;
await _messageAggregator.PublishAsync(new PageAddedMessage()
{
PageId = page.PageId,
HasPublishedVersionChanged = command.Publish
});
}
public async Task ExecuteAsync(DeletePageDraftVersionCommand command, IExecutionContext executionContext)
{
var draft = await _dbContext
.PageVersions
.SingleOrDefaultAsync(v => v.PageId == command.PageId &&
v.WorkFlowStatusId == (int)WorkFlowStatus.Draft &&
!v.IsDeleted);
if (draft != null)
{
var versionId = draft.PageVersionId;
draft.IsDeleted = true;
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(PageVersionEntityDefinition.DefinitionCode, draft.PageVersionId), executionContext);
await _dbContext.SaveChangesAsync();
await _pageStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.PageId);
scope.Complete();
}
_pageCache.Clear(command.PageId);
await _messageAggregator.PublishAsync(new PageDraftVersionDeletedMessage()
{
PageId = command.PageId,
PageVersionId = versionId
});
}
}
public async Task ExecuteAsync(UpdateDocumentAssetCommand command, IExecutionContext executionContext)
{
bool hasNewFile = command.File != null;
var documentAsset = await _dbContext
.DocumentAssets
.Include(a => a.DocumentAssetTags)
.Include(a => a.DocumentAssetTags.Select(pt => pt.Tag))
.FilterById(command.DocumentAssetId)
.SingleOrDefaultAsync();
documentAsset.Title = command.Title;
documentAsset.Description = command.Description ?? string.Empty;
documentAsset.FileName = SlugFormatter.ToSlug(command.Title);
_entityTagHelper.UpdateTags(documentAsset.DocumentAssetTags, command.Tags, executionContext);
_entityAuditHelper.SetUpdated(documentAsset, executionContext);
using (var scope = _transactionScopeFactory.Create())
{
if (hasNewFile)
{
await _documentAssetCommandHelper.SaveFile(command.File, documentAsset);
}
await _dbContext.SaveChangesAsync();
scope.Complete();
}
}
private Func <System.Transactions.TransactionScope> CreateScopeFactory(
System.Transactions.TransactionScopeOption transactionScopeOption = System.Transactions.TransactionScopeOption.Required,
System.Transactions.IsolationLevel isolationLevel = System.Transactions.IsolationLevel.ReadCommitted
)
{
return(() => _transactionScopeFactory.Create(
transactionScopeOption,
isolationLevel
));
}
public async Task ExecuteAsync(UpdateCustomEntityDraftVersionCommand command, IExecutionContext executionContext)
{
var definition = _customEntityDefinitionRepository.GetByCode(command.CustomEntityDefinitionCode);
var draft = await GetDraftVersionAsync(command);
using (var scope = _transactionScopeFactory.Create())
{
draft = await CreateDraftIfRequiredAsync(command, draft);
await ValidateTitle(command, draft, definition);
UpdateDraft(command, draft);
await _dbContext.SaveChangesAsync();
var dependencyCommand = new UpdateUnstructuredDataDependenciesCommand(
CustomEntityVersionEntityDefinition.DefinitionCode,
draft.CustomEntityVersionId,
command.Model);
await _commandExecutor.ExecuteAsync(dependencyCommand);
scope.Complete();
}
_customEntityCache.Clear(command.CustomEntityDefinitionCode, command.CustomEntityId);
await _messageAggregator.PublishAsync(new CustomEntityDraftVersionUpdatedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityDefinitionCode = command.CustomEntityDefinitionCode,
CustomEntityVersionId = draft.CustomEntityVersionId
});
if (command.Publish)
{
using (var scope = _transactionScopeFactory.Create())
{
await _commandExecutor.ExecuteAsync(new PublishCustomEntityCommand(draft.CustomEntityId));
scope.Complete();
}
}
}
public void ResetPassword(User user, IResetUserPasswordCommand command, IExecutionContext executionContext)
{
ValidateUserAccountExists(user);
ValidateUserArea(user.UserAreaCode);
var existingIncompleteRequests = QueryIncompleteRequests(user).ToList();
SetExistingRequestsComplete(existingIncompleteRequests);
var request = CreateRequest(executionContext, user);
SetMailTemplate(command, user, request);
using (var scope = _transactionScopeFactory.Create())
{
_dbContext.SaveChanges();
_mailService.Send(user.Email, user.GetFullName(), command.MailTemplate);
scope.Complete();
}
}
public async Task <string> CreateAccount(User user)
{
bool conflictFound = await UserRepo.UserExistsByUsernameOrEmail(user.Username, user.EmailAddress);
if (conflictFound)
{
throw new CritterException($"Sorry, someone already exists with that name or email!", $"Duplicate account creation attempt on {user.Username} or {user.EmailAddress}", System.Net.HttpStatusCode.Conflict);
}
using (var trans = TransactionScopeFactory.Create())
{
user.Cash = 500; //TODO economics
user.IsActive = true;
user.Salt = BCrypt.Net.BCrypt.GenerateSalt();
user.Password = BCrypt.Net.BCrypt.HashPassword(user.Password, user.Salt);
user.Id = await UserRepo.CreateUser(user) ?? throw new CritterException("Could not create account, try again!", null, System.Net.HttpStatusCode.Conflict);
List <int> metaphones = new List <int>();
var doubles = new List <ShortDoubleMetaphone>();
doubles.Add(new ShortDoubleMetaphone(user.Username));
doubles.Add(new ShortDoubleMetaphone(user.FirstName));
doubles.Add(new ShortDoubleMetaphone(user.LastName));
doubles.ForEach(d => { metaphones.Add(d.PrimaryShortKey); metaphones.Add(d.AlternateShortKey); });
metaphones = metaphones.Distinct().AsList();
if (!await UserRepo.InsertMetaphone(user.Id, metaphones.ToArray()))
{
Log.Logger.Error($"Failed to create metaphone for {user.Id}");
}
if (!await UserRepo.CreateUserMeta(user.Id, ""))
{
throw new CritterException("Could not create account, try again!", $"Failed to create a user meta for user ID {user.Id}", System.Net.HttpStatusCode.InternalServerError);
}
trans.Complete();
}
user = await RetrieveUser(user.Id);
return(JWTProvider.GenerateToken(user));
}
public async Task ExecuteAsync(PublishCustomEntityCommand command, IExecutionContext executionContext)
{
// Prefer draft, but update published entity if no draft (only one draft permitted)
var version = await _dbContext
.CustomEntityVersions
.Include(v => v.CustomEntity)
.Where(v => v.CustomEntityId == command.CustomEntityId && (v.WorkFlowStatusId == (int)WorkFlowStatus.Draft || v.WorkFlowStatusId == (int)WorkFlowStatus.Published))
.OrderByDescending(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft)
.ThenByDescending(v => v.CreateDate)
.FirstOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(version, command.CustomEntityId);
var definition = _customEntityDefinitionRepository.GetByCode(version.CustomEntity.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, version.CustomEntity.CustomEntityDefinitionCode);
await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityPublishPermission>(definition.CustomEntityDefinitionCode);
UpdatePublishDate(command, executionContext, version);
if (version.WorkFlowStatusId == (int)WorkFlowStatus.Published)
{
// only thing we can do with a published version is update the date
await _dbContext.SaveChangesAsync();
}
else
{
await ValidateTitle(version, definition);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await UpdateUrlSlugIfRequired(version, definition);
version.WorkFlowStatusId = (int)WorkFlowStatus.Published;
version.CustomEntity.PublishStatusCode = PublishStatusCode.Published;
await _dbContext.SaveChangesAsync();
await _customEntityStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.CustomEntityId);
scope.Complete();
}
}
_customEntityCache.Clear(version.CustomEntity.CustomEntityDefinitionCode, command.CustomEntityId);
await _messageAggregator.PublishAsync(new CustomEntityPublishedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityDefinitionCode = version.CustomEntity.CustomEntityDefinitionCode
});
}
public void Execute(CompleteUserPasswordResetCommand command, IExecutionContext executionContext)
{
var validationResult = _queryExecutor.Execute(CreateValidationQuery(command));
ValidatePasswordRequest(validationResult);
var request = QueryPasswordRequestIfToken(command).SingleOrDefault();
EntityNotFoundException.ThrowIfNull(request, command.UserPasswordResetRequestId);
UpdatePasswordAndSetComplete(request, command, executionContext);
SetMailTemplate(command, request.User);
using (var scope = _transactionScopeFactory.Create())
{
_dbContext.SaveChanges();
_mailService.Send(request.User.Email, request.User.GetFullName(), command.MailTemplate);
scope.Complete();
}
}
public IActionResult Post([FromForm] RegisterDocumentModel model)
{
Guard.AgainstNull(model, nameof(model));
try
{
model.ApplyInvariants();
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
var id = Guid.NewGuid();
var effectiveFromDate = DateTime.Now;
using (var scope = _transactionScopeFactory.Create())
using (_databaseContextFactory.Create())
using (var stream = new MemoryStream())
{
var result = _documentQuery.Search(new DataAccess.Query.Document.Specification().AddId(model.Id).GetActiveOnly()).ToList();
if (result.Any())
{
var document = result.First();
if (model.EffectiveFromDate <= document.EffectiveFromDate)
{
return(BadRequest(
$"Existing active document (id = '{document.Id}' / reference id = '{document.ReferenceId}') is effective from date '{document.EffectiveFromDate:O}' and the document being registered for the same reference id is effective from date '{model.EffectiveFromDate:O}' which on or after the new one. The new document should be effective from a date after the existing document."));
}
}
model.Document.CopyTo(stream);
_documentRepository.Save(new Document(id, model.Id, model.Document.FileName, model.ContentType,
stream.ToArray(), model.SystemName, model.Username, effectiveFromDate));
_serviceBus.Send(new RegisterDocumentCommand
{
Id = id
});
scope.Complete();
}
return(Ok(new
{
DocumentId = id,
EffectiveFromDate = $"{effectiveFromDate:O}"
}));
}
public async Task ExecuteAsync(UnPublishPageCommand command, IExecutionContext executionContext)
{
var page = await _dbContext
.Pages
.FilterActive()
.FilterByPageId(command.PageId)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(page, command.PageId);
if (page.PublishStatusCode == PublishStatusCode.Unpublished)
{
// No action
return;
}
var version = await _dbContext
.PageVersions
.Include(p => p.Page)
.Where(v => v.PageId == command.PageId &&
!v.IsDeleted &&
!v.Page.IsDeleted &&
(v.WorkFlowStatusId == (int)WorkFlowStatus.Draft || v.WorkFlowStatusId == (int)WorkFlowStatus.Published))
.OrderByDescending(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft)
.ThenByDescending(v => v.CreateDate)
.FirstOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(version, command.PageId);
page.PublishStatusCode = PublishStatusCode.Unpublished;
version.WorkFlowStatusId = (int)WorkFlowStatus.Draft;
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _dbContext.SaveChangesAsync();
await _pageStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.PageId);
scope.Complete();
}
_pageCache.Clear();
await _messageAggregator.PublishAsync(new PageUnPublishedMessage()
{
PageId = command.PageId
});
}
public void Execute(OnStartTransactionScope pipelineEvent)
{
var state = pipelineEvent.Pipeline.State;
var scope = state.GetTransactionScope();
if (scope != null)
{
throw new InvalidOperationException(
string.Format(Resources.TransactionAlreadyStartedException, GetType().FullName,
MethodBase.GetCurrentMethod().Name));
}
scope = _transactionScopeFactory.Create();
state.SetTransactionScope(scope);
}
public async Task ExecuteAsync(PublishCustomEntityCommand command, IExecutionContext executionContext)
{
var versions = await _dbContext
.CustomEntityVersions
.Include(v => v.CustomEntity)
.Where(p => p.CustomEntityId == command.CustomEntityId &&
(p.WorkFlowStatusId == (int)WorkFlowStatus.Draft || p.WorkFlowStatusId == (int)WorkFlowStatus.Published))
.ToListAsync();
var publishedVersion = versions.SingleOrDefault(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Published);
var draftVersion = versions.SingleOrDefault(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft);
EntityNotFoundException.ThrowIfNull(draftVersion, "Draft:" + command.CustomEntityId);
var definition = _customEntityDefinitionRepository.GetByCode(draftVersion.CustomEntity.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, draftVersion.CustomEntity.CustomEntityDefinitionCode);
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityPublishPermission>(definition.CustomEntityDefinitionCode);
await ValidateTitle(draftVersion, definition);
using (var scope = _transactionScopeFactory.Create())
{
// Find the published one and make it approved
if (publishedVersion != null)
{
publishedVersion.WorkFlowStatusId = (int)WorkFlowStatus.Approved;
await _dbContext.SaveChangesAsync();
}
await UpdateUrlSlugIfRequired(draftVersion, definition);
// Find the draft page and make it published
draftVersion.WorkFlowStatusId = (int)WorkFlowStatus.Published;
await _dbContext.SaveChangesAsync();
scope.Complete();
}
_customEntityCache.Clear(draftVersion.CustomEntity.CustomEntityDefinitionCode, command.CustomEntityId);
await _messageAggregator.PublishAsync(new CustomEntityPublishedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityDefinitionCode = draftVersion.CustomEntity.CustomEntityDefinitionCode
});
}