public async Task DeleteCollectionAsync_Should_Pass()
{
// Arrange
CollectionDto collectionDto = new CollectionDto
{
UserId = 1,
Name = "Dank Memes"
};
await CollectionService.CreateCollectionAsync(collectionDto);
List <CollectionDto> collections = (await CollectionService.GetAllCollectionsAsync()).ToList();
Assert.IsTrue(collections.Count.Equals(1));
// Act
DeleteCollectionDto deleteCollectionDto = new DeleteCollectionDto {
Id = 1, UserId = 1
};
ServiceResponseDto deleteCollectionResultDto = await CollectionService.DeleteCollectionAsync(deleteCollectionDto);
// Assert
Assert.IsTrue(deleteCollectionResultDto.Success);
collections = (await CollectionService.GetAllCollectionsAsync()).ToList();
Assert.IsTrue(collections.Count.Equals(0));
}
public ActionResult Create()
{
CollectionDto instance = new CollectionDto();
CollectionCreateViewModel model = new CollectionCreateViewModel(instance);
return(View(model));
}
public ViewResult Edit(int id)
{
CollectionDto instance = Service.GetCollection(id);
InstanceEditViewModel model = new InstanceEditViewModel(InstanceTypes.Collection, instance);
return(View(model));
}
public async Task <IActionResult> Put([FromBody] CollectionDto model)
{
if (!await _permissionService.Authorize(PermissionSystemName.Collections))
{
return(Forbid());
}
var collection = await _mediator.Send(new GetQuery <CollectionDto>() { Id = model.Id });
if (!collection.Any())
{
return(NotFound());
}
if (ModelState.IsValid)
{
model = await _mediator.Send(new UpdateCollectionCommand()
{
Model = model
});
return(Ok(model));
}
return(BadRequest(ModelState));
}
public void Update(CollectionDto collectionDto)
{
if (string.IsNullOrWhiteSpace(collectionDto.Name))
{
throw new ValidationException("Collection name is empty");
}
var currentCollection = _database.Collections.GetById(collectionDto.Id);
if (currentCollection == null || collectionDto.UserId != currentCollection.UserId)
{
throw new ValidationException("Collection not found");
}
if (collectionDto.Name != currentCollection.Name)
{
// name of collection has changed so check if the new name of collection is already taken
var userCollections = _database.Collections.GetAll(c => c.UserId == collectionDto.UserId).ToList();
if (userCollections.Any(c => c.Name == collectionDto.Name))
{
throw new ValidationException($"Collection name \"{collectionDto.Name}\" is already exists");
}
}
// update collection properties
currentCollection.Name = collectionDto.Name;
currentCollection.Description = collectionDto.Description;
_database.Save();
}
public CollectionDto GetCollection(int id)
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CMSDataStoreKey))
{
CollectionFacade facade = new CollectionFacade(uow);
CollectionDto result = facade.RetrieveOrNewCollection(id, new CollectionConverter());
return(result);
}
}
public IFacadeUpdateResult <CollectionData> SaveCollection(CollectionDto instance)
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CMSDataStoreKey))
{
CollectionFacade facade = new CollectionFacade(uow);
IFacadeUpdateResult <CollectionData> result = facade.SaveCollection(CollectionConverter.ConvertToData(instance));
return(result);
}
}
public async Task <IActionResult> CollectionAsync(int?id)
{
if (!id.HasValue)
{
return(BadRequest());
}
CollectionDto collectionDto = await _collectionService.GetCollectionByIdAsync(id.Value);
if (collectionDto.Equals(default))
public ViewResult Detail(int id)
{
CollectionDto instance = Service.GetCollection(id);
InstanceDetailViewModel model = new InstanceDetailViewModel(InstanceTypes.Collection, instance);
// CollectionItem list
InstanceChildListViewModel items = new InstanceChildListViewModel(InstanceTypes.CollectionItem);
items.Instances = instance.CollectionItems;
items.AllowListAdd = false;
model.ChildLists.Add(items);
return(View(model));
}
public async Task <CollectionDto> CreateAsync(CollectionDto collectionDto)
{
var collection = _mapper.Map <CollectionDto, ExploraCollection>(collectionDto);
_repository.Create <ExploraCollection, int>(collection);
await SaveChangesAsync();
collection.ImageUrl = GenerateImageUrl(collection.Id);
await SaveChangesAsync();
return(_mapper.Map <CollectionDto>(collection));
}
public async Task <ActionResult <CollectionDto> > CreateCollection(int profileId, [FromBody] CreateCollection collection)
{
if (profileId != collection.ProfileId)
{
return(BadRequest());
}
Collection newCollection = await profileCollectionRepository.CreateCollection(profileId, collection);
CollectionDto newCollectionDto = await collectionRepository.GetCollection(newCollection.CollectionId);
return(CreatedAtAction("GetCollection", new { profileId = newCollection.ProfileId, collectionId = newCollection.CollectionId }, newCollectionDto));
}
public static CollectionDto ToCollectionDto(this Collection collection)
{
var result = new CollectionDto()
{
Id = collection.Id,
Name = collection.Name,
year = collection.year,
//FashionHouse = it.FashionHouse
};
//collection.Take(3);
return(result);
}
public IActionResult Post([FromBody] CreateCollectionRequest request)
{
if (request == null || string.IsNullOrEmpty(request.Name.Trim()))
{
return(BadRequest());
}
var collection = new CollectionDto {
Id = Guid.NewGuid(), Name = request.Name
};
_collections.InsertOne(collection);
return(Ok(new { collection.Id }));
}
public void TestAll()
{
CollectionFacade facade = new CollectionFacade(UnitOfWork);
List <CollectionDto> result = facade.RetrieveAllCollection(new CollectionConverter());
if (result != null)
{
}
CollectionDto instance = facade.RetrieveOrNewCollection(1, new CollectionConverter());
if (instance != null)
{
}
}
public async Task <CollectionDto> UpdateAsync(CollectionDto collectionDto)
{
var collection = await _repository.GetEntityByIdAsync <ExploraCollection, int>(collectionDto.Id);
if (collection != null)
{
collection.Name = collectionDto.Name;
collection.Description = collectionDto.Description;
collection.ModifiedDate = DateTime.UtcNow;
_repository.Update(collection);
await SaveChangesAsync();
return(_mapper.Map <CollectionDto>(collection));
}
return(default(CollectionDto));
}
public void CollectionMapping()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMapping <CollectionItem, CollectionItemDto>();
cfg.CreateMapping <Collection, CollectionDto>(mapping => mapping
.MapMemberList(d => d.CollectionItems, dd => dd.CollectionItems)
.MapMemberList(d => d.CollectionItemDtos, dd => dd.CollectionItems)
);
});
var mapper = config.CreateMapper();
var collectionMapping = mapper.GetMapping <Collection, CollectionDto>();
using (var context = new DatabaseContext(DatabaseHelper.Options))
{
var collectionDtos = context.Collections.Select(collectionMapping).ToList();
var result = collectionDtos.FirstOrDefault();
var expected = new CollectionDto
{
Id = 1,
CollectionItemDtos = new List <CollectionItemDto>
{
new CollectionItemDto {
Id = 1
},
new CollectionItemDto {
Id = 2
},
},
CollectionItems = new List <CollectionItem>
{
new CollectionItem {
Id = 1, CollectionId = 1
},
new CollectionItem {
Id = 2, CollectionId = 1
},
}
};
Assert.AreEqual(true, expected.Equals(result));
}
}
public async Task CreateCollectionAsync_Should_Pass()
{
// Arrange
CollectionDto expectedCollectionDto1 = new CollectionDto
{
UserId = 1,
Name = "Dank"
};
ServiceResponseDto createCollectionResultDto = await CollectionService.CreateCollectionAsync(expectedCollectionDto1);
Assert.IsTrue(createCollectionResultDto.Success);
// Act
CollectionDto actualCollectionDto1 = await CollectionService.GetCollectionByIdAsync(1);
// Assert
Assert.AreEqual(expectedCollectionDto1, actualCollectionDto1);
}
public async Task <IActionResult> Post([FromBody] CollectionDto model)
{
if (!await _permissionService.Authorize(PermissionSystemName.Collections))
{
return(Forbid());
}
if (ModelState.IsValid)
{
model = await _mediator.Send(new AddCollectionCommand()
{
Model = model
});
return(Created(model));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Update(CollectionDto collectionDto, IFormFile image)
{
//updates collection's data
var collection = await _collectionService.UpdateAsync(collectionDto);
if (image != null)
{
//updates collection's image
await _blobStorageService.UpdateResourceBlobAsync(
new ResourceBlobDto
{
Id = collection.Id,
Name = image.FileName,
Type = Enums.Resource.CollectionImage,
Blob = image.OpenReadStream()
});
}
return(RedirectToAction(nameof(Index)));
}
public async Task <ServiceResponseDto> CreateCollectionAsync(CollectionDto collectionDto)
{
ServiceResponseDto createCollectionResultDto = new ServiceResponseDto();
if (await _collectionRepository.ExistsAsync(collection => collection.Name.Equals(collectionDto.Name)))
{
createCollectionResultDto.Message = $"A collection with the name {collectionDto.Name} already exists.";
return(createCollectionResultDto);
}
Collection actualCollection = DtoToEntityConverter.Convert <Collection, CollectionDto>(collectionDto);
if (await _collectionRepository.CreateAsync(actualCollection))
{
createCollectionResultDto.Success = true;
createCollectionResultDto.Message = "The collection is created successfully.";
return(createCollectionResultDto);
}
createCollectionResultDto.Message = "Something happened try again later..";
return(createCollectionResultDto);
}
/// <summary>
/// Method responsible for make a patch request to the api to update the collection state.
///</summary>
///
/// <param name="lectureId"> lecture id </param>
/// <param name="collectionState"> collection state (eg. In Progress, Not started, ...) </param>
/// <param name="notes"> collection note made by the collection responsible </param>
///
/// <exception cref="ApiNotAvailableException"> if the operation was canceled because api wasn't available </exception>
/// <exception cref="NoSuccessfulResponseException"> if the request was not successful </exception>
public async Task UpdateCollectionSate(int lectureId, string collectionState, string notes)
{
try
{
string json;
if (notes == null)
{
var stateDto = new StateDto {
State = collectionState
};
json = JsonConvert.SerializeObject(stateDto, Formatting.Indented,
new JsonSerializerSettings {
ContractResolver = _contractResolver
});
}
else
{
var collectionDto = new CollectionDto {
Notes = notes, State = collectionState
};
json = JsonConvert.SerializeObject(collectionDto, Formatting.Indented,
new JsonSerializerSettings {
ContractResolver = _contractResolver
});
}
var requestContent = new StringContent(json, Encoding.UTF8, "application/json");
var cancellationTokenSource = new CancellationTokenSource(Constants.Timeout);
var header = Convert.ToBase64String(Encoding.ASCII.GetBytes(await Authentication.Authentication.GetStoreCredentials()));
var response = await _client.PatchAsync(Links.UpdateCollectionUri(lectureId), requestContent, cancellationTokenSource.Token, header);
response.EnsureSuccessStatusCode();
}
catch (OperationCanceledException operationCanceledException)
{
throw new ApiNotAvailableException(Constants.ApiNotAvailableMessage, operationCanceledException);
}
catch (HttpRequestException httpRequestException)
{
throw new NoSuccessfulResponseException(Constants.StateChangeMessage, httpRequestException);
}
}
public ActionResult Edit(int id, FormCollection formData)
{
CollectionDto instance = Service.GetCollection(id);
InstanceEditViewModel model = new InstanceEditViewModel(InstanceTypes.Collection, instance);
UpdateModel(instance, formData);
if (ModelState.IsValid)
{
IFacadeUpdateResult <CollectionData> result = Service.SaveCollection(instance);
if (result.IsSuccessful)
{
return(RedirectToAction(DetailAction, new { id = id }));
}
else
{
ProcUpdateResult(result.ValidationResult, result.Exception);
}
}
return(View(model));
}
public ActionResult Create(FormCollection formData)
{
CollectionDto instance = new CollectionDto();
CollectionCreateViewModel model = new CollectionCreateViewModel(instance);
UpdateModel(instance, formData);
if (ModelState.IsValid)
{
IFacadeUpdateResult <CollectionData> result = Service.SaveCollection(instance);
if (result.IsSuccessful)
{
return(RedirectToAction(IndexAction));
}
else
{
ProcUpdateResult(result.ValidationResult, result.Exception);
}
}
return(View(model));
}
public CollectionDto Create(CollectionDto collectionDto)
{
if (string.IsNullOrWhiteSpace(collectionDto.Name))
{
throw new ValidationException("Collection name is empty");
}
var collections = _database.Collections.GetAll(c => c.UserId == collectionDto.UserId).ToList();
if (collections.Any(c => c.Name == collectionDto.Name))
{
throw new ValidationException($"Collection name \"{collectionDto.Name}\" is already exists");
}
var collection = _mapper.Map <Collection>(collectionDto);
_database.Collections.Create(collection);
_database.Save();
return(_mapper.Map <CollectionDto>(collection));
}
public async Task <IActionResult> CreateCollection([FromHeader(Name = "Authorization")] string authorization, [FromBody] CollectionDto collectionDto)
{
if (!_userValidationService.CheckAuthorizationToken(authorization))
{
return(Unauthorized());
}
if (!(await _userValidationService.ValidateContentManager(authorization.Split(" ")[1])))
{
return(Unauthorized());
}
var userRef = await _userValidationService.GetUserRef(authorization.Split(" ")[1]);
_logger.logInformation(userRef, LoggingEvents.PostItem, "Creating By Dto: {0}", collectionDto.Reference);
ValidationOutput validationOutput = _collectionService.Register(collectionDto);
if (validationOutput.HasErrors())
{
if (validationOutput is ValidationOutputBadRequest)
{
_logger.logCritical(userRef, LoggingEvents.PostBadRequest, "Creating Collection Failed: {0}", ((ValidationOutputBadRequest)validationOutput).ToString());
return(BadRequest(validationOutput.FoundErrors));
}
if (validationOutput is ValidationOutputNotFound)
{
_logger.logCritical(userRef, LoggingEvents.PostNotFound, "Creating Collection Failed: {0}", ((ValidationOutputNotFound)validationOutput).ToString());
return(NotFound(validationOutput.FoundErrors));
}
_logger.logCritical(userRef, LoggingEvents.PostInternalError, "Type of validation output not recognized. Please contact your software provider.");
return(BadRequest("Type of validation output not recognized. Please contact your software provider."));
}
else
{
CollectionDto newCollectionDto = (CollectionDto)validationOutput.DesiredReturn;
_logger.logInformation(userRef, LoggingEvents.PostOk, "Creating Collection Succeeded: {0}", newCollectionDto.ToString());
return(CreatedAtRoute("GetCollection", new { reference = newCollectionDto.Reference }, newCollectionDto));
}
}
// ============ Methods to UPDATE something ============
/**
* Method that will update the collection (name and description), with the passed reference, with the data present in the passed DTO OR return all the errors found when trying to do so.
*
* Validations performed:
* 1. Validation of the passed collection's reference (database);
* 2. Validation of the name and description of the passed DTO.
*/
public ValidationOutput Update(string reference, CollectionDto dto)
{
//1.
ValidationOutput validationOutput = new ValidationOutputNotFound();
if (!CollectionExists(reference))
{
validationOutput.AddError("Reference of collection", "No collection with the reference '" + reference + "' exists in the system.");
return(validationOutput);
}
validationOutput = new ValidationOutputForbidden();
if (dto.Reference != null && !dto.Reference.Equals(reference))
{
validationOutput.AddError("Reference of collection", "It's not allowed to update reference.");
return(validationOutput);
}
//2.
validationOutput = _collectionDTOValidator.DTOIsValidForUpdate(dto);
if (validationOutput.HasErrors())
{
return(validationOutput);
}
Collection collectionToUpdate = _collectionRepository.GetByReference(reference);
if (dto.Name != null)
{
collectionToUpdate.Name = dto.Name;
}
if (dto.Description != null)
{
collectionToUpdate.Description = dto.Description;
}
validationOutput.DesiredReturn = _mapper.Map <CollectionDto>(_collectionRepository.Update(collectionToUpdate));
return(validationOutput);
}
public void Non_Public_Destination_Collection_Setter_Is_Populated()
{
var poco = new CollectionPoco
{
Id = Guid.NewGuid(),
Name = "TestName",
Children = new List <ChildDto> {
new ChildDto {
Id = Guid.NewGuid(), Name = "TestChild"
}
}
};
CollectionDto dto = TypeAdapter.Adapt <CollectionPoco, CollectionDto>(poco);
dto.Id.ShouldBe(poco.Id);
dto.Name.ShouldBe(poco.Name);
dto.Children.ShouldNotBeNull();
dto.Children.Count.ShouldBe(1);
dto.Children[0].Id.ShouldBe(poco.Children[0].Id);
}
public async Task GetAllCollectionsAsync_Should_Return_3_Collections()
{
// Arrange
CollectionDto expectedCollectionDto1 = new CollectionDto
{
UserId = 1,
Name = "Dank Memes1"
};
Collection entity1 = DtoToEntityConverter.Convert <Collection, CollectionDto>(expectedCollectionDto1);
await CollectionRepository.CreateAsync(entity1);
CollectionDto expectedCollectionDto2 = new CollectionDto
{
UserId = 1,
Name = "Dank Memes2"
};
Collection entity2 = DtoToEntityConverter.Convert <Collection, CollectionDto>(expectedCollectionDto2);
await CollectionRepository.CreateAsync(entity2);
CollectionDto expectedCollectionDto3 = new CollectionDto
{
UserId = 1,
Name = "Dank Memes3"
};
Collection entity3 = DtoToEntityConverter.Convert <Collection, CollectionDto>(expectedCollectionDto3);
await CollectionRepository.CreateAsync(entity3);
// Act
CollectionDto actualCollectionDto1 = (await CollectionService.GetAllCollectionsAsync()).First();
CollectionDto actualCollectionDto2 = (await CollectionService.GetAllCollectionsAsync()).Skip(1).First();
CollectionDto actualCollectionDto3 = (await CollectionService.GetAllCollectionsAsync()).Skip(2).First();
// Assert
Assert.AreEqual(expectedCollectionDto1, actualCollectionDto1);
Assert.AreEqual(expectedCollectionDto2, actualCollectionDto2);
Assert.AreEqual(expectedCollectionDto3, actualCollectionDto3);
}
public async Task Initialize()
{
ApplicationDbFactory = new ApplicationDbFactory("InMemoryDatabase");
await ApplicationDbFactory.Create().Database.EnsureDeletedAsync();
await ApplicationDbFactory.Create().Database.EnsureCreatedAsync();
ApplicationDbFactory.Create().ResetValueGenerators();
// Relational-specific methods can only be used when the context is using a relational database provider..
// ApplicationDbFactory.Create().Database.Migrate();
CollectionRepository = new CollectionRepository(ApplicationDbFactory.Create(), CollectionValidator);
MemeRepository = new MemeRepository(ApplicationDbFactory.Create(), MemeValidator);
CollectionItemDetailRepository = new CollectionItemDetailRepository(ApplicationDbFactory.Create(), CollectionItemDetailValidator);
CollectionService = new CollectionService(CollectionRepository);
CollectionItemDetailService = new CollectionItemDetailService(CollectionItemDetailRepository, CollectionRepository, MemeRepository);
CollectionDto collectionDto = new CollectionDto
{
UserId = 1,
Name = "Dank Memes"
};
ServiceResponseDto createCollectionResultDto = await CollectionService.CreateCollectionAsync(collectionDto);
Assert.IsTrue(createCollectionResultDto.Success);
}
public async Task <IActionResult> UpdateCollection([FromHeader(Name = "Authorization")] string authorization, [FromRoute] string reference, [FromBody] CollectionDto collectionDto)
{
if (!_userValidationService.CheckAuthorizationToken(authorization))
{
return(Unauthorized());
}
if (!(await _userValidationService.ValidateContentManager(authorization.Split(" ")[1])))
{
return(Unauthorized());
}
var userRef = await _userValidationService.GetUserRef(authorization.Split(" ")[1]);
_logger.logInformation(userRef, LoggingEvents.UpdateItem, "Updating By Reference: {0}", reference);
ValidationOutput validationOutput = _collectionService.Update(reference, collectionDto);
if (validationOutput.HasErrors())
{
if (validationOutput is ValidationOutputBadRequest)
{
_logger.logCritical(userRef, LoggingEvents.UpdateBadRequest, "Updating Failed: {0}", ((ValidationOutputBadRequest)validationOutput).ToString());
return(BadRequest(validationOutput.FoundErrors));
}
if (validationOutput is ValidationOutputNotFound)
{
_logger.logCritical(userRef, LoggingEvents.UpdateNotFound, "Updating Failed: {0}", ((ValidationOutputNotFound)validationOutput).ToString());
return(NotFound(validationOutput.FoundErrors));
}
if (validationOutput is ValidationOutputForbidden)
{
_logger.logCritical(userRef, LoggingEvents.UpdateForbidden, "Updating Failed: {0}", ((ValidationOutputForbidden)validationOutput).ToString());
return(new ForbiddenObjectResult(validationOutput.FoundErrors));
}
_logger.logCritical(userRef, LoggingEvents.UpdateInternalError, "Type of validation output not recognized. Please contact your software provider.");
return(BadRequest("Type of validation output not recognized. Please contact your software provider."));
}
else
{
_logger.logInformation(userRef, LoggingEvents.UpdateNoContent, "Updating Collection: {0}", ((CollectionDto)validationOutput.DesiredReturn).ToString());
_logger.logInformation(userRef, LoggingEvents.UpdateOk, "Updating Collection: {0}", ((CollectionDto)validationOutput.DesiredReturn).ToString());
return(NoContent());
}
}