450 lines
14 KiB
JavaScript
450 lines
14 KiB
JavaScript
import ApiUtils from "./apiUtils";
|
|
import { useErrorStore } from "./stores/errors";
|
|
|
|
const ZIPPOPOTAMUS_BASE_URL = "https://api.zippopotam.us/us";
|
|
// Proxy method for external API calls
|
|
const FRAPPE_PROXY_METHOD = "custom_ui.api.proxy.request";
|
|
// Estimate methods
|
|
const FRAPPE_UPSERT_ESTIMATE_METHOD = "custom_ui.api.db.estimates.upsert_estimate";
|
|
const FRAPPE_GET_ESTIMATES_METHOD = "custom_ui.api.db.estimates.get_estimate_table_data";
|
|
// Job methods
|
|
const FRAPPE_GET_JOBS_METHOD = "custom_ui.api.db.get_jobs";
|
|
const FRAPPE_UPSERT_JOB_METHOD = "custom_ui.api.db.jobs.upsert_job";
|
|
// Invoice methods
|
|
const FRAPPE_UPSERT_INVOICE_METHOD = "custom_ui.api.db.invoices.upsert_invoice";
|
|
// Warranty methods
|
|
const FRAPPE_GET_WARRANTY_CLAIMS_METHOD = "custom_ui.api.db.warranties.get_warranty_claims";
|
|
// On-Site Meeting methods
|
|
const FRAPPE_GET_WEEK_ONSITE_MEETINGS_METHOD =
|
|
"custom_ui.api.db.onsite_meetings.get_week_onsite_meetings";
|
|
const FRAPPE_GET_ONSITE_MEETINGS_METHOD = "custom_ui.api.db.onsite_meetings.get_onsite_meetings";
|
|
// Address methods
|
|
const FRAPPE_GET_ADDRESSES_METHOD = "custom_ui.api.db.addresses.get_addresses";
|
|
// Client methods
|
|
const FRAPPE_UPSERT_CLIENT_METHOD = "custom_ui.api.db.clients.upsert_client";
|
|
const FRAPPE_GET_CLIENT_STATUS_COUNTS_METHOD = "custom_ui.api.db.clients.get_client_status_counts";
|
|
const FRAPPE_GET_CLIENT_TABLE_DATA_METHOD = "custom_ui.api.db.clients.get_clients_table_data";
|
|
const FRAPPE_GET_CLIENT_METHOD = "custom_ui.api.db.clients.get_client";
|
|
const FRAPPE_GET_CLIENT_NAMES_METHOD = "custom_ui.api.db.clients.get_client_names";
|
|
|
|
class Api {
|
|
static async request(frappeMethod, args = {}) {
|
|
const errorStore = useErrorStore();
|
|
args = ApiUtils.toSnakeCaseObject(args);
|
|
const request = { method: frappeMethod, args };
|
|
console.log("DEBUG: API - Request Args: ", request);
|
|
try {
|
|
let response = await frappe.call(request);
|
|
response = ApiUtils.toCamelCaseObject(response);
|
|
response.method = frappeMethod;
|
|
console.log("DEBUG: API - Request Response: ", response);
|
|
if (response.message.status && response.message.status === "error") {
|
|
throw new Error(response.message.message);
|
|
}
|
|
return response.message.data;
|
|
} catch (error) {
|
|
console.error("ERROR: API - Request Error: ", error);
|
|
errorStore.setApiError("Frappe API", error.message || "API request error");
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
static async getAddressByFullAddress(fullAddress) {
|
|
return await this.request("custom_ui.api.db.addresses.get_address_by_full_address", {
|
|
full_address: fullAddress,
|
|
});
|
|
}
|
|
|
|
static async getQuotationItems() {
|
|
return await this.request("custom_ui.api.db.estimates.get_quotation_items");
|
|
}
|
|
|
|
static async getEstimateFromAddress(fullAddress) {
|
|
return await this.request("custom_ui.api.db.estimates.get_estimate_from_address", {
|
|
full_address: fullAddress,
|
|
});
|
|
}
|
|
|
|
static async getAddress(fullAddress) {
|
|
return await this.request("custom_ui.api.db.addresses.get_address", { fullAddress });
|
|
}
|
|
|
|
static async getContactsForAddress(fullAddress) {
|
|
return await this.request("custom_ui.api.db.addresses.get_contacts_for_address", {
|
|
fullAddress,
|
|
});
|
|
}
|
|
|
|
static async getEstimate(estimateName) {
|
|
return await this.request("custom_ui.api.db.estimates.get_estimate", {
|
|
estimate_name: estimateName,
|
|
});
|
|
}
|
|
|
|
static async getEstimateItems() {
|
|
return await this.request("custom_ui.api.db.estimates.get_estimate_items");
|
|
}
|
|
|
|
static async searchAddresses(searchTerm) {
|
|
const filters = {
|
|
full_address: ["like", `%${searchTerm}%`],
|
|
};
|
|
return await this.getAddresses(["full_address"], filters);
|
|
}
|
|
|
|
static async getAddresses(fields = ["*"], filters = {}) {
|
|
return await this.request(FRAPPE_GET_ADDRESSES_METHOD, { fields, filters });
|
|
}
|
|
|
|
static async getUnscheduledOnSiteMeetings() {
|
|
return await this.request(
|
|
"custom_ui.api.db.onsite_meetings.get_unscheduled_onsite_meetings",
|
|
);
|
|
}
|
|
|
|
static async getScheduledOnSiteMeetings(fields = ["*"], filters = {}) {
|
|
return await this.request(FRAPPE_GET_ONSITE_MEETINGS_METHOD, { fields, filters });
|
|
}
|
|
|
|
static async getWeekOnSiteMeetings(weekStart, weekEnd) {
|
|
return await this.request(FRAPPE_GET_WEEK_ONSITE_MEETINGS_METHOD, { weekStart, weekEnd });
|
|
}
|
|
|
|
static async updateOnSiteMeeting(name, data) {
|
|
return await this.request("custom_ui.api.db.onsite_meetings.update_onsite_meeting", {
|
|
name,
|
|
data,
|
|
});
|
|
}
|
|
|
|
static async createOnSiteMeeting(address, notes = "") {
|
|
return await this.request("custom_ui.api.db.onsite_meetings.create_onsite_meeting", {
|
|
address,
|
|
notes,
|
|
});
|
|
}
|
|
|
|
static async getClientStatusCounts(params = {}) {
|
|
return await this.request(FRAPPE_GET_CLIENT_STATUS_COUNTS_METHOD, params);
|
|
}
|
|
|
|
static async getClientDetails(clientName) {
|
|
return await this.request(FRAPPE_GET_CLIENT_METHOD, { clientName });
|
|
}
|
|
|
|
static async getJobDetails() {
|
|
const projects = await this.getDocsList("Project");
|
|
const data = [];
|
|
for (let prj of projects) {
|
|
let project = await this.getDetailedDoc("Project", prj.name);
|
|
const tableRow = {
|
|
name: project.name,
|
|
customInstallationAddress: project.custom_installation_address,
|
|
customer: project.customer,
|
|
status: project.status,
|
|
percentComplete: project.percent_complete,
|
|
};
|
|
data.push(tableRow);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
static async getServiceData() {
|
|
const data = DataUtils.dummyServiceData;
|
|
return data;
|
|
}
|
|
|
|
static async getRouteData() {
|
|
const data = DataUtils.dummyRouteData;
|
|
//const data = [];
|
|
const routes = getDocList("Pre-Built Routes");
|
|
for (const rt of routes) {
|
|
route = getDetailedDoc("Pre-Built Routes", rt.name);
|
|
let tableRow = {};
|
|
}
|
|
return data;
|
|
}
|
|
|
|
static async getWarrantyData() {
|
|
const data = await this.request(FRAPPE_GET_WARRANTY_CLAIMS_METHOD);
|
|
console.log("DEBUG: API - getWarrantyData result: ", data);
|
|
return data;
|
|
}
|
|
|
|
static async getTimesheetData() {
|
|
//const data = DataUtils.dummyTimesheetData;
|
|
const data = [];
|
|
const timesheets = await this.getDocsList("Timesheet");
|
|
for (const ts of timesheets) {
|
|
const timesheet = await this.getDetailedDoc("Timesheet", ts.name);
|
|
const tableRow = {
|
|
timesheetId: timesheet.name,
|
|
employee: timesheet.employee_name,
|
|
date: timesheet.date,
|
|
customer: timesheet.customer,
|
|
totalHours: timesheet.total_hours,
|
|
status: timesheet.status,
|
|
totalPay: timesheet.total_costing_amount,
|
|
};
|
|
console.log("Timesheet Row: ", tableRow);
|
|
data.push(tableRow);
|
|
}
|
|
console.log("DEBUG: API - getTimesheetData result: ", data);
|
|
return data;
|
|
}
|
|
|
|
static async getClient(clientName) {
|
|
return await this.request(FRAPPE_GET_CLIENT_METHOD, { clientName });
|
|
}
|
|
|
|
/**
|
|
* Get paginated client data with filtering and sorting
|
|
* @param {Object} paginationParams - Pagination parameters from store
|
|
* @param {Object} filters - Filter parameters from store
|
|
* @param {Object} sorting - Sorting parameters from store (optional)
|
|
* @returns {Promise<{data: Array, pagination: Object}>}
|
|
*/
|
|
static async getPaginatedClientDetails(paginationParams = {}, filters = {}, sortings = []) {
|
|
const { page = 0, pageSize = 10 } = paginationParams;
|
|
const result = await this.request(FRAPPE_GET_CLIENT_TABLE_DATA_METHOD, {
|
|
filters,
|
|
sortings,
|
|
page: page + 1,
|
|
pageSize,
|
|
});
|
|
return result;
|
|
}
|
|
|
|
static async getPaginatedEstimateDetails(paginationParams = {}, filters = {}, sorting = null) {
|
|
const { page = 0, pageSize = 10, sortField = null, sortOrder = null } = paginationParams;
|
|
|
|
// Use sorting from the dedicated sorting parameter first, then fall back to pagination params
|
|
const actualSortField = sorting?.field || sortField;
|
|
const actualSortOrder = sorting?.order || sortOrder;
|
|
|
|
const options = {
|
|
page: page + 1, // Backend expects 1-based pages
|
|
page_size: pageSize,
|
|
filters,
|
|
sorting:
|
|
actualSortField && actualSortOrder
|
|
? `${actualSortField} ${actualSortOrder === -1 ? "desc" : "asc"}`
|
|
: null,
|
|
for_table: true,
|
|
};
|
|
|
|
console.log("DEBUG: API - Sending estimate options to backend:", options);
|
|
|
|
const result = await this.request(FRAPPE_GET_ESTIMATES_METHOD, { options });
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get paginated job data with filtering and sorting
|
|
* @param {Object} paginationParams - Pagination parameters from store
|
|
* @param {Object} filters - Filter parameters from store
|
|
* @param {Object} sorting - Sorting parameters from store (optional)
|
|
* @returns {Promise<{data: Array, pagination: Object}>}
|
|
*/
|
|
static async getPaginatedJobDetails(paginationParams = {}, filters = {}, sorting = null) {
|
|
const { page = 0, pageSize = 10, sortField = null, sortOrder = null } = paginationParams;
|
|
|
|
// Use sorting from the dedicated sorting parameter first, then fall back to pagination params
|
|
const actualSortField = sorting?.field || sortField;
|
|
const actualSortOrder = sorting?.order || sortOrder;
|
|
|
|
const options = {
|
|
page: page + 1, // Backend expects 1-based pages
|
|
page_size: pageSize,
|
|
filters,
|
|
sorting:
|
|
actualSortField && actualSortOrder
|
|
? `${actualSortField} ${actualSortOrder === -1 ? "desc" : "asc"}`
|
|
: null,
|
|
for_table: true,
|
|
};
|
|
|
|
console.log("DEBUG: API - Sending job options to backend:", options);
|
|
|
|
const result = await this.request(FRAPPE_GET_JOBS_METHOD, { options });
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get paginated warranty claims data with filtering and sorting
|
|
* @param {Object} paginationParams - Pagination parameters from store
|
|
* @param {Object} filters - Filter parameters from store
|
|
* @param {Object} sorting - Sorting parameters from store (optional)
|
|
* @returns {Promise<{data: Array, pagination: Object}>}
|
|
*/
|
|
static async getPaginatedWarrantyData(paginationParams = {}, filters = {}, sorting = null) {
|
|
const { page = 0, pageSize = 10, sortField = null, sortOrder = null } = paginationParams;
|
|
|
|
// Use sorting from the dedicated sorting parameter first, then fall back to pagination params
|
|
const actualSortField = sorting?.field || sortField;
|
|
const actualSortOrder = sorting?.order || sortOrder;
|
|
|
|
const options = {
|
|
page: page + 1, // Backend expects 1-based pages
|
|
page_size: pageSize,
|
|
filters,
|
|
sorting:
|
|
actualSortField && actualSortOrder
|
|
? `${actualSortField} ${actualSortOrder === -1 ? "desc" : "asc"}`
|
|
: null,
|
|
for_table: true,
|
|
};
|
|
|
|
console.log("DEBUG: API - Sending warranty options to backend:", options);
|
|
|
|
const result = await this.request(FRAPPE_GET_WARRANTY_CLAIMS_METHOD, { options });
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Fetch a list of documents from a specific doctype.
|
|
*
|
|
* @param {String} doctype
|
|
* @param {string[]} fields
|
|
* @param {Object} filters
|
|
* @returns {Promise<Object[]>}
|
|
*/
|
|
static async getDocsList(
|
|
doctype,
|
|
fields = [],
|
|
filters = {},
|
|
page = 0,
|
|
start = 0,
|
|
pageLength = 0,
|
|
) {
|
|
const docs = await frappe.db.get_list(doctype, {
|
|
fields,
|
|
filters,
|
|
start: start,
|
|
limit: pageLength,
|
|
});
|
|
console.log(
|
|
`DEBUG: API - Fetched ${doctype} list (page ${page + 1}, start ${start}): `,
|
|
docs,
|
|
);
|
|
return docs;
|
|
}
|
|
|
|
/**
|
|
* Fetch a detailed document by doctype and name.
|
|
*
|
|
* @param {String} doctype
|
|
* @param {String} name
|
|
* @param {Object} filters
|
|
* @returns {Promise<Object>}
|
|
*/
|
|
static async getDetailedDoc(doctype, name, filters = {}) {
|
|
const doc = await frappe.db.get_doc(doctype, name, filters);
|
|
console.log(`DEBUG: API - Fetched Detailed ${doctype}: `, doc);
|
|
return doc;
|
|
}
|
|
|
|
static async getDocCount(doctype, filters = {}) {
|
|
const count = await frappe.db.count(doctype, filters);
|
|
console.log(`DEBUG: API - Counted ${doctype}: `, count);
|
|
return count;
|
|
}
|
|
|
|
static async createDoc(doctype, data) {
|
|
const doc = await frappe.db.insert({
|
|
...data,
|
|
doctype,
|
|
});
|
|
console.log(`DEBUG: API - Created ${doctype}: `, doc);
|
|
return doc;
|
|
}
|
|
|
|
static async getCustomerNames(type) {
|
|
return await this.request(FRAPPE_GET_CLIENT_NAMES_METHOD, { type });
|
|
}
|
|
|
|
static async getClientNames(clientName) {
|
|
return await this.request(FRAPPE_GET_CLIENT_NAMES_METHOD, { searchTerm: clientName });
|
|
}
|
|
|
|
static async searchClientNames(searchTerm) {
|
|
return await this.request("custom_ui.api.db.clients.search_client_names", { searchTerm });
|
|
}
|
|
|
|
static async getCompanyNames() {
|
|
const companies = await this.getDocsList("Company", ["name"]);
|
|
const companyNames = companies.map((company) => company.name);
|
|
console.log("DEBUG: API - Fetched Company Names: ", companyNames);
|
|
return companyNames;
|
|
}
|
|
|
|
// Create methods
|
|
|
|
static async createClient(clientData) {
|
|
const result = await this.request(FRAPPE_UPSERT_CLIENT_METHOD, { data: clientData });
|
|
console.log("DEBUG: API - Created/Updated Client: ", result);
|
|
return result;
|
|
}
|
|
|
|
static async createEstimate(estimateData) {
|
|
const result = await this.request(FRAPPE_UPSERT_ESTIMATE_METHOD, { data: estimateData });
|
|
return result;
|
|
}
|
|
|
|
static async createJob(jobData) {
|
|
const payload = DataUtils.toSnakeCaseObject(jobData);
|
|
const result = await this.request(FRAPPE_UPSERT_JOB_METHOD, { data: payload });
|
|
console.log("DEBUG: API - Created Job: ", result);
|
|
return result;
|
|
}
|
|
|
|
static async createInvoice(invoiceData) {
|
|
const payload = DataUtils.toSnakeCaseObject(invoiceData);
|
|
const result = await this.request(FRAPPE_UPSERT_INVOICE_METHOD, { data: payload });
|
|
console.log("DEBUG: API - Created Invoice: ", result);
|
|
return result;
|
|
}
|
|
|
|
static async createWarranty(warrantyData) {
|
|
const payload = DataUtils.toSnakeCaseObject(warrantyData);
|
|
const result = await this.request(FRAPPE_UPSERT_INVOICE_METHOD, { data: payload });
|
|
console.log("DEBUG: API - Created Warranty: ", result);
|
|
return result;
|
|
}
|
|
|
|
// External API calls
|
|
|
|
/**
|
|
* Fetch a list of places (city/state) by zipcode using Zippopotamus API.
|
|
*
|
|
* @param {String} zipcode
|
|
* @returns {Promise<Object[]>}
|
|
*/
|
|
static async getCityStateByZip(zipcode) {
|
|
const url = `${ZIPPOPOTAMUS_BASE_URL}/${zipcode}`;
|
|
const response = await this.request(FRAPPE_PROXY_METHOD, { url, method: "GET" });
|
|
const { places } = response || {};
|
|
if (!places || places.length === 0) {
|
|
throw new Error(`No location data found for zip code ${zipcode}`);
|
|
}
|
|
return places.map((place) => ({
|
|
city: place["place name"],
|
|
state: place["state abbreviation"],
|
|
}));
|
|
}
|
|
|
|
static async getGeocode(address) {
|
|
const urlSafeAddress = encodeURIComponent(address);
|
|
const url = `https://nominatim.openstreetmap.org/search?format=jsonv2&q=${urlSafeAddress}`;
|
|
const response = await this.request(FRAPPE_PROXY_METHOD, {
|
|
url,
|
|
method: "GET",
|
|
headers: { "User-Agent": "FrappeApp/1.0 (+https://yourappdomain.com)" },
|
|
});
|
|
const { lat, lon } = response[0] || {};
|
|
return { latitude: parseFloat(lat), longitude: parseFloat(lon) };
|
|
}
|
|
}
|
|
|
|
export default Api;
|