def reset_enabled_scheduler_events(login_manager):
if login_manager.info.user_type == "System User":
try:
frappe.db.set_global('enabled_scheduler_events', None)
except MySQLdb.OperationalError, e:
if e.args[0]==1205:
frappe.get_logger().error("Error in reset_enabled_scheduler_events")
else:
raise
else:
is_dormant = frappe.conf.get('dormant')
if is_dormant:
update_site_config('dormant', 'None')
def reset_enabled_scheduler_events(login_manager):
if login_manager.info.user_type == "System User":
try:
frappe.db.set_global('enabled_scheduler_events', None)
except MySQLdb.OperationalError, e:
if e.args[0] == 1205:
frappe.get_logger().error(
"Error in reset_enabled_scheduler_events")
else:
raise
else:
is_dormant = frappe.conf.get('dormant')
if is_dormant:
update_site_config('dormant', 'None')
def make_error_snapshot(exception):
if frappe.conf.disable_error_snapshot:
return
logger = frappe.get_logger()
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, e:
logger.error('Could not take error snapshot: {0}'.format(e))
def make_error_snapshot(exception):
if frappe.conf.disable_error_snapshot:
return
logger = frappe.get_logger()
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, e:
logger.error('Could not take error snapshot: {0}'.format(e))
import time
from frappe.utils import cint
import jasper_erpnext_report, os
import JasperRoot as Jr
from jasper_erpnext_report import jasper_session_obj
from jasper_erpnext_report.core.JasperRoot import get_copies
from jasper_erpnext_report.utils.utils import set_jasper_email_doctype, check_frappe_permission, jasper_run_method,\
jasper_users_login, jaspersession_set_value, pipInstall, getFrappeVersion
from jasper_erpnext_report.utils.jasper_email import jasper_save_email, get_sender, get_email_pdf_path, get_email_other_path, sendmail, sendmail_v5
from jasper_erpnext_report.utils.file import get_file, get_html_reports_path, write_file
from jasper_erpnext_report.utils.cache import redis_transation
_logger = frappe.get_logger("jasper_erpnext_report")
def boot_session(bootinfo):
bootinfo['jasper_reports_list'] = get_reports_list_for_all()
arr = getLangInfo()
bootinfo["langinfo"] = arr
def getLangInfo():
arr = []
version = cint(frappe.__version__.split(".", 1)[0])
if version < 5:
from frappe.translate import get_lang_info
langinfo = get_lang_info()
for l in langinfo:
import mimetypes
import frappe
import frappe.handler
import frappe.auth
import frappe.api
import frappe.utils.response
import frappe.website.render
from frappe.utils import get_site_name
from frappe.middlewares import StaticDataMiddleware
local_manager = LocalManager([frappe.local])
_site = None
_sites_path = os.environ.get("SITES_PATH", ".")
logger = frappe.get_logger()
@Request.application
def application(request):
frappe.local.request = request
frappe.local.is_ajax = frappe.get_request_header("X-Requested-With")=="XMLHttpRequest"
response = None
try:
rollback = True
init_site(request)
if frappe.local.conf.get('maintenance_mode'):
raise frappe.SessionStopped
import mimetypes
import frappe
import frappe.handler
import frappe.auth
import frappe.api
import frappe.utils.response
import frappe.website.render
from frappe.utils import get_site_name
from frappe.middlewares import StaticDataMiddleware
local_manager = LocalManager([frappe.local])
_site = None
_sites_path = os.environ.get("SITES_PATH", ".")
logger = frappe.get_logger()
@Request.application
def application(request):
frappe.local.request = request
frappe.local.is_ajax = frappe.get_request_header(
"X-Requested-With") == "XMLHttpRequest"
response = None
try:
rollback = True
init_site(request)
if frappe.local.conf.get('maintenance_mode'):
from frappe.utils import cint
from jasper_erpnext_report.utils.file import get_jasper_path, get_file
from jasper_erpnext_report.utils.jasper_file_jrxml import get_compiled_path
import jasper_erpnext_report.utils.utils as utils
import jasper_erpnext_report.jasper_reports as jr
import JasperBase as Jb
#from jasper_erpnext_report.jasper_reports.FrappeDataSource import _JasperCustomDataSource
import uuid
import os, json
_logger = frappe.get_logger("jasper_erpnext_report")
print_format = ["docx", "ods", "odt", "rtf", "xls", "xlsx", "pptx", "html", "pdf"]
class JasperLocal(Jb.JasperBase):
def __init__(self, doc=None):
super(JasperLocal, self).__init__(doc, "local")
def run_local_report_async(self, path, doc, data=None, params=None, pformat="pdf", ncopies=1, for_all_sites=0):
from jasper_erpnext_report.core.FrappeTask import FrappeTask
try:
self.frappe_task = FrappeTask(frappe.local.task_id, None)
cresp = self.prepare_report_async(path, doc, data=data, params=params, pformat=pformat, ncopies=ncopies, for_all_sites=for_all_sites)
return [cresp]
class Bot(object):
def __init__(self, bot_id):
self.log_buffer = []
self.parameters = Parameters()
self.current_message = None
self.last_message = None
self.message_counter = 0
self.error_retries_count = 0
self.source_pipeline = None
self.destination_pipeline = None
self.logger = None
try:
self.log_buffer.append(
('debug',
'{} initialized with id {}'.format(self.__class__.__name__,
bot_id)))
self.check_bot_id(bot_id)
self.bot_id = bot_id
self.load_defaults_configuration()
self.load_system_configuration()
self.logger = frappe.get_logger('Programmer:BOT')
except:
self.log_buffer.append(('critical', traceback.format_exc()))
self.stop()
else:
for line in self.log_buffer:
getattr(self.logger, line[0])(line[1])
try:
self.logger.info('Bot is starting.')
self.load_runtime_configuration()
self.load_pipeline_configuration()
self.load_harmonization_configuration()
self.init()
except:
self.logger.exception('Bot initialized failed.')
raise
def init(self):
pass
def start(self,
starting=True,
error_on_pipeline=True,
error_on_message=True,
source_pipeline=None,
destination_pipeline=None):
self.source_pipeline = source_pipeline
self.destination_pipeline = destination_pipeline
self.logger.info('Bot starts processing')
while True:
try:
if not starting and (error_on_pipeline or error_on_message):
self.logger.info('Bot will restart in {} seconds.'.format(
self.parameters.error_retry_delay))
time.sleep(self.parameters.error_retry_delay)
self.logger.info('Bot woke up.')
self.logger.info('Trying to start processing again.')
if error_on_message:
error_on_message = False
if error_on_pipeline:
self.logger.info('Loading source pipeline.')
self.source_pipeline = PipelineFactory.create(
self.parameters)
self.logger.info('Loading source queue.')
self.source_pipeline.set_queues(self.source_queues,
'source')
self.logger.info('Source queue loaded {}.'.format(
self.source_queues))
self.source_pipeline.connect()
self.logger.info('Connect to source queue.')
self.logger.info('Loading destination pipeline.')
self.destination_pipeline = PipelineFactory(
self.parameters)
self.logger.info('Loading destination queues.')
self.destination_pipeline.set_queues(
self.destination_queues, 'destination')
self.logger.info('Destination queues loaded {}'.format(
self.destination_queues))
self.destination_pipeline.connect()
self.logger.info('Connect to destination queues.')
self.logger.info('Pipeline ready.')
error_on_pipeline = False
if starting:
self.logger.info('Start processing.')
starting = False
self.process()
self.source_pipeline.sleep(self.parameters.rate_limit)
except exceptions.PipelineError:
error_on_pipeline = True
if self.parameters.error_log_exception:
self.logger.exception('Pipeline failed.')
else:
self.logger.error('Pipeline failed.')
self.source_pipeline = None
self.destination_pipeline = None
except KeyboardInterrupt:
self.logger.error('Received KeyboardInterrupt.')
self.stop()
break
except Exception:
if self.parameters.error_log_exception:
self.logger.exception('Bot has found a problem.')
else:
self.logger.error('Bot has found a problem.')
if self.parameters.error_log_message:
self.logger.info(
'Last Correct Message(event): {!r}.'.format(
self.last_message[:500]))
self.logger.info('Current Message(event): {!r}.'.format(
self.current_message[:500]))
self.error_retries_count += 1
if self.parameters.error_procedure == 'Retry':
if (self.error_retries_counter >=
self.parameters.error_max_retries):
if self.parameters.error_dump_message:
self.dump_message()
self.acknowledge_message()
self.stop()
# when bot acknowledge the message, dont need to wait again
error_on_message = True
else:
if self.parameters.error_dump_message:
self.dump_message()
self.acknowledge_message()
finally:
if (self.error_retries_count >=
self.parameters.error_max_retries
and self.parameters.error_max_retries >= 0):
self.stop()
break
def stop(self):
'''
Stop Bot by diconnecting pipelines
'''
if self.source_pipeline:
self.source_pipeline.disconnect()
self.source_pipeline = None
self.logger.info('Disconnecting from source pipeline.')
if self.destination_pipeline:
self.destination_pipeline.disconnect()
self.destination_pipeline = None
self.logger.info('Disconnecting from destination pipeline.')
if self.logger:
self.logger.info('Bot stopped.')
else:
self.logger_buffer.append(('info', 'Bot stopped.'))
self.print_log_buffer()
if self.parameters.exit_on_stop:
self.terminate()
def terminate(self):
try:
self.logger.error('Exiting.')
except:
pass
finally:
print('Exiting.')
exit(-1)
def print_log_buffer(self):
for level, message in self.log_buffer:
if self.logger:
getattr(self.logger, level)(message)
print(level.upper(), '-', message)
self.log_buffer = []
def check_bot_id(self, bot_id):
res = re.search('[^0-9a-zA-Z-]+', bot_id)
if res:
self.log_buffer.append(
('error', 'Invalid bot id, must match "[^0-9a-zA-Z-]+".'))
self.stop()
def send_message(self, message):
if not message:
self.log.warning('Sending message: Empty message found.')
return False
self.logger.debug('Sending message.')
self.message_counter += 1
if self.message_counter % 500 == 0:
self.logger.info('Processed {} messages.' % self.message_counter)
raw_message = MessageFactory.serialize(message)
self.destination_pipeline.send(raw_message)
def receive_message(self):
self.logger.debug('Receiving Message.')
message = self.source_pipeline.receive()
self.logger.debug('Receive message {!r}...'.format(message[:500]))
if not message:
self.logger.warning('Empty message received.')
return None
self.current_message = MessageFactory.unserialize(message)
return self.current_message
def acknowledge_message(self):
self.last_message = self.current_message
self.source_pipeline.acknowledge()
def dump_message(self):
timestamp = datetime.datetime.utcnow()
timestamp = timestamp.isoformat()
dump_file = '{}{}.dump'.format(self.parameters.logging_path,
self.bot_id)
new_dump_data = dict()
new_dump_data[timestamp] = dict(
boot_id=self.boot_id,
source_queue=self.source_queues,
traceback=traceback.format_exc(),
message=self.current_message.serialize()
if self.current_message is not None else None)
try:
with open(dump_file, 'r') as fp:
dump_data = json.load(fp)
dump_data.update(new_dump_data)
except:
dump_data = new_dump_data
with open(dump_file, 'w') as fp:
json.dump(dump_data, fp, indent=4, sort_keys=True)
def load_defaults_configuration(self):
pass
from __future__ import unicode_literals
import frappe
import logging
jasper_session_obj = frappe.local("jasper_session_obj")
jasper_session = frappe.local("jasper_session")
pyjnius = False
jasperserverlib = False
frappe.get_logger("jasper_erpnext_report").addHandler(logging.NullHandler())
fds = frappe.local("fds")
batch = frappe.local("batch")
from .utils.utils import get_Frappe_Version
FRAPPE_VERSION = get_Frappe_Version()
# -*- 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.get_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',
from __future__ import unicode_literals
import frappe
import logging
jasper_session_obj = frappe.local("jasper_session_obj")
jasper_session = frappe.local("jasper_session")
pyjnius = False
jasperserverlib = False
frappe.get_logger("jasper_erpnext_report").addHandler(logging.NullHandler())
fds = frappe.local("fds")
batch = frappe.local("batch")
from .utils.utils import get_Frappe_Version
FRAPPE_VERSION = get_Frappe_Version()
def get_logger(
): # Everytime will return the same logger, if its already registered
return frappe.get_logger("bcommerce")
