big updates

custom_ui/api/db/addresses.py

@@ -0,0 +1,28 @@
+import frappe
+from custom_ui.db_utils import build_error_response, build_success_response
+
+@frappe.whitelist()
+def get_addresses(fields=["*"], filters={}):
+    """Get addresses with optional filtering."""
+    if isinstance(fields, str):
+        import json
+        fields = json.loads(fields)
+    if isinstance(filters, str):
+        import json
+        filters = json.loads(filters)
+    if fields[0] != "*" and len(fields) == 1:
+        pluck = fields[0]
+        fields = None
+    print(f"Getting addresses with fields: {fields} and filters: {filters} and pluck: {pluck}")
+    try:
+        addresses = frappe.get_all(
+            "Address",
+            fields=fields,
+            filters=filters,
+            order_by="address_line1 desc",
+            pluck=pluck
+        )
+        return build_success_response(addresses)
+    except Exception as e:
+        frappe.log_error(message=str(e), title="Get Addresses Failed")
+        return build_error_response(str(e), 500)

custom_ui/api/db/clients.py

@@ -269,7 +269,9 @@ def upsert_client(data):
         
         # Check for existing address
         filters = {
-            "address_title": data.get("address_title"),
+            "address_line1": data.get("address_line1"),
+            "city": data.get("city"),
+            "state": data.get("state"),
         }
         existing_address = frappe.db.exists("Address", filters)
         print("Existing address check:", existing_address)
@@ -280,10 +282,10 @@ def upsert_client(data):
         address_doc = frappe.get_doc({
             "doctype": "Address",
             "address_line1": data.get("address_line1"),
+            "address_line2": data.get("address_line2"),
             "city": data.get("city"),
             "state": data.get("state"),
             "country": "United States",
-            "address_title": data.get("address_title"),
             "pincode": data.get("pincode"),
             "custom_customer_to_bill": customer_doc.name
         }).insert(ignore_permissions=True)

custom_ui/api/db/onsite_meetings.py

@@ -0,0 +1,130 @@
+import frappe
+import json
+from custom_ui.db_utils import build_error_response, build_success_response, process_filters, process_sorting
+
+@frappe.whitelist()
+def get_week_onsite_meetings(week_start, week_end):
+    """Get On-Site Meetings scheduled within a specific week."""
+    try:
+        meetings = frappe.db.get_all(
+            "On-Site Meeting",
+            fields=["*"],
+            filters=[
+                ["start_time", ">=", week_start],
+                ["start_time", "<=", week_end]
+            ],
+            order_by="start_time asc"
+        )
+        return build_success_response(meetings)
+    except Exception as e:
+        frappe.log_error(message=str(e), title="Get Week On-Site Meetings Failed")
+        return build_error_response(str(e), 500)
+
+@frappe.whitelist()
+def get_onsite_meetings(fields=["*"], filters={}):
+    """Get paginated On-Site Meetings with filtering and sorting support."""
+    try:
+        print("DEBUG: Raw onsite meeting options received:", filters)
+        
+        processed_filters = process_filters(filters)
+        
+        meetings = frappe.db.get_all(
+            "On-Site Meeting",
+            fields=fields,
+            filters=processed_filters,
+            order_by="creation desc"
+        )
+        
+        return build_success_response(
+            meetings
+        )
+    except Exception as e:
+        frappe.log_error(message=str(e), title="Get On-Site Meetings Failed")
+        return build_error_response(str(e), 500)
+    
+
+@frappe.whitelist()
+def get_unscheduled_onsite_meetings():
+    """Get On-Site Meetings that are unscheduled."""
+    try:
+        meetings = frappe.db.get_all(
+            "On-Site Meeting",
+            fields=["*"],
+            filters={"status": "Unscheduled"},
+            order_by="creation desc"
+        )
+        return build_success_response(meetings)
+    except Exception as e:
+        frappe.log_error(message=str(e), title="Get Unscheduled On-Site Meetings Failed")
+        return build_error_response(str(e), 500)
+    
+
+@frappe.whitelist()
+def create_onsite_meeting(address, notes=""):
+    """Create a new On-Site Meeting with Unscheduled status."""
+    try:
+        print(f"DEBUG: Creating meeting with address='{address}', notes='{notes}'")
+        
+        # Validate address parameter
+        if not address or address == "None" or not address.strip():
+            return build_error_response("Address is required and cannot be empty.", 400)
+        
+        # Get the address document name from the full address string
+        address_name = frappe.db.get_value("Address", filters={"full_address": address}, fieldname="name")
+        
+        print(f"DEBUG: Address lookup result: address_name='{address_name}'")
+        
+        if not address_name:
+            return build_error_response(f"Address '{address}' not found in the system.", 404)
+        
+        # Create the meeting with Unscheduled status
+        meeting = frappe.get_doc({
+            "doctype": "On-Site Meeting",
+            "address": address_name,
+            "notes": notes or "",
+            "status": "Unscheduled"
+        })
+        meeting.flags.ignore_permissions = True
+        meeting.insert(ignore_permissions=True)
+        frappe.db.commit()
+        
+        # Clear any auto-generated messages from Frappe
+        frappe.local.message_log = []
+        
+        print(f"DEBUG: Meeting created successfully: {meeting.name}")
+        
+        return build_success_response(meeting.as_dict())
+    except Exception as e:
+        frappe.log_error(message=str(e), title="Create On-Site Meeting Failed")
+        return build_error_response(str(e), 500)
+    
+@frappe.whitelist()
+def update_onsite_meeting(name, data):
+    """Update an existing On-Site Meeting."""
+    defualts = {
+        "address": None,
+        "start_time": None,
+        "end_time": None,
+        "notes": None,
+        "assigned_employee": None,
+        "completed_by": None
+    }
+    try:
+        if isinstance(data, str):
+            data = json.loads(data)
+            data = {**defualts, **data}
+        meeting = frappe.get_doc("On-Site Meeting", name)
+        for key, value in data.items():
+            if value is not None:
+                if key == "address":
+                    value = frappe.db.get_value("Address", {"full_address": value}, "name")
+                elif key in ["assigned_employee", "completed_by"]:
+                    value = frappe.db.get_value("Employee", {"employee_name": value}, "name")
+                meeting.set(key, value)
+        meeting.save()
+        return build_success_response(meeting.as_dict())
+    except frappe.DoesNotExistError:
+        return build_error_response(f"On-Site Meeting '{name}' does not exist.", 404)
+    except Exception as e:
+        return build_error_response(str(e), 500)
+