public async Task <GetPublicationDto> CreateOneAsync(CreatePublicationDto item)
{
try
{
foreach (var space in item.SharedSpaces)
{
if (await _sharedSpaceRepository.IsAvaliableSharedSpace(space.CreateSharedSpace()))
{
throw new BadRequestException($"The space with resource id {space.ResourceId} has been shared already");
}
}
if (!await ValidPublicationTime(item))
{
throw new BadRequestException($"The Publication with reservartion id {item.ReservationId} time is not valid");
}
await _publicationRepository.CreateOneAsync(item.CreatePublication());
// Se debe actualizar el estado de la reserva a compartido(ID=8)
var reservation = await _reservationRepository.FindOneByIdAsync(item.ReservationId);
reservation.ReservationStateId = ReservationStates.Shared;
reservation.UpdatedAt = DateTime.Now;
await _reservationRepository.UpdateOneAsync(reservation);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw new BadRequestException("System error");
}
return(GetPublicationDto.FromPublication(item.CreatePublication()));
}
public async Task <IActionResult> CreateOneAsync(
[FromBody] CreatePublicationDto createPublicationDto
)
{
var item = await _publicationService.CreateOneAsync(createPublicationDto);
return(Ok(item));
}
private async Task <bool> ValidPublicationTime(CreatePublicationDto pub)
{
var res = await _reservationRepository.FindOneByIdAsync(pub.ReservationId);
if (pub.StartTime.Hour < res.StartTime.Hour || pub.EndTime.Hour > res.EndTime.Hour)
{
return(false);
}
return(true);
}
public async Task Create(CreatePublicationDto input)
{
var @publication = Publication.Create(1, input.Name, input.Description, input.FilePath, input.Downloads);
var user = await UserManager.GetUserByIdAsync(3);
await _notificationPublisher.PublishAsync(
notificationName : "PublicationNotification",
data : new MessageNotificationData("New Publication available : " + input.Name),
severity : NotificationSeverity.Success,
userIds : new[] { user.ToUserIdentifier() }
);
await _publicationRepository.InsertAsync(@publication);
}
public async Task <IActionResult> CreateOneAsync(
[FromBody] CreatePublicationDto createPublicationDto
)
{
try
{
var created = await _publicationService.CreateOneAsync(createPublicationDto);
return(Ok(created));
}
catch (Exception e)
{
return(HttpExceptionMapper.ToHttpActionResult(e));
}
}
public async Task <PublicationResponseObject> CreateOneAsync(CreatePublicationDto t)
{
// Validando que exista el usuario
var foundUser = await _usersRepository.FindOneByIdAsync(t.UserId);
if (foundUser == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound, "User not found");
}
// Validando que exista Food
var foundFood = await _foodRepository.FindOneByIdAsync(t.FoodId);
if (foundFood == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound, "Food not found");
}
// Validando que exista la publicacion no exista
var found = await _publicationsRepository.FindOneByUserIdAndFoodIdAndDescriptionAsync(t.UserId, t.FoodId, t.Description);
if (found != null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest, "Publication already exists");
}
// Validaciones
if (!IsDescriptionValid(t.Description))
{
throw new HttpResponseException(HttpStatusCode.BadRequest, "Description is not valid");
}
if (!IsStockValid(t.Stock))
{
throw new HttpResponseException(HttpStatusCode.BadRequest, "Stock is invalid");
}
if (!IsPricePerUnitValid(t.PricePerUnit))
{
throw new HttpResponseException(HttpStatusCode.BadRequest, "PricePerUnit is invalid");
}
// if (!AreDatesValid(t.StartDate, t.EndDate))
// throw new HttpResponseException(HttpStatusCode.BadRequest, "Dates are invalid");
if (!IsImageUrlValid(t.ImageUrl))
{
throw new HttpResponseException(HttpStatusCode.BadRequest, "ImageUrl is invalid");
}
// Creation
var newPublication = new Publication()
{
Description = t.Description,
Stock = t.Stock,
StartDate = t.StartDate,
// EndDate = t.EndDate,
ImageUrl = t.ImageUrl,
IsPublished = t.IsPublished,
PricePerUnit = t.PricePerUnit,
FoodId = foundFood.Id,
UserId = foundUser.Id,
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
await _publicationsRepository.CreateOneAsync(newPublication);
var entity = await _publicationsRepository.FindOneByIdAsync(newPublication.Id);
return(PublicationResponseObject.FromEntity(entity));
}
