# dbr.auths **dbr.auths.dkl** Funciones para la implementación de flujos de autorización de operaciones entre usuarios. ### type.register Inserta o actualiza los datos en la tabla `sys_auth_tpy`. Si el ID que proviene del objeto `data` ya existe en la base de datos, la función realizará una actualización. En caso contrario se insertará un nuevo registro. Además, si un tipo de autorización se encuentra eliminado lógicamente al momento de actualizar el tipo de autorización, se quitará la eliminación. ``` dbr.auths.type.register::&db,&data ``` #### Parámetros * `db` - Referencia a una conexión de bases de datos. * `data` - El objeto contiene los datos que serán insertados o actualizados en la tabla. #### Valor de retorno: Objeto con todos los datos insertados o actualizados. #### Excepciones - Excepciones de bases de datos. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") new data { @"id": "create_auth" @"usergroup": 1 // sys_pk del grupo de usuarios(usergroup) @"min_users": 3 // cantidad de usuarios que podrán autorizar, si se omite será 1 @"view": "Código dkl de cómo se visualizará las autorizaciones que tendrá dicho tipo de autorización" } ref nuevo_grupo = type.register(db,data) } ``` ### type.unregister Elimina un tipo de autorización especificado en typeid, dicha función intentará eliminar el tipo de autorización físicamente. Si la eliminación no se realiza correctamente, se realizará una eliminación lógica. ``` dbr.auths.type.unregister::&db,typeid ``` #### Parámetros * `db` - Referencia a una conexión de bases de datos. * `typeid` - Identificador único del tipo de autorización que deseas eliminar. #### Valor de retorno Ninguno (0). #### Excepciones - Excepciones de bases de datos. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") do type.unregister(db,"create_auth") } ``` ### post Crea una nueva transacción de autorización si no existe una pendiente que coincida con los parámetros indicados (typeid, id, operation). Además, lanza la autorización según la configuración del tipo de autorización en el campo "min_users". Si el valor es 1, la función intentará autorizarlo. ``` dbr.auths.post::&db,typeid,id,operation,&http_context,&data ``` #### Parámetros * `db` - Referencia a una conexión de bases de datos. * `typeid` - Es el identificador único del tipo de autorización que deseas verificar. * `id` - Identificador con el cual se identificará una transacción (autorización). * `operation` - Operación con la cual se identifica lo que hará la transacción (create, update, etc.). * `http_context` - Objeto completo proporcionado por el intérprete Devkron. * `data` - Objeto con los campos adicionales de la tabla `sys_auth_log`. #### Valor de retorno Objeto con los siguientes datos new response { @"authorized": true/false // true si logra ser autorizado. @"error": Último error ocurrido durante la creación de la transacción y su lanzamiento. @"request": Objeto con los datos de la nueva transacción. } #### Excepciones - Excepciones de bases de datos. - Ya hay un proceso pendiente con los datos indicados. - No hay datos de tipo de autorización indicado. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") new data { @"note":"Esta transacción es de prueba" } new @http_context { //datos necesarios por default esta variable existe desde un entorno web } ref crear_autorizacion = post(db,"create_auth","factura_0001","create",@http_context,data) } ``` ### pending Verifica si hay algún proceso pendiente de autorización de acuerdo a los siguientes parámetros typeid, id y operation. ``` dbr.auths.pending::&db,typeid,id,operation ``` #### Parámetros * `db` - Referencia a una conexión de bases de datos. * `typeid` - Es el identificador único del tipo de autorización que deseas verificar. * `id` - identificador con la cual se identificará una transacción(autorización). * `operation` - Operación con la cual se identificará de lo qué hará la transacción(create,update...). #### Valor de retorno Objeto con todos los datos de la transacción pendiente, de acuerdo a los parámetros indicados, devuelve null si no encuentra datos. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") ref autorizacion_pendiente = pending(db,"create_auth","factura_0001","create") } ``` ### auth Realiza la autorización de la transacción pendiente según el parámetro UUID. Ejecuta el programa(runscript) ubicado en `request/headers/path_translated` del objeto `@http_context` indicado en la función post. si en el tipo de autorización está marcado como auto-login, la función tratará de iniciar sesión con el usuario quien solicitó la autorización. ``` Ejemplo de ejecución del programa ref http_obj=@http_context // @http_context -> objeto indicado en la función post. script=@@(http_obj,"$request/headers/path_translated") res=runscript(script,"http_context",http_obj) ``` ``` dbr.auths.auth::&db,uuid,notas ``` #### Parámetros * `db` - Referencia a una conexión de bases de datos. * `uuid` - Identificador único(sys_guid) de la tabla sys_auth_log. * `notas` - Nota. #### Valor de retorno Objeto con los siguientes campos new response { @"authorized": "true/false" //true si la autorización se realizó correctamente. @"pending": 1 // Muestra la cantidad de usuarios faltantes por autorizar. @"error" //error ocurrido durante el proceso, este campo viene solo si ocurrió algún error. } #### Excepciones - El usuario no pertenece al grupo indicado en la tabla `sys_auth_tpy` // esto sucede cuando el usuario que está autorizando no pertenece al grupo de usuario configurado en el tipo de autorización. - No hay transacción pendientes en relación a la UUID indicado. - Se alcanzó el máximo de usuarios para la autorización. - El usuario ya ha autorizado la solicitud, intente con otro usuario. - Solo pueden autorizar los usuarios que pertenecen al grupo de usuario configurado en el `Tipo de autorización`. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") ref autorizacion = auth(db,"40d36a089de54c4ea4baf182088db9a7","Transacción por autorizar") } ``` ### deny Marca como rechazada la transacción pendiente especificada en el campo UUID. ``` dbr.auths.deny::&db,uuid,notas ``` #### Parámetros * `db` - Excepciones de bases de datos. * `uuid` - Identificador único(sys_guid) de la tabla sys_auth_log. * `notas` - Nota. #### Valor de retorno Ninguno (0) #### Excepciones - No hay transacción pendientes en relación a la UUID indicado. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") do deny(db,"40d36a089de54c4ea4baf182088db9a7","Transacción rechazado") } ``` ### cancel Marca como cancelada la transacción pendiente especificada en el campo UUID. ``` dbr.auths.cancel::&db,uuid,notas ``` #### Parámetros * `db` - Excepciones de bases de datos. * `uuid` - Identificador único(sys_guid) de la tabla sys_auth_log. * `notas` - Nota. #### Valor de retorno Ninguno (0). #### Excepciones - No hay transacción pendientes en relación a la UUID indicado. #### Ejemplo ``` #include "dkli.dkh" #! program { #include "functions.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") do cancel(db,"40d36a089de54c4ea4baf182088db9a7","Transacción cancelado") } ``` ### Ejemplo de autorización Cuando un usuario completa un formulario para registrar un empleado y hace clic en el botón "Guardar", los datos se envían al servidor para su posterior almacenamiento en la base de datos. Sin embargo, para crear un empleado, es necesario que un administrador autorice la operación. Por lo tanto, implementaremos un proceso de solicitud de autorización desde el modelo de la entidad "Empleado". Aquí está el esquema general: 1. El usuario completa el formulario de registro con los datos del empleado. 2. Al hacer clic en "Guardar", se inicia una solicitud al servidor. 3. En el modelo de la entidad "Empleado", se genera una solicitud de autorización para crear el nuevo empleado 5. Si la solicitud es aprobada por los usuarios correspondientes, se completa la creación del empleado y se almacenan los datos en la base de datos. Este proceso garantiza que solo los empleados autorizados puedan ser registrados en el sistema. ``` #include "dkli.dkh" #! module "Empleado" { #include "functions.dkh" #include "serialize.dkh" #include "dbr.dkh" #include "dbr.auths.dkl" namespace "dbr.auths" ref db = dbr.open("mydb@myappgroup") //crear tipo de autorización new data { @"id":"create_empleado" @"usergroup": 1 @"min_users": 3 } ref nuevo_grupo = type.register(db,data) create_empleado::&db,¶ms,&data { //Aqui solicitamos la autorización para crear el empleado new data { @"note": "Solicito autorización para crear un nuevo empleado" } // Solicitar autorización para crear un nuevo empleado ref crear_autorizacion = post(db,"create_empleado","empleado_00001","create",http_context,data) if not(@@(crear_autorizacion,"#authorized")) { do rise_error(500,"Esta operación está sujeta de autorización") } // El proceso se autorizará completamente cuando se alcance la cantidad de usuarios definidos en min_users // Cuando se complete la autorización, el empleado aparecerá automáticamente en la lista de empleados. return entity.create(db,params,data) } } ```