public void Update(WorkOrdersModel w)
{
PropertyId = w.PropertyId;
TenantId = w.TenantId;
Description = w.Description;
OpenedDate = w.OpenedDate;
ClosedDate = w.ClosedDate;
Priority = (Priorities)w.Priority;
}
public IHttpActionResult PostWorkOrder(WorkOrdersModel workOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dbWorkOrder = new WorkOrder(workOrder);
db.WorkOrders.Add(dbWorkOrder);
db.SaveChanges();
workOrder.WorkOrderId = dbWorkOrder.WorkOrderId;
return(CreatedAtRoute("DefaultApi", new { id = workOrder.WorkOrderId }, workOrder));
}
public IHttpActionResult PutWorkOrder(int id, WorkOrdersModel workOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != workOrder.WorkOrderId)
{
return(BadRequest());
}
// var dbWorkOrders = db.WorkOrders.Find(id);
var dbWorkOrders = db.WorkOrders.FirstOrDefault(p => p.Property.User.UserName == User.Identity.Name && p.WorkOrderId == id);
if (dbWorkOrders == null)
{
return(BadRequest());
}
dbWorkOrders.Update(workOrder);
db.Entry(dbWorkOrders).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkOrderExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private IList <OrderItem> GetOrderItems(WorkOrdersModel workOrdersModel, IEnumerable <string> orderItemsKeys)
{
List <WorkOrderModel> woList = workOrdersModel.Value.ToList();
List <OrderItem> orderOverviews = new List <OrderItem>();
foreach (var wo in woList)
{
List <OrderItemPropsModel> PropsList = new List <OrderItemPropsModel>();
foreach (var orderItemKey in orderItemsKeys)
{
PropsList.Add(new OrderItemPropsModel {
Key = orderItemKey, Value = wo.Get(orderItemKey)
});
}
orderOverviews.Add(new OrderItem {
Id = wo.Id, CreatedOn = wo.CreatedOn, Props = PropsList
});
}
return(orderOverviews);
}
public async Task <Result> Handle(ListWorkOrderQuery request, CancellationToken cancellationToken)
{
Result result;
try
{
var filter = _filterProvider.Replace(request.Filter, Item.DictionaryOrderItemPath());
int?skip = request.Skip.ToNullableInt();
int?limit = request.Top.ToNullableInt();
var workOrderDomains = await _workOrderReadRepository.ListAsync(filter, skip, limit);
var workOrderModels = _mapper.Map <IEnumerable <WorkOrderModel> >(workOrderDomains);
var count = workOrderModels.Count();
var workOrdersModels = new WorkOrdersModel {
Value = workOrderModels, Count = count, NextLink = null
};
result = Result.Ok(workOrdersModels);
}
catch (FilterODataException)
{
result = Result.Fail(new System.Collections.Generic.List <Failure>()
{
new HandlerFault()
{
Code = HandlerFaultCode.InvalidQueryFilter.Name,
Message = HandlerFailures.InvalidQueryFilter,
Target = "$filter"
}
}
);
}
catch (Exception ex)
{
_logAs.Error(CustomFailures.ListWorkOrderFailure, ex);
result = Result.Fail(CustomFailures.ListWorkOrderFailure);
}
return(result);
}
public WorkOrder(WorkOrdersModel workOrder)
{
this.Update(workOrder);
}
public async Task <OperationDataResult <WorkOrdersModel> > GetWorkOrdersAsync(WorkOrdersRequestModel pnRequestModel)
{
try
{
var core = await _coreService.GetCore();
var sites = await core.Advanced_SiteItemReadAll(false);
var workOrdersModel = new WorkOrdersModel();
var workOrdersQuery = _dbContext.WorkOrders
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
// add serch
if (!string.IsNullOrEmpty(pnRequestModel.SearchString))
{
workOrdersQuery = workOrdersQuery.Where(x =>
x.Description.ToLower().Contains(pnRequestModel.SearchString.ToLower()) ||
x.DescriptionOfTaskDone.ToLower().Contains(pnRequestModel.SearchString.ToLower()));
}
// sort
if (!string.IsNullOrEmpty(pnRequestModel.Sort))
{
if (pnRequestModel.IsSortDsc)
{
workOrdersQuery = workOrdersQuery.CustomOrderByDescending(pnRequestModel.Sort);
}
else
{
workOrdersQuery = workOrdersQuery.CustomOrderBy(pnRequestModel.Sort);
}
}
else
{
workOrdersQuery = _dbContext.WorkOrders.OrderBy(x => x.Id);
}
// pagination
workOrdersQuery = workOrdersQuery
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
// add select
var workOrderList = await AddSelectToQuery(workOrdersQuery).Result.ToListAsync();
foreach (var workOrderModel in workOrderList)
{
workOrderModel.CreatedBy = sites
.Where(x => x.SiteUId == workOrderModel.CreatedByUserId)
.Select(x => x.SiteName)
.FirstOrDefault();
workOrderModel.DoneBy = sites
.Where(x => x.SiteUId == workOrderModel.DoneBySiteId)
.Select(x => x.SiteName)
.FirstOrDefault();
}
workOrdersModel.Total = await _dbContext.WorkOrders.CountAsync(x =>
x.WorkflowState != Constants.WorkflowStates.Removed);
workOrdersModel.WorkOrders = workOrderList;
return(new OperationDataResult <WorkOrdersModel>(true, workOrdersModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <WorkOrdersModel>(false,
_workOrdersLocalizationService.GetString("ErrorWhileObtainingWorkOrders")));
}
}
