public ActionResult <Guid> CreateService([FromBody] ServiceRequestModel serviceRequestModel)
{
if (serviceRequestModel == null || string.IsNullOrWhiteSpace(serviceRequestModel.Name) || string.IsNullOrWhiteSpace(serviceRequestModel.Version))
{
return(StatusCode(400));
}
int result = HeaderValidation.ValidateUserCredentials(Request.Headers[Username], Request.Headers[Password]);
if (result == -1)
{
return(StatusCode(401));
}
if (!HeaderValidation.ValidateUserPermissions(result))
{
return(StatusCode(403));
}
Guid guid = ServiceService.CreateService(serviceRequestModel);
if (guid == Guid.Empty)
{
return(StatusCode(500));
}
return(StatusCode(201, guid));
}
public async Task <IActionResult> Create([Bind("ServiceId,ServiceType")] Service service)
{
if (ModelState.IsValid)
{
await _serviceService.CreateService(service);
return(RedirectToAction(nameof(Create)));
}
return(View(service));
}
public void CreateService_Service_Fail()
{
// Arrange
serviceService = new ServiceService(mockRepository.Object, mockLogger.Object, mockCache.Object, mockTelemetry.Object);
mockRepository.Setup(x => x.Insert(It.IsAny <Service>())).Returns(false).Verifiable();
// Act
var service = new ServiceDto();
var response = serviceService.CreateService(service);
// Assert
Assert.IsNotNull(response);
Assert.IsFalse(response.Result);
Assert.IsTrue(response.Notifications.HasErrors());
Assert.IsInstanceOfType(response, typeof(GenericServiceResponse <bool>));
mockRepository.Verify(x => x.Insert(It.IsAny <Service>()), Times.Once);
}
public ActionResult CreateService([FromBody] ServiceCM model)
{
if (_serviceTypeService.GetServiceType(model.ServiceTypeId) == null)
{
return(NotFound(401));
}
if (_storeService.GetStore(model.StoreId) == null)
{
return(NotFound(401));
}
Services _services = model.Adapt <Services>();
_services.IsDelete = false;
_serviceService.CreateService(_services);
_serviceService.Save();
return(Ok(201));
}
public async Task <IActionResult> CreateService([FromBody] ServiceModel model)
{
var result = await _serviceService.CreateService(model);
if (result != null)
{
var isCache = _redisCacheRepository.isExist(Constants.KeyRedis.SERVICES);
if (!isCache)
{
_redisCacheRepository.Delete(Constants.KeyRedis.SERVICES);
}
var listServices = await _serviceService.GetServices();
_redisCacheRepository.Add(Constants.KeyRedis.SERVICES, listServices);
return(Created("", result));
}
return(BadRequest());
}
public ActionResult Create([FromBody] ServiceViewModel model)
{
try
{
if (ModelState.IsValid)
{
var serviceEntity = new ServiceEntity
{
Title = model.Title,
IdOrganization = model.IdOrganization,
};
var createdEntity = _serviceService.CreateService(serviceEntity);
ViewBag.RegisteredUser = true;
return(RedirectToAction("Details", new { id = createdEntity.IdService }));
}
}
catch
{
ModelState.AddModelError("", "Nepavyko sukurti vartotojo!");
}
return(View(model));
}
public async Task <IActionResult> CreateService([FromBody] ServiceRequestModel model)
{
var service = await _serviceService.CreateService(model);
return(Ok(service));
}
