public ServiceReadDto Update(int id, ServiceCreateDto dto)
{
var user = UserData.Users.FirstOrDefault(e => e.Id == dto.UserId);
if (user == null)
{
throw new BusinessException("User does not exist", 400);
}
var service = _context.Services.FirstOrDefault(e => e.Id == id);
if (service == null)
{
throw new BusinessException("Service does not exist");
}
service.Name = dto.Name;
service.Description = dto.Description;
service.Price = dto.Price;
service.UserId = dto.UserId;
_context.SaveChanges();
return(_mapper.Map <ServiceReadDto>(service));
}
public async Task <ActionResult <ServiceDto> > PostAsync([FromBody] ServiceCreateDto serviceCreateDTO)
{
var service = _mapper.Map <Service>(serviceCreateDTO);
var insertedService = await _serviceService.AddAsync(service);
var insertedServiceDTO = _mapper.Map <ServiceDto>(insertedService);
return(CreatedAtAction(nameof(GetAsync), new Response <ServiceDto>(insertedServiceDTO)));
}
public void CreateService_ValidObjectPassed_ReturnsCreatedAtRouteResult()
{
var testItem = new ServiceCreateDto()
{
Shortname = "PHONE", Name = "Phone service"
};
var response = controller.CreateService(testItem);
Assert.IsType <CreatedAtRouteResult>(response.Result);
}
public void CreateService_InvalidObjectPassed_ReturnsBadRequestResult()
{
var testItem = new ServiceCreateDto()
{
Shortname = "", Name = ""
};
controller.ModelState.AddModelError("Shortname", "Required");
var response = controller.CreateService(testItem);
Assert.IsType <BadRequestResult>(response.Result);
}
public ServiceCreateDto Create(ServiceCreateDto service)
{
if (service != null)
{
var serv = new Clinic.System.Entities.Models.Service();
serv.Name = service.Name;
serv.Price = service.Price;
_serviceRepository.Create(serv);
_unitOfWork.Complete();
}
return(service);
}
public void CreateService_ValidObjectPassed_ReturnedResponseHasCreatedItem()
{
var testItem = new ServiceCreateDto()
{
Shortname = "PHONE", Name = "Phone service"
};
var response = controller.CreateService(testItem).Result as CreatedAtRouteResult;
var item = response.Value as ServiceReadDto;
Assert.IsType <ServiceReadDto>(item);
Assert.Equal(testItem.Shortname, item.Shortname);
Assert.Equal(testItem.Name, item.Name);
}
public async Task <ActionResult> Create([FromBody] ServiceCreateDto serviceCreateDto)
{
Service service = new Service
{
Name = serviceCreateDto.Name,
Description = serviceCreateDto.Description,
ShortDesc = serviceCreateDto.ShortDesc
};
await _context.AddAsync(service);
await _context.SaveChangesAsync();
return(Ok(service));
}
public ActionResult <ServiceReadDto> CreateService(ServiceCreateDto serviceCreateDto)
{
if (serviceCreateDto.Shortname.Equals(""))
{
return(BadRequest());
}
var serviceEntity = mapper.Map <Service>(serviceCreateDto);
repository.CreateService(serviceEntity);
repository.SaveChanges();
var serviceReadDto = mapper.Map <ServiceReadDto>(serviceEntity);
return(CreatedAtRoute(nameof(GetServiceById), new { Id = serviceReadDto.Id }, serviceReadDto));
}
public ServiceReadDto Create(ServiceCreateDto dto)
{
var user = UserData.Users.FirstOrDefault(e => e.Id == dto.UserId);
if (user == null)
{
throw new BusinessException("User does not exist", 400);
}
var service = _mapper.Map <Service>(dto);
_context.Services.Add(service);
_context.SaveChanges();
_logger.Log("Service created!");
return(_mapper.Map <ServiceReadDto>(service));
}
public async Task <ActionResult <Service> > CreateWorkshopService([FromRoute] int workshopId, [FromBody] ServiceCreateDto serviceDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(serviceDto));
}
Workshop workshop = await _workshopRepo.GetByIdAsync(workshopId);
if (workshop == null)
{
return(NotFound(new { error = $"workshop with id {workshopId} could not be found" }));
}
else
{
serviceDto.WorkshopID = workshopId;
Service service = _mapper.Map <Service>(serviceDto);
int createdServiceId = await _serviceRepo.CreateAsync(service);
await _workshopRepo.UpdateAsync(workshop);
return(CreatedAtAction(nameof(GetSingleWorkshopService), new { workshopId = workshopId, serviceId = createdServiceId }, serviceDto));
}
}
public ActionResult PostService([FromBody] ServiceCreateDto dto)
{
var entity = _repository.Create(dto);
return(Ok(entity));
}
public ActionResult PutService(int id, ServiceCreateDto dto)
{
var entity = _repository.Update(id, dto);
return(Ok(entity));
}
public async Task <IActionResult> createServiceAsync([FromBody] ServiceCreateDto serviceCreateDto)
{
var service = await _serviceRepo.createService(serviceCreateDto.name);
return(Created($"http://{Request.Host.Value}/about.json/service", service.Id));
}
