def register_file(asset,
upload_name,
override_suffix=None,
asset_type: AssetType = AssetType.SINGLE):
connector = current_app.connector
file_repository = FileRepository(connector)
user_repository = UserRepository(connector)
user = user_repository.find_by_uuid(session['uuid'])
files = file_repository.list_by(
**deactivate_filter(upload_name, asset, asset_type))
for file in files:
file['active'] = 0
file_repository.update(file)
source = Path(upload_name)
uuid = uuid4().hex
file = {
'uuid':
uuid,
'asset':
asset,
'uploadname':
source.name,
'usr_id':
user['id'],
'filename':
ora.nvl2(override_suffix, f"{uuid}{override_suffix}",
f"{uuid}{source.suffix}")
}
file_repository.insert(file)
return file['uuid']
def test_user_insert(self):
properties = {
'current.dir': os.path.abspath(os.getcwd()),
'package.dir': os.path.dirname(snapsnare.__file__),
'home.dir': str(Path.home()),
'app.name': 'snapsnare'
}
ds = utils.load_json(properties, 'snapsnare-ds.json')
connector = ConnectorFactory.create_connector(ds)
connector.connect()
user_repository = UserRepository(connector)
user = {
'username': '******',
'password': '******'
}
id_ = user_repository.insert(user)
self.assertIsNotNone(id_, 'no id')
user = user_repository.find_by(id=id_)
connector.rollback()
connector.close()
self.assertIsNotNone(user, 'no user')
username = user.get('username')
self.assertIsNotNone(username, 'no username')
expected = '*****@*****.**'
self.assertEqual(expected, username,
'invalid state, expected {} got {}'.format(expected, username))
def show():
if request.method == 'GET':
role = session.get('role', 'user')
if role != 'admin':
return redirect(url_for('login.show'))
uuid_ = request.args.get('uuid')
connector = current_app.connector
registration_repository = RegistrationRepository(connector)
registration = registration_repository.find_by_uuid(uuid_)
if registration['state'] != 'approved':
flash('Unexpected registration state.', 'danger')
return redirect(url_for('registrations.show'))
user_repository = UserRepository(connector)
user = user_repository.find_by(id=registration['id'])
user = {'uuid': user['uuid'], 'active': 0}
user_repository.update(user)
registration = {'uuid': uuid_, 'state': 'terminated', 'active': 0}
registration_repository.update(registration)
connector.commit()
connector.close()
return redirect(url_for('registrations.show'))
def load_user(user_id):
user_repository = UserRepository(connector)
user = user_repository.find_by_uuid(user_id)
connector.close()
if not user:
return redirect(url_for('login.show'))
else:
return User(user['id'], user['username'], user['password'])
def show():
connector = current_app.connector
if request.method == 'GET':
section_repository = SectionRepository(connector)
sections = section_repository.list_by(active=1, order_by='id')
connector.close()
return render_template('password_forgotten/password_forgotten.html',
sections=sections)
if request.method == 'POST':
username = request.form['username']
user_repository = UserRepository(connector)
user = user_repository.find_by(username=username, active=1)
if not user:
flash('Invalid account state', 'danger')
return redirect(url_for('login.show'))
# disable previous resets of this user.
reset = {"active": 0}
reset_repository = ResetRepository(connector)
reset_repository.update(reset, where={"username": user["username"]})
# create an active reset for this user.
reset = {
"active": 1,
"uuid": str(uuid4()),
"username": user["username"],
}
reset_repository.insert(reset)
properties = current_app.properties
settings = utils.load_json(properties, 'snapsnare.json')
credentials = settings['gmail']
snapsnare = settings['snapsnare']
host = snapsnare['host']
template_repository = TemplateRepository(connector)
template = template_repository.find_by(template='reset')
content = template['content']
content = content.replace("{host}", host)
content = content.replace("{uuid}", reset['uuid'])
connector.commit()
gmail.send_email(credentials, reset['username'],
"Reset your account on snapsnare.org", content)
flash(
'A reset request is successfully created. Please check your e-mail to reset your password.',
'success')
return redirect(url_for('login.show'))
def load():
connector = current_app.connector
snap_repository = SnapRepository(connector)
user_repository = UserRepository(connector)
role_repository = RoleRepository(connector)
section = component.section()
if not component.has_fragment(section, ComponentEnum.MY_SAMPLES):
return []
user = user_repository.find_by_uuid(session['uuid'])
snaps = snap_repository.list_by(usr_id=user['id'],
active=1,
order_by='updated_at desc')
properties = current_app.properties
for snap in snaps:
user = user_repository.find_by(id=snap['usr_id'], active=1)
role = role_repository.find_by(id=user['rle_id'], active=1)
snap['username'] = user.get('username')
snap['first_name'] = user.get('first_name')
snap['last_name'] = user.get('last_name')
snap['role'] = role.get('role')
snap['section'] = section['uuid']
dt_created_at = datetime.strptime(snap['created_at'],
'%Y-%m-%d %H:%M:%S.%f')
snap['created_at_formatted'] = dt_created_at.strftime('%d %B at %H:%M')
dt_updated_at = datetime.strptime(snap['updated_at'],
'%Y-%m-%d %H:%M:%S.%f')
snap['updated_at_formatted'] = dt_updated_at.strftime('%d %B at %H:%M')
clips_folder = os.path.join(properties['current.dir'], 'assets',
snap['uuid'])
if os.path.isdir(clips_folder):
files = Folder(clips_folder).listdir(filters='.wav;.mp3;.ogg')
if len(files) != 0:
snap['url'] = '/assets/{}/{}'.format(snap['uuid'], files[0])
snap['type'] = utils.html_audio_source_type(files[0])
return snaps
def post(self):
try:
payload = request.get_json(silent=True)
if not payload:
return responsify(
message='Invalid JSON content, or content-type header '
'is not set to application/json'), 400
username = payload.get('username')
password = payload.get('password')
if not username:
logging.debug('no username given')
return responsify(message='invalid username or password'), 400
if not password:
logging.debug('no password given')
return responsify(message='invalid username or password'), 400
connector = current_app.connector
user_repository = UserRepository(connector)
user = user_repository.find_by_username(username)
if not user:
logging.debug('user not found')
return responsify(message='invalid username or password'), 400
# hash the given password, so it can be checked against the hashed password
# stored in the database
password = hasher.sha256(password)
if password != user.get('password'):
logging.debug('invalid password')
return responsify(message='invalid username or password'), 401
access_token = create_access_token(identity=username)
return responsify(access_token=access_token), 200
except Exception:
response = tracer.build()
logging.exception('authentication failed')
return response, 500
def show():
connector = current_app.connector
if request.method == 'GET':
section_repository = SectionRepository(connector)
sections = section_repository.list_by(active=1, order_by='id')
connector.close()
return render_template('login/login.html', sections=sections)
username = request.form['username']
password = request.form['password']
user_repository = UserRepository(connector)
user = user_repository.find_by_username(username)
if not user:
flash('Invalid username or password.', 'danger')
return redirect(url_for('login.show'))
registration_repository = RegistrationRepository(connector)
registration = registration_repository.find_by(id=user['rgn_id'], active=1)
if registration['state'] == 'blocked':
flash('This account is blocked.', 'danger')
return redirect(url_for('login.show'))
registered_user = User(user['uuid'], user['username'], user['password'])
if not registered_user.check_password(password):
flash('Invalid username or password.', 'danger')
return redirect(url_for('login.show'))
role_repository = RoleRepository(connector)
role = role_repository.find_by(id=user['rle_id'], active=1)
connector.close()
login_user(registered_user)
session['username'] = request.form['username']
session['uuid'] = user['uuid']
session['role'] = role['role']
return redirect(request.args.get('next') or url_for('index.show'))
def show():
if request.method == 'GET':
uuid_ = request.args.get('uuid')
connector = current_app.connector
registration_repository = RegistrationRepository(connector)
user_repository = UserRepository(connector)
role_repository = RoleRepository(connector)
registration = registration_repository.find_by(uuid=uuid_,
active=1,
state='new')
if not registration:
connector.close()
flash('This account is already activated.', 'danger')
return render_template('activate/activate.html', code=code.load())
role = role_repository.find_by(id=registration['rle_id'], active=1)
user = {
'username': registration['username'],
'password': registration['password'],
'first_name': registration['first_name'],
'last_name': registration['last_name'],
'nickname': registration['nickname'],
'rgn_id': registration['id'],
'rle_id': role['id']
}
user_repository.insert(user)
registration = {'uuid': uuid_, 'state': 'approved'}
registration_repository.update(registration)
connector.commit()
connector.close()
flash('Your account is activated successfully and ready for use.',
'success')
return render_template('activate/activate.html', code=code.load())
def show():
if request.method == 'GET':
uuid_ = request.args.get('uuid')
section_uuid_ = request.args.get('section')
connector = current_app.connector
activity_repository = ActivityRepository(connector)
file_repository = FileRepository(connector)
section_repository = SectionRepository(connector)
user_repository = UserRepository(connector)
section = section_repository.find_by_uuid(section_uuid_)
user = user_repository.find_by_uuid(session['uuid'])
activity = activity_repository.find_by(uuid=uuid_)
if user['id'] != activity['usr_id']:
connector.close()
return redirect(
url_for(f"{section['endpoint']}.show",
section=section['uuid']))
activity = {'uuid': uuid_, 'active': 0}
activity_repository.update(activity)
file = {
'active': 0,
}
file_repository.update(file, where={'asset': uuid_})
connector.commit()
connector.close()
flash('Your posting is removed successfully.', 'info')
return redirect(
url_for(f"{section['endpoint']}.show", section=section['uuid']))
def show():
connector = current_app.connector
user_repository = UserRepository(connector)
if request.method == 'GET':
uuid_ = request.args.get('uuid')
if uuid_ != session['uuid']:
return redirect(url_for('login.show'))
user = user_repository.find_by_uuid(uuid_)
user = dictionaries.strip_none(user)
section_repository = SectionRepository(connector)
sections = section_repository.list_by(active=1, order_by='id')
connector.close()
return render_template('password/password.html',
sections=sections,
user=user)
uuid_ = request.form['uuid']
password_ = request.form['password']
new_password = request.form['new_password']
repeat = request.form['repeat']
if uuid_ != session['uuid']:
return redirect(url_for('login.show'))
user = user_repository.find_by_username(session['username'])
if not user:
flash('Invalid username.', 'danger')
return redirect(url_for('password.show', uuid=uuid_))
registered_user = User(user['uuid'], user['username'], user['password'])
if not registered_user.check_password(password_):
flash('Invalid password.', 'error')
return redirect(url_for('password.show', uuid=uuid_))
# the given passwords do not match
if new_password != repeat:
flash('The newly entered passwords do not match.', 'danger')
return redirect(url_for('password.show', uuid=uuid_))
# change the password
user = {'uuid': uuid_, 'password': hasher.sha256(new_password)}
user_repository.update(user)
connector.commit()
connector.close()
# show the login screen
flash('The password is updated successfully.', 'success')
return redirect(url_for('password.show', uuid=uuid_))
def show():
connector = current_app.connector
user_repository = UserRepository(connector)
section_repository = SectionRepository(connector)
sections = section_repository.list_by(active=1, order_by='id')
if request.method == 'GET':
uuid_ = request.args.get('uuid')
# check messing with uuid's
if uuid_ != session['uuid']:
return redirect(url_for('login.show'))
user = user_repository.find_by_uuid(uuid_)
user = dictionaries.strip_none(user)
role_repository = RoleRepository(connector)
role = role_repository.find_by(id=user['rle_id'], active=1)
user['role'] = role['role']
connector.close()
return render_template('profile/profile.html', sections=sections, user=user)
uuid_ = request.form['uuid']
first_name = request.form['first_name']
last_name = request.form['last_name']
nickname = request.form['nickname']
phone_number = request.form['phone_number']
user = {
'uuid': uuid_,
'first_name': first_name,
'last_name': last_name,
'nickname': nickname,
'phone_number': phone_number
}
# check messing with uuid's
if uuid_ != session['uuid']:
return redirect(url_for('login.show'))
user_repository.update(user)
user = user_repository.find_by_uuid(user['uuid'])
connector.commit()
connector.close()
flash('Your account details are updated successfully.', 'info')
return render_template('profile/profile.html', sections=sections, user=user)
def show():
connector = current_app.connector
user_repository = UserRepository(connector)
section_repository = SectionRepository(connector)
role_repository = RoleRepository(connector)
instrument_repository = InstrumentRepository(connector)
access_modifier_repository = AccessModifierRepository(connector)
genre_repository = GenreRepository(connector)
user = user_repository.find_by_uuid(session['uuid'])
if request.method == 'GET':
# retrieve the uuid.
section_uuid = request.args.get('section')
uuid_ = request.args.get('uuid')
# retrieve the instruments
instruments = instrument_repository.list_by(active=1, order_by='name')
access_modifiers = access_modifier_repository.list_by(
active=1, order_by='modifier')
genres = genre_repository.list_by(active=1, order_by='genre')
sections = section_repository.list_by(active=1, order_by='id')
if uuid_:
# contains the uuid of the section
snap_repository = SnapRepository(connector)
snap = snap_repository.find_by_uuid(uuid_)
upload_ = {
'section': section_uuid,
'uuid': uuid_,
'user': user['uuid'],
'first_name': user['first_name'],
'last_name': user['last_name'],
'title': snap['title'],
'access': snap['access'],
'instrument': snap['instrument'],
'genre': snap['genre'],
'chord_schema': snap['chord_schema']
}
connector.close()
return render_template('upload/upload.html',
sections=sections,
upload=upload_,
instruments=instruments,
access_modifiers=access_modifiers,
genres=genres)
# contains the uuid of the section
section_uuid = request.args.get('section')
user = user_repository.find_by_uuid(session['uuid'])
section = section_repository.find_by_uuid(section_uuid)
role = role_repository.find_by(id=section['rle_id'], active=1)
# check messing with the posting in relation to the section
if session['role'] != role['role']:
return redirect(url_for('login.show'))
upload_ = {
'section': section_uuid,
'user': user['uuid'],
'first_name': user['first_name'],
'last_name': user['last_name'],
'access': "public"
}
connector.close()
return render_template('upload/upload.html',
sections=sections,
upload=upload_,
instruments=instruments,
access_modifiers=access_modifiers,
genres=genres)
if request.method == 'POST':
uuid_ = request.form['uuid']
user_uuid = request.form['user']
section_uuid = request.form['section']
title = request.form['title']
instrument = request.form['instrument']
access = request.form['access']
genre = request.form['genre']
chord_schema = request.form['chord_schema']
# image_as_background = request.form['image_as_background']
# print('image_as_background', image_as_background)
# store the uploaded files if given.
files = request.files
properties = current_app.properties
snap_repository = SnapRepository(connector)
section = section_repository.find_by_uuid(section_uuid)
if uuid_:
# persist the uploaded files if any.
storage.persist_files(properties, uuid_, files,
storage.AssetType.SINGLE)
snap_ = {
'uuid': uuid_,
'title': title,
'access': access,
'instrument': instrument,
'genre': genre,
'chord_schema': chord_schema
}
snap_repository.update(snap_)
connector.commit()
connector.close()
flash('Your sample is updated successfully.', 'info')
return redirect(
url_for('{}.show'.format(section['endpoint']),
section=section['uuid']))
user = user_repository.find_by_uuid(user_uuid)
# check messing with the posting in relation to the section
role = role_repository.find_by(id=section['rle_id'], active=1)
if session['role'] != role['role']:
return redirect(url_for('login.show'))
# generate a uuid, reflecting functional key of the activity
uuid_ = str(uuid4())
# persist the uploaded files if any.
storage.persist_files(properties, uuid_, files,
storage.AssetType.SINGLE)
snap_ = {
'uuid': uuid_,
'usr_id': user['id'],
'title': title,
'access': access,
'instrument': instrument,
'genre': genre,
'chord_schema': chord_schema
}
snap_repository.insert(snap_)
connector.commit()
connector.close()
flash('Your sample is posted successfully.', 'info')
return redirect(
url_for('{}.show'.format(section['endpoint']),
section=section['uuid']))
def load():
connector = current_app.connector
activity_repository = ActivityRepository(connector)
user_repository = UserRepository(connector)
role_repository = RoleRepository(connector)
section = component.section()
if not component.has_fragment(section, ComponentEnum.ACTIVITIES):
return []
activities = activity_repository.list_by(stn_id=section.get('id', -1),
active=1,
order_by='updated_at desc')
properties = current_app.properties
for activity in activities:
user = user_repository.find_by(id=activity['usr_id'], active=1)
role = role_repository.find_by(id=user['rle_id'], active=1)
content = activity['content']
if content:
content = content.replace('\n', '<br>')
activity['username'] = user.get('username')
activity['first_name'] = user.get('first_name')
activity['last_name'] = user.get('last_name')
activity['role'] = role.get('role')
activity['section'] = section['uuid']
activity['content'] = Markup(content)
activity['slide_count'] = 0
dt_created_at = datetime.strptime(activity['created_at'],
'%Y-%m-%d %H:%M:%S.%f')
activity['created_at_formatted'] = dt_created_at.strftime(
'%d %B at %H:%M')
# for now we only use .png, .jpg and .gif images
# slides_folder = os.path.join(current_app.config['UPLOAD_FOLDER'], activity['uuid'])
logging.debug(f"{activity=}")
slides_folder = os.path.join(properties['current.dir'], 'assets',
activity['uuid'])
slides = []
if os.path.isdir(slides_folder):
files = Folder(slides_folder).listdir(
filters='.png;.jpg;.gif;.jpeg')
activity['slide_count'] = len(files)
index_ = 0
for file in files:
slide = {
'url': '/assets/{}/{}'.format(activity['uuid'], file),
'index': index_
}
slides.append(slide)
index_ += 1
activity['slides'] = slides
# for now we only use .mp4 and .mov
# clips_folder = os.path.join(current_app.config['UPLOAD_FOLDER'], activity['uuid'])
clips_folder = os.path.join(properties['current.dir'], 'assets',
activity['uuid'])
clips = []
if os.path.isdir(clips_folder):
files = Folder(clips_folder).listdir(filters='.mp4;.MOV')
activity['clip_count'] = len(files)
index_ = 0
for file in files:
clip = {
'url': '/assets/{}/{}'.format(activity['uuid'], file),
'index': index_
}
clips.append(clip)
index_ += 1
activity['clips'] = clips
return activities
def show():
connector = current_app.connector
registration_repository = RegistrationRepository(connector)
role_repository = RoleRepository(connector)
role = session.get('role', 'user')
if role != 'admin':
return redirect(url_for('login.show'))
if request.method == 'GET':
uuid_ = request.args.get('uuid')
registration_ = registration_repository.find_by_uuid(uuid_)
registration_ = dictionaries.strip_none(registration_)
role = role_repository.find_by(id=registration_['rle_id'], active=1)
registration_['role'] = role['role']
roles = role_repository.list_by(active=1)
section_repository = SectionRepository(connector)
sections = section_repository.list_by(active=1, order_by='id')
connector.close()
return render_template('registration/registration.html',
sections=sections,
registration=registration_,
roles=roles)
uuid_ = request.form['uuid']
username = request.form['username']
first_name = request.form['first_name']
last_name = request.form['last_name']
nickname = request.form['nickname']
phone_number = request.form['phone_number']
role = request.form['role']
role = role_repository.find_by(role=role, active=1)
registration_ = {
'uuid': uuid_,
'username': username,
'first_name': first_name,
'last_name': last_name,
'nickname': nickname,
'phone_number': phone_number,
'rle_id': role['id']
}
registration_repository.update(registration_)
registration_ = registration_repository.find_by_uuid(uuid_)
user_repository = UserRepository(connector)
user = user_repository.find_by_rgn_id(registration_['id'])
if user:
user = {
'uuid': user['uuid'],
'username': username,
'first_name': first_name,
'last_name': last_name,
'nickname': nickname,
'phone_number': phone_number,
'rle_id': role['id']
}
user_repository.update(user)
connector.commit()
connector.close()
flash('The registration is updated successfully.', 'info')
return redirect(url_for('registrations.show'))
def show():
connector = current_app.connector
user_repository = UserRepository(connector)
section_repository = SectionRepository(connector)
role_repository = RoleRepository(connector)
user = user_repository.find_by_uuid(session['uuid'])
sections = section_repository.list_by(active=1, order_by='id')
if request.method == 'GET':
# retrieve the uuid.
section_uuid = request.args.get('section')
uuid_ = request.args.get('uuid')
if uuid_:
# contains the uuid of the section
activity_repository = ActivityRepository(connector)
activity = activity_repository.find_by(uuid=uuid_)
if user['id'] != activity['usr_id']:
flash('You are not allowed to change this posting.', 'danger')
posting_ = {
'section': section_uuid,
'uuid': uuid_,
}
connector.close()
return render_template('posting/posting.html',
sections=sections,
posting=posting_)
posting_ = {
'section': section_uuid,
'uuid': uuid_,
'user': user['uuid'],
'first_name': user['first_name'],
'last_name': user['last_name'],
'content': activity['content'],
'rendering': activity['rendering']
}
connector.close()
return render_template('posting/posting.html',
sections=sections,
posting=posting_)
# contains the uuid of the section
section_uuid = request.args.get('section')
user = user_repository.find_by_uuid(session['uuid'])
# section = section_repository.find_by_uuid(section_uuid)
# role = role_repository.find_by(id=section['rle_id'], active=1)
#
# # check messing with the posting in relation to the section
# if session['role'] != role['role']:
# return redirect(url_for('login.show'))
posting_ = {
'section': section_uuid,
'user': user['uuid'],
'first_name': user['first_name'],
'last_name': user['last_name']
}
connector.close()
return render_template('posting/posting.html',
sections=sections,
posting=posting_)
uuid_ = request.form['uuid']
user_uuid = request.form['user']
section_uuid = request.form['section']
content = request.form['content']
rendering = request.form.get('rendering')
# store the uploaded files if given.
files = request.files
properties = current_app.properties
activity_repository = ActivityRepository(connector)
section = section_repository.find_by_uuid(section_uuid)
if uuid_:
activity = activity_repository.find_by(uuid=uuid_)
if user['id'] != activity['usr_id']:
flash('You are not allowed to update this posting.', 'danger')
posting_ = {
'section': section_uuid,
'uuid': uuid_,
}
connector.close()
return render_template('posting/posting.html',
sections=sections,
posting=posting_)
# persist the uploaded files if any.
storage.persist_files(properties, uuid_, files,
storage.AssetType.MULTIPLE)
activity = {'uuid': uuid_, 'content': content, 'rendering': rendering}
activity_repository.update(activity)
connector.commit()
connector.close()
flash('Your posting is updated successfully.', 'info')
return redirect(
url_for('{}.show'.format(section['endpoint']),
section=section['uuid']))
user = user_repository.find_by_uuid(user_uuid)
# # check messing with the posting in relation to the section
# role = role_repository.find_by(id=section['rle_id'], active=1)
#
# if session['role'] != role['role']:
# return redirect(url_for('login.show'))
# generate a uuid, reflecting functional key of the activity
uuid_ = str(uuid4())
# persist the uploaded files if any.
storage.persist_files(properties, uuid_, files, storage.AssetType.MULTIPLE)
activity = {
'uuid': uuid_,
'usr_id': user['id'],
'stn_id': section['id'],
'content': content,
'rendering': rendering
}
activity_repository.insert(activity)
connector.commit()
connector.close()
flash('Your posting is created successfully.', 'info')
return redirect(
url_for('{}.show'.format(section['endpoint']),
section=section['uuid']))
