Exemplo n.º 1
0
        public async Task CreateRoles()
        {
            // Arrange
            var testRole = context.Roles.FirstOrDefault(r => r.RoleLevel == RoleLevel.NULL);

            context.Roles.Remove(testRole);
            context.SaveChanges();

            // Act
            var result = await sut.Add(newRole);

            // Assert
            Assert.That(result.Success, Is.True);
            Assert.That((Role)result.Object, Is.InstanceOf <Role>());
        }
Exemplo n.º 2
0
        public async Task <IActionResult> Post([FromBody] RoleItem role)
        {
            var result = await repository.Add(role);

            if (result == null)
            {
                return(NotFound());
            }

            return(Ok(result));
        }
        public async Task <ActionResult <RoleDto> > PostRole(RoleDto role)
        {
            var response = await _repository.Add(_mapper.Map <Role>(role));

            if (!response.Success)
            {
                return(Conflict(response.Message));
            }

            return(CreatedAtAction("GetRole", new { id = role.Id }, response.Data));
        }
Exemplo n.º 4
0
    public HttpResponseMessage Post([FromBody] RoleItem role)
    {
        var result = repository.Add(role);

        if (result == null)
        {
            return(Request.CreateResponse(HttpStatusCode.NotFound));
        }

        return(Request.CreateResponse(HttpStatusCode.Created, result));
    }
Exemplo n.º 5
0
        public object Post(Roles roledata)
        {
            object json;
            string messageError = "";

            try
            {
                Roles posted = repository.Add(roledata, ref messageError);

                if (posted != null)
                {
                    json = new
                    {
                        total   = 1,
                        data    = posted,
                        success = true
                    };
                }
                else
                {
                    json = new
                    {
                        message = messageError,
                        success = false
                    };
                };
            }
            catch (Exception ex)
            {
                LogManager.Write("ERROR:" + Environment.NewLine + "\tMETHOD = " + this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + Environment.NewLine + "\tMESSAGE = " + ex.Message);

                object error = new { message = ex.Message };

                json = new
                {
                    message = ex.Message,
                    success = false
                };
            };

            return(json);
        }
    public HttpResponseMessage Post([FromBody] RoleItem role)
    {
        try
        {
            var result = repository.Add(role);
            if (result == null)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            return(Request.CreateResponse(HttpStatusCode.Created, result));
        }
        catch (UnauthorizedAccessException)
        {
            return(Request.CreateResponse(HttpStatusCode.Unauthorized));
        }
        catch (Exception)
        {
            return(Request.CreateResponse(HttpStatusCode.InternalServerError));
        }
    }
 public void Create(RoleDTO aspNetRole)
 {
     _roles.Add(Mapper.Map <RoleDTO, AspNetRole>(aspNetRole));
 }
 public async Task Add(Roles roles)
 {
     await _rolesRepository.Add(roles);
 }
        public async Task <IRoleResult> CreateRole(
            string name,
            RoleLevel roleLevel)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException(nameof(name));
            }

            var result = new RoleResult();

            try
            {
                if (!(await rolesRepository.HasRoleLevel(roleLevel)))
                {
                    var role = new Role()
                    {
                        Name      = name,
                        RoleLevel = roleLevel
                    };

                    var response = await rolesRepository.Add(role);

                    if (response.Success)
                    {
                        result.Success = response.Success;
                        result.Message = RolesMessages.RoleCreatedMessage;
                        result.Role    = (IRole)response.Object;

                        return(result);
                    }
                    else if (!response.Success && response.Exception != null)
                    {
                        result.Success = response.Success;
                        result.Message = response.Exception.Message;

                        return(result);
                    }
                    else
                    {
                        result.Success = false;
                        result.Message = RolesMessages.RoleNotCreatedMessage;

                        return(result);
                    }
                }
                else
                {
                    result.Success = false;
                    result.Message = RolesMessages.RoleAlreadyExistsMessage;

                    return(result);
                }
            }
            catch (Exception exp)
            {
                result.Success = false;
                result.Message = exp.Message;

                return(result);
            }
        }