public async Task <IHttpActionResult> Patch(int id, JsonPatchDocument <Class> newdata)
{
var clas = await db.Classes.FindAsync(id);
if (clas == null)
{
return(NotFound());
}
newdata.ApplyUpdatesTo(clas);
await db.SaveChangesAsync();
var cla = db.Classes.Include(c => c.Product).Include(c => c.Charger.User).Where(c => c.Id == id).FirstOrDefault();
var result = new ClassVM()
{
Arrange = cla.Arrange,
ChargerID = cla.ChargerID,
chargerName = cla.Charger.User.Name,
ClassName = cla.ClassName,
ClassState = cla.ClassState,
Id = cla.Id,
OverDate = cla.OverDate,
ProductID = cla.ProductID,
ProductName = cla.Product.ProductName,
studentCount = cla.StudentCount
};
return(Ok(result));
}
public async Task <IHttpActionResult> Patch(string bookId, JsonPatchDocument <BookModel> patch)
{
Guid bookUniqueIdentifier;
if (!Guid.TryParse(bookId, out bookUniqueIdentifier))
{
return(Content <Error>(HttpStatusCode.BadRequest, new Error("400", $"Invalid book id supplied. Book id: {bookId}.")));
}
var book = await _bookRepository.GetByIDAsync(bookId);
if (book == null)
{
return(Content <Error>(HttpStatusCode.NotFound, new Error("404", $"Cannot find book with id {bookId}.")));
}
BookModel originalModel = Mapper.Map <BookModel>(book);
patch.ApplyUpdatesTo(originalModel);
// Apply changes back to book object and save.
book.Name = originalModel.Name;
book.DateOfPublication = originalModel.DateOfPublication;
book.Authors = string.Join(",", originalModel.Authors);
book.NumberOfPages = originalModel.NumberOfPages;
await _bookRepository.UpdateAsync(book);
await _unitOfWork.SaveChangesAsync();
return(Ok());
}
public async Task <IHttpActionResult> PatchStudent(int id, JsonPatchDocument <Coupon> newdata)
{
var coupon = await db.Coupons.FindAsync(id);
if (coupon == null)
{
return(NotFound());
}
newdata.ApplyUpdatesTo(coupon);
await db.SaveChangesAsync();
coupon = await db.Coupons.Include(cou => cou.Campuses).Include(c => c.Products).Where(c => c.Id == id).SingleOrDefaultAsync();
var data = new CouponVM()
{
CouponName = coupon.CouponName,
Id = coupon.Id,
OverDate = coupon.OverDate,
Rule = coupon.Rule,
StartDate = coupon.StartDate,
State = coupon.State,
Vlaue = coupon.Vlaue,
campusIds = coupon.Campuses.Select(c => c.CampusID).ToList(),
productIds = coupon.Products.Select(c => c.ProductId).ToList()
};
return(Ok(data));
}
public IHttpActionResult EditInvoice(int id, [FromBody] JsonPatchDocument <Models.Viewmodels.API.EditInvoiceVm> patchData)
{
var invoice = _repository.GetInvoice(id);
if (invoice == null)
{
return(BadRequest("Invoice does not exist."));
}
if (patchData == null)
{
return(BadRequest("Request body is empty"));
}
Models.Viewmodels.API.EditInvoiceVm vm = new Models.Viewmodels.API.EditInvoiceVm
{
InvoiceDate = invoice.Invoice_date,
DueDate = invoice.Due_date,
Paid = invoice.Paid
};
patchData.ApplyUpdatesTo(vm);
Invoice inv = new Invoice()
{
Id = id,
Invoice_date = vm.InvoiceDate,
Due_date = vm.DueDate,
Paid = vm.Paid
};
_repository.EditInvoice(inv);
return(Ok());
}
public void ApplyUpdate_MoveFromPropertyToList_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument <ComplexEntity>();
var entity = new ComplexEntity
{
Bar = new SimpleEntity
{
Foo = "I am foo"
},
Norf = new List <ListEntity>
{
new ListEntity
{
Foo = new List <string> {
"Element One", "Element Two", "Element Three"
}
}
}
};
//Act
patchDocument.Move("/Bar/Foo", "/Norf/0/Foo/1");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.IsNull(entity.Bar.Foo);
Assert.AreEqual(4, entity.Norf[0].Foo.Count);
Assert.AreEqual("Element One", entity.Norf[0].Foo[0]);
Assert.AreEqual("I am foo", entity.Norf[0].Foo[1]);
Assert.AreEqual("Element Two", entity.Norf[0].Foo[2]);
Assert.AreEqual("Element Three", entity.Norf[0].Foo[3]);
}
public async Task <IHttpActionResult> PatchQuestionTemplateAsync(int id, JsonPatchDocument <EquityQuestionTemplateContract> patchData)
{
var question = await _repository.GetQuestionTemplateByIdAsync(id);
patchData.ApplyUpdatesTo(question);
await _repository.PutQuestionTemplateAsync(question);
return(new NoContentResult());
}
public async Task <IHttpActionResult> PatchStoryAsync(int id, JsonPatchDocument <EquityStoryContract> patchData)
{
var story = await _repository.GetStoryByIdAsync(id);
patchData.ApplyUpdatesTo(story);
await _repository.PutStoryAsync(story);
return(new NoContentResult());
}
public void ApplyUpdate_TestOperation_Failed()
{
//Arrange
var patchDocument = new JsonPatchDocument <SimpleEntity>();
var entity = new SimpleEntity {
Foo = "bar"
};
//Act
patchDocument.Test("Foo", "blah");
patchDocument.ApplyUpdatesTo(entity);
}
public void ApplyUpdate_TestOperation_Array_Failed()
{
//Arrange
var patchDocument = new JsonPatchDocument <ArrayEntity>();
var entity = new ArrayEntity {
Foo = new string[] { "bar1", "bar2" }
};
//Act
patchDocument.Test("Foo/1", "blah");
patchDocument.ApplyUpdatesTo(entity);
}
public void ApplyUpdate_AddOperation_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument <SimpleEntity>();
var entity = new SimpleEntity();
//Act
patchDocument.Add("Foo", "bar");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.AreEqual("bar", entity.Foo);
}
public async Task <IHttpActionResult> PatchStudent(string id, JsonPatchDocument <ApplicationUser> newdata)
{
var old = db.Users.Find(id);
if (old == null)
{
return(NotFound());
}
newdata.ApplyUpdatesTo(old);
await db.SaveChangesAsync();
return(Ok(old));
}
public async Task <IHttpActionResult> PatchStudent(int id, JsonPatchDocument <Diploma> newdata)
{
var old = await db.Diplomas.FindAsync(id);
if (old == null)
{
return(NotFound());
}
newdata.ApplyUpdatesTo(old);
await db.SaveChangesAsync();
return(Ok(old));
}
public void ApplyUpdate_RemoveOperation_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument <SimpleEntity>();
var entity = new SimpleEntity {
Foo = "bar"
};
//Act
patchDocument.Remove("Foo");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.AreEqual(null, entity.Foo);
}
/// <summary>
/// MOVE
/// </summary>
/// <param name="patchData"></param>
/// <returns></returns>
public List <Album> Move(int albumId, JsonPatchDocument <Album> patchData)
{
/*
* /api/patch/move?albumId=1
* [
* { "op": "move", "from": "/Tags/0", "path": "/Genre/Description" }
* ]
*/
var album = this.albums.Find(w => w.AlbumId == albumId);
patchData.ApplyUpdatesTo(album);
return(this.albums);
}
/// <summary>
/// REPLACE
/// </summary>
/// <param name="patchData"></param>
/// <returns></returns>
public List <Album> Replace(int albumId, JsonPatchDocument <Album> patchData)
{
/*
* /api/patch/replace?albumId=2
* [
* { "op": "replace", "path": "/Tags", value:["1","2","3"] },
* { "op": "replace", "path": "/Tags/0", value:"再次替换" }
* ]
*/
var album = this.albums.Find(w => w.AlbumId == albumId);
patchData.ApplyUpdatesTo(album);
return(this.albums);
}
/// <summary>
/// REMOVE
/// </summary>
/// <param name="patchData"></param>
/// <returns></returns>
public List <Album> Remove(int albumId, JsonPatchDocument <Album> patchData)
{
/*
* /api/patch/remove?albumId=2
* [
* { "op": "remove", "path": "/Tags/0"}
* ]
*/
var album = this.albums.Find(w => w.AlbumId == albumId);
patchData.ApplyUpdatesTo(album);
return(this.albums);
}
public async Task <ValueReadDto> Update(int id, JsonPatchDocument <ValueUpdateDto> model)
{
var item = await _repo.Get(id);
var dto = _mapper.Map <ValueUpdateDto>(item);
model.ApplyUpdatesTo(dto);
item = _mapper.Map(dto, item);
var updated = await _repo.Update(id, item);
var updatedDto = _mapper.Map <ValueReadDto>(updated);
return(updatedDto);
}
public async Task <IHttpActionResult> UpdateBook(Guid id, [FromBody] JsonPatchDocument <Book> patchData)
{
if (patchData == null)
{
return(BadRequest());
}
var book = await _context.Books.FirstOrDefaultAsync(x => x.Id.Equals(id));
book.UpdateDate = DateTime.Now;
patchData.ApplyUpdatesTo(book);
await _context.SaveChangesAsync();
return(Ok(book));
}
public void ApplyUpdate_MoveOperation_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument <SimpleEntity>();
var entity = new SimpleEntity {
Foo = "bar", Baz = "qux"
};
//Act
patchDocument.Move("Foo", "Baz");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.IsNull(entity.Foo);
Assert.AreEqual("bar", entity.Baz);
}
/// <summary>
/// ADD
/// </summary>
/// <param name="patchData"></param>
/// <returns></returns>
public List <Album> Add(JsonPatchDocument <Album> patchData)
{
/*
* /api/patch/add
* [
* { "op": "add", "path": "/AlbumId", "value": 3},
* { "op": "add", "path": "/Title", "value": 'Chinese'},
* { "op": "add", "path": "/Price", "value": '9.99'},
* { "op": "add", "path": "/Tags", "value": ['限免','粤语']},
* { "op": "add", "path": "/IsDeleted", "value": '0'},
* { "op": "add", "path": "/Genre", "value": {"GenreId": 1, "Name": "Men At Work"}}
* ]
*/
var album = new Album();
patchData.ApplyUpdatesTo(album);
this.albums.Add(album);
return(this.albums);
}
public int UpdateUser(int UserId, JsonPatchDocument <UserMaster> userPath)
{
try
{
UserMaster user = _uow.UserMasters.GetById(UserId);
if (user.UserMasterId > 0)
{
userPath.ApplyUpdatesTo(user);
_uow.UserMasters.Update(user);
return(_uow.CommitChanges());
}
else
{
return(-2);
}
}
catch (Exception ex)
{
return(0);
}
}
public int UpdateCar(int CarId, JsonPatchDocument <CarMaster> CarPath)
{
try
{
CarMaster Car = _uow.CarMasters.GetById(CarId);
if (Car.CarMasterId > 0)
{
CarPath.ApplyUpdatesTo(Car);
_uow.CarMasters.Update(Car);
return(_uow.CommitChanges());
}
else
{
return(-2);
}
}
catch (Exception ex)
{
return(0);
}
}
public void ApplyUpdate_MoveListElement_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument <ListEntity>();
var entity = new ListEntity
{
Foo = new List <string> {
"Element One", "Element Two", "Element Three"
}
};
//Act
patchDocument.Move("/Foo/2", "/Foo/1");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.AreEqual(3, entity.Foo.Count);
Assert.AreEqual("Element One", entity.Foo[0]);
Assert.AreEqual("Element Three", entity.Foo[1]);
Assert.AreEqual("Element Two", entity.Foo[2]);
}
public async virtual Task <IHttpActionResult> Patch(int id, [FromBody] JsonPatchDocument <Edicao> patch)
{
try
{
// validate
if (patch == null)
{
return(BadRequest("Model can not be null."));
}
if (id == 0)
{
return(BadRequest("Identifier is required."));
}
var model = FacadeBO.Edicao.GetById(id);
if (model == null)
{
return(NotFound());
}
patch.ApplyUpdatesTo(model);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// modify entity
if (await FacadeBO.Edicao.ModifyAsync(model) == 0)
{
return(NotFound());
}
return(Ok());
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
private CustomerInformation ProcessPatchJsonToActualJson(JsonPatchDocument <CustomerInformation> customerInfo)
{
CustomerInformation customerInformation = new CustomerInformation();
var customer = customerInformation.Customer;
ResolveNullValueForEnumField(customerInfo);
InitializeCustomer(customerInformation);
try
{
customerInfo.ApplyUpdatesTo(customerInformation);
}
catch (Exception ex)
{
Trace.TraceError($"Message:{ex.Message} StackTrace:{ex.StackTrace.ToString()}");
return(null);
}
AssignPatchParameters(customerInfo, customerInformation);
customer.Address[0] = customer.Address1;
customer.Address[1] = customer.Address2;
customer.Address[2] = customer.Address3;
customer.Address1 = null;
customer.Address2 = null;
customer.Address3 = null;
customer.Email[0] = customer.Email1;
customer.Email[1] = customer.Email2;
customer.Email[2] = customer.Email3;
customer.Email1 = null;
customer.Email2 = null;
customer.Email3 = null;
customer.Phone[0] = customer.Phone1;
customer.Phone[1] = customer.Phone2;
customer.Phone[2] = customer.Phone3;
customer.Phone1 = null;
customer.Phone2 = null;
customer.Phone3 = null;
customerInformation.Customer = customer;
return(customerInformation);
}
public Car Patch(int id, JsonPatchDocument<Car> patchData)
{
// TODO: Do some validation and all that fun stuff
var carTuple = _carsCtx.GetSingle(id);
if (!carTuple.Item1)
{
var response = Request.CreateResponse(HttpStatusCode.NotFound);
throw new HttpResponseException(response);
}
patchData.ApplyUpdatesTo(carTuple.Item2);
carTuple.Item2.Id = id;
if (!_carsCtx.TryUpdate(carTuple.Item2))
{
var response = Request.CreateResponse(HttpStatusCode.NotFound);
throw new HttpResponseException(response);
}
return carTuple.Item2;
}
public Car Patch(int id, JsonPatchDocument <Car> patchData)
{
// TODO: Do some validation and all that fun stuff
var carTuple = _carsCtx.GetSingle(id);
if (!carTuple.Item1)
{
var response = Request.CreateResponse(HttpStatusCode.NotFound);
throw new HttpResponseException(response);
}
patchData.ApplyUpdatesTo(carTuple.Item2);
carTuple.Item2.Id = id;
if (!_carsCtx.TryUpdate(carTuple.Item2))
{
var response = Request.CreateResponse(HttpStatusCode.NotFound);
throw new HttpResponseException(response);
}
return(carTuple.Item2);
}
public void ApplyUpdate_MoveFromPropertyToList_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument<ComplexEntity>();
var entity = new ComplexEntity
{
Bar = new SimpleEntity
{
Foo = "I am foo"
},
Norf = new List<ListEntity>
{
new ListEntity
{
Foo = new List<string> { "Element One", "Element Two", "Element Three" }
}
}
};
//Act
patchDocument.Move("/Bar/Foo", "/Norf/0/Foo/1");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.IsNull(entity.Bar.Foo);
Assert.AreEqual(4, entity.Norf[0].Foo.Count);
Assert.AreEqual("Element One", entity.Norf[0].Foo[0]);
Assert.AreEqual("I am foo", entity.Norf[0].Foo[1]);
Assert.AreEqual("Element Two", entity.Norf[0].Foo[2]);
Assert.AreEqual("Element Three", entity.Norf[0].Foo[3]);
}
public void ApplyUpdate_MoveListElement_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument<ListEntity>();
var entity = new ListEntity
{
Foo = new List<string> { "Element One", "Element Two", "Element Three" }
};
//Act
patchDocument.Move("/Foo/2", "/Foo/1");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.AreEqual(3, entity.Foo.Count);
Assert.AreEqual("Element One", entity.Foo[0]);
Assert.AreEqual("Element Three", entity.Foo[1]);
Assert.AreEqual("Element Two", entity.Foo[2]);
}
public void ApplyUpdate_MoveOperation_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument<SimpleEntity>();
var entity = new SimpleEntity { Foo = "bar", Baz = "qux" };
//Act
patchDocument.Move("Foo", "Baz");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.IsNull(entity.Foo);
Assert.AreEqual("bar", entity.Baz);
}
public void ApplyUpdate_ReplaceOperation_EntityUpdated()
{
//Arrange
var patchDocument = new JsonPatchDocument<SimpleEntity>();
var entity = new SimpleEntity { Foo = "bar" };
//Act
patchDocument.Replace("Foo", "baz");
patchDocument.ApplyUpdatesTo(entity);
//Assert
Assert.AreEqual("baz", entity.Foo);
}
