public async Task <ServiceItemViewModel> AddServiceItem(ServiceItemViewModel serviceItem)
{
var domainservice = new SchedulableCatalogItem(
serviceItem.SiteId,
serviceItem.Name,
serviceItem.Description,
serviceItem.DefaultTimeLength,
serviceItem.Price,
serviceItem.ServiceCategoryId,
serviceItem.IndustryStandardCategoryId
);
_serviceItemRepository.Add(domainservice);
var serviceItemCreatedEvent = new ServiceItemCreatedEvent(
domainservice.SiteId,
domainservice.Id,
domainservice.Name,
domainservice.Description,
domainservice.DefaultTimeLength,
domainservice.Price,
domainservice.AllowOnlineScheduling,
domainservice.ServiceCategoryId,
domainservice.IndustryStandardCategoryId
);
await _businessIntegrationEventService.PublishThroughEventBusAsync(serviceItemCreatedEvent);
//_session.Add<ServiceItem>(domainservice);
//_session.Commit();
serviceItem.Id = domainservice.Id;
return(serviceItem);
}
protected override void OnAppearing()
{
base.OnAppearing();
BindingContext = null;
BindingContext = ViewModel = new ServiceItemViewModel(m_AdditionalService)
{
Navigation = Navigation
};
}
public async Task <IActionResult> AddService(ServiceItemViewModel serviceItemModelView)
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
if (serviceItemModelView.File != null)
{
//WebRootPath retourne chemain de wwwroot
string uploads = Path.Combine(_hosting.WebRootPath, @"img\services");
//Ajout le chemain de nouveau fichier
string fullPath = Path.Combine(uploads, serviceItemModelView.File.FileName);
//Fait copier fichier dans ce chemain
//model.File.CopyTo(new FileStream(fullPath, FileMode.Create));
using (var stream = new FileStream(fullPath, FileMode.Create))
{
serviceItemModelView.File.CopyTo(stream);
}
}
var serviceItem = new ServiceItem()
{
//Id = Guid.Parse(ServiceItemModelView.Id),
ServiceName = serviceItemModelView.ServiceName,
Description = serviceItemModelView.Description,
Image = serviceItemModelView.File.FileName
};
//--> Récupérer Token de session
var JWToken = HttpContext.Session.GetString("token");
if (string.IsNullOrEmpty(JWToken))
{
ViewBag.MessageError = "Vous devez être authentifié";
return(View(serviceItemModelView));
}
string stringData = JsonConvert.SerializeObject(serviceItem);
var contentData = new StringContent(stringData, System.Text.Encoding.UTF8, "application/json");
//--> Ajouter Token dans Header Request pour avoir l'autorisation
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", JWToken);
var response = await client.PostAsync(URLBase + "ServiceItem", contentData);
var result = response.IsSuccessStatusCode;
if (result)
{
return(RedirectToAction("Index", "ServiceItem"));
}
ViewBag.MessageError = response.ReasonPhrase;
return(View(serviceItemModelView));
}
}
return(View(serviceItemModelView));
}
public async Task <IActionResult> AddServiceItem([FromBody]
ServiceItemViewModel request
)
{
if (!ModelState.IsValid)
{
return((IActionResult)BadRequest());
}
var result = await _serviceCategoryService.AddServiceItem(request);
return(CreatedAtAction(nameof(AddServiceItem), new { id = result.Id }, null));
}
public async Task <ServiceItemViewModel> Find(int id)
{
try
{
ServiceItemViewModel serviceItems = await this.BusinessLayer.Find(id);
return(serviceItems);
}
catch (Exception ex)
{
this.ExceptionLogger.Log(LogLevel.Error, ex);
throw ex;
}
}
public async Task <ServiceItemViewModel> Update(ServiceItemViewModel serviceItemData)
{
try
{
serviceItemData.LastModifiedBy = User.Identity.GetUserId();
serviceItemData.LastModifiedOn = DateTime.Now;
serviceItemData.IsActive = true;
return(await this.BusinessLayer.Update(serviceItemData));
}
catch (Exception ex)
{
this.ExceptionLogger.Log(LogLevel.Error, ex);
throw ex;
}
}
public async Task <ServiceItemViewModel> Create(ServiceItemViewModel viewModel)
{
if (viewModel != null)
{
var serviceItem = this.ServiceItemRepository.Add(ViewModelToEntityMapper.Map(viewModel));
if (serviceItem.ServiceItemId > 0)
{
viewModel.ServiceItemId = serviceItem.ServiceItemId;
}
else
{
viewModel.HasError = true;
}
}
return(viewModel);
}
public async Task <IActionResult> Delete(Guid id)
{
using (var client = new HttpClient())
{
var serviceOld = new ServiceItemViewModel();
using (var respense = await client.GetAsync(URLBase + "serviceitem/" + id))
{
string apiResponse = await respense.Content.ReadAsStringAsync();
serviceOld = JsonConvert.DeserializeObject <ServiceItemViewModel>(apiResponse);
}
//WebRootPath retourne chemain de wwwroot
string Olduploads = Path.Combine(_hosting.WebRootPath, @"img\services");
//--> Supprimer ancien Image
//--> Retourner l'ancien nom de image
string OldNameImage = serviceOld.Image;
//Ajout le chemain de ancien fichier
string oldPath = Path.Combine(Olduploads, OldNameImage);
//--> Sypprimer l'ancien image
System.IO.File.Delete(oldPath);
//--> Récupérer Token de session
var JWToken = HttpContext.Session.GetString("token");
if (string.IsNullOrEmpty(JWToken))
{
ViewBag.MessageError = "Vous devez être authentifié";
return(View());
}
//--> Ajouter Token dans Header Request pour avoir l'autorisation
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", JWToken);
var response = await client.DeleteAsync(URLBase + "serviceItem/" + id);
var result = response.IsSuccessStatusCode;
if (result)
{
return(RedirectToAction("Index", "ServiceItem"));
}
ViewBag.MessageError = response.ReasonPhrase;
return(View());
}
}
// GET: ServiceItems/Delete/5
public async Task <IActionResult> Delete(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var service = new ServiceItemViewModel();
using (var httpClient = new HttpClient())
{
using (var respense = await httpClient.GetAsync(URLBase + "serviceitem/" + id))
{
string apiResponse = await respense.Content.ReadAsStringAsync();
service = JsonConvert.DeserializeObject <ServiceItemViewModel>(apiResponse);
}
}
return(View(service));
}
public static ServiceItem Map(ServiceItemViewModel viewModel, ServiceItem entity)
{
if (viewModel == null || entity == null)
{
return(null);
}
entity.ServiceItemId = viewModel.ServiceItemId;
entity.ServiceItemName = viewModel.ServiceItemName;
entity.ServiceItemDescription = viewModel.ServiceItemDescription;
entity.ServiceCategoryId = viewModel.ServiceCategoryId;
entity.IsHourBased = viewModel.IsHourBased;
entity.DefaultQuantity = viewModel.DefaultQuantity;
entity.DefaultFee = viewModel.DefaultFee;
entity.MinimumFee = viewModel.MinimumFee;
entity.CreatedDate = viewModel.CreatedOn;
entity.CreatedBy = viewModel.CreatedBy;
entity.LastModifiedDate = viewModel.LastModifiedOn;
entity.LastModifiedBy = viewModel.LastModifiedBy;
entity.IsActive = viewModel.IsActive;
return(entity);
}
public async Task <ServiceItemViewModel> Update(ServiceItemViewModel viewModel)
{
if (viewModel != null)
{
var serviceItem = this.ServiceItemRepository.Find(viewModel.ServiceItemId);
if (serviceItem != null)
{
var lastModifiedDate = serviceItem.LastModifiedDate;
serviceItem = this.ServiceItemRepository.Update(ViewModelToEntityMapper.Map(viewModel, serviceItem));
if (lastModifiedDate < serviceItem.LastModifiedDate)
{
return(viewModel);
}
else
{
viewModel.HasError = true;
}
}
}
return(viewModel);
}
public static ServiceItem Map(ServiceItemViewModel viewModel)
{
if (viewModel == null)
{
return(null);
}
return(new ServiceItem
{
ServiceItemId = viewModel.ServiceItemId,
ServiceItemName = viewModel.ServiceItemName,
ServiceItemDescription = viewModel.ServiceItemDescription,
ServiceCategoryId = viewModel.ServiceCategoryId,
IsHourBased = viewModel.IsHourBased,
DefaultQuantity = viewModel.DefaultQuantity,
DefaultFee = viewModel.DefaultFee,
MinimumFee = viewModel.MinimumFee,
CreatedDate = viewModel.CreatedOn,
CreatedBy = viewModel.CreatedBy,
LastModifiedDate = viewModel.LastModifiedOn,
LastModifiedBy = viewModel.LastModifiedBy,
IsActive = viewModel.IsActive
});
}
public async Task <IActionResult> AddService()
{
var serviceItemViwModel = new ServiceItemViewModel();
return(View(serviceItemViwModel));
}
