コード例 #1
0
        public UpdatePermissionOut Update(UpdatePermissionIn input)
        {
            var output = new UpdatePermissionOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.Permission.Permission();

            var updatePermissiontOut = request.UpdatePermission(new MethodParameters.Permission.UpdatePermissionIn()
            {
                permission = new Entities.Database.Permission()
                {
                    pm_code             = input.pm_code,
                    pm_name             = input.pm_name,
                    pm_modificationUser = input.pm_modificationUser,
                    pm_status           = input.pm_status
                }
            });

            if (updatePermissiontOut.result == Entities.Common.Result.Success)
            {
                output.pmID   = updatePermissiontOut.pmID;
                output.result = Entities.Common.Result.Success;
            }

            return(output);
        }
コード例 #2
0
        public CreatePermissionOut Create(CreatePermissionIn input)
        {
            var output = new CreatePermissionOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.Permission.Permission();

            var createPermissionOut = request.CreatePermission(new MethodParameters.Permission.CreatePermissionIn()
            {
                permission = new Entities.Database.Permission()
                {
                    pm_name         = input.pm_name,
                    pm_description  = input.pm_description,
                    pm_creationUser = input.pm_creationUser
                }
            });

            if (createPermissionOut.result == Entities.Common.Result.Success)
            {
                output.pmID   = createPermissionOut.pmID;
                output.result = Entities.Common.Result.Success;
            }

            return(output);
        }
コード例 #3
0
        public TransferBalanceOut TransferBalance(TransferBalanceIn input)
        {
            var output = new TransferBalanceOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.User.User();

            var getUserInfoOut = request.GetUsers(new MethodParameters.User.GetUsersIn()
            {
            }).listUsers.FirstOrDefault(x => x.usrID == input.currentUser.usrID);
            var permissionRequest        = new Business.Permission.Permission();
            var validateAccesFunctionOut = permissionRequest.GetPermissionByRole(new MethodParameters.Permission.GetPermissionByRoleIn()
            {
                role = getUserInfoOut.usr_role
            });

            if (validateAccesFunctionOut.result == Entities.Common.Result.Success &&
                validateAccesFunctionOut.listPermissions.FirstOrDefault(x => x.pm_code == "06") != null)
            {
                var getUserOut = request.GetUser(new MethodParameters.User.GetUserIn()
                {
                    usr_userName = input.usr_userNameOrigin
                });

                if (getUserOut.result == Entities.Common.Result.Success &&
                    getUserOut.user.usr_balance >= input.valueTransfer)
                {
                    var transferBalanceOut = request.TransferBalance(new MethodParameters.User.TransferBalanceIn()
                    {
                        usr_userNameOrigin  = input.usr_userNameOrigin,
                        usr_userNameDestiny = input.usr_userNameDestiny,
                        valueTransfer       = input.valueTransfer
                    });

                    if (transferBalanceOut.result == Entities.Common.Result.Success)
                    {
                        output.message = "Transferencia realizada con exito";
                        output.result  = Entities.Common.Result.Success;
                    }
                }
                else if (getUserOut.result == Entities.Common.Result.Success)
                {
                    output.message = "El valor a transferir supera el balance de la cuenta de origen";
                    output.result  = Entities.Common.Result.Success;
                }
            }
            else if (validateAccesFunctionOut.result == Entities.Common.Result.Success)
            {
                output.message = "Esta funcionalidad no se encuentra disponible para no usuarios";
            }

            return(output);
        }
コード例 #4
0
        public DeleteBalanceOut DeleteBalance(DeleteBalanceIn input)
        {
            var output = new DeleteBalanceOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.User.User();

            var getUserInfoOut = request.GetUsers(new MethodParameters.User.GetUsersIn()
            {
            }).listUsers.FirstOrDefault(x => x.usrID == input.currentUser.usrID);
            var permissionRequest        = new Business.Permission.Permission();
            var validateAccesFunctionOut = permissionRequest.GetPermissionByRole(new MethodParameters.Permission.GetPermissionByRoleIn()
            {
                role = getUserInfoOut.usr_role
            });

            if (validateAccesFunctionOut.result == Entities.Common.Result.Success &&
                validateAccesFunctionOut.listPermissions.FirstOrDefault(x => x.pm_code == "04") != null)
            {
                var getUserOut = request.GetUser(new MethodParameters.User.GetUserIn()
                {
                    usr_userName = input.usr_userNameDestiny
                });

                if (getUserOut.result == Entities.Common.Result.Success &&
                    getUserOut.user.usr_balance >= input.valueTransfer)
                {
                    var deleteBalanceOut = request.DeleteBalance(new MethodParameters.User.DeleteBalanceIn()
                    {
                        usr_userNameDestiny = input.usr_userNameDestiny,
                        valueTransfer       = input.valueTransfer
                    });

                    if (deleteBalanceOut.result == Entities.Common.Result.Success)
                    {
                        output.result = deleteBalanceOut.result;
                        output.result = Entities.Common.Result.Success;
                    }
                }
                else if (getUserOut.result == Entities.Common.Result.Success)
                {
                    output.message = "La operación que intenta realizar supera el balance actual";
                }
            }
            else if (validateAccesFunctionOut.result == Entities.Common.Result.Success)
            {
                output.message = "Esta funcionalidad no se encuentra disponible para usuarios no Administrador";
            }

            return(output);
        }
コード例 #5
0
        public CreateUserOut Create(CreateUserIn input)
        {
            var output = new CreateUserOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.User.User();

            var getUserInfoOut = request.GetUsers(new MethodParameters.User.GetUsersIn()
            {
            }).listUsers.FirstOrDefault(x => x.usrID == input.currentUser.usrID);
            var permissionRequest        = new Business.Permission.Permission();
            var validateAccesFunctionOut = permissionRequest.GetPermissionByRole(new MethodParameters.Permission.GetPermissionByRoleIn()
            {
                role = getUserInfoOut.usr_role
            });

            if (validateAccesFunctionOut.result == Entities.Common.Result.Success &&
                validateAccesFunctionOut.listPermissions.FirstOrDefault(x => x.pm_code == "01") != null)
            {
                var password       = Common.Security.Encryption.Encrypt(input.usr_password, input.usr_userName);
                var createUsertOut = request.CreateUser(new MethodParameters.User.CreateUserIn()
                {
                    user = new Entities.Database.User()
                    {
                        usr_userName       = input.usr_userName,
                        usr_password       = password,
                        usr_fullName       = input.usr_fullName,
                        usr_documentType   = input.usr_documentType,
                        usr_numberDocument = input.usr_numberDocument,
                        usr_email          = input.usr_email,
                        usr_role           = input.usr_role
                    }
                });

                if (createUsertOut.result == Entities.Common.Result.Success)
                {
                    output.result = Entities.Common.Result.Success;
                }
            }
            else if (validateAccesFunctionOut.result == Entities.Common.Result.Success)
            {
                output.message = "Esta funcionalidad no se encuentra disponible para usuarios no Administrador";
            }

            return(output);
        }
コード例 #6
0
        public GetPermissionByCodeOut GetPermissionByCode(GetPermissionByCodeIn input)
        {
            var output = new GetPermissionByCodeOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.Permission.Permission();

            var getPermissionByCodeOut = request.GetPermissionByCode(new MethodParameters.Permission.GetPermissionByCodeIn()
            {
                pm_code = input.pm_code
            });

            if (getPermissionByCodeOut.result == Entities.Common.Result.Success)
            {
                output.permissions = getPermissionByCodeOut.permission;
                output.result      = Entities.Common.Result.Success;
            }

            return(output);
        }
コード例 #7
0
        public AddBalanceOut AddBalance(AddBalanceIn input)
        {
            var output = new AddBalanceOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.User.User();

            var getUserOut = request.GetUsers(new MethodParameters.User.GetUsersIn()
            {
            }).listUsers.FirstOrDefault(x => x.usrID == input.currentUser.usrID);
            var permissionRequest        = new Business.Permission.Permission();
            var validateAccesFunctionOut = permissionRequest.GetPermissionByRole(new MethodParameters.Permission.GetPermissionByRoleIn()
            {
                role = getUserOut.usr_role
            });

            if (validateAccesFunctionOut.result == Entities.Common.Result.Success &&
                validateAccesFunctionOut.listPermissions.FirstOrDefault(x => x.pm_code == "03") != null)
            {
                var createUsertOut = request.AddBalance(new MethodParameters.User.AddBalanceIn()
                {
                    usr_userNameDestiny = input.usr_userNameDestiny,
                    valueTransfer       = input.valueTransfer
                });

                if (createUsertOut.result == Entities.Common.Result.Success)
                {
                    output.usrID  = createUsertOut.usrID;
                    output.result = Entities.Common.Result.Success;
                }
            }
            else if (validateAccesFunctionOut.result == Entities.Common.Result.Success)
            {
                output.message = "Esta funcionalidad no se encuentra disponible para usuarios no Administrador";
            }
            return(output);
        }
コード例 #8
0
        public GetPermissionByRoleOut GetPermissionByRole(GetPermissionByRoleIn input)
        {
            var output = new GetPermissionByRoleOut()
            {
                result = Entities.Common.Result.Error
            };
            var request = new Business.Permission.Permission();

            var getPermissionByRole = request.GetPermissionByRole(new MethodParameters.Permission.GetPermissionByRoleIn()
            {
                role = input.role
            });

            if (getPermissionByRole.result == Entities.Common.Result.Success)
            {
                var listGetPermissionByRole = new List <MethodParameters.Controllers.SystemManagementApi.Permission.GetPermissionByRoleOut.PermissionByRole>();

                foreach (var item in getPermissionByRole.listPermissions)
                {
                    var role = new MethodParameters.Controllers.SystemManagementApi.Permission.GetPermissionByRoleOut.PermissionByRole()
                    {
                        rpID    = item.rpID,
                        rl_code = item.rl_code,
                        rl_name = item.rl_name,
                        pm_code = item.pm_code,
                        pm_name = item.pm_name
                    };
                    listGetPermissionByRole.Add(role);
                }

                output.listPermissions = listGetPermissionByRole;
                output.result          = Entities.Common.Result.Success;
            }

            return(output);
        }