def connect(cls, retry=RETRY):
logger.info('Start connection...')
client = None
try:
for trying in range(1, retry + 1):
client = MongoClient(MongoConf.URL)
try:
info = client.server_info()
logger.info(info)
break
except errors.ServerSelectionTimeoutError as error:
logger.info(f' { error } : retry...{ trying }/{ retry }')
except Exception as error:
client = None
logger.error(error)
finally:
cls.CLIENT = client
logger.info('End connection!!!')
return client
def run(self):
try:
_, temp_path = mkstemp()
if config.get('USE_MOTION') is True:
response = requests.get(config.get('MOTION_EYE_SNAPSHOT_URL'))
buffered_reader = BufferedReader(BytesIO(response.content))
logger.debug('Image retrieved from motionEye')
with open(temp_path, 'wb') as capture:
capture.write(response.content)
else:
command = [
config.get('WEBCAM_BIN'),
'--device',
config.get('WEBCAM_DEVICE', '/dev/video0'),
'--resolution',
config.get('WEBCAM_RESOLUTION', '1920x1080'),
'--no-banner',
'--delay',
config.get('WEBCAM_DELAY', '2'),
'--rotate',
config.get('WEBCAM_ROTATE', '180'),
'--jpeg',
config.get('WEBCAM_JPG_COMP', '80'),
temp_path
]
if logger.level > logging.DEBUG:
command.insert(1, '--quiet')
call(command)
buffered_reader = open(temp_path, 'rb')
logger.debug('Image {} captured from webcam'.format(temp_path))
notification = Notification(buffered_reader)
notification.run()
# Move picture in place as background for WebRTC call.
destination_folder = os.path.join(
config.ROOT_PATH,
'app',
'www',
'mobile',
'static',
'img'
)
# Create destination folder if it does not exist
if not os.path.exists(destination_folder):
os.mkdir(destination_folder)
destination = os.path.join(
destination_folder,
'capture.jpg'
)
move(temp_path, destination)
except Exception as e:
logger.error('Camera Helper: {}'.format(str(e)))
return
def response(event, context):
line_header = "X-Line-Signature".lower()
signature = event["headers"][line_header]
body = event["body"]
ok_json = {
"isBase64Encoded": False,
"statusCode": 200,
"headers": {},
"body": ""
}
error_json = {
"isBase64Encoded": False,
"statusCode": 403,
"headers": {},
"body": "Error",
}
try:
handler.handle(body, signature)
except LineBotApiError as e:
logger.error("Got exception from LINE Messaging API: %s\n" % e.message)
for m in e.error.details:
logger.error(" %s: %s" % (m.property, m.message))
return error_json
except InvalidSignatureError:
return error_json
else:
return ok_json
def time_limit_parse(author, rss_url):
try:
items = parse_rss(author, rss_url)
logger.info(rss_url + ' over')
return items
except func_timeout.exceptions.FunctionTimedOut as e:
logger.error(rss_url)
logger.error(e)
return None
def get_user_from_authorization(cls, authorization):
try:
plain = aes.decrypt(authorization)
if ';' not in plain:
return None
except:
logger.error(traceback.format_exc())
return None
id = plain.split(';')[0]
return cls.query_by_id(id)
def insert(cls, collection=None, data={}, retry=RETRY):
res = None
try:
res = cls.CLIENT[collection].insert_one(data, session=cls.SESSION)
logger.info(f'inserted!!! ObjectId: { ObjectId(res.inserted_id) }')
except Exception as error:
logger.error(error)
return res
def save(self, force_insert=False, only=None):
if self.id is not None:
self.modified_date = datetime.now()
try:
return super().save(force_insert=force_insert, only=only)
except Exception as e:
logger.error("{}.save - {}".format(self.__class__.__name__, str(e)))
return False
def save(self, force_insert=False, only=None):
if self.id is None:
self.token = os.urandom(32).hex()
try:
return super().save(force_insert=force_insert, only=only)
except Exception as e:
logger.error("{}.save - {}".format(self.__class__.__name__, str(e)))
return False
def run(self):
try:
logger.debug('Ring bell, ring bell...')
for i in range(0, self.__times):
self.__buzzer.on()
sleep(self.PAUSE_BETWEEN_STATES)
self.__buzzer.off()
sleep(self.PAUSE_BETWEEN_STATES)
except Exception as e:
logger.error(e)
return # Close thread
def error_handlers(response: Response) -> None:
status_code = response.status_code
if status_code == 403:
raise HTTPException(
status_code=403, detail='Forbidden')
if status_code == 400:
raise HTTPException(
status_code=400, detail='Bad request')
if status_code == 422:
logger.error(f'Validation error: {response.json()}')
raise HTTPException(
status_code=422, detail='Validation error')
if status_code != 200:
raise HTTPException(status_code=status_code)
def select(cls, collection=None, cond=None, filter=None, retry=RETRY):
res = None
try:
res = list(cls.CLIENT[collection].find(cond,
filter,
session=cls.SESSION))
cls.CLIENT[collection].aggregate(pipeline=pipe)
logger.info(f'selected!!! length: { len( res ) }')
except Exception as error:
logger.error(error)
return res
def get_network(self, metadata=False, limit=None):
"""
Constructs a citation network from the edge list.
:param metadata: whether or not to include metadata
:param limit: a limit to the number of documents to return
:return: the NetworkX graph
"""
if self.cache:
try:
return nx.read_gpickle(self.make_filename(prefix="GRAPH"))
except FileNotFoundError:
logger.warn("No file on record, creating new graph")
logger.info(
"Generating network from data (metadata={}, limit={})".format(
metadata, limit))
df_edges = self.get_edges()
if limit is not None:
df_edges = df_edges.head(limit)
# for key in self.get_citation_keys():
# df_edges[key] = df_edges[key].str.strip()
G = nx.from_pandas_edgelist(df_edges,
source='citation_id',
target='patent_id',
edge_attr="date",
create_using=nx.DiGraph())
if metadata:
self.ensure_meta()
for entry in self.df_meta.to_dict(orient='records'):
try:
G.nodes[entry['patent_number']].update({
key: val
for key, val in entry.items() if key != 'patent_number'
})
except KeyError:
logger.error("Couldn't find network entry for {}".format(
entry['patent_number']))
logger.info("Generated network with {} nodes and {} edges".format(
len(G.nodes), len(G.edges)))
self.write_graph_to_file(G, self.make_filename(prefix="GRAPH"))
return G
def create_role(db: Session, role_data: RoleModel) -> Role:
try:
role = Role(**role_data.dict())
db.add(role)
db.commit()
db.refresh(role)
except (DataError, OperationalError, IntegrityError) as e:
logger.error(e)
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="invalid data")
except Exception as e:
logger.error(e)
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="unknown error")
else:
return role
def create_policy(db: Session, policy_data: PolicyModel) -> Policy:
try:
policy = Policy(**policy_data.dict())
db.add(policy)
db.commit()
db.refresh(policy)
except (DataError, OperationalError, IntegrityError) as e:
logger.error(e)
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="invalid data")
except Exception as e:
logger.error(e)
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="unknown error")
else:
return policy
def create_user(db: Session, user_data: UserModel) -> User:
try:
user = User(**user_data.dict())
db.add(user)
db.commit()
db.refresh(user)
except (DataError, OperationalError, IntegrityError) as e:
logger.error(e)
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="invalid data")
except Exception as e:
logger.error(e)
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail="unknown error")
else:
return user
def read(cls, message, last_time_received):
try:
message_datetime = datetime.fromtimestamp(message['timestamp'])
delta = message_datetime - last_time_received
if delta.seconds >= int(config.get('BUTTON_PRESS_THRESHOLD')):
if message.get('device') == config.get(
'BACK_DOORBELL_DEVICE_MAC'):
telegram = Notification(front_door=False)
telegram.start()
chime = Chime(
times=config.get('BACK_DOORBELL_RINGS_NUMBER'))
chime.run() # No need to run it as thread
else:
logger.debug('Relax dude! Stop pushing the button')
except KeyError:
logger.error('Message is invalid.')
return False
def send(cls, message, type_):
message.update({
'type': type_,
'timestamp': time.time(),
'signature': config.get('MESSAGE_BROKER_KEY')
})
host = config.get('MESSAGE_BROKER_HOST')
port = int(config.get('MESSAGE_BROKER_PORT'))
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((host, port))
s.sendall(json.dumps(message).encode('utf-8'))
except ConnectionRefusedError:
logger.error('Could not connect to socket')
return False
return True
def kill(cls, slug):
logger.debug('Process.run: KILL ' + slug)
if slug is None:
processes = Process.select().where(cls.slug.is_null(False))
else:
processes = Process.select().where(cls.slug == slug)
for process in processes:
cp = subprocess.run(['kill', '-9', str(process.pid)],
stderr=subprocess.PIPE)
if cp.returncode != 0:
logger.error('Process #{} ({}) could not be killed'.format(
process.pid, process.slug))
else:
logger.debug('Process #{} ({}) has been killed'.format(
process.pid, process.slug))
process.delete_instance()
def get_security_body(self, msg_encrypt, msg_signature, timestamp, nonce):
'''获取加密消息体'''
check_data = [self.token, msg_encrypt, timestamp, nonce]
check_data.sort()
sign = sha1(''.join(check_data))
if sign == msg_signature:
try:
aes_key = base64.b64decode(f'{self.encoding_aes_key}=')
aes = AESecurity(aes_key)
aes_msg = base64.b64decode(msg_encrypt)
body = aes.decrypt(aes_msg)
res = body[20:body.rfind('>') + 1]
return 200, res
except Exception as e:
logger.error(e)
return 500, '加密信息解析失败'
else:
return 500, '加密校验失败'
def return_response(cls, data={}, status=200, message="", headers={}):
try:
logger.debug('return %s %s', status, message)
except:
logger.error(traceback.format_exc())
try:
filters = request.args.get('filters')
if filters:
fd = BaseDict(data).filter(*filters.split(','))
data = fd
except:
logger.error(traceback.format_exc())
data = data
try:
if isinstance(data, db.Model):
data = data.format()
elif isinstance(data, list) and data and \
isinstance(data[0], db.Model):
data = [o.format() for o in data]
except:
logger.error(traceback.format_exc())
data = data
res = cls(
data=data,
status=status,
message=message
).to_dict()
return make_response(jsonify(res), status, headers)
def run(self):
now = datetime.datetime.now().replace(microsecond=0).isoformat()
if self.__picture is None:
if self.__front_door:
token = Token()
token.save()
auth_web_app_link = 'https://{domain}:{port}?token={token}'.format(
message=config.get('NOTIFICATION_FRONT_DOOR_MESSAGE'),
domain=config.get('WEB_APP_DOMAIN_NAME'),
port=config.get('WEB_APP_PORT'),
token=token.token)
message = '{message}\n' \
'[{call_cta_label}]({call_cta_link})'.\
format(
message=_('daemon/notification/front_door_message'),
call_cta_label=_('daemon/notification/call_cta_label'),
call_cta_link=auth_web_app_link)
else:
message = _('daemon/notification/back_door_message')
bot.send_message(chat_id=config.get('TELEGRAM_CHAT_ID'),
text=message,
parse_mode=telegram.ParseMode.MARKDOWN)
logger.debug('Ring notification sent to Telegram')
return # Close thread
try:
bot.send_photo(chat_id=config.get('TELEGRAM_CHAT_ID'),
photo=self.__picture,
caption=_('Photo'),
disable_notification=True)
logger.debug('Photo sent to Telegram')
except Exception as e:
logger.error('Could not send attachment to Telegram: {}'.format(
str(e)))
return # Close thread
def get(self):
kind = None
identifier = None
try:
identifier = get_kvk_number_from_request(request)
kind = "kvk"
except SamlVerificationException:
return {"status": "ERROR", "message": "Missing SAML token"}, 400
except KeyError:
# does not contain kvk number, might still contain BSN
pass
if not identifier:
try:
identifier = get_bsn_from_request(request)
except InvalidBSNException:
return {"status": "ERROR", "message": "Invalid BSN"}, 400
kind = "bsn"
try:
has_erfpacht, notifications = get_data(kind, identifier)
except Timeout:
return {"status": "ERROR", "message": "Timeout"}, 500
except ConnectionError as e:
logger.error(f"ConnectionError {e}")
return {"status": "ERROR", "message": "Connection Error"}, 500
except Exception as e:
logger.exception(e)
return {"status": "ERROR", "message": "Unknown error"}, 500
return {
"status": "OK",
"content": {
"isKnown": has_erfpacht,
"meldingen": notifications,
},
}
def run(self, command, slug=None):
logger.debug('Process.run: START ')
logger.debug(command)
proc = subprocess.Popen(command, stderr=subprocess.PIPE)
try:
command_str = ' '.join(command)
self.pid = proc.pid
self.slug = slug
self.command = command_str
if proc.returncode:
logger.error(
'Process.run: Command `{}` failed: Error ({}): {}'.format(
command_str, proc.returncode,
proc.stderr.read().encode()))
self.save()
except Exception as e:
logger.error('Process.run: Command `{}` failed: Error: {}'.format(
command_str, str(e)))
logger.debug('Process.run: END ' + command_str)
def transWrap(pipeline=None):
if cls.CLIENT != None and pipeline != None:
logger.info(pipeline)
'''
Setting pipeline
'''
session = cls.CLIENT.start_session()
res = None
try:
session.start_transaction()
res = func(client=cls.CLIENT[database],
session=session)
session.commit_transaction()
except Exception as error:
session.abort_transaction()
logger.error(error)
return res
else:
return func(client=None, session=None)
def before_request():
g.request_start_time = time.time()
try:
data = request.data
logger.debug('data %s', data)
args = request.args or {}
logger.debug('args %s', args)
json_data = request.json or {}
logger.debug('json %s', json_data)
form_data = request.form or {}
logger.debug('form %s', form_data)
h_data = request.headers or {}
for k, v in h_data:
logger.debug('header %s: %s', k, v)
except Exception as e:
logger.error('params %s', e)
logger.error(traceback.format_exc())
navs = Nav.query_items()
g.navs = navs
g.current_nav = Nav.query_item(url=request.path)
authorization = request.cookies.get('authorization') or\
request.headers.get(BaseConfig.HEAD_AUTHORIZATION)
if not authorization:
user = None
else:
user = User.get_user_from_authorization(authorization)
if request.path.startswith('/admin'):
if not user and (request.path != '/admin/login'
or request.path.startswith('/static')):
return redirect('/admin/login')
g.current_user = user
logger.debug('current_user %s', g.current_user)
