public async Task Add(CreateServiceByAdminDto createService)
{
//Sprawdzić, czy parametry są poprawne
//Usługa z DayWorkDto. Przenieść do helpera?
var itemService = await _itemServiceRepository.Get(createService.ItemServiceId);
var client = await _userRepository.GetUserById(createService.ClientId);
var dayWork = await _dayWorkRepository.Get(createService.DayWorkId);
if (itemService == null || client == null || dayWork == null)
{
throw new Exception("Bad Id");
}
var serviceToDb = new Service();
serviceToDb.Id = Guid.NewGuid();
serviceToDb.ItemService = itemService;
serviceToDb.Client = (UserClient)client;
serviceToDb.DayWork = dayWork;
serviceToDb.DateOfReservation = DateTime.Now;
await _serviceRepsitory.AddService(serviceToDb);
}
public HttpResponseMessage Register(ObservableService service)
{
//add service to db
_serviceRepository.AddService(service);
return(Request.CreateResponse(HttpStatusCode.OK, "Service has been added"));
}
private static void AddServiceAsSingleton(this IServiceRepository repository, Type type, Func <object> serviceBuilder)
{
repository.AddService(type, () =>
{
if (!SingletonCache.TryGetValue(type, out var service))
{
// Build the service on first retrieval, then store it for future use
service = serviceBuilder();
SingletonCache.Add(type, service);
}
return(service);
});
}
protected override async Task <AddServiceResponse> HandleCore(AddServiceRequest request)
{
if (String.IsNullOrEmpty(request.Name) || String.IsNullOrEmpty(request.Address))
{
throw new ArgumentNullException(nameof(request));
}
Service service = new Service
{
Name = request.Name,
Ip = request.Address
};
await _repository.AddService(service);
return(new AddServiceResponse());
}
private static void AddServiceAsScoped(this IServiceRepository repository, Type type, Func <object> serviceBuilder)
{
repository.AddService(type, () =>
{
if (!ScopedCache.TryGetValue(repository, out var serviceMap))
{
serviceMap = new Dictionary <Type, object>();
ScopedCache.Add(repository, serviceMap);
}
if (!serviceMap.TryGetValue(type, out var service))
{
// Build the service on first retrieval, then store it for future use
service = serviceBuilder();
serviceMap.Add(type, service);
}
return(service);
});
}
protected ServiceEntity RegisterService(ServiceModel model)
{
if (_serviceRepository.ExistService(model.Name))
{
var update = _serviceRepository.UpdateService(model);
if (update)
{
return(_serviceSearchRepository.GetServiceByName(model.Name));
}
return(null);
}
else
{
var service = Mapper.Map <ServiceEntity>(model);
var add = _serviceRepository.AddService(service);
if (add)
{
return(service);
}
return(null);
}
}
public async Task <IActionResult> AddService(ServiceViewModel model)
{
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status400BadRequest,
new Response {
Status = "Error", Message = "fill all fields"
}));
}
_serviceRepository.AddService(new Service {
Name = model.Name, CommissionPercentage = model.CommissionPercentage
});
if (await _serviceRepository.SaveChangesAsync())
{
return(Ok(new Response {
Status = "success", Message = "Saved successfully"
}));
}
return(StatusCode(StatusCodes.Status500InternalServerError));
}
public void AddService(ServiceView service)
{
_serviceRepository.AddService(service);
}
public static IServiceRepository AddTransient <TService>(this IServiceRepository repository)
{
repository.AddService(typeof(TService), () => repository.BuildInjectableService <TService, TService>());
return(repository);
}
public static IServiceRepository AddSingleton <TService>(this IServiceRepository repository, object service)
{
repository.AddService(typeof(TService), () => service);
return(repository);
}
public static IServiceRepository AddTransient <TService>(this IServiceRepository repository, Func <TService> serviceBuilder)
{
repository.AddService(typeof(TService), () => serviceBuilder());
return(repository);
}
public static IServiceRepository AddTransient <TService, TImplementation>(this IServiceRepository repository)
where TImplementation : TService
{
repository.AddService(typeof(TService), () => repository.BuildInjectableService <TService, TImplementation>());
return(repository);
}
public void AddService(Service service)
{
serviceRepository.AddService(service); //Adding new service
}
/// <summary>
/// Add a service into the system
/// </summary>
/// <param name="serviceDetails"></param>
/// <returns>boolean</returns>
public bool AddService(Service serviceDetails)
{
return(_serviceRepo.AddService(serviceDetails));
}
public Service AddService(Service service)
{
return(_serviceRepository.AddService(service));
}
