Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Posts y likes

17/29
Recursos

Aportes 17

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Reto resuelto:

Si quieren que en la query JOIN devuleva todos los Post de un user tiene que quitarle el [0] al ultimo resolve d ela sentecia. Quedaria asi.

function query(table, query, join){
    let joinQuery = '';
    if(join){
        const key = Object.keys(join)[0];
        const val = join[key];
        joinQuery =`JOIN ${key} ON ${table}.${val} = ${key}.id`;
        // Object.entries(join).forEach(([key, value]) => {
        //     const[from, to] = value;
        //     joinQuery+= `JOIN ${key} ON ${table}.${from} = ${key}.${to}`;
        // })
    }
    // debug(`${table}, ${JSON.stringify(query)}, ${joinQuery}`);
    return new Promise((resolve, reject) => {
        connection.query(`SELECT * FROM ${table} ${joinQuery}  WHERE  ${table}.?`, query, (err, res) =>{
            if(err) return reject(err)
           //AQUI+++++
           //resolve(res[0] || null);
            resolve(res || null);
        })
    })
}

Les comparto la función query, donde acepta varios parámetros para el join

function query(table, query, join = null) {
    let joinQuery = '';
    if (join) {
        Object.entries(join).forEach(([key, value]) => {
            const [from, to] = value;
            joinQuery+= `JOIN ${key} ON ${table}.${from} = ${key}.${to}`;
        })
    }
    debug(`${table}, ${JSON.stringify(query)}, ${joinQuery}`);
    return new Promise((resolve, reject) => {
        connection.query(`SELECT * FROM ${table} ${joinQuery} WHERE ?`, query,  (error, data) => {
            if (error) return reject(error);
            resolve(data);
        })
    });
}```

si quieres traer una lista en lugar de un solo registro de las personas siguiendo. cambia

resolve(res[0] || null)
por
resolve(res || null);

aqui te devuelve una lista pero afecta al servicio de login por eso les recomiendo una condicion con el join para la respuesta

if (join) {
resolve(res || null)
} else {
resolve(res[0] || null)
}

como seria el codigo, para traerme todos los seguidore.? actualmente el codigo solo trae un seguidor.!

me imagino que se usa un forEach pero no se como va la cosa.!

Si quieren que en la consulta query les devuelva todos los post, like que dependen de una JOIN le tienen que quitar en el ultimo resolve en [0] de la funcion query. quedaria asi.

function query(table, query, join){
    let joinQuery = '';
    if(join){
        const key = Object.keys(join)[0];
        const val = join[key];
        joinQuery =`JOIN ${key} ON ${table}.${val} = ${key}.id`;
        // Object.entries(join).forEach(([key, value]) => {
        //     const[from, to] = value;
        //     joinQuery+= `JOIN ${key} ON ${table}.${from} = ${key}.${to}`;
        // })
    }
    // debug(`${table}, ${JSON.stringify(query)}, ${joinQuery}`);
    return new Promise((resolve, reject) => {
        connection.query(`SELECT * FROM ${table} ${joinQuery}  WHERE  ${table}.?`, query, (err, res) =>{
            if(err) return reject(err)
            resolve(res || null);
        })
    })
}

Buena solución al reto! En base a eso, modifiqué el método que elimina para hacer un endpoint que hace unfollow. Acá mi solución:
.
Método remove de mysql.js:

function remove(table, firstCondition, othersCondition = []) {
  let andConditions = "";
  if (othersCondition.length > 0) {
    andConditions = othersCondition.map(c => "AND ?").join(" ");
  }

  return new Promise((resolve, reject) => {
    connection.query(
      `DELETE FROM ${table} WHERE ? ${andConditions}`,
      [firstCondition, ...othersCondition],
      (err, data) => {
        if (err) return reject(err);
        return resolve(data);
      }
    );
  });
}

.
Método unfollow de userController:

  const unfollow = (from, to) => {
    return store.remove("follows", { user_from: from }, [{ user_to: to }]);
  };

.
El userNetwork ya se lo conocen 😃

Vamos bien!!!

Hola saben por que no puedo colocar el caracter de pregunta en la sentencias, estoy usando MSSQL :

Me sale el siguiente error:

e:21740) UnhandledPromiseRejectionWarning: RequestError: Incorrect syntax near '?'.
    at handleError (C:\trabajo\GOCHO\OneDrive - GRUPO OSPEDALE\Documentos\GOCHO\PROYECTOS\KERBERUS\API_IVR_TRANSACCIONAL\node_modules\mssql\lib\tedious\request.js:374:15)     
    at Connection.emit (events.js:375:28)

y el metodo es tal cual el del profesor :

function query(table, query, join) {
    let joinQuery = '';
    if (join) {
        const key = Object.keys(join)[0];
        const val = join[key];
        joinQuery = `JOIN ${key} ON ${table}.${val} = ${key}.id`;
    }

    return new Promise((resolve, reject) => {
        connection.query(`SELECT * FROM ${table} ${joinQuery} WHERE ${table}.?`, query, (err, res) => {
            if (err) return reject(err);
            resolve(res[0] || null);
        })
    })
}

Solo como mejora, sería ideal poner la llave foránea user como user_id para que al implementar relaciones por medio de algún ORM se pueda diferenciar que user_id es el ID y user es el objeto user a través de una relación.

Controller quedó así

async function following({id}) {
        const join = {
            [TABLA]: ['user_to_id', 'id'],
        };

        return store.query(`${TABLA}_follow`, {user_from_id: id}, join);
    }```

Acá dejo todo mi reto, tuve que modificar mi método get para que obtenga arreglos de condiciones.
https://github.com/behagoras/platzi-practico-node/tree/posts-likes

Hola, tengo una duda, como seria la mejor manera de comunicar componentes? , por ejemplo si requiero de una funcionalidad de otro componente importo el controlador de este? , o hay alguna otra forma ?

Excelente clase

Super 😃

Me podrian ayudar por favor con este error

{
    "error": false,
    "status": 500,
    "body": "Cannot enqueue Query after fatal error."
}

En la consola me sale esto

code: 'PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR',
  fatal: false
}

No me gusta que las tablas no estén relacionadas