def getAdminContent(self, **params):
"""
Deliver admin content of module messages
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
if 'saveparameters' in request.form.keys(): # save parameters for modules
for k in [k for k in request.form if k != 'saveparameters']:
Settings.set("messages.%s" % k, request.form.get(k))
monitorserver.sendMessage('0', 'reset') # refresh monitor layout
if len(module) == 2:
if module[1] == 'types': # type submodule
params.update({'implementations': MessageType.getMessageTypes()})
return render_template('admin.messages.types.html', **params)
else:
messages = {
'1': Messages.getMessages(state=1),
'0': Messages.getMessages(state=0)
}
params.update({'messages': messages})
return render_template('admin.messages.html', **params)
def init_app(self, app):
Communication.app = app
try: # try telegram
import telegram
self.__dict__['telegram'] = TelegramBot(
app=app,
token=Settings.get('telegramsettings')['telegramkey']
or app.config.get('TELEGRAMKEY'))
except TypeError:
Settings.set('telegramsettings', {'telegramkey': ''})
self.__dict__['telegram'] = None
except ImportError:
logger.error("error telegram")
self.__dict__['telegram'] = None
try: # try mail
# TODO: add Mail communicator
pass
self.__dict__['mail'] = Mailer
except ImportError:
self.__dict__['mail'] = None
logger.error("error Mail")
# Mail = None
app.extensions['communication'] = self
logger.info("{} Communicator(s) loaded: {}".format(
len(self.__dict__.keys()), ", ".join(self.__dict__.keys())))
events.addHandlerClass(
'*', 'emonitor.communication.Communication',
Communication.handleEvent,
['in.sendertype', 'in.group', 'in.id', 'in.style'])
def addParameters(self, **kwargs):
"""
Add special parameters for birthday widget *messages.birthday.\**
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
content = kwargs['message'].get('content')
template = kwargs['message'].get('template')
n = int(kwargs['message'].get('number'))
orientation = kwargs['message'].get('orientation')
else:
content = Settings.get('messages.birthday.content')
template = "" # todo define templates
n = int(Settings.get('messages.birthday.number', 20))
orientation = Settings.get('messages.birthday.orientation', 20)
persons = sorted(Person.getPersons(onlyactive=True), key=lambda p: p.birthday)
p = [(val.birthday - int(datetime.datetime.now().strftime('%j')), idx, persons[idx].lastname, persons[idx].birthdate) for (idx, val) in enumerate(persons)]
idx = min(filter(lambda x: x[0] >= 0, p))
person = OrderedDict()
try:
for i in range(idx[1] - (n / 2) + 1, idx[1] + (n / 2) + 2):
_p = persons[i % (len(p))]
if _p.birthdate.strftime('%d.%m.') not in person.keys():
person[_p.birthdate.strftime('%d.%m.')] = []
person[_p.birthdate.strftime('%d.%m.')].append(_p)
for _p in persons:
if _p.birthdate.strftime('%d.%m.') in person.keys() and _p not in person[_p.birthdate.strftime('%d.%m.')]:
person[_p.birthdate.strftime('%d.%m.')].append(_p)
except:
pass
kwargs.update({'content': content, 'template': template, 'persons': person, 'daynum': int((datetime.datetime.now()).strftime('%j')), 'orientation': orientation})
self.params = kwargs
def init_app(self, app):
Communication.app = app
try: # try telegram
import telegram
self.__dict__['telegram'] = TelegramBot(app=app, token=Settings.get('telegramsettings')['telegramkey'] or app.config.get('TELEGRAMKEY'))
except TypeError:
Settings.set('telegramsettings', {'telegramkey': ''})
self.__dict__['telegram'] = None
except ImportError:
logger.error("error telegram")
self.__dict__['telegram'] = None
try: # try mail
# TODO: add Mail communicator
pass
self.__dict__['mail'] = Mailer
except ImportError:
self.__dict__['mail'] = None
logger.error("error Mail")
# Mail = None
app.extensions['communication'] = self
logger.info("{} Communicator(s) loaded: {}".format(len(self.__dict__.keys()), ", ".join(self.__dict__.keys())))
events.addHandlerClass('*', 'emonitor.communication.Communication', Communication.handleEvent, ['in.sendertype', 'in.group', 'in.id', 'in.style'])
def getFrontendContent(self, **params):
"""
Get frontend content with areas (west, center, east) to hold modules.
Areas can be configured in :py:class:`emonitor.modules.settings.settings.Settings`
:param params: dict with key `area`
:return: rendered HTML-template of module
"""
if 'area' in params:
defaultarea = dict()
defaultarea['center'] = Settings.getFrontendSettings('center')
defaultarea['west'] = Settings.getFrontendSettings('west')
defaultarea['east'] = Settings.getFrontendSettings('east')
# load module data
if defaultarea[params['area']]['module'] == 'default':
return render_template('frontend.default.html')
elif defaultarea[params['area']][
'module'] in current_app.blueprints['frontend'].modules:
return current_app.blueprints['frontend'].modules[defaultarea[
params['area']]['module']].getFrontendContent(**params)
else:
current_app.logger.error(
"module %s not found for frontend area %s" %
(defaultarea[params['area']]['module'], params['area']))
return ""
return render_template('frontend.default.html')
def action(**kwargs):
"""
implementation of map-message specific actions
:param kwargs: list of parameters: action, mid and all arguments of ajax requests
:return: results of action
"""
if kwargs.get('action') == 'render':
"""
render string with restructured text engine
"""
return getreStructuredText(kwargs.get('text'))
elif kwargs.get('action') == 'mapconfig':
"""
open overlay map with config values
"""
try:
config = json.loads(kwargs.get('config', ''))
except ValueError:
config = {}
if not config.get('lat'):
config['lat'] = Settings.get('defaultLat')
if not config.get('lng'):
config['lng'] = Settings.get('defaultLng')
config['map'] = Map.getDefaultMap()
kwargs.update(**config)
#print ">>>>>", kwargs
return render_template("frontend.messages_map.html", **kwargs)
return ""
def getFrontendContent(self, **params):
"""
Get frontend content with areas (west, center, east) to hold modules.
Areas can be configured in :py:class:`emonitor.modules.settings.settings.Settings`
:param params: dict with key `area`
:return: rendered HTML-template of module
"""
if "area" in params:
defaultarea = dict()
defaultarea["center"] = Settings.getFrontendSettings("center")
defaultarea["west"] = Settings.getFrontendSettings("west")
defaultarea["east"] = Settings.getFrontendSettings("east")
# load module data
if defaultarea[params["area"]]["module"] == "default":
return render_template("frontend.default.html")
elif defaultarea[params["area"]]["module"] in current_app.blueprints["frontend"].modules:
return (
current_app.blueprints["frontend"]
.modules[defaultarea[params["area"]]["module"]]
.getFrontendContent(**params)
)
else:
current_app.logger.error(
"module %s not found for frontend area %s" % (defaultarea[params["area"]]["module"], params["area"])
)
return ""
return render_template("frontend.default.html")
def action(**kwargs):
"""
implementation of map-message specific actions
:param kwargs: list of parameters: action, mid and all arguments of ajax requests
:return: results of action
"""
if kwargs.get('action') == 'render':
"""
render string with restructured text engine
"""
return getreStructuredText(kwargs.get('text'))
elif kwargs.get('action') == 'mapconfig':
"""
open overlay map with config values
"""
try:
config = json.loads(kwargs.get('config', ''))
except ValueError:
config = {}
if not config.get('lat'):
config['lat'] = Settings.get('defaultLat')
if not config.get('lng'):
config['lng'] = Settings.get('defaultLng')
config['map'] = Map.getDefaultMap()
kwargs.update(**config)
#print ">>>>>", kwargs
return render_template("frontend.messages_map.html", **kwargs)
return ""
def getFrontendData(self):
"""
Deliver frontend content of module streets (ajax)
:return: rendered template as string or json dict
"""
if request.args.get('action') == 'streetcoords': # get map parameter for given streetid
if request.args.get('id') not in ['', 'None']:
street = Street.getStreets(id=request.args.get('id'))
return {'lat': street.lat, 'lng': street.lng, 'zoom': street.zoom, 'way': street.navigation,
'cityid': street.cityid, 'cityname': street.city.name}
elif request.args.get('action') == 'housecoords': # deliver center of housenumbers
if request.args.get('streetid') != '' and request.args.get('housenumber') != '':
street = Street.getStreet(id=request.args.get('streetid'))
hnumber = street.getHouseNumber(number=request.args.get('housenumber').split()[0])
if hnumber:
return hnumber.getPosition(0)
return {'lat': street.lat, 'lng': street.lng}
return {}
elif request.args.get('action') == 'defaultposition':
return {'defaultlat': float(Settings.get('defaultLat')),
'defaultlng': float(Settings.get('defaultLng')),
'defaultzoom': int(Settings.get('defaultZoom'))}
elif request.args.get('action') == 'alarmposition':
alarm = Alarm.getAlarms(id=request.args.get('alarmid'))
if alarm:
return {'id': request.args.get('alarmid'), 'alarmlat': alarm.lat, 'alarmlng': alarm.lng,
'alarmzoom': alarm.zoom, 'marker': alarm.marker, 'alarmprio': alarm.priority,
'alarmstreet': alarm.street.name, 'alarmstreetno': alarm.get('streetno'),
'alarmstreet2': alarm.get('address2'), 'alarmcity': alarm.city.name,
'alarmsubcity': alarm.street.subcity}
else:
return {'id': '0'}
elif request.args.get('action') == 'streetslookup':
streets = {}
cities = {}
for c in City.getCities():
cities[c.id] = c.name
for k, street in c.streets.iteritems():
if street.active:
try:
streets[str(street.id)] = '%s (%s)' % (street.name, c.name)
except:
streets[str(street.id)] = '%s (-%s-)' % (street.name, street.cityid)
return streets
elif request.args.get('action') == 'defaultmap':
dmap = Map.getDefaultMap()
return {'tileserver': dmap.tileserver, 'name': dmap.name}
return ""
def getMapBox(tilepath="", mappath="", zoom=DEFAULTZOOM):
"""
Deliver a hashmap with the bounding box of current map definition
:param tilepath: path to tile images
:param mappath:
:param zoom: zoom level
:return: hashmap with parameters
"""
ret = dict(mappath=[],
coord=[],
min_lngtile=10000,
min_lattile=10000,
max_lngtile=0,
max_lattile=0,
min_lngdeg=0.0,
max_lngdeg=0.0,
min_latdeg=0.0,
max_latdeg=0.0)
"""Default hashmap"""
for path, dirs, files in os.walk('%s%s' % (tilepath, mappath)):
if path.endswith('/%s' % zoom) or path.endswith('\\%s' % zoom):
for _file in files:
lat, lng = _file.split(".")[0].split('-')
# build bounding box
if int(lat) < ret['min_lattile']:
ret['min_lattile'] = int(lat)
if int(lat) > ret['max_lattile']:
ret['max_lattile'] = int(lat)
if int(lng) < ret['min_lngtile']:
ret['min_lngtile'] = int(lng)
if int(lng) > ret['max_lngtile']:
ret['max_lngtile'] = int(lng)
lat1, lng1 = Settings.num2deg(ret['min_lattile'],
ret['min_lngtile'], zoom)
lat2, lng2 = Settings.num2deg(ret['max_lattile'] + 1,
ret['max_lngtile'] + 1, zoom)
lat = [lat1, lat2]
lng = [lng1, lng2]
lat.sort()
lng.sort()
ret['min_latdeg'] = lat[0]
ret['max_latdeg'] = lat[-1]
ret['min_lngdeg'] = lng[0]
ret['max_lngdeg'] = lng[-1]
ret['mappath'].append(_file.replace('-', '/'))
ret['coord'].append('.'.join(_file.split('.')[:-1]))
break
return ret
def getExportData(exportformat, **params):
"""
Export alarm to given format
:param exportformat: *.html*, *.png*
:param params:
- style: exportstyle: *alarmmap*, *routemap*
- filename: name of exportfile
:return: alarm in correct format
"""
if params['id'] and params:
alarm = Alarm.getAlarms(id=params['id'])
logger.debug('load export data for alarm {}, style {}, exportformat {}'.format(params['id'], params['style'], exportformat))
if not alarm: # create dummy alarm
alarm = Alarm(datetime.datetime.now(), '', 2, 0)
alarm.position = dict(lat=Settings.get('defaultLat'), lng=Settings.get('defaultLng'))
alarm.set('id.key', '1')
alarm.set('id.address', '1')
alarm.set('id.city', '1')
alarm.set('remark', 'TEST TEST TEST')
if alarm:
if exportformat == '.html' and 'style' in params: # build html-template
params.update({'alarm': alarm})
try:
if params['style'].startswith(u'report'):
return render_template('{}.html'.format(params['style']), **params)
else:
return render_template('print.{}.html'.format(params['style']), **params)
except TemplateNotFound:
logger.error('template {}{} not found'.format(params['style'], exportformat))
return abort(404)
elif exportformat == '.png': # send image file
if params['style'].startswith('alarmmap'): # deliver map for alarmid
from emonitor.modules.maps.map_utils import getAlarmMap
args = dict()
if params['style'] != 'alarmmap':
args = dict(style=params['style'].split('_')[-1])
return getAlarmMap(alarm, current_app.config.get('PATH_TILES'), **args)
elif params['style'] == 'routemap': # deliver map with route
from emonitor.modules.maps.map_utils import getAlarmRoute
return getAlarmRoute(alarm, current_app.config.get('PATH_TILES'))
if 'filename' in params and os.path.exists("%s/inc/%s.png" % (os.path.abspath(os.path.dirname(__file__)), params['filename'])):
with open("%s/inc/%s.png" % (os.path.abspath(os.path.dirname(__file__)), params['filename']), 'rb') as f:
return f.read()
abort(404)
def addParameters(self, **kwargs):
"""
Add special parameters for weather widget *messages.weather.\**
check https://developer.yahoo.com/yql/console/ for online editor
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
location = kwargs['message'].attributes['weather.location']
icons = kwargs['message'].attributes['weather.icons']
forecast = kwargs['message'].attributes['weather.forecast']
else:
location = Settings.get('messages.weather.location')
icons = Settings.get('messages.weather.icons')
forecast = Settings.get('messages.weather.forecast')
if not self.lastcall or datetime.datetime.now() > self.lastcall + datetime.timedelta(hours=1):
# reload data from web
compass = ['N', 'NNO', 'NO', 'ONO', 'O', 'OSO', 'SO', 'SSO', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW', 'N']
baseurl = "https://query.yahooapis.com/v1/public/yql?"
yql_query = u'select * from weather.forecast where woeid in (select woeid from geo.places(1) where text="{}") and u="c"'.format(location).encode('utf-8')
yql_url = baseurl + urllib.urlencode({'q': yql_query}) + "&format=json"
try:
result = urllib2.urlopen(yql_url).read()
self.data = json.loads(result)
self.data = self.data['query']['results']['channel']
except urllib2.URLError:
self.data = {}
try:
self.data['wind']['directionstring'] = compass[int(int(self.data['wind']['direction']) / 22.5)]
except (KeyError, ValueError):
self.data['wind'] = {}
self.data['wind']['directionstring'] = ""
if 'astronomy' not in self.data:
self.data['astronomy'] = {'sunrise': {}, 'sunset': {}}
if 'am' in self.data['astronomy']['sunrise']:
self.data['astronomy']['sunrise'] = self.data['astronomy']['sunrise'][:-3]
if 'pm' in self.data['astronomy']['sunset']:
self.data['astronomy']['sunset'] = self.data['astronomy']['sunset'][:-3].split(':')
self.data['astronomy']['sunset'][0] = "%s" % (12 + int(self.data['astronomy']['sunset'][0]))
self.data['astronomy']['sunset'] = ':'.join(self.data['astronomy']['sunset'])
self.lastcall = datetime.datetime.now()
try:
self.data['lastBuildDate'] = datetime.datetime.strptime(self.data['lastBuildDate'][:-5], '%a, %d %b %Y %I:%M %p').strftime('%d.%m.%Y %H:%M')
except ValueError:
self.data['lastBuildDate'] = datetime.datetime.now().strftime('%d.%m.%Y %H:%M')
kwargs.update({'location': location, 'icons': icons, 'forecast': forecast, 'data': self.data})
self.params = kwargs
def getFrontendContent(**params):
"""
Deliver frontend content of module maps
:return: data of maps
"""
if 'area' not in params.keys() and request.args.get('area', '') != '':
params['area'] = request.args.get('area')
if 'area' in params.keys() and params['area'] in ['west', 'center', 'east']: # select view
tiledefs = [d for d in Settings.get('mapitemdefinition') if d['parameters']['tileserver'] == '1']
return render_template('frontend.map.html', maps=Map.getMaps(), defaultlat=Settings.get('defaultLat'), defaultlng=Settings.get('defaultLng'), defaultzoom=Settings.get('defaultZoom'), maptype="" or Map.getDefaultMap(), tiledefs=tiledefs)
return "default"
def updateToken(self, token=None):
"""
update token after changes
:return: botname
"""
from telegram.ext import Updater
from telegram.error import InvalidToken, Unauthorized, NetworkError
try:
self.updater = Updater(token or Settings.get('telegramkey'))
if self.updater.bot.getMe():
self.botname = self.updater.bot.getMe().name
except InvalidToken:
self.updater = None
self.botname = None
logger.error('telegram module not functional')
except Unauthorized:
self.botname = None
except NetworkError:
self.logger.error("network error")
except:
self.updater = None
self.botname = None
logger.error('telegram module not functional')
return self.botname
def handleEvent(eventname, **kwargs):
hdl = [hdl for hdl in Eventhandler.getEventhandlers(event=eventname) if hdl.handler == 'emonitor.communication.Communication'][0]
if hdl:
from emonitor.extensions import communication
params = {}
for p in hdl.getParameterValues('in'):
params[p[0].split('.')[-1]] = p[1]
if params["sendertype"] == 'telegram':
for group, members in Settings.getYaml('telegramsettings').__dict__['groups'].items():
if group == params['group']:
from telegram import InlineKeyboardMarkup, InlineKeyboardButton
args = {'id': int(kwargs.get('alarmid')), 'style': params['style'], 'addressees': members[:-1], 'keyboard': InlineKeyboardMarkup, 'button': InlineKeyboardButton}
attrs = Alarm.getExportData('telegram', **args)
for member in members[:-1]:
if params['id'] == 'alarmid': # send alarm details with location
try:
if params.get('style') in ['text', 'details']:
communication.telegram.sendMessage(member, attrs['details'], reply_markup=attrs['reply'])
elif params.get('style') == 'venue':
communication.telegram.sendVenue(member, attrs['text'], lat=attrs['lat'], lng=attrs['lng'], address=attrs['address'], reply_markup=attrs['reply'])
except:
print "error handleEvent"
return kwargs
elif params["sendertype"] == 'mailer':
# TODO: implement mail notification
pass
return kwargs
def getCallString(self,
pdffilename="",
**params): # get formated callstring
from emonitor import app
callstring = Settings.get('printer.callstring')
callstring = callstring.replace('[basepath]',
app.config.get('PROJECT_ROOT'))
if self.printer == '<default>': # use default printer
callstring = callstring.replace('-printer [printer]', '')
else:
if 'printer' in params:
callstring = callstring.replace(
'[printer]', '"{}"'.format(params['printer']))
else:
callstring = callstring.replace('[printer]',
'"{}"'.format(self.printer))
try:
if 'copies' in params:
callstring = callstring.replace('[copies]',
"{}".format(params['copies']))
else:
callstring = callstring.replace('[copies]', self.settings[0])
except IndexError:
callstring = callstring.replace('[copies]', '1')
callstring = callstring.replace('[filename]', pdffilename)
return callstring
def frontendContent(module=u""):
"""
Frontend area is reachable under *http://[servername]:[port]/[module]*
:param module: module name as string
:return: renderd HTML-outpu of module or startpage
"""
if module != "":
if module == "none":
return render_template("frontend.area.html")
try:
current_mod = [
frontend.modules[m]
for m in frontend.modules
if frontend.modules[m].info["path"] == module.split("/")[0]
][0]
except IndexError:
current_mod = frontend.modules["startpages"]
return current_mod.getFrontendContent()
current_mod = frontend.modules["startpages"]
return render_template(
"frontendframe.html",
user=User.getUsers(login.current_user.get_id() or -1),
current_mod=current_mod,
modules=frontend.modules,
app_name=current_app.config.get("PROJECT"),
app_version=current_app.config.get("APP_VERSION"),
areas=Settings.getFrontendSettings(),
)
def frontendContent(module=u''):
"""
Frontend area is reachable under *http://[servername]:[port]/[module]*
:param module: module name as string
:return: renderd HTML-outpu of module or startpage
"""
if module != "":
if module == 'none':
return render_template('frontend.area.html')
try:
current_mod = [
frontend.modules[m] for m in frontend.modules
if frontend.modules[m].info['path'] == module.split('/')[0]
][0]
except IndexError:
current_mod = frontend.modules['startpages']
return current_mod.getFrontendContent()
current_mod = frontend.modules['startpages']
return render_template('frontendframe.html',
user=User.getUsers(login.current_user.get_id()
or -1),
current_mod=current_mod,
modules=frontend.modules,
app_name=current_app.config.get('PROJECT'),
app_version=current_app.config.get('APP_VERSION'),
areas=Settings.getFrontendSettings())
def updateToken(self, token=None):
"""
update token after changes
:return: botname
"""
from telegram.ext import Updater
from telegram.error import InvalidToken, Unauthorized, NetworkError
try:
self.updater = Updater(token or Settings.get('telegramkey'))
if self.updater.bot.getMe():
self.botname = self.updater.bot.getMe().name
except InvalidToken:
self.updater = None
self.botname = None
logger.error('telegram module not functional')
except Unauthorized:
self.botname = None
except NetworkError:
self.logger.error("network error")
except:
self.updater = None
self.botname = None
logger.error('telegram module not functional')
return self.botname
def getOCRParams():
"""
Get dict with OCR parameters
:return: *callstring*, *inputformat*, *inputtextformat*
"""
ret = {'callstring': '', 'inputformat': '', 'inputtextformat': ''}
for v in Settings.query.filter(Settings.name.like('ocr.%')).all():
ret[v.name.split('.')[-1]] = v.value
if Settings.query.filter(Settings.name.like('ocr.%')).count() == 0: # use default values
db.session.add(Settings.set('ocr.inputformat', DEFAULTINPUTFORMAT))
db.session.add(Settings.set('ocr.inputtextformat', DEFAULTINPUTTEXTFORMAT))
db.session.add(Settings.set('ocr.callstring', DEFAULTCALLSTRING))
db.session.commit()
return Ocr.getOCRParams()
return ret
def msg_start(bot, update, **kwargs):
"""
send start message and add user id to emonitor user if found
:param bot:
:param update:
:param kwargs:
"""
for person in TelegramBot.users.getPersons():
if person.firstname == update.message.from_user[
'first_name'] and person.lastname == update.message.from_user[
'last_name']:
TelegramBot.logger.info(
'add telegramid {} to user {} {}'.format(
update.message.from_user['id'], person.firstname,
person.lastname))
_additional = person.options
_additional['telegramid'] = update.message.from_user['id']
person._options = yaml.safe_dump(_additional, encoding='utf-8')
db.session.commit()
msgtext = Settings.get('telegramsettings')[
'welcomemsg'] or babel.gettext('telegram.default.welcomemsg')
bot.sendMessage(update.message.chat_id,
text=msgtext.format(
vorname=update.message.from_user.first_name,
nachname=update.message.from_user.last_name))
TelegramBot.logger.info(
'send message from "msg_start" to {} {}'.format(
update.message.from_user.first_name,
update.message.from_user.last_name))
def addParameters(self, **kwargs):
"""
Add special parameters for widget and create content of widget from MessageType
:param kwargs: list of parameters for update
"""
content = ""
if 'clientid' in kwargs:
messages = filter(lambda x: x.currentState and kwargs['clientid'] in x.monitors, Messages.getActiveMessages())
else:
messages = filter(lambda x: x.currentState, Messages.getActiveMessages())
kwargs.update({'settings': Settings})
if len(messages) > 0:
for message in messages:
kwargs.update({'message': message, 'count': len(messages)})
pos = render_template('monitor.messages.position.html', number=len(messages), position=messages.index(message))
content += '<div class="slide">%s%s</div>\n' % (message.type.getMonitorContent(**kwargs), pos)
else: # load default message widget
for mt in MessageType.getMessageTypes():
if mt[0] == Settings.get('messages.base.default'):
kwargs.update({'footer': 1}) # set footer
content = mt[1].getMonitorContent(**kwargs)
kwargs.update({'content': content, 'count': len(messages)})
if len(messages) > 0:
kwargs.update({'footer': 1})
self.params = kwargs
return kwargs
def updateCommunicator(self, commtype):
for key, communicator in self.__dict__.items():
if key == commtype:
self.__dict__[key] = TelegramBot(
app=Communication.app,
token=Settings.get('telegramsettings')['telegramkey']
or Communication.app.config.get('TELEGRAMKEY'))
return self.__dict__[key]
def addParameters(self, **kwargs):
"""
Add special parameters for birthday widget *messages.birthday.\**
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
content = kwargs['message'].get('content')
template = kwargs['message'].get('template')
n = int(kwargs['message'].get('number'))
orientation = kwargs['message'].get('orientation')
else:
content = Settings.get('messages.birthday.content')
template = "" # todo define templates
n = int(Settings.get('messages.birthday.number', 20))
orientation = Settings.get('messages.birthday.orientation', 20)
persons = sorted(Person.getPersons(onlyactive=True), key=lambda p: p.birthday)
val, idx = min((val.birthday - int(datetime.datetime.now().strftime('%j')), idx) for (idx, val) in enumerate(persons) if val.birthday - int(datetime.datetime.now().strftime('%j')) >= 0)
person = OrderedDict()
# calculate correct slice of birthdays
#for j in range(idx - (n / 2), idx + (n / 2)):
# p = persons[j % (len(persons))]
# if p.birthdate.strftime('%d.%m.') not in person.keys():
# person[p.birthdate.strftime('%d.%m.')] = []
# person[p.birthdate.strftime('%d.%m.')].append(p)
x = 0
while len(person.keys()) < n / 2: # lower
p = persons[(idx - x) % (len(persons))]
if p.birthdate.strftime('%d.%m.') not in person.keys():
person[p.birthdate.strftime('%d.%m.')] = []
person[p.birthdate.strftime('%d.%m.')].append(p)
x += 1
x = 1
person = OrderedDict(sorted(person.items(), key=lambda t: t[0])) # order dates
while len(person.keys()) < n: # upper
p = persons[(idx + x) % (len(persons))]
if p.birthdate.strftime('%d.%m.') not in person.keys():
person[p.birthdate.strftime('%d.%m.')] = []
person[p.birthdate.strftime('%d.%m.')].append(p)
x += 1
kwargs.update({'content': content, 'template': template, 'persons': person, 'daynum': int((datetime.datetime.now()).strftime('%j'))})
self.params = kwargs
def getAdminData(self):
"""
Deliver admin content of module mapitems (ajax)
:return: rendered template as string or json dict
"""
if request.args.get('action') == 'loadfromosm': # load all objects from osm
itemdefinition = [t for t in Settings.get('mapitemdefinition') if t['name'] == request.args.get('type')][0]
dbodmids = [int(i.osmid) for i in MapItem.getMapitems(itemtype=itemdefinition['name'])]
for cid in itemdefinition['cities']:
city = City.getCities(id=cid)
for item in MapItem.loadFromOSM(itemdefinition, city.name):
if int(item['id']) > 0 and int(item['id']) not in dbodmids: # add item
attrs = item.copy()
del attrs['id']
db.session.add(MapItem(itemdefinition['name'], int(item['id']), attrs))
else: # update
pass # TODO write update method
db.session.commit()
elif request.args.get('action') == 'uploadlayouter':
if request.files:
ufile = request.files['uploadfile']
if not os.path.exists('%s/emonitor/modules/alarms/inc/%s' % (current_app.config.get('PROJECT_ROOT'), ufile.filename)):
ufile.save('%s/emonitor/modules/mapitems/inc/%s' % (current_app.config.get('PROJECT_ROOT'), ufile.filename))
try:
cls = imp.load_source('emonitor.modules.mapitems.inc', 'emonitor/modules/mapitems/inc/%s' % ufile.filename)
if isinstance(getattr(cls, cls.__all__[0])(), ItemLayout):
return "ok"
except:
pass
os.remove('%s/emonitor/modules/mapitems/inc/%s' % (current_app.config.get('PROJECT_ROOT'), ufile.filename))
return babel.gettext(u'admin.mapitems.layouternotvalid')
return ""
elif request.args.get('action') == 'buildtiles':
itemdefinition = [t for t in Settings.get('mapitemdefinition') if t['name'] == request.args.get('type')][0]
for layouter in MapItem.getLayouters():
if layouter.getName() == itemdefinition['parameters']['layout']:
scheduler.add_job(layouter.buildTiles, args=[MapItem.getMapitems(itemdefinition['name']), itemdefinition['attributes']])
break
return ""
def addParameters(self, **kwargs):
"""
Add special parameters for birthday widget *messages.birthday.\**
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
content = kwargs['message'].get('content')
template = kwargs['message'].get('template')
n = int(kwargs['message'].get('number'))
orientation = kwargs['message'].get('orientation')
else:
content = Settings.get('messages.birthday.content')
template = "" # todo define templates
n = int(Settings.get('messages.birthday.number', 20))
orientation = Settings.get('messages.birthday.orientation', 20)
persons = sorted(Person.getPersons(onlyactive=True),
key=lambda p: p.birthday)
p = [((val.birthday - int(datetime.datetime.now().strftime('%j'))) %
365, idx, persons[idx].lastname, persons[idx].birthdate)
for (idx, val) in enumerate(persons)]
idx = min(filter(lambda x: x[0] >= 0, p))
person = OrderedDict()
try:
for i in range(idx[1] - (n / 2) + 1, idx[1] + (n / 2) + 2):
_p = persons[i % (len(p))]
if _p.birthdate.strftime('%d.%m.') not in person.keys():
person[_p.birthdate.strftime('%d.%m.')] = []
person[_p.birthdate.strftime('%d.%m.')].append(_p)
for _p in persons:
if _p.birthdate.strftime('%d.%m.') in person.keys(
) and _p not in person[_p.birthdate.strftime('%d.%m.')]:
person[_p.birthdate.strftime('%d.%m.')].append(_p)
except:
pass
kwargs.update({
'content': content,
'template': template,
'persons': person,
'daynum': int((datetime.datetime.now()).strftime('%j')),
'orientation': orientation
})
self.params = kwargs
def getConvertParams():
"""
Get dict with configuration parameters for conversion
:return: *callstring*, *format*
"""
ret = {'callstring': '', 'format': ''}
for v in Settings.query.filter(Settings.name.like('convert.%')):
if v.name == 'convert.format':
ret['format'] = v.value
elif v.name == 'convert.callstring':
ret['callstring'] = v.value
if Settings.query.filter(Settings.name.like('convert.%')).count() == 0: # use default values
db.session.add(Settings.set('convert.format', DEFAULTIMAGECONVERTFORMAT))
db.session.add(Settings.set('convert.callstring', DEFAULTIMAGECONVERTCALL))
db.session.commit()
return Ocr.getConvertParams()
return ret
def getOCRParams():
"""
Get dict with OCR parameters
:return: *callstring*, *inputformat*, *inputtextformat*
"""
ret = {'callstring': '', 'inputformat': '', 'inputtextformat': ''}
for v in Settings.query.filter(Settings.name.like('ocr.%')).all():
ret[v.name.split('.')[-1]] = v.value
if Settings.query.filter(Settings.name.like(
'ocr.%')).count() == 0: # use default values
db.session.add(Settings.set('ocr.inputformat', DEFAULTINPUTFORMAT))
db.session.add(
Settings.set('ocr.inputtextformat', DEFAULTINPUTTEXTFORMAT))
db.session.add(Settings.set('ocr.callstring', DEFAULTCALLSTRING))
db.session.commit()
return Ocr.getOCRParams()
return ret
def getColor(self):
"""
Get color of car, default *#ffffff*
:return: colorcode
"""
for t in Settings.getCarTypes():
if t[0] == self.type:
return t[1]
return "#ffffff"
def msg_help(bot, update, **kwargs):
"""
send information about the bot
:param bot:
:param update:
:param kwargs:
"""
msgtext = Settings.get('telegramsettings')['helpmsg'] or babel.gettext('telegram.default.helpmsg')
bot.sendMessage(update.message.chat_id, msgtext, parse_mode='Markdown')
TelegramBot.logger.debug("help_msg sent.")
def getColor(self):
"""
Get color of car, default *#ffffff*
:return: colorcode
"""
for t in Settings.getCarTypes():
if t[0] == self.type:
return t[1]
return "#ffffff"
def msg_help(bot, update, **kwargs):
"""
send information about the bot
:param bot:
:param update:
:param kwargs:
"""
msgtext = Settings.get('telegramsettings')['helpmsg'] or babel.gettext(
'telegram.default.helpmsg')
bot.sendMessage(update.message.chat_id, msgtext, parse_mode='Markdown')
TelegramBot.logger.debug("help_msg sent.")
def addParameters(self, **kwargs):
"""
choose implementation of weather channel
:param kwargs:
:return: list of parameters, weather dict added
"""
if kwargs.get('message', {'weather.type': Settings.get('messages.weather.type', '')}).get('weather.type') in ['', 'yahoo']:
return self._addParametersYahoo(**kwargs)
else:
return self._addParametersOWM(**kwargs)
def updateAdminSubNavigation(self):
"""
Add submenu entries for admin area
"""
from sqlalchemy.exc import OperationalError
self.adminsubnavigation = []
try:
for maptype in Settings.get('mapitemdefinition'):
self.adminsubnavigation.append(('/admin/mapitems/%s' % maptype['name'], '%s' % maptype['name']))
except OperationalError:
pass
self.adminsubnavigation.append(('/admin/mapitems/definition', 'mapitems.definition'))
def type(self):
"""
Get message type as MessageType class object
:return: :py:class:`emonitor.modules.messages.messagetype.MessageType`
"""
if self._type == '':
self._type = Settings.get('messages.base.type')
impl = filter(lambda x: x[0].split('.')[0] == self._type, MessageType.getMessageTypes())
if len(impl) == 1:
return impl[0][1]
return None
def __init__(self, app):
Module.__init__(self, app)
# add template path
app.jinja_loader.searchpath.append(
"%s/emonitor/modules/settings/templates" %
app.config.get('PROJECT_ROOT'))
self.widgets = [CrestWidget('departmentcrest')]
# subnavigation
self.adminsubnavigation = [
('/admin/settings', 'settings.main'),
('/admin/settings/department', 'module.settings.department'),
('/admin/settings/cars', 'module.settings.cars'),
('/admin/settings/communication', 'module.settings.communication'),
('/admin/settings/start', 'module.settings.start')
]
# static folders
@app.route('/settings/inc/<path:filename>')
def settings_static(filename):
return send_from_directory(
"%s/emonitor/modules/settings/inc/" %
app.config.get('PROJECT_ROOT'), filename)
# translations
babel.gettext(u'module.settings')
babel.gettext(u'settings.main')
babel.gettext(u'module.settings.department')
babel.gettext(u'module.settings.cars')
babel.gettext(u'module.settings.communication')
babel.gettext(u'module.settings.start')
babel.gettext(u'settings.pathtype.pathdone')
babel.gettext(u'settings.pathtype.pathtmp')
babel.gettext(u'settings.pathtype.pathdata')
babel.gettext(u'settings.pathtype.pathincome')
babel.gettext(u'departmentcrest')
babel.gettext(u'telegram.default.welcomemsg')
# add default values
if Settings.query.count() == 0: # add default values
db.session.add(Settings.set('defaultZoom', 15))
db.session.add(Settings.set('startLat', ''))
db.session.add(Settings.set('startLng', ''))
db.session.add(Settings.set('homeLat', ''))
db.session.add(Settings.set('homeLng', ''))
db.session.add(
Settings.set(
'alarms.evalfields',
'_bab_\r\n_train_\r\n_street_\r\n_default_city_\r\n_interchange_\r\n_kilometer_\r\n_bma_\r\n_bma_main_\r\n_bma_key_\r\n_train_identifier_'
))
db.session.add(Settings('cartypes', "- [car, '#ffffff']\n"))
db.session.commit()
def getMapBox(tilepath="", mappath="", zoom=DEFAULTZOOM):
"""
Deliver a hashmap with the bounding box of current map definition
:param tilepath: path to tile images
:param mappath:
:param zoom: zoom level
:return: hashmap with parameters
"""
ret = dict(mappath=[], coord=[], min_lngtile=10000, min_lattile=10000, max_lngtile=0, max_lattile=0,
min_lngdeg=0.0, max_lngdeg=0.0, min_latdeg=0.0, max_latdeg=0.0)
"""Default hashmap"""
for path, dirs, files in os.walk('%s%s' % (tilepath, mappath)):
if path.endswith('/%s' % zoom) or path.endswith('\\%s' % zoom):
for _file in files:
lat, lng = _file.split(".")[0].split('-')
# build bounding box
if int(lat) < ret['min_lattile']: ret['min_lattile'] = int(lat)
if int(lat) > ret['max_lattile']: ret['max_lattile'] = int(lat)
if int(lng) < ret['min_lngtile']: ret['min_lngtile'] = int(lng)
if int(lng) > ret['max_lngtile']: ret['max_lngtile'] = int(lng)
lat1, lng1 = Settings.num2deg(ret['min_lattile'], ret['min_lngtile'], zoom)
lat2, lng2 = Settings.num2deg(ret['max_lattile'] + 1, ret['max_lngtile'] + 1, zoom)
lat = [lat1, lat2]
lng = [lng1, lng2]
lat.sort()
lng.sort()
ret['min_latdeg'] = lat[0]
ret['max_latdeg'] = lat[-1]
ret['min_lngdeg'] = lng[0]
ret['max_lngdeg'] = lng[-1]
ret['mappath'].append(_file.replace('-', '/'))
ret['coord'].append('.'.join(_file.split('.')[:-1]))
break
return ret
def convertFileType(path, inname):
from emonitor import app
i = t = 0
params = Ocr.getOCRParams()
convertparams = Ocr.getConvertParams()
ext = os.path.splitext(inname)[-1]
inname = os.path.splitext(inname)[0]
if ext[1:] not in params['inputformat']:
return 0, 0.0
path2 = app.config.get('PATH_TMP')
if "/" in inname or "\\" in inname or ":" in inname:
path = path2 = ""
while 1:
try:
stime = time.time()
callstring = convertparams['callstring']
callstring = callstring.replace('[basepath]',
app.config.get('PROJECT_ROOT'))
callstring = callstring.replace('[incomepath]', path)
callstring = callstring.replace(
'[filename]', '{}{}[{}]'.format(inname, ext, i))
callstring = callstring.replace(
'[tmppath]', '{}{}-%d.{}'.format(path2, inname,
convertparams['format']))
logger.debug('run image conversion with {}'.format(callstring))
subprocess.check_output(callstring,
stderr=subprocess.STDOUT,
shell=True)
if i > -1:
im = Image.open('{}{}-{}.{}'.format(
path2, inname, i, convertparams['format']))
w, h = im.size
# remove header line = 1/4 of quality
if Settings.get('convert.crop' == 'True'):
im.crop((0, 100, w, h - 100)).save(
'{}{}-{}.{}'.format(path2, inname, i,
convertparams['format']),
convertparams['format'].upper())
i += 1
t = time.time() - stime
if ext[1:] in ['jpg', 'jpeg', 'tif', 'tiff',
'png']: # tif and jpg with only one page
break
except:
break
return i, t
def updateSchedules(self, reference=0):
"""
set scheduler events for current alarm:
* autoclose
* autoarchive
:param reference: 0 (default)= time.time()
1 = alarm.timestamp
"""
for job in scheduler.get_jobs(): # remove schedules of current alarm
if job.name.startswith('alarms_') and job.name.endswith('_{}'.format(self.id)):
scheduler.remove_job(job.id)
if reference == 0:
reference = time.time()
else:
reference = time.mktime(self.timestamp.timetuple())
# test autoclose
if self.state == 1 and self.type == 1 and Settings.get('alarms.autoclose', '0') != '0': # only for open alarms
closingtime = reference + float(Settings.get('alarms.autoclose', 30)) * 60.0 # minutes -> seconds
if closingtime > time.time(): # close alarm in future
logger.debug("add close schedule in future for alarmid {}".format(self.id))
scheduler.add_job(self.changeState, run_date=datetime.datetime.fromtimestamp(closingtime), args=[self.id, 2], name="alarms_close_{}".format(self.id))
else: # close alarm now
logger.debug("add close schedule now for alarmid {}".format(self.id))
scheduler.add_job(self.changeState, args=[self.id, 2], name="alarms_close_{}".format(self.id))
self.state = 2
# test autoarchive
if self.state == 2 and Settings.get('alarms.autoarchive', '0') != '0': # only closed alarms
archivetime = reference + float(Settings.get('alarms.autoarchive', 12)) * 3600.0 # hours -> seconds
if archivetime > time.time(): # archive alarm in future
logger.debug("add archive schedule in future for alarmid {}".format(self.id))
scheduler.add_job(self.changeState, run_date=datetime.datetime.fromtimestamp(archivetime), args=[self.id, 3], name="alarms_archive_{}".format(self.id))
else: # archive alarm now
logger.debug("add archive schedule now for alarmid {}".format(self.id))
scheduler.add_job(self.changeState, args=[self.id, 3], name="alarms_archive_{}".format(self.id))
def updateSchedules(self, reference=0):
"""
set scheduler events for current alarm:
* autoclose
* autoarchive
:param reference: 0 (default)= time.time()
1 = alarm.timestamp
"""
for job in scheduler.get_jobs(): # remove schedules of current alarm
if job.name.startswith('alarms_') and job.name.endswith('_{}'.format(self.id)):
scheduler.remove_job(job.id)
if reference == 0:
reference = time.time()
else:
reference = time.mktime(self.timestamp.timetuple())
# autoclose
if self.state == 1 and self.type == 1 and Settings.get('alarms.autoclose', '0') != '0': # only for open alarms
closingtime = reference + float(Settings.get('alarms.autoclose', 30)) * 60.0 # minutes -> seconds
if closingtime > time.time(): # close alarm in future
logger.debug("add close schedule in future for alarmid {}".format(self.id))
scheduler.add_job(Alarm.changeState, run_date=datetime.datetime.fromtimestamp(closingtime), args=[self.id, 2], name="alarms_close_{}".format(self.id))
else: # close alarm now
logger.debug("add close schedule now for alarmid {}".format(self.id))
scheduler.add_job(Alarm.changeState, args=[self.id, 2], name="alarms_close_{}".format(self.id))
self.state = 2
# autoarchive
if self.state == 2 and Settings.get('alarms.autoarchive', '0') != '0': # only closed alarms
archivetime = reference + float(Settings.get('alarms.autoarchive', 12)) * 3600.0 # hours -> seconds
if archivetime > time.time(): # archive alarm in future
logger.debug("add archive schedule in future for alarmid {}".format(self.id))
scheduler.add_job(Alarm.changeState, run_date=datetime.datetime.fromtimestamp(archivetime), args=[self.id, 3], name="alarms_archive_{}".format(self.id))
else: # archive alarm now
logger.debug("add archive schedule now for alarmid {}".format(self.id))
scheduler.add_job(Alarm.changeState, args=[self.id, 3], name="alarms_archive_{}".format(self.id))
def getAdminContent(self, **params):
"""
Deliver admin content of module messages
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
if 'saveparameters' in request.form.keys(): # save parameters for modules
for k in [k for k in request.form if k != 'saveparameters']:
Settings.set("messages.%s" % k, request.form.get(k))
monitorserver.sendMessage('0', 'reset') # refresh monitor layout
if len(module) == 2:
if module[1] == 'types': # type submodule
params.update({'implementations': MessageType.getMessageTypes()})
return render_template('admin.messages.types.html', **params)
else:
messages = {'1': Messages.getMessages(state=1), '0': Messages.getMessages(state=0)}
params.update({'messages': messages})
return render_template('admin.messages.html', **params)
def addParameters(self, **kwargs):
"""
choose implementation of weather channel
:param kwargs:
:return: list of parameters, weather dict added
"""
if kwargs.get('message', {
'weather.type': Settings.get('messages.weather.type', '')
}).get('weather.type') in ['', 'yahoo']:
return self._addParametersYahoo(**kwargs)
else:
return self._addParametersOWM(**kwargs)
def type(self):
"""
Get message type as MessageType class object
:return: :py:class:`emonitor.modules.messages.messagetype.MessageType`
"""
if self._type == '':
self._type = Settings.get('messages.base.type')
impl = filter(lambda x: x[0].split('.')[0] == self._type,
MessageType.getMessageTypes())
if len(impl) == 1:
return impl[0][1]
return None
def handleEvent(eventname, **kwargs):
hdl = [
hdl for hdl in Eventhandler.getEventhandlers(event=eventname)
if hdl.handler == 'emonitor.communication.Communication'
][0]
if hdl:
from emonitor.extensions import communication
params = {}
for p in hdl.getParameterValues('in'):
params[p[0].split('.')[-1]] = p[1]
if params["sendertype"] == 'telegram':
for group, members in Settings.getYaml(
'telegramsettings').__dict__['groups'].items():
if group == params['group']:
from telegram import InlineKeyboardMarkup, InlineKeyboardButton
args = {
'id': int(kwargs.get('alarmid')),
'style': params['style'],
'addressees': members[:-1],
'keyboard': InlineKeyboardMarkup,
'button': InlineKeyboardButton
}
attrs = Alarm.getExportData('telegram', **args)
for member in members[:-1]:
if params[
'id'] == 'alarmid': # send alarm details with location
try:
if params.get('style') in [
'text', 'details'
]:
communication.telegram.sendMessage(
member,
attrs['details'],
reply_markup=attrs['reply'])
elif params.get('style') == 'venue':
communication.telegram.sendVenue(
member,
attrs['text'],
lat=attrs['lat'],
lng=attrs['lng'],
address=attrs['address'],
reply_markup=attrs['reply'])
except:
print "error handleEvent"
return kwargs
elif params["sendertype"] == 'mailer':
# TODO: implement mail notification
pass
return kwargs
def addParameters(self, **kwargs):
"""
Add special parameters for text widget *messages.text.\**
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
content = kwargs['message'].get('content')
template = kwargs['message'].get('template') # todo: define templates
else:
content = Settings.get('messages.text.content')
template = "" # todo define templates
kwargs.update({'content': content, 'template': template})
self.params = kwargs
def getConvertParams():
"""
Get dict with configuration parameters for conversion
:return: *callstring*, *format*
"""
ret = {'callstring': '', 'format': '', 'crop': 'True'}
for v in Settings.query.filter(Settings.name.like('convert.%')):
if v.name == 'convert.format':
ret['format'] = v.value
elif v.name == 'convert.callstring':
ret['callstring'] = v.value
elif v.name == 'convert.crop':
ret['crop'] = v.value
if Settings.query.filter(Settings.name.like(
'convert.%')).count() == 0: # use default values
db.session.add(
Settings.set('convert.format', DEFAULTIMAGECONVERTFORMAT))
db.session.add(
Settings.set('convert.callstring', DEFAULTIMAGECONVERTCALL))
db.session.add(Settings.set('convert.crop', 'True'))
db.session.commit()
return Ocr.getConvertParams()
return ret
def updateAdminSubNavigation(self):
"""
Add submenu entries for admin area
"""
from sqlalchemy.exc import OperationalError
self.adminsubnavigation = []
try:
for maptype in Settings.get('mapitemdefinition'):
self.adminsubnavigation.append(
('/admin/mapitems/%s' % maptype['name'],
'%s' % maptype['name']))
except OperationalError:
pass
self.adminsubnavigation.append(
('/admin/mapitems/definition', 'mapitems.definition'))
def getFrontendContent(self, **params):
"""
Get frontend content with areas (west, center, east) to hold modules.
Areas can be configured in :py:class:`emonitor.modules.settings.settings.Settings`
:param params: dict with key `area`
:return: rendered HTML-template of module
"""
if 'area' in params:
defaultarea = dict()
defaultarea['center'] = Settings.getFrontendSettings('center')
defaultarea['west'] = Settings.getFrontendSettings('west')
defaultarea['east'] = Settings.getFrontendSettings('east')
# load module data
if defaultarea[params['area']]['module'] == 'default':
return render_template('frontend.default.html')
elif defaultarea[params['area']]['module'] in current_app.blueprints['frontend'].modules:
return current_app.blueprints['frontend'].modules[defaultarea[params['area']]['module']].getFrontendContent(**params)
else:
current_app.logger.error("module %s not found for frontend area %s" % (defaultarea[params['area']]['module'], params['area']))
return ""
return render_template('frontend.default.html')
def addParameters(self, **kwargs):
"""
Add special parameters for text widget *messages.text.\**
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
content = kwargs['message'].get('content')
template = kwargs['message'].get('template') # todo: define templates
else:
content = Settings.get('messages.text.content')
template = "" # todo define templates
mimetypes.init()
dep = Department.getDefaultDepartment()
kwargs.update(content=content, template=template, crest=dep.getLogoStream(), mime=mimetypes.guess_type(dep.attributes.get('logo', ''))[0])
self.params = kwargs
def msg_start(bot, update, **kwargs):
"""
send start message and add user id to emonitor user if found
:param bot:
:param update:
:param kwargs:
"""
for person in TelegramBot.users.getPersons():
if person.firstname == update.message.from_user['first_name'] and person.lastname == update.message.from_user['last_name']:
TelegramBot.logger.info('add telegramid {} to user {} {}'.format(update.message.from_user['id'], person.firstname, person.lastname))
_additional = person.options
_additional['telegramid'] = update.message.from_user['id']
person._options = yaml.safe_dump(_additional, encoding='utf-8')
db.session.commit()
msgtext = Settings.get('telegramsettings')['welcomemsg'] or babel.gettext('telegram.default.welcomemsg')
bot.sendMessage(update.message.chat_id, text=msgtext.format(vorname=update.message.from_user.first_name, nachname=update.message.from_user.last_name))
TelegramBot.logger.info('send message from "msg_start" to {} {}'.format(update.message.from_user.first_name, update.message.from_user.last_name))
def getCallString(self, pdffilename="", **params): # get formated callstring
from emonitor import app
callstring = Settings.get('printer.callstring')
callstring = callstring.replace('[basepath]', app.config.get('PROJECT_ROOT'))
if self.printer == '<default>': # use default printer
callstring = callstring.replace('-printer [printer]', '')
else:
if 'printer' in params:
callstring = callstring.replace('[printer]', '"{}"'.format(params['printer']))
else:
callstring = callstring.replace('[printer]', '"{}"'.format(self.printer))
try:
if 'copies' in params:
callstring = callstring.replace('[copies]', "{}".format(params['copies']))
else:
callstring = callstring.replace('[copies]', self.settings[0])
except IndexError:
callstring = callstring.replace('[copies]', '1')
callstring = callstring.replace('[filename]', pdffilename)
return callstring
def addParameters(self, **kwargs):
"""
Add special parameters for text widget *messages.text.\**
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
content = kwargs['message'].get('content')
template = kwargs['message'].get(
'template') # todo: define templates
else:
content = Settings.get('messages.text.content')
template = "" # todo define templates
mimetypes.init()
dep = Department.getDefaultDepartment()
kwargs.update(content=content,
template=template,
crest=dep.getLogoStream(),
mime=mimetypes.guess_type(dep.attributes['logo'])[0])
self.params = kwargs
def convertFileType(path, inname):
from emonitor import app
i = t = 0
params = Ocr.getOCRParams()
convertparams = Ocr.getConvertParams()
ext = os.path.splitext(inname)[-1]
inname = os.path.splitext(inname)[0]
if ext[1:] not in params['inputformat']:
return 0, 0.0
path2 = app.config.get('PATH_TMP')
if "/" in inname or "\\" in inname or ":" in inname:
path = path2 = ""
while 1:
try:
stime = time.time()
callstring = convertparams['callstring']
callstring = callstring.replace('[basepath]', app.config.get('PROJECT_ROOT'))
callstring = callstring.replace('[incomepath]', path)
callstring = callstring.replace('[filename]', '{}{}[{}]'.format(inname, ext, i))
callstring = callstring.replace('[tmppath]', '{}{}-%d.{}'.format(path2, inname, convertparams['format']))
logger.debug('run image conversion with {}'.format(callstring))
subprocess.check_output(callstring, stderr=subprocess.STDOUT, shell=True)
if i > -1:
im = Image.open('{}{}-{}.{}'.format(path2, inname, i, convertparams['format']))
w, h = im.size
# remove header line = 1/4 of quality
if Settings.get('convert.crop' == 'True'):
im.crop((0, 100, w, h - 100)).save('{}{}-{}.{}'.format(path2, inname, i, convertparams['format']), convertparams['format'].upper())
i += 1
t = time.time() - stime
if ext[1:] in ['jpg', 'jpeg', 'tif', 'tiff', 'png']: # tif and jpg with only one page
break
except:
break
return i, t
def getAdminContent(self, **params):
"""
Deliver admin content of module alarmobjects
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
def chunks(l, n):
return [l[i:i + n] for i in range(0, len(l), n)]
if len(module) > 1: # type definition
if module[1] == 'types':
if request.method == 'POST':
if request.form.get(
'action') == 'createalarmobjecttype': # add type
params.update({'alarmobjecttype': AlarmObjectType('', '')})
return render_template(
'admin.alarmobjects.types_action.html', **params)
elif request.form.get(
'action') == 'savealarmobjecttype': # save type
if request.form.get(
'alarmobjecttype_id') == 'None': # add new type
alarmobjecttype = AlarmObjectType('', '')
db.session.add(alarmobjecttype)
else: # update existing
alarmobjecttype = AlarmObjectType.getAlarmObjectTypes(
id=int(request.form.get('alarmobjecttype_id')))
alarmobjecttype.name = request.form.get(
'alarmobjecttype_name')
alarmobjecttype.remark = request.form.get(
'alarmobjecttype_remark')
db.session.commit()
elif request.form.get('action').startswith(
'detailobjecttype'): # edit type
alarmobjecttype = AlarmObjectType.getAlarmObjectTypes(
id=int(request.form.get('action').split('_')[-1]))
params.update({'alarmobjecttype': alarmobjecttype})
return render_template(
'admin.alarmobjects.types_action.html', **params)
elif request.form.get('action').startswith(
'deleteobjecttype_'): # delete type
db.session.delete(
AlarmObjectType.getAlarmObjectTypes(
id=int(request.form.get('action').split('_')[-1])))
db.session.commit()
params.update(
{'alarmobjecttypes': AlarmObjectType.getAlarmObjectTypes()})
return render_template('admin.alarmobjects.types.html', **params)
elif module[1] == 'fields':
if request.method == 'POST':
if request.form.get(
'action') == 'updatefield': # update fields
Settings.set('alarmobjectfields', [
i for i in chunks(request.form.getlist('fieldname'), 2)
if i[0] != ''
])
db.session.commit()
params.update({'fields': Settings.get('alarmobjectfields', [])})
return render_template('admin.alarmobjects.fields.html', **params)
else: # base view
if request.method == 'POST':
streets = Street.getStreets()
if request.form.get(
'action') == 'createalarmobject': # add alarmobject
params.update({
'alarmobject':
AlarmObject('', 0, '', Settings.get('defaultLat'),
Settings.get('defaultLng'),
Settings.get('defaultZoom'), '', '', '', 0, 0),
'streets':
streets,
'selectedstreet':
'',
'map':
Map.getDefaultMap(),
'alarmobjecttypes':
AlarmObjectType.getAlarmObjectTypes()
})
return render_template('admin.alarmobjects_actions.html',
**params)
elif request.form.get('action') == 'savealarmobject': # save
if request.form.get('alarmobject_id') == 'None': # add new
alarmobject = AlarmObject('', 0, '', 0, 0, 0, '', '', '',
0, 0)
db.session.add(alarmobject)
else: # update existing
alarmobject = AlarmObject.getAlarmObjects(
id=request.form.get('alarmobject_id'))
alarmobject.name = request.form.get('edit_name')
alarmobject._streetid = request.form.get('streetid')
alarmobject._objecttype = int(
request.form.get('edit_objecttype'))
alarmobject.remark = request.form.get('edit_remark')
if request.form.get('edit_position') == '1':
alarmobject.lat = request.form.get('edit_lat')
alarmobject.lng = request.form.get('edit_lng')
alarmobject.zoom = request.form.get('edit_zoom')
alarmobject.streetno = request.form.get('edit_streetno')
alarmobject.alarmplan = request.form.get('edit_alarmplan')
alarmobject.bma = request.form.get('edit_bma')
alarmobject.active = int(request.form.get('edit_active', '0'))
db.session.commit()
elif request.form.get(
'action'
) == 'savealarmobjectattributes': # save attributes
alarmobject = AlarmObject.getAlarmObjects(
id=request.form.get('alarmobject_id'))
for field in Settings.get('alarmobjectfields',
[]): # store attributes
if 'edit_%s' % field[0] in request.form:
alarmobject.set(field[0],
request.form.get('edit_%s' % field[0]))
db.session.commit()
elif request.form.get(
'action') == 'savealarmobjectaao': # save aao
alarmobject = AlarmObject.getAlarmObjects(
id=request.form.get('alarmobject_id'))
if alarmobject:
alarmobject.set('cars1', [
c for c in request.form.get('cars1').split(';')
if c != ''
])
alarmobject.set('cars2', [
c for c in request.form.get('cars2').split(';')
if c != ''
])
alarmobject.set('material', [
c for c in request.form.get('material').split(';')
if c != ''
])
db.session.commit()
elif request.form.get('action').startswith(
'editalarmobject_'): # edit alarmobject
alarmobject = AlarmObject.getAlarmObjects(
id=int(request.form.get('action').split('_')[-1]))
params.update({
'alarmobject':
alarmobject,
'streets':
streets,
'selectedstreet':
'%s (%s)' %
(alarmobject.street.name, alarmobject.street.city.name),
'map':
Map.getDefaultMap(),
'alarmobjecttypes':
AlarmObjectType.getAlarmObjectTypes(),
'fields':
Settings.get('alarmobjectfields', []),
'cars':
Car.getCars(deptid=Department.getDefaultDepartment().id)
})
return render_template('admin.alarmobjects_actions.html',
**params)
elif request.form.get('action').startswith(
'deletealarmobject_'): # delete alarmobject
db.session.delete(
AlarmObject.getAlarmObjects(
id=int(request.form.get('action').split('_')[-1])))
db.session.commit()
params.update({
'alarmobjects': AlarmObject.getAlarmObjects(active=0),
'alarmobjecttypes': AlarmObjectType.getAlarmObjectTypes()
})
return render_template('admin.alarmobjects.html', **params)
def getFrontendData(self):
"""
Deliver frontend content of module streets (ajax)
:return: rendered template as string or json dict
"""
if request.args.get(
'action'
) == 'streetcoords': # get map parameter for given streetid
if request.args.get('id') not in ['', 'None']:
street = Street.getStreets(id=request.args.get('id'))
return {
'lat': street.lat,
'lng': street.lng,
'zoom': street.zoom,
'way': street.navigation,
'cityid': street.cityid,
'cityname': street.city.name
}
elif request.args.get(
'action') == 'housecoords': # deliver center of housenumbers
if request.args.get('streetid') != '' and request.args.get(
'housenumber') != '':
street = Street.getStreet(id=request.args.get('streetid'))
hnumber = street.getHouseNumber(
number=request.args.get('housenumber').split()[0])
if hnumber:
return hnumber.getPosition(0)
return {'lat': street.lat, 'lng': street.lng}
return {}
elif request.args.get('action') == 'defaultposition':
return {
'defaultlat': float(Settings.get('defaultLat')),
'defaultlng': float(Settings.get('defaultLng')),
'defaultzoom': int(Settings.get('defaultZoom'))
}
elif request.args.get('action') == 'alarmposition':
alarm = Alarm.getAlarms(id=request.args.get('alarmid'))
if alarm:
return {
'id': request.args.get('alarmid'),
'alarmlat': alarm.lat,
'alarmlng': alarm.lng,
'alarmzoom': alarm.zoom,
'marker': alarm.marker,
'alarmprio': alarm.priority,
'alarmstreet': alarm.street.name,
'alarmstreetno': alarm.get('streetno'),
'alarmstreet2': alarm.get('address2'),
'alarmcity': alarm.city.name,
'alarmsubcity': alarm.street.subcity
}
else:
return {'id': '0'}
elif request.args.get('action') == 'streetslookup':
streets = {}
cities = {}
for c in City.getCities():
cities[c.id] = c.name
for k, street in c.streets.iteritems():
if street.active:
try:
streets[str(
street.id)] = '%s (%s)' % (street.name, c.name)
except:
streets[str(street.id)] = '%s (-%s-)' % (street.name,
street.cityid)
return streets
elif request.args.get('action') == 'defaultmap':
dmap = Map.getDefaultMap()
return {'tileserver': dmap.tileserver, 'name': dmap.name}
return ""
logger = logging.getLogger(__name__)
BEFORE = AFTER = {}
events.addEvent('file_added',
handlers=[],
parameters=['out.incomepath', 'out.filename'])
events.addEvent('file_removed',
handlers=[],
parameters=['out.incomepath', 'out.filename'])
OBSERVERACTIVE = 1
ERROR_RAISED = 0
FILES = []
INPUTFORMAT = Settings.get('ocr.inputformat', ['pdf']) + Settings.get(
'ocr.inputtextformat', [])
# noinspection PyPep8Naming
def observeFolder(**kwargs):
"""
Observer method to observe given folder
:param kwargs:
"""
global BEFORE, AFTER, FILES, ERROR_RAISED
if OBSERVERACTIVE == 0:
return
if 'path' in kwargs:
def getAdminContent(self, **params):
"""
Deliver admin content of module textmod
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
if len(module) == 2:
if module[1] == 'ocr': # ocr settings
if request.method == 'POST':
if request.form.get(
'action') == 'savereocrparams': # save changes
Settings.set('ocr.inputformat',
request.form.get('ocr_formats').split('\r\n'))
Settings.set(
'ocr.inputtextformat',
request.form.get('ocr_textformats').split('\r\n'))
Settings.set('ocr.callstring',
request.form.get('ocr_callstring'))
params.update({'params': Ocr.getOCRParams()})
return render_template('admin.textmod.ocr.html', **params)
elif module[1] == 'ocrcustom':
if request.method == 'POST':
if request.form.get(
'action') == 'savereocrcustom': # save changes
if not os.path.exists(
'%s/bin/tesseract/tessdata' %
current_app.config.get('PROJECT_ROOT')):
os.makedirs('%s/bin/tesseract/tessdata/' %
current_app.config.get('PROJECT_ROOT'))
with codecs.open(
'%s/bin/tesseract/tessdata/deu.user-words' %
current_app.config.get('PROJECT_ROOT'), 'w',
'utf-8') as f:
f.write(request.form.get('ocrcustom', ''))
if os.path.exists('%s/bin/tesseract/tessdata/deu.user-words' %
current_app.config.get('PROJECT_ROOT')):
content = codecs.open(
'%s/bin/tesseract/tessdata/deu.user-words' %
current_app.config.get('PROJECT_ROOT'), 'r',
'utf-8').read()
else:
current_app.logger.info('ocr custom wordlist not found')
content = ""
params.update({'content': content})
return render_template('admin.textmod.ocrcustom.html', **params)
elif module[1] == 'convert': # convert image
if request.method == 'POST':
if request.form.get(
'action') == 'savereconvertparams': # save changes
Settings.set('convert.format',
request.form.get('convert_format'))
Settings.set('convert.callstring',
request.form.get('convert_callstring'))
Settings.set(
'convert.crop', 'convert_crop'
in request.form.get('convert_crop', 'False'))
params.update({
'params': Ocr.getConvertParams(),
'imageformats': ['jpg', 'png']
})
return render_template('admin.textmod.convert.html', **params)
else: # replacements
if request.method == 'POST':
if request.form.get('action') == 'addreplace': # add replacement
params.update({'replacement': Replace('', '')})
return render_template('admin.textmod_actions.html', **params)
elif request.form.get('action').startswith(
'editreplace_'): # edit existing replacement
params.update({
'replacement':
Replace.getReplacements(
id=request.form.get('action').split('_')[-1])
})
return render_template('admin.textmod_actions.html', **params)
elif request.form.get('action').startswith(
'deletereplace_'): # delete existing replacement
db.session.delete(
Replace.getReplacements(
id=request.form.get('action').split('_')[-1]))
db.session.commit()
elif request.form.get(
'action') == 'savereplace': # save replacement
if request.form.get('replace_id') == 'None': # add new
db.session.add(
Replace(request.form.get('replace_text'),
request.form.get('replace_repl')))
else: # update existing replacement
replacement = Replace.getReplacements(
id=request.form.get('replace_id'))
replacement.text = request.form.get('replace_text')
replacement.replace = request.form.get('replace_repl')
db.session.commit()
params.update({'replacements': Replace.getReplacements()})
return render_template('admin.textmod.html', **params)
