public virtual void Delete(TEntity entityToDelete)
{
if (dbContext.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}
private void SetModifiedOrAddedState(CoreContext context, object entity, int?id)
{
if (id != null && id.Value != 0)
{
context.Entry(entity).State = EntityState.Modified;
}
else
{
context.Entry(entity).State = EntityState.Added;
}
}
public virtual async Task <IActionResult> PutAsync(long id, T entity)
{
var entityId = (long)typeof(T).GetProperty("Id").GetValue(entity);
if (id != entityId)
{
return(BadRequest());
}
_context.Entry(entity).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync(new System.Threading.CancellationToken());
}
catch (DbUpdateConcurrencyException)
{
if (!EntityExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(await _table.FindAsync(entityId)));
}
public void Update(TEntityDTO entity)
{
var mappedEntity = Mapper.Map <TEntity>(entity);
Db.Entry(mappedEntity).State = EntityState.Modified;
Db.SaveChanges();
}
public async Task <IActionResult> PutSensor(int id, Sensor sensor)
{
if (id != sensor.SensorId)
{
return(BadRequest());
}
_context.Entry(sensor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SensorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutIncidente(int id, Incidente incidente)
{
if (id != incidente.IncidenteId)
{
return(BadRequest());
}
_context.Entry(incidente).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IncidenteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutMedia(Guid id, MediaItem media)
{
if (id != media.Id)
{
return(BadRequest());
}
_context.Entry(media).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MediaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutFriendship(int id, Friendship friendship)
{
if (id != friendship.Id)
{
return(BadRequest());
}
_context.Entry(friendship).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FriendshipExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutStudent(string id, Student student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != student.CollegeID)
{
return(BadRequest());
}
db.Entry(student).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> PutAlbum(Guid id, Album album)
{
if (id != album.Id)
{
return(BadRequest());
}
_context.Entry(album).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlbumExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutBrewery([FromRoute] int id, [FromBody] Brewery brewery)
{
if (id != brewery.BreweryId)
{
return(BadRequest());
}
_context.Entry(brewery).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Brewery.Any(e => e.BreweryId == id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEmployee([FromRoute] long id, [FromBody] Employee employee)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != employee.employeeId)
{
return(BadRequest());
}
_context.Entry(employee).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutPaises(int id, Paises paises)
{
if (id != paises.Id)
{
return(BadRequest());
}
_context.Entry(paises).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaisesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutAfetado(int id, Afetado afetado)
{
if (id != afetado.AfetadoId)
{
return(BadRequest());
}
_context.Entry(afetado).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AfetadoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IHttpActionResult PutAttendance(int id, Attendance attendance)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != attendance.ID)
{
return(BadRequest());
}
db.Entry(attendance).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!AttendanceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public virtual bool Save(TEntity entity)
{
if (entity == null)
{
throw new Exception("保存对象不能为空");
}
CoreContext.Entry <TEntity>(entity).State = EntityState.Modified;
return(CoreContext.SaveChanges() > 0);
}
public ActionResult Edit([Bind(Include = "ID,FirstName,MidName,LastName,DOB")] User user)
{
if (ModelState.IsValid)
{
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(user));
}
public ActionResult Edit(LessonViewModel lessonviewmodel)
{
if (ModelState.IsValid)
{
db.Entry(lessonviewmodel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(lessonviewmodel));
}
public void ShouldAddACategoryWithDbSet()
{
var category = new ProductsCategory {
Title = "Foo"
};
_db.ProductsCategories.Add(category);
Assert.Equal(EntityState.Added, _db.Entry(category).State);
Assert.True(category.Id < 0);
Assert.Null(category.TimeStamp);
_db.SaveChanges();
Assert.Equal(EntityState.Unchanged, _db.Entry(category).State);
Assert.Equal(0, category.Id);
Assert.NotNull(category.TimeStamp);
Assert.Equal(1, _db.ProductsCategories.Count());
}
public int Delete(int id, byte[] timeStamp, bool persist = true)
{
var entry = GetEntryFromChangeTracker(id);
if (entry != null)
{
if (entry.TimeStamp == timeStamp)
{
return(Delete(entry, persist));
}
throw new Exception("Unable to delete due to concurrency violation.");
}
Db.Entry(new T {
Id = id, TimeStamp = timeStamp
}).State = EntityState.Deleted;
return(persist ? SaveChanges() : 0);
}
public void ShouldDeleteACategoryWithTimestampData()
{
var category = new ProductsCategory {
Title = "Foo"
};
_db.ProductsCategories.Add(category);
_db.SaveChanges();
var context = new CoreContext();
var catToDelete = new ProductsCategory {
Id = category.Id, TimeStamp = category.TimeStamp
};
context.Entry(catToDelete).State = EntityState.Deleted;
var affected = context.SaveChanges();
Assert.Equal(1, affected);
}
public void RemoveIdentityFromGroup(SecurityGroupSecurityIdentity groupConenction)
{
context.Entry(groupConenction.Group).State = EntityState.Detached;
context.Entry(groupConenction.Identity).State = EntityState.Detached;
context.Entry(groupConenction).State = EntityState.Deleted;
}
public virtual void SetModified(T entity)
{
_contexto.Entry(entity).State = EntityState.Modified;
}
public async Task UpdateAsync(T entity)
{
_context.Entry(entity).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
public async Task Update(Student std)
{
_context.Entry(std).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
public async Task UpdateAsync(User entity)
{
_context.Entry(entity).State = EntityState.Modified;
}
