feat: buscar por responsibleFk sin afectar a la consulta principal

modules/claim/back/methods/claim/filter.js

@@ -93,33 +93,34 @@ module.exports = Self => {
 
     Self.filter = async(ctx, filter, options) => {
         const conn = Self.dataSource.connector;
+        const args = ctx.args;
         const myOptions = {};
         let to;
 
         if (typeof options == 'object')
             Object.assign(myOptions, options);
 
-        const where = buildFilter(ctx.args, (param, value) => {
+        const where = buildFilter(args, (param, value) => {
             switch (param) {
             case 'search':
                 return /^\d+$/.test(value)
                     ? {'cl.id': value}
                     : {
                         or: [
-                            {'cl.clientName': {like: `%${value}%`}}
+                            {'c.name': {like: `%${value}%`}}
                         ]
                     };
             case 'clientName':
-                return {'cl.clientName': {like: `%${value}%`}};
+                return {'c.name': {like: `%${value}%`}};
             case 'clientFk':
             case 'id':
             case 'claimStateFk':
-            case 'itemFk':
-            case 'claimResponsibleFk':
             case 'priority':
                 return {[`cl.${param}`]: value};
+            case 'itemFk':
+                return {[`s.${param}`]: value};
             case 'salesPersonFk':
-                return {'cl.salesPersonFk': value};
+                return {'c.salesPersonFk': value};
             case 'attenderFk':
                 return {'cl.workerFk': value};
             case 'created':
@@ -131,14 +132,12 @@ module.exports = Self => {
             }
         });
 
-        filter = mergeFilters(ctx.args.filter, {where});
+        filter = mergeFilters(args.filter, {where});
 
         const stmts = [];
 
         const stmt = new ParameterizedSQL(
-            `SELECT *
+            `SELECT
-                FROM (
-                    SELECT DISTINCT
                     cl.id,
                     cl.clientFk,
                     c.name AS clientName,
@@ -149,18 +148,34 @@ module.exports = Self => {
                     cs.priority,
                     cl.claimStateFk,
                     c.salesPersonFk,
-                        s.itemFk,
+                    s.itemFk
-                        cd.claimResponsibleFk
                 FROM claim cl
                     LEFT JOIN client c ON c.id = cl.clientFk
                     LEFT JOIN worker w ON w.id = cl.workerFk
                     LEFT JOIN account.user u ON u.id = w.userFk
                     LEFT JOIN claimState cs ON cs.id = cl.claimStateFk
                     LEFT JOIN claimBeginning cb ON cb.claimFk = cl.id
-                        LEFT JOIN sale s ON s.id = cb.saleFk
+                    LEFT JOIN sale s ON s.id = cb.saleFk`
-                        LEFT JOIN claimDevelopment cd ON cd.claimFk = cl.id ) cl`
         );
 
+        if (args.claimResponsibleFk) {
+            query = `SELECT cd.claimFk
+                    FROM claimDevelopment cd
+                    WHERE cd.claimResponsibleFk = ?`;
+            const claimDevelopments = await Self.rawSql(query, [args.claimResponsibleFk], myOptions);
+
+            const claimIds = claimDevelopments.map(claimDevelopment => {
+                return claimDevelopment.claimFk;
+            });
+
+            stmt.merge({
+                sql: `LEFT JOIN claimDevelopment cd ON cd.claimFk = cl.id
+                    WHERE cl.id IN (?)
+                    GROUP BY cl.id`,
+                params: [claimIds],
+            });
+        }
+
         stmt.merge(conn.makeSuffix(filter));
         const itemsIndex = stmts.push(stmt) - 1;