public IActionResult Create(Service service)
{
service.Message = "";
if (ModelState.IsValid)
{
_serviceRepo.Create(service);
return(View("Services", GetList()));
}
return(View(service));
}
public async Task <IActionResult> Post([FromBody] ServiceRegister s)
{
if (ModelState.IsValid)
{
var service = await repository.Create(new Service
{
Name = s.Name,
Code = s.Code,
Cost = s.Cost,
UnitMeasurement = s.UnitMeasurement,
NeedPlate = s.NeedPlate,
EmissionPoint = await ePointRepository.GetPoint(s.EmissionPoint),
IsActive = s.IsActive
});
return(Json(new StandardResponse
{
Status = 200,
Data = service
}));
}
else
{
var errorList = ModelState.Values.SelectMany(v => v.Errors);
var errors = errorList.Select(e => e.ErrorMessage).ToArray();
return(Json(new StandardResponse
{
Status = 400,
Errors = errors
}));
}
}
public async Task <ServiceResponse> Create(ServiceDTO newService)
{
var service = ServiceMapper.Map(newService);
if (service.Name == null)
{
string errorMessage1 = "Service name not found.";
Log.Error(errorMessage1);
return(new ServiceResponse(errorMessage1));
}
if (service.Description == null)
{
string errorMessage2 = "Service description not found.";
Log.Error(errorMessage2);
return(new ServiceResponse(errorMessage2));
}
try
{
await _serviceRepository.Create(service);
await _context.SaveChangesAsync();
return(new ServiceResponse(ServiceMapper.Map(service)));
}
catch (Exception exception)
{
string errorMessage = $"An error occured when creating the item: {exception.Message}";
return(new ServiceResponse(errorMessage));
}
}
public async Task <IActionResult> Create([FromBody] ServiceCreateDTO serviceDTO)
{
try
{
if (serviceDTO == null)
{
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = _mapper.Map <Service>(serviceDTO);
var isSuccess = await _serviceRepository.Create(service);
if (!isSuccess)
{
return(InternalError($"Creation failed"));
}
return(Created("Create", new { service }));
}
catch (Exception e)
{
return(InternalError($"{e.Message} - {e.InnerException}"));
}
}
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 Service Create(CreateServiceCommand command)
{
var service = new Service(command.Name, command.Value, command.CoachingProcess, command.Description);
service.Validate();
_repository.Create(service);
if (Commit())
{
return(service);
}
return(null);
}
public async Task <bool> CreateService(Service service)
{
try
{
_serviceRepository.Create(service);
await _serviceRepository.SaveAsync();
return(true);
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
}
public JsonResult Create(ServiceRequest model)
{
try
{
///ServiceRequest serviceRequest = Mapper.Map<ServiceRequestViewModel, ServiceRequest>(model);
model.CreatedDate = DateTime.Now;
model.CreatedBy = CurrentUser.UserId;
_repository.Create(model);
return(Json("success", JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
public Service Create(Service model)
{
_repository.Create(model);
_repository.SaveCganges();
return(model);
}
public async Task <RepositoryResponce> Create(TEntity entity) => await _ServiceRepository.Create(CombineUrl(), entity);
public ActionResult PostService([FromBody] ServiceCreateDto dto)
{
var entity = _repository.Create(dto);
return(Ok(entity));
}
public void Create(Service entity)
{
_servicerepository.Create(entity);
}
public async Task <Service> Create(Service service)
{
return(await _serviceRepository.Create(service));
}
public ActionResult <ApiResultModel <UtService> > Create([FromForm] string name, [FromForm] string phone)
{
var row = _serviceRepository.Create(name, phone);
return(Ok(new ApiResultModel <UtService>(200, row)));
}
public virtual async Task <ApiResult <TSelectDto> > Create(TDto dto, CancellationToken cancellationToken)
{
dto.CreatedDate = DateTime.Now;
return(await serviceRepository.Create(dto, cancellationToken));
}
/// <summary>
/// Adds the service.
/// </summary>
/// <param name="service">The service.</param>
public void AddService(Service service)
{
serviceRepository.Create(service);
}
public Service Create(Service service)
{
return(_serviceRepository.Create(service));
}
