public ActionResult Updateusergroup(int groupid)
{
UserService.UserServiceClient Client = new UserService.UserServiceClient();
UserGroupViewModel model = new UserGroupViewModel();
DataSet ds = new DataSet();
string xmldata = Client.GetUserGroup(groupid);
ds.ReadXml(new StringReader(xmldata));
model.Group = new UserGroup();
model.Group.UserGroupName = Convert.ToString(ds.Tables[0].Rows[0]["User_Group_Name"]);
model.Group.UserGroupDescription = Convert.ToString(ds.Tables[0].Rows[0]["User_Group_Description"]);
model.Group.UserRoleId = Convert.ToInt32(ds.Tables[0].Rows[0]["Role_ID"]);
xmldata = Client.GetRoles(1);
DataSet dsrole = new DataSet();
dsrole.ReadXml(new StringReader(xmldata));
model.Roles = new List <SelectListItem>();
if (dsrole.Tables.Count > 0)
{
foreach (System.Data.DataRow row in ds.Tables[0].Rows)
{
model.Roles.Add(new SelectListItem {
Text = row["Role_Name"].ToString(), Value = row["Role_ID"].ToString()
});
}
}
return(View("_AddUserGroup", model));
}
public ActionResult Edit(UserGroupViewModel model)
{
ViewBag.Role = _userGrDao.ListAllRole();
if (ModelState.IsValid)
{
var userGr = new UserGroup();
userGr.UpdateUserGroup(model);
var result = _userGrDao.Update(userGr);
new CredentialDao().Update(userGr, model.Role);
if (result == 0)
{
ModelState.AddModelError("", "Tên đã tồn tại");
}
else if (result > 0)
{
SetAlert("Cập nhật thành công", "success");
return(RedirectToAction("Index", "UserGroup"));
}
else
{
ModelState.AddModelError("", "Cập nhật thất bại");
}
}
return(View(model));
}
public async Task <IActionResult> Update([FromBody] UserGroupViewModel value, Guid?index)
{
if (ModelState.IsValid)
{
var grp = new UserGroup
{
ID = Guid.NewGuid(),
Code = Guid.NewGuid().ToString(),
Name = value.Name,
Description = value.Note,
CreatedBy = userId,
UpdatedBy = userId,
CreatedDate = DateTime.Now,
UpdatedDate = DateTime.Now,
UserId = userId,
IsActive = true
};
//commit
var ret = await this._unitOfWork.UserGroups.Update(grp, value.ID);
//return client side
return(Ok(ret));
}
return(BadRequest(ModelState));
}
public ActionResult Create(UserGroupViewModel model)
{
ViewBag.Role = _userGrDao.ListAllRole();
try
{
if (ModelState.IsValid)
{
var userGr = new UserGroup();
userGr.UpdateUserGroup(model);
int id = _userGrDao.Insert(userGr);
new CredentialDao().Create(userGr, model.Role);
if (id == 0)
{
ModelState.AddModelError("", "Tên đã tồn tại");
}
else if (id > 0)
{
SetAlert("Thêm thành công", "success");
return(RedirectToAction("Index", "UserGroup"));
}
else
{
ModelState.AddModelError("", "Thêm thất bại");
}
}
return(View(model));
}
catch
{ return(View()); }
}
public async Task <ActionResult> New(string tabId, int parentId)
{
var group = _service.NewProperties();
var model = UserGroupViewModel.Create(group, tabId, parentId, _service);
return(await JsonHtml("Properties", model));
}
// POST api/<controller>
public async Task <IHttpActionResult> AddUserToGroup(UserGroupViewModel GVM)
{
ResultClassToken result = new ResultClassToken();
try
{
var token = HttpContext.Current.Request.Headers["Authorization"].Replace("bearer ", "");
var mm = ApiMessage.AddUserToGroup(GVM);
if (mm != null)
{
result.Code = (int)HttpStatusCode.OK;
result.Msg = ap.Success;
}
else
{
result.Code = (int)HttpStatusCode.NonAuthoritativeInformation;
result.Msg = ap.MessageNoData;
}
if (updatetoken)
{
token = result.AccessToken = accessToken;
}
else
{
result.AccessToken = "";
}
return(Ok(result));
}
catch (Exception ex)
{
return(Ok(ApiEx.FireException(result, ex)));
}
}
public ActionResult Create(UserGroupViewModel model)
{
ViewBag.Role = _userGrDao.ListAllRole();
try
{
if (ModelState.IsValid)
{
var userGr = new USERGROUP();
userGr.ID = StringHelper.ToUnsignString(model.Name);
userGr.Name = model.Name;
int id = _userGrDao.Insert(userGr);
if (id == -1)
{
ModelState.AddModelError("", "Tên đã tồn tại");
}
else if (id == 1)
{
new CredentialDao().Create(userGr, model.Role);
SetAlert("Thêm thành công", "success");
return(RedirectToAction("Index", "UserGroup"));
}
else
{
ModelState.AddModelError("", "Thêm thất bại");
}
}
return(View(model));
}
catch
{ return(View()); }
}
public ActionResult New()
{
var mdoel = new UserGroupViewModel
{
};
return(View(mdoel));
}
public void Create(UserGroupViewModel model)
{
var result = mapper.Map <UserGroupViewModel, UsersGroup>(model);
userGroupRepository.Add(result);
dbContext.Complete();
}
public async Task <IActionResult> Index()
{
ViewBag.Roles = RoleViewModel.GetSelectList();
ViewBag.UserGroups = UserGroupViewModel.GetSelectList();
ViewBag.IsValidList = IsValidList;
var users = await ApplicationUserViewModel.GetAll(_context, _applicationUser);
return(View(users));
}
public JsonResult EditUserGroup(UserGroupViewModel request, string groupName)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Admin)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to perform this action",
}));
}
var userGroup = _context.UserGroups.FirstOrDefault(g => g.GroupName == groupName);
if (userGroup == null)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Could not find the usergroup"
}));
}
userGroup.GroupName = request.GroupName;
userGroup.Role = request.Role;
userGroup.IsDefault = request.IsDefault;
userGroup.Status = request.Status;
userGroup.AllowedPrivileges = request.Privileges;
_context.Update(userGroup);
_context.SaveChanges();
return(Json(new ReturnData <string>
{
Success = true,
Message = "Group updated successfully"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "An error occurred,please retry : " + ex.Message,
Error = new Error(ex)
}));
}
}
/// <summary>
/// Delete an entity.
/// </summary>
/// <param name="model"></param>
public void Delete(UserGroupViewModel model)
{
var entity = model.ToEntity();
this._UserGroupsRepository.Delete(entity);
#region Commit Changes
this._unitOfWork.Commit();
#endregion
}
public async Task <ActionResult> Properties(string tabId, int parentId, int id, string successfulActionCode)
{
var group = _service.ReadProperties(id);
ViewData[SpecialKeys.IsEntityReadOnly] = group.IsReadOnly;
var model = UserGroupViewModel.Create(group, tabId, parentId, _service);
model.SuccesfulActionCode = successfulActionCode;
return(await JsonHtml("Properties", model));
}
public ActionResult Edit(UserGroupViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = _userGroupService.Update(model);
return(RedirectToAction("Index", "Result", new { state = result, style = "dialog" }));
}
public async Task <ActionResult> DeleteUserGroup(UserGroupViewModel model)
{
if (string.IsNullOrEmpty(model.Id))
{
return(BadRequest());
}
await _userGroupManager.DeleteUserGroupAsync(model.Id);
return(Ok(model));
}
public JavaScriptResult Create(UserGroupViewModel userGroupvm)
{
try
{
_userGroupService.Add(Mapper.Map <UserGroup>(userGroupvm));
return(JavaScript($"ShowResult('{"Data saved successfully."}','{"success"}','{"redirect"}','{"/APanel/UserGroup?companyId=" + userGroupvm.CompanyId + "&&branchId=" + userGroupvm.BranchId}')"));
}
catch (Exception ex)
{
return(JavaScript($"ShowResult('{ex.Message}','failure')"));
}
}
public bool Add(UserGroupViewModel model)
{
model.Id = Guid.NewGuid().ToString();
UserGroup entity = new UserGroup();
uow.Set <UserGroup>().Add(entity);
entity.Id = model.Id;
entity.Name = model.Name;
entity.Description = model.Description;
entity.No = model.No;
uow.Commit();
return(true);
}
public async Task <UserGroupViewModel> Get(Guid index)
{
var c = await this._unitOfWork.UserGroups.GetItem(index);
var grp = new UserGroupViewModel
{
ID = c.ID,
Code = c.Code,
Name = c.Name
};
return(grp);
}
public IActionResult Create([FromBody] UserGroupViewModel userGroupViewModel)
{
try
{
serviceUserGroup.AddUserToAGroup(userGroupViewModel.GroupId, userGroupViewModel.UserId);
string output = "userul " + userGroupViewModel.UserId + "a fost adaugat in grupa" + userGroupViewModel.GroupId;
return(Ok(output));
}
catch (Exception e)
{
return(BadRequest());
}
}
public async Task <IActionResult> UpdateGroup([FromBody] UserGroupViewModel group)
{
if (ModelState.IsValid)
{
UserGroup appUserGroup = Mapper.Map <UserGroup>(group);
this._unitOfWork.UserGroups.Update(appUserGroup);
await this._unitOfWork.SaveChangesAsync();
return(new OkResult());
}
return(BadRequest(ModelState));
}
public int Insert(UserGroupViewModel repo)
{
seat_menu_access access = new seat_menu_access()
{
menu_id = repo.menu_id,
group_id = repo.usergroupid,
created_by = SessionValues.UserIdSession,
created_date = DateTime.Today
};
db.seat_menu_access.Add(access);
return(db.SaveChanges());
}
public virtual ActionResult Create(UserGroupViewModel userGroupView)
{
if (ModelState.IsValid)
{
var userGroup = new UserGroup();
userGroupView.MapTo(userGroup);
userGroupService.Save(userGroup);
Success(Translate("Messages.RoleCreated"));
return(RedirectToAction(MVC.Admin.UserGroup.Users(userGroup.Id)));
}
Error(Translate("Messages.ValidationError"));
return(View("New", userGroupView));
}
public ActionResult Updateusergroup(UserGroupViewModel model)
{
if (ModelState.IsValid)
{
UserService.UserServiceClient Client = new UserService.UserServiceClient();
Client.updateGroups(model.Group);
return(View("ListofUsergroup"));
}
else
{
ModelState.AddModelError("", ConfigurationManager.AppSettings["Requried"]);
}
return(View("_AddUserGroup", model));
}
// GET: UserGroups/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserGroupViewModel userGroup = Mapper.Map <UserGroupViewModel>(userGroupService.Get(id.Value));
if (userGroup == null)
{
return(HttpNotFound());
}
return(View(userGroup));
}
/// <summary>
/// Throw an exception if name is exist.
/// </summary>
/// <param name="model">UserGroup view model</param>
public void ThrowExceptionIfExist(UserGroupViewModel model)
{
ConditionFilter <UserGroup, long> condition = new ConditionFilter <UserGroup, long>
{
Query = (entity =>
entity.Name == model.Name &&
entity.Id != model.Id)
};
var existEntity = this._UserGroupsRepository.Get(condition).FirstOrDefault();
if (existEntity != null)
{
throw new ItemAlreadyExistException();
}
}
// GET: UserGroups/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserGroupViewModel userGroup = Mapper.Map <UserGroupViewModel>(userGroupService.Get(id.Value));
if (userGroup == null)
{
return(HttpNotFound());
}
ViewBag.LanguageId = new SelectList(languageService.GetAll(), "Id", "Code", userGroup.LanguageId);
return(View(userGroup));
}
public bool Update(UserGroupViewModel model)
{
var entity = uow.Set <UserGroup>().Find(model.Id);
if (entity == null)
{
return(false);
}
entity.Name = model.Name;
entity.Description = model.Description;
entity.No = model.No;
uow.Commit();
return(true);
}
/// <summary>
/// Update an entity.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public UserGroupViewModel Update(UserGroupViewModel model)
{
this.ThrowExceptionIfExist(model);
var entity = model.ToEntity();
entity = this._UserGroupsRepository.Update(entity);
#region Commit Changes
this._unitOfWork.Commit();
#endregion
model = entity.ToModel();
return(model);
}
public object GetUserGroup(int userGroupId)
{
using (DataContext db = new DataContext())
{
UserGroupViewModel model = new UserGroupViewModel();
var userGroup = db.UsersGroups.FirstOrDefault(u => u.Id == userGroupId);
if (userGroup != null)
{
model = _mapper.Map <UserGroupViewModel>(userGroup);
}
return(model);
}
}
public async Task <ActionResult> Properties(string tabId, int parentId, int id, IFormCollection collection)
{
var group = _service.ReadProperties(id);
var model = UserGroupViewModel.Create(group, tabId, parentId, _service);
await TryUpdateModelAsync(model);
if (ModelState.IsValid)
{
model.Data = _service.UpdateProperties(model.Data);
return(Redirect("Properties", new { tabId, parentId, id = model.Data.Id, successfulActionCode = ActionCode.UpdateUserGroup }));
}
return(await JsonHtml("Properties", model));
}
public virtual ActionResult Create(UserGroupViewModel userGroupView)
{
if (ModelState.IsValid)
{
var userGroup = new UserGroup();
userGroupView.MapTo(userGroup);
userGroupService.Save(userGroup);
Success(Translate("Messages.RoleCreated"));
return RedirectToAction(MVC.Admin.UserGroup.Users(userGroup.Id));
}
Error(Translate("Messages.ValidationError"));
return View("New", userGroupView);
}
public virtual ActionResult Update(long id, UserGroupViewModel userGroupView)
{
var userGroup = userGroupService.Find(id);
if (userGroup == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, Translate("Messages.CouldNotFoundEntity"));
}
if (ModelState.IsValid)
{
userGroupView.MapTo(userGroup);
userGroupService.Save(userGroup);
Success(Translate("Messages.RoleUpdated"));
return RedirectToAction(MVC.Admin.UserGroup.Index());
}
Error(Translate("Messages.ValidationError"));
return View("Edit", userGroupView);
}
