def classes_convert(item):
if item.get('start_at'):
item['startAt'] = item['start_at']
if item.get('finish_at'):
item['finishAt'] = item['finish_at']
if item.get('module'):
lookup = {
'name': item['module']['name']
}
module, *_ = getitem_internal('modules', **lookup)
item['module'] = module[config.ID_FIELD]
if item.get('branch'):
lookup = {
'name': item['branch']['name']
}
branch, *_ = getitem_internal('branches', **lookup)
item['branch'] = branch[config.ID_FIELD]
if item.get('tutor'):
resource = 'users'
app.config['DOMAIN'][resource]['soft_delete'] = False
lookup = {
'username': item['tutor']['username']
}
try:
tutor, *_ = getitem_internal(resource, **lookup)
item['tutor'] = tutor[config.ID_FIELD]
except NotFound:
item['tutor'] = None
if item.get('students'):
resource = 'users'
for v in item['students']:
lookup = {
'username': v['student']['username']
}
try:
student, *_ = getitem_internal(resource, **lookup)
v['student'] = student[config.ID_FIELD]
except NotFound:
v['student'] = None
allowed_key = ('day', 'startAt', 'finishAt',
'module', 'branch', 'tutor', 'students')
item = filter(lambda v: v[0] in allowed_key, item.items())
item = dict(item)
item = filter(lambda v: v[1] is not None, item.items())
item = dict(item)
return item
def test_get_single_product_audit_creation(client, app):
with app.test_request_context(path='/account/products/'):
g.user = '******'
response = getitem_internal('account/products',
_id='5ab03a87bdd78169bb6d0783')
assert str(response[0]['_id']) == '5ab03a87bdd78169bb6d0783'
audit_check('5ab03a87bdd78169bb6d0783')
def add_file(items):
project_info=getitem_internal('project',**{'_id': items[0]['ProjectID']})[0]
trimble_folder_id=project_info['TrimbleFolderID']
for item in items:
# download file
file=IO()
file_path=file.save_file(item['Url'])
# upload to trimble
token=get_internal('lastToken')[0]['_items']['token']
headers={"Authorization":"Bearer "+token}
files = {'file': open(file_path, 'rb')}
r = requests.post(trimble_url+'files?parentId='+trimble_folder_id,files=files,headers=headers)
trimble_data=r.json()[0]
TrimbleVersionID=trimble_data['versionId']
item['TrimbleVersionID']=TrimbleVersionID
# extract features from ifc file
ifc=IFC(file_path)
entityList, entities, data=ifc.parse_geometry()
file.remove_file(file_path)
bim=Model(data=data,model_id=TrimbleVersionID)
features=bim.get_features()
item['ThumbnailUrl']=process_thumbnail(TrimbleVersionID,headers)
item['Entities']=entityList
for entity in entities:
entity['TrimbleVersionID']=TrimbleVersionID
post_internal('entity',entities)
post_internal('feature',features)
def sign():
data = request.values or request.get_json()
if not data:
abort(400, description='username required')
expected_username = data.get('username')
if not expected_username:
abort(400, description='username required')
expected_username = expected_username.lower()
expected_role = data.get('role')
if not expected_role:
abort(400, description='role required')
r = {'username': expected_username, 'role': expected_role[0]}
user, *_ = getitem_internal(resource, **r)
if not user:
abort(400, description='user not found')
if user.get('pass_'):
password = data.get('password')
if (password != user['pass_']):
abort(400, description='password required or wrong password')
return jsonify({
'token':
jwt.encode({config.ID_FIELD: user[config.ID_FIELD]}, config.JWT_SECRET)
})
def auth():
try:
lookup = {config.ID_FIELD: app.auth.get_request_auth_value()}
user, *_ = getitem_internal(resource, **lookup)
allowed_key = ('name', 'username', 'email', 'role', 'photo',
config.ID_FIELD, config.ETAG)
user = filter(lambda v: v[0] in allowed_key, user.items())
user = dict(user)
return jsonify(user)
except Exception as e:
abort(400, description=str(e))
def get_user():
"""A simple whoami
Only return 'I am username'"""
try:
response, last_modified, etag, status = getitem_internal(resource='users', **{'id': app.globals['id']})
if status == 200 and '_id' in response:
return eve_response(data={'iam': response['id']})
except:
app.logger.error("Unknown error in get_user")
return eve_abort(500, 'Unknown error occurred')
def forgot_password():
mail.init_app(app)
data = request.values or request.get_json()
if not data:
abort(422, description='username or email required')
expected_username = data.get('username')
if not expected_username:
abort(422, description='username or email required')
expected_role = data.get('role')
if not expected_role:
abort(422, description='role required')
r = {'username': expected_username, 'role': expected_role[0]}
user, *_ = getitem_internal(resource, **r)
if not user:
r = {'email': expected_username, 'role': expected_role[0]}
user, *_ = getitem_internal(resource, **r)
if not user:
abort(404, description='username or email not found')
else:
if not user['email']:
abort(422, description='username or email found, but no email')
new_password = str(uuid.uuid4())[:8]
_ = patch_internal(resource, {'password': new_password},
**{config.ID_FIELD: user[config.ID_FIELD]})
body = template % (expected_username, new_password)
msg = Message("Reset Password", body=body, recipients=[user['email']])
mail.send(msg)
return jsonify({})
def get_user():
"""A simple whoami
Only return 'I am username'"""
try:
response, last_modified, etag, status = getitem_internal(
resource='users', **{'id': app.globals['id']})
if status == 200 and '_id' in response:
return eve_response(data={'iam': response['id']})
except:
app.logger.error("Unknown error in get_user")
return eve_abort(500, 'Unknown error occurred')
def get_feature_view(data):
items=data['_items']
if len(items)==0:
return
TrimbleVersionID=items[0]['TrimbleVersionID']
all=getitem_internal('file',**{'TrimbleVersionID': TrimbleVersionID})[0]['Entities']
for item in items:
hide=all[:]
if item['FeatureType']=='Pairwise' and item['FeatureProvider']=='System':
show=item['FeatureValue']
show.append(item['GlobalId'])
for show_obj in show:
hide.remove(show_obj)
item['FeatureValue']=hide
def create_user(username):
melwin_user, _, _, status = getitem_internal(resource='melwin/users', **{'id': username})
if melwin_user and status == 200:
try:
user_response, _, _, user_code, header = post_internal(resource=app.globals['auth']['users_collection'],
payl={'id': username},
skip_validation=True)
except:
app.logger.exception("503: Could not create (POST) new user %i" % username)
return False
try:
auth_response, _, _, auth_code, header = post_internal(resource='users/auth',
payl={'id': username,
'user': user_response['_id'],
'auth': {"token": "",
"valid": ""}},
skip_validation=True)
except:
app.logger.exception("%i: Could not create (mongo insert) user %i auth item" % (auth_code, username))
return False
# Verify both post's response codes
if user_code == 201 and auth_code == 201:
return True
else:
try:
from eve.methods.delete import deleteitem_internal
if '_id' in user_response:
_, _, _, code = deleteitem_internal(resource=app.globals['auth']['users_collection'],
concurrency_check=False,
suppress_callbacks=True,
**{'_id': user_response['_id']})
app.logger.info("Deleted user from users")
if '_id' in auth_response:
_, _, _, code = deleteitem_internal(resource='users/auth',
concurrency_check=False,
suppress_callbacks=True,
**{'_id': auth_response['_id']})
app.logger.info("Deleted user from users_auth")
except:
app.logger.exception("Delete operation of user %i from users and users_auth but failed" % username)
return False
def before_aggregation(endpoint, pipeline):
"""Before get or aggregation, check permissions
If OBSREG is closed, none?"""
if endpoint == 'notifications_events':
_id = pipeline[0].get('$match', {}).get('event_from_id')
resource = pipeline[0].get('$match', {}).get('event_from')
item, _date, etag, status = getitem_internal(resource, **{'_id': _id})
if (
(item.get('workflow', {}).get('state', 'closed') == 'closed' and item.get('acl_user', {}).get('x',
False) is False)
or
(item.get('acl_user', {}).get('r', False) is False)
):
return eve_abort(403, 'No access')
def _update_person(item):
lookup = {'person_id': item['id']}
competences, _, _, c_status, _ = get_internal(RESOURCE_COMPETENCES_PROCESS,
**lookup)
if c_status == 200:
on_competence_post(competences.get('_items', []))
licenses, _, _, l_status, _ = get_internal(RESOURCE_LICENSES_PROCESS,
**lookup)
if l_status == 200:
on_license_post(licenses.get('_items', []))
functions, _, _, f_status, _ = get_internal(RESOURCE_FUNCTIONS_PROCESS,
**lookup)
app.logger.debug('Functions\n{}'.format(functions))
if f_status == 200:
on_function_post(functions.get('_items', []))
try:
# Need to get personreturn response, last_modified, etag, 200
person, _, _, p_status = getitem_internal(RESOURCE_PERSONS_PROCESS,
**{'id': item['id']})
if p_status == 200:
# Broadcast all
broadcast({
'entity':
'person',
'entity_id':
item['id'],
'orgs':
list(
set([x['activity'] for x in person['memberships']] +
[x['discipline'] for x in person['memberships']] +
[x['club'] for x in person['memberships']]))
})
except Exception as e:
print('[ERR]', e)
print(person)
def on_insert(resource_name, items):
if resource_name == 'classes':
for i, v in enumerate(items):
d = conv_put_recurr(v)
items[i].update(d)
if v.get('day'):
del items[i]['day']
if v.get('startAt'):
del items[i]['startAt']
if v.get('finishAt'):
del items[i]['finishAt']
if resource_name == 'attendances_tutors':
for i, v in enumerate(items):
class_ = v.pop('class', None)
lookup = {config.ID_FIELD: class_}
class_, *_ = getitem_internal('classes', **lookup)
date = wib_now.date()
# pprint('class_')
# pprint(class_)
try:
lookup = {
'class': class_[config.ID_FIELD],
'module': class_['module'],
config.DATE_CREATED: {
'$gte':
class_['start'].astimezone(wib_tz).replace(
day=date.day, month=date.month, year=date.year)
},
}
attendance, *_ = getitem_internal('attendances', **lookup)
except NotFound:
payload = {
'class': class_[config.ID_FIELD],
'module': class_['module']
}
attendance, *_ = post_internal('attendances', payload)
# pprint('attendance')
# pprint(attendance)
try:
lookup = {
'attendance': attendance[config.ID_FIELD],
'tutor': app.auth.get_request_auth_value(),
config.DATE_CREATED: {
'$gte': attendance[config.DATE_CREATED]
},
}
*_, status = getitem_internal('attendances_tutors', **lookup)
if status == 200:
abort(422, description='exist')
except NotFound:
# pprint(items)
items[i].update({
'attendance': attendance[config.ID_FIELD],
'tutor': app.auth.get_request_auth_value(),
})
def login():
username = None
password = None
logged_in = False
m = Melwin()
if m is None:
app.logger.critical("Melwin service unavailable")
eve_abort('503', 'Melwin service is unavailable')
# Request via json
rq = request.get_json()
try:
username = rq['username']
password = rq['password']
except:
# Now it will fail in the next if
pass
if username == 'access_token':
try:
public_key = _get_public_key()
decoded_token = jwt.decode(password, public_key, issuer=ISSUER, algorithm='HS256')
logged_in = True
username = decoded_token.get('melwin_id', None)
if username is None:
eve_abort(401, 'Could not validate the token, could not find username')
else:
# print('Username', username)
username = int(username)
except jwt.exceptions.InvalidTokenError:
logged_in = False
eve_abort(401, 'Could not validate the token, InvalidTokenError')
except jwt.exceptions.InvalidSignatureError:
logged_in = False
eve_abort(401, 'Could not validate the token, InvalidSignatureError')
except jwt.exceptions.InvalidIssuerError:
logged_in = False
eve_abort(401, 'Could not validate the token, InvalidIssuerError')
except jwt.exceptions.ExpiredSignatureError:
logged_in = False
eve_abort(401, 'Could not validate the token, ExpiredSignatureError')
except Exception as e:
logged_in = False
eve_abort(401, 'Could not validate your token {}'.format(e))
else:
try:
username = int(username)
logged_in = m.login(username, password)
except:
logged_in = False
eve_abort(503, 'Could not log you into Melwin') # isinstance(username, int) and len(password) == 9 and
# Now process user and successful authentication
if logged_in is True:
try:
user, last_modified, etag, status = getitem_internal(resource='users', **{'id': username})
except:
user = None
if not is_mongo_alive():
eve_abort(502, 'Network problems')
# If not existing, make from melwin!
if user is None or status != 200:
if not create_user(username):
app.logger.error("502: Could not create user %i from Melwin" % username)
eve_abort(502, 'Could not create user from Melwin')
else:
app.logger.info("Created user %i" % username)
# token = uuid5(uuid4(),rq['username'])
token = uuid4().hex
# valid = utc.replace(hours=+2) # @bug: utc and cet!!!
utc = arrow.utcnow()
valid = utc.replace(seconds=+app.config['AUTH_SESSION_LENGHT'])
# Pure datetime
# valid = datetime.datetime.now() + datetime.timedelta(seconds=60)
try:
response, last_modified, etag, status = patch_internal('users/auth',
payload={'auth': {'token': token,
'valid': valid.datetime}},
concurrency_check=False, **{'id': username})
if status != 200:
app.logger.error("Could not insert token for %i" % username)
except:
app.logger.exception("Could not update user %i auth token" % username)
eve_abort(500, "Could not update user %i auth token" % username)
t = '%s:' % token
b64 = b64encode(t.encode('utf-8'))
"""return jsonify(**{'success': True,
'token': token,
'token64': b64,
'valid': valid,
})"""
return eve_response(data={'success': True,
'username': username,
'token': token,
'token64': b64.decode('utf-8'),
'valid': valid.datetime},
status=200)
# On error sleep a little against brute force
sleep(1)
return eve_response({'success': False, 'username': None, 'token': None, 'token64': None, 'valid': None,
'message': 'Wrong username or password'})
def do_melwin_update(app):
app.logger.info("[MELWIN] Updater started")
use_pickle = False
result = {'replaced': 0, 'created': 0, 'errors': 0, 'error_ids': []}
try:
with app.test_request_context('api/v1/melwin/users'):
try:
if not use_pickle:
raise FileNotFoundError
with open("persons.p", "rb") as f:
persons = pickle.load(f)
app.logger.info("[MELWIN] Using local person pickle file")
except FileNotFoundError:
app.logger.info("[MELWIN] requesting data from Melwin")
m = Melwin()
persons = m.get_all()
with open("persons.p", "wb") as f:
pickle.dump(persons, f)
except:
pass
for key, user in persons.items():
""""Iterate every person from Melwin"""
try:
existing_user, _, _, status = getitem_internal(resource='melwin/users', **{'id': user['id']})
if not existing_user or status != 200:
existing_user = None
except:
app.logger.info("[MELWIN] No existing user %i" % user['id'])
existing_user = None
if existing_user is None \
or user['location']['street'] != existing_user['location']['street'] \
or user['location']['zip'] != existing_user['location']['zip'] \
or user['location']['country'] != existing_user['location']['country'] \
or user['location']['city'] != existing_user['location']['city']:
app.logger.info("[MELWIN] Geocoding %i" % user['id'])
try:
geo = m.get_geo(user['location']['street'],
user['location']['city'],
user['location']['zip'],
user['location']['country'])
if geo != None:
user['location'].update(
{'geo': {"type": "Point", "coordinates": [geo.latitude, geo.longitude]}})
user['location'].update({'geo_type': geo.raw['type']})
user['location'].update({'geo_class': geo.raw['class']})
user['location'].update({'geo_importance': float(geo.raw['importance'])})
user['location'].update({'geo_place_id': int(geo.raw['place_id'])})
except:
app.logger.error("[MELWIN] Geocoding for user %i failed" % user['id'])
if not 'fullname' in user:
user.update({'fullname': "%s %s" % (user['firstname'], user['lastname'])})
lookup = dict({})
try:
lookup = dict({'id': key})
r, _, _, status = put_internal(resource='melwin/users', payload=user, concurrency_check=False,
skip_validation=False, **lookup)
if status == 200:
result['replaced'] += 1
elif status == 201:
result['created'] += 1
else:
app.logger.info("[MELWIN] Status %i for put_internal" % status)
except KeyError:
r, _, _, status, header = post_internal(resource='melwin/users', payl=user, skip_validation=True)
if status == 201:
result['created'] += 1
except:
result['errors'] += 1
result['error_ids'].append(user['id'])
app.logger.error("[MELWIN] Error for user %i" % user['id'])
except:
"""Major error, warn"""
from ext.notifications.sms import Sms
app.logger.exception("[MELWIN] Error updating users from Melwin")
sms = Sms()
sms.send(mobile=sms.get_warn_sms(), message="[%s] %s" % (500, "Error updating users from Melwin"))
result['errors'] += 1
app.logger.info("[MELWIN] Updater finished (created: %i updated: %i errors: %i)" %
(result['created'], result['replaced'], result['errors']))
# Restart in one day!
threading.Timer(get_timer(), do_melwin_update, [app]).start()
def _get_file_link(file_id: ObjectId) -> str:
# Get the file document via Eve to make it update the link.
file_doc, _, _, status = getitem_internal('files', _id=file_id)
assert status == 200
return file_doc['link']
def _acl_from_functions(person_id):
function_acl = []
lookup = {
'person_id':
person_id,
'is_deleted':
False,
'is_passive':
False,
'type_is_license':
False,
'$or': [{
'to_date': {
'$gt': '{}Z'.format(datetime.now().isoformat())
}
}, {
'to_date': {
'$exists': False
}
}]
}
functions, _, _, status, _ = get_internal('functions_process', **lookup)
if status == 200:
for f in functions['_items']:
org, _, _, fstatus = getitem_internal(
'organizations', **{'id': f['active_in_org_id']})
if fstatus == 200 and org.get('type_id', 0) in [
6, 2, 19, 14
]: # 2 særforbund, 19 seksjon, 14 er gren
""" Due to NA
if org.get('type_id', 0) == 6:
activities = _get_activities_in_club(org['id'])
else:
activities = [org.get('activities', {'id': 27}).get('id')]
"""
for activity in [
v['id'] for v in org.get('activities', [{
'id': 27
}])
]:
try:
if activity in list(NLF_ORG.keys()):
function_acl.append({
'activity':
activity,
'org':
f['active_in_org_id'],
'role':
f['type_id'],
'name':
f.get('type_name', 'ukjent'),
'func':
f['id'],
'type':
org.get('type_id')
})
except:
pass
return status, function_acl
return status, function_acl
def get_viewer_data(item):
project_info=getitem_internal('project',**{'_id': item['ProjectID']})[0]
item['TrimbleProjectID']=project_info['TrimbleProjectID']
item['token']=get_internal('lastToken')[0]['_items']['token']
