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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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())
# 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 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 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 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 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 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 getFrontendContent(**params):
"""
Deliver frontend content of module alarms
:return: data of alarms
"""
from emonitor.extensions import monitorserver
if 'alarmfilter' not in session:
session['alarmfilter'] = '7'
if request.args.get('alarmfilter'): # filter for alarms last x days, -1 no filter set
session['alarmfilter'] = request.args.get('alarmfilter', '7')
if 'area' in request.args:
params['area'] = request.args.get('area')
if 'state' in request.args:
params['activeacc'] = request.args.get('state')
if request.form.get('action') == 'updatealarm':
if request.form.get('alarm_id') != 'None': # update alarm
alarm = Alarm.getAlarms(request.form.get('alarm_id'))
else: # create new alarm
d = datetime.datetime.strptime('%s %s' % (request.form.get('edit_timestamp_date'), request.form.get('edit_timestamp_time')), "%d.%m.%Y %H:%M:%S")
alarm = Alarm(d, request.form.get('edit_keyid'), 2, 0)
db.session.add(alarm)
params['activeacc'] = 1
try:
alarm.timestamp = datetime.datetime.strptime('%s %s' % (request.form.get('edit_timestamp_date'), request.form.get('edit_timestamp_time')), "%d.%m.%Y %H:%M:%S")
except ValueError:
alarm.timestamp = datetime.datetime.now()
alarm._key = request.form.get('edit_key')
alarm.set(u'id.key', request.form.get('edit_keyid'))
alarm.set(u'k.cars1', request.form.get('val_cars1'))
alarm.set(u'k.cars2', request.form.get('val_cars2'))
alarm.set(u'k.material', request.form.get('val_material'))
alarm.set(u'marker', request.form.get('marker'))
alarm.set(u'id.city', request.form.get('edit_city'))
_city = City.getCities(id=request.form.get('edit_cityname'))
if _city:
alarm.set(u'city', _city.name)
else:
alarm.set(u'city', request.form.get('edit_cityname'))
alarm.set(u'streetno', request.form.get('edit_streetno'))
street = Street.getStreets(id=request.form.get('edit_addressid'))
hnumber = None
if street:
alarm.set(u'id.address', street.id)
try:
hnumber = [h for h in street.housenumbers if h.number == request.form.get('edit_streetno').split()[0]]
if len(hnumber) > 0:
alarm.set(u'lat', hnumber[0].points[0][0])
alarm.set(u'lng', hnumber[0].points[0][1])
except IndexError:
pass
elif request.form.get('edit_addressid') == 'None':
alarm.set(u'id.address', '')
else:
alarm.set(u'id.address', request.form.get('edit_addressid'))
alarm.set(u'address', request.form.get('edit_address'))
if request.form.get('edit_object') != '0':
alarm.set(u'id.object', request.form.get('edit_object'))
else: # remove object definition if present
if u'id.object' in alarm.attributes:
del alarm.attributes[u'id.object']
if u'object' in alarm.attributes:
del alarm.attributes[u'object']
alarm.set(u'priority', request.form.get('edit_priority'))
alarm.set(u'remark', request.form.get('edit_remark'))
alarm.set(u'person', request.form.get('edit_person'))
if request.form.get(u'edit_address2').strip() != '':
alarm.set(u'address2', request.form.get('edit_address2'))
if (request.form.get(u'marker') == '1' and not hnumber) or request.form.get('update_position') == '1':
alarm.set(u'routing', '')
alarm.set(u'lat', request.form.get('lat'))
alarm.set(u'lng', request.form.get('lng'))
alarm.set(u'zoom', request.form.get('zoom'))
try:
d = datetime.datetime.strptime('%s %s' % (request.form.get('edit_endtimestamp_date'), request.form.get('edit_endtimestamp_time')), "%d.%m.%Y %H:%M:%S")
except ValueError:
d = datetime.datetime.now()
alarm.set(u'endtimestamp', d)
db.session.commit()
signal.send('alarm', 'updated', alarmid=alarm.id)
if request.form.get('alarm_id') == u'None': # create new
Alarm.changeState(alarm.id, 0) # prepare alarm
return redirect('/alarms?area=%s&state=1' % params['area'])
elif alarm.state == 1: # active alarm update
monitorserver.sendMessage('0', 'reset') # refresh monitor layout
return redirect('/alarms?area=%s&state=0' % params['area'])
elif request.args.get('action') == 'editalarm':
if request.args.get('alarmid', '0') == '0': # add new alarm
alarm = Alarm(datetime.datetime.now(), '', 2, 0)
#flash(babel.gettext(u'alarms.alarmadded'), 'alarms.add')
else: # edit alarm
alarm = Alarm.getAlarms(id=request.args.get('alarmid'))
return render_template('frontend.alarms_edit.html', alarm=alarm, cities=City.getCities(), objects=AlarmObject.getAlarmObjects(), cars=Car.getCars(), departments=Department.getDepartments(), frontendarea=params['area'], frontendmodules=frontend.modules, frontendmoduledef=Settings.get('frontend.default'))
elif request.args.get('action') == 'refresh': # refresh alarm section
params['area'] = request.args.get('area')
params['activeacc'] = int(request.args.get('activeacc'))
elif request.args.get('action') == 'finishalarm': # finish selected alarm
Alarm.changeState(int(request.args.get('alarmid')), 2)
params['area'] = request.args.get('area')
elif request.args.get('action') == 'activatealarm': # activate selected alarm
ret = Alarm.changeState(int(request.args.get('alarmid')), 1)
if len(ret) > 0:
flash(render_template_string("{{ _('alarms.carsinuse') }}</br><b>" + ", ".join([r.name for r in sorted(ret, key=attrgetter('name'))]) + "</b>"), 'alarms')
params['area'] = request.args.get('area')
params['activeacc'] = 0
elif request.args.get('action') == 'deletealarm': # delete selected alarm
alarm = Alarm.getAlarms(id=request.args.get('alarmid'))
refresh = 1 or alarm.state == 1 # check if alarm is active
try:
# delete file if not used in any other alarm
c = Alarm.query.filter(Alarm.attributes.any(value=alarm.get('filename'), name="filename")).count()
if c == 1 and os.path.exists("{}{}".format(current_app.config.get('PATH_DONE'), alarm.get('filename'))):
os.remove("{}{}".format(current_app.config.get('PATH_DONE'), alarm.get('filename')))
except:
pass
alarm.state = -1
alarm.updateSchedules()
db.session.delete(alarm)
db.session.commit()
if refresh:
monitorserver.sendMessage('0', 'reset') # refresh monitor layout
signal.send('alarm', 'deleted', alarmid=request.args.get('alarmid'))
elif request.args.get('action') == 'archivealarm': # archive selected alarms, id=0 == all
if ";" in request.args.get('alarmid'): # archive selected alarms
for alarmid in request.args.get('alarmid').split(';'):
Alarm.changeState(int(alarmid), 3)
elif int(request.args.get('alarmid')) == 0: # archive all alarms
Alarm.changeStates(3)
else: # archive single selected alarm
Alarm.changeState(int(request.args.get('alarmid')), 3)
params['area'] = request.args.get('area')
stats = dict.fromkeys(Alarm.ALARMSTATES.keys() + ['3'], 0)
for s, c in Alarm.getAlarmCount(days=int(session['alarmfilter'])): # s=state, c=count(ids of state)
if str(s) in stats.keys():
stats[str(s)] = c
if 'area' not in params:
params['area'] = 'center'
if 'activeacc' not in params:
params['activeacc'] = 0
return render_template('frontend.alarms_smallarea.html', alarmstates=Alarm.ALARMSTATES, stats=stats, frontendarea=params['area'], activeacc=str(params['activeacc']), printdefs=Printers.getActivePrintersOfModule('alarms'), frontendmodules=frontend.modules, frontendmoduledef=Settings.get('frontend.default'), alarmfilter=session['alarmfilter'])
logger.info(u"file_added: {}{}".format(incomepath, filename))
except:
OBSERVERTYPE = "other"
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:
path = kwargs['path']
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 _addParametersYahoo(self, **kwargs):
"""
Add special parameters for yahoo 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.locationid']
icons = kwargs['message'].attributes['weather.icons']
forecast = kwargs['message'].attributes['weather.forecast']
else:
location = Settings.get('messages.weather.locationid')
icons = Settings.get('messages.weather.icons')
forecast = Settings.get('messages.weather.forecast')
_yahooIcons = [[], ['31', '32', '33', '34', '44'], ['36'], ['21'],
['22'], ['26', '27', '28', '29', '30'],
['9', '11', '12', '37', '38', '40', '45', '47'], [],
['3', '4'], [], [], [],
['13', '14', '15', '16', '41', '42', '43', '46'],
['5', '6', '7', '18', '35'], ['8', '10', '15', '17'],
[], ['25'], ['19', '20'], ['0', '1', '2', '23', '24']]
if not self.lastcall or datetime.datetime.now(
) > self.lastcall + datetime.timedelta(hours=1):
# reload data from web
yql_url = "https://query.yahooapis.com/v1/public/yql?{}&format=json".format(
urllib.urlencode({
'q':
u'select * from weather.forecast where woeid = {} and u="c"'
.format(location).encode('utf-8')
}))
try:
result = urllib2.urlopen(yql_url).read()
d = json.loads(result)
d = flatten(
d.get('query', {
'results': {}
}).get('results', {
'channel': {}
}).get('channel'))
except urllib2.URLError:
import exceptions
raise exceptions.IOError
self.data.set('conditioncode', d.get('item_condition_code', ''))
self.data.set(
'conditionicon',
getIcon4Code(d.get('item_condition_code', 0), _yahooIcons))
self.data.set(
'conditioncss',
"wi wi-yahoo-{}".format(d.get('item_condition_code', '0')))
self.data.set('condition', d.get('item_condition_text', ''))
self.data.set('temperature', d.get('item_condition_temp', ''))
for fcast in d.get('item_forecast', []):
fcast['date'] = datetime.datetime.strptime(
fcast.get('date'), "%d %b %Y")
fcast['iconclass'] = "wi-yahoo-{}".format(fcast.get('code', 0))
self.data.weather['forecast'].append(fcast)
self.data.set('temperatureunit', d.get('units_temperature', ''))
self.data.set('winddirection', int(d.get('wind_direction', '0')))
self.data.set('windspeed', d.get('wind_speed', 0))
self.data.set('windunit', d.get('units_speed', 'km/h'))
self.data.set('humidity', d.get('atmosphere_humidity', ''))
if d.get('atmosphere_pressure',
0) < 2000: # fix error in pressure of webservice
self.data.set('pressure', d.get('atmosphere_pressure', ''))
self.data.set(
'sunrise',
datetime.datetime(*time.strptime(
d.get('astronomy_sunrise', time.time()).upper(),
"%I:%M %p")[:6]))
self.data.set(
'sunset',
datetime.datetime(*time.strptime(
d.get('astronomy_sunset', time.time()).upper(), "%I:%M %p")
[:6]))
self.data.set('location', d.get('location_city', ''))
self.data.set('builddate', datetime.datetime.now())
kwargs.update({
'location': location,
'icons': icons,
'forecast': forecast,
'data': self.data
})
self.params = kwargs
return kwargs
def configure_extensions(app):
"""
Confgure all extensions with current app object
:param app: :py:class:`Flask`
"""
# alembic
alembic.init_app(app)
# flask-sqlalchemy
db.init_app(app)
db.app = app
db.create_all()
with app.app_context():
_dbversion = alembic.migration_context.get_current_heads()
if len(_dbversion) > 0 and _dbversion[0] != current_app.config.get(
'DB_VERSION'): # update version
try:
alembic.upgrade(current_app.config.get('DB_VERSION'))
except (alembicutil.CommandError, OperationalError):
pass
db.reflect() # check init
db.create_all()
try:
alembic.stamp() # set stamp to latest version
except:
pass
# babel
babel.init_app(app)
# flask-cache
cache.init_app(app)
# signals
signal.init_app(app)
# events
events.init_app(app)
events.addEvent('default', handlers=[], parameters=[])
# scheduler
if not scheduler.running:
scheduler.start()
scheduler.initJobs(app)
# monitorserver
monitorserver.init_app(app)
monitorserver.sendMessage('0', 'reset')
# printers
printers.init_app(app)
# flask-login
login_manager.login_view = 'login.loginform'
login_manager.login_message = "admin.login.needed"
login_manager.unauthorized_handler = "frontend.login_page"
login_manager.init_app(app)
# jinja2 filters
from utils import getmarkdown, getreStructuredText, getJavaSafe
app.jinja_env.filters['markdown'] = getmarkdown
app.jinja_env.filters['rst'] = getreStructuredText
app.jinja_env.filters['javasafe'] = getJavaSafe
# user
if User.query.count() == 0:
User.getUsers(1)
@login_manager.user_loader
def load_user(id):
return User.getUsers(userid=id)
# communication
communication.init_app(app)
# add global elements
from emonitor.scheduler import eMonitorIntervalTrigger
from emonitor.modules.settings.settings import Settings
from emonitor.observer import observeFolder, OBSERVERTYPE
try:
_jping = scheduler.add_job(
monitorserver.getClients,
trigger=eMonitorIntervalTrigger(minutes=int(
Settings.get('monitorping', app.config.get('MONITORPING',
2)))),
name='monitorping')
except:
_jping = scheduler.add_job(
monitorserver.getClients,
trigger=eMonitorIntervalTrigger(
minutes=int(app.config.get('MONITORPING', 2))),
name='monitorping')
if str(Settings.get('monitorping', app.config.get('MONITORPING'))) == '0':
_jping.pause()
try:
if OBSERVERTYPE == "watchdog":
_jobserver = scheduler.add_job(observeFolder,
kwargs={
'path':
app.config.get(
'PATH_INCOME',
app.config.get('PATH_DATA'))
},
name='observerinterval')
else:
_jobserver = scheduler.add_job(
observeFolder,
trigger=eMonitorIntervalTrigger(seconds=int(
Settings.get('observer.interval',
app.config.get('OBSERVERINTERVAL', 2)))),
kwargs={
'path':
app.config.get('PATH_INCOME', app.config.get('PATH_DATA'))
},
name='observerinterval')
except ValueError:
_jobserver = scheduler.add_job(
observeFolder,
trigger=eMonitorIntervalTrigger(
seconds=int(app.config.get('OBSERVERINTERVAL', 2))),
kwargs={
'path': app.config.get('PATH_INCOME',
app.config.get('PATH_DATA'))
},
name='observerinterval')
if str(
Settings.get('observer.interval',
app.config.get('OBSERVERINTERVAL'))) == '0':
_jobserver.pause()
if str(
Settings.get('observer.interval',
app.config.get('OBSERVERINTERVAL'))) == '0':
_jobserver.pause()
def getAdminContent(self, **params):
module = request.view_args['module'].split('/')
if len(module) < 2:
module.append(u'1')
if len(module) > 2 and module[2] == 'upload': # upload persons
params.update({'': int(module[1]), 'depid': module[1]})
return render_template('admin.persons.upload.html', **params)
if request.method == 'POST':
if request.form.get('action') == 'createperson': # add person
params.update({'person': Person('', '', '', '', '', '', False, datetime.now(), '', int(module[1])), 'settings': Settings.get('persons.settings')})
return render_template('admin.persons_edit.html', **params)
elif request.form.get('action').startswith('editperson_'): # edit person
params.update({'person': Person.getPersons(id=request.form.get('action').split('_')[-1]), 'settings': Settings.get('persons.settings')})
return render_template('admin.persons_edit.html', **params)
elif request.form.get('action') == 'updateperson': # save person
if request.form.get('person_id') != 'None':
person = Person.getPersons(id=request.form.get('person_id'))
else:
person = Person('', '', '', '', '', '', False, datetime.now(), '', int(module[1]))
db.session.add(person)
person.firstname = request.form.get('firstname')
person.lastname = request.form.get('lastname')
person.salutation = request.form.get('salutation')
person.grade = request.form.get('grade')
person._dept = int(request.form.get('dept'))
person.position = request.form.get('position')
person.active = 'active' in request.form.keys()
try:
person.birthdate = datetime.strptime('{} 00:00:00'.format(request.form.get('birthdate')), "%d.%m.%Y %H:%M:%S")
except ValueError:
pass
person.identifier = request.form.get('identifier')
person.remark = request.form.get('remark')
db.session.commit()
elif request.form.get('action').startswith('deleteperson_'):
db.session.delete(Person.getPersons(id=request.form.get('action').split('_')[-1]))
db.session.commit()
elif request.form.get('action') == 'updategrades':
grades = request.form.getlist('grade')
while grades[-1] == grades[-2] == u"": # remove last empty entries
grades = grades[:-2]
_settings = Settings.get('persons.settings')
if 'positions' not in _settings.keys():
_settings['positions'] = []
_settings['grades'] = zip(*[grades[i::2] for i in range(2)])
Settings.set('persons.settings', _settings)
db.session.commit()
elif request.form.get('action') == 'updatepositions':
_settings = Settings.get('persons.settings')
if 'grades' not in _settings.keys():
_settings['grades'] = []
_settings['positions'] = request.form.get('positions').replace('\r', '').split('\n')
Settings.set('persons.settings', _settings)
db.session.commit()
if int(module[1]) == 0:
params.update({'settings': Settings.get('persons.settings')})
return render_template("admin.persons.settings.html", **params)
persons = Person.getPersons(dept=int(module[1]))
chars = {}
for p in persons:
chars[p.fullname[0].upper()] = 0
params.update({'persons': persons, 'chars': sorted(chars), 'depid': module[1]})
return render_template("admin.persons.html", **params)
def getAdminContent(self, **params):
"""
Deliver admin content of module streets
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
if len(module) < 2:
if City.getDefaultCity():
module.append(u'{}'.format(City.getDefaultCity().id))
else:
module.append(u'1')
if len(module) == 2: # cities
if module[1] == '0': # city list
if request.method == 'POST':
if request.form.get('action').startswith('detailcity_'): # edit city
params.update({'city': City.getCities(id=request.form.get('action').split('_')[-1]), 'departments': Department.getDepartments(), 'maps': Map.getMaps()})
return render_template('admin.streets.city_edit.html', **params)
elif request.form.get('action') == 'updatecity': # update existing city
if request.form.get('city_id') != 'None': # update city
city = City.getCities(id=request.form.get('city_id'))
city.name = request.form.get('cityname')
city.subcity = request.form.get('subcity')
city._dept = request.form.get('department')
city.mapname = request.form.get('citymap')
city.color = request.form.get('colorname')
city.default = request.form.get('citydefault')
city.osmid = request.form.get('osmid')
city.osmname = request.form.get('osmname')
else: # add city
city = City(request.form.get('cityname'), request.form.get('department'),
request.form.get('citymap'), request.form.get('citydefault'),
request.form.get('subcity'), request.form.get('colorname'),
request.form.get('osmid'), request.form.get('osmname'))
db.session.add(city)
db.session.commit()
cache.clear()
elif request.form.get('action') == 'createcity': # add city
params.update({'city': City('', '', '', '', '', '', 0, ''), 'departments': Department.getDepartments(), 'maps': Map.getMaps()})
return render_template('admin.streets.city_edit.html', **params)
elif request.form.get('action').startswith('deletecity_'): # delete city
db.session.delete(City.getCities(id=request.form.get('action').split('_')[-1]))
db.session.commit()
self.updateAdminSubNavigation()
cache.clear()
params.update({'cities': City.getCities()})
return render_template('admin.streets.city_list.html', **params)
else: # show city details
if request.method == 'POST':
if request.form.get('action').startswith('detailstreet_'): # edit street
tileserver = {'lat': Settings.get('defaultLat'),
'lng': Settings.get('defaultLng'),
'zoom': Settings.get('defaultZoom'),
'map': Map.getDefaultMap()}
params.update({'street': Street.getStreets(id=request.form.get('action').split('_')[-1]), 'cities': City.getCities(), 'maps': Map.getMaps(), 'tileserver': tileserver})
return render_template('admin.streets_edit.html', **params)
elif request.form.get('action') == 'createstreet': # add street
tileserver = {'lat': Settings.get('defaultLat'),
'lng': Settings.get('defaultLng'),
'zoom': Settings.get('defaultZoom'),
'map': Map.getDefaultMap()}
params.update({'street': Street('', '', int(module[1]), '', '', '', '', '', ''), 'cities': City.getCities(), 'maps': Map.getMaps(), 'tileserver': tileserver})
return render_template('admin.streets_edit.html', **params)
elif request.form.get('action').startswith('deletestreets_'): # delete street
db.session.delete(Street.getStreets(id=request.form.get('action').split('_')[-1]))
db.session.commit()
cache.clear()
elif request.form.get('action') == 'savestreet': # save street
if request.form.get('street_id') != 'None': # update existing street
street = Street.getStreets(id=request.form.get('street_id'))
street.name = request.form.get('edit_name')
street.navigation = request.form.get('edit_navigation')
c = request.form.get('edit_cityid').split('_')
if len(c) < 2:
c.append('')
street.cityid = c[0]
street.subcity = c[1]
street.lat = request.form.get('edit_lat')
street.lng = request.form.get('edit_lng')
street.zoom = request.form.get('edit_zoom')
street.active = request.form.get('edit_active')
db.session.commit()
#cache.delete_memoized(City.streets)
else: # add street
c = request.form.get('edit_cityid').split('_')
if len(c) < 2:
c.append('') # subcity
city = [ct for ct in City.getCities() if str(ct.id) == c[0]][0]
city.addStreet(Street(request.form.get('edit_name'), request.form.get('edit_navigation'), int(c[0]), c[1], request.form.get('edit_lat'), request.form.get('edit_lng'), request.form.get('edit_zoom'), request.form.get('edit_active'), ''))
db.session.commit()
cache.clear()
try:
streets = Street.getStreets(cityid=module[-1])
except AttributeError:
streets = []
chars = {}
for s in streets:
chars[s.name[0].upper()] = 0
params.update({'streets': streets, 'chars': sorted(chars.keys()), 'city': City.getCities(id=module[-1])})
return render_template('admin.streets.html', **params)
return "streets"
def configure_extensions(app):
"""
Confgure all extensions with current app object
:param app: :py:class:`Flask`
"""
# alembic
alembic.init_app(app)
# flask-sqlalchemy
db.init_app(app)
db.app = app
db.create_all()
with app.app_context():
if alembic.context.get_current_revision() != current_app.config.get('DB_VERSION'): # update version
try:
alembic.upgrade(current_app.config.get('DB_VERSION'))
except (alembicutil.CommandError, OperationalError):
pass
db.reflect() # check init
db.create_all()
try:
alembic.stamp() # set stamp to latest version
except:
pass
# babel
babel.init_app(app)
# flask-cache
cache.init_app(app)
# signals
signal.init_app(app)
# events
events.init_app(app)
events.addEvent('default', handlers=[], parameters=[])
# scheduler
if not scheduler.running:
scheduler.start()
scheduler.initJobs(app)
# monitorserver
monitorserver.init_app(app)
monitorserver.sendMessage('0', 'reset')
# printers
printers.init_app(app)
# flask-login
login_manager.login_view = 'login.loginform'
login_manager.login_message = "admin.login.needed"
login_manager.unauthorized_handler = "frontend.login_page"
login_manager.init_app(app)
# jinja2 filters
from utils import getmarkdown, getreStructuredText, getJavaSafe
app.jinja_env.filters['markdown'] = getmarkdown
app.jinja_env.filters['rst'] = getreStructuredText
app.jinja_env.filters['javasafe'] = getJavaSafe
# user
if User.query.count() == 0:
User.getUsers(1)
@login_manager.user_loader
def load_user(id):
return User.getUsers(userid=id)
# communication
communication.init_app(app)
# add global elements
from emonitor.scheduler import eMonitorIntervalTrigger
from emonitor.modules.settings.settings import Settings
from emonitor.observer import observeFolder, OBSERVERTYPE
try:
_jping = scheduler.add_job(monitorserver.getClients, trigger=eMonitorIntervalTrigger(minutes=int(Settings.get('monitorping', app.config.get('MONITORPING', 2)))), name='monitorping')
except:
_jping = scheduler.add_job(monitorserver.getClients, trigger=eMonitorIntervalTrigger(minutes=int(app.config.get('MONITORPING', 2))), name='monitorping')
if str(Settings.get('monitorping', app.config.get('MONITORPING'))) == '0':
_jping.pause()
try:
if OBSERVERTYPE == "watchdog":
_jobserver = scheduler.add_job(observeFolder, kwargs={'path': app.config.get('PATH_INCOME', app.config.get('PATH_DATA'))}, name='observerinterval')
else:
_jobserver = scheduler.add_job(observeFolder, trigger=eMonitorIntervalTrigger(seconds=int(Settings.get('observer.interval', app.config.get('OBSERVERINTERVAL', 2)))), kwargs={'path': app.config.get('PATH_INCOME', app.config.get('PATH_DATA'))}, name='observerinterval')
except ValueError:
_jobserver = scheduler.add_job(observeFolder, trigger=eMonitorIntervalTrigger(seconds=int(app.config.get('OBSERVERINTERVAL', 2))), kwargs={'path': app.config.get('PATH_INCOME', app.config.get('PATH_DATA'))}, name='observerinterval')
if str(Settings.get('observer.interval', app.config.get('OBSERVERINTERVAL'))) == '0':
_jobserver.pause()
if str(Settings.get('observer.interval', app.config.get('OBSERVERINTERVAL'))) == '0':
_jobserver.pause()
def getAdminContent(self, **params):
"""
Deliver admin content of module alarms
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
if len(module) > 1:
if module[1] == 'types':
impl = [] # load implementations of faxchecker
for f in [f for f in os.listdir('%s/emonitor/modules/alarms/inc/' % current_app.config.get('PROJECT_ROOT')) if f.endswith('.py')]:
if not f.startswith('__'):
cls = imp.load_source('emonitor.modules.alarms.inc', 'emonitor/modules/alarms/inc/%s' % f)
if isinstance(getattr(cls, cls.__all__[0])(), AlarmFaxChecker):
impl.append((f, getattr(cls, cls.__all__[0])(), AlarmType.getAlarmTypeByClassname(f)))
if request.method == 'POST':
if request.form.get('action') == 'createtype': # add type
params.update({'alarmtype': AlarmType('', ''), 'interpreter': impl})
return render_template('admin.alarms.type_actions.html', **params)
elif request.form.get('action').startswith('deleteinterpreter_'): # delete checker
for cls in impl:
if cls[0] == request.form.get('action')[18:]:
if os.path.exists('%s/emonitor/modules/alarms/inc/%s' % (current_app.config.get('PROJECT_ROOT'), cls[0])):
os.remove('%s/emonitor/modules/alarms/inc/%s' % (current_app.config.get('PROJECT_ROOT'), cls[0]))
if os.path.exists('%s/emonitor/modules/alarms/inc/%sc' % (current_app.config.get('PROJECT_ROOT'), cls[0])):
os.remove('%s/emonitor/modules/alarms/inc/%sc' % (current_app.config.get('PROJECT_ROOT'), cls[0]))
impl.remove(cls)
elif request.form.get('action').startswith('editalarmtype_'): # edit type
params.update({'alarmtype': AlarmType.getAlarmTypes(id=int(request.form.get('action').split('_')[-1])), 'interpreter': impl})
return render_template('admin.alarms.type_actions.html', **params)
elif request.form.get('action').startswith('deletetype_'): # delete type
atype = AlarmType.getAlarmTypes(id=int(request.form.get('action').split('_')[-1]))
for e in [e for e in events.events if e.name in ['alarm_added.{}'.format(atype.name), 'alarm_changestate.{}'.format(atype.name)]]:
# delete event handlers and monitor layout
for eh in Eventhandler.getEventhandlers(event=e.name):
for ml in MonitorLayout.query.filter(MonitorLayout.trigger.like('%{}%'.format(eh.event))).all():
if ';' in ml.trigger:
_tr = ml.trigger.split(';')
del _tr[_tr.index(e.name)]
ml.trigger = ";".join(_tr)
else:
db.session.remove(ml)
db.session.delete(eh)
# delete event
del events.events[events.events.index(e)]
db.session.delete(atype)
db.session.commit()
elif request.form.get('action') == 'updatetype': # update type
if request.form.get('type_id') == 'None': # add type
atype = AlarmType('', '')
db.session.add(atype)
events.addEvent('alarm_added.{}'.format(request.form.get('edit_name')), handlers=[], parameters=[])
events.addEvent('alarm_changestate.{}'.format(request.form.get('edit_name')), handlers=[], parameters=[])
else: # update type
atype = AlarmType.getAlarmTypes(id=int(request.form.get('type_id')))
for e in [e for e in events.events if e.name in ['alarm_added.{}'.format(atype.name), 'alarm_changestate.{}'.format(atype.name)]]:
# update event handler and monitor layout
newname = '{}.{}'.format(e.name.split('.')[0], request.form.get('edit_name'))
for eh in Eventhandler.getEventhandlers(event=e.name):
for ml in MonitorLayout.query.filter(MonitorLayout.trigger.like('%{}%'.format(eh.event))).all():
ml.trigger = ml.trigger.replace(e.name, newname)
eh.event = newname
# update event
e.name = newname
atype.name = request.form.get('edit_name')
atype.keywords = request.form.get('edit_keywords')
atype.interpreter = request.form.get('edit_interpreter')
atype.attributes = dict(zip(request.form.getlist('attribute_name'), request.form.getlist('attribute_value')))
atype.translations = dict(zip(request.form.getlist('alarmtypevariables'), request.form.getlist('alarmtypetranslation')))
db.session.commit()
if request.form.get('type_id') == 'None': # add predefined keywords and sections
# add pre-defined sections
for checker in [i for i in impl if i[0] == request.form.get('edit_interpreter')]:
if request.form.get('edit_keywords') == "":
atype.keywords = "\n".join(checker[1].getDefaultConfig()['keywords'])
sections = checker[1].getDefaultConfig()['sections']
i = 1
for key in sections:
db.session.add(AlarmSection(atype.id, key, sections[key][0], 1, sections[key][1], i))
i += 1
db.session.commit()
elif request.form.get('action').startswith('createsection_'): # add section
alarmtype = AlarmType.getAlarmTypes(id=int(request.form.get('action').split('_')[-1]))
params.update({'alarmtype': alarmtype, 'section': AlarmSection(alarmtype.id, '', '', 0, '', 0), 'functions': alarmtype.interpreterclass().getEvalMethods()})
return render_template('admin.alarms.sections_actions.html', **params)
elif request.form.get('action') == 'updatesection': # save section
db.session.rollback()
if request.form.get('section_id') == 'None': # add
section = AlarmSection(request.form.get('edit_tid'), '', '', '', '', '')
section.orderpos = 1 + len(AlarmSection.getSections())
db.session.add(section)
else: # update
section = AlarmSection.getSections(id=int(request.form.get('section_id')))
section.orderpos = request.form.get('edit_orderpos')
section.tid = request.form.get('edit_tid')
section.name = request.form.get('edit_name')
section.key = request.form.get('edit_key')
section.method = request.form.get('edit_method')
section.active = request.form.get('edit_active')
alarmtype = AlarmType.getAlarmTypes(request.form.get('edit_tid'))
if alarmtype.interpreterclass().configtype == 'generic':
attrs = {'start': request.form.get('edit_start'), 'end': request.form.get('edit_end')}
if 'edit_multiline' in request.form.keys():
attrs['multiline'] = 'True'
section.attributes = attrs
db.session.commit()
elif request.form.get('action') == 'updateorder':
for item in [i for i in request.form if i.startswith('position_')]:
ids = request.form.getlist(item)
for _id in ids:
AlarmSection.getSections(id=_id).orderpos = ids.index(_id) + 1
db.session.commit()
elif request.form.get('action').startswith('editalarmsection_'): # edit section
section = AlarmSection.getSections(id=int(request.form.get('action').split('_')[-1]))
params.update({'section': section, 'functions': section.alarmtype.interpreterclass().getEvalMethods(), 'alarmtype': AlarmType.getAlarmTypes(section.tid)})
return render_template('admin.alarms.sections_actions.html', **params)
elif request.form.get('action').startswith('deletealarmsection_'): # delete section
section = AlarmSection.getSections(id=int(request.form.get('action').split('_')[-1]))
db.session.delete(section)
db.session.commit()
params.update({'alarmtypes': AlarmType.getAlarmTypes(), 'interpreters': impl})
return render_template('admin.alarms.type.html', **params)
elif module[1] == 'report':
if request.method == 'POST':
if request.form.get('action') == 'createreport': # add report
params.update({'report': AlarmReport('', '', '', 1, []), 'departments': Department.getDepartments(), 'reporttypes': AlarmReport.getReportTypes()})
return render_template('admin.alarms.report_action.html', **params)
elif request.form.get('action') == 'updatereport':
if request.form.get('report_id') == 'None': # add new report
report = AlarmReport('', '', '', '')
db.session.add(report)
else:
report = AlarmReport.getReports(request.form.get('report_id'))
report.name = request.form.get('edit_name')
if not request.form.get('template').startswith(current_app.config.get('PATH_DATA')): # internal template
report._reporttype = 'internal'
report.filename = request.form.get('template').replace("{}/emonitor/modules/alarms/templates/".format(current_app.config.get('PROJECT_ROOT')).replace('\\', '/'), "")
else:
report._reporttype = 'external'
report.filename = request.form.get('template').replace("{}".format(current_app.config.get('PATH_DATA')), "")
report.fields = json.loads(request.form.get('fielddefinition'))
report.departments = request.form.getlist('edit_department')
db.session.commit()
elif request.form.get('action').startswith('editreport_'): # edit report
report = AlarmReport.getReports(request.form.get('action').split('_')[-1])
params.update({'report': report, 'departments': Department.getDepartments(), 'reporttypes': AlarmReport.getReportTypes(), 'alarmfields': AlarmField.getAlarmFields()})
return render_template('admin.alarms.report_action.html', **params)
elif request.form.get('action').startswith('deletereport_'): # delete report
report = AlarmReport.getReports(request.form.get('action').split('_')[-1])
if AlarmReport.query.filter(AlarmReport.filename == report.filename).count() == 1 and os.path.exists(report.filename):
os.remove(report.filename)
db.session.delete(report)
db.session.commit()
params.update({'reports': AlarmReport.getReports(), 'departments': Department.getDepartments()})
return render_template('admin.alarms.report.html', **params)
elif module[1] == 'config':
if request.method == 'POST':
if request.form.get('action') == 'alarmcarsprio':
for k in Alarm.ALARMSTATES.keys():
if 'used_cars{}'.format(k) in request.form.keys():
Settings.set('alarms.spc_cars.{}'.format(k), request.form.get('used_cars{}'.format(k)))
db.session.commit()
elif request.form.get('action') == 'alarmsettings':
Settings.set('alarms.autoclose', request.form.get('settings.autoclose'))
for aalarm in [a for a in Alarm.getAlarms() if a.state == 1]: # only active alarms
aalarm.updateSchedules(reference=1) # use alarmtime as refernce
elif request.form.get('action') == 'archivesettings':
Settings.set('alarms.autoarchive', request.form.get('settings.autoarchive'))
for aalarm in [a for a in Alarm.getAlarms() if a.state == 2]: # only closed alarms
aalarm.updateSchedules(reference=1) # use alarmtime as refernce
elif request.form.get('action').startswith('save_'):
if request.form.get('fieldid') == 'None':
field = AlarmField.getAlarmFieldForType(request.form.get('action').split('_')[1], dept=request.form.get('action').split('_')[2])
db.session.add(field)
else:
field = AlarmField.getAlarmFields(id=request.form.get('fieldid'))
field.saveConfigForm(request)
db.session.commit()
elif request.form.get('action').startswith('field_delete_'): # delete definition of field
db.session.delete(AlarmField.getAlarmFields(id=request.form.get('action').split('_')[-1]))
db.session.commit()
elif request.form.get('action').startswith('field_add_'): # add field for department
field = AlarmField.getAlarmFieldForType(request.form.get('action').split('_')[-2], dept=request.form.get('action').split('_')[-1])
field.name = babel.gettext(field.name)
db.session.add(field)
db.session.commit()
fields = {}
for dept in Department.getDepartments():
fields[dept.id] = AlarmField.getAlarmFieldsForDepartment(dept.id)
params.update({'cars': Car.getCars(), 'alarmstates': Alarm.ALARMSTATES, 'settings': Settings, 'departments': Department.getDepartments(), 'fields': fields})
return render_template('admin.alarms.config.html', **params)
elif module[1] == 'test':
params.update({'uploadfileformat': filter(None, sum([Settings.get('ocr.inputformat', []), Settings.get('ocr.inputtextformat', [])], []))})
return render_template('admin.alarms.test.html', **params)
else:
params.update({'alarms': dict(Alarm.getAlarmCount()), 'alarmstates': Alarm.ALARMSTATES, 'help': self.hasHelp('admin')})
return render_template('admin.alarms.html', **params)
def getVariables():
return Settings.get('alarms.evalfields').split('\r\n')
def getMapItemDefinitions(self):
return Settings.get('mapitemdefinition')
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 _addParametersOWM(self, **kwargs):
"""
Add special parameters for open-weather-map weather widget *messages.weather.\**
check https://www.openweathermap.org/ for online help
weather conditions: https://www.openweathermap.org/weather-conditions
:param kwargs: list of parameters for update
"""
if 'message' in kwargs:
location = kwargs['message'].attributes['weather.locationid']
icons = kwargs['message'].attributes['weather.icons']
forecast = kwargs['message'].attributes['weather.forecast']
else:
location = Settings.get('messages.weather.locationid')
icons = Settings.get('messages.weather.icons')
forecast = Settings.get('messages.weather.forecast')
_owmIcons = [[], [
800,
], [
904,
], [
905,
], [711, 801], [804, 771, 802, 803],
[
310, 313, 520, 521, 522, 701, 602, 300, 301, 321, 500,
531, 901, 210, 211, 212, 221
], [302, 311, 312, 314, 501, 502, 503, 504],
[200, 201, 202, 230, 231, 232], [], [], [],
[600, 601, 621, 622], [511, 611, 612, 615, 616, 620],
[
906,
], [], [
903,
], [731, 761, 762, 721, 741],
[900, 781, 901, 902,
957]] # weather code mapping for png icons
url_weather = "http://api.openweathermap.org/data/2.5/weather?id={}&units=metric&lang={}&APPID={}".format(
location,
current_app.config.get('LANGUAGES').keys()[0],
Settings.get('messages.weather.owmkey', ''))
url_forecast = "http://api.openweathermap.org/data/2.5/forecast?id={}&units=metric&lang={}&APPID={}".format(
location,
current_app.config.get('LANGUAGES').keys()[0],
Settings.get('messages.weather.owmkey', ''))
try:
d = flatten(json.loads(urllib2.urlopen(url_weather).read()))
f = flatten(json.loads(urllib2.urlopen(url_forecast).read()))
except:
import exceptions
raise exceptions.IOError
self.data.set(
'condition',
d.get('weather', [{
'description': ''
}])[0]['description'])
self.data.set(
'conditionicon',
getIcon4Code(
d.get('weather', [{
'id': '01'
}])[0].get('id'), _owmIcons))
self.data.set(
'conditioncss', "wi wi-owm-{}".format(
d.get('weather', [{
'id': '01'
}])[0].get('id')))
self.data.set('temperature', d.get('main_temp', 0))
self.data.set('forecast', [])
_ld = ""
for fcast in f.get('list', []):
_day = datetime.datetime(*time.gmtime(fcast.get('dt', 0))[:6])
if datetime.date.today() == _day.date():
continue
if _ld != _day.strftime('%Y%m%d'):
self.data.weather['forecast'].append({
'date':
_day,
'low':
fcast.get('main', {'temp_min': 0})['temp_min'],
'high':
fcast.get('main', {'temp_max': 0})['temp_max'],
'pressure':
fcast.get('main', {'pressure': 0})['pressure'],
'description':
'',
'code':
'',
'windspeed':
0,
'winddegree':
0
})
_ld = _day.strftime('%Y%m%d')
if self.data.weather.get('forecast')[-1].get('low') > fcast.get(
'main', {'temp_min': 0})['temp_min']:
self.data.weather.get('forecast')[-1].update(
{'low': fcast.get('main', {'temp_min': 0})['temp_min']})
if self.data.weather.get('forecast')[-1].get('high') < fcast.get(
'main', {'temp_max': 0})['temp_max']:
self.data.weather.get('forecast')[-1].update(
{'high': fcast.get('main', {'temp_max': 0})['temp_max']})
if self.data.weather.get('forecast')[-1].get(
'windspeed') < fcast.get('wind', {
'speed': 0
}).get('speed'):
self.data.weather.get('forecast')[-1].update(
{'windspeed': fcast.get('wind', {'speed': 0})['speed']})
self.data.weather.get('forecast')[-1].update(
{'winddegree': fcast.get('wind', {'deg': 0})['deg']})
self.data.weather.get('forecast')[-1].update({
'pressure':
(self.data.weather.get('forecast')[-1].get('pressure') +
fcast.get('main', {'pressure': 0})['pressure']) / 2.0
})
if _day.strftime('%H') == "12":
self.data.weather.get('forecast')[-1].update({
'description':
fcast.get('weather', {'description': ''})[0]['description']
})
self.data.weather.get('forecast')[-1].update(
{'code': fcast.get('weather', {'id': ''})[0]['id']})
self.data.weather.get('forecast')[-1].update({
'iconclass':
"wi-owm-{}".format(
fcast.get('weather', {'id': ''})[0]['id'])
})
self.data.set('temperatureunit', 'C')
self.data.set('winddirection', int(d.get('wind_deg', '0')))
self.data.set('windspeed', d.get('wind_speed', 0))
self.data.set('windunit', 'm/s')
self.data.set('humidity', d.get('main_humidity', ''))
self.data.set('pressure', d.get('main_pressure', ''))
self.data.set('clouds', d.get('clouds_all', 0))
self.data.set(
'sunrise',
datetime.datetime(*time.gmtime(d.get('sys_sunrise', 0))[:6]))
self.data.set(
'sunset',
datetime.datetime(*time.gmtime(d.get('sys_sunset', 0))[:6]))
self.data.set('location', d.get('name', ''))
self.data.set('builddate', datetime.datetime.now())
kwargs.update({
'location': location,
'icons': icons,
'forecast': forecast,
'data': self.data
})
self.params = kwargs
return kwargs
def getAdminContent(self, **params):
"""
Deliver admin content of module mapitems
:param params: use given parameters of request
:return: rendered template as string
"""
module = request.view_args['module'].split('/')
if len(module) < 2:
module.append(
current_app.blueprints['admin'].modules['mapitems'].
adminsubnavigation[0][0].split('/')[-1]) # get first submenuitem
if len(module) >= 2:
if module[1] == 'definition': # definition
if request.method == 'POST':
if request.form.get('action').startswith(
'edititemtype_'): # edit/add definition TODO: fix
typename = request.form.get('action').split('_')
itemtype = [
d for d in Settings.get('mapitemdefinition')
if d['name'] == typename[1]
]
if len(itemtype) > 0:
itemtype = itemtype[0]
if 'parameters' not in itemtype:
itemtype['parameters'] = {
'layout': '',
'tileserver': 0
}
if 'key' not in itemtype:
itemtype['key'] = []
if 'cities' not in itemtype:
itemtype['cities'] = []
if 'itemtype' not in itemtype:
itemtype['itemtype'] = 'node'
else:
itemtype = {
'name': '',
'filter': '',
'attributes': [],
'parameters': {'layout', 'tileserver'},
'key': [],
'cities': [],
'itemtype': 'node'
}
params.update({
'itemtype': itemtype,
'cities': City.getCities(),
'layouters': MapItem.getLayouters()
})
return render_template(
'admin.mapitems.definition_actions.html', **params)
elif request.form.get('action').startswith(
'deleteitemtype_'): # delete definition
itemtypes = Settings.get('mapitemdefinition')
for itemtype in itemtypes:
if itemtype['name'] == request.form.get(
'action').split('_')[1]:
del itemtypes[itemtypes.index(itemtype)]
Settings.set('mapitemdefinition', itemtypes)
db.session.commit()
elif request.form.get(
'action') == 'updateitemtypes': # save definition
itemtypes = Settings.get('mapitemdefinition')
position = -1
for itemtype in itemtypes:
if itemtype['name'] == request.form.get('edit_name'):
position = itemtypes.index(itemtype)
break
if position >= 0: # update type
itemtypes[position]['filter'] = request.form.get(
'edit_filter')
itemtypes[position]['cities'] = [
int(i) for i in request.form.getlist('edit_cityid')
]
itemtypes[position]['itemtype'] = request.form.get(
'edit_itemtype')
itemtypes[position]['attributes'] = request.form.get(
'edit_attributes').split('\r\n')
itemtypes[position]['parameters'] = {
'layout': request.form.get('edit_layout'),
'tileserver': request.form.get('edit_tileserver')
}
itemtypes[position]['key'] = request.form.get(
'edit_keys').split('\r\n')
else: # add new type
it = dict()
it['name'] = request.form.get('edit_name')
it['filter'] = request.form.get('edit_filter')
it['cities'] = [
int(i) for i in request.form.getlist('edit_cityid')
]
it['itemtype'] = request.form.get('edit_itemtype')
it['attributes'] = request.form.get(
'edit_attributes').split('\r\n')
it['parameters'] = {
'layout': request.form.get('edit_layout')
}
if itemtypes == "":
itemtypes = [it]
else:
itemtypes.append(it)
it['key'] = request.form.get('edit_keys').split('\r\n')
Settings.set('mapitemdefinition', itemtypes)
db.session.commit()
current_app.blueprints['admin'].modules[
'mapitems'].updateAdminSubNavigation()
params.update({
'itemtypes': Settings.get('mapitemdefinition', []),
'layouters': MapItem.getLayouters()
})
return render_template('admin.mapitems.definition.html', **params)
# deliver default list
itemdefinition = [
t for t in Settings.get('mapitemdefinition') if t['name'] == module[1]
][0]
itemtypes = MapItem.getMapitems(itemtype=module[1])
page = 0
if len(module) == 3: # pagination active
page = int(module[2])
pagination = Pagination(page, PER_PAGE, len(itemtypes))
params.update({
'itemtypes': itemtypes[page:page + PER_PAGE],
'itemdefinition': itemdefinition,
'pagination': pagination
})
return render_template('admin.mapitems.html', **params)
def getMapItemDefinitions(self):
return Settings.get('mapitemdefinition')
def get_zoom(self): # deliver zoom integer
return int(self.get('zoom', Settings.get('defaultZoom', '13')))
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 get_street_proto(self, stype): # deliver street object
_t = {1: 'address', 2: 'address2'}
if self.get('id.%s' % _t[stype]) and self.get('id.%s' % _t[stype], '0') not in ['-1', '0']:
return Street.getStreets(id=self.get('id.%s' % _t[stype], '0'))
else:
return Street(self.get(_t[stype], ''), '', '', 1, '', float(Settings.get('defaultLat', '0')), float(Settings.get('defaultLng', '0')), float(Settings.get('defaultZoom', '13')), 1)
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 getAlarmRoute(alarm):
"""
get routing from webservice, points and description
"""
if alarm.get('lat', '') != '':
params = {'format': 'kml', 'flat': Settings.get('homeLat'), 'flon': Settings.get('homeLng'), 'tlat': alarm.get('lat'), 'tlon': alarm.get('lng'), 'v': 'motorcar', 'fast': '1', 'layer': 'mapnik', 'instructions': '1', 'lang': current_app.config.get('BABEL_DEFAULT_LOCALE')}
else:
params = {'format': 'kml', 'flat': Settings.get('homeLat'), 'flon': Settings.get('homeLng'), 'tlat': 0, 'tlon': 0, 'v': 'motorcar', 'fast': '1', 'layer': 'mapnik', 'instructions': '1', 'lang': current_app.config.get('BABEL_DEFAULT_LOCALE')}
if alarm.object:
params.update({'tlat': alarm.object.lat, 'tlon': alarm.object.lng})
try:
r = requests.get(alarm.ROUTEURL, params=params)
tree = ET.fromstring(r.content)
except:
return {}
data = {}
def getText(items, elementname):
for el in items:
elname = el.tag[el.tag.find('}') + 1:]
if elname == elementname:
return el.text
def getElements(items, elementname):
for el in items:
elname = el.tag[el.tag.find('}') + 1:]
if elname == elementname:
return el
elements = getElements(tree, 'Document')
data['distance'] = float(getText(elements, 'distance'))
data['traveltime'] = int(getText(elements, 'traveltime'))
data['description'] = getText(elements, 'description')
if data['description'] is None:
data['description'] = ""
data['error'] = 1
data['description'] = re.sub('\s+', ' ', data['description'].replace('\\', ''))
description = []
for l in data['description'].split('<br>'):
if babel.gettext(u'alarms.print.bus') not in l.lower():
match_dir = re.findall(r"" + babel.gettext(u'alarms.print.slightleft') + "|" + babel.gettext(u'alarms.print.left') + "|" + babel.gettext(u'alarms.print.slightright') + "|" + babel.gettext(u'alarms.print.right') + "|" + babel.gettext(u'alarms.print.straight') + "|\d\.\s" + babel.gettext(u'alarms.print.exit'), l.lower()), # km extraction
match_length = re.findall(r"\d*\.\d+\s*[k]?m|\d+\s*[k]?m", l) # km extraction
if len(match_dir) > 0 and len(match_length) > 0:
try:
match_dir = re.sub('\d*\.|\s', '', match_dir[0][0].lower()) # reformat direction
except IndexError:
continue
direction = l.split('. Der Str')[0]
if '[positive]' in direction or '[negative]' in direction or babel.gettext(u'alarms.print.highwaylong') in direction: # eval highway
match_dir = 'highway'
direction = direction.replace(babel.gettext(u'alarms.print.highwaylong'), babel.gettext(u'alarms.print.highwayshort'))
highwayexit = re.findall(r"auf .*;.*", l.lower()) # eval highway exit
if len(highwayexit) > 0:
match_dir = 'highwayexit'
direction = direction.replace(babel.gettext(u'alarms.print.exitstart'), babel.gettext(u'alarms.print.exit').title()).replace(babel.gettext(u'alarms.print.straight'), babel.gettext(u'alarms.print.straightexit'))
direction = re.sub(';\s?', '/', direction)
direction = direction.replace('[positive]', u'<b>%s</b>' % babel.gettext(u'alarms.print.positive'))
direction = direction.replace('[negative]', u'<b>%s</b>' % babel.gettext(u'alarms.print.negative'))
description.append([match_dir, match_length[0], direction])
data['description'] = description
f = getElements(getElements(elements, 'Folder'), 'Placemark')
f = getElements(f, 'LineString')
data['coordinates'] = []
for c in getText(f, 'coordinates').split('\n'):
if c.strip() != '':
data['coordinates'].append((float(c.split(',')[0]), float(c.split(',')[1])))
return data
