diff --git a/spp_registry_search/__init__.py b/spp_registry_search/__init__.py new file mode 100644 index 000000000..c4ccea794 --- /dev/null +++ b/spp_registry_search/__init__.py @@ -0,0 +1,3 @@ +# Part of OpenSPP. See LICENSE file for full copyright and licensing details. + +from . import models diff --git a/spp_registry_search/__manifest__.py b/spp_registry_search/__manifest__.py new file mode 100644 index 000000000..6a3865ba2 --- /dev/null +++ b/spp_registry_search/__manifest__.py @@ -0,0 +1,45 @@ +# Part of OpenSPP. See LICENSE file for full copyright and licensing details. + + +{ + "name": "OpenSPP Registry Search", + "category": "OpenSPP/OpenSPP", + "version": "17.0.1.0.0", + "sequence": 1, + "author": "OpenSPP.org", + "website": "https://github.com/OpenSPP/openspp-modules", + "license": "LGPL-3", + "development_status": "Beta", + "maintainers": ["jeremi", "gonzalesedwin1123", "emjay0921"], + "depends": [ + "base", + "g2p_registry_base", + "spp_base_common", + "g2p_registry_individual", + "g2p_registry_group", + ], + "excludes": [], + "external_dependencies": {}, + "data": [ + "security/ir.model.access.csv", + "data/partner_search_field_data.xml", + "data/partner_search_filter_data.xml", + "views/partner_search_field_view.xml", + "views/partner_search_filter_view.xml", + "views/partner_custom_search_view.xml", + ], + "assets": { + "web.assets_backend": [ + "spp_registry_search/static/src/js/partner_search_view.js", + "spp_registry_search/static/src/js/partner_search_widget.js", + "spp_registry_search/static/src/xml/partner_search_view.xml", + "spp_registry_search/static/src/xml/partner_search_widget.xml", + ], + }, + "demo": [], + "images": [], + "application": False, + "installable": True, + "auto_install": False, + "summary": "Provides advanced search capabilities for the OpenSPP Registry. Features include configurable search fields, dynamic field filtering by registrant type (Individual/Group), and an intuitive search interface with real-time results.", +} diff --git a/spp_registry_search/data/partner_search_field_data.xml b/spp_registry_search/data/partner_search_field_data.xml new file mode 100644 index 000000000..b69df364b --- /dev/null +++ b/spp_registry_search/data/partner_search_field_data.xml @@ -0,0 +1,30 @@ + + + + + + Name + + both + 10 + + + + + Email + + both + 20 + + + + + Phone + + both + 30 + + + diff --git a/spp_registry_search/data/partner_search_filter_data.xml b/spp_registry_search/data/partner_search_filter_data.xml new file mode 100644 index 000000000..9f5c64a52 --- /dev/null +++ b/spp_registry_search/data/partner_search_filter_data.xml @@ -0,0 +1,30 @@ + + + + + Female Registrants + 10 + individual + [('gender', '=', 'Female')] + Show only female individuals + + + + + Male Registrants + 20 + individual + [('gender', '=', 'Male')] + Show only male individuals + + + + + Archived Registrants + 90 + both + [('active', '=', False)] + Show only archived registrants + + + diff --git a/spp_registry_search/models/__init__.py b/spp_registry_search/models/__init__.py new file mode 100644 index 000000000..d32fa5249 --- /dev/null +++ b/spp_registry_search/models/__init__.py @@ -0,0 +1,5 @@ +# Part of OpenSPP. See LICENSE file for full copyright and licensing details. + +from . import partner_search_field +from . import partner_search_filter +from . import res_partner diff --git a/spp_registry_search/models/partner_search_field.py b/spp_registry_search/models/partner_search_field.py new file mode 100644 index 000000000..70c0ac715 --- /dev/null +++ b/spp_registry_search/models/partner_search_field.py @@ -0,0 +1,99 @@ +# Part of OpenSPP. See LICENSE file for full copyright and licensing details. + +import logging + +from odoo import api, fields, models + +_logger = logging.getLogger(__name__) + + +class PartnerSearchField(models.Model): + """Configuration model for managing searchable partner fields""" + + _name = "spp.partner.search.field" + _description = "Partner Search Field Configuration" + _order = "sequence, name" + + name = fields.Char( + string="Field Label", + required=True, + help="Display name for the field in the dropdown", + ) + field_id = fields.Many2one( + "ir.model.fields", + string="Field", + domain="[('model', '=', 'res.partner')]", + help="Partner field to be searchable", + ) + field_name = fields.Char( + string="Field Name", + related="field_id.name", + store=True, + readonly=True, + ) + field_type = fields.Selection( + string="Field Type", + related="field_id.ttype", + store=True, + readonly=True, + ) + target_type = fields.Selection( + [ + ("individual", "Individual"), + ("group", "Group"), + ("both", "Both"), + ], + string="Target Type", + default="both", + required=True, + help="Specify if this field is for Individuals, Groups, or Both", + ) + active = fields.Boolean( + default=True, + help="If unchecked, this field will not appear in the search dropdown", + ) + sequence = fields.Integer( + default=10, + help="Order in which fields appear in the dropdown", + ) + company_id = fields.Many2one( + "res.company", + string="Company", + default=lambda self: self.env.company, + required=False, + ) + + _sql_constraints = [ + ( + "unique_field_per_company", + "unique(field_id, company_id)", + "This field is already configured for this company!", + ), + ] + + @api.constrains("field_id") + def _check_field_type(self): + """Ensure only searchable field types are selected""" + searchable_types = [ + "char", + "text", + "selection", + "many2one", + "many2many", + "integer", + "float", + "date", + "datetime", + "boolean", + ] + for record in self: + if record.field_type not in searchable_types: + raise models.ValidationError(f"Field type '{record.field_type}' is not supported for searching.") + + def name_get(self): + """Custom name display""" + result = [] + for record in self: + name = f"{record.name} ({record.field_name})" + result.append((record.id, name)) + return result diff --git a/spp_registry_search/models/partner_search_filter.py b/spp_registry_search/models/partner_search_filter.py new file mode 100644 index 000000000..7d28601a4 --- /dev/null +++ b/spp_registry_search/models/partner_search_filter.py @@ -0,0 +1,64 @@ +# Part of OpenSPP. See LICENSE file for full copyright and licensing details. + +import logging + +from odoo import api, fields, models +from odoo.tools.safe_eval import safe_eval + +_logger = logging.getLogger(__name__) + + +class SPPPartnerSearchFilter(models.Model): + _name = "spp.partner.search.filter" + _description = "Partner Search Filter Configuration" + _order = "sequence, name" + + name = fields.Char(string="Filter Name", required=True, translate=True) + sequence = fields.Integer(default=10, help="Order of filter in dropdown") + active = fields.Boolean(default=True) + domain = fields.Text( + string="Domain", + required=True, + default="[]", + help="Domain filter in Python format, e.g., [('gender', '=', 'Female')]", + ) + target_type = fields.Selection( + [ + ("individual", "Individual"), + ("group", "Group"), + ("both", "Both"), + ], + string="Target Type", + required=True, + default="both", + help="Specify whether this filter applies to individuals, groups, or both", + ) + description = fields.Text(string="Description", translate=True) + company_id = fields.Many2one( + "res.company", + string="Company", + default=lambda self: self.env.company, + ) + + @api.constrains("domain") + def _check_domain(self): + """Validate that the domain is a valid Python expression""" + for record in self: + try: + domain = safe_eval(record.domain or "[]") + if not isinstance(domain, list): + raise ValueError("Domain must be a list") + except Exception as e: + from odoo.exceptions import ValidationError + + raise ValidationError(f"Invalid domain: {e}") from e + + def name_get(self): + """Custom name display""" + result = [] + for record in self: + name = record.name + if record.description: + name = f"{name} - {record.description}" + result.append((record.id, name)) + return result diff --git a/spp_registry_search/models/res_partner.py b/spp_registry_search/models/res_partner.py new file mode 100644 index 000000000..9be2eea1b --- /dev/null +++ b/spp_registry_search/models/res_partner.py @@ -0,0 +1,216 @@ +import json +import logging + +from odoo import api, models +from odoo.tools.safe_eval import safe_eval + +_logger = logging.getLogger(__name__) + + +class SPPResPartner(models.Model): + _inherit = "res.partner" + + @api.model + def search_by_field(self, field_name, search_value, is_group=False, filter_domain="[]"): # noqa: C901 + """ + Search partners by a specific field + :param field_name: The field name to search on + :param search_value: The value to search for (empty string for "search all") + :param is_group: Whether to search for groups (True) or individuals (False) + :param filter_domain: Additional filter domain in string format (e.g., "[('gender', '=', 'Female')]") + :return: List of matching partner IDs + """ + if not field_name: + return [] + + # Start with base domain + domain = [] + + # If search_value is provided, add field-specific search + if search_value: + # Get the field configuration + field_config = self.env["spp.partner.search.field"].search( + [("field_name", "=", field_name), ("active", "=", True)], limit=1 + ) + + if not field_config: + _logger.warning(f"Field {field_name} is not configured for searching") + return [] + + # Build the search domain based on field type + field_type = field_config.field_type + + if field_type in ["char", "text"]: + domain = [(field_name, "ilike", search_value)] + elif field_type in ["integer", "float"]: + try: + numeric_value = float(search_value) + domain = [(field_name, "=", numeric_value)] + except ValueError: + _logger.warning(f"Invalid numeric value: {search_value}") + return [] + elif field_type == "boolean": + bool_value = search_value.lower() in ["true", "1", "yes"] + domain = [(field_name, "=", bool_value)] + elif field_type == "selection": + domain = [(field_name, "=", search_value)] + elif field_type == "many2one": + # search_value should be the ID of the related record + try: + record_id = int(search_value) + domain = [(field_name, "=", record_id)] + except ValueError: + # Fallback to name search + domain = [(field_name + ".name", "ilike", search_value)] + elif field_type in ["date", "datetime"]: + domain = [(field_name, "=", search_value)] + else: + domain = [(field_name, "ilike", search_value)] + # If search_value is empty, we're doing a "search all" - no field-specific filter + + # Add partner type filter (is_group) + domain.append(("is_group", "=", is_group)) + + # Always filter by is_registrant = True + domain.append(("is_registrant", "=", True)) + + # Apply additional filter domain + include_archived = False + try: + # Parse JSON domain from frontend (comes as JSON string with lowercase true/false) + additional_domain = json.loads(filter_domain or "[]") + + if additional_domain and isinstance(additional_domain, list): + # Convert list format to tuple format for Odoo + # JSON: ["|", ["field", "=", value], ...] -> Odoo: ["|", ("field", "=", value), ...] + for condition in additional_domain: + if isinstance(condition, str): + # Domain operators like '|', '&', '!' + domain.append(condition) + elif isinstance(condition, list) and len(condition) >= 3: + # Regular domain condition + domain.append(tuple(condition)) + # Check if we're searching for archived records + if condition[0] == "active" and not condition[2]: + include_archived = True + else: + # If no filter domain, only show active records by default + domain.append(("active", "=", True)) + except Exception as e: + _logger.warning(f"Error applying filter domain: {e}") + # Default to active records on error + domain.append(("active", "=", True)) + + # Use with_context to include archived records if needed + if include_archived: + return self.with_context(active_test=False).search(domain).ids + return self.search(domain).ids + + @api.model + def get_searchable_fields(self, partner_type=None): + """ + Get list of searchable fields configured for partner search + :param partner_type: 'individual', 'group', or None for all + :return: List of dictionaries with field information + """ + domain = [("active", "=", True)] + + # Filter by target_type based on partner_type + if partner_type == "individual": + domain.append(("target_type", "in", ["individual", "both"])) + elif partner_type == "group": + domain.append(("target_type", "in", ["group", "both"])) + # If partner_type is None, return all active fields + + search_fields = self.env["spp.partner.search.field"].search(domain, order="sequence, name") + + result = [] + for field in search_fields: + field_info = { + "id": field.id, + "name": field.name, + "field_name": field.field_name, + "field_type": field.field_type, + "target_type": field.target_type, + } + + # Add relational field information + if field.field_type == "many2one": + # Get the related model + odoo_field = field.field_id + if odoo_field.relation: + field_info["relation"] = odoo_field.relation + field_info["relation_field"] = "name" # Default display field + + elif field.field_type == "selection": + # Get selection options + odoo_field = field.field_id + model = self.env[odoo_field.model] + field_obj = model._fields.get(odoo_field.name) + if field_obj and hasattr(field_obj, "selection"): + if callable(field_obj.selection): + selection_options = field_obj.selection(model) + else: + selection_options = field_obj.selection + field_info["selection"] = selection_options + + result.append(field_info) + + return result + + @api.model + def get_field_options(self, relation_model): + """ + Get options for a many2one field + :param relation_model: The model name to get records from + :return: List of tuples (id, name) + """ + try: + records = self.env[relation_model].search([], limit=200) + # Use name_get() which is more universal and returns [(id, name), ...] + return records.name_get() + except Exception as e: + _logger.error(f"Error loading options for {relation_model}: {e}") + return [] + + @api.model + def get_search_filters(self, partner_type=None): + """ + Get list of search filters configured for partner search + :param partner_type: 'individual', 'group', or None for all + :return: List of dictionaries with filter information + """ + + domain = [("active", "=", True)] + + # Filter by target_type based on partner_type + if partner_type == "individual": + domain.append(("target_type", "in", ["individual", "both"])) + elif partner_type == "group": + domain.append(("target_type", "in", ["group", "both"])) + # If partner_type is None, return all active filters + + filters = self.env["spp.partner.search.filter"].search(domain, order="sequence, name") + + result = [] + for f in filters: + # Convert Python domain to JSON-compatible format + try: + python_domain = safe_eval(f.domain or "[]") + # Convert tuples to lists for JSON compatibility + json_domain = json.dumps(python_domain) + except Exception as e: + _logger.warning(f"Error converting domain for filter {f.name}: {e}") + json_domain = "[]" + + result.append( + { + "id": f.id, + "name": f.name, + "domain": json_domain, + "description": f.description, + "target_type": f.target_type, + } + ) + + return result diff --git a/spp_registry_search/pyproject.toml b/spp_registry_search/pyproject.toml new file mode 100644 index 000000000..4231d0ccc --- /dev/null +++ b/spp_registry_search/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["whool"] +build-backend = "whool.buildapi" diff --git a/spp_registry_search/readme/README.rst b/spp_registry_search/readme/README.rst new file mode 100644 index 000000000..90413d0de --- /dev/null +++ b/spp_registry_search/readme/README.rst @@ -0,0 +1,111 @@ +====================== +OpenSPP Registry Search +====================== + +.. + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + !! This file is generated by oca-gen-addon-readme !! + !! changes will be overwritten. !! + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + !! source digest: sha256:TODO + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +.. |badge1| image:: https://img.shields.io/badge/maturity-Beta-yellow.png + :target: https://odoo-community.org/page/development-status + :alt: Beta +.. |badge2| image:: https://img.shields.io/badge/licence-LGPL--3-blue.png + :target: http://www.gnu.org/licenses/lgpl-3.0-standalone.html + :alt: License: LGPL-3 +.. |badge3| image:: https://img.shields.io/badge/github-OpenSPP%2Fopenspp--modules-lightgray.png?logo=github + :target: https://github.com/OpenSPP/openspp-modules/tree/17.0/spp_registry_search + :alt: OpenSPP/openspp-modules + +|badge1| |badge2| |badge3| + +This module provides advanced search capabilities for the OpenSPP Registry system. + +**Features:** + +* **Configurable Search Fields**: Administrators can configure which partner fields are searchable +* **Dynamic Field Filtering**: Search fields automatically filter based on registrant type (Individual/Group) +* **Target Type Support**: Fields can be configured for Individuals, Groups, or Both +* **Intuitive Search Interface**: User-friendly search form with real-time results +* **Type-Aware Search**: Different search strategies for different field types (text, numbers, dates, etc.) +* **Always Filters Registrants**: Automatically filters to only show registrants (is_registrant=True) + +**Table of contents** + +.. contents:: + :local: + +Configuration +============= + +To configure searchable fields: + +1. Go to **Settings → Administration → Partner Search Fields** +2. Click **Create** to add a new searchable field +3. Fill in: + + * **Field Label**: Display name for the field + * **Field**: Select the partner field + * **Target Type**: Individual, Group, or Both + * **Sequence**: Display order + * **Active**: Enable/disable the field + +4. Save the configuration + +Usage +===== + +To search for registrants: + +1. Navigate to **Registry → Registry Search** +2. Select **Registrant Type** (Individual or Group) +3. Select **Search By** field from the dropdown +4. Enter your **Search Value** +5. Press **Enter** or click **Search** +6. View results and click **Open** to access full records + +The search interface dynamically updates available fields based on the selected Registrant Type. + +Bug Tracker +=========== + +Bugs are tracked on `GitHub Issues `_. +In case of trouble, please check there if your issue has already been reported. +If you spotted it first, help us to smash it by providing a detailed and welcomed +`feedback `_. + +Do not contact contributors directly about support or help with technical issues. + +Credits +======= + +Authors +~~~~~~~ + +* OpenSPP.org + +Contributors +~~~~~~~~~~~~ + +* Jeremi Joslin +* Edwin Gonzales +* Emjay Rolusta + +Maintainers +~~~~~~~~~~~ + +This module is maintained by OpenSPP.org. + +.. image:: https://openspp.org/logo.png + :alt: OpenSPP + :target: https://openspp.org + +OpenSPP is a digital platform for social protection programs. + +This module is part of the `OpenSPP/openspp-modules `_ project on GitHub. + +You are welcome to contribute. + diff --git a/spp_registry_search/security/ir.model.access.csv b/spp_registry_search/security/ir.model.access.csv new file mode 100644 index 000000000..254e7e6db --- /dev/null +++ b/spp_registry_search/security/ir.model.access.csv @@ -0,0 +1,11 @@ +id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink + +spp_partner_search_field_read_access,Partner Search Field Read Access,model_spp_partner_search_field,spp_base_common.read_registry,1,0,0,0 +spp_partner_search_field_write_access,Partner Search Field Write Access,model_spp_partner_search_field,spp_base_common.write_registry,1,1,0,0 +spp_partner_search_field_create_access,Partner Search Field Create Access,model_spp_partner_search_field,spp_base_common.create_registry,1,1,1,0 +spp_partner_search_field_admin_access,Partner Search Field Admin Access,model_spp_partner_search_field,base.group_system,1,1,1,1 + +spp_partner_search_filter_read_access,Partner Search Filter Read Access,model_spp_partner_search_filter,spp_base_common.read_registry,1,0,0,0 +spp_partner_search_filter_write_access,Partner Search Filter Write Access,model_spp_partner_search_filter,spp_base_common.write_registry,1,1,0,0 +spp_partner_search_filter_create_access,Partner Search Filter Create Access,model_spp_partner_search_filter,spp_base_common.create_registry,1,1,1,0 +spp_partner_search_filter_admin_access,Partner Search Filter Admin Access,model_spp_partner_search_filter,base.group_system,1,1,1,1 diff --git a/spp_registry_search/static/description/icon.png b/spp_registry_search/static/description/icon.png new file mode 100644 index 000000000..c7dbdaaf1 Binary files /dev/null and b/spp_registry_search/static/description/icon.png differ diff --git a/spp_registry_search/static/src/js/partner_search_view.js b/spp_registry_search/static/src/js/partner_search_view.js new file mode 100644 index 000000000..0c765ad6e --- /dev/null +++ b/spp_registry_search/static/src/js/partner_search_view.js @@ -0,0 +1,577 @@ +/** @odoo-module **/ + +import {registry} from "@web/core/registry"; +import {Component, onWillStart, useState} from "@odoo/owl"; +import {useService} from "@web/core/utils/hooks"; + +export class PartnerSearchAction extends Component { + static template = "spp_registry_search.PartnerSearchAction"; + static props = ["*"]; + + setup() { + this.orm = useService("orm"); + this.action = useService("action"); + this.notification = useService("notification"); + + // Get context from action props + const context = this.props.action?.context || {}; + const defaultPartnerType = context.default_partner_type || "individual"; + this.hidePartnerType = context.hide_partner_type || false; + this.formViewRef = context.form_view_ref || null; + + this.state = useState({ + searchFields: [], + selectedField: "", + selectedFieldInfo: null, + searchValue: "", + fieldOptions: [], + partnerType: defaultPartnerType, + searching: false, + results: [], + showResults: false, + selectedIds: new Set(), + searchFilters: [], + selectedFilterIds: new Set(), + }); + + onWillStart(async () => { + await this.loadSearchFields(this.state.partnerType); + await this.loadSearchFilters(this.state.partnerType); + // Try to restore previous search state + await this.restoreSearchState(); + }); + } + + getSearchStateKey() { + // Create unique key per partner type + return `partner_search_state_${this.state.partnerType}`; + } + + saveSearchState() { + const searchState = { + selectedField: this.state.selectedField, + searchValue: this.state.searchValue, + partnerType: this.state.partnerType, + results: this.state.results, + showResults: this.state.showResults, + selectedIds: Array.from(this.state.selectedIds), + selectedFilterIds: Array.from(this.state.selectedFilterIds), + }; + sessionStorage.setItem(this.getSearchStateKey(), JSON.stringify(searchState)); + } + + async restoreSearchState() { + const savedState = sessionStorage.getItem(this.getSearchStateKey()); + if (savedState) { + try { + const state = JSON.parse(savedState); + // Only restore if the partner type matches + if (state.partnerType === this.state.partnerType) { + this.state.selectedField = state.selectedField || this.state.selectedField; + this.state.searchValue = state.searchValue || ""; + this.state.results = state.results || []; + this.state.showResults = state.showResults || false; + this.state.selectedIds = new Set(state.selectedIds || []); + this.state.selectedFilterIds = new Set(state.selectedFilterIds || []); + + // Restore field info and options for relational fields + if (this.state.selectedField) { + const fieldInfo = this.state.searchFields.find( + (f) => f.field_name === this.state.selectedField + ); + this.state.selectedFieldInfo = fieldInfo; + + if (fieldInfo) { + if (fieldInfo.field_type === "selection" && fieldInfo.selection) { + this.state.fieldOptions = fieldInfo.selection; + } else if (fieldInfo.field_type === "many2one" && fieldInfo.relation) { + try { + const options = await this.orm.call("res.partner", "get_field_options", [ + fieldInfo.relation, + ]); + this.state.fieldOptions = options; + } catch (error) { + console.error("Error loading field options during restore:", error); + } + } + } + } + } + } catch (error) { + console.error("Error restoring search state:", error); + } + } + } + + async loadSearchFields(partnerType = null) { + try { + const fields = await this.orm.call("res.partner", "get_searchable_fields", [partnerType]); + this.state.searchFields = fields; + if (fields.length > 0) { + this.state.selectedField = fields[0].field_name; + } else { + this.state.selectedField = ""; + } + } catch (error) { + console.error("Error loading searchable fields:", error); + } + } + + async loadSearchFilters(partnerType = null) { + try { + const filters = await this.orm.call("res.partner", "get_search_filters", [partnerType]); + this.state.searchFilters = filters; + // Don't auto-select any filters by default + this.state.selectedFilterIds.clear(); + } catch (error) { + console.error("Error loading search filters:", error); + } + } + + async onFieldChange(event) { + this.state.selectedField = event.target.value; + this.state.searchValue = ""; + this.state.fieldOptions = []; + + // Find the selected field info + const fieldInfo = this.state.searchFields.find((f) => f.field_name === this.state.selectedField); + this.state.selectedFieldInfo = fieldInfo; + + // Load options for relational fields + if (fieldInfo) { + if (fieldInfo.field_type === "selection" && fieldInfo.selection) { + // Selection field - options are already loaded + this.state.fieldOptions = fieldInfo.selection; + } else if (fieldInfo.field_type === "many2one" && fieldInfo.relation) { + // Many2one field - load options from related model + try { + const options = await this.orm.call("res.partner", "get_field_options", [ + fieldInfo.relation, + ]); + this.state.fieldOptions = options; + } catch (error) { + console.error("Error loading field options:", error); + } + } + } + } + + onSearchValueChange(event) { + this.state.searchValue = event.target.value; + } + + get isArchivedFilterSelected() { + // Check if any selected filter is for archived records + const selectedFilters = this.state.searchFilters.filter((f) => + this.state.selectedFilterIds.has(f.id) + ); + + return selectedFilters.some((filter) => { + try { + const domain = JSON.parse(filter.domain || "[]"); + // Check if domain contains active = False in any format + return domain.some((condition) => { + if (Array.isArray(condition) && condition.length === 3) { + return condition[0] === "active" && condition[1] === "=" && condition[2] === false; + } + return false; + }); + } catch (error) { + console.error("Error parsing filter domain for archive check:", error); + return false; + } + }); + } + + get combinedFilterDomain() { + // Combine all selected filter domains + const selectedFilters = this.state.searchFilters.filter((f) => + this.state.selectedFilterIds.has(f.id) + ); + + if (selectedFilters.length === 0) { + return "[]"; + } + + // Parse all filter domains + const parsedDomains = []; + for (const filter of selectedFilters) { + try { + const domain = JSON.parse(filter.domain || "[]"); + if (domain && domain.length > 0) { + parsedDomains.push(domain); + } + } catch (error) { + console.error("Error parsing filter domain:", error); + } + } + + if (parsedDomains.length === 0) { + return "[]"; + } + + // Single filter - just return it + if (parsedDomains.length === 1) { + return JSON.stringify(parsedDomains[0]); + } + + // Multiple filters - combine with OR logic + // Odoo domain syntax: ['|', cond1, cond2] for OR + // For n conditions, we need (n-1) '|' operators at the beginning + const combinedDomain = []; + + // Add (n-1) OR operators at the beginning + for (let i = 0; i < parsedDomains.length - 1; i++) { + combinedDomain.push("|"); + } + + // Add all conditions (flattened) + for (const domain of parsedDomains) { + for (const condition of domain) { + combinedDomain.push(condition); + } + } + + return JSON.stringify(combinedDomain); + } + + onFilterChange(event) { + // Handle multiple select + const selectedOptions = Array.from(event.target.selectedOptions); + this.state.selectedFilterIds.clear(); + + selectedOptions.forEach((option) => { + this.state.selectedFilterIds.add(parseInt(option.value)); + }); + } + + removeFilter(filterId) { + // Remove a specific filter from selection + this.state.selectedFilterIds.delete(filterId); + } + + async onPartnerTypeChange(event) { + this.state.partnerType = event.target.value; + // Reload fields and filters based on selected partner type + await this.loadSearchFields(this.state.partnerType); + await this.loadSearchFilters(this.state.partnerType); + // Clear search value when partner type changes + this.state.searchValue = ""; + this.state.showResults = false; + } + + async onSearch() { + // Only require selected field, allow empty search value + if (!this.state.selectedField) { + return; + } + + this.state.searching = true; + this.state.showResults = false; + try { + // Determine is_group value based on partner type + const isGroup = this.state.partnerType === "group"; + + let results = []; + + // Always use backend method for consistency + results = await this.orm.call("res.partner", "search_by_field", [ + this.state.selectedField, + this.state.searchValue || "", // Pass empty string for "search all" + isGroup, + this.combinedFilterDomain, + ]); + + if (results && results.length > 0) { + // Load partner details with proper context for archived records + const searchReadDomain = [["id", "in", results]]; + const searchReadFields = [ + "name", + "address", + "phone", + "tags_ids", + "birthdate", + "registration_date", + "is_group", + "active", + ]; + + if (this.isArchivedFilterSelected) { + // Use webSearchRead with context for archived records + this.state.results = await this.orm.call("res.partner", "search_read", [], { + domain: searchReadDomain, + fields: searchReadFields, + context: {active_test: false}, + }); + } else { + this.state.results = await this.orm.searchRead( + "res.partner", + searchReadDomain, + searchReadFields + ); + } + this.state.showResults = true; + // Clear previous selections + this.state.selectedIds.clear(); + + // Save search state to session storage + this.saveSearchState(); + } else { + this.state.results = []; + this.state.showResults = true; + this.state.selectedIds.clear(); + } + } catch (error) { + console.error("Error searching partners:", error); + } finally { + this.state.searching = false; + } + } + + onKeyPress(event) { + if (event.key === "Enter") { + this.onSearch(); + } + } + + async openPartner(partnerId, isGroup) { + // Save current search state before navigating + this.saveSearchState(); + + // Determine the correct form view based on partner type + let viewId = false; + + if (this.formViewRef) { + // Use the view reference from context + try { + const viewRef = await this.orm.call("ir.model.data", "xmlid_to_res_id", [this.formViewRef]); + viewId = viewRef || false; + } catch (error) { + console.error("Error resolving view reference:", error); + } + } else { + // Auto-detect based on partner type + const viewRefString = isGroup + ? "g2p_registry_group.view_groups_form" + : "g2p_registry_individual.view_individuals_form"; + + try { + viewId = await this.orm.call("ir.model.data", "xmlid_to_res_id", [viewRefString]); + } catch (error) { + console.error("Error resolving view reference:", error); + } + } + + await this.action.doAction({ + type: "ir.actions.act_window", + res_model: "res.partner", + res_id: partnerId, + views: [[viewId, "form"]], + target: "current", + context: { + form_view_ref: this.formViewRef, + }, + }); + } + + onClearSearch() { + this.state.searchValue = ""; + this.state.results = []; + this.state.showResults = false; + this.state.selectedIds.clear(); + this.state.selectedFilterIds.clear(); + // Clear saved state for current partner type + sessionStorage.removeItem(this.getSearchStateKey()); + } + + async onArchiveSelected() { + // Archive selected records + if (this.state.selectedIds.size === 0) { + return; + } + + const ids = Array.from(this.state.selectedIds); + + try { + // Call Odoo's action_archive method + await this.orm.call("res.partner", "action_archive", [ids]); + + // Refresh the search + await this.onSearch(); + + // Show success notification + this.notification.add(`${ids.length} record(s) archived successfully`, { + type: "success", + }); + } catch (error) { + console.error("Error archiving records:", error); + this.notification.add("Failed to archive records", { + type: "danger", + }); + } + } + + async onUnarchiveSelected() { + // Unarchive selected records + if (this.state.selectedIds.size === 0) { + return; + } + + const ids = Array.from(this.state.selectedIds); + + try { + // Call Odoo's action_unarchive method + await this.orm.call("res.partner", "action_unarchive", [ids]); + + // Refresh the search + await this.onSearch(); + + // Show success notification + this.notification.add(`${ids.length} record(s) unarchived successfully`, { + type: "success", + }); + } catch (error) { + console.error("Error unarchiving records:", error); + this.notification.add("Failed to unarchive records", { + type: "danger", + }); + } + } + + onRowClick(event, partnerId, isGroup) { + // Open the partner record + this.openPartner(partnerId, isGroup); + } + + onSelectRecord(recordId) { + if (this.state.selectedIds.has(recordId)) { + this.state.selectedIds.delete(recordId); + } else { + this.state.selectedIds.add(recordId); + } + } + + onSelectAll() { + this.state.selectedIds.clear(); + this.state.results.forEach((record) => { + this.state.selectedIds.add(record.id); + }); + } + + onDeselectAll() { + this.state.selectedIds.clear(); + } + + isSelected(recordId) { + return this.state.selectedIds.has(recordId); + } + + get hasSelections() { + return this.state.selectedIds.size > 0; + } + + get allSelected() { + return this.state.results.length > 0 && this.state.selectedIds.size === this.state.results.length; + } + + async onCreate() { + // Determine is_group value based on partner type + const isGroup = this.state.partnerType === "group"; + + // Determine the correct form view + let viewId = false; + + if (this.formViewRef) { + try { + viewId = await this.orm.call("ir.model.data", "xmlid_to_res_id", [this.formViewRef]); + } catch (error) { + console.error("Error resolving view reference:", error); + } + } else { + const viewRefString = isGroup + ? "g2p_registry_group.view_groups_form" + : "g2p_registry_individual.view_individuals_form"; + + try { + viewId = await this.orm.call("ir.model.data", "xmlid_to_res_id", [viewRefString]); + } catch (error) { + console.error("Error resolving view reference:", error); + } + } + + await this.action.doAction({ + type: "ir.actions.act_window", + res_model: "res.partner", + views: [[viewId, "form"]], + target: "current", + context: { + default_is_group: isGroup, + default_is_registrant: true, + form_view_ref: this.formViewRef, + }, + }); + } + + async onImport() { + // Determine is_group value based on partner type + const isGroup = this.state.partnerType === "group"; + + // Call Odoo's built-in import action + await this.action.doAction({ + type: "ir.actions.client", + tag: "import", + params: { + model: "res.partner", + context: { + default_is_group: isGroup, + default_is_registrant: true, + }, + }, + }); + } + + async onExport() { + // Check if there are selected records + if (this.state.selectedIds.size === 0) { + return; + } + + // Get the IDs of selected records + const ids = Array.from(this.state.selectedIds); + + // Save search state before export + this.saveSearchState(); + + // Determine is_group value and correct tree view + const isGroup = this.state.partnerType === "group"; + let treeViewId = false; + + const treeViewRefString = isGroup + ? "g2p_registry_group.view_groups_list_tree" + : "g2p_registry_individual.view_individuals_list_tree"; + + try { + treeViewId = await this.orm.call("ir.model.data", "xmlid_to_res_id", [treeViewRefString]); + } catch (error) { + console.error("Error resolving tree view reference:", error); + } + + // Open list view with filtered records + // User can then use Actions > Export from the list view + await this.action.doAction({ + type: "ir.actions.act_window", + name: isGroup ? "Export Groups" : "Export Individuals", + res_model: "res.partner", + views: [[treeViewId, "list"]], + view_mode: "list", + target: "current", + domain: [["id", "in", ids]], + context: { + default_is_group: isGroup, + default_is_registrant: true, + }, + }); + } +} + +registry.category("actions").add("partner_search_action", PartnerSearchAction); diff --git a/spp_registry_search/static/src/js/partner_search_widget.js b/spp_registry_search/static/src/js/partner_search_widget.js new file mode 100644 index 000000000..42294c2ba --- /dev/null +++ b/spp_registry_search/static/src/js/partner_search_widget.js @@ -0,0 +1,83 @@ +/** @odoo-module **/ + +import {Component, onWillStart, useState} from "@odoo/owl"; +import {registry} from "@web/core/registry"; +import {useService} from "@web/core/utils/hooks"; + +export class PartnerSearchWidget extends Component { + static template = "spp_registry_search.PartnerSearchWidget"; + + setup() { + this.orm = useService("orm"); + this.action = useService("action"); + this.state = useState({ + searchFields: [], + selectedField: "", + searchValue: "", + searching: false, + }); + + onWillStart(async () => { + await this.loadSearchFields(); + }); + } + + async loadSearchFields() { + try { + const fields = await this.orm.call("res.partner", "get_searchable_fields", []); + this.state.searchFields = fields; + if (fields.length > 0) { + this.state.selectedField = fields[0].field_name; + } + } catch (error) { + console.error("Error loading searchable fields:", error); + } + } + + onFieldChange(event) { + this.state.selectedField = event.target.value; + } + + onSearchValueChange(event) { + this.state.searchValue = event.target.value; + } + + async onSearch() { + if (!this.state.selectedField || !this.state.searchValue) { + return; + } + + this.state.searching = true; + try { + const results = await this.orm.call("res.partner", "search_by_field", [ + this.state.selectedField, + this.state.searchValue, + ]); + + // Open the partner list with the search results + await this.action.doAction({ + type: "ir.actions.act_window", + name: "Search Results", + res_model: "res.partner", + views: [ + [false, "list"], + [false, "form"], + ], + domain: [["id", "in", results]], + target: "current", + }); + } catch (error) { + console.error("Error searching partners:", error); + } finally { + this.state.searching = false; + } + } + + onKeyPress(event) { + if (event.key === "Enter") { + this.onSearch(); + } + } +} + +registry.category("actions").add("partner_search_widget", PartnerSearchWidget); diff --git a/spp_registry_search/static/src/xml/partner_search_view.xml b/spp_registry_search/static/src/xml/partner_search_view.xml new file mode 100644 index 000000000..7533fb538 --- /dev/null +++ b/spp_registry_search/static/src/xml/partner_search_view.xml @@ -0,0 +1,416 @@ + + + +
+
+ +
+
+
+
+

+ + Individual Search + + + Group Search + + + Registry Search + +

+
+
+
+ +
+ + +
+ +
+ + +
+
+ + +
+
+ + + + + + + + + +
+
+ +
+