public async Task<HttpResponseMessage> GetWorkflow(Int32 id) { var response = new SingleModelResponse<WorkflowViewModel>() as ISingleModelResponse<WorkflowViewModel>; try { var model = await Task.Run(() => { return BusinessObject.GetWorkflow(new Workflow { ID = id }); }); response.Model = new WorkflowViewModel(model); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return response.ToHttpResponse(Request); }
public async Task<HttpResponseMessage> CreateWorkflow([FromBody]WorkflowViewModel value) { var response = new SingleModelResponse<WorkflowViewModel>() as ISingleModelResponse<WorkflowViewModel>; try { var model = await Task.Run(() => { return BusinessObject.AddWorkflow(value.ToEntity()); }); response.Model = new WorkflowViewModel(model); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return response.ToHttpResponse(Request); }
public async Task <IActionResult> DeleteProduct(Int32 id) { var response = new SingleModelResponse <ProductViewModel>() as ISingleModelResponse <ProductViewModel>; try { var entity = await Task.Run(() => { return(AdventureWorksRepository.DeleteProduct(id)); }); response.Model = entity.ToViewModel(); response.Message = "The record was deleted successfully"; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> DeleteOrderStatusAsync(Int32 id) { var response = new SingleModelResponse <OrderStatusViewModel>() as ISingleModelResponse <OrderStatusViewModel>; try { var entity = await Task.Run(() => { return(_RESTfulAPI_Repository.DeleteOrderStatus(id)); }); response.Model = entity.ToViewModel(); response.Info = "The record was deleted successfully"; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> CreateProduct([FromBody] ProductViewModel value) { var response = new SingleModelResponse <ProductViewModel>() as ISingleModelResponse <ProductViewModel>; try { var entity = await Task.Run(() => { return(AdventureWorksRepository.AddProduct(value.ToEntity())); }); response.Model = entity.ToViewModel(); response.Message = "The data was saved successfully"; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.ToString(); } return(response.ToHttpResponse()); }
public async Task <IActionResult> Update(int id, PartnerContactResource resource) { var response = new SingleModelResponse <PartnerContactResource>(); if (resource == null) { response.DidError = true; response.ErrorMessage = ResponseMessageConstants.NotFound; return(response.ToHttpResponse()); } try { var entity = await _repository.FindAsync(x => x.Id == id); if (entity == null) { response.DidError = true; response.ErrorMessage = ResponseMessageConstants.NotFound; return(response.ToHttpResponse()); } _mapper.Map(resource, entity); await _repository.UpdateAsync(entity); response.Model = _mapper.Map(entity, resource); response.Message = ResponseMessageConstants.Success; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.ToString(); _logger.LogInformation(ex.Message); _logger.LogTrace(ex.InnerException.ToString()); } return(response.ToHttpResponse()); }
public async Task <HttpResponseMessage> UpdateProduct(Int32 id, [FromBody] Product value) { var response = new SingleModelResponse <Product>() as ISingleModelResponse <Product>; try { var entity = await Task.Run(() => { return(BusinessObject.UpdateProduct(value)); }); response.Model = entity; } catch (Exception ex) { ExceptionHelper.Publish(ex); response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse(Request)); }
public async Task <ISingleModelResponse <string> > Refresh(int instanceId) { ISingleModelResponse <string> result = new SingleModelResponse <string>(); result.ErrorMessage = "OK"; try { ChannelFactory <IWCFContract> mChannelFacory = new ChannelFactory <IWCFContract>(new NetTcpBinding(), new EndpointAddress(ENDPOINT)); IWCFContract proxy = mChannelFacory.CreateChannel(); proxy.RefreshInstance(instanceId); } catch (Exception e) { result.DidError = true; result.ErrorMessage = e.Message; } return(result); }
public async Task <IActionResult> UpdateAthlete([FromBody] Athlete athlete) { var response = new SingleModelResponse <Athlete>() as ISingleModelResponse <Athlete>; try { if (athlete == null) { throw new Exception("Model is missing"); } response.Model = await Task.Run(() => { return(_context.UpdateAthlete(athlete)); }); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> ForgotPassword([FromBody] string email) { var response = new SingleModelResponse <Athlete>() as ISingleModelResponse <Athlete>; try { if (email == null) { throw new Exception("Email Address is missing"); } response.Model = await Task.Run(() => { return(_context.ForgotPassword(email)); }); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <HttpResponseMessage> GetCategory(Int32 id) { var response = new SingleModelResponse <CategoryViewModel>() as ISingleModelResponse <CategoryViewModel>; try { var entity = await Task.Run(() => { return(BusinessObject.GetCategory(new Category(id))); }); response.Model = new CategoryViewModel(entity); } catch (Exception ex) { ExceptionHelper.Publish(ex); response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse(Request)); }
public async Task <HttpResponseMessage> DeleteSupplier(Int32 id) { var response = new SingleModelResponse <Supplier>() as ISingleModelResponse <Supplier>; try { var entity = await Task.Run(() => { return(BusinessObject.DeleteSupplier(new Supplier(id))); }); response.Model = entity; } catch (Exception ex) { ExceptionHelper.Publish(ex); response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse(Request)); }
public SingleModelResponse <TModel> DeleteContent <TModel>(string requestUri, int content) where TModel : class { using (httpClient = new HttpClient()) { SingleModelResponse <TModel> model = null; httpClient.BaseAddress = new Uri(BaseUri); httpClient.DefaultRequestHeaders.Accept.Clear(); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Mozilla/5.0 (Windows NT 6.2; WOW64; rv:19.0) Gecko/20100101 Firefox/19.0"); var response = httpClient.PutAsync(requestUri, new StringContent(JsonConvert.SerializeObject(content), System.Text.Encoding.UTF8, "application/json")) .ContinueWith((taskwithresponse) => { var resp = taskwithresponse.Result.Content.ReadAsStringAsync(); resp.Wait(); model = JsonConvert.DeserializeObject <SingleModelResponse <TModel> >(resp.Result); } ); response.Wait(); return(model); } }
public async Task <HttpResponseMessage> CreateRegion([FromBody] Region value) { var response = new SingleModelResponse <Region>() as ISingleModelResponse <Region>; try { var entity = await Task.Run(() => { return(BusinessObject.CreateRegion(value)); }); response.Model = entity; } catch (Exception ex) { ExceptionHelper.Publish(ex); response.ErrorMessage = ex.Message; response.DidError = true; } return(response.ToHttpResponse(Request)); }
public async Task <IActionResult> GetCreateOrderRequestAsync() { Logger?.LogInformation("{0} has been invoked", nameof(GetCreateOrderRequestAsync)); var response = new SingleModelResponse <CreateOrderViewModel>() as ISingleModelResponse <CreateOrderViewModel>; var customersResponse = await SalesBusinessObject.GetCustomersAsync(); response.Model.Customers = customersResponse.Model.Select(item => new CustomerViewModel(item)); var employeesResponse = await HumanResourcesBusinessObject.GetEmployeesAsync(); response.Model.Employees = employeesResponse.Model.Select(item => new EmployeeViewModel(item)); var shippersResponse = await SalesBusinessObject.GetShippersAsync(); response.Model.Shippers = shippersResponse.Model.Select(item => new ShipperViewModel(item)); var productsResponse = await ProductionBusinessObject.GetProductsAsync(); response.Model.Products = productsResponse.Model.Select(item => new ProductViewModel(item)); return(response.ToHttpResponse()); }
public async Task <ISingleModelResponse <Order> > RemoveOrderAsync(Int32 id) { Logger?.LogInformation("{0} has been invoked", nameof(RemoveOrderAsync)); var response = new SingleModelResponse <Order>(); try { response.Model = await SalesRepository.GetOrderAsync(new Order(id)); if (response.Model?.OrderDetails.Count > 0) { throw new ForeignKeyDependencyException( String.Format("Order with ID: {0} cannot be deleted, because has dependencies. Please contact to technical support for more details", id) ); } } catch (Exception ex) { response.SetError(ex, Logger); } return(response); }
public IActionResult Update([FromBody] ProductViewModel productVm) { var response = new SingleModelResponse <ProductViewModel>() as ISingleModelResponse <ProductViewModel>; try { var dbProduct = _productService.GetById(productVm.ID); dbProduct.UpdateProduct(productVm); _productService.Update(dbProduct); _productService.Save(); var responseData = Mapper.Map <ProductViewModel>(dbProduct); response.Model = responseData; response.Message = dbProduct.Name + " đã được cập nhật thành công"; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.ToString(); } return(response.ToHttpResponse()); }
public async Task <IActionResult> UpdateRun([FromBody] Run run) { var response = new SingleModelResponse <Run>() as ISingleModelResponse <Run>; try { if (run == null) { throw new Exception("Run is missing"); } response.Model = await Task.Run(() => { Run runn = _context.UpdateRun(run); return(runn); }); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> UpdateOrderAsync(Int32 id, [FromBody] OrderViewModel value) { var response = new SingleModelResponse <OrderViewModel>() as ISingleModelResponse <OrderViewModel>; try { var entity = await Task.Run(() => { return(_RESTfulAPI_Repository.UpdateOrder(id, value.ToEntity())); }); response.Model = entity.ToViewModel(); response.Info = "The record was updated successfully"; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> Update(int id, AreaResource resource) { var response = new SingleModelResponse <AreaResource>(); if (resource == null) { response.DidError = true; response.ErrorMessage = "Input cannot be null."; return(response.ToHttpResponse()); } try { var area = await _areaRepository.FindAsync(x => x.Id == id); if (area == null || resource == null) { response.DidError = true; response.ErrorMessage = "Input could not be found."; return(response.ToHttpResponse()); } _mapper.Map(resource, area); await _areaRepository.UpdateAsync(area); response.Model = _mapper.Map(area, resource); response.Message = "The data was saved successfully"; } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.ToString(); } return(response.ToHttpResponse()); }
//[ValidateAntiForgeryToken] public async Task <IActionResult> EditRoute([FromBody] Route route) { var response = new SingleModelResponse <Route>() as ISingleModelResponse <Route>; try { if (route == null) { throw new Exception("Route Model is missing"); } response.Model = await Task.Run(() => { Route uproute = _context.UpdateRoute(route); return(uproute); }); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> UpdateClub([FromBody] Club club) { var response = new SingleModelResponse <Club>() as ISingleModelResponse <Club>; try { if (club == null) { throw new Exception("Model is missing"); } response.Model = await Task.Run(() => { Club cl = _context.UpdateClub(club); return(cl); }); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <ISingleModelResponse <Order> > CreateOrderAsync(Order header, OrderDetail[] details) { Logger?.LogInformation("{0} has been invoked", nameof(CreateOrderAsync)); var response = new SingleModelResponse <Order>(); try { using (var transaction = await DbContext.Database.BeginTransactionAsync()) { var warehouses = await ProductionRepository.GetWarehouses().ToListAsync(); try { foreach (var detail in details) { var product = await ProductionRepository.GetProductAsync(new Product { ProductID = detail.ProductID }); if (product == null) { throw new NonExistingProductException( String.Format("Sent order has a non existing product with ID: '{0}', order has been cancelled.", detail.ProductID) ); } else { detail.ProductName = product.ProductName; } if (product.Discontinued == true) { throw new AddOrderWithDiscontinuedProductException( String.Format("Product with ID: '{0}' is discontinued, order has been cancelled.", product.ProductID) ); } detail.UnitPrice = product.UnitPrice; detail.Total = product.UnitPrice * detail.Quantity; } header.Total = details.Sum(item => item.Total); await SalesRepository.AddOrderAsync(header); foreach (var detail in details) { detail.OrderID = header.OrderID; await SalesRepository.AddOrderDetailAsync(detail); var lastInventory = ProductionRepository .GetProductInventories() .Where(item => item.ProductID == detail.ProductID) .OrderByDescending(item => item.CreationDateTime) .FirstOrDefault(); var stocks = lastInventory == null ? 0 : lastInventory.Stocks - detail.Quantity; var productInventory = new ProductInventory { ProductID = detail.ProductID, WarehouseID = warehouses.First().WarehouseID, CreationDateTime = DateTime.Now, Quantity = detail.Quantity * -1, Stocks = stocks }; await ProductionRepository.AddProductInventoryAsync(productInventory); } response.Model = header; transaction.Commit(); } catch (Exception ex) { transaction.Rollback(); throw ex; } } } catch (Exception ex) { response.SetError(ex, Logger); } return(response); }
public SingleModelResponse<EventViewModel> GetEvent(int eventId) { string getUrl = EventUri + "GetEvent?eventId="+eventId; var evnt = GetSingleContent<Event>(getUrl); List<EventRouteViewModel> routes = new List<EventRouteViewModel>(); if (evnt.Model.EventRoute.Count>0) { foreach (EventRoute rou in evnt.Model.EventRoute) { EventRouteViewModel newRoute = new EventRouteViewModel { Title = rou.Title, DateAdded = rou.DateAdded, RouteId = rou.RouteID, EventRouteId = rou.EventRouteID, DateModified = rou.DateAdded, Distance = rou.Distance, Description = rou.Description, EventId = rou.EventID }; routes.Add(newRoute); } } EventViewModel ConvertedEvent = new EventViewModel { EventId = evnt.Model.EventId, Date = evnt.Model.Date, DateCreated = evnt.Model.DateCreated, DateModified = evnt.Model.DateModified, Description = evnt.Model.Description, UserID = evnt.Model.UserID, Location = evnt.Model.Location, Time = evnt.Model.Time, Title = evnt.Model.Title, EventRoutes = routes, }; if(evnt.Model.ClubID>0) { ConvertedEvent.ClubId = evnt.Model.ClubID; ConvertedEvent.ClubName = evnt.Model.Club.Name; } SingleModelResponse<EventViewModel> model = new SingleModelResponse<EventViewModel> { DidError = evnt.DidError, Message = evnt.Message, ErrorMessage = evnt.ErrorMessage, Model = ConvertedEvent }; return model; }
public virtual ActionResult Details(int id) { var viewModel = new AdministratorViewModel <DetailsViewModel>(); var response = new SingleModelResponse <DetailsViewModel> { IsValid = true, }; if (id == 0) { response = _helpService.SetNewView(); viewModel.Data = response.Model; viewModel.Descriptions = this.FillMultiLanguageBoxSimpleModel( "description", response.Model.Descriptions); viewModel.Urls = this.FillMultiLanguageBoxSimpleModel( "url", response.Model.Urls, new bool[] { true, false, false, false }); viewModel.ButtonConfiguration = new ButtonControlViewModel { ActionEdit = "edit", ActionSave = "saveDetails", HasEditButton = IDBContext.Current.HasPermission( Permission.HELP_CONVERGENCE_WRITE), NavigationCancel = Url.Action( controllerName: "Help", actionName: "Index"), UrlSave = Url.Action( controllerName: "Help", actionName: "SaveViewHelpData") }; return(View(viewModel)); } response = _helpService.GetViewData(id); if (!response.IsValid) { return(RedirectToAction("Index")); } viewModel.Data = response.Model; viewModel.Descriptions = this.FillMultiLanguageBoxSimpleModel( "description", response.Model.Descriptions); viewModel.Urls = this.FillMultiLanguageBoxSimpleModel( "url", response.Model.Urls, new bool[] { true, false, false, false }); viewModel.ButtonConfiguration = new ButtonControlViewModel { ActionCancel = "cancelDetails", ActionEdit = "edit", ActionSave = "saveDetails", HasEditButton = IDBContext.Current.HasPermission( Permission.HELP_CONVERGENCE_WRITE), UrlSave = Url.Action( controllerName: "Help", actionName: "SaveViewHelpData") }; return(View(viewModel)); }
public IActionResult PutUserData([FromBody] User user) { var response = new SingleModelResponse <UserListVM>() as ISingleModelResponse <UserListVM>; var result = new UserListVM(); try { if (ModelState.IsValid) { var details = _userService.GetUserById(user.userid); if (details == null) { response.StatusCode = (int)HttpStatusCode.InternalServerError; response.Success = "N"; response.Message = "Data does not exists."; } else { details.branchid = user.branchid; details.name = user.name; details.email = user.email; details.telno = user.telno; details.address = user.address; details.username = user.username; details.password = user.password; details.lastupdateddate = user.lastupdateddate; details.lastupdatedby = user.lastupdatedby; details.nactive = user.nactive; details.usertypeid = user.usertypeid; var IsSuccess = _userService.UpdateUserData(details); if (IsSuccess) { result = _userService.GetUserListsById(details.userid); } else { result = null; } response.StatusCode = (int)HttpStatusCode.OK; response.Success = "Y"; response.Message = "Save data successful."; response.Data = result; } } else { response.StatusCode = (int)HttpStatusCode.InternalServerError; response.Success = "N"; response.Message = "Invalid entry."; } } catch (Exception ex) { response.StatusCode = (int)HttpStatusCode.InternalServerError; response.Success = "N"; response.Message = ex.Message; } return(response.ToHttpResponse()); }
public async Task <IActionResult> ImportEmployees() { ISingleModelResponse <dynamic> response = new SingleModelResponse <dynamic>(); try { var file = Request.Form.Files[0]; using (var stream = file.OpenReadStream()) { using (var reader = new StreamReader(stream)) { reader.ReadLine(); IList <Employee> employees = new List <Employee>(); IList <Department> departments = _departmentRepository.GetDepartments().Result; _logger.LogInformation(entities.LoggingEvents.ImportEmployee, null, "line from Employees: {0}", departments); while (!reader.EndOfStream) { string line = reader.ReadLine(); _logger.LogInformation(entities.LoggingEvents.ImportEmployee, null, "lines from Employees: {0}", line); string[] columns = line.Split(","); if (columns.Count() == 5) { Employee employee = new Employee(); if (!String.IsNullOrEmpty(columns[0])) { employee.FirstName = columns[0]; } if (!String.IsNullOrEmpty(columns[1])) { employee.LastName = columns[1]; } employee.Cell = columns[2]; employee.Email = columns[3]; // if (!String.IsNullOrEmpty(columns[4])) // { // var department = departments.Where(x => x.Code == columns[4]).SingleOrDefault(); // employee.Department = new DropDownValue() { _id = department.Id, Name = department.Name }; // } employees.Add(employee); } await _employeeRepository.AddEmployees(employees); response.IsError = false; response.Model = new { TotalCount = employees.Count, SuccessCount = 10 }; } } } } catch (Exception ex) { response.IsError = true; response.Message = "Could not import Employees, Please check again"; return(BadRequest("Upload Failed: " + ex.Message)); } return(Ok(response)); }