Aug 20 [UPDT] Updated 'inventory_advanced_reports'

inventory_advanced_reports/README.rst

@@ -2,19 +2,14 @@
     :target: https://www.gnu.org/licenses/lgpl-3.0-standalone.html
     :alt: License: LGPL-3
 
-Advanced Inventory Reports
+Inventory Advanced Reports
 ==========================
-Helps to Manage different types of Inventory Reports like FSN Report, Out Of Stock Report, etc.
+* This module provides inventory reports to help you manage your inventory properly.
 
 Configuration
 =============
 - Additional configuration not required
 
-Installation
-============
-- www.odoo.com/documentation/16.0/setup/install.html
-- Install our custom addon
-
 License
 -------
 Lesser General Public License, Version 3 (LGPL v3).

inventory_advanced_reports/__manifest__.py

@@ -20,11 +20,18 @@
 #
 ###############################################################################
 {
-    "name": "Advanced Inventory Reports",
-    "version": "16.0.1.0.0",
+    "name": "Inventory Advanced Reports",
+    "version": "16.0.1.0.1",
     "category": 'Warehouse',
-    "summary": "Helps to Manage different types of Inventory Reports like FSN Report, Out Of Stock Report, Inventory XYZ Report, etc.",
-    "description": "Helps to Manage different types of Inventory Reports like FSN Report, Out Of Stock Report, Inventory XYZ Report, etc",
+    "summary": "Inventory reports to help you to manage your inventory "
+               "properly",
+    "description": "This module allows you to generate inventory reports,users "
+                   "can track Aging analysis, FSN classification (inventory "
+                   "movement frequency classification), XYZ classification "
+                   "(inventory classification based on stock value), FSN-XYZ "
+                   "combined classification to define sales strategies for the "
+                   "existing inventories. Overstock analysis, Out of Stock "
+                   "analysis and Stock movements (inventory rotation).",
     "author": "Cybrosys Techno Solutions",
     'company': 'Cybrosys Techno Solutions',
     'maintainer': 'Cybrosys Techno Solutions',

inventory_advanced_reports/doc/RELEASE_NOTES.md

@@ -4,4 +4,10 @@
 #### Version 16.0.1.0.0
 ##### ADD
 
-- Initial Commit for Advanced Inventory Reports
+- Initial Commit for Inventory Advanced Reports
+
+#### 19.08.2024
+#### Version 16.0.1.0.1
+##### UPDT
+
+- Fixed the issue in filtering of warehouses of same company

inventory_advanced_reports/report/fsn_report.py

@@ -44,8 +44,7 @@ class FsnReport(models.AbstractModel):
         end_date = data.get('end_date')
         fsn = data.get('fsn')
         if not start_date or not end_date:
-            raise ValueError(
-                "Missing start_date or end_date in the data")
+            raise ValueError("Missing start_date or end_date in the data")
         start_date = datetime.strptime(start_date, '%Y-%m-%d')
         end_date = datetime.strptime(end_date, '%Y-%m-%d')
         filtered_product_stock = []
@@ -99,26 +98,26 @@ class FsnReport(models.AbstractModel):
                     END AS product_code_and_name, 
                     pc.complete_name AS category_name,
                     company.id AS company_id,
-                    sw.id AS warehouse_id,
-                    (SUM(CASE WHEN sm.date <= %s AND sld_dest.usage = 'internal' 
+                    COALESCE(sw_dest.id, sw_src.id) AS warehouse_id,
+                    (SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END)) AS opening_stock,
-                    (SUM(CASE WHEN sm.date <= %s AND sld_dest.usage = 'internal' 
+                    (SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END)) AS closing_stock,
                     SUM(CASE WHEN sm.date BETWEEN %s AND %s 
-                    AND sld_dest.usage = 'customer' 
+                    AND sl_dest.usage = 'customer' 
                     THEN sm.product_uom_qty ELSE 0 END) AS sales,
                     ((SUM(CASE WHEN sm.date <= %s 
-                    AND sld_dest.usage = 'internal' 
+                    AND sl_dest.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END))+
-                    (SUM(CASE WHEN sm.date <= %s AND sld_dest.usage = 'internal' 
+                    (SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' 
                     THEN sm.product_uom_qty ELSE 0 END)))/2 AS average_stock
                 FROM
                     stock_move sm
@@ -131,11 +130,13 @@ class FsnReport(models.AbstractModel):
                 JOIN
                     res_company company ON company.id = sm.company_id
                 JOIN
-                    stock_warehouse sw ON sw.company_id = company.id
+                    stock_location sl_dest ON sm.location_dest_id = sl_dest.id
+                JOIN
+                    stock_location sl_src ON sm.location_id = sl_src.id
                 LEFT JOIN
-                    stock_location sld_dest ON sm.location_dest_id = sld_dest.id
+                    stock_warehouse sw_dest ON sl_dest.warehouse_id = sw_dest.id
                 LEFT JOIN
-                    stock_location sld_src ON sm.location_id = sld_src.id
+                    stock_warehouse sw_src ON sl_src.warehouse_id = sw_src.id
                 WHERE
                     sm.state = 'done'
                         """
@@ -143,46 +144,36 @@ class FsnReport(models.AbstractModel):
             start_date, start_date, end_date, end_date, start_date, end_date,
             start_date, start_date, end_date, end_date
         ]
-        sub_queries = []
-        sub_params = []
-        param_count = 0
         if product_ids or category_ids:
             query += " AND ("
         if product_ids:
-            product_ids = [product_id for product_id in product_ids]
             query += "pp.id = ANY(%s)"
             params.append(product_ids)
-            param_count += 1
         if product_ids and category_ids:
             query += " OR "
         if category_ids:
-            category_ids = [category_id for category_id in category_ids]
             query += "pt.categ_id IN %s"
             params.append(tuple(category_ids))
-            param_count += 1
         if product_ids or category_ids:
             query += ")"
         if company_ids:
-            query += f" AND company.id IN %s"
-            sub_params.append(tuple(company_ids))
-            param_count += 1
+            query += " AND company.id IN %s"
+            params.append(tuple(company_ids))
         if warehouse_ids:
-            query += f" AND sw.id IN %s"
-            sub_params.append(tuple(warehouse_ids))
-            param_count += 1
-        if sub_queries:
-            query += " AND " + " AND ".join(sub_queries)
+            query += " AND (COALESCE(sw_dest.id, sw_src.id) IN %s)"
+            params.append(tuple(warehouse_ids))
         query += """
-                            GROUP BY pp.id, pt.categ_id,CASE
-                        WHEN pp.default_code IS NOT NULL 
-                            THEN CONCAT(pp.default_code, ' - ', 
-                            pt.name->>'en_US')
-                        ELSE
-                            pt.name->>'en_US'
-                    END, pc.complete_name, company.id, sw.id
-                        ) AS subquery
-                        """
-        self.env.cr.execute(query, tuple(params + sub_params))
+                GROUP BY pp.id, pt.categ_id,
+                CASE
+                    WHEN pp.default_code IS NOT NULL 
+                        THEN CONCAT(pp.default_code, ' - ', 
+                        pt.name->>'en_US')
+                    ELSE
+                        pt.name->>'en_US'
+                END, pc.complete_name, company.id, COALESCE(sw_dest.id, sw_src.id)
+                ) AS subquery
+                """
+        self.env.cr.execute(query, tuple(params))
         result_data = self.env.cr.dictfetchall()
         for fsn_data in result_data:
             if fsn_data.get('fsn_classification') == str(fsn):

inventory_advanced_reports/report/fsn_xyz_report.py

@@ -49,192 +49,163 @@ class FsnXyzReport(models.AbstractModel):
         end_date = fields.datetime.strptime(end_date, '%Y-%m-%d')
         filtered_product_stock = []
         query = """
-                    SELECT
-                        product_id,
-        product_code_and_name,
-        category_id,
-        category_name,
-        company_id,
-        warehouse_id,
-        opening_stock,
-        closing_stock,
-        sales,
-        average_stock,
-        current_stock,
-        stock_value,
-        stock_percentage,
+            SELECT
+                product_id,
+                product_code_and_name,
+                category_id,
+                category_name,
+                company_id,
+                warehouse_id,
+                opening_stock,
+                closing_stock,
+                sales,
+                average_stock,
+                current_stock,
+                stock_value,
+                stock_percentage,
+                CASE
+                    WHEN sales > 0 
+                    THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
+                    ELSE 0
+                END AS turnover_ratio,
+                CASE
+                    WHEN
                         CASE
                             WHEN sales > 0 
                             THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
                             ELSE 0
-                        END AS turnover_ratio,
+                        END > 3 THEN 'Fast Moving'
+                    WHEN
                         CASE
-                            WHEN
-                                CASE
-                                    WHEN sales > 0 
-                                    THEN 
-                                    ROUND((sales / NULLIF(average_stock, 0)), 2)
-                                    ELSE 0
-                                END > 3 THEN 'Fast Moving'
-                            WHEN
-                                CASE
-                                    WHEN sales > 0 
-                                    THEN 
-                                    ROUND((sales / NULLIF(average_stock, 0)), 2)
-                                    ELSE 0
-                                END >= 1 AND
-                                CASE
-                                    WHEN sales > 0 
-                                    THEN 
-                                    ROUND((sales / NULLIF(average_stock, 0)), 2)
-                                    ELSE 0
-                                END <= 3 THEN 'Slow Moving'
-                            ELSE 'Non Moving'
-                        END AS fsn_classification,
-                        SUM(stock_percentage) OVER (ORDER BY stock_value DESC) 
-                        AS cumulative_stock_percentage,
+                            WHEN sales > 0 
+                            THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
+                            ELSE 0
+                        END >= 1 AND
                         CASE
-            WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) < 70 
-            THEN 'X'
-            WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) >= 70 
-            AND SUM(stock_percentage) OVER (ORDER BY stock_value DESC) <= 90 
-            THEN 'Y'
-            ELSE 'Z'
-        END AS xyz_classification,
-        CONCAT(
-            CASE
-                WHEN
-                    CASE
-                        WHEN sales > 0 
-                        THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
-                        ELSE 0
-                    END > 3 THEN 'F'
-                WHEN
+                            WHEN sales > 0 
+                            THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
+                            ELSE 0
+                        END <= 3 THEN 'Slow Moving'
+                    ELSE 'Non Moving'
+                END AS fsn_classification,
+                SUM(stock_percentage) OVER (ORDER BY stock_value DESC) AS cumulative_stock_percentage,
+                CASE
+                    WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) < 70 THEN 'X'
+                    WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) >= 70 
+                        AND SUM(stock_percentage) OVER (ORDER BY stock_value DESC) <= 90 THEN 'Y'
+                    ELSE 'Z'
+                END AS xyz_classification,
+                CONCAT(
                     CASE
-                        WHEN sales > 0 
-                        THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
-                        ELSE 0
-                    END >= 1 AND
+                        WHEN
+                            CASE
+                                WHEN sales > 0 
+                                THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
+                                ELSE 0
+                            END > 3 THEN 'F'
+                        WHEN
+                            CASE
+                                WHEN sales > 0 
+                                THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
+                                ELSE 0
+                            END >= 1 AND
+                            CASE
+                                WHEN sales > 0 
+                                THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
+                                ELSE 0
+                            END <= 3 THEN 'S'
+                        ELSE 'N'
+                    END,
                     CASE
-                        WHEN sales > 0 
-                        THEN ROUND((sales / NULLIF(average_stock, 0)), 2)
-                        ELSE 0
-                    END <= 3 THEN 'S'
-                ELSE 'N'
-            END,
-            CASE
-                WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) < 70 
-                THEN 'X'
-                WHEN SUM(stock_percentage) 
-                OVER (ORDER BY stock_value DESC) >= 70 AND SUM(stock_percentage) 
-                OVER (ORDER BY stock_value DESC) <= 90 THEN 'Y'
-                ELSE 'Z'
-            END
-        ) AS combined_classification
+                        WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) < 70 THEN 'X'
+                        WHEN SUM(stock_percentage) OVER (ORDER BY stock_value DESC) >= 70 
+                            AND SUM(stock_percentage) OVER (ORDER BY stock_value DESC) <= 90 THEN 'Y'
+                        ELSE 'Z'
+                    END
+                ) AS combined_classification
             FROM
                 (SELECT
                     pp.id AS product_id,
                     pt.categ_id AS category_id,
                     CASE
                         WHEN pp.default_code IS NOT NULL 
-                            THEN CONCAT(pp.default_code, ' - ', 
-                            pt.name->>'en_US')
+                            THEN CONCAT(pp.default_code, ' - ', pt.name->>'en_US')
                         ELSE
                             pt.name->>'en_US'
                     END AS product_code_and_name, 
                     pc.complete_name AS category_name,
                     company.id AS company_id,
-                    sw.id AS warehouse_id,
+                    COALESCE(sw_dest.id, sw_src.id) AS warehouse_id,
                     SUM(svl.remaining_qty) AS current_stock,
                     SUM(svl.remaining_value) AS stock_value,
-                    COALESCE(ROUND((SUM(svl.remaining_value) / 
-                    NULLIF(SUM(SUM(svl.remaining_value)) 
-                    OVER (), 0)) * 100, 2),0) AS stock_percentage,
-                    (SUM(CASE WHEN sm.date <= %s AND sld_dest.usage = 'internal'
-                     THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
-                    THEN sm.product_uom_qty ELSE 0 END)) AS opening_stock,
-                    (SUM(CASE WHEN sm.date <= %s AND sld_dest.usage = 'internal'
-                     THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
-                    THEN sm.product_uom_qty ELSE 0 END)) AS closing_stock,
-                    SUM(CASE WHEN sm.date BETWEEN %s AND %s 
-                    AND sld_dest.usage = 'customer' 
-                    THEN sm.product_uom_qty ELSE 0 END) AS sales,
-                    ((SUM(CASE WHEN sm.date <= %s 
-                    AND sld_dest.usage = 'internal' 
-                    THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
-                    THEN sm.product_uom_qty ELSE 0 END))+
-                    (SUM(CASE WHEN sm.date <= %s AND sld_dest.usage = 'internal' 
-                    THEN sm.product_uom_qty ELSE 0 END) -
-                    SUM(CASE WHEN sm.date <= %s AND sld_src.usage = 'internal' 
-                    THEN sm.product_uom_qty ELSE 0 END)))/2 AS average_stock
+                    COALESCE(ROUND((SUM(svl.remaining_value) / NULLIF(SUM(SUM(svl.remaining_value)) OVER (), 0)) * 100, 2), 0) AS stock_percentage,
+                    (SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END) -
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END)) AS opening_stock,
+                    (SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END) -
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END)) AS closing_stock,
+                    SUM(CASE WHEN sm.date BETWEEN %s AND %s AND sl_dest.usage = 'customer' THEN sm.product_uom_qty ELSE 0 END) AS sales,
+                    ((SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END) -
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END))+
+                    (SUM(CASE WHEN sm.date <= %s AND sl_dest.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END) -
+                    SUM(CASE WHEN sm.date <= %s AND sl_src.usage = 'internal' THEN sm.product_uom_qty ELSE 0 END)))/2 AS average_stock
                 FROM
-            stock_move sm
-        JOIN
-            product_product pp ON sm.product_id = pp.id
-        JOIN
-            product_template pt ON pp.product_tmpl_id = pt.id
-        JOIN
-            product_category pc ON pt.categ_id = pc.id
-        JOIN
-            res_company company ON company.id = sm.company_id
-        JOIN
-            stock_warehouse sw ON sw.company_id = company.id
-        JOIN
-            stock_valuation_layer svl ON svl.stock_move_id = sm.id    
-        LEFT JOIN
-            stock_location sld_dest ON sm.location_dest_id = sld_dest.id
-        LEFT JOIN
-            stock_location sld_src ON sm.location_id = sld_src.id
-        WHERE
-            sm.state = 'done'
-            AND pp.active = TRUE
-            AND pt.active = TRUE
-            AND pt.type = 'product'
-            AND svl.remaining_value IS NOT NULL
+                    stock_move sm
+                JOIN
+                    product_product pp ON sm.product_id = pp.id
+                JOIN
+                    product_template pt ON pp.product_tmpl_id = pt.id
+                JOIN
+                    product_category pc ON pt.categ_id = pc.id
+                JOIN
+                    res_company company ON company.id = sm.company_id
+                JOIN
+                    stock_location sl_dest ON sm.location_dest_id = sl_dest.id
+                JOIN
+                    stock_location sl_src ON sm.location_id = sl_src.id
+                LEFT JOIN
+                    stock_warehouse sw_dest ON sl_dest.warehouse_id = sw_dest.id
+                LEFT JOIN
+                    stock_warehouse sw_src ON sl_src.warehouse_id = sw_src.id
+                JOIN
+                    stock_valuation_layer svl ON svl.stock_move_id = sm.id    
+                WHERE
+                    sm.state = 'done'
+                    AND pp.active = TRUE
+                    AND pt.active = TRUE
+                    AND pt.type = 'product'
+                    AND svl.remaining_value IS NOT NULL
         """
         params = [
             start_date, start_date, end_date, end_date, start_date, end_date,
             start_date, start_date, end_date, end_date
         ]
-        sub_queries = []
-        sub_params = []
-        param_count = 0
         if product_ids or category_ids:
             query += " AND ("
         if product_ids:
             product_ids = [product_id for product_id in product_ids]
             query += "pp.id = ANY(%s)"
             params.append(product_ids)
-            param_count += 1
         if product_ids and category_ids:
             query += " OR "
         if category_ids:
             category_ids = [category_id for category_id in category_ids]
             query += "pt.categ_id IN %s"
             params.append(tuple(category_ids))
-            param_count += 1
         if product_ids or category_ids:
             query += ")"
         if company_ids:
-            query += f" AND sm.company_id IN %s"
-            sub_params.append(tuple(company_ids))
-            param_count += 1
+            query += " AND sm.company_id IN %s"
+            params.append(tuple(company_ids))
         if warehouse_ids:
-            query += f" AND sw.id IN %s"
-            sub_params.append(tuple(warehouse_ids))
-            param_count += 1
-        if sub_queries:
-            query += " AND " + " AND ".join(sub_queries)
+            query += " AND (COALESCE(sw_dest.id, sw_src.id) IN %s)"
+            params.append(tuple(warehouse_ids))
         query += """
-                    GROUP BY
-            pp.id,pt.name, pt.categ_id,pc.complete_name, company.id, sw.id  
-    ) AS subquery
-    ORDER BY stock_value DESC
-                    """
-        self.env.cr.execute(query, tuple(params + sub_params))
+                GROUP BY
+                    pp.id, pt.name, pt.categ_id, pc.complete_name, company.id, COALESCE(sw_dest.id, sw_src.id)
+            ) AS subquery
+            ORDER BY stock_value DESC
+        """
+        self.env.cr.execute(query, tuple(params))
         result_data = self.env.cr.dictfetchall()
         for fsn_data in result_data:
             if (

inventory_advanced_reports/report/out_of_stock_report.py

@@ -45,103 +45,89 @@ class OutOfStockReport(models.AbstractModel):
             raise ValueError(
                 "Missing start_date or end_date in the data")
         query = """
-                    SELECT
-                        product_id,
-                        product_code_and_name,
-                        category_id,
-                        category_name,
-                        company_id,
-                        current_stock,
-                        warehouse_id,
-                        incoming_quantity,
-                        outgoing_quantity,
-                        virtual_stock,
-                        sales,
-                        ads,
-                        advance_stock_days,
-                        ROUND(advance_stock_days * ads, 0) AS demanded_quantity,
-                        ROUND(CASE
-                        WHEN ads = 0 THEN virtual_stock / 0.001
-                        ELSE virtual_stock / ads
-                    END,0) AS in_stock_days,
-                    ROUND(CASE
-                        WHEN ads = 0 THEN GREATEST(advance_stock_days - 
-                        ROUND(virtual_stock / 0.001, 2), 0)
-                        ELSE GREATEST(advance_stock_days - 
-                        ROUND(virtual_stock / ads, 2), 0)
-                    END ,0) AS out_of_stock_days,
-                    ROUND(
+            SELECT
+                product_id,
+                product_code_and_name,
+                category_id,
+                category_name,
+                company_id,
+                current_stock,
+                warehouse_id,
+                incoming_quantity,
+                outgoing_quantity,
+                virtual_stock,
+                sales,
+                ads,
+                advance_stock_days,
+                ROUND(advance_stock_days * ads, 0) AS demanded_quantity,
+                ROUND(CASE
+                    WHEN ads = 0 THEN virtual_stock / 0.001
+                    ELSE virtual_stock / ads
+                END,0) AS in_stock_days,
+                ROUND(CASE
+                    WHEN ads = 0 THEN GREATEST(advance_stock_days - ROUND(virtual_stock / 0.001, 2), 0)
+                    ELSE GREATEST(advance_stock_days - ROUND(virtual_stock / ads, 2), 0)
+                END ,0) AS out_of_stock_days,
+                ROUND(
+                    CASE
+                        WHEN advance_stock_days = 0 THEN 0
+                        ELSE
                             CASE
-                            WHEN advance_stock_days = 0 THEN 0
-                            ELSE
-                                CASE
-                                WHEN ads = 0 THEN GREATEST(advance_stock_days - 
-                                ROUND(virtual_stock / 0.001, 2), 0)
-                                ELSE GREATEST(advance_stock_days - 
-                                ROUND(virtual_stock / ads, 2), 0)
-                                END
-                            END, 2
-                            ) AS out_of_stock_ratio,
-                                        ROUND(
-                                            CASE
-                                            WHEN ads = 0 
-                                            THEN 
-                                            GREATEST(advance_stock_days - 
-                                            ROUND(virtual_stock / 0.001, 2), 0)
-                                            ELSE GREATEST(advance_stock_days - 
-                                            ROUND(virtual_stock / ads, 2), 0)
-                                            END * ads, 0
-                                        ) AS out_of_stock_qty,
-                                        ROUND(
-                                CASE
-                                WHEN virtual_stock = 0 THEN 0 
-                                ELSE sales / virtual_stock
-                                END, 2
-                                ) AS turnover_ratio,
+                                WHEN ads = 0 THEN GREATEST(advance_stock_days - ROUND(virtual_stock / 0.001, 2), 0)
+                                ELSE GREATEST(advance_stock_days - ROUND(virtual_stock / ads, 2), 0)
+                            END
+                    END, 2
+                ) AS out_of_stock_ratio,
+                ROUND(
+                    CASE
+                        WHEN ads = 0 THEN GREATEST(advance_stock_days - ROUND(virtual_stock / 0.001, 2), 0)
+                        ELSE GREATEST(advance_stock_days - ROUND(virtual_stock / ads, 2), 0)
+                    END * ads, 0
+                ) AS out_of_stock_qty,
+                ROUND(
+                    CASE
+                        WHEN virtual_stock = 0 THEN 0 
+                        ELSE sales / virtual_stock
+                    END, 2
+                ) AS turnover_ratio,
+                CASE
+                    WHEN
                         CASE
-                            WHEN
-                                CASE
-                                    WHEN sales > 0 THEN 
-                                    ROUND((sales / NULLIF(virtual_stock, 0)), 2)
-                                    ELSE 0
-                                END > 3 THEN 'Fast Moving'
-                            WHEN
-                                CASE
-                                    WHEN sales > 0 THEN 
-                                    ROUND((sales / NULLIF(virtual_stock, 0)), 2)
-                                    ELSE 0
-                                END >= 1 AND
-                                CASE
-                                    WHEN sales > 0 THEN 
-                                    ROUND((sales / NULLIF(virtual_stock, 0)), 2)
-                                    ELSE 0
-                                END <= 3 THEN 'Slow Moving'
-                            ELSE 'Non Moving'
-                        END AS fsn_classification
-                    FROM(
-                        SELECT 
-                            CASE
-                                WHEN pp.default_code IS NOT NULL 
-                                    THEN CONCAT(pp.default_code, ' - ', 
-                                    pt.name->>'en_US')
-                                ELSE
-                                    pt.name->>'en_US'
-                            END AS product_code_and_name,
-                            company.id AS company_id,
-                            company.name AS company_name,
-                            sm.product_id AS product_id,
-                            pc.id AS category_id,
-                            pc.complete_name AS category_name,
-                            sw.id AS warehouse_id,
-                                    SUM(CASE
-                        WHEN sld_dest.usage = 'internal' AND sm.state IN 
-                        ('assigned', 'confirmed', 'waiting') 
+                            WHEN sales > 0 THEN ROUND((sales / NULLIF(virtual_stock, 0)), 2)
+                            ELSE 0
+                        END > 3 THEN 'Fast Moving'
+                    WHEN
+                        CASE
+                            WHEN sales > 0 THEN ROUND((sales / NULLIF(virtual_stock, 0)), 2)
+                            ELSE 0
+                        END >= 1 AND
+                        CASE
+                            WHEN sales > 0 THEN ROUND((sales / NULLIF(virtual_stock, 0)), 2)
+                            ELSE 0
+                        END <= 3 THEN 'Slow Moving'
+                    ELSE 'Non Moving'
+                END AS fsn_classification
+            FROM(
+                SELECT 
+                    CASE
+                        WHEN pp.default_code IS NOT NULL 
+                            THEN CONCAT(pp.default_code, ' - ', pt.name->>'en_US')
+                        ELSE
+                            pt.name->>'en_US'
+                    END AS product_code_and_name,
+                    company.id AS company_id,
+                    company.name AS company_name,
+                    sm.product_id AS product_id,
+                    pc.id AS category_id,
+                    pc.complete_name AS category_name,
+                    COALESCE(sld_dest.warehouse_id, sld_src.warehouse_id) AS warehouse_id,
+                    SUM(CASE
+                        WHEN sld_dest.usage = 'internal' AND sm.state IN ('assigned', 'confirmed', 'waiting') 
                         THEN sm.product_uom_qty
                         ELSE 0
                     END) AS incoming_quantity,
                     SUM(CASE
-                        WHEN sld_src.usage = 'internal' AND sm.state IN 
-                        ('assigned', 'confirmed', 'waiting') 
+                        WHEN sld_src.usage = 'internal' AND sm.state IN ('assigned', 'confirmed', 'waiting') 
                         THEN sm.product_uom_qty
                         ELSE 0
                     END) AS outgoing_quantity,
@@ -156,94 +142,86 @@ class OutOfStockReport(models.AbstractModel):
                         ELSE 0
                     END) AS current_stock,
                     SUM(CASE
-                WHEN sld_dest.usage = 'internal' AND sm.state = 'done' 
-                THEN sm.product_uom_qty
-                ELSE 0
-            END) -
-            SUM(CASE
-                WHEN sld_src.usage = 'internal' AND sm.state = 'done' 
-                THEN sm.product_uom_qty
-                ELSE 0
-            END)+
-            SUM(CASE
-                WHEN sld_dest.usage = 'internal' AND sm.state 
-                IN ('assigned', 'confirmed', 'waiting') THEN sm.product_uom_qty
-                ELSE 0
-            END) -
-            SUM(CASE
-                WHEN sld_src.usage = 'internal' AND sm.state 
-                IN ('assigned', 'confirmed', 'waiting') THEN sm.product_uom_qty
-                ELSE 0
-            END) AS virtual_stock,
-                     SUM(CASE WHEN sm.date BETWEEN %s AND %s 
-                     AND sld_dest.usage = 'customer' 
-                     THEN sm.product_uom_qty ELSE 0 END) AS sales,
-                            ROUND(SUM(CASE
-                WHEN sm.date BETWEEN %s AND %s AND sld_src.usage = 'internal' 
-                AND sm.state = 'done' THEN sm.product_uom_qty
-                ELSE 0
-            END) / ((date %s - date %s)+1), 2) AS ads,
-            %s AS advance_stock_days
-                    FROM stock_move sm
-                    INNER JOIN product_product pp ON pp.id = sm.product_id
-                    INNER JOIN product_template pt ON pt.id = pp.product_tmpl_id
-                    INNER JOIN res_company company ON company.id = sm.company_id
-                    INNER JOIN stock_warehouse sw ON sw.company_id = company.id
-                    INNER JOIN product_category pc ON pc.id = pt.categ_id
-                    LEFT JOIN (
-                        SELECT sm.id AS move_id, usage
-                        FROM stock_location sld
-                        INNER JOIN stock_move sm ON sld.id = sm.location_dest_id
-                    ) sld_dest ON sm.id = sld_dest.move_id
-                    LEFT JOIN (
-                        SELECT sm.id AS move_id, usage
-                        FROM stock_location sld
-                        INNER JOIN stock_move sm ON sld.id = sm.location_id
-                    ) sld_src ON sm.id = sld_src.move_id
-                    WHERE pp.active = TRUE
-                            AND pt.active = TRUE
-                            AND pt.type = 'product'
-                                """
+                        WHEN sld_dest.usage = 'internal' AND sm.state = 'done' 
+                        THEN sm.product_uom_qty
+                        ELSE 0
+                    END) -
+                    SUM(CASE
+                        WHEN sld_src.usage = 'internal' AND sm.state = 'done' 
+                        THEN sm.product_uom_qty
+                        ELSE 0
+                    END)+
+                    SUM(CASE
+                        WHEN sld_dest.usage = 'internal' AND sm.state IN ('assigned', 'confirmed', 'waiting') 
+                        THEN sm.product_uom_qty
+                        ELSE 0
+                    END) -
+                    SUM(CASE
+                        WHEN sld_src.usage = 'internal' AND sm.state IN ('assigned', 'confirmed', 'waiting') 
+                        THEN sm.product_uom_qty
+                        ELSE 0
+                    END) AS virtual_stock,
+                    SUM(CASE WHEN sm.date BETWEEN %s AND %s AND sld_dest.usage = 'customer' 
+                        THEN sm.product_uom_qty ELSE 0 END) AS sales,
+                    ROUND(SUM(CASE
+                        WHEN sm.date BETWEEN %s AND %s AND sld_src.usage = 'internal' 
+                        AND sm.state = 'done' THEN sm.product_uom_qty
+                        ELSE 0
+                    END) / ((date %s - date %s)+1), 2) AS ads,
+                    %s AS advance_stock_days
+                FROM stock_move sm
+                INNER JOIN product_product pp ON pp.id = sm.product_id
+                INNER JOIN product_template pt ON pt.id = pp.product_tmpl_id
+                INNER JOIN res_company company ON company.id = sm.company_id
+                INNER JOIN product_category pc ON pc.id = pt.categ_id
+                LEFT JOIN (
+                    SELECT sm.id AS move_id, sld.usage, sw.id AS warehouse_id
+                    FROM stock_location sld
+                    INNER JOIN stock_move sm ON sld.id = sm.location_dest_id
+                    LEFT JOIN stock_warehouse sw ON sld.warehouse_id = sw.id
+                ) sld_dest ON sm.id = sld_dest.move_id
+                LEFT JOIN (
+                    SELECT sm.id AS move_id, sld.usage, sw.id AS warehouse_id
+                    FROM stock_location sld
+                    INNER JOIN stock_move sm ON sld.id = sm.location_id
+                    LEFT JOIN stock_warehouse sw ON sld.warehouse_id = sw.id
+                ) sld_src ON sm.id = sld_src.move_id
+                WHERE pp.active = TRUE
+                    AND pt.active = TRUE
+                    AND pt.type = 'product'
+        """
         params = [
             start_date, end_date,
             start_date, end_date,
             end_date, start_date,
             inventory_for_next_x_days
         ]
-        sub_queries = []
-        sub_params = []
-        param_count = 0
         if product_ids or category_ids:
             query += " AND ("
         if product_ids:
             product_ids = [product_id for product_id in product_ids]
             query += "pp.id = ANY(%s)"
             params.append(product_ids)
-            param_count += 1
         if product_ids and category_ids:
             query += " OR "
         if category_ids:
             category_ids = [category for category in category_ids]
             params.append(category_ids)
             query += "(pt.categ_id = ANY(%s))"
-            param_count += 1
         if product_ids or category_ids:
             query += ")"
         if company_ids:
             company_ids = [company for company in company_ids]
             query += " AND (sm.company_id = ANY(%s))"
-            sub_params.append(company_ids)
-            param_count += 1
+            params.append(company_ids)
         if warehouse_ids:
             warehouse_ids = [warehouse for warehouse in warehouse_ids]
-            query += " AND (sw.id = ANY(%s))"
-            sub_params.append(warehouse_ids)
-            param_count += 1
-        if sub_queries:
-            query += " AND " + " AND ".join(sub_queries)
+            query += " AND (COALESCE(sw_dest.id, sw_src.id) IN %s)"
+            params.append(warehouse_ids)
         query += """ GROUP BY pp.id, pt.name, pc.id, company.id, sm.product_id, 
-        sw.id) AS sub_query """
-        self.env.cr.execute(query, tuple(params + sub_params))
+            COALESCE(sld_dest.warehouse_id, sld_src.warehouse_id)
+        ) AS sub_query """
+        self.env.cr.execute(query, tuple(params))
         result_data = self.env.cr.dictfetchall()
         for data in result_data:
             product_id = data.get('product_id')

inventory_advanced_reports/report/over_stock_report.py

@@ -110,7 +110,7 @@ class OverStockReport(models.AbstractModel):
                     sm.product_id AS product_id,
                     pc.id AS category_id,
                     pc.complete_name AS category_name,
-                    sw.id AS warehouse_id,
+                    COALESCE(sld_dest.warehouse_id, sld_src.warehouse_id) AS warehouse_id,
                             SUM(CASE
                 WHEN sld_dest.usage = 'internal' AND sm.state 
                 IN ('assigned', 'confirmed', 'waiting') THEN sm.product_uom_qty
@@ -164,17 +164,18 @@ class OverStockReport(models.AbstractModel):
                 INNER JOIN product_product pp ON pp.id = sm.product_id
                 INNER JOIN product_template pt ON pt.id = pp.product_tmpl_id
                 INNER JOIN res_company company ON company.id = sm.company_id
-                INNER JOIN stock_warehouse sw ON sw.company_id = company.id
                 INNER JOIN product_category pc ON pc.id = pt.categ_id
                 LEFT JOIN (
-                    SELECT sm.id AS move_id, usage
+                    SELECT sm.id AS move_id, sld.usage, sw.id AS warehouse_id
                     FROM stock_location sld
                     INNER JOIN stock_move sm ON sld.id = sm.location_dest_id
+                    LEFT JOIN stock_warehouse sw ON sld.warehouse_id = sw.id
                 ) sld_dest ON sm.id = sld_dest.move_id
                 LEFT JOIN (
-                    SELECT sm.id AS move_id, usage
+                    SELECT sm.id AS move_id, sld.usage, sw.id AS warehouse_id
                     FROM stock_location sld
                     INNER JOIN stock_move sm ON sld.id = sm.location_id
+                    LEFT JOIN stock_warehouse sw ON sld.warehouse_id = sw.id
                 ) sld_src ON sm.id = sld_src.move_id
                 WHERE pp.active = TRUE
                         AND pt.active = TRUE
@@ -186,40 +187,32 @@ class OverStockReport(models.AbstractModel):
             end_date, start_date,
             inventory_for_next_x_days
         ]
-        sub_queries = []
-        sub_params = []
-        param_count = 0
         if product_ids or category_ids:
             query += " AND ("
         if product_ids:
             product_ids = [product_id for product_id in product_ids]
             query += "pp.id = ANY(%s)"
             params.append(product_ids)
-            param_count += 1
         if product_ids and category_ids:
             query += " OR "
         if category_ids:
             category_ids = [category for category in category_ids]
             params.append(category_ids)
             query += "(pt.categ_id = ANY(%s))"
-            param_count += 1
         if product_ids or category_ids:
             query += ")"
         if company_ids:
             company_ids = [company for company in company_ids]
             query += " AND (sm.company_id = ANY(%s))"
-            sub_params.append(company_ids)
-            param_count += 1
+            params.append(company_ids)
         if warehouse_ids:
             warehouse_ids = [warehouse for warehouse in warehouse_ids]
-            query += " AND (sw.id = ANY(%s))"
-            sub_params.append(warehouse_ids)
-            param_count += 1
-        if sub_queries:
-            query += " AND " + " AND ".join(sub_queries)
+            query += " AND (COALESCE(sld_dest.warehouse_id, sld_src.warehouse_id) = ANY(%s))"
+            params.append(warehouse_ids)
         query += """ GROUP BY pp.id, pt.name, pc.id, company.id, sm.product_id, 
-        sw.id) AS sub_query """
-        self.env.cr.execute(query, tuple(params + sub_params))
+        COALESCE(sld_dest.warehouse_id, sld_src.warehouse_id)
+                    ) AS sub_query """
+        self.env.cr.execute(query, tuple(params))
         result_data = self.env.cr.dictfetchall()
         for data in result_data:
             product_id = data.get('product_id')

inventory_advanced_reports/report/stock_movement_report.py

@@ -144,18 +144,12 @@ class StockMovementReport(models.AbstractModel):
                         AND %s AND sld_src.usage = 'transit' 
                         THEN sm.product_uom_qty ELSE 0 END) AS transit_out
                     """
-            params = [start_date, start_date, end_date, end_date, start_date,
-                      end_date, start_date, end_date, start_date, end_date,
-                      start_date, end_date, start_date, end_date, start_date,
-                      end_date, start_date, end_date, start_date, end_date,
-                      start_date, end_date, start_date, end_date, start_date,
-                      end_date, start_date, end_date]
+            params = [start_date, start_date, end_date, end_date] + [start_date, end_date] * 12
         query += """
                     FROM stock_move sm
                     INNER JOIN product_product pp ON pp.id = sm.product_id
                     INNER JOIN product_template pt ON pt.id = pp.product_tmpl_id
                     INNER JOIN res_company company ON company.id = sm.company_id
-                    INNER JOIN stock_warehouse sw ON sw.company_id = company.id
                     INNER JOIN product_category pc ON pc.id = pt.categ_id   
                 """
         query += """
@@ -163,31 +157,32 @@ class StockMovementReport(models.AbstractModel):
                     ON sm.location_dest_id = sld_dest.id
                     LEFT JOIN stock_location sld_src 
                     ON sm.location_id = sld_src.id
+                    LEFT JOIN
+                    stock_warehouse sw_dest ON sld_dest.warehouse_id = sw_dest.id
+                    LEFT JOIN
+                    stock_warehouse sw_src ON sld_src.warehouse_id = sw_src.id
                     WHERE
                 sm.state = 'done'
                         """
-        sub_queries = []
         if product_ids:
             product_ids = [product_id for product_id in product_ids]
-            sub_queries.append("pp.id = ANY(%s)")
+            query += " AND pp.id = ANY(%s)"
             params.append(product_ids)
         if category_ids:
             category_ids = [category for category in category_ids]
-            sub_queries.append("pt.categ_id = ANY(%s)")
+            query += " AND (pt.categ_id = ANY(%s))"
             params.append(category_ids)
-        if sub_queries:
-            query += " AND (" + " OR ".join(sub_queries) + ")"
         if company_ids:
             company_ids = [company for company in company_ids]
             query += " AND sm.company_id = ANY(%s)"
             params.append(company_ids)
         if warehouse_ids:
             warehouse_ids = [warehouse for warehouse in warehouse_ids]
-            query += " AND sw.id = ANY(%s)"
+            query += " AND (COALESCE(sw_dest.id, sw_src.id) = ANY(%s))"
             params.append(warehouse_ids)
         query += """
-                    GROUP BY pp.id,pt.name,pc.complete_name,company.name
-                """
+            GROUP BY pp.id, pt.name, pc.complete_name, company.name
+        """
         self.env.cr.execute(query, params)
         result_data = self.env.cr.dictfetchall()
         if result_data: