//--------------------------------------------------------------------------------------------------
        //FUNCION QUE REGISTRA LA INFORMACION DE UN NUEVO TABLERO EN LA BASE DE DATOS
        //--------------------------------------------------------------------------------------------------
        public async Task <IActionResult> NewTablero([FromBody] RegistroTablero newtablero)
        {
            //SE VERIFICA SI LOS SIGUIENTES DATOS YA SE ENCUENTRAN REGISTRADOS DENTRO DE LA TABLA:
            if (!MatchTableroID(newtablero.tableroInfo.TableroId) &&                //TRUE: SE ENCONTRO UN REGISTRO CON EL MISMO ID DE TABLERO
                !MatchTableroID(newtablero.tableroInfo.SapId) &&                    //TRUE: SE ENCONTRO UN REGISTRO CON EL MISMO ID DE SAP
                !MatchTableroCodigoQRData(newtablero.tableroInfo.CodigoQrdata))     //TRUE: SE ENCONTRO UN REGISTRO CON EL MIDMO CodigoQRData
            {
                //SE INICIA EL CICLO TRY... CATCH
                try
                {
                    //SE INICIA LA TRANSACCION
                    using (var transaction = this._context.Database.BeginTransaction())
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE EL OBJETO "newtablero"
                        this._context.Tableros.Add(newtablero.tableroInfo);

                        //--------------------------------------------------------------------------------------------------------
                        //SE CAMBIA EL ESTADO DE LA ENTIDAD QUE ESTA RETENIDA POR EF
                        this._context.Entry(newtablero.tableroInfo).State = EntityState.Added;

                        //--------------------------------------------------------------------------------------------------------
                        //SE RECORRE LA LISTA DE ITEMS ENVIADA JUNTO CON LA INFORMACION DEL TABLERO
                        foreach (Items x in newtablero.itemsTablero)
                        {
                            //SE AÑADE EL OBJETO "Items"
                            this._context.Items.Add(x);

                            //SE CAMBIA EL ESTADO DE LA ENTIDAD QUE ESTA SIENDO RETENIDA POR EF
                            this._context.Entry(x).State = EntityState.Added;
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //CREACION E INICIALIZACION DEL OBJETO solicitudweb
                        Historialsolicitudesweb solicitudweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(newtablero.tableroInfo.Idcreador, 4);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE EL NUEVO REGISTRO A LA BASE DE DATOS
                        this._context.Historialsolicitudesweb.Add(solicitudweb);      //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudweb).State = EntityState.Added;  //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS
                        await this._context.SaveChangesAsync();

                        //SE CULMINA LA TRANSACCION
                        await transaction.CommitAsync();
                    }
                }
                //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                catch (Exception ex) when(ex is DbUpdateException ||
                                          ex is DbUpdateConcurrencyException)
                {
                    Console.WriteLine("\n=================================================");
                    Console.WriteLine("=================================================");
                    Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                    Console.WriteLine("=================================================");
                    Console.WriteLine("=================================================\n");
                    //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                    return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                }
            }
            //NO SE CUMPLIO ALGUNA DE LAS TRES CONDICIONES, SE RETORNA UN MENSAJE INFORMANDO CUAL CONDICION FALLO.
            else
            {
                //SE EVALUA CUAL DE LAS PROPIEDADES DEL OBJETO "newtablero" ENVIADO COINCIDE CON EL LA INFORMACION DE REGISTRO DE
                //ALGUN OTRO TABLERO

                //SE EVALUA SI EXISTE ALGUN TABLERO CON EL ID DEL TABLERO QUE SE DESEA REGISTRAR
                if (MatchTableroSAPID(newtablero.tableroInfo.TableroId))
                {
                    return(BadRequest("El ID del tablero que intenta registrar ya se encuentra registrado: " + newtablero.tableroInfo.TableroId));
                }

                //SE EVALUA SI EXISTE ALGUN TABLERO CON EL ID DE SAP DEL TABLERO QUE SE DESEA REGISTRAR
                if (MatchTableroSAPID(newtablero.tableroInfo.SapId))
                {
                    return(BadRequest("El ID de SAP del tablero que intenta registrar ya se encuentra registrado: " + newtablero.tableroInfo.SapId));
                }

                //SE EVALUA SI EXISTE ALGUN TABLERO QUE POSEA EL CODIGOQR (IMAGEN) QUE SE DESEA REGISTRAR
                if (MatchTableroCodigoQRData(newtablero.tableroInfo.CodigoQrdata))
                {
                    return(BadRequest("El codigo QR del tablero que intenta registrar ya se encuentra asignado a otro tablero"));
                }
            }

            //SI TODAS LAS CONDICIONES SE CUMPLEN SE REGISTRA EL TABLERO, SE RETORNA EL CODIGO DE ESTATUS 200
            //OK Y SE INFORMA MEDIANTE UN MENSAJE QUE SE REGISTRO CON EXITO EL TABLERO.
            return(Ok("Registro exitoso"));
        }
        //--------------------------------------------------------------------------------------------------
        //FUNCION QUE ACTUALIZARA LA INFORMACION DE UN USUARIO CUANDO SE REALICE EL LLAMADO DESDE
        //LA PAGINA "PaginaConsultaTableros" DE LA APLICACION "Mtto App". EN ESTA FUNCION SE RECIBEN
        //LOS PARAMETROS:
        // -info => OBJETO DEL TIPO "RequestConsultaTablero" ENVIADO EN EL BODY DE LA SOLICITUD HTTP
        // JUNTO CON LA INFORMACION NECESARIA PARA PROCESAR LA CONSULTA DE TABLEROS.
        //--------------------------------------------------------------------------------------------------
        public async Task <ActionResult <RegistroTablero> > ConsultaTableroId([FromBody] RequestConsultaTablero info)
        {
            //SE CREA E INICIALIZA EL OBJETO DEL TIPO "RegistroTablero" QUE CONTENDRA Y RETORNARA
            //TODA LA INFORMACION DEL TABLERO CONSULTADO.
            RegistroTablero tablero = null;

            //SE EVALUA SI EXISTE ALGUN TABLERO DENTRO DE LA BASE DE DATOS QUE POSEEA EL ID ENVIADO COMO PARAMETRO
            if (this._context.Tableros.Any
                    (x => x.TableroId.ToLower() == info.TableroId.ToLower())) //=> true => EXISTE UN REGISTRO DENTRO DE LA CLASE TABLERO CON DICHO DATO
            {
                //SE INICIA LA TRANSACCIONES CON LA BASE DE DATOS
                using (var transaction = this._context.Database.BeginTransaction())
                {
                    //SE INICIA EL CICLO TRY... CATCH
                    try
                    {
                        //--------------------------------------------------------------------------------------------------------
                        //CON LA INFORMACION ENVIADA SE PROCEDE A BUSCAR LA INFORMACION DE USUARIO DENTRO DE LA BASE DE DATOS
                        //SE CREA EL OBJETO "tableroinfo", Y SE INICIALIZA CON EL METODO DE BUSQUEDA PROPIO DEL OBJETO "Context"
                        //DECRITO AL INICIO DE LA CLASE.
                        Tableros tableroinfo = await this._context.Tableros.FirstAsync
                                                   (x => x.TableroId.ToLower() == info.TableroId.ToLower()); //=> METODO QUE INSPECCIONA TODOS LOS REGISTROS DE

                        //LA TABLA "Tableros" Y COMPARA EL ID DE CADA REGISTRO
                        //CON EL ID DEL OBJETO ENVIADO COMO PARAMETRO DE FUNCION

                        //--------------------------------------------------------------------------------------------------------
                        //SE EVALUA QUE EL OBJETO NO SEA NULO
                        if (tableroinfo != null)
                        {
                            //SI ES DIFERENTE DE NULO DESECHAMOS LA ENTIDAD RETENIDA POR EF (ENTITYFRAMEWORK)
                            this._context.Entry(tableroinfo).State = EntityState.Detached;
                        }

                        //--------------------------------------------------------------------------------------------------------
                        //CREAMOS E INICIALIZAMOS UNA LISTA DE OBJETOS "Items" CON LOS ITEMS QUE POSEE DICHO TABLERO
                        List <Items> itemstablero =
                            await this._context.Items.Where(x => x.TableroId.ToLower() == info.TableroId.ToLower()).ToListAsync();

                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialConsultaTableros" QUE SERVIRA PARA CONTENER
                        //LA INFORMACION DEL NUEVO REGISTRO DENTRO DE LA TABLA "Modificacionesusuario"
                        Historialconsultatableros newregistro =
                            Historialconsultatableros.NewHistorialConsultaTableros(tableroinfo.TableroId, "CONSULTA_POR_TABLERO_ID", info.UserId);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE A LA TABLAS "HistorialConsultaTableros" EL NUEVO REGISTRO
                        this._context.Historialconsultatableros.Add(newregistro);   //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialConsultaTableros.
                        this._context.Entry(newregistro).State = EntityState.Added; //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //SE CREA E INICIALIZA UN OBJETO DEL TIPO "HistorialSolicitudesWeb" CON LA INFORMACION DEL NUEVO REGISTRO
                        //DE LA TABLA "HistorialSolicitudesWeb".
                        Historialsolicitudesweb solicitudweb =
                            Historialsolicitudesweb.NewHistorialSolocitudesWeb(info.UserId, 2);

                        //--------------------------------------------------------------------------------------------------------
                        //SE AÑADE A LA TABLA "HistorialSolicitudesWeb" EL NUEVO REGISTRO
                        this._context.Historialsolicitudesweb.Add(solicitudweb);     //=> SE CREA LA INFORMACION DE UN NUEVO REGISTRO EN LA TABLA HistorialSolicitudesWeb.
                        this._context.Entry(solicitudweb).State = EntityState.Added; //=> SE CAMBIA EL ESTADO DEL OBJETO CREADO COMO REFERENCIA.

                        //--------------------------------------------------------------------------------------------------------
                        //INICIALIZAMOS EL OBJETO "RegistroTablero" (CREADO AL INICIO DE LA FUNCION) CON TODA LA
                        //INFORMACION DEL TABLERO SOLICITADO
                        tablero = RegistroTablero.NewRegistroTablero(tableroinfo, itemstablero);

                        //--------------------------------------------------------------------------------------------------------
                        //SE GUARDAN LOS CAMBIOS REALIZADOS SOBRE LA BASE DE DATOS
                        await this._context.SaveChangesAsync();

                        //SE CULMINA LA TRANSACCION CON LA BASE DE DATOS
                        await transaction.CommitAsync();
                    }
                    //SI OCURRE ALGUNA EXCEPCION EN EL PROCESO DE LECTURA Y ESCRITURA DE LA BASE DE DATOS EL CODIGO
                    //SE REDIRIGE A LA SECCION CATCH DEL CICLO TRY...CATCH
                    catch (Exception ex) when(ex is DbUpdateException ||
                                              ex is DbUpdateConcurrencyException)
                    {
                        Console.WriteLine("\nHa ocurrico un error:\n" + ex.Message.ToString());
                        //SE RETONA LA RESPUESTA "BadRequest" JUNTO CON UN MENSAJE INFORMANDO SOBRE EL ERROR
                        return(BadRequest("\nHa ocurrico un error, intentelo nuevamente"));
                    }
                }
            }
            //NO SE CONSIGUIO NINGUN REGISTRO QUE POSEEA EL ID ENVIADO COMO PARAMETRO
            else
            {
                //SE RETORNA EL CODIGO 404 NOT FOUND (NO ENCONTRADO)
                return(NotFound("No se encontro registro de tableros con el siguiente Id: " + info.TableroId));
            }

            //SE RETORNA EL CODIGO 200 OK JUNTO CON TODA LA INFORMACION DEL TABELRO SOLICITADO
            return(Ok(tablero));
        }