Example #1
0
        public async Task <Model.Services.Common.Result> UserInfo([FromBody] UserRequest model)
        {
            var Validate = _tokenManegerService.ValidateServiceToken(HttpContext).Result;

            if (Validate.Success)
            {
                try
                {
                    Model.Services.Common.Result result = new Model.Services.Common.Result();

                    result.Data = await _userManagerService.GetUser(model);

                    result.Success       = true;
                    result.ResultMessage = "Infomações Listadas com sucesso";

                    return(result);
                }
                catch (Exception ex)
                {
                    return(new Model.Services.Common.Result()
                    {
                        Success = false,
                        ResultMessage = $"Ocorreu um erro durante a operação, Descricao: {ex.Message}"
                    });
                }
            }
            else
            {
                return(new Model.Services.Common.Result()
                {
                    Success = false,
                    ResultMessage = $"Token Inválido, Descricao: {Validate.ResultMessage}"
                });
            }
        }
        public async Task <Model.Services.Common.Result> GenerateToken([FromBody] Model.Services.Application.Application modelApplication)
        {
            var Validate = _tokenManegerService.ValidateServiceToken(HttpContext).Result;

            if (Validate.Success)
            {
                try
                {
                    Model.Services.Common.Result result = new Model.Services.Common.Result();

                    result.Data = await _applicationServices.CreateApplication(modelApplication);

                    result.Success       = true;
                    result.ResultMessage = "Aplicação criado com sucesso";

                    return(result);
                }
                catch (Exception ex)
                {
                    return(new Model.Services.Common.Result()
                    {
                        Success = false,
                        ResultMessage = $"Ocorreu um erro durante a operação: Descrição {ex.Message}"
                    });
                }
            }
            else
            {
                return(new Database.Model.Application.ApplicationRepository()
                {
                    Success = false,
                    ResultMessage = $"Token invalido. Erro: {Validate.ResultMessage}"
                });
            }
        }
Example #3
0
        public async Task <Model.Services.Common.Result> UpdateCompany([FromBody] Empresa empresa)
        {
            var Validate = _tokenManegerService.ValidateServiceToken(HttpContext).Result;

            if (Validate.Success)
            {
                try
                {
                    Model.Services.Common.Result result = new Model.Services.Common.Result();

                    result.Data = await _companyService.UpdateCompany(empresa);

                    result.Success       = true;
                    result.ResultMessage = "Empresa Atualizada com sucesso";

                    return(result);
                }
                catch (Exception ex)
                {
                    return(new Model.Services.Common.Result()
                    {
                        Success = false,
                        ResultMessage = $"Ocorreu um erro durante a operação, Descricao: {ex.Message}"
                    });
                }
            }
            else
            {
                return(new Model.Services.Common.Result()
                {
                    Success = false,
                    ResultMessage = $"Token Inválido, Descrica: {Validate.ResultMessage}"
                });
            }
        }
Example #4
0
        public async Task <Model.Services.Common.Result> ListPermission()
        {
            try
            {
                Model.Services.Common.Result result = new Model.Services.Common.Result();

                result.Data = await _permissionControlService.GetMenu(HttpContext);

                result.Success       = true;
                result.ResultMessage = "Infomações Listadas com sucesso";

                return(result);
            }
            catch (Exception ex)
            {
                return(new Model.Services.Common.Result()
                {
                    Success = false,
                    ResultMessage = $"Ocorreu um erro durante a operação, Descricao: {ex.Message}"
                });
            }
        }
        public async Task <Model.Services.Common.Result> GenerateUserToken(UserRequest userRequest)
        {
            try
            {
                Model.Services.Common.Result result = new Model.Services.Common.Result();

                result.Data = await _tokenManegerService.CreateUserToken(userRequest);

                result.Success       = true;
                result.ResultMessage = "Token gerado com sucesso";

                return(result);
            }
            catch (Exception ex)
            {
                return(new Model.Services.Common.Result()
                {
                    Success = false,
                    ResultMessage = $"Ocorreu um erro durante a operação: Descrição {ex.Message}"
                });
            }
        }
        public async Task <Model.Services.Common.Result> ValidateToken()
        {
            try
            {
                Model.Services.Common.Result result = new Model.Services.Common.Result();

                result.Data = await _tokenManegerService.ValidateServiceToken(HttpContext);

                result.Success       = true;
                result.ResultMessage = "Token validado com sucesso";

                return(result);
            }
            catch (Exception ex)
            {
                return(new Model.Services.Authentication.ValidateToken()
                {
                    Success = false,
                    ResultMessage = $"Ocorreu um erro durante a operação: Descrição {ex.Message}"
                });
            }
        }
        public async Task <Model.Services.Common.Result> FlowRegister([FromBody] Model.Services.Business.FlowRequest model)
        {
            try
            {
                Model.Services.Common.Result result = new Model.Services.Common.Result();

                result.Data = await _businessService.RegisterFlow(model);

                result.Success       = true;
                result.ResultMessage = "Fluxo cadastrado com sucesso";

                return(result);
            }
            catch (Exception ex)
            {
                return(new Model.Services.Common.Result()
                {
                    Success = false,
                    ResultMessage = $"Ocorreu um erro durante a operação. Descricao: {ex.Message}"
                });
            }
        }
Example #8
0
        public async Task <Model.Services.Common.Result> ListByName([FromBody] FantasyName fantasyName)
        {
            try
            {
                Model.Services.Common.Result result = new Model.Services.Common.Result();

                result.Data = await _companyService.ListByName(fantasyName);

                result.Success       = true;
                result.ResultMessage = "Empresas listadas com sucesso";

                return(result);
            }
            catch (Exception ex)
            {
                return(new Model.Services.Common.Result()
                {
                    Success = false,
                    ResultMessage = $"Ocorreu um erro durante a operação, Descricao: {ex.Message}"
                });
            }
        }