/// <summary>
/// Create gateway in particular boundary, return true if successfully created else return false
/// </summary>
/// <param name="gatewayName">GatewayName</param>
/// <param name="gatewayMAC">GatewayMAC</param>
/// <param name="createdBy">CreatedBy</param>
/// <param name="boundaryId">BoundaryId</param>
/// <param name="isEnable">IsEnable</param>
/// <returns>True if gateway successfully created</returns>
/// Author = Ali Abbas, version 1.0
public bool CreateGateway(string gatewayName, string gatewayMAC, string createdBy, int boundaryId, bool isEnable)
{
try
{
Gateway gateway = new Gateway()
{
GatewayName = gatewayName,
GatewayMAC = gatewayMAC,
CreatedBy = createdBy,
BoundaryId = boundaryId,
IsEnable = isEnable,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
using (db.Database.BeginTransaction())
{
db.Entry(gateway).State = EntityState.Added;
db.Gateways.Add(gateway);
db.SaveChanges();
db.Database.CommitTransaction();
return(true);
}
}
catch (Exception ex)
{
db.Database.RollbackTransaction();
throw ex;
}
}
/// <summary>
/// Update method for updating record
/// </summary>
/// <param name="entity">T type of entity model</param>
public void Update(TEntity entity)
{
var entry = _db.Entry(entity);
if (entry.State == EntityState.Detached)
{
_dbSet.Attach(entity);
entry = _db.Entry(entity);
}
entry.State = EntityState.Modified;
}
public async Task <IActionResult> PutApplicationUser([FromRoute] Guid id, [FromBody] ApplicationUser applicationUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != applicationUser.Id)
{
return(BadRequest());
}
_context.Entry(applicationUser).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ApplicationUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
//GET message/details/1
public ActionResult Details(int?id)
{
string userId = User.Identity.GetUserId();
Message message = Db.Messages.Find(id);
var grps = Db.Groups.Where(g => g.Users.Any(u => u.Id.Equals(userId))).ToList();
if (!(message.SenderId.Equals(userId)) && !(message.ApplicationUserMessages.Where(u => u.User_Id.Equals(userId)).Any()) && !(grps.Any(g => g.Messages.Any(m => m.Id.Equals(id)))))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if ((message.ApplicationUserMessages.Where(u => u.User_Id.Equals(userId)).Any()))
{
message.ApplicationUserMessages.Where(u => u.Message_Id.Equals(id)).First().User.Email.ToString();
var um = Db.ApplicationUserMessages.Find(userId, message.Id);
um.Read = true;
Db.Entry(um).State = EntityState.Modified;
Db.SaveChanges();
}
MessageViewModel viewModel = new MessageViewModel(
message.Subject,
message.Sender.Email,
message.Body);
return(View(viewModel));
}
public async Task <IActionResult> PutDocument([FromRoute] long id, [FromBody] Document document)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != document.DocumentId)
{
return(BadRequest());
}
_context.Entry(document).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DocumentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCustomer(long id, Customer customer)
{
if (id != customer.Id)
{
return(BadRequest());
}
_context.Entry(customer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult EditRole(string id, string Name)
{
string RoleNameNew = Name;
if (ModelState.IsValid)
{
RoleManager <IdentityRole> RoleManager1 = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new IdentityContext()));
if (!RoleManager1.RoleExists(RoleNameNew))
{
IdentityContext IdentityDbContext1 = new IdentityContext();
IdentityRole Role1 = IdentityDbContext1.Roles.First(x => x.Id == id);
Role1.Name = RoleNameNew;
IdentityDbContext1.Entry(Role1).State = System.Data.Entity.EntityState.Modified;
IdentityDbContext1.SaveChanges();
//return RedirectToAction("AllRoles");
return(Json(new { success = true }));
}
else
{
ModelState.AddModelError("", "گروه جدید قبلا ساخته شده است.");
}
}
else
{
ModelState.AddModelError("", "داده های وارد شده معتبر نیستند.");
}
return(PartialView("_EditRole", RoleNameNew));
}
public ActionResult EditUser(ApplicationUser User1)
{
if (ModelState.IsValid)
{
UserManager <ApplicationUser> UserManager1 = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new IdentityContext()));
//جهت فعال کردن امکان ثبت نام فارسی
UserManager1.UserValidator = new UserValidator <ApplicationUser>(UserManager1)
{
AllowOnlyAlphanumericUserNames = false
};
if ((UserManager1.FindByName(User1.UserName) == null) ||
(UserManager1.FindById(User1.Id).UserName == User1.UserName))
{
IdentityContext IdentityContext1 = new IdentityContext();
IdentityContext1.Entry(User1).State = System.Data.Entity.EntityState.Modified;
IdentityContext1.SaveChanges();
//return RedirectToAction("AllUsers");
return(Json(new { success = true }));
}
else
{
ModelState.AddModelError("", "نام" + User1.UserName + "قبلا انتخاب شده است.");
}
}
else
{
ModelState.AddModelError("", "داده های وارد شده نامعتبراند");
}
return(PartialView("_EditUser", User1));
}
public async Task <IActionResult> PutAspNetRole([FromRoute] string id, [FromBody] AspNetRole aspNetRole)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != aspNetRole.Id)
{
return(BadRequest());
}
_context.Entry(aspNetRole).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AspNetRoleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Task <IdentityResult> Update(Role role)
{
return(Task <IdentityResult> .Run(() =>
{
var entry = Context.Entry <Role>(role);
if (entry.State == EntityState.Detached)
{
Context.Set <Role>().Attach(role);
}
if (entry.State == EntityState.Unchanged)
{
Context.Entry(role).State = EntityState.Modified;
}
Context.SaveChanges();
return IdentityResult.Success;
}));
}
public virtual async Task UpdateAsync(TEntity entity)
{
var entityDb = await _dataset.FindAsync(entity.Id);
entity.CreatedAt = entityDb.CreatedAt;
entity.UpdatedAt = DateTime.UtcNow;
_context.Entry(entityDb).CurrentValues.SetValues(entity);
await _context.SaveChangesAsync();
}
public async Task <User> Get(int id)
{
var user = await identityContext.Users.FindAsync(id);
if (user != null)
{
await identityContext.Entry(user).Collection(x => x.Groups).LoadAsync();
}
return(user);
}
/// <summary>
/// Save the token granted to user with Token Key and Expiry Date
/// </summary>
/// <param name="userName">Username</param>
/// <param name="tokenKey">Token key</param>
/// <param name="expiryDate">Expiry Date of Token</param>
/// <param name="isCompleted">Optional = false</param>
/// <returns>If successfully saved return true</returns>
public bool SaveToken(string userName, string tokenKey, DateTime expiryDate, bool isCompleted = false)
{
if (!string.IsNullOrEmpty(tokenKey))
{
try
{
AspNetUser user = _db.AspNetUsers.SingleOrDefault(u => u.UserName.Equals(userName, StringComparison.OrdinalIgnoreCase));
user.TokenKey = tokenKey;
user.ExpiryDate = expiryDate;
user.IsComplete = isCompleted;
_db.Entry(user).State = EntityState.Modified;
_db.SaveChanges();
return(true);
}
catch (Exception ex)
{
LogHelper.WriteLog(TAG, ex);
throw ex;
}
}
return(false);
}
public async Task <ActionResult> ViewProfile(ExtendedProfileModels model)
{
if (ModelState.IsValid)
{
using (IdentityContext idDb = new IdentityContext())
{
var currentUserId = User.Identity.GetUserId();
var currentUser = idDb.Users.FirstOrDefault(x => x.Id == currentUserId);
var copy = Clone(currentUser);
copy.FirstName = model.FirstName;
copy.LastName = model.LastName;
copy.Email = model.Email;
//if (model.Password != null)
//{
// copy.PasswordHash = new UserManager<ApplicationUser>(idDb).PasswordHasher.HashPassword(model.Password);
//}
if (model.UserProfilePicture != null)
{
if (model.UserProfilePicture.ContentLength > (4 * 1024 * 1024))
{
ModelState.AddModelError("CustomError", "Image can not be lager than 4MB.");
return(View());
}
if (
!(model.UserProfilePicture.ContentType == "image/jpeg" ||
model.UserProfilePicture.ContentType == "image/gif"))
{
ModelState.AddModelError("CustomError", "Image must be in jpeg or gif format.");
}
byte[] data = new byte[model.UserProfilePicture.ContentLength];
model.UserProfilePicture.InputStream.Read(data, 0, model.UserProfilePicture.ContentLength);
copy.ProfilePicture = data;
}
idDb.Entry(currentUser).CurrentValues.SetValues(copy);
await idDb.SaveChangesAsync();
}
return(RedirectToAction("ViewProfile", "Profile"));
}
// If we got this far, something failed, redisplay form
return(View());
}
public TEntity Update(TEntity updated, long key)
{
if (updated == null)
{
return(null);
}
var existing = _context.Set <TEntity>().Find(key);
if (existing != null)
{
_context.Entry(existing).CurrentValues.SetValues(updated);
}
return(existing);
}
public async Task <bool> UpdateUserAsync(User user)
{
_context.Entry(user).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (_context.Users.Find(user.Id) == null)
{
return(false);
}
throw;
}
return(true);
}
public async Task <IActionResult> Put(int id, Product product)
{
if (id != product.Id)
{
return(BadRequest());
}
_context.Entry(product).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (ProductExists(id))
{
return(BadRequest());
}
throw;
}
return(NoContent());
}
public async Task UpdateAsync(T entity)
{
//_identityContext.BeginTransaction();
_identityContext.Entry(entity).State = EntityState.Modified;
await _identityContext.SaveChangesAsync();
}
/// <summary>
/// 회원 정보 수정
/// </summary>
public async Task ModifyUserAsync(UserModel user)
{
_db.Entry(user).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
await _db.SaveChangesAsync();
}
public async Task <IActionResult> PutAnime(AnimeItem animeItem)
{
_context.Entry(animeItem).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok(animeItem));
}
public void Update(T entity)
{
context.Entry(entity).State = EntityState.Modified;
}
/// <summary>
/// Create profile.
/// </summary>
/// <param name="profile">New profile.</param>
public void Create(Profile profile)
{
_context.Entry(profile).State = System.Data.Entity.EntityState.Added;
_context.SaveChanges();
}
public async Task UpdateAsync(ApplicationUser user)
{
_db.Users.Attach(user);
_db.Entry(user).State = EntityState.Modified;
await _db.SaveChangesAsync();
}
public async Task UpdateAsync(T entity)
{
DbContext.Entry(entity).State = EntityState.Modified;
await DbContext.SaveChangesAsync();
}
