def edit_view(self):
"""
Edit model view
"""
return_url = get_redirect_target() or url_for(".index_view")
if not self.can_edit:
return redirect(return_url)
id = get_mdict_item_or_list(request.args, "id")
if id is None:
return redirect(return_url)
model = self.get_one(id)
if model is None:
return redirect(return_url)
form = self.edit_form(obj=model)
if validate_form_on_submit(form):
if self.update_model(form, model):
if "_continue_editing" in request.form:
flash(gettext("Model was successfully saved."))
return redirect(request.url)
else:
return redirect(return_url)
if request.method == "GET":
self.on_form_prefill(form, id)
form_opts = FormOpts(widget_args=self.form_widget_args, form_rules=self._form_edit_rules)
return self.render(self.edit_template, model=model, form=form, form_opts=form_opts, return_url=return_url)
def login_view(self):
# handle user login
if login.current_user.is_authenticated():
if self.get_req_user_type() != login.current_user.user_type:
return redirect('/%s/' % self.get_req_console_type(login.current_user.user_type))
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = User.query.filter_by(email=form.email.data, password=form.password.data).first()
if user is None:
flash('Invalid Username or Password')
elif user.password != form.password.data:
flash('Invalid Username or Password')
else:
login.login_user(user)
if login.current_user.is_authenticated():
return redirect(url_for('.index'))
link = '<p>Don\'t have an account? <a href="' + url_for('.register_view') + '">Click here to register.</a></p>'
self._template_args['form'] = form
self._template_args['link'] = link
self._template_args['admin_name'] = self.admin.name
print self.admin.name
return self.render('shared/login.html')
def edit_view(self):
"""
Edit model view
"""
return_url = request.args.get('url') or url_for('.index_view')
if not self.can_edit:
return redirect(return_url)
id = request.args.get('id')
if id is None:
return redirect(return_url)
model = self.get_one(id)
if model is None:
return redirect(return_url)
form = self.edit_form(obj=model)
if validate_form_on_submit(form):
if self.update_model(form, model):
return redirect(return_url)
return self.render(self.edit_template,
model=model,
form=form,
form_widget_args=self.form_widget_args,
return_url=return_url)
def upload(self, path=None):
"""
Upload view method
:param path:
Optional directory path. If not provided, will use the base directory
"""
# Get path and verify if it is valid
base_path, directory, path = self._normalize_path(path)
if not self.can_upload:
flash(gettext('File uploading is disabled.'), 'error')
return redirect(self._get_dir_url('.index', path))
if not self.is_accessible_path(path):
flash(gettext(gettext('Permission denied.')))
return redirect(self._get_dir_url('.index'))
form = UploadForm(self)
if helpers.validate_form_on_submit(form):
filename = op.join(directory,
secure_filename(form.upload.data.filename))
if op.exists(filename):
flash(gettext('File "%(name)s" already exists.', name=filename),
'error')
else:
try:
self.save_file(filename, form.upload.data)
self.on_file_upload(directory, path, filename)
return redirect(self._get_dir_url('.index', path))
except Exception as ex:
flash(gettext('Failed to save file: %(error)s', error=ex))
return self.render(self.upload_template, form=form)
def mkdir(self, path=None):
"""
Directory creation view method
:param path:
Optional directory path. If not provided, will use the base directory
"""
# Get path and verify if it is valid
base_path, directory, path = self._normalize_path(path)
dir_url = self._get_dir_url('.index', path)
if not self.can_mkdir:
flash(gettext('Directory creation is disabled.'), 'error')
return redirect(dir_url)
if not self.is_accessible_path(path):
flash(gettext(gettext('Permission denied.')))
return redirect(self._get_dir_url('.index'))
form = NameForm(helpers.get_form_data())
if helpers.validate_form_on_submit(form):
try:
os.mkdir(op.join(directory, form.name.data))
self.on_mkdir(directory, form.name.data)
return redirect(dir_url)
except Exception as ex:
flash(gettext('Failed to create directory: %(error)s', ex), 'error')
return self.render(self.mkdir_template,
form=form,
dir_url=dir_url)
def resetpassword_view(self):
form = ResetPasswordForm(request.form)
reset_hash = request.args.get('reset_hash')
if request.method == 'GET':
if reset_hash is not None:
self._template_args['reset_hash'] = reset_hash
user = user_service.get_by_reset_hash(reset_hash)
if user is not None:
self._template_args['form'] = form
self._template_args['admin_name'] = self.admin.name
return self.render('shared/reset_password.html')
else:
return redirect(url_for('.requestresetpassword_view') + '?m=1')
else:
if helpers.validate_form_on_submit(form):
user = user_service.get_by_reset_hash(str(form.reset_hash.data))
if user is None:
flash('Something went wrong!')
elif form.confirm.data != form.password.data:
flash('Passwords don\'t match')
else:
user.password = form.confirm.data
db.session.commit()
send_reset_password_complete(user)
return redirect(url_for('.login_view') + '?m=0')
self._template_args['reset_hash'] = reset_hash
self._template_args['form'] = form
self._template_args['admin_name'] = self.admin.name
return self.render('shared/reset_password.html')
def create_view(self):
"""
Create model view
"""
return_url = get_redirect_target() or url_for('.index_view')
if not self.can_create:
return redirect(return_url)
form = self.create_form()
if validate_form_on_submit(form):
if self.create_model(form):
if '_add_another' in request.form:
flash(gettext('Model was successfully created.'))
return redirect(url_for('.create_view', url=return_url))
else:
return redirect(return_url)
form_opts = FormOpts(widget_args=self.form_widget_args,
form_rules=self._form_create_rules)
return self.render(self.create_template,
form=form,
form_opts=form_opts,
return_url=return_url)
def edit_view(self):
"""
Edit model view
"""
return_url = request.args.get('url') or url_for('.index_view')
if not self.can_edit:
return redirect(return_url)
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return redirect(return_url)
model = self.get_one(id)
if model is None:
return redirect(return_url)
form = self.edit_form(obj=model)
if validate_form_on_submit(form):
if self.update_model(form, model):
if '_continue_editing' in request.form:
flash(gettext('Model was successfully saved.'))
return redirect(request.full_path)
else:
return redirect(return_url)
return self.render(self.edit_template,
model=model,
form=form,
form_opts=get_form_opts(self),
form_rules=self._form_edit_rules,
return_url=return_url)
def register(self):
form = RegisterForm(request.form)
# hacks to register a superuser
if request.method == 'GET':
form.is_superuser.data = request.args.get('is_superuser', '')
if helpers.validate_form_on_submit(form):
user = User()
form.populate_obj(user)
user.set_password(form.password.data)
user.is_staff = True
user.is_superuser = bool(form.is_superuser.data)
user.date_joined = NOW()
db.session.add(user)
db.session.commit()
login.login_user(user)
return redirect(url_for('.index'))
link = u'<p>å·²ē»ęäŗåøå·ļ¼ <a href="%s">马äøē»å½</a></p>' % url_for('.login')
self._template_args['form'] = form
self._template_args['link'] = link
return super(AdminIndexView, self).index()
def upload(self, path=None):
"""
Upload view method
:param path:
Optional directory path. If not provided, will use the base directory
"""
# Get path and verify if it is valid
base_path, directory, path = self._normalize_path(path)
if not self.can_upload:
flash(gettext('File uploading is disabled.'), 'error')
return redirect(self._get_dir_url('.index', path))
if not self.is_accessible_path(path):
flash(gettext('Permission denied.'))
return redirect(self._get_dir_url('.index'))
form = self.upload_form(self)
if helpers.validate_form_on_submit(form):
try:
self._save_form_files(directory, path, form)
return redirect(self._get_dir_url('.index', path))
except Exception as ex:
flash(gettext('Failed to save file: %(error)s', error=ex))
return self.render(self.upload_template, form=form)
def validate_form(self, form):
"""
Validate the form on submit.
:param form:
Form to validate
"""
return validate_form_on_submit(form)
def login_view():
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = form.get_user()
login.login_user(user)
return redirect(url_for('index'))
return render_template('form.html', form=form)
def login_view(self):
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = form.get_user()
login.login_user(user)
if login.current_user.is_authenticated():
return redirect(url_for('.index'))
self._template_args['form'] = form
return super(MyAdminIndexView, self).index()
def edit(self):
"""
Edit view method
"""
path = request.args.getlist('path')
next_url = None
if not path:
return redirect(url_for('.index'))
if len(path) > 1:
next_url = url_for('.edit', path=path[1:])
path = path[0]
base_path, full_path, path = self._normalize_path(path)
dir_url = self._get_dir_url('.index', os.path.dirname(path))
next_url = next_url or dir_url
form = EditForm(helpers.get_form_data())
error = False
if helpers.validate_form_on_submit(form):
form.process(request.form, content='')
if form.validate():
try:
with open(full_path, 'w') as f:
f.write(request.form['content'])
except IOError:
flash(gettext("Error saving changes to %(name)s.", name=path), 'error')
error = True
else:
self.on_edit_file(full_path, path)
flash(gettext("Changes to %(name)s saved successfully.", name=path))
return redirect(next_url)
else:
try:
with open(full_path, 'r') as f:
content = f.read()
except IOError:
flash(gettext("Error reading %(name)s.", name=path), 'error')
error = True
except:
flash(gettext("Unexpected error while reading from %(name)s", name=path), 'error')
error = True
else:
try:
content.decode('utf8')
except UnicodeDecodeError:
flash(gettext("Cannot edit %(name)s.", name=path), 'error')
error = True
except:
flash(gettext("Unexpected error while reading from %(name)s", name=path), 'error')
error = True
else:
form.content.data = content
return self.render(self.edit_template, dir_url=dir_url, path=path,
form=form, error=error)
def register_view():
form = RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
user = User()
form.populate_obj(user)
db_session.add(user)
db_session.commit()
login.login_user(user)
return redirect(url_for('index'))
return render_template('form.html', form=form)
def login():
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = User.query.filter_by(username=form.username.data, password=form.password.data).first()
if user is not None:
login_user(user)
session['logged_in'] = True
flash('You are now logged in')
return redirect(url_for('main'))
return render_template('login.html', form=form)
def login():
form = LoginForm()
if form.validate_on_submit():
if helpers.validate_form_on_submit(form):
user = form.get_user()
login_user(user)
return redirect(url_for('index'))
else:
return render_template('users/login.html', form=form, error=True)
return render_template('users/login.html', form=form)
def login_view():
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = form.get_user()
login.login_user(user,remember=form.remember_me)
return redirect(request.args.get("next") or url_for("index"))
return render_template('login.html',
title="Login",user=login.current_user,
form=form)
def login_view():
login_form = LoginForm(request.form)
if helpers.validate_form_on_submit(login_form):
user = login_form.get_user()
login_user_with_remember(user)
if user.is_normal_superuser() or user.is_normal_manageruser():
return redirect('/admin')
return redirect('/admin')
return render_template('admin_page/auth.html', form=login_form)
def login_view():
login_form = LoginForm(request.form)
if helpers.validate_form_on_submit(login_form):
user = login_form.get_user()
login_user_with_remember(user)
if user.admin:
return redirect('/admin') # todo-lyw čæéäøčÆ„ä½æēØē»åƹē¼ē
return redirect('/')
return render_template('admin_tour/auth.html', form=login_form)
def upload(self, path=None):
"""
Upload view method
:param path:
Optional directory path. If not provided, will use the base directory
"""
# Get path and verify if it is valid
base_path, directory, path = self._normalize_path(path)
if not self.can_upload:
flash(gettext('File uploading is disabled.'), 'error')
return redirect(self._get_dir_url('.index', path))
if not self.is_accessible_path(path):
flash(gettext(gettext('Permission denied.')))
return redirect(self._get_dir_url('.index'))
form = UploadForm(self)
#print form, helpers.validate_form_on_submit(form), form.data
if helpers.validate_form_on_submit(form):
filename = op.join(directory,
secure_filename(form.upload.data.filename))
if op.exists(filename):
flash(gettext('File "%(name)s" already exists.', name=filename),
'error')
else:
try:
self.save_file(filename, form.upload.data)
self.on_file_upload(directory, path, filename)
flash('%s was correctly uploaded' % form.upload.data.filename)
return redirect(self._get_dir_url('.index', path))
except Exception as ex:
flash(gettext('Failed to save file: %(error)s', error=ex))
elif request.form and 'async' in request.form:
total_uploaded = 0
for tmp_filename in json.loads(request.form['async']):
filename = op.join(directory,
secure_filename(form.upload.data.filename))
if op.exists(filename):
total_uploaded = total_uploaded + 1
if total_uploaded == 0:
flash('Nothing was uploaded', 'error')
elif total_uploaded == 1:
flash('%s was correctly uploaded' % tmp_filename)
return redirect(self._get_dir_url('.index', path))
else:
flash('%d files were correctly uploaded' % total_uploaded)
return redirect(self._get_dir_url('.index', path))
return self.render(self.upload_template, form=form, dir_path=path)
def register_view(self):
form = RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
user = models.User()
form.populate_obj(user)
user.save()
login.login_user(user)
return redirect(url_for('.index'))
link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def login_view(self):
# handle user login
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = form.get_user()
session.permanent = False
session['admin'] = 'root'
if 'admin' in session and session['admin'] == 'root':
return redirect(url_for('.index'))
self._template_args['form'] = form
return super(AuthAdminIndexView, self).index()
def login(self):
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = form.get_user()
login_user(user)
if current_user.is_authenticated():
return redirect(url_for('.index'))
# link = '<p>Don\'t have an account? <a href="' + url_for('.register_view') + '">Click here to register.</a></p>'
self._template_args['form'] = form
# self._template_args['link'] = link
return super(AdminIndexView, self).index()
def register_view(self):
register_form = AdminRegistrationForm(request.form)
if helpers.validate_form_on_submit(register_form):
user = Administrator(None)
register_form.populate_obj(user)
user.password = hash_password(register_form.password.data)
db.session.add(user)
db.session.commit()
login_user(user)
redirect(url_for('.index'))
self._template_args['form'] = register_form
return super(BooksAdminIndexView, self).index()
def index(self):
form = CommandForm(request.form)
if helpers.validate_form_on_submit(form):
if form.args.data != "":
ret = client.cmd_async(tgt=str(form.tgt.data).strip(), fun=str(form.fun.data).strip(),
arg=str(form.args.data).strip().split(';'),
expr_form='compound', ret='http_api')
else:
ret = client.cmd_async(tgt=str(form.tgt.data).strip(), fun=str(form.fun.data).strip(),
expr_form='compound', ret='http_api')
flash(str(ret), 'success')
jobs = Returner.query.order_by(Returner.id.desc()).limit(10).all()
return self.render('saltstack/command.html', form=form, jobs=jobs)
def requestresetpassword_view(self):
form = RequestResetPasswordForm(request.form)
if helpers.validate_form_on_submit(form):
user = form.get_user()
if user is None:
flash('User not found')
else:
send_password_reset(user)
return redirect(url_for('.passwordemailsent_view'))
self._template_args['form'] = form
self._template_args['admin_name'] = self.admin.name
return self.render('shared/request_reset_password.html')
def login_view(self):
# handle user login
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
log = open(config.LOG_PATH+config.DIVIDER+'login_log.txt', 'a')
log.write("user {} logged in at {}\n".format(form.get_user().email, str(datetime.now())))
log.close()
user = form.get_user()
login.login_user(user)
if login.current_user.is_authenticated():
return redirect(url_for('.index'))
self._template_args['form'] = form
return super(CustomAdminIndexView, self).index()
def index(self):
if not current_user.is_authenticated():
return redirect('/admin')
with open(ABOUT_PATH, 'r+') as f:
about = f.read()
form = AboutForm()
if helpers.validate_form_on_submit(form):
new = form.about.data
with open(ABOUT_PATH, 'w+') as f:
f.write(new)
flash('Success commit!')
else:
form.about.data = about
return self.render('admin/about.html', form=form)
def login_view(self):
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
user = get_user(form.login.data)
login.login_user(user)
if login.current_user.is_authenticated():
self.__setFlag(True)
return redirect(url_for('.index'))
self.__setFlag(False)
self._template_args['form'] = form
return super(CustomAdminIndexView, self).index()
def register_view(self):
form = RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
user = User()
# hash password, before populating User object
form.password.data = hash(form.password.data)
form.populate_obj(user)
# activate the admin user
if user.email == app.config['ADMIN_USER']:
user.is_active = True
db.session.add(user)
db.session.commit()
flash('Please wait for your new account to be activated.', 'info')
return redirect(url_for('.login_view'))
link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
return self.render('admin/home.html', form=form, link=link, register=True)
def login_view(self):
# handle user login
form = LoginForm(request.form)
if helpers.validate_form_on_submit(form):
form.validate_login()
user = form.get_user()
if user is not None:
if user.has_role('admin'):
if not form.password.errors and \
not form.email.errors:
login.login_user(user)
else:
form.password.errors.append(
"No tens permisos d'administrador")
else:
form.password.errors.append('Credencials invĆ lides')
if login.current_user.is_authenticated:
return redirect(url_for('.index'))
self._template_args['form'] = form
return super(MyAdminIndexView, self).index()
def register_view(self):
form = RegisterForm(request.form)
user = None
if helpers.validate_form_on_submit(form):
with db_scoped_session() as s:
try:
new_user = User()
new_user.email = form.email.data
new_user.password = generate_password_hash(form.password.data)
new_user.fullname = form.full_name.data
new_user.age = form.age.data
new_user.author_identifier = form.author_identifier.data
new_user.status = form.status.data
new_user.private_key = form.private_key.data
new_user.secondary_email = form.secondary_email.data
new_user.summary = form.summary.data
new_user.twitter = form.twitter.data
# Only AppDev users register from this page
new_user.role = UserRole.AppDev
s.add(new_user)
user_session_dict = {
'fullname': new_user.fullname,
'email': new_user.email,
'role': new_user.role,
'author_identifier': new_user.author_identifier
}
session['user'] = user_session_dict
user = form.get_user()
except Exception as e:
s.rollback()
raise e
# Commit changes
s.commit()
if user and (user.role == UserRole.SiteAdmin or user.role == UserRole.AppDev):
return redirect(url_for('.index'))
self._template_args['form'] = form
return super(iModsAdminIndexView, self).index()
def register_view(self):
form = RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
if form.email.data == app.config['ADMIN_USER']:
user = User()
# hash password, before populating User object
form.password.data = hash(form.password.data)
form.populate_obj(user)
db.session.add(user)
db.session.commit()
login.login_user(user)
if login.current_user.is_authenticated():
return redirect(url_for('.index'))
else:
flash('You cannot be registered.', 'info')
return redirect(url_for('.login_view'))
link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
return self.render('admin/home.html', form=form, link=link, register=True)
def edit_view(self):
"""
Edit model view
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_edit:
return redirect(return_url)
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return redirect(return_url)
model = self.get_one(id)
if model is None:
return redirect(return_url)
form = self.edit_form(obj=model)
if validate_form_on_submit(form):
if self.update_model(form, model):
if '_continue_editing' in request.form:
flash(gettext('Model was successfully saved.'))
return redirect(request.url)
else:
return redirect(return_url)
if request.method == 'GET':
self.on_form_prefill(form, id)
form_opts = FormOpts(widget_args=self.form_widget_args,
form_rules=self._form_edit_rules)
return self.render(self.edit_template,
model=model,
form=form,
form_opts=form_opts,
return_url=return_url)
def register():
form = eforms.RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
user = models.User()
if form.validate_login(user):
form.populate_obj(user)
user.password = generate_password_hash(form.password.data)
db.session.add(user)
db.session.commit()
login.login_user(user)
flash('logged in!')
return redirect(url_for('home'))
else:
flash('user exists.')
return redirect(url_for('signup'))
flash(form.name.data)
return render_template('debug.html', msg='error')
def create_view(self):
"""
Create model view
"""
return_url = request.args.get('url') or url_for('.index_view')
if not self.can_create:
return redirect(return_url)
form = self.create_form()
if validate_form_on_submit(form):
if self.create_model(form):
if '_add_another' in request.form:
flash(gettext('Model was successfully created.'))
return redirect(url_for('.create_view', url=return_url))
else:
return redirect(return_url)
return self.render(self.create_template,
form=form,
form_widget_args=self.form_widget_args,
return_url=return_url)
def register_view(self):
if login.current_user.is_authenticated(
) and login.current_user.isAdmin():
form = RegistrationForm(request.form)
if helpers.validate_form_on_submit(form):
user = User()
form.populate_obj(user)
# we hash the users password to avoid saving it as plaintext in the db,
# remove to use plain text:
user.password = generate_password_hash(form.password.data)
db.session.add(user)
db.session.commit()
login.login_user(user)
return redirect(url_for('.index'))
link = '<p>Already have an account? <a href="' + url_for(
'.login_view') + '">Click here to log in.</a></p>'
self._template_args['form'] = form
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
return redirect(url_for('.index'))
def login_view(self):
""" handle user login """
# User login is performed through the form "LoginForm"
form = LoginForm(request.form)
# if the form is validated, the login is done with the validated user
if helpers.validate_form_on_submit(form):
user = form.get_user()
if user != None:
login.login_user(user)
# if the user login is correct, is redirected to the home page
if login.current_user.is_authenticated():
return redirect(url_for('index'))
link = '<p>Si no dispone de cuenta de usuario <a href="' + url_for(
'.register_view') + '">Pulse aquí para registrarse.</a></p>'
link2 = u'<p>Si no recuerda su contraseƱa <a href="' + url_for(
'rec_pass') + '">pulse aquí para reactivarla.</a></p>'
self._template_args['form'] = form
self._template_args['legend'] = u"Entrada a la aplicaciĆ³n"
self._template_args['link'] = link
self._template_args['link2'] = link2
return super(MyAdminIndexView, self).index()
def upload(self, path=None):
"""
Upload view method
:param path:
Optional directory path. If not provided, will use the base directory
"""
# Get path and verify if it is valid
base_path, directory, path = self._normalize_path(path)
if not self.can_upload:
flash(gettext('File uploading is disabled.'), 'error')
return redirect(self._get_dir_url('.index', path))
if not self.is_accessible_path(path):
flash(gettext(gettext('Permission denied.')))
return redirect(self._get_dir_url('.index'))
form = UploadForm(self)
if helpers.validate_form_on_submit(form):
filename = op.join(directory,
secure_filename(form.upload.data.filename))
if op.exists(filename):
flash(
gettext('File "%(name)s" already exists.', name=filename),
'error')
else:
try:
self.save_file(filename, form.upload.data)
self.on_file_upload(directory, path, filename)
return redirect(self._get_dir_url('.index', path))
except Exception as ex:
flash(gettext('Failed to save file: %(error)s', error=ex))
return self.render(self.upload_template, form=form)
def edit(self):
"""
Edit view method
"""
next_url = None
path = request.args.getlist('path')
if not path:
return redirect(self.get_url('.index'))
if len(path) > 1:
next_url = self.get_url('.edit', path=path[1:])
path = path[0]
base_path, full_path, path = self._normalize_path(path)
if not self.is_accessible_path(path) or not self.is_file_editable(
path):
flash(gettext('Permission denied.'))
return redirect(self._get_dir_url('.index'))
dir_url = self._get_dir_url('.index', os.path.dirname(path))
next_url = next_url or dir_url
form = EditForm(helpers.get_form_data())
error = False
if helpers.validate_form_on_submit(form):
form.process(request.form, content='')
if form.validate():
try:
with open(full_path, 'w') as f:
f.write(request.form['content'])
except IOError:
flash(
gettext("Error saving changes to %(name)s.",
name=path), 'error')
error = True
else:
self.on_edit_file(full_path, path)
flash(
gettext("Changes to %(name)s saved successfully.",
name=path))
return redirect(next_url)
else:
try:
with open(full_path, 'r') as f:
content = f.read()
except IOError:
flash(gettext("Error reading %(name)s.", name=path), 'error')
error = True
except:
flash(
gettext("Unexpected error while reading from %(name)s",
name=path), 'error')
error = True
else:
try:
content = content.decode('utf8')
except UnicodeDecodeError:
flash(gettext("Cannot edit %(name)s.", name=path), 'error')
error = True
except:
flash(
gettext("Unexpected error while reading from %(name)s",
name=path), 'error')
error = True
else:
form.content.data = content
return self.render(self.edit_template,
dir_url=dir_url,
path=path,
form=form,
error=error)
def validate_form(self, form): return validate_form_on_submit(form)
def index(self):
form = PackageAssetsUploadForm(request.form)
# Populate choices for select field
with db_scoped_session() as s:
items = s.query(Item).all()
form.item_id.choices = [(item.iid, item.display_name)
for item in items]
if helpers.validate_form_on_submit(form):
# from boto.s3.key import Key
# Get file data from request.files
app_icon = request.files["app_icon"]
screenshot1 = request.files["screenshot1"]
screenshot2 = request.files["screenshot2"]
screenshot3 = request.files["screenshot3"]
screenshot4 = request.files["screenshot4"]
# Get package file
package_file = request.files["package_file"]
# Get banner image file
banner_img_file = request.files["banner_image"]
# Get pkg_assets_path
item = s.query(Item).get(form.item_id.data)
_, debTmpFile = mkstemp()
with open(debTmpFile, "wb") as local_deb_file:
local_deb_file.write(package_file.read())
sha1 = hashlib.sha1()
sha1.update(open(debTmpFile, 'rb').read())
deb_sha1_digest = sha1.hexdigest()
try:
# Verify and update item information based on package file
deb_obj = debfile.DebPackage(debTmpFile)
item.control = deb_obj.control_content("control")
tags = TagSection(item.control)
item.pkg_dependencies = tags.get("Depends", "")
item.pkg_predepends = tags.get("Pre-Depends", "")
item.pkg_conflicts = tags.get("Conflicts", "")
item.pkg_version = tags.get("Version", "")
item.pkg_signature = deb_sha1_digest
item.description = tags.get("Description", "")
# Create local package path
pkg_fullname = item.pkg_name + '-' + str(item.pkg_version)
base_path = path.join(
"packages",
item.pkg_name,
pkg_fullname,
'assets')
item.pkg_assets_path = base_path
pkg_name = tags.get("Package", None)
if (pkg_name is not None) and pkg_name != item.pkg_name:
# Check if the name already exists
t_item = s.query(Item).filter_by(pkg_name=pkg_name).first()
if t_item is None or t_item.iid == item.iid:
item.pkg_name = pkg_name
else:
flash("Package name '%s' is used by another "
"item(%d)." % (pkg_name, t_item.iid))
s.rollback()
os.unlink(debTmpFile)
return redirect(url_for(".index"))
# Build package path
pkg_path = path.join(
"packages",
item.pkg_name)
assets_bucket = app.config.get("S3_ASSETS_BUCKET")
pkg_bucket = app.config.get("S3_PKG_BUCKET")
pkg_s3_key_path = generate_bucket_key(
pkg_path,
pkg_fullname,
package_file.filename)
item.pkg_path = pkg_s3_key_path
pkg_local_cache_path = path.join(
app.config["DEB_UPLOAD_PATH"],
pkg_s3_key_path)
# Local package path
pkg_local_cache_dir = path.dirname(pkg_local_cache_path)
if not path.exists(pkg_local_cache_dir):
print("Creating path %s" % pkg_local_cache_dir)
os.makedirs(pkg_local_cache_dir)
# Move tmp deb file to the cache folder
shutil.move(debTmpFile, pkg_local_cache_path)
pkg_overrides = [(item.pkg_name, "itemid", item.iid),
(item.pkg_name, "itemname", item.display_name),
(item.pkg_name, "filename", "null")]
# Check if it's a tweak
tweak_file = detect_tweak(deb_obj.filelist)
if tweak_file is not None:
tweak_file = 'file:///' + tweak_file
pkg_overrides.append((item.pkg_name, "Respring", "YES",))
pkg_overrides.append((item.pkg_name, "TweakLib", tweak_file,))
index_s3_key_path = "Packages.gz"
# Upload deb file
upload_to_s3.delay(pkg_bucket,
pkg_s3_key_path,
pkg_local_cache_path)
pkg_index_file = path.join(app.config["DEB_UPLOAD_PATH"],
app.config["PKG_INDEX_FILE_NAME"]
)
# Update and upload package index
dpkg_update_index.delay(app.config["DEB_UPLOAD_PATH"],
pkg_bucket,
index_s3_key_path,
pkg_index_file,
pkg_overrides)
# Upload icon
icon_base_path = path.join(base_path, "icons")
icon_s3_path = generate_bucket_key(icon_base_path,
"app_icon",
app_icon.filename)
_, icon_tmpfile = mkstemp()
with open(icon_tmpfile, "wb") as tmp:
tmp.write(app_icon.read())
upload_to_s3.delay(assets_bucket, icon_s3_path, icon_tmpfile, True)
# Upload screenshot 1
ss_base_path = path.join(base_path, "screenshots")
sshot_s3_path = generate_bucket_key(ss_base_path,
"screenshot1",
screenshot1.filename)
_, sshot_tmpfile = mkstemp()
with open(sshot_tmpfile, "wb") as tmp:
tmp.write(screenshot1.read())
upload_to_s3.delay(assets_bucket, sshot_s3_path, sshot_tmpfile, True)
# Upload screenshot 2
ss_base_path = path.join(base_path, "screenshots")
sshot_s3_path = generate_bucket_key(ss_base_path,
"screenshot2",
screenshot2.filename)
_, sshot_tmpfile = mkstemp()
with open(sshot_tmpfile, "wb") as tmp:
tmp.write(screenshot2.read())
upload_to_s3.delay(assets_bucket, sshot_s3_path, sshot_tmpfile, True)
# Upload screenshot 3
ss_base_path = path.join(base_path, "screenshots")
sshot_s3_path = generate_bucket_key(ss_base_path,
"screenshot3",
screenshot3.filename)
_, sshot_tmpfile = mkstemp()
with open(sshot_tmpfile, "wb") as tmp:
tmp.write(screenshot3.read())
upload_to_s3.delay(assets_bucket, sshot_s3_path, sshot_tmpfile, True)
# Upload screenshot 4
ss_base_path = path.join(base_path, "screenshots")
sshot_s3_path = generate_bucket_key(ss_base_path,
"screenshot4",
screenshot4.filename)
_, sshot_tmpfile = mkstemp()
with open(sshot_tmpfile, "wb") as tmp:
tmp.write(screenshot4.read())
upload_to_s3.delay(assets_bucket, sshot_s3_path, sshot_tmpfile, True)
# Upload youtube video id
youtube_id_path = path.join(base_path, "videos")
youtube_s3_filename = "youtube-%s" % form.youtube_video_id.data
youtube_id_s3_path = path.join(youtube_id_path,
youtube_s3_filename)
_, youtube_id_tmpfile = mkstemp()
with open(youtube_id_tmpfile, "wb") as tmp:
tmp.write(form.youtube_video_id.data)
upload_to_s3.delay(assets_bucket, youtube_id_s3_path, youtube_id_tmpfile, True)
# Upload banner image
banner_img_path = path.join(base_path, "banners")
banner_img_s3_path = generate_bucket_key(banner_img_path,
"banner_image",
banner_img_file.filename)
_, banner_img_tmpfile = mkstemp()
with open(banner_img_tmpfile, "wb") as tmp:
tmp.write(banner_img_file.read())
# Add banner item to the database
with db_scoped_session() as ses:
banner = ses.query(Banner).filter_by(item_id = item.iid).first()
if banner is None:
banner = Banner(item_id=item.iid)
ses.add(banner)
ses.commit()
upload_to_s3.delay(assets_bucket, banner_img_s3_path, banner_img_tmpfile, True)
except Exception as e:
s.rollback()
raise e
# Commit changes
s.commit()
flash("Assets uploaded successfully")
return redirect(url_for('.index'))
context = {'form': form}
return self.render(self.template_name, **context)
