def handle_exception(e):
response = None
http_status_code = getattr(e, "http_status_code", 500)
return_as_message = False
if frappe.get_request_header('Accept') and (frappe.local.is_ajax or 'application/json' in frappe.get_request_header('Accept')):
# handle ajax responses first
# if the request is ajax, send back the trace or error message
response = frappe.utils.response.report_error(http_status_code)
elif (http_status_code==500
and (frappe.db and isinstance(e, frappe.db.InternalError))
and (frappe.db and (frappe.db.is_deadlocked(e) or frappe.db.is_timedout(e)))):
http_status_code = 508
elif http_status_code==401:
frappe.respond_as_web_page(_("Session Expired"),
_("Your session has expired, please login again to continue."),
http_status_code=http_status_code, indicator_color='red')
return_as_message = True
elif http_status_code==403:
frappe.respond_as_web_page(_("Not Permitted"),
_("You do not have enough permissions to complete the action"),
http_status_code=http_status_code, indicator_color='red')
return_as_message = True
elif http_status_code==404:
frappe.respond_as_web_page(_("Not Found"),
_("The resource you are looking for is not available"),
http_status_code=http_status_code, indicator_color='red')
return_as_message = True
else:
traceback = "<pre>"+frappe.get_traceback()+"</pre>"
if frappe.local.flags.disable_traceback:
traceback = ""
frappe.respond_as_web_page("Server Error",
traceback, http_status_code=http_status_code,
indicator_color='red', width=640)
return_as_message = True
if e.__class__ == frappe.AuthenticationError:
if hasattr(frappe.local, "login_manager"):
frappe.local.login_manager.clear_cookies()
if http_status_code >= 500:
if not frappe.conf.developer_mode:
for fn in frappe.get_hooks("exception_handlers"):
frappe.get_attr(fn)()
frappe.logger().error('Request Error', exc_info=True)
make_error_snapshot(e)
if return_as_message:
response = frappe.website.render.render("message",
http_status_code=http_status_code)
return response
def sync(self):
"""Create and execute Data Migration Run for Mautic Sync plan"""
frappe.has_permission('Mautic Settings', throw=True)
exists = frappe.db.exists(
'Data Migration Run',
dict(status=('in', ['Fail', 'Error']), name=('!=', self.name)))
if exists:
failed_run = frappe.get_doc("Data Migration Run",
dict(status=('in', ['Fail', 'Error'])))
failed_run.delete()
started = frappe.db.exists(
'Data Migration Run',
dict(status=('in', ['Started']), name=('!=', self.name)))
if started:
print("Break")
return
try:
doc = frappe.get_doc({
'doctype': 'Data Migration Run',
'data_migration_plan': 'Mautic Sync',
'data_migration_connector': 'Mautic Connector'
}).insert()
try:
doc.run()
except Exception:
frappe.log_error(frappe.get_traceback())
except Exception as e:
frappe.logger().debug({"Mautic Error: "}, e)
def sync_transactions(bank, bank_account):
last_sync_date = frappe.db.get_value("Bank Account", bank_account,
"last_integration_date")
if last_sync_date:
start_date = formatdate(last_sync_date, "YYYY-MM-dd")
else:
start_date = formatdate(add_months(today(), -12), "YYYY-MM-dd")
end_date = formatdate(today(), "YYYY-MM-dd")
try:
transactions = get_transactions(bank=bank,
bank_account=bank_account,
start_date=start_date,
end_date=end_date)
result = []
for transaction in reversed(transactions):
result += new_bank_transaction(transaction)
frappe.logger().info(
"Plaid added {} new Bank Transactions from '{}' between {} and {}".
format(len(result), bank_account, start_date, end_date))
frappe.db.set_value("Bank Account", bank_account,
"last_integration_date", getdate(end_date))
return result
except Exception:
frappe.log_error(frappe.get_traceback(),
_("Plaid transactions sync error"))
def get_fields(item_code=None):
if print_debug: frappe.logger().debug("get_fields")
fields = []
template = ""
field_template = {
"fieldtype": "Link",
"fieldname": "template",
"label": _("Template"),
"options": "Item",
"onchange": "function(e){console.log('ONCHANGE')}"
}
if item_code:
item = frappe.get_doc("Item", item_code)
if item.variant_of:
field_template["default"] = item.variant_of
fields.append(field_template)
fields_attributes = [{
"fieldtype": "Read Only",
"fieldname": "item_code",
"label": _("Item Code"),
"in_list_view": 1
}, {
"fieldtype": "Check",
"fieldname": "completed",
"label": _("Completed"),
"in_list_view": 1
}]
return fields
def update_reserved_qty_for_production(self, items=None):
if print_debug: frappe.logger().debug("---radplusplus.manufacturing_controllers.update_reserved_qty_for_production---")
'''update reserved_qty_for_production in bins'''
if not self.source_warehouse:
return
if not items:
items = [d.item_code for d in self.required_items]
for item in items:
# RENMAI - 2017-04-13 - a modifier lorsque les entrepots sources seront associé
# aux productions items.
#doc_item = frappe.get_doc("Item",item)
#if doc_item.variant_of && doc_item.variant_of == "PM":
# source_warehouse = self.source_warehouse
source_warehouse = self.source_warehouse
stock_bin = get_bin(item, source_warehouse)
'''Update qty reserved for production from Production Item tables
in open production orders'''
stock_bin.reserved_qty_for_production = frappe.db.sql('''select sum(required_qty - transferred_qty)
from `tabProduction Order` pro, `tabProduction Order Item` item
where
item.item_code = %s
and item.parent = pro.name
and pro.docstatus = 1
and pro.source_warehouse = %s''', (stock_bin.item_code, stock_bin.warehouse))[0][0]
stock_bin.set_projected_qty()
stock_bin.db_set('reserved_qty_for_production', stock_bin.reserved_qty_for_production)
stock_bin.db_set('projected_qty', stock_bin.projected_qty)
def on_trash(self):
from app_center.appmgr import remove_app_folder
try:
remove_app_link(self.app_path)
remove_app_folder(self.app)
except Exception as ex:
frappe.logger(__name__).error(ex)
def editor_release(app=None, version=None, comment=None):
app = app or frappe.form_dict.app
version = version or frappe.form_dict.version
comment = comment or frappe.form_dict.comment
if not app or not version or not comment:
raise frappe.ValidationError
valid_app_owner(app)
data = {
"doctype": "IOT Application Version",
"app": app,
"version": version,
"beta": 1,
"comment": comment,
}
app_file = zip_application(app, version)
try:
doc = frappe.get_doc(data).insert()
os.system("md5sum " + app_file + " > " + app_file + ".md5")
except Exception as ex:
frappe.logger(__name__).error(repr(ex))
remove_version_file(app, version)
raise ex
copy_to_latest(app, version)
return _("Application upload success")
def enqueue_events_for_site(site, queued_jobs):
try:
frappe.init(site=site)
if frappe.local.conf.maintenance_mode:
return
if frappe.local.conf.pause_scheduler:
return
frappe.connect()
if is_scheduler_disabled():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
frappe.logger(__name__).debug(
'Queued events for site {0}'.format(site))
except:
frappe.logger(__name__).error(
'Exception in Enqueue Events for Site {0}'.format(site) + '\n' +
frappe.get_traceback())
raise
finally:
frappe.destroy()
def enqueue_events_for_site(site):
def log_and_raise():
error_message = 'Exception in Enqueue Events for Site {0}\n{1}'.format(
site, frappe.get_traceback())
frappe.logger("scheduler").error(error_message)
try:
frappe.init(site=site)
frappe.connect()
if is_scheduler_inactive():
return
enqueue_events(site=site)
frappe.logger("scheduler").debug(
'Queued events for site {0}'.format(site))
except frappe.db.OperationalError as e:
if frappe.db.is_access_denied(e):
frappe.logger("scheduler").debug(
'Access denied for site {0}'.format(site))
else:
log_and_raise()
except:
log_and_raise()
finally:
frappe.destroy()
def enqueue_events_for_site(site, queued_jobs):
def log_and_raise():
frappe.logger(__name__).error(
'Exception in Enqueue Events for Site {0}'.format(site) + '\n' +
frappe.get_traceback())
raise # pylint: disable=misplaced-bare-raise
try:
frappe.init(site=site)
if frappe.local.conf.maintenance_mode:
return
if frappe.local.conf.pause_scheduler:
return
frappe.connect()
if is_scheduler_disabled():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
frappe.logger(__name__).debug(
'Queued events for site {0}'.format(site))
except frappe.db.OperationalError as e:
if frappe.db.is_access_denied(e):
frappe.logger(__name__).debug(
'Access denied for site {0}'.format(site))
else:
log_and_raise()
except:
log_and_raise()
finally:
frappe.destroy()
def enqueue_events_for_site(site, queued_jobs):
try:
frappe.init(site=site)
if frappe.local.conf.maintenance_mode:
return
if frappe.local.conf.pause_scheduler:
return
frappe.connect()
if is_scheduler_disabled():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
# TODO this print call is a tempfix till logging is fixed!
print 'Queued events for site {0}'.format(site)
frappe.logger(__name__).debug('Queued events for site {0}'.format(site))
except:
frappe.logger(__name__).error('Exception in Enqueue Events for Site {0}'.format(site))
raise
finally:
frappe.destroy()
def send_message(doc,support_code):
if frappe.session.user == "Guest":
return
url = frappe.get_value("ISupport Settings",None,"support_url")
if not url:
return
url = str(url) + "/api/method/usupport.sync.receive_message"
space = "\n" * 2
user_name = frappe.get_value("User",doc.user,"full_name")
message = "{0} {1}From: {2}".format(doc.content,space,user_name)
data = {
"name": doc.name,
"support_code": support_code,
"notes": doc.content,
"last_message": message,
"from_user": frappe.session.user,
"from_name": user_name,
"date": nowdate(),
"time": now(),
}
for i in range(3):
try:
r = requests.post(url, data=json.dumps(data), timeout=5)
r.raise_for_status()
frappe.logger().debug({"webhook_success": r.text})
break
except Exception as e:
frappe.logger().debug({"webhook_error": e, "try": i + 1})
sleep(3 * i + 1)
if i != 2:
continue
else:
raise e
def get_report(dateFrom,
reportType,
doc,
dateTo=None,
flag=0,
monthly=False,
rrd_id=0):
frappe.logger("my").info('reportType {0}, dateFrom {1}'.format(
reportType, dateFrom))
if flag == 1 and monthly == True:
create_report(dateFrom, reportType, doc, flag)
else:
reports = get_reports_instance()
report_response = (call_mws_method(reports.get_report,
reportType=reportType,
dateFrom=dateFrom,
dateTo=dateTo,
flag=flag,
rrd_id=rrd_id)).json()
if reportType == 'stocks':
deleting_data_in_wb_report(dateFrom, reportType, doc)
create_report_stocks(report_response)
elif reportType == 'orders':
deleting_data_in_wb_report(dateFrom, reportType, doc)
create_report_orders(report_response)
elif reportType == 'sales':
deleting_data_in_wb_report(dateFrom, reportType, doc)
create_report_sales(report_response)
elif reportType == 'reportDetailByPeriod':
if doc == 'WB Sales by Sales Monthly':
deleting_data_in_wb_report(dateFrom, reportType, doc)
create_report_sales_by_sales(report_response, dateFrom, dateTo,
reportType, doc, rrd_id)
def iot_device_his_data(sn=None, vsn=None, fields=None, condition=None):
vsn = vsn or sn
fields = fields or "*"
doc = frappe.get_doc('IOT Device', sn)
doc.has_permission("read")
if vsn != sn:
if vsn not in iot_device_tree(sn):
return 401
inf_server = IOTHDBSettings.get_influxdb_server()
if not inf_server:
frappe.logger(__name__).error("InfluxDB Configuration missing in IOTHDBSettings")
return 500
query = 'SELECT ' + fields + ' FROM "' + vsn + '"'
if condition:
query = query + " WHERE " + condition
else:
query = query + " LIMIT 1000"
domain = frappe.get_value("Cloud Company", doc.company, "domain")
r = requests.session().get(inf_server + "/query", params={"q": query, "db": domain}, timeout=10)
if r.status_code == 200:
return r.json()["results"] or r.json()
return r.text
def resend_failed_serials():
failed_serials_doc = frappe.get_all("Serial Number list", ["name", "sync_status", "serial_no"], filters={"sync_status": ["!=", "successful"], })
# for doc in failed_serials_doc:
# print(doc.name, doc.sync_status, doc.serial_no)
if failed_serials_doc:
send_data = {"sn_list": [v.name for v in failed_serials_doc]}
cloud_server = ThingsCloudSettings.get_thingscloud_server()
authorization_code = ThingsCloudSettings.get_authorization_code()
headers = {'HDB-AuthorizationCode': authorization_code, 'Content-Type': 'application/json',
'Accept': 'application/json'}
try:
r = requests.session().post(cloud_server + "/api/method/iot.hdb_api.batch_add_device", headers=headers, json=send_data, timeout=3)
if r.status_code == 200:
result = r.json().get('message')
# print(json.dumps(result, sort_keys=True, indent=4, separators=(',', ':')))
if result.get('done'):
for sn in result.get('done'):
serialno_doc = frappe.get_doc("Serial Number list", sn)
serialno_doc.set("sync_status", 'successful')
serialno_doc.save()
return True
else:
return False
except Exception as ex:
frappe.logger(__name__).error(ex)
else:
return False
def enqueue_webhook(doc, webhook):
webhook = frappe.get_doc("Webhook", webhook.get("name"))
headers = {}
data = {}
if webhook.webhook_headers:
for h in webhook.webhook_headers:
if h.get("key") and h.get("value"):
headers[h.get("key")] = h.get("value")
if webhook.webhook_data:
for w in webhook.webhook_data:
for k, v in doc.as_dict().items():
if k == w.fieldname:
data[w.key] = v
for i in range(3):
try:
r = requests.post(webhook.request_url, data=json.dumps(data), headers=headers, timeout=5)
r.raise_for_status()
frappe.logger().debug({"webhook_success":r.text})
break
except Exception as e:
frappe.logger().debug({"webhook_error":e, "try": i+1})
sleep(3*i + 1)
if i !=2:
continue
else:
raise e
def enqueue_events_for_site(site, queued_jobs):
def log_and_raise():
frappe.logger(__name__).error(
'Exception in Enqueue Events for Site {0}'.format(site) + '\n' +
frappe.get_traceback())
raise # pylint: disable=misplaced-bare-raise
try:
frappe.init(site=site)
frappe.connect()
if is_scheduler_inactive():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
frappe.logger(__name__).debug(
'Queued events for site {0}'.format(site))
except pymysql.OperationalError as e:
if e.args[0] == ER.ACCESS_DENIED_ERROR:
frappe.logger(__name__).debug(
'Access denied for site {0}'.format(site))
else:
log_and_raise()
except:
log_and_raise()
finally:
frappe.destroy()
def check_wechat_binding(app=None, redirect_url=None):
app = app or frappe.form_dict.app
code = frappe.form_dict.code
app_id = frappe.get_value('Wechat App', app, 'app_id')
secret = frappe.get_value('Wechat App', app, 'secret')
auth = WeChatOAuth(app_id, secret, '')
token = auth.fetch_access_token(code)
openid = token["openid"]
expires_in = token['expires_in']
user = frappe.get_value('Wechat Binding', {'app': app, 'openid': openid}, 'user')
if not user:
redirect = "/" #redirect_url or frappe.form_dict.redirect or ('wechat/home/' + app)
url = "/wechat_login?app=" + app + "&openid=" + openid + "&redirect=" + redirect
frappe.local.flags.redirect_location = url
raise frappe.Redirect
frappe.logger(__name__).info(_("check_wechat_binding {0} {1}").format(frappe.session.user, user))
if frappe.session.user != user:
#frappe.local.login_manager.clear_cookies()
frappe.local.cookie_manager.to_delete = []
frappe.local.login_manager.login_as(user)
if redirect_url:
#frappe.local.response["type"] = "redirect"
#frappe.local.response["location"] = redirect_url
frappe.local.flags.redirect_location = redirect_url
frappe.local.response["home_page"] = redirect_url
frappe.local.response["redirect_to"] = redirect_url
raise frappe.Redirect
else:
return app
def enqueue_webhook(doc, webhook):
webhook = frappe.get_doc("Webhook", webhook.get("name"))
headers = {}
data = {}
if webhook.webhook_headers:
for h in webhook.webhook_headers:
if h.get("key") and h.get("value"):
headers[h.get("key")] = h.get("value")
if webhook.webhook_data:
for w in webhook.webhook_data:
for k, v in doc.as_dict().items():
if k == w.fieldname:
data[w.key] = v
for i in range(3):
try:
r = requests.post(webhook.request_url, data=json.dumps(data), headers=headers, timeout=5)
r.raise_for_status()
frappe.logger().debug({"webhook_success":r.text})
break
except Exception as e:
frappe.logger().debug({"webhook_error":e, "try": i+1})
sleep(3*i + 1)
if i !=2:
continue
else:
raise e
def get_context(context):
context.no_cache = 1
context.show_sidebar = True
try:
app = check_wechat_binding()
if frappe.session.user == 'Guest':
frappe.local.flags.redirect_location = "/login"
raise frappe.Redirect
context.filter = frappe.form_dict.filter or "all"
context.language = frappe.db.get_value("User", frappe.session.user,
["language"])
context.csrf_token = frappe.local.session.data.csrf_token
if 'Company Admin' in frappe.get_roles():
context.isCompanyAdmin = True
userdevices = devices_list_array(context.filter) or []
context.userdevices = userdevices
context.dev_lens = int(ceil(len(userdevices) * 0.1))
context.wechat_app = app or frappe.form_dict.app
context.title = _('Wechat Devices')
except Exception as ex:
frappe.logger(__name__).exception(ex)
raise ex
def superuser(username=None):
username = username or frappe.form_dict.username
frappe.logger(__name__).debug(_("MQTT Superuser: username - {0}").format(username))
if username == "root":
return http_200ok()
else:
return http_403("Auth Error")
def get_device_doc(sn):
dev = None
try:
dev = frappe.get_doc("IOT Device", sn)
except Exception, e:
frappe.logger(__name__).error(e)
traceback.print_exc()
def remove_version_file(app, version):
valid_app_owner(app)
try:
os.remove(get_app_release_filepath(app, version))
os.remove(get_app_release_filepath(app, version) + ".md5")
except Exception as ex:
frappe.logger(__name__).error(repr(ex))
def make_child_variant(parent, template_name):
if print_debug: frappe.logger().debug("***make_child_variant***")
#mapper selon le noms des attributes
attribute_map = {}
child_attributes = get_item_variant_attributes_values(template_name)
parent_attributes = get_item_variant_attributes_values(parent.item_code)
for child_attribute in child_attributes:
for item_attribute in parent_attributes:
#if child_attribute[0] == item_attribute[0] and item_attribute[3] == 0:
if child_attribute[0] == item_attribute[0]:
attribute_map[child_attribute[0]] = child_attribute[0]
#mapper selon la configuration dans la bd
attribute_map_bd = get_attribute_mapping(parent.variant_of, template_name)
if attribute_map_bd:
attribute_map.update(attribute_map_bd)
parent_attributes_dict = {i[0]: i[1] for i in parent_attributes}
args = {}
for key, value in attribute_map.iteritems():
att_value = get_attribute_value_mapping(parent.variant_of,
template_name, key, value,
parent_attributes_dict[key])
args[value] = att_value
return create_variant_and_submit(template_name, args)
def sync_transactions(bank, bank_account):
'''Sync transactions based on the last integration date as the start date, after the sync is completed
add the transaction date of the oldest transaction as the last integration date'''
last_transaction_date = frappe.db.get_value("Bank Account", bank_account,
"last_integration_date")
if last_transaction_date:
start_date = formatdate(last_transaction_date, "YYYY-MM-dd")
else:
start_date = formatdate(add_months(today(), -12), "YYYY-MM-dd")
end_date = formatdate(today(), "YYYY-MM-dd")
try:
transactions = get_transactions(bank=bank,
bank_account=bank_account,
start_date=start_date,
end_date=end_date)
result = []
for transaction in reversed(transactions):
result += new_bank_transaction(transaction)
if result:
last_transaction_date = frappe.db.get_value(
'Bank Transaction', result.pop(), 'date')
frappe.logger().info(
"Plaid added {} new Bank Transactions from '{}' between {} and {}"
.format(len(result), bank_account, start_date, end_date))
frappe.db.set_value("Bank Account", bank_account,
"last_integration_date", last_transaction_date)
except Exception:
frappe.log_error(frappe.get_traceback(),
_("Plaid transactions sync error"))
def get_item_attributes_values(item_code):
#template_item_code = frappe.db.get_value("Item", {"item_code":item_code}, "variant_of")
args = {'item_code': item_code}
from radplusplus.radplusplus.controllers.configurator import update_user_translations
update_user_translations(
frappe.db.get_value("User", frappe.session.user, "language"))
query = frappe.db.sql("""
SELECT
`tabItem Variant Attribute`.attribute,
`tabItem Variant Attribute`.attribute as attribute_name_key,
`tabItem Variant Attribute`.attribute_value,
`tabItem Variant Attribute`.attribute_value as item_attribute_value_key
FROM
`tabItem Variant Attribute`
WHERE
`tabItem Variant Attribute`.parent = %(item_code)s
ORDER BY
`tabItem Variant Attribute`.idx ASC""",
args,
as_dict=1)
for attribute in query:
if print_debug: frappe.logger().debug("attribute : " + cstr(attribute))
attribute["attribute"] = _(attribute["attribute"])
attribute["attribute_value"] = _(attribute["attribute_value"])
if print_debug: frappe.logger().debug("attribute : " + cstr(attribute))
return query
def make_dynamic_bom(item, create_new_if_exist=False):
if print_debug: frappe.logger().debug("***make_dynamic_bom***")
#Si c'est un variant et que son modèle possède un constructeur de BOM
if item.variant_of is not None and frappe.db.exists(
"Configurator Bom", item.variant_of):
cb = frappe.get_doc("Configurator Bom", item.variant_of)
#Obtenir le bom actuel
bom = get_bom(item.item_code)
if bom is None or create_new_if_exist:
bom = make_bom_base(item, cb)
else:
return
for bom_oper in cb.operations:
make_dynamic_bom_oper(item, bom, bom_oper)
for bom_item in cb.items:
make_bom_item(item, bom, bom_item)
#make_packaging(item, bom)
bom.insert(ignore_permissions=True)
bom.submit()
if print_debug: frappe.logger().debug("bom created: " + cstr(bom.name))
def handle_exception(e):
http_status_code = getattr(e, "http_status_code", 500)
if (http_status_code==500
and isinstance(e, MySQLdb.OperationalError)
and e.args[0] in (1205, 1213)):
# 1205 = lock wait timeout
# 1213 = deadlock
# code 409 represents conflict
http_status_code = 508
if frappe.local.is_ajax or 'application/json' in frappe.local.request.headers.get('Accept', ''):
response = frappe.utils.response.report_error(http_status_code)
else:
traceback = "<pre>"+frappe.get_traceback()+"</pre>"
if frappe.local.flags.disable_traceback:
traceback = ""
frappe.respond_as_web_page("Server Error",
traceback,
http_status_code=http_status_code)
response = frappe.website.render.render("message", http_status_code=http_status_code)
if e.__class__ == frappe.AuthenticationError:
if hasattr(frappe.local, "login_manager"):
frappe.local.login_manager.clear_cookies()
if http_status_code >= 500:
frappe.logger().error('Request Error', exc_info=True)
make_error_snapshot(e)
return response
def application(request):
response = None
try:
rollback = True
init_request(request)
if frappe.local.form_dict.cmd:
response = frappe.handler.handle()
elif frappe.request.path.startswith("/api/"):
if frappe.local.form_dict.data is None:
frappe.local.form_dict.data = request.get_data()
response = frappe.api.handle()
elif frappe.request.path.startswith('/backups'):
response = frappe.utils.response.download_backup(request.path)
elif frappe.request.path.startswith('/private/files/'):
response = frappe.utils.response.download_private_file(request.path)
elif frappe.local.request.method in ('GET', 'HEAD'):
response = frappe.website.render.render()
else:
raise NotFound
except HTTPException, e:
frappe.logger().error('Request Error', exc_info=True)
return e
def send_message(self):
if frappe.session.user == "Guest":
return
if not self.support_code or not self.notes:
return
url = frappe.get_value("ISupport Settings",None,"support_url")
if not url:
return
url = str(url) + "/api/method/usupport.sync.receive_message"
data = {
"name": self.name,
"support_code": self.support_code,
"notes": self.notes,
"last_message": self.last_message,
"from_user": frappe.session.user,
"from_name": frappe.get_value("User",frappe.session.user,"full_name"),
"date": nowdate(),
"time": now(),
"error_msg": self.error_msg or "",
}
for i in range(3):
try:
r = requests.post(url, data=json.dumps(data), timeout=5)
r.raise_for_status()
frappe.logger().debug({"webhook_success": r.text})
self.need_sync = 0
self.last_sync = now()
break
except Exception as e:
frappe.logger().debug({"webhook_error": e, "try": i + 1})
sleep(3 * i + 1)
if i != 2:
continue
else:
raise e
def check_bind(app, openid, gen_token=False):
if frappe.request.method != "POST" and frappe.request.method != "PUT":
throw(_("Request Method Must be POST!"))
from iot.user_api import valid_auth_code
valid_auth_code()
frappe.logger(__name__).info(_("check_bind {0}").format(openid))
user = frappe.get_value('Wechat Binding', {'app': app, 'openid': openid}, 'user')
if not user:
if frappe.get_value('Wechat App', app, 'name'):
throw(_("There is no user bind with this openid!"))
else:
throw(_('Wechat application name does not exists!'))
token = frappe.get_value("IOT User Api", user, 'authorization_code')
if not token and gen_token is not False:
doc = frappe.get_doc({
"doctype": "IOT User Api",
"user": user,
"authorization_code": str(uuid.uuid1()).upper()
}).insert()
token = doc.authorization_code
return {
"user": user,
"fullname": get_fullname(user),
"token": token,
"creation": frappe.get_value('Wechat Binding', {'app': app, 'openid': openid}, 'creation')
}
def create_mandate(data):
data = frappe._dict(data)
frappe.logger().debug(data)
mandate = data.get('mandate')
if frappe.db.exists("GoCardless Mandate", mandate):
return
else:
reference_doc = frappe.db.get_value(
data.get('reference_doctype'),
data.get('reference_docname'),
["reference_doctype", "reference_name"],
as_dict=1)
erpnext_customer = frappe.db.get_value(reference_doc.reference_doctype,
reference_doc.reference_name,
["customer_name"],
as_dict=1)
try:
frappe.get_doc({
"doctype": "GoCardless Mandate",
"mandate": mandate,
"customer": erpnext_customer.customer_name,
"gocardless_customer": data.get('customer')
}).insert(ignore_permissions=True)
except Exception:
frappe.log_error(frappe.get_traceback())
def get_item_details_translated(args):
from erpnext.stock.get_item_details import get_item_details
out = get_item_details(args)
args = process_args(args)
lang = "fr"
if args.get("customer"):
lang = frappe.db.get_value("Customer", args.customer, "language")
if args.get("supplier"):
lang = frappe.db.get_value("Supplier", args.supplier, "language")
out.update({
"description":
frappe.db.get_value("Item Language", {
"parent": args.item_code,
"language": lang
}, "description")
or frappe.db.get_value("Item", args.item_code, "description")
})
if print_debug: frappe.logger().debug(out)
return out
def get_purchase_order_items(self):
'''Returns items that already do not have a linked purchase order'''
if print_debug: frappe.logger().debug("---radplusplus.manufacturing_controllers.get_purchase_order_items:")
if print_debug: frappe.logger().debug("self : " + self)
required_items = json.loads(self).get('required_items')
self = json.loads(self)
items = []
for i in required_items:
if print_debug: frappe.logger().debug("i : ")
if print_debug: frappe.logger().debug(i)
if print_debug: frappe.logger().debug("i['required_qty'] : " + cstr(i['required_qty']))
pending_qty= i['required_qty'] - flt(frappe.db.sql('''select sum(qty) from `tabPurchase Order Item`
where item_code=%s and production_order=%s and production_order_item = %s and docstatus<2''', (i['item_code'], i['parent'], i['name']))[0][0])
if pending_qty:
items.append(dict(
item_code= i['item_code'],
warehouse = i['source_warehouse'],
pending_qty = pending_qty,
production_order_item = i['name']
))
return items
def handle_exception(e):
response = None
http_status_code = getattr(e, "http_status_code", 500)
return_as_message = False
if frappe.local.is_ajax or 'application/json' in frappe.get_request_header('Accept'):
# handle ajax responses first
# if the request is ajax, send back the trace or error message
response = frappe.utils.response.report_error(http_status_code)
elif (http_status_code==500
and isinstance(e, MySQLdb.OperationalError)
and e.args[0] in (1205, 1213)):
# 1205 = lock wait timeout
# 1213 = deadlock
# code 409 represents conflict
http_status_code = 508
elif http_status_code==401:
frappe.respond_as_web_page(_("Session Expired"),
_("Your session has expired, please login again to continue."),
http_status_code=http_status_code, indicator_color='red')
return_as_message = True
elif http_status_code==403:
frappe.respond_as_web_page(_("Not Permitted"),
_("You do not have enough permissions to complete the action"),
http_status_code=http_status_code, indicator_color='red')
return_as_message = True
elif http_status_code==404:
frappe.respond_as_web_page(_("Not Found"),
_("The resource you are looking for is not available"),
http_status_code=http_status_code, indicator_color='red')
return_as_message = True
else:
traceback = "<pre>"+frappe.get_traceback()+"</pre>"
if frappe.local.flags.disable_traceback:
traceback = ""
frappe.respond_as_web_page("Server Error",
traceback, http_status_code=http_status_code,
indicator_color='red', width=640)
return_as_message = True
if e.__class__ == frappe.AuthenticationError:
if hasattr(frappe.local, "login_manager"):
frappe.local.login_manager.clear_cookies()
if http_status_code >= 500:
frappe.logger().error('Request Error', exc_info=True)
make_error_snapshot(e)
if return_as_message:
response = frappe.website.render.render("message",
http_status_code=http_status_code)
return response
def make_error_snapshot(exception):
if frappe.conf.disable_error_snapshot:
return
logger = frappe.logger(__name__, with_more_info=False)
try:
error_id = '{timestamp:s}-{ip:s}-{hash:s}'.format(
timestamp=cstr(datetime.datetime.now()),
ip=frappe.local.request_ip or '127.0.0.1',
hash=frappe.generate_hash(length=3)
)
snapshot_folder = get_error_snapshot_path()
frappe.create_folder(snapshot_folder)
snapshot_file_path = os.path.join(snapshot_folder, "{0}.json".format(error_id))
snapshot = get_snapshot(exception)
with open(encode(snapshot_file_path), 'wb') as error_file:
error_file.write(encode(frappe.as_json(snapshot)))
logger.error('New Exception collected with id: {}'.format(error_id))
except Exception as e:
logger.error('Could not take error snapshot: {0}'.format(e), exc_info=True)
def sendmail(communication_name, print_html=None, print_format=None, attachments=None,
recipients=None, cc=None, bcc=None, lang=None, session=None, print_letterhead=None):
try:
if lang:
frappe.local.lang = lang
if session:
# hack to enable access to private files in PDF
session['data'] = frappe._dict(session['data'])
frappe.local.session.update(session)
if print_letterhead:
frappe.flags.print_letterhead = print_letterhead
# upto 3 retries
for i in range(3):
try:
communication = frappe.get_doc("Communication", communication_name)
communication._notify(print_html=print_html, print_format=print_format, attachments=attachments,
recipients=recipients, cc=cc, bcc=bcc)
except pymysql.InternalError as e:
# deadlock, try again
if e.args[0] == ER.LOCK_DEADLOCK:
frappe.db.rollback()
time.sleep(1)
continue
else:
raise
else:
break
except:
traceback = log("frappe.core.doctype.communication.email.sendmail", frappe.as_json({
"communication_name": communication_name,
"print_html": print_html,
"print_format": print_format,
"attachments": attachments,
"recipients": recipients,
"cc": cc,
"bcc": bcc,
"lang": lang
}))
frappe.logger(__name__).error(traceback)
raise
def sendmail(communication_name, print_html=None, print_format=None, attachments=None,
recipients=None, cc=None, lang=None, session=None):
try:
if lang:
frappe.local.lang = lang
if session:
# hack to enable access to private files in PDF
session['data'] = frappe._dict(session['data'])
frappe.local.session.update(session)
# upto 3 retries
for i in xrange(3):
try:
communication = frappe.get_doc("Communication", communication_name)
if communication.sent_or_received == "Received":
communication.message_id = None
communication._notify(print_html=print_html, print_format=print_format, attachments=attachments,
recipients=recipients, cc=cc)
except MySQLdb.OperationalError, e:
# deadlock, try again
if e.args[0]==1213:
frappe.db.rollback()
time.sleep(1)
continue
else:
raise
else:
break
except:
traceback = log("frappe.core.doctype.communication.email.sendmail", frappe.as_json({
"communication_name": communication_name,
"print_html": print_html,
"print_format": print_format,
"attachments": attachments,
"recipients": recipients,
"cc": cc,
"lang": lang
}))
frappe.logger(__name__).error(traceback)
raise
def trigger(site, event, last=None, queued_jobs=(), now=False):
"""Trigger method in hooks.scheduler_events."""
queue = 'long' if event.endswith('_long') else 'short'
timeout = queue_timeout[queue]
if not queued_jobs and not now:
queued_jobs = get_jobs(site=site, queue=queue)
if frappe.flags.in_test:
frappe.flags.ran_schedulers.append(event)
events_from_hooks = get_scheduler_events(event)
if not events_from_hooks:
return
events = events_from_hooks
if not now:
events = []
if event == "cron":
for e in events_from_hooks:
e = cron_map.get(e, e)
if croniter.is_valid(e):
if croniter(e, last).get_next(datetime) <= frappe.utils.now_datetime():
events.extend(events_from_hooks[e])
else:
frappe.log_error("Cron string " + e + " is not valid", "Error triggering cron job")
frappe.logger(__name__).error('Exception in Trigger Events for Site {0}, Cron String {1}'.format(site, e))
else:
if croniter(cron_map[event], last).get_next(datetime) <= frappe.utils.now_datetime():
events.extend(events_from_hooks)
for handler in events:
if not now:
if handler not in queued_jobs:
enqueue(handler, queue, timeout, event)
else:
scheduler_task(site=site, event=event, handler=handler, now=True)
def enqueue_events_for_site(site, queued_jobs):
try:
frappe.init(site=site)
if frappe.local.conf.maintenance_mode:
return
if frappe.local.conf.pause_scheduler:
return
frappe.connect()
if is_scheduler_disabled():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
frappe.logger(__name__).debug('Queued events for site {0}'.format(site))
except:
frappe.logger(__name__).error('Exception in Enqueue Events for Site {0}'.format(site) +
'\n' + frappe.get_traceback())
raise
finally:
frappe.destroy()
def scheduler_task(site, event, handler, now=False):
'''This is a wrapper function that runs a hooks.scheduler_events method'''
frappe.logger(__name__).info('running {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
try:
if not now:
frappe.connect(site=site)
frappe.flags.in_scheduler = True
frappe.get_attr(handler)()
except Exception:
frappe.db.rollback()
traceback = log(handler, "Method: {event}, Handler: {handler}".format(event=event, handler=handler))
frappe.logger(__name__).error(traceback)
raise
else:
frappe.db.commit()
frappe.logger(__name__).info('ran {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import frappe
import string
import datetime
import re
import json
import sys
from frappe import _
from frappe.model.document import Document
_logger = frappe.logger(__name__)
try:
import vatnumber
except ImportError:
_logger.warning("VAT validation partially unavailable because the `vatnumber` Python library cannot be found. "
"Install it to support more countries, for example with `easy_install vatnumber`.")
vatnumber = None
_ref_vat = {
'at': 'ATU12345675',
'be': 'BE0477472701',
'bg': 'BG1234567892',
'ch': 'CHE-123.456.788 TVA or CH TVA 123456', #Swiss by Yannick Vaucher @ Camptocamp
'cy': 'CY12345678F',
'cz': 'CZ12345679',
'de': 'DE123456788',
'dk': 'DK12345674',
import os, frappe
import jasper_erpnext_report as jr
_logger = frappe.logger("jasper_erpnext_report")
try:
import jnius_config as jc
jr.pyjnius = True
if not jc.vm_running:
jc.add_options('-Djava.awt.headless=true')
else:
_logger.info("vm_running: {}".format(jc.vm_running))
except:
print "jnius_config not found"
jr.pyjnius = False
norm_path = os.path.normpath
join_path = os.path.join
dirname = os.path.dirname
parent_path = dirname(dirname(__file__))
rel_path = os.path.relpath(os.path.join(parent_path, "java"),dirname(__file__))
rel_path_curr = os.path.relpath(parent_path, os.getcwd())
try:
os.environ['CLASSPATH'] = norm_path(join_path(parent_path,"java/lib/*")) + ":.:" + os.environ.get('CLASSPATH',"")
print "CLASSPATH {}".format(os.environ['CLASSPATH'])
except:
print "Error in setting java classpath."
try:
from jnius import autoclass
def log(event, details): frappe.logger().info(details)
