public async Task <ApplicationRoleDto> PostApplicationRole(ApplicationRoleDto model)
{
var url = CRMApiUri + "/ApplicationRole";
var result = await PostRequestToApi(url, model);
return(result);
}
/// <summary>
/// Save or update records for the table
/// </summary>
/// <param name="dtoApplicationRole">List of data to store ApplicationRole.</param>
/// <returns>The result of processing the list.</returns>
/// <author>Mauricio Suárez.</author>
public List <ApplicationRoleDto> SaveApplicationRole(ApplicationRoleDto dtoApplicationRole)
{
List <ApplicationRoleDto> listDataApplicationRole = new List <ApplicationRoleDto>();
listDataApplicationRole.Add(dtoApplicationRole);
return(this.SaveApplicationRole(listDataApplicationRole));
}
public IResponseDTO GetAllUserAdmin()
{
try
{
var data = _unitOfWork.ApplicationRole.Get(x => x.UserType == UserType.Admin).ToList();
var ApplicationRoleDto = new List <ApplicationRoleDto>();
foreach (var Model in data)
{
var Application = new ApplicationRoleDto();
Application.Id = Model.Id;
Application.Name = Model.Name;
Application.UserType = (int?)Model.UserType;
Application.Permissions = !String.IsNullOrEmpty(Model.Permissions) ? Model.Permissions.Split(',').Select(x => int.Parse(x.Trim())).ToList():new List <int>();
ApplicationRoleDto.Add(Application);
}
_response.Data = ApplicationRoleDto;
_response.Code = 200;
_response.Message = "OK";
}
catch (Exception ex)
{
_response.Data = null;
_response.Code = 200;
_response.Message = ex.Message;
}
return(_response);
}
/// <summary>
/// Gets list object of the table ApplicationRole.
/// </summary>
/// <param name="dtoApplicationRole">List that contains the DTOs from ApplicationRole table that filter the query.</param>
/// <returns>List object of the table ApplicationRole.</returns>
/// <author>Mauricio Suarez.</author>
public List <ApplicationRoleDto> GetApplicationRole(ApplicationRoleDto dtoApplicationRole)
{
List <ApplicationRoleDto> listFilterApplicationRole = new List <ApplicationRoleDto>();
listFilterApplicationRole.Add(dtoApplicationRole);
return(this.ExecuteGetApplicationRole(null, listFilterApplicationRole));
}
public async Task <BaseEntity> SaveAndReturnEntityAsync(ApplicationRoleDto entityDto)
{
var entity = _mapper.Map <ApplicationRole>(entityDto);
var result = await _repository.SaveAndReturnEntityAsync(entity);
return(result);
}
public IActionResult SavePermission(RoleDto model)
{
int id;
var message = string.Empty;
UpdateAuditInformation(model);
var entity = new ApplicationRoleDto {
ApplicationId = model.ApplicationId, RoleId = model.Id
};
if (!ModelState.IsValid)
{
message = ModelState.Values.Aggregate(message, (current1, modelState) => modelState.Errors.Aggregate(current1, (current, error) => current + error));
return(Json(new { success = false, message }));
}
foreach (var fullaccessId in model.LinkedFullAccessRolePermissionsIds)
{
int.TryParse(fullaccessId, out id);
entity.RolePermissions.Add(new PermissionDto {
AccessLevel = AccessLevel.Full, MenuItemId = id
});
}
foreach (var readonlyRoleId in model.LinkedReadonlyRolePermissionsIds)
{
int.TryParse(readonlyRoleId, out id);
entity.RolePermissions.Add(new PermissionDto {
AccessLevel = AccessLevel.Readonly, MenuItemId = id
});
}
model.ApplicationRoles.Add(entity);
model = _employeeFacadeApiClient.PutRole(model.Id, model).Result;
message = string.IsNullOrWhiteSpace(model.ErrorMessage) ? model.SuccessMessage : model.ErrorMessage;
return(Json(new { success = string.IsNullOrWhiteSpace(model.ErrorMessage), message }));
}
private async Task UpdateRolePermission(ApplicationRoleDto entity)
{
var persistedEntity = _repository.CRMContext.ApplicationRoles.Include(x => x.RolePermissions).AsNoTracking()
.FirstOrDefault(x => x.Id == entity.Id);
var persistedPermissionIds = persistedEntity.RolePermissions.Select(x => x.MenuItemId).ToList();
var currentPermissionIds = entity.RolePermissions.Select(x => x.MenuItemId).ToList();
var permissionAdded = _mapper.Map <List <Permission> >(entity.RolePermissions.Where(x => !persistedPermissionIds.Contains(x.MenuItemId)).ToList());
var permissionRemoved = _mapper.Map <List <Permission> >(persistedEntity.RolePermissions.Where(x => !currentPermissionIds.Contains(x.MenuItemId))
.ToList());
foreach (var rolePermission in permissionAdded)
{
await _repository.SaveAndReturnEntityAsync(rolePermission);
}
foreach (var rolePermission in permissionRemoved.Where(x => x.MenuItemId > 0))
{
try
{
var permission = _repository.CRMContext.Permissions.FirstOrDefault(x => x.Id == rolePermission.Id);
await _repository.HardDeleteAsync(permission);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public async Task <ApplicationRoleDto> PutApplicationRole(int id, ApplicationRoleDto model)
{
var url = CRMApiUri + "/ApplicationRole/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public async Task <IActionResult> Put(int id, [FromBody] ApplicationRoleDto applicationRole)
{
if (id == 0 || applicationRole.Id == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0."));
}
return(await SaveAndReturnEntityAsync(async() => await _applicationRoleService.SaveAndReturnEntityAsync(applicationRole)));
}
public static ApplicationRoleDto ToApplicationRoleDto(this ApplicationRole user)
{
var result = new ApplicationRoleDto();
result.Id = user.Id;
result.Name = user.Name;
return(result);
}
public async Task <IActionResult> Post([FromBody] ApplicationRoleDto applicationRole)
{
if (applicationRole.Id != 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted."));
}
return(await SaveAndReturnEntityAsync(async() => await _applicationRoleService.SaveAndReturnEntityAsync(applicationRole)));
}
public virtual void Update(String id, ApplicationRoleDto model)
{
ApplicationRole applicationRole = this.ApplicationRoleRepository.GetById(id);
applicationRole.CreatedAt = model.CreatedAt;
applicationRole.UpdatedAt = model.UpdatedAt;
applicationRole.Name = model.Name;
applicationRole.Description = model.Description;
this.ApplicationRoleRepository.Update(applicationRole);
}
public async Task <bool> IsExistsAsync(ApplicationRoleDto roleDto)
{
var isExistsRole = await _roleManager.FindByNameAsync(roleDto.Name);
if (isExistsRole == null)
{
return(true);
}
return(false);
}
public virtual String Save(ApplicationRoleDto model)
{
ApplicationRole applicationRole = new ApplicationRole();
applicationRole.Id = model.Id;
applicationRole.CreatedAt = model.CreatedAt;
applicationRole.UpdatedAt = model.UpdatedAt;
applicationRole.Name = model.Name;
applicationRole.Description = model.Description;
return(this.ApplicationRoleRepository.Save(applicationRole));
}
/// <summary>
/// 获取
/// </summary>
/// <param name="id"></param>
public virtual ApplicationRoleDto GetApplicationRoleById(String id)
{
ApplicationRole applicationRole = this.ApplicationRoleRepository.GetById(id);
ApplicationRoleDto model = new ApplicationRoleDto();
model.Id = applicationRole.Id;
model.CreatedAt = applicationRole.CreatedAt;
model.UpdatedAt = applicationRole.UpdatedAt;
model.Name = applicationRole.Name;
model.Description = applicationRole.Description;
return(model);
}
private async Task LoadData()
{
var result = await _usersApi.GetById <ApplicationUserDto>(_id);
LoadPropertyValues(result);
ApplicationRoleDto userRole = _roles.Data.Where(x => result.UserRoles.Select(y => y.RoleId).Contains(x.Id)).FirstOrDefault();
var roleRBtn = gbRoles.Controls.OfType <RadioButton>().Where(x => x.Text.ToLower() == userRole.Name.ToLower()).FirstOrDefault();
roleRBtn.Checked = true;
}
public async Task <ResponseDto <ApplicationRoleDto> > CreateAsync(ApplicationRoleDto roleDto)
{
var isExistsRole = await IsExistsAsync(roleDto);
if (isExistsRole)
{
var newRole = _mapper.Map <ApplicationRoleDto, ApplicationRole>(roleDto);
var result = await _roleManager.CreateAsync(newRole);
if (result.Succeeded)
{
return(_responseService.Response(roleDto, result.Errors.Select(c => c.Description), UserMessage.Success));
}
return(_responseService.Response(roleDto, result.Errors.Select(c => c.Description), UserMessage.Failed));
}
return(_responseService.Response(roleDto, UserMessage.Duplicated));
}
public async Task <IHttpActionResult> AddNewRole(ApplicationRoleDto model)
{
var id = RequestContext.Principal.Identity.GetUserId();
await AdminAuthorization(id);
var roleStore = new RoleStore <IdentityRole>(new ApplicationDbContext());
var roleManager = new RoleManager <IdentityRole>(roleStore);
IdentityRole role = new IdentityRole(model.Name);
var result = await roleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
/// <summary>
/// Gets list object of the table ApplicationRole.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterApplicationRole">List that contains the DTOs from ApplicationRole table that filter the query.</param>
/// <returns>List object of the table ApplicationRole.</returns>
/// <author>Mauricio Suarez.</author>
public List <ApplicationRoleDto> GetApplicationRole(PaginationDto paginationDto, ApplicationRoleDto dtoApplicationRole)
{
List <ApplicationRoleDto> listFilterApplicationRole = new List <ApplicationRoleDto>();
listFilterApplicationRole.Add(dtoApplicationRole);
return(this.ExecuteGetApplicationRole(paginationDto, listFilterApplicationRole));
}
public async Task <int> SaveAsync(ApplicationRoleDto entityDto)
{
var result = await SaveAndReturnEntityAsync(entityDto);
return(result.Id);
}
public async Task <ApplicationRoleDto> PostApplicationRole(ApplicationRoleDto model)
{
return(await _applicationRoleApiClient.PostApplicationRole(model));
}
public async Task <ApplicationRoleDto> PutApplicationRole(int id, ApplicationRoleDto model)
{
return(await _applicationRoleApiClient.PutApplicationRole(id, model));
}
public async Task <ResponseDto <ApplicationRoleDto> > CreateAsync(ApplicationRoleDto role)
{
return(await _roleService.CreateAsync(role));
}
/// <summary>
/// Create user and save its details,
/// sign it and assign User role to him/her.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <bool> Insert(ApplicationUserDto model)
{
try
{
if (model.VoiceOver == null)
{
model.VoiceOver = false;
}
if (model.BallFlight == null)
{
model.BallFlight = "Multiple";
}
if (model.HandicapId < 1 || model.HandicapId > 4)
{
model.HandicapId = 4;
}
var user = new ApplicationUserDto
{
UserName = model.UserName,
Email = model.Email,
Name = model.Name,
Address = model.Address,
City = model.City,
State = model.State,
Zip = model.Zip,
DatePaid = model.DatePaid,
Twitter = model.Twitter,
PhoneNumber = model.PhoneNumber,
LockoutEndDateUtc = model.LockoutEndDateUtc,
ClubType = model.ClubType,
Height = model.Height,
Weight = model.Weight,
Age = model.Age,
SevenIronDistance = model.SevenIronDistance,
DriverDistance = model.DriverDistance,
VoiceOver = model.VoiceOver,
BallFlight = model.BallFlight,
// Can not be null.
AccountActive = model.AccountActive,
EmailConfirmed = model.EmailConfirmed,
PhoneNumberConfirmed = model.PhoneNumberConfirmed,
TwoFactorEnabled = model.PhoneNumberConfirmed,
LockoutEnabled = model.LockoutEnabled,
AccessFailedCount = model.AccessFailedCount,
HandicapId = model.HandicapId,
};
// Create the new user
var result = await _userManager.CreateAsync(user, model.PasswordHash);
if (result.Succeeded)
{
ApplicationRoleDto applicationRole = await _roleManager.FindByNameAsync(Common.Common.Roles.User.ToString());
if (applicationRole != null)
{
// Assign role to user.
IdentityResult roleResult = await _userManager.AddToRoleAsync(user, applicationRole.Name);
if (roleResult.Succeeded)
{
return(true);
}
return(false);
}
return(false);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public String Post([FromBody] ApplicationRoleDto model)
{
return(this.ApplicationRoleService.Save(model));
}
public void Put(String id, [FromBody] ApplicationRoleDto model)
{
this.ApplicationRoleService.Update(id, model);
}
