//Get a specific Resource from a GUID
public ApiResponse<Domain.Models.Resource> Get(Guid guid)
{
Domain.Models.Resource ResourceToReturn = new Domain.Models.Resource();
try
{
//Gets a Resource with all of its children
ResourceToReturn = _applicationContext.Resources
.Include(Resource => Resource.TimeSlots)
.SingleOrDefault(Resource => Resource.Id == guid);
if (ResourceToReturn == null)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.NoContent, null);
}
else
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.OK, ResourceToReturn);
}
}
catch (Exception)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.InternalServerError, null);
}
}
//Delete a Resource
public async Task<ApiResponse<Domain.Models.Resource>> Delete(Guid guid)
{
Domain.Models.Resource ResourceToDelete = new Domain.Models.Resource();
try
{
//Gets the Resource to be deleted. All children are tracked as well, so that they are also deleted.
ResourceToDelete = _applicationContext.Resources
.Include(Resource => Resource.TimeSlots)
.SingleOrDefault(Resource => Resource.Id == guid);
if (ResourceToDelete == null)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.NoContent, null);
}
else
{
var Resource = await _applicationContext.Resources.FirstOrDefaultAsync(x => x.Id == ResourceToDelete.Id);
//This will cascade delete.
_applicationContext.Resources.Remove(ResourceToDelete);
_applicationContext.SaveChanges();
_eventBus.PublishEvent(new ResourceDeletedEvent(Resource));
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.OK, null);
}
}
catch (Exception)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.InternalServerError, null);
}
}
//Creates a Resource
public ApiResponse<Domain.Models.Resource> Create(Domain.Models.Resource Resource)
{
bool invalidDate = false;
try
{
if (Resource == null)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.NoContent, null);
}
foreach (var timeslot in Resource.TimeSlots)
{
timeslot.Id = Guid.NewGuid();
}
//Checks that the timeslots do not overlap.
Resource.TimeSlots.ForEach(delegate (AvailableTime outerTime)
{
Resource.TimeSlots.ForEach(delegate (AvailableTime innerTime)
{
if (!(((outerTime.From <= innerTime.From) && (outerTime.To <= innerTime.From)) ||
((outerTime.From >= innerTime.To) && (outerTime.To >= innerTime.To))))
{
if (outerTime.Id != innerTime.Id)
{
invalidDate = true;
}
}
});
});
if (!invalidDate)
{
_applicationContext.Add(Resource);
_applicationContext.SaveChanges();
_eventBus.PublishEvent(new ResourceCreatedEvent(Resource));
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.OK, Resource);
}
else
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.NotModified, null);
}
}
catch (Exception e)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.InternalServerError, null);
}
}
public Domain.Client.Dtos.Resource Update(Domain.Client.Dtos.Resource entity)
{
try
{
Domain.Models.Resource ormEntity = _mapper.Map <Domain.Client.Dtos.Resource, Domain.Models.Resource>(entity);
ormEntity = _repository.Update(ormEntity);
entity = _mapper.Map <Domain.Models.Resource, Domain.Client.Dtos.Resource>(ormEntity);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
this.ErrorMessage = ex.ToString();
}
return(entity);
}
public Domain.Client.Dtos.Resource Read(int id, string includeProperties = null)
{
Domain.Client.Dtos.Resource toReturn = null;
try
{
Domain.Models.Resource ormEntity = _repository.Read(id, includeProperties);
toReturn = _mapper.Map <Domain.Models.Resource, Domain.Client.Dtos.Resource>(ormEntity);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
this.ErrorMessage = ex.ToString();
}
return(toReturn);
}
public async Task <ApiResponse <Domain.Models.Resource> > UpdateResource([FromBody] Domain.Models.Resource Resource)
{
return(await _ResourceService.Update(Resource));
}
public ApiResponse <Domain.Models.Resource> CreateResource([FromBody] Domain.Models.Resource Resource)
{
return(_ResourceService.Create(Resource));
}
//Update a Resource
//Should ignore reservations when being updated
public async Task<ApiResponse<Domain.Models.Resource>> Update(Domain.Models.Resource Resource)
{
Domain.Models.Resource ResourceToUpdate = new Domain.Models.Resource();
bool invalidDate = false;
try
{
ResourceToUpdate = _applicationContext.Resources.Include(r => r.TimeSlots).SingleOrDefault(r => r.Id == Resource.Id);
if (ResourceToUpdate == null)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.NoContent, null);
}
//Checks that the timeslots do not overlap. Also makes sure that he id is not the same, if the times do match.
Resource.TimeSlots.ForEach(delegate (AvailableTime newTimeSlot)
{
ResourceToUpdate.TimeSlots.ForEach(delegate (AvailableTime existingTimeSlot)
{
if (!(((newTimeSlot.From <= existingTimeSlot.From) && (newTimeSlot.To <= existingTimeSlot.From)) ||
((newTimeSlot.From >= existingTimeSlot.To) && (newTimeSlot.To >= existingTimeSlot.To))))
{
if (newTimeSlot.Id != existingTimeSlot.Id)
{
invalidDate = true;
}
}
});
});
if (!invalidDate)
{
ResourceToUpdate.Name = Resource.Name;
ResourceToUpdate.Description = Resource.Description;
//Makes sure that new timeslots that is not in db has no ID because of Auto Assignment
Resource.TimeSlots.ForEach(newTimeSlot =>
{
if(ResourceToUpdate.TimeSlots.FirstOrDefault(x => x.Id == newTimeSlot.Id) == null)
newTimeSlot.Id = Guid.Empty;
});
ResourceToUpdate.TimeSlots = Resource.TimeSlots;
Domain.Models.Resource OldResourece = await _applicationContext.Resources.FirstOrDefaultAsync(x => x.Id == ResourceToUpdate.Id);
_applicationContext.Resources.Update(ResourceToUpdate);
_applicationContext.SaveChanges();
_eventBus.PublishEvent(new ResourceUpdatedEvent(ResourceToUpdate));
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.OK, ResourceToUpdate);
}
else
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.NotModified, null);
}
}
catch (Exception)
{
return new ApiResponse<Domain.Models.Resource>(ApiResponseCode.InternalServerError, null);
}
}
