/// <summary>
/// Create the role.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// The role.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <RoleDto> CreateRoleAsync(this IRole operations, RoleCreateDto body = default(RoleCreateDto), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateRoleWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public IActionResult CreateRole([FromBody] RoleCreateDto createRole)
{
if (createRole == null)
{
return(BadRequest(new TransActionResponse("No Role entered.")));
}
if (!ModelState.IsValid)
{
return(BadRequest(new TransActionResponse(ModelState)));
}
if (_unitOfWork.Role.RoleExists(createRole.Name))
{
return(BadRequest(new TransActionResponse("Role Already exists")));
}
var newRole = _mapper.Map <TraRole>(createRole);
_unitOfWork.Role.Create(newRole);
if (!_unitOfWork.Save())
{
return(StatusCode(500, new TransActionResponse("A problem happened while handling your request.")));
}
var createRoleResult = _mapper.Map <RoleDto>(newRole);
return(CreatedAtRoute("GetRole", new { id = createRoleResult.RoleId }, new TransActionResponse(createRoleResult)));
}
public IActionResult CreateRole([FromBody] RoleCreateDto createRole)
{
if (createRole == null)
{
return(BadRequest());
}
if (createRole.Description == null || createRole.Name == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (_transActionRepo.RoleExists(createRole.Name))
{
return(BadRequest());
}
var newRole = _mapper.Map <TraRole>(createRole);
_transActionRepo.CreateRole(newRole);
if (!_transActionRepo.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdPointOfInterestToReturn = _mapper.Map <RoleDto>(newRole);
return(CreatedAtRoute("GetThatRole", new { id = createdPointOfInterestToReturn.RoleId }, createdPointOfInterestToReturn));
}
public async Task <IActionResult> PutRole(Guid id, RoleCreateDto roleUpdateDto)
{
var roleFromDB = _roleService.GetRoleById(id);
if (roleFromDB == null)
{
return(NotFound(
new GlobalResponse
{
RequestData = roleUpdateDto,
ResponseData = null,
Status = System.Net.HttpStatusCode.NotFound,
Message = $"There is no role with Id {id}"
}
));
}
roleUpdateDto.CreatedDate = roleFromDB.CreatedDate;
_mapper.Map(roleUpdateDto, roleFromDB);
_roleService.UpdateRole(roleFromDB);
try
{
await Task.Run(() =>
{
_roleService.SaveChanges();
});
}
catch (DbUpdateConcurrencyException)
{
throw;
}
//return NoContent();
return(Ok(roleUpdateDto));
}
public async Task <Response <NoDataDto> > CreateRole(RoleCreateDto role)
{
var result = _roleManager.CreateAsync(ObjectMapper.Mapper.Map <AppRole>(role)).Result;
if (!result.Succeeded)
{
return(Response <NoDataDto> .Fail("Bir hata oldu, lütfen daha sonra tekrar deneyin", 400));
}
return(Response <NoDataDto> .Success(201));
}
/// <summary>
/// 新增角色信息
/// </summary>
/// <param name="dto">需要新增的数据</param>
/// <returns></returns>
public async Task <bool> InsertAsync(RoleCreateDto dto)
{
dto.NotNull(nameof(RoleCreateDto));
if (!await _roleRepository.IsExistAsync(op => op.Name == dto.Name))
{
var roleModel = dto.ToMap <Role>();
return(await _roleRepository.InsertAsync(roleModel));
}
throw new BusinessException("当前角色名称已存在!!!");
}
public async Task <ActionResult <RoleDto> > CreateRole(RoleCreateDto role)
{
var response = await _roleSvc.CreateRoleAsync(role);
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(CreatedAtRoute("GetRole", new { id = response.RoleId }, await _roleSvc.GetRoleAsync(response.RoleId)));
}
public async Task Create(RoleCreateDto input)
{
if (await _repository.FirstOrDefaultAsync(x => x.RoleCode == input.RoleCode) != null)
{
throw new UserFriendlyException(string.Format(L("DuplicateRoleCode"), input.RoleCode));
}
var role = input.MapTo<RoleEntity>();
role.Id = Guid.NewGuid();
await _repository.InsertAsync(role);
}
public async Task <IActionResult> AddRoleAsync([FromBody] RoleCreateDto roleDto)
{
var id = Convert.ToInt32(User.Identity.Name);
var roles = mapper.Map <Roles>(roleDto);
roles.CreateID = id;
roles.CreateTime = DateTime.Now;
await context.Roles.AddAsync(roles);
await context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <ApplicationRole> > PostApplicationRole(RoleCreateDto applicationRole)
{
try
{
var newRole = _mapper.Map <ApplicationRole>(applicationRole);
var createdRole = _roleService.CreateRole(newRole);
return(Ok(_mapper.Map <RoleDto>(createdRole)));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task Create(RoleCreateDto input)
{
if (await _repository.FirstOrDefaultAsync(x => x.RoleCode == input.RoleCode) != null)
{
throw new UserFriendlyException(string.Format(L("DuplicateRoleCode"), input.RoleCode));
}
var role = input.MapTo <RoleEntity>();
role.Id = Guid.NewGuid();
await _repository.InsertAsync(role);
}
public IHttpActionResult CreateRole([FromBody] RoleCreateDto model)
{
Role newRole;
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState));
}
newRole = roleService.Create(model.RoleName);
roleService.SaveChanges();
return(Ok(newRole));
}
public async Task <ApiResult> RoleCreate(RoleCreateDto input)
{
using var tran = await unitofWork.BeginTransactionAsync();
var role = new Role();
role.SetRole(input.RoleName, input.SuperAdmin, input.Permissions);
rolerepository.Add(role);
if (await new PermissionValidityCheckSpecification(permissionRepository).IsSatisfiedBy(role))
{
await unitofWork.CommitAsync(tran);
}
return(ApiResult.Ok("角色创建成功"));
}
public async Task <HmrRole> CreateRoleAsync(RoleCreateDto role)
{
var roleEntity = await AddAsync(role);
foreach (var permission in role.Permissions)
{
roleEntity.HmrRolePermissions
.Add(new HmrRolePermission
{
PermissionId = permission
});
}
return(roleEntity);
}
public async Task <IActionResult> EditRoleAsync(int id, [FromBody] RoleCreateDto editRoleDto)
{
var oldrole = await context.Roles.FindAsync(id);
if (oldrole == null)
{
return(NotFound());
}
oldrole.Name = editRoleDto.Name;
context.Roles.Update(oldrole);
await context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> CreateRole(RoleCreateDto roleCreateDto)
{
var roles = _roleManager.Roles.ToList();
var newRole = roleCreateDto.RoleName;
foreach (var availrole in roles)
{
if (string.Equals(availrole.Name, newRole))
{
return(BadRequest("Failed 'Role exitst"));
}
}
await _roleManager.CreateAsync(new Role { Name = newRole });
return(Ok(_roleManager.Roles.ToList()));
}
public IHttpActionResult Create(RoleCreateDto dto)
{
//Recupero l'entity
var vResults = _authorizeService.CreateRole(dto);
//Se ci sono stati errori, li notifico
if (vResults.Any())
{
Log4NetConfig.ApplicationLog.Warn(string.Format("Errore durante la creazione di un ruolo. Nome: {0}, Descrizione: {1}",
dto.Name, dto.Description, ValidationHelper.GetErrorsInline(vResults, " - ")));
NHibernateHelper.SessionFactory.GetCurrentSession().Transaction.Rollback();
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.BadRequest, vResults)));
}
//Ritorno i risultati
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK)));
}
public async Task <IActionResult> PostRole(RoleCreateDto roleCreateDto)
{
//var yetki = AuthorizeControl("RoleCreate");
//if (yetki == false)
//return Unauthorized();
Role role = new Role()
{
Name = roleCreateDto.RoleName
};
_context.Roles.Add(role);
await _context.SaveChangesAsync();
return(Ok(role));
}
public async Task <ActionResult <RoleDto> > PostRole(RoleCreateDto role)
{
Role newRole;
try
{
newRole = _mapper.Map <Role>(role);
newRole.Id = Guid.NewGuid();
_roleService.CreateRole(newRole);
await Task.Run(() =>
{
_roleService.SaveChanges();
});
}
catch (DbUpdateException ex)
{
return(BadRequest(Utils.GenerateResponse(role, null, System.Net.HttpStatusCode.BadRequest, ex.Message)));
}
return(CreatedAtAction("GetRole", new { id = newRole.Id }, newRole));
}
public async Task <ResponseHelper> CreateRole(RoleCreateDto model)
{
var result = new ResponseHelper();
try
{
var entry = Mapper.Map <Role>(model);
await _context.AddAsync(entry);
await _context.SaveChangesAsync();
result.IsSuccess = true;
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
return(result);
}
public async Task <IActionResult> PostRolePerm(RoleCreateDto roleCreateDto)
{
var roleName = _context.Roles.Where(u => u.Name == roleCreateDto.RoleName).ToList();
var roleId = 0;
foreach (var item in roleName)
{
roleId = item.Id;
}
RolePerm rolePerm = new RolePerm();
foreach (var perm in roleCreateDto.Permissions)
{
rolePerm.RoleId = roleId;
rolePerm.PermId = int.Parse(perm);
_context.RolePerms.Add(rolePerm);
await _context.SaveChangesAsync();
}
;
return(Ok(rolePerm));
}
public async Task <IActionResult> CreateRole(CreateRoleViewModel model)
{
if (ModelState.IsValid)
{
RoleCreateDto identityRole = new RoleCreateDto
{
Name = model.RoleName
};
var result = await _userService.CreateRole(identityRole);
if (result.IsSuccess)
{
return(RedirectToAction("ListRoles", "Admin"));
}
else
{
ModelState.AddModelError("", "No se pudo crear el Role");
throw new Exception("No se pudo crear el Role");
}
}
return(View(model));
}
/// <summary>
/// Create the role.
/// </summary>
/// <param name='body'>
/// The role.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <object> > CreateRoleWithHttpMessagesAsync(RoleCreateDto body = default(RoleCreateDto), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (body != null)
{
body.Validate();
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("body", body);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "CreateRole", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/v1/role").ToString();
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (body != null)
{
_requestContent = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(body, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json;odata.metadata=minimal;odata.streaming=true; charset=utf-8");
}
// Set Credentials
if (Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 201 && (int)_statusCode != 400)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <object>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 201)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject <RoleDto>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
// Deserialize Response
if ((int)_statusCode == 400)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject <Status>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public async Task <RoleDto> CreateRole(RoleCreateDto userCreateDto)
{
var result = await _accountManager.CreateRole(userCreateDto.Name);
return(ObjectMapper.Map <Role, RoleDto>(result));
}
public async Task <IActionResult> Create(RoleCreateDto roleCreateDto)
{
await BaseService.CreateAsync <ROLE, RoleCreateDto>(roleCreateDto);
return(Ok());
}
public async Task <RoleDto> CreateRole(RoleCreateDto roleCreateDto)
{
return(await _accountAppService.CreateRole(roleCreateDto));
}
/// <summary>
/// Create the role.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// The role.
/// </param>
public static RoleDto CreateRole(this IRole operations, RoleCreateDto body = default(RoleCreateDto))
{
return(operations.CreateRoleAsync(body).GetAwaiter().GetResult());
}
public async Task <IActionResult> CreateRole(RoleCreateDto role)
{
return(ActionResultInstance(await _roleService.CreateRole(role)));
}
