def execute_bloomtrace_integration_request():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
pending_requests = frappe.get_all("Integration Request",
filters={
"status":
["IN", ["Queued", "Failed"]],
"reference_doctype":
"Plant",
"integration_request_service":
"BloomTrace"
},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request",
request.name)
plant = frappe.get_doc("Plant", integration_request.reference_docname)
bloomtrace_plant = frappe_client.get_doc(
"Plant", filters={"label": integration_request.reference_docname})
try:
if not bloomtrace_plant:
insert_plant(plant, frappe_client)
else:
update_plant(plant, frappe_client, bloomtrace_plant)
integration_request.error = ""
integration_request.status = "Completed"
integration_request.save(ignore_permissions=True)
except Exception as e:
integration_request.error = cstr(frappe.get_traceback())
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def execute_bloomtrace_integration_request():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
pending_requests = frappe.get_all("Integration Request",
filters={
"status":
["IN", ["Queued", "Failed"]],
"reference_doctype":
"Delivery Note",
"integration_request_service":
"BloomTrace"
},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request",
request.name)
delivery_note = frappe.get_doc("Delivery Note",
integration_request.reference_docname)
try:
insert_transfer_template(delivery_note, frappe_client)
integration_request.error = ""
integration_request.status = "Completed"
integration_request.save(ignore_permissions=True)
except Exception as e:
integration_request.error = cstr(e)
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def execute_bloomtrace_integration_request():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
site_url = get_host_name()
pending_requests = frappe.get_all("Integration Request",
filters={
"status":
["IN", ["Queued", "Failed"]],
"reference_doctype":
"User",
"integration_request_service":
"BloomTrace"
},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request",
request.name)
user = frappe.get_doc("User", integration_request.reference_docname)
try:
insert_bloomstack_site_user(user, site_url, frappe_client)
integration_request.error = ""
integration_request.status = "Completed"
except Exception as e:
integration_request.error = cstr(frappe.get_traceback())
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def execute_bloomtrace_integration_request():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
pending_requests = frappe.get_all("Integration Request",
filters={"status": ["IN", ["Queued", "Failed"]], "reference_doctype": "Stock Reconciliation", "integration_request_service": "BloomTrace"},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request", request.name)
stock_reconciliation = frappe.get_doc("Stock Reconciliation", integration_request.reference_docname)
bloomtrace_uid_transaction_log = frappe_client.get_doc("UID Transaction Log", integration_request.reference_docname)
try:
if not bloomtrace_uid_transaction_log:
insert_uid_transaction_log(stock_reconciliation, frappe_client)
else:
update_uid_transaction_log(stock_reconciliation, frappe_client)
integration_request.error = ""
integration_request.status = "Completed"
integration_request.save(ignore_permissions=True)
except Exception as e:
integration_request.error = cstr(e)
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def execute_bloomtrace_integration_request_for_stock_entry():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
pending_requests = frappe.get_all("Integration Request",
filters={
"status":
["IN", ["Queued", "Failed"]],
"reference_doctype":
"Stock Entry",
"integration_request_service":
"BloomTrace"
},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request",
request.name)
stock_entry = frappe.get_doc("Stock Entry",
integration_request.reference_docname)
try:
package = build_stock_payload(stock_entry)
frappe_client.insert(package)
integration_request.error = ""
integration_request.status = "Completed"
except Exception as e:
integration_request.error = cstr(e)
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def sync_bloomtrace(compliance_settings, method):
if not compliance_settings.is_compliance_enabled:
return
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
site_url = get_host_name()
frappe_client.update({
"doctype":
"Bloomstack Site",
"name":
site_url,
"metrc_url":
compliance_settings.metrc_url,
"metrc_user_key":
compliance_settings.get_password("metrc_user_key"),
"metrc_push_data":
compliance_settings.metrc_push_data,
"metrc_pull_data":
compliance_settings.metrc_pull_data,
"pull_incoming_transfer":
compliance_settings.pull_incoming_transfer
})
def sync_with_bloomtrace():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
site_url = get_host_name()
clear_bloomstack_site_users(frappe_client, site_url)
make_bloomstack_site_users()
clear_bloomstack_site_licenses(frappe_client, site_url)
make_bloomstack_site_licenses(frappe_client, site_url)
def fetch_license_types_from_bloomtrace():
frappe_client = get_bloomtrace_client()
if not frappe_client:
frappe.throw(_("Bloomtrace Integration is disabled."))
doc = frappe_client.get_doc("DocType", "License Info")
for field in doc.get("fields", []):
if field.get("fieldname") == "license_type":
frappe.cache().hset("cannabis", "license_type", field.get("options"))
return frappe.cache().hget("cannabis", "license_type")
def execute_bloomtrace_integration_request():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
pending_requests = frappe.get_all("Integration Request",
filters={
"status":
["IN", ["Queued", "Failed"]],
"reference_doctype":
"Delivery Note",
"integration_request_service":
"BloomTrace"
},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request",
request.name)
delivery_note = frappe.get_doc("Delivery Note",
integration_request.reference_docname)
try:
error, status = "", "Completed"
if integration_request.endpoint == "Package":
if not delivery_note.is_return:
insert_delivery_payload(delivery_note, frappe_client)
else:
error, status = "Delivery Note is marked as return", "Failed"
if integration_request.endpoint == "Transfer":
if delivery_note.lr_no or (delivery_note.estimated_arrival
and delivery_note.departure_time):
# If delivery trip is created or estimated_arrival and departure_time is present, only then move forward to integrate with BloomTrace
insert_transfer_template(delivery_note, frappe_client)
else:
error, status = "Delivery Trip / Estimated Departure / Estimated Arrival is missing", "Failed"
integration_request.error = error
integration_request.status = status
integration_request.save(ignore_permissions=True)
except Exception as e:
integration_request.error = cstr(frappe.get_traceback())
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def sync_bloomtrace(compliance_settings, method):
if not compliance_settings.is_compliance_enabled:
return
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
site_url = get_host_name()
try:
frappe_client.update({
"doctype":
"Bloomstack Site",
"name":
site_url,
"metrc_user_key":
compliance_settings.get_password("metrc_user_key")
})
except Exception as e:
frappe.log_error(e)
for company in compliance_settings.company:
try:
frappe_client.update({
"doctype": "Bloomstack Company",
"name": company.company,
"push_item": company.push_item,
"pull_item": company.pull_item,
"push_package_tag": company.push_package_tag,
"pull_package_tag": company.pull_package_tag,
"pull_transfer": company.pull_transfer,
"push_transfer": company.push_transfer,
"pull_plant": company.pull_plant,
"push_plant": company.push_plant,
"pull_plant_batch": company.pull_plant_batch,
"push_plant_batch": company.push_plant_batch,
"pull_strain": company.pull_strain,
"push_strain": company.push_strain,
"pull_harvest": company.pull_harvest,
"push_harvest": company.push_harvest,
"pull_package": company.pull_package,
"push_package": company.push_package
})
except Exception as e:
frappe.log_error(e)
def create_bloomtrace_license(compliance_info, method):
frappe_client = get_bloomtrace_client()
if not frappe_client or compliance_info.synced_from_bloomtrace:
return
license_info = frappe_client.get_doc("License Info", compliance_info.license_number)
if not license_info:
frappe.msgprint(_("License Number not found in our database. Proceed with Caution."))
else:
compliance_info.status = license_info.get("status")
compliance_info.license_issuer = license_info.get('issued_by')
compliance_info.license_type = license_info.get('license_type')
compliance_info.license_category = license_info.get('license_category')
compliance_info.license_expiry_date = license_info.get('expiration_date')
compliance_info.license_for = license_info.get('license_for')
compliance_info.legal_name = license_info.get('legal_name')
compliance_info.county = license_info.get('county')
compliance_info.city = license_info.get('city')
make_bloomstack_site_license(frappe_client, compliance_info, compliance_info.license_number, 'Active')
def get_all_licenses(filters, limit_start=0, limit_page_length=21):
frappe_client = get_bloomtrace_client()
if not frappe_client:
frappe.throw(_("Bloomtrace Integration is disabled."))
condition_map = {
"zip_code": {
"condition": "=",
"pattern": "{}"
},
"license_type": {
"condition": "=",
"pattern": "{}"
},
"legal_name": {
"condition": "like",
"pattern": "%{}%"
}
}
license_filters = {}
filters = json.loads(filters)
for key, value in filters.items():
license_filters.update({
key: [condition_map.get(key).get("condition"), condition_map.get(key).get("pattern").format(value)]
})
params = {
"cmd": "bloomtrace.bloomtrace.doctype.license_info.license_info.get_licenses",
"filters": license_filters,
"fields": ["legal_name", "zip_code", "license_type", "county", "city", "license_number", "email_id", "expiration_date", "status"],
"limit_start": limit_start,
"limit_page_length": limit_page_length
}
try:
r = frappe_client.post_request(params)
return r
except Exception as e:
frappe.log_error(e)
frappe.throw(_("Couldn't connect to BloomTrace."))
def execute_bloomtrace_integration_request_for_delivery_note():
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
pending_requests = frappe.get_all("Integration Request",
filters={
"status":
["IN", ["Queued", "Failed"]],
"reference_doctype":
"Delivery Note",
"integration_request_service":
"BloomTrace"
},
order_by="creation ASC",
limit=50)
for request in pending_requests:
integration_request = frappe.get_doc("Integration Request",
request.name)
delivery_note = frappe.get_doc("Delivery Note",
integration_request.reference_docname)
for item in delivery_note.items:
if not frappe.db.get_value(
"Item", item.item_code,
"is_compliance_item") or not item.package_tag:
continue
try:
package = build_delivery_payload(delivery_note, item)
frappe_client.insert(package)
integration_request.error = ""
integration_request.status = "Completed"
except Exception as e:
integration_request.error = cstr(e)
integration_request.status = "Failed"
integration_request.save(ignore_permissions=True)
def sync_bloomtrace(compliance_settings, method):
if not compliance_settings.is_compliance_enabled:
return
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
site_url = get_host_name()
frappe_client.update({"doctype": "Bloomstack Site", "name": site_url})
for company in compliance_settings.company:
frappe_client.update({
"doctype":
"Bloomstack Company",
"name":
company.company,
"metrc_push_data":
company.push_data,
"metrc_pull_data":
company.pull_data,
"pull_incoming_transfer":
company.pull_incoming_transfer
})
def get_all_licenses(page_number, per_page, filters):
frappe_client = get_bloomtrace_client()
if not frappe_client:
return
key_map = {
"zip": {
"key": "zip_code",
"operator": "=",
"pattern": "{}"
},
"licenseType": {
"key": "license_type",
"operator": "=",
"pattern": "{}"
},
"search": {
"key": "legal_name",
"operator": "like",
"pattern": "%{}%"
}
}
and_filters = {}
filters = json.loads(filters)
for f in filters:
if filters[f] == "":
continue
and_filters[key_map[f]["key"]] = [
key_map[f]["operator"], key_map[f]["pattern"].format(filters[f])
]
fields = [
"legal_name", "zip_code", "license_type", "status", "county", "city",
"license_number", "email_id", "expiration_date", "business_structure",
"business_owner", "license_for"
]
limit_start = (int(page_number) - 1) * int(per_page)
license_info = frappe_client.get_list("License Info",
fields=fields,
filters=and_filters,
limit_start=limit_start,
limit_page_length=per_page)
total_licenses = frappe_client.post_api("frappe.client.get_count", {
"doctype": "License Info",
"filters": and_filters
})
license_doc = frappe_client.get_doc("DocType", "License Info")
for field in license_doc["fields"]:
if field["fieldname"] == 'license_type':
license_types = field["options"].splitlines()
return {
"license_info": license_info,
"total_count": total_licenses,
"license_types": license_types
}
