[UI] Refactor order table filters (#11939)

* Refactor build order filters

- Common set of filters for build order views

* Refactor PurchaseOrder filters

* Update company table

* Refactor SalesOrder filters

* Refactor common filters

* Refactor ReturnOrder table filters

src/frontend/src/components/calendar/OrderCalendar.tsx

@@ -69,7 +69,16 @@ export default function OrderCalendar({
 
   // Complete set of available filters
   const calendarFilters: TableFilter[] = useMemo(() => {
-    return [...orderFilters, ...(filters ?? [])];
+    const calendarFilters: TableFilter[] = [...(filters ?? [])];
+
+    // Add any "standard" filters - but do not override provided filters
+    orderFilters.forEach((orderFilter) => {
+      if (!calendarFilters.some((f) => f.name === orderFilter.name)) {
+        calendarFilters.push(orderFilter);
+      }
+    });
+
+    return calendarFilters;
   }, [orderFilters, filters]);
 
   const modelInfo = useMemo(() => {

src/frontend/src/pages/build/BuildIndex.tsx

@@ -20,7 +20,7 @@ import { PanelGroup } from '../../components/panels/PanelGroup';
 import SegmentedControlPanel from '../../components/panels/SegmentedControlPanel';
 import { useGlobalSettingsState } from '../../states/SettingsStates';
 import { useUserState } from '../../states/UserState';
-import { PartCategoryFilter } from '../../tables/Filter';
+import BuildOrderFilters from '../../tables/build/BuildOrderFilters';
 import BuildOrderParametricTable from '../../tables/build/BuildOrderParametricTable';
 import { BuildOrderTable } from '../../tables/build/BuildOrderTable';
 
@@ -28,15 +28,10 @@ function BuildOrderCalendar() {
   const globalSettings = useGlobalSettingsState();
 
   const calendarFilters: TableFilter[] = useMemo(() => {
-    return [
+    return BuildOrderFilters({
-      {
+      includeDateFilters: false,
-        name: 'external',
+      externalBuilds: globalSettings.isSet('BUILDORDER_EXTERNAL_BUILDS')
-        label: t`External`,
+    });
-        description: t`Show external build orders`,
-        active: globalSettings.isSet('BUILDORDER_EXTERNAL_BUILDS')
-      },
-      PartCategoryFilter()
-    ];
   }, [globalSettings]);
 
   return (

src/frontend/src/pages/purchasing/PurchasingIndex.tsx

@@ -14,6 +14,7 @@ import { useMemo } from 'react';
 
 import { ModelType, PluginPanelKey } from '@lib/enums/ModelType';
 import { UserRoles } from '@lib/enums/Roles';
+import type { TableFilter } from '@lib/index';
 import { useLocalStorage } from '@mantine/hooks';
 import OrderCalendar from '../../components/calendar/OrderCalendar';
 import PermissionDenied from '../../components/errors/PermissionDenied';
@@ -25,11 +26,27 @@ import { CompanyTable } from '../../tables/company/CompanyTable';
 import ParametricCompanyTable from '../../tables/company/ParametricCompanyTable';
 import ManufacturerPartParametricTable from '../../tables/purchasing/ManufacturerPartParametricTable';
 import { ManufacturerPartTable } from '../../tables/purchasing/ManufacturerPartTable';
+import PurchaseOrderFilters from '../../tables/purchasing/PurchaseOrderFilters';
 import PurchaseOrderParametricTable from '../../tables/purchasing/PurchaseOrderParametricTable';
 import { PurchaseOrderTable } from '../../tables/purchasing/PurchaseOrderTable';
 import SupplierPartParametricTable from '../../tables/purchasing/SupplierPartParametricTable';
 import { SupplierPartTable } from '../../tables/purchasing/SupplierPartTable';
 
+function PurchaseOrderCalendar() {
+  const calendarFilters: TableFilter[] = useMemo(() => {
+    return PurchaseOrderFilters({ includeDateFilters: false });
+  }, []);
+
+  return (
+    <OrderCalendar
+      model={ModelType.purchaseorder}
+      role={UserRoles.purchase_order}
+      params={{ outstanding: true }}
+      filters={calendarFilters}
+    />
+  );
+}
+
 export default function PurchasingIndex() {
   const user = useUserState();
 
@@ -79,13 +96,7 @@ export default function PurchasingIndex() {
             value: 'calendar',
             label: t`Calendar View`,
             icon: <IconCalendar />,
-            content: (
+            content: <PurchaseOrderCalendar />
-              <OrderCalendar
-                model={ModelType.purchaseorder}
-                role={UserRoles.purchase_order}
-                params={{ outstanding: true }}
-              />
-            )
           },
           {
             value: 'parametric',

src/frontend/src/pages/sales/SalesIndex.tsx

@@ -13,6 +13,7 @@ import { useMemo } from 'react';
 
 import { ModelType, PluginPanelKey } from '@lib/enums/ModelType';
 import { UserRoles } from '@lib/enums/Roles';
+import type { TableFilter } from '@lib/index';
 import { useLocalStorage } from '@mantine/hooks';
 import OrderCalendar from '../../components/calendar/OrderCalendar';
 import PermissionDenied from '../../components/errors/PermissionDenied';
@@ -24,10 +25,41 @@ import { CompanyTable } from '../../tables/company/CompanyTable';
 import ParametricCompanyTable from '../../tables/company/ParametricCompanyTable';
 import ReturnOrderParametricTable from '../../tables/sales/ReturnOrderParametricTable';
 import { ReturnOrderTable } from '../../tables/sales/ReturnOrderTable';
+import SalesOrderFilters from '../../tables/sales/SalesOrderFilters';
 import SalesOrderParametricTable from '../../tables/sales/SalesOrderParametricTable';
 import SalesOrderShipmentTable from '../../tables/sales/SalesOrderShipmentTable';
 import { SalesOrderTable } from '../../tables/sales/SalesOrderTable';
 
+function SalesOrderCalendar() {
+  const calendarFilters: TableFilter[] = useMemo(() => {
+    return SalesOrderFilters({ includeDateFilters: false });
+  }, []);
+
+  return (
+    <OrderCalendar
+      model={ModelType.salesorder}
+      role={UserRoles.sales_order}
+      params={{ outstanding: true }}
+      filters={calendarFilters}
+    />
+  );
+}
+
+const ReturnOrderCalendar = () => {
+  const calendarFilters: TableFilter[] = useMemo(() => {
+    return SalesOrderFilters({ includeDateFilters: false });
+  }, []);
+
+  return (
+    <OrderCalendar
+      model={ModelType.returnorder}
+      role={UserRoles.return_order}
+      params={{ outstanding: true }}
+      filters={calendarFilters}
+    />
+  );
+};
+
 export default function SalesIndex() {
   const user = useUserState();
 
@@ -66,13 +98,7 @@ export default function SalesIndex() {
             value: 'calendar',
             label: t`Calendar View`,
             icon: <IconCalendar />,
-            content: (
+            content: <SalesOrderCalendar />
-              <OrderCalendar
-                model={ModelType.returnorder}
-                role={UserRoles.return_order}
-                params={{ outstanding: true }}
-              />
-            )
           },
           {
             value: 'parametric',
@@ -112,13 +138,7 @@ export default function SalesIndex() {
             value: 'calendar',
             label: t`Calendar View`,
             icon: <IconCalendar />,
-            content: (
+            content: <ReturnOrderCalendar />
-              <OrderCalendar
-                model={ModelType.returnorder}
-                role={UserRoles.return_order}
-                params={{ outstanding: true }}
-              />
-            )
           },
           {
             value: 'parametric',

src/frontend/src/tables/Filter.tsx

@@ -250,6 +250,24 @@ export function StartDateAfterFilter(): TableFilter {
   };
 }
 
+export function HasStartDateFilter(): TableFilter {
+  return {
+    name: 'has_start_date',
+    type: 'boolean',
+    label: t`Has Start Date`,
+    description: t`Show items with a start date`
+  };
+}
+
+export function HasTargetDateFilter(): TableFilter {
+  return {
+    name: 'has_target_date',
+    type: 'boolean',
+    label: t`Has Target Date`,
+    description: t`Show items with a target date`
+  };
+}
+
 export function TargetDateBeforeFilter(): TableFilter {
   return {
     name: 'target_date_before',

src/frontend/src/tables/build/BuildOrderFilters.tsx

@@ -0,0 +1,87 @@
+import { ModelType } from '@lib/enums/ModelType';
+import type { TableFilter } from '@lib/types/Filters';
+import { t } from '@lingui/core/macro';
+import {
+  AssignedToMeFilter,
+  CompletedAfterFilter,
+  CompletedBeforeFilter,
+  CreatedAfterFilter,
+  CreatedBeforeFilter,
+  HasProjectCodeFilter,
+  HasStartDateFilter,
+  HasTargetDateFilter,
+  IncludeVariantsFilter,
+  IssuedByFilter,
+  MaxDateFilter,
+  MinDateFilter,
+  OrderStatusFilter,
+  OutstandingFilter,
+  OverdueFilter,
+  PartCategoryFilter,
+  ProjectCodeFilter,
+  ResponsibleFilter,
+  StartDateAfterFilter,
+  StartDateBeforeFilter,
+  TargetDateAfterFilter,
+  TargetDateBeforeFilter
+} from '../Filter';
+
+/**
+ * Generate a set of common filters for the build order views
+ */
+export default function BuildOrderFilters({
+  partId,
+  includeDateFilters = true,
+  externalBuilds = false
+}: {
+  partId?: number;
+  includeDateFilters: boolean;
+  externalBuilds?: boolean;
+}): TableFilter[] {
+  const filters: TableFilter[] = [
+    OutstandingFilter(),
+    OrderStatusFilter({ model: ModelType.build }),
+    OverdueFilter(),
+    AssignedToMeFilter(),
+    CompletedBeforeFilter(),
+    CompletedAfterFilter(),
+    ProjectCodeFilter(),
+    HasProjectCodeFilter(),
+    IssuedByFilter(),
+    ResponsibleFilter(),
+    PartCategoryFilter()
+  ];
+
+  const dateFilters: TableFilter[] = [
+    MinDateFilter(),
+    MaxDateFilter(),
+    CreatedBeforeFilter(),
+    CreatedAfterFilter(),
+    TargetDateBeforeFilter(),
+    TargetDateAfterFilter(),
+    StartDateBeforeFilter(),
+    StartDateAfterFilter(),
+    HasTargetDateFilter(),
+    HasStartDateFilter()
+  ];
+
+  // Date filters may be optionally included or excluded from the filter set
+  if (includeDateFilters) {
+    filters.push(...dateFilters);
+  }
+
+  if (externalBuilds) {
+    filters.push({
+      name: 'external',
+      label: t`External`,
+      description: t`Show external build orders`
+    });
+  }
+
+  // If we are filtering on a specific part, we can include the "include variants" filter
+  if (!!partId) {
+    filters.push(IncludeVariantsFilter());
+  }
+
+  return filters;
+}

src/frontend/src/tables/build/BuildOrderParametricTable.tsx

@@ -3,19 +3,22 @@ import type { TableFilter } from '@lib/types/Filters';
 import type { TableColumn } from '@lib/types/Tables';
 import { t } from '@lingui/core/macro';
 import { type ReactNode, useMemo } from 'react';
+import { useGlobalSettingsState } from '../../states/SettingsStates';
 import {
   DescriptionColumn,
   PartColumn,
   ReferenceColumn
 } from '../ColumnRenderers';
-import { OrderStatusFilter, OutstandingFilter } from '../Filter';
 import ParametricDataTable from '../general/ParametricDataTable';
+import BuildOrderFilters from './BuildOrderFilters';
 
 export default function BuildOrderParametricTable({
   queryParams
 }: {
   queryParams?: Record<string, any>;
 }): ReactNode {
+  const globalSettings = useGlobalSettingsState();
+
   const customColumns: TableColumn[] = useMemo(() => {
     return [
       ReferenceColumn({
@@ -32,8 +35,11 @@ export default function BuildOrderParametricTable({
   }, []);
 
   const customFilters: TableFilter[] = useMemo(() => {
-    return [OutstandingFilter(), OrderStatusFilter({ model: ModelType.build })];
+    return BuildOrderFilters({
-  }, []);
+      includeDateFilters: true,
+      externalBuilds: globalSettings.isSet('BUILDORDER_EXTERNAL_BUILDS')
+    });
+  }, [globalSettings]);
 
   return (
     <ParametricDataTable

src/frontend/src/tables/build/BuildOrderTable.tsx

@@ -29,29 +29,8 @@ import {
   TargetDateColumn,
   UserColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  CompletedAfterFilter,
-  CompletedBeforeFilter,
-  CreatedAfterFilter,
-  CreatedBeforeFilter,
-  HasProjectCodeFilter,
-  IncludeVariantsFilter,
-  IssuedByFilter,
-  MaxDateFilter,
-  MinDateFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  PartCategoryFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter,
-  StartDateAfterFilter,
-  StartDateBeforeFilter,
-  TargetDateAfterFilter,
-  TargetDateBeforeFilter
-} from '../Filter';
 import { InvenTreeTable } from '../InvenTreeTable';
+import BuildOrderFilters from './BuildOrderFilters';
 
 /*
  * Construct a table of build orders, according to the provided parameters
@@ -152,52 +131,11 @@ export function BuildOrderTable({
   }, [parentBuildId, globalSettings]);
 
   const tableFilters: TableFilter[] = useMemo(() => {
-    const filters: TableFilter[] = [
+    return BuildOrderFilters({
-      OutstandingFilter(),
+      partId: partId,
-      OrderStatusFilter({ model: ModelType.build }),
+      includeDateFilters: true,
-      OverdueFilter(),
+      externalBuilds: globalSettings.isSet('BUILDORDER_EXTERNAL_BUILDS')
-      AssignedToMeFilter(),
+    });
-      MinDateFilter(),
-      MaxDateFilter(),
-      CreatedBeforeFilter(),
-      CreatedAfterFilter(),
-      TargetDateBeforeFilter(),
-      TargetDateAfterFilter(),
-      StartDateBeforeFilter(),
-      StartDateAfterFilter(),
-      {
-        name: 'has_target_date',
-        type: 'boolean',
-        label: t`Has Target Date`,
-        description: t`Show orders with a target date`
-      },
-      {
-        name: 'has_start_date',
-        type: 'boolean',
-        label: t`Has Start Date`,
-        description: t`Show orders with a start date`
-      },
-      CompletedBeforeFilter(),
-      CompletedAfterFilter(),
-      ProjectCodeFilter(),
-      HasProjectCodeFilter(),
-      IssuedByFilter(),
-      ResponsibleFilter(),
-      {
-        name: 'external',
-        label: t`External`,
-        description: t`Show external build orders`,
-        active: globalSettings.isSet('BUILDORDER_EXTERNAL_BUILDS')
-      },
-      PartCategoryFilter()
-    ];
-
-    // If we are filtering on a specific part, we can include the "include variants" filter
-    if (!!partId) {
-      filters.push(IncludeVariantsFilter());
-    }
-
-    return filters;
   }, [partId, globalSettings]);
 
   const user = useUserState();

src/frontend/src/tables/company/ParametricCompanyTable.tsx

@@ -1,5 +1,6 @@
 import { ApiEndpoints } from '@lib/enums/ApiEndpoints';
 import { ModelType } from '@lib/enums/ModelType';
+import type { TableFilter } from '@lib/types/Filters';
 import type { TableColumn } from '@lib/types/Tables';
 import { t } from '@lingui/core/macro';
 import { useMemo } from 'react';
@@ -11,6 +12,16 @@ export default function ParametricCompanyTable({
 }: {
   queryParams?: any;
 }) {
+  const customFilters: TableFilter[] = useMemo(() => {
+    return [
+      {
+        name: 'active',
+        label: t`Active`,
+        description: t`Show active companies`
+      }
+    ];
+  }, []);
+
   const customColumns: TableColumn[] = useMemo(() => {
     return [
       {
@@ -31,6 +42,7 @@ export default function ParametricCompanyTable({
       modelType={ModelType.company}
       endpoint={ApiEndpoints.company_list}
       customColumns={customColumns}
+      customFilters={customFilters}
       queryParams={{
         ...queryParams
       }}

src/frontend/src/tables/purchasing/PurchaseOrderFilters.tsx

@@ -0,0 +1,66 @@
+import { ModelType } from '@lib/enums/ModelType';
+import type { TableFilter } from '@lib/types/Filters';
+import {
+  AssignedToMeFilter,
+  CompletedAfterFilter,
+  CompletedBeforeFilter,
+  CreatedAfterFilter,
+  CreatedBeforeFilter,
+  CreatedByFilter,
+  HasProjectCodeFilter,
+  HasStartDateFilter,
+  HasTargetDateFilter,
+  MaxDateFilter,
+  MinDateFilter,
+  OrderStatusFilter,
+  OutstandingFilter,
+  OverdueFilter,
+  ProjectCodeFilter,
+  ResponsibleFilter,
+  StartDateAfterFilter,
+  StartDateBeforeFilter,
+  TargetDateAfterFilter,
+  TargetDateBeforeFilter,
+  UpdatedAfterFilter,
+  UpdatedBeforeFilter
+} from '../Filter';
+
+export default function PurchaseOrderFilters({
+  includeDateFilters = true
+}: {
+  includeDateFilters?: boolean;
+}): TableFilter[] {
+  const filters: TableFilter[] = [
+    OrderStatusFilter({ model: ModelType.purchaseorder }),
+    OutstandingFilter(),
+    OverdueFilter(),
+    AssignedToMeFilter(),
+    ProjectCodeFilter(),
+    HasProjectCodeFilter(),
+    ResponsibleFilter(),
+    CreatedByFilter()
+  ];
+
+  const dateFilters: TableFilter[] = [
+    MinDateFilter(),
+    MaxDateFilter(),
+    CreatedBeforeFilter(),
+    CreatedAfterFilter(),
+    TargetDateBeforeFilter(),
+    TargetDateAfterFilter(),
+    StartDateBeforeFilter(),
+    StartDateAfterFilter(),
+    HasTargetDateFilter(),
+    HasStartDateFilter(),
+    CompletedBeforeFilter(),
+    CompletedAfterFilter(),
+    UpdatedBeforeFilter(),
+    UpdatedAfterFilter()
+  ];
+
+  if (includeDateFilters) {
+    filters.push(...dateFilters);
+  }
+
+  return filters;
+}

src/frontend/src/tables/purchasing/PurchaseOrderParametricTable.tsx

@@ -9,15 +9,8 @@ import {
   DescriptionColumn,
   ReferenceColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter
-} from '../Filter';
 import ParametricDataTable from '../general/ParametricDataTable';
+import PurchaseOrderFilters from './PurchaseOrderFilters';
 
 export default function PurchaseOrderParametricTable({
   queryParams
@@ -42,14 +35,7 @@ export default function PurchaseOrderParametricTable({
   }, []);
 
   const customFilters: TableFilter[] = useMemo(() => {
-    return [
+    return PurchaseOrderFilters({ includeDateFilters: true });
-      OrderStatusFilter({ model: ModelType.purchaseorder }),
-      OutstandingFilter(),
-      OverdueFilter(),
-      AssignedToMeFilter(),
-      ProjectCodeFilter(),
-      ResponsibleFilter()
-    ];
   }, []);
 
   return (

src/frontend/src/tables/purchasing/PurchaseOrderTable.tsx

@@ -28,29 +28,8 @@ import {
   TargetDateColumn,
   UpdatedAtColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  CompletedAfterFilter,
-  CompletedBeforeFilter,
-  CreatedAfterFilter,
-  CreatedBeforeFilter,
-  CreatedByFilter,
-  HasProjectCodeFilter,
-  MaxDateFilter,
-  MinDateFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter,
-  StartDateAfterFilter,
-  StartDateBeforeFilter,
-  TargetDateAfterFilter,
-  TargetDateBeforeFilter,
-  UpdatedAfterFilter,
-  UpdatedBeforeFilter
-} from '../Filter';
 import { InvenTreeTable } from '../InvenTreeTable';
+import PurchaseOrderFilters from './PurchaseOrderFilters';
 
 /**
  * Display a table of purchase orders
@@ -75,40 +54,7 @@ export function PurchaseOrderTable({
   const user = useUserState();
 
   const tableFilters: TableFilter[] = useMemo(() => {
-    return [
+    return PurchaseOrderFilters({ includeDateFilters: true });
-      OrderStatusFilter({ model: ModelType.purchaseorder }),
-      OutstandingFilter(),
-      OverdueFilter(),
-      AssignedToMeFilter(),
-      MinDateFilter(),
-      MaxDateFilter(),
-      CreatedBeforeFilter(),
-      CreatedAfterFilter(),
-      TargetDateBeforeFilter(),
-      TargetDateAfterFilter(),
-      StartDateBeforeFilter(),
-      StartDateAfterFilter(),
-      {
-        name: 'has_target_date',
-        type: 'boolean',
-        label: t`Has Target Date`,
-        description: t`Show orders with a target date`
-      },
-      {
-        name: 'has_start_date',
-        type: 'boolean',
-        label: t`Has Start Date`,
-        description: t`Show orders with a start date`
-      },
-      CompletedBeforeFilter(),
-      CompletedAfterFilter(),
-      UpdatedBeforeFilter(),
-      UpdatedAfterFilter(),
-      ProjectCodeFilter(),
-      HasProjectCodeFilter(),
-      ResponsibleFilter(),
-      CreatedByFilter()
-    ];
   }, []);
 
   const tableColumns = useMemo(() => {

src/frontend/src/tables/sales/ReturnOrderFilters.tsx

@@ -0,0 +1,73 @@
+import { ModelType } from '@lib/enums/ModelType';
+import type { TableFilter } from '@lib/types/Filters';
+import {
+  AssignedToMeFilter,
+  CompletedAfterFilter,
+  CompletedBeforeFilter,
+  CreatedAfterFilter,
+  CreatedBeforeFilter,
+  CreatedByFilter,
+  HasProjectCodeFilter,
+  HasStartDateFilter,
+  HasTargetDateFilter,
+  IncludeVariantsFilter,
+  MaxDateFilter,
+  MinDateFilter,
+  OrderStatusFilter,
+  OutstandingFilter,
+  OverdueFilter,
+  ProjectCodeFilter,
+  ResponsibleFilter,
+  StartDateAfterFilter,
+  StartDateBeforeFilter,
+  TargetDateAfterFilter,
+  TargetDateBeforeFilter,
+  UpdatedAfterFilter,
+  UpdatedBeforeFilter
+} from '../Filter';
+
+export default function ReturnOrderFilters({
+  partId,
+  includeDateFilters = true
+}: {
+  partId?: number;
+  includeDateFilters?: boolean;
+}): TableFilter[] {
+  const filters: TableFilter[] = [
+    OrderStatusFilter({ model: ModelType.returnorder }),
+    OutstandingFilter(),
+    OverdueFilter(),
+    AssignedToMeFilter(),
+    HasProjectCodeFilter(),
+    ProjectCodeFilter(),
+    ResponsibleFilter(),
+    CreatedByFilter()
+  ];
+
+  const dateFilters: TableFilter[] = [
+    MinDateFilter(),
+    MaxDateFilter(),
+    CreatedBeforeFilter(),
+    CreatedAfterFilter(),
+    TargetDateBeforeFilter(),
+    TargetDateAfterFilter(),
+    StartDateBeforeFilter(),
+    StartDateAfterFilter(),
+    HasTargetDateFilter(),
+    HasStartDateFilter(),
+    CompletedBeforeFilter(),
+    CompletedAfterFilter(),
+    UpdatedBeforeFilter(),
+    UpdatedAfterFilter()
+  ];
+
+  if (includeDateFilters) {
+    filters.push(...dateFilters);
+  }
+
+  if (!!partId) {
+    filters.push(IncludeVariantsFilter());
+  }
+
+  return filters;
+}

src/frontend/src/tables/sales/ReturnOrderParametricTable.tsx

@@ -9,15 +9,8 @@ import {
   DescriptionColumn,
   ReferenceColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter
-} from '../Filter';
 import ParametricDataTable from '../general/ParametricDataTable';
+import ReturnOrderFilters from './ReturnOrderFilters';
 
 export default function ReturnOrderParametricTable({
   queryParams
@@ -40,14 +33,7 @@ export default function ReturnOrderParametricTable({
   }, []);
 
   const customFilters: TableFilter[] = useMemo(() => {
-    return [
+    return ReturnOrderFilters({ includeDateFilters: true });
-      OrderStatusFilter({ model: ModelType.returnorder }),
-      OutstandingFilter(),
-      OverdueFilter(),
-      AssignedToMeFilter(),
-      ProjectCodeFilter(),
-      ResponsibleFilter()
-    ];
   }, []);
 
   return (

src/frontend/src/tables/sales/ReturnOrderTable.tsx

@@ -28,30 +28,8 @@ import {
   TargetDateColumn,
   UpdatedAtColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  CompletedAfterFilter,
-  CompletedBeforeFilter,
-  CreatedAfterFilter,
-  CreatedBeforeFilter,
-  CreatedByFilter,
-  HasProjectCodeFilter,
-  IncludeVariantsFilter,
-  MaxDateFilter,
-  MinDateFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter,
-  StartDateAfterFilter,
-  StartDateBeforeFilter,
-  TargetDateAfterFilter,
-  TargetDateBeforeFilter,
-  UpdatedAfterFilter,
-  UpdatedBeforeFilter
-} from '../Filter';
 import { InvenTreeTable } from '../InvenTreeTable';
+import ReturnOrderFilters from './ReturnOrderFilters';
 
 export function ReturnOrderTable({
   partId,
@@ -75,46 +53,7 @@ export function ReturnOrderTable({
   const user = useUserState();
 
   const tableFilters: TableFilter[] = useMemo(() => {
-    const filters: TableFilter[] = [
+    return ReturnOrderFilters({ partId: partId, includeDateFilters: true });
-      OrderStatusFilter({ model: ModelType.returnorder }),
-      OutstandingFilter(),
-      OverdueFilter(),
-      AssignedToMeFilter(),
-      MinDateFilter(),
-      MaxDateFilter(),
-      CreatedBeforeFilter(),
-      CreatedAfterFilter(),
-      TargetDateBeforeFilter(),
-      TargetDateAfterFilter(),
-      StartDateBeforeFilter(),
-      StartDateAfterFilter(),
-      {
-        name: 'has_target_date',
-        type: 'boolean',
-        label: t`Has Target Date`,
-        description: t`Show orders with a target date`
-      },
-      {
-        name: 'has_start_date',
-        type: 'boolean',
-        label: t`Has Start Date`,
-        description: t`Show orders with a start date`
-      },
-      CompletedBeforeFilter(),
-      CompletedAfterFilter(),
-      UpdatedBeforeFilter(),
-      UpdatedAfterFilter(),
-      HasProjectCodeFilter(),
-      ProjectCodeFilter(),
-      ResponsibleFilter(),
-      CreatedByFilter()
-    ];
-
-    if (!!partId) {
-      filters.push(IncludeVariantsFilter());
-    }
-
-    return filters;
   }, [partId]);
 
   const tableColumns = useMemo(() => {

src/frontend/src/tables/sales/SalesOrderFilters.tsx

@@ -0,0 +1,73 @@
+import { ModelType } from '@lib/enums/ModelType';
+import type { TableFilter } from '@lib/types/Filters';
+import {
+  AssignedToMeFilter,
+  CompletedAfterFilter,
+  CompletedBeforeFilter,
+  CreatedAfterFilter,
+  CreatedBeforeFilter,
+  CreatedByFilter,
+  HasProjectCodeFilter,
+  HasStartDateFilter,
+  HasTargetDateFilter,
+  IncludeVariantsFilter,
+  MaxDateFilter,
+  MinDateFilter,
+  OrderStatusFilter,
+  OutstandingFilter,
+  OverdueFilter,
+  ProjectCodeFilter,
+  ResponsibleFilter,
+  StartDateAfterFilter,
+  StartDateBeforeFilter,
+  TargetDateAfterFilter,
+  TargetDateBeforeFilter,
+  UpdatedAfterFilter,
+  UpdatedBeforeFilter
+} from '../Filter';
+
+export default function SalesOrderFilters({
+  partId,
+  includeDateFilters = true
+}: {
+  partId?: number;
+  includeDateFilters?: boolean;
+}): TableFilter[] {
+  const filters: TableFilter[] = [
+    OrderStatusFilter({ model: ModelType.salesorder }),
+    OutstandingFilter(),
+    OverdueFilter(),
+    AssignedToMeFilter(),
+    HasProjectCodeFilter(),
+    ProjectCodeFilter(),
+    ResponsibleFilter(),
+    CreatedByFilter()
+  ];
+
+  const dateFilters: TableFilter[] = [
+    MinDateFilter(),
+    MaxDateFilter(),
+    CreatedBeforeFilter(),
+    CreatedAfterFilter(),
+    TargetDateBeforeFilter(),
+    TargetDateAfterFilter(),
+    StartDateBeforeFilter(),
+    StartDateAfterFilter(),
+    HasTargetDateFilter(),
+    HasStartDateFilter(),
+    CompletedBeforeFilter(),
+    CompletedAfterFilter(),
+    UpdatedBeforeFilter(),
+    UpdatedAfterFilter()
+  ];
+
+  if (includeDateFilters) {
+    filters.push(...dateFilters);
+  }
+
+  if (!!partId) {
+    filters.push(IncludeVariantsFilter());
+  }
+
+  return filters;
+}

src/frontend/src/tables/sales/SalesOrderParametricTable.tsx

@@ -9,15 +9,8 @@ import {
   DescriptionColumn,
   ReferenceColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter
-} from '../Filter';
 import ParametricDataTable from '../general/ParametricDataTable';
+import SalesOrderFilters from './SalesOrderFilters';
 
 export default function SalesOrderParametricTable({
   queryParams
@@ -40,14 +33,7 @@ export default function SalesOrderParametricTable({
   }, []);
 
   const customFilters: TableFilter[] = useMemo(() => {
-    return [
+    return SalesOrderFilters({ includeDateFilters: true });
-      OrderStatusFilter({ model: ModelType.salesorder }),
-      OutstandingFilter(),
-      OverdueFilter(),
-      AssignedToMeFilter(),
-      ProjectCodeFilter(),
-      ResponsibleFilter()
-    ];
   }, []);
 
   return (

src/frontend/src/tables/sales/SalesOrderTable.tsx

@@ -30,30 +30,8 @@ import {
   TargetDateColumn,
   UpdatedAtColumn
 } from '../ColumnRenderers';
-import {
-  AssignedToMeFilter,
-  CompletedAfterFilter,
-  CompletedBeforeFilter,
-  CreatedAfterFilter,
-  CreatedBeforeFilter,
-  CreatedByFilter,
-  HasProjectCodeFilter,
-  IncludeVariantsFilter,
-  MaxDateFilter,
-  MinDateFilter,
-  OrderStatusFilter,
-  OutstandingFilter,
-  OverdueFilter,
-  ProjectCodeFilter,
-  ResponsibleFilter,
-  StartDateAfterFilter,
-  StartDateBeforeFilter,
-  TargetDateAfterFilter,
-  TargetDateBeforeFilter,
-  UpdatedAfterFilter,
-  UpdatedBeforeFilter
-} from '../Filter';
 import { InvenTreeTable } from '../InvenTreeTable';
+import SalesOrderFilters from './SalesOrderFilters';
 
 export function SalesOrderTable({
   partId,
@@ -73,46 +51,7 @@ export function SalesOrderTable({
   const user = useUserState();
 
   const tableFilters: TableFilter[] = useMemo(() => {
-    const filters: TableFilter[] = [
+    return SalesOrderFilters({ partId: partId, includeDateFilters: true });
-      OrderStatusFilter({ model: ModelType.salesorder }),
-      OutstandingFilter(),
-      OverdueFilter(),
-      AssignedToMeFilter(),
-      MinDateFilter(),
-      MaxDateFilter(),
-      CreatedBeforeFilter(),
-      CreatedAfterFilter(),
-      TargetDateBeforeFilter(),
-      TargetDateAfterFilter(),
-      StartDateBeforeFilter(),
-      StartDateAfterFilter(),
-      {
-        name: 'has_target_date',
-        type: 'boolean',
-        label: t`Has Target Date`,
-        description: t`Show orders with a target date`
-      },
-      {
-        name: 'has_start_date',
-        type: 'boolean',
-        label: t`Has Start Date`,
-        description: t`Show orders with a start date`
-      },
-      CompletedBeforeFilter(),
-      CompletedAfterFilter(),
-      UpdatedBeforeFilter(),
-      UpdatedAfterFilter(),
-      HasProjectCodeFilter(),
-      ProjectCodeFilter(),
-      ResponsibleFilter(),
-      CreatedByFilter()
-    ];
-
-    if (!!partId) {
-      filters.push(IncludeVariantsFilter());
-    }
-
-    return filters;
   }, [partId]);
 
   const salesOrderFields = useSalesOrderFields({});