public IActionResult InitiateDb()
{
roleService.Add("User");
roleService.Add("Manager");
return(RedirectToAction("Index"));
}
public RoleServiceTests()
{
this.service = new RoleService();
service.Add(new Role { RoleType = "Administrator" }
);
service.Add(new Role { RoleType = "Order" }
);
}
public ActionResult Create([Bind(Include = "RoleId,Name,Type,Description")] Role role)
{
if (ModelState.IsValid)
{
_roleService.Add(role);
return(RedirectToAction("Index"));
}
return(View(role));
}
public RoleServiceTests()
{
this.service = new RoleService();
service.Add(new Role {
RoleType = "Administrator"
}
);
service.Add(new Role {
RoleType = "Register User"
}
);
}
public ActionResult <AddModel <RoleModel> > Add()
{
try
{
return(Ok(_serviceRole.Add()));
}
catch (Exception exception)
{
ModelState.AddModelError("ErrorMessage", exception.Message);
return(BadRequest(ModelState));
}
}
public ActionResult <RoleDto> Add(Role role)
{
var result = _roleService.Add(role);
return(result.IsSuccess ? Ok(new RoleDto(result.Value))
: (ActionResult)NotFound());
}
//[ApiExplorerSettings(IgnoreApi = true)] //隐藏接口
public async Task <ApiResult> Add(string Names, int Sorting)
{
// 以接口的形式返回数据
var res = new ApiResult {
statusCode = (int)ApiEnum.ParameterError
};
if (string.IsNullOrWhiteSpace(Names))
{
res.msg = "请填写标题";
}
else
{
try
{
Role m = new Role();
m.Names = Names;
m.Sorting = Sorting;
res.success = db.Add(m) > 0;
if (res.success)
{
res.statusCode = (int)ApiEnum.Status;
}
}
catch (Exception ex)
{
res.statusCode = (int)ApiEnum.Error;
res.msg = ApiEnum.Error.GetEnumText() + ex.Message;
}
}
// {"success":true,"message":null,"statusCode":200,"data":null}
return(await Task.Run(() => res));
}
public ActionResult <OperateResult <Auth_Role> > Post([FromBody] AuthRoleParam value)
{
var result = Json(_service.Add(value));
_cacheHelp.UpdateRoleCache();
return(result);
}
public override bool SaveEntity()
{
roleEntity = null;
roleEntity = new PiRoleEntity
{
Code = txtCode.Text.Trim(),
RealName = txtRealName.Text.Trim(),
Enabled = chkEnabled.Checked ? 1 : 0,
Description = txtDescription.Text.Trim(),
DeleteMark = 0,
AllowDelete = 1,
AllowEdit = 1
};
if (this.cboCategory.SelectedValue != null && this.cboCategory.SelectedValue.ToString().Length > 0)
{
roleEntity.Category = cboCategory.SelectedValue.ToString();
}
else
{
roleEntity.Category = null;
}
if (base.UserInfo != null)
{
roleEntity.CreateBy = UserInfo.RealName;
roleEntity.CreateUserId = UserInfo.Id;
}
string statusMessage = string.Empty;
string statusCode = string.Empty;
try
{
roleService.Add(base.UserInfo, roleEntity, out statusCode, out statusMessage);
if (statusCode == StatusCode.OKAdd.ToString())
{
if (SystemInfo.ShowSuccessMsg)
{
MessageBoxHelper.ShowSuccessMsg(statusMessage);
}
return(true);
}
else
{
MessageBoxHelper.ShowWarningMsg(statusMessage);
if (statusCode == StatusCode.ErrorNameExist.ToString())
{
this.txtRealName.SelectAll();
}
return(false);
}
}
catch (Exception ex)
{
base.ProcessException(ex);
return(false);
}
}
public async Task <MessageModel <int> > Post([FromBody] Role role)
{
return(new MessageModel <int>
{
response = await _service.Add(role)
});
}
public ActionResult Save(RoleModel model)
{
try
{
Role entity = new Role();
ModelCopier.CopyModel(model, entity);
if (model.Id == 0)
{
roleService.Add(entity);
}
else
{
roleService.Update(entity);
}
unitOfWork.Commit();
return(PartialView());
}
catch
{
return(RedirectToAction("Error", "Main"));
}
}
public async Task <ActionResult <ApiResult> > Add(RoleStrActions roleStrActions)
{
await _RoleService.Add(roleStrActions);
ApiResult resp = new ApiResult();
resp.code = Code.Success;
return(resp);
}
public ActionResult Create(Role role)
{
if (ModelState.IsValid)
{
_roleService.Add(role);
}
return(RedirectToAction("Create"));
}
public async Task <IActionResult> Add(RoleViewModel model)
{
var result = await roleService.Add(model);
if (result == null)
{
return(RedirectToAction(nameof(Index)));
}
return(RedirectToAction(nameof(Index), new { errorMessage = result }));
}
public ActionResult New(RoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = _roleService.Add(model);
return(RedirectToAction("Index", "Result", new { state = result, style = "dialog" }));
}
public ActionResult Create(Role rol)
{
if (ModelState.IsValid)
{
rolservice.Add(rol);
uow.SaveChanges();
return(RedirectToAction("Index", "Roles"));
}
return(View(rol));
}
public IAjaxResult AddRole(Role role)
{
if (_roleService.Add(role))
{
return(Success("添加成功！"));
}
else
{
return(Error("添加失败"));
}
}
public object Add(RoleViewModel model)
{
model = _roleService.Add(model);
if (model == null)
{
return(new ResponseDetails(false, "Could not add new role."));
}
return(new ResponseDetails(true, model));
}
public IActionResult Create(RoleViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var original = _mapper.Map <Role>(viewModel);
_roleService.Add(original);
return(CreatedAtRoute("find", original.Id));
}
public IHttpActionResult AddRole([FromBody] OPC_AuthRole role)
//public IHttpActionResult AddUser()
{
//TODO:check params
if (_roleService.Add(role))
{
return(Ok());
}
return(InternalServerError());
}
public IActionResult Post([FromBody] RoleViewModel model)
{
if (!ModelState.IsValid)
{
var errors = ModelState.ToDictionary(x => x.Key, x => x.Value.Errors.Select(e => e.ErrorMessage).ToList())
.Select(x => new ValidationResponse()
{
Key = x.Key,
Validations = x.Value
});
return(BadRequest(errors));
}
return(DoActionWithReturnResult(() =>
{
var roleId = _roleService.Add(model);
_roleService.Save();
return ResponseDataSuccess(roleId);
}));
}
public IActionResult Post(Role _obj)
{
if (ModelState.IsValid)
{
return(Ok(_roleService.Add(_obj)));
}
else
{
return(BadRequest(ModelState));
}
}
public ActionResult Create(CreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View("_Create", model));
}
_roleService.Add(model.RoleName);
return(Content("Refresh"));
}
public async Task <ActionResult> AddDepartment([FromBody] AddRoleDto roleDto)
{
if (!IsAvailableOperation())
{
return(BadRequest());
}
await _roleService.Add(roleDto);
AddLog(Enums.LogType.Create, LogMessage.CreateSuccessByNameMessage(LogMessage.RoleEntityName, roleDto.Name, LogMessage.CreateAction, UserId));
return(Ok());
}
public ActionResult Create([Bind(Include = "ID,Name")] Role role)
{
if (ModelState.IsValid)
{
_roleService.Add(role);
_roleService.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(role));
}
public IActionResult Ekle(Role rol)
{
try
{
_rolService.Add(rol);
return(Ok());
}
catch (Exception)
{
return(BadRequest(rol));
}
}
public override IHttpActionResult Post(IdentityRole model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
model.Id = Guid.NewGuid().ToString();
var add = _service.Add(model);
return(Ok(add));
}
public ActionResult Add(RoleDto dto)
{
if (ModelState.IsValid)
{
var result = _roleService.Add(dto);
if (result.IsNotBlank())
{
return(RedirectToAction("Index"));
}
}
return(View(dto));
}
public IHttpActionResult Add([FromBody] RoleViewModel model)
{
try
{
var responseData = _roleService.Add(model);
return(Ok(responseData));
}
catch (Exception ex)
{
_logger.LogError("Error at method: Add - RoleApi," + ex.InnerException.InnerException.Message + "");
return(BadRequest("Error System"));
}
}
/// <summary>
/// 实现对用户角色的添加信息
/// </summary>
/// <param name="role"></param>
/// <returns></returns>
public ActionResult AddUserRoleInfo(Role role)
{
//实现对用户的添加信息
role.DelFlag = (short)DelFlagEnum.None;
role.SubTime = DateTime.Now;
var result = _roleService.Add(role);
if (result.Code == ResultEnum.Success && result.Data.ID > 0)
{
return(Content("OK"));
}
return(Content(result.Msg));
}
public void AddTest()
{
var type = Guid.NewGuid().ToString();
var NewRole = new Role
{
RoleType = type
};
var AddedRole = service.Add(NewRole);
Assert.IsNotNull(AddedRole);
Assert.IsTrue(AddedRole.Id > 0);
Assert.AreEqual(AddedRole.RoleType, type);
}
