def edit_view(self):
return_url = get_redirect_target() or self.get_url('.index_view')
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return redirect(return_url)
top_project = self.get_one(id)
form = EditTopProjectForm(description=top_project.description,
name=top_project.name)
if request.method == 'POST' and form.validate_on_submit():
top_project.name = form.name.data
top_project.description = form.description.data
self.session.commit()
if form.image.data:
filename = secure_filename(form.image.data.filename)
file_type = filename.rsplit('.', 1)[1]
if file_type in ['png', 'jpg', 'jpeg']:
form.image.data.save(
os.path.join(current_app.config['UPLOAD_FOLDER'],
'top_projects',
'%s.png' % str(top_project.id)))
else:
flash('this file is not supported')
return self.render('admin/edit_top_project.html',
form=form)
return redirect(return_url)
return self.render('admin/edit_top_project.html', form=form)
def update_view(self):
url = get_redirect_target() or self.get_url(".index_view")
if request.method != "POST":
return redirect(url)
change_form = OfferChangeForm(request.form)
if change_form.validate():
offer_ids: List[str] = change_form.ids.data.split(",")
criteria: List[OfferCriterion] = change_form.data["tags"]
remove_other_tags = change_form.data["remove_other_tags"]
if remove_other_tags:
OfferCriterion.query.filter(
OfferCriterion.offerId.in_(offer_ids)).delete(
synchronize_session=False)
offer_criteria: List[OfferCriterion] = []
for criterion in criteria:
offer_criteria.extend(
OfferCriterion(offerId=offer_id, criterionId=criterion.id)
for offer_id in offer_ids if OfferCriterion.query.filter(
OfferCriterion.offerId == offer_id, OfferCriterion.
criterionId == criterion.id).first() is None)
db.session.bulk_save_objects(offer_criteria)
db.session.commit()
# synchronize with external apis that generate playlists based on tags
search.async_index_offer_ids(offer_ids)
return redirect(url)
# Form didn't validate
flash("Le formulaire est invalide: %s" % (change_form.errors), "error")
return redirect(url, code=307)
def details_view(self):
sub = request.args.get('sub', self.default_subordinate_view)
self._template_args.update({
'sub': sub,
'time_formatter': datetime.time,
})
self._edit_form_class = self._delegate_to_sub('form')
self.override_fields(self._edit_form_class)
return_url = get_redirect_target() or self.get_url('.index_view')
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:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
form = self.edit_form(obj=model)
form_opts = FormOpts(widget_args=self.form_widget_args,
form_rules=self._form_edit_rules)
return self.render(self.details_modal_template,
model=model,
form=form,
form_opts=form_opts,
return_url=return_url)
def update_util(self):
return_url = get_redirect_target() or self.get_url('.index_view')
# 正常应该跳转到对应飞机的详情页
id = request.args.get('id', '')
if request.form.get('name') == 'hours':
times = None
hours = request.form.get('value', None)
if hours is not None:
hours = float(hours)
elif request.form.get('name') == 'times':
hours = None
times = request.form.get('value', None)
if times is not None:
times = int(float(times))
if id:
return_url = self.get_url('.aircraft_details_view',
id=id,
sub='basic')
try:
self._api_proxy.create(
{
'id': id,
'hours': hours,
'times': times,
}, '/v1/utilization/')
except Exception as ex:
# TODO: 客户端应该根据返回的JSON数据确定是否保存成功
return jsonify(status='400', message=unicode(ex))
# TODO: 根据前端所需要的JSON内容进行返回
return jsonify(status='200', msg='ok', times=times, hours=hours)
def delete_view(self):
"""
Delete model view. Only POST method is allowed.
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_delete:
return redirect(return_url)
form = self.delete_form()
if self.validate_form(form):
# id is InputRequired()
id = form.id.data
model = self.get_one(id)
if model is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
# message is flashed from within delete_model if it fails
if self.delete_model(model):
flash(gettext('Record was successfully deleted.'), 'success')
return redirect(
self.get_save_return_url(model, is_created=False))
else:
flash_errors(form, message='Failed to delete record. %(error)s')
return super(MongoCustomView, self).delete_view()
def bind_mxp(self):
mxp_id = request.args.get('id', '')
plane_id = request.args.get('plane', '')
return_url = request.args.get('return_url') or get_redirect_target(
) or self.get_url('.index_view')
# 默认为解除绑定
is_bind = request.args.get('bind', '')
dest_url = '/v1/mxp-binding/unbind'
if is_bind:
dest_url = '/v1/mxp-binding/bind'
if not mxp_id or not plane_id:
return redirect(return_url)
resp = self._api_proxy.create(
{
'force': True,
'mxpId': mxp_id,
'planeId': plane_id,
}, dest_url)
if resp.status_code != 200:
return abort(503)
cache.delete_memoized(self.get_bindable_status)
return redirect(return_url)
def delete_sprints_and_issues(self):
return_url = get_redirect_target() or self.get_url(".index_view")
model_id = get_mdict_item_or_list(request.args, "id")
model = self.get_one(model_id)
try:
sprints = (Sprint.query.filter(
Sprint.activity == model).with_entities(
Sprint.sprint_id).all())
issue_count = IssueSnapshot.query.filter(
IssueSnapshot.sprint_id.in_(sprints)).delete(
synchronize_session=False)
db.session.commit()
sprint_count = Sprint.query.filter(
Sprint.activity == model).delete()
db.session.commit()
message = (
f"Deleted {sprint_count} sprints with {issue_count} issue snapshots."
)
current_app.logger.info(message)
flash(message, "success")
except Exception:
current_app.logger.error(traceback.format_exc())
current_app.logger.error(
"Failed to delete sprints and issue snapshots")
flash("Deleting sprints and issue snapshots failed", "error")
return redirect(return_url)
def get_page(self):
return_url = get_redirect_target() or self.get_url('.index_view')
task_id = get_mdict_item_or_list(request.args, 'id')
task = self.get_one(task_id)
if task is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
if self.coll_name == 'crawl':
colname = 'crawl_%s' % task['_project']
else:
colname = 'auth_%s' % task['_code']
# print PageDB[colname]
coll = PageDB[colname]
page = coll.find({'_task_id': self._get_valid_id(task_id)})
page = list(page)
if not page:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
tmpl = 'admin/model/task_page_info.html'
return self.render(tmpl,
# get_value=self.get_list_value,
get_value=lambda m, c: m[c],
get_type=type,
model=page)
def edit_view(self):
"""Define Api for edit view.
Returns:
HTML page -- Html page for edit view
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_edit:
return redirect(return_url)
id_list = helpers.get_mdict_item_or_list(request.args, 'id')
widget_data = convert_widget_data_to_dict(self.get_one(id_list))
multi_lang_data = WidgetMultiLangData.get_by_widget_id(id_list)
converted_data = convert_data_to_desgin_pack(widget_data,
multi_lang_data)
model = convert_data_to_edit_pack(converted_data)
if model is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
return self.render(config.WEKO_GRIDLAYOUT_ADMIN_EDIT_WIDGET_SETTINGS,
model=json.dumps(model),
return_url=return_url)
def sync_project_sprints_without_issues(self):
return_url = get_redirect_target() or self.get_url(".index_view")
model_id = get_mdict_item_or_list(request.args, "id")
model = self.get_one(model_id)
if not model.jira_project:
flash("No Jira Project assigned to Activity", "error")
return redirect(return_url)
try:
# synchronous sync
current_app.logger.info(
f"Syncing all sprints (without issues) of project {model.jira_project.project_key}"
)
from tasks.jira import ( # pylint: disable=import-outside-toplevel
sync_all_sprints_without_issues, )
result_only_sprints = sync_all_sprints_without_issues.delay(
model_id)
result_only_sprints.get()
flash("Project sprints successfully synced.", "success")
except Exception as e:
logging.error(f"Sync project error: {e}")
flash("Project sprints not synced.", "error")
return redirect(return_url)
def handle_action(self, return_view=None):
"""
Handle action request.
:param return_view:
Name of the view to return to after the request.
If not provided, will return user to the return url in the form
or the list view.
"""
form = self.action_form()
if self.validate_form(form):
# using getlist instead of FieldList for backward compatibility
ids = request.form.getlist('rowid')
action = form.action.data
handler = self._actions_data.get(action)
if handler and self.is_action_allowed(action):
response = handler[0](ids)
if response is not None:
return response
else:
flash_errors(form, message='Failed to perform action. %(error)s')
if return_view:
url = self.get_url('.' + return_view)
else:
url = get_redirect_target() or self.get_url('.index_view')
return redirect(url)
def load_projects(self):
return_url = get_redirect_target() or self.get_url(".index_view")
try:
current_app.logger.info("Attempting to connect to jira")
jira = jira_core.connect()
except Exception as e:
status = "Jira not configured"
current_app.logger.error(f"{status}: {e}")
flash(status, "error")
else:
if jira is not None:
# load projects
projects = jira.projects()
for project in projects:
# create or update in case of change in Jira.
stmt = (pg_insert(JiraProject).values(
project_key=project.key,
project_name=project.name).on_conflict_do_update(
constraint="uq_jira_projects_project_key",
set_=dict(project_name=project.name),
))
db.session.execute(stmt)
db.session.commit()
status = f"{len(projects)} project/s loaded successfully."
current_app.logger.info(f"{status}")
flash(status, "success")
else:
flash("Jira failed to connect", "error")
return redirect(return_url)
def details_view(self):
return_url = get_redirect_target() or self.get_url('.index_view')
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return redirect(return_url)
if id.startswith("RH"):
id = id[2:]
model = self.get_one(id)
if model is None:
flash('Record does not exist.', 'error')
return redirect(return_url)
template = self.details_template
batch_number = get_next_file_batch_number()
file_form = FileForm(batch_number=batch_number)
logs = db.session.query(LogItem).filter(
LogItem.table == "Asset", LogItem.object_id == model.id).order_by(
LogItem.datetime.desc()).all()
return self.render(template,
model=model,
details_columns=self._details_columns,
get_value=self.get_detail_value,
return_url=return_url,
file_form=file_form,
logs=logs)
def details_view_with_extra_func(self, extra_func):
"""
Details model view
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_view_details:
return redirect(return_url)
if self.__class__.__name__ == 'AdminBIUserModelView':
id = get_mdict_item_or_list(request.args, 'id')
user_id = get_mdict_item_or_list(request.args, 'user_id')
if id is not None:
model = self.get_one(id)
elif user_id is not None:
model = self.session.query(BIUser).filter_by(user_id=user_id).one()
else:
return redirect(return_url)
else:
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:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
return extra_func(model, return_url)
def handle_action(self, return_view=None):
"""
Handle action request.
:param return_view:
Name of the view to return to after the request.
If not provided, will return user to the return url in the form
or the list view.
"""
form = self.action_form()
if self.validate_form(form):
# using getlist instead of FieldList for backward compatibility
ids = request.form.getlist('rowid')
action = form.action.data
handler = self._actions_data.get(action)
if handler and self.is_action_allowed(action):
response = handler[0](ids)
if response is not None:
return response
else:
flash_errors(form, message='Failed to perform action. %(error)s')
if return_view:
url = self.get_url('.' + return_view)
else:
url = get_redirect_target() or self.get_url('.index_view')
return redirect(url)
def handle_action(self, return_view=None):
"""
Handle action request.
:param return_view:
Name of the view to return to after the request.
If not provided, will return user to the return url in the form
or the list view.
"""
action = request.form.get('action')
ids = request.form.getlist('rowid')
handler = self._actions_data.get(action)
if handler and self.is_action_allowed(action):
response = handler[0](ids)
if response is not None:
return response
if return_view:
url = self.get_url('.' + return_view)
else:
url = get_redirect_target() or self.get_url('.index_view')
return redirect(url)
def details_view(self):
"""Override the details_view to use the export formatter."""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_view_details:
return redirect(return_url)
request_id = get_mdict_item_or_list(request.args, 'id')
if request_id is None:
return redirect(return_url)
request_model = self.get_one(request_id)
if request_model is None:
flash(gettext('O registro não existe.'), 'erro')
return redirect(return_url)
if self.details_modal and request.args.get('modal'):
template = self.details_modal_template
else:
template = self.details_template
return self.render(template,
model=request_model,
details_columns=self._details_columns,
get_value=self.get_export_value,
return_url=return_url)
def update_view(self):
if request.method == 'POST':
url = get_redirect_target() or self.get_url('.index_view')
change_form = ChangeForm(request.form)
if change_form.validate():
# decoded_ids = base64.b64decode(change_form.ids.data)
# decoded_ids = decoded_ids.decode("UTF-8")
ids = (change_form.ids.data).split(',')
cost = change_form.cost.data
_update_mappings = [{
'id': rowid,
'cost': cost
} for rowid in ids]
db.session.bulk_update_mappings(Project, _update_mappings)
db.session.commit()
flash("Set cost for {} record{} to {}.".format(
len(ids), 's' if len(ids) > 1 else '', cost),
category='info')
return redirect(url)
else:
# Form didn't validate
self._template_args['url'] = url
self._template_args['change_form'] = change_form
self._template_args['change_modal'] = True
return self.index_view()
def details_view(self):
"""
Details model view
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_view_details:
return self.redirect(return_url)
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return self.redirect(return_url)
model = self.get_one(id)
if model is None:
flash(gettext('Record does not exist.'), 'error')
return self.redirect(return_url)
if self.details_modal and request.args.get('modal'):
template = self.details_modal_template
else:
template = self.details_template
return self.render(template,
model=model,
details_columns=self._details_columns,
get_value=self.get_list_value,
return_url=return_url)
def details_view(self):
"""Details model view."""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_view_details:
return redirect(return_url)
widget_item_id = helpers.get_mdict_item_or_list(request.args, 'id')
if widget_item_id is None:
return redirect(return_url)
model = self.get_one(widget_item_id)
label = WidgetSettingView.get_label_display_to_list(model.widget_id)
model.label = label
if model is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
if self.details_modal and request.args.get('modal'):
template = self.details_modal_template
else:
template = self.details_template
return self.render(template,
model=model,
details_columns=self._details_columns,
get_value=self.get_detail_value,
return_url=return_url)
def edit_view(self):
"""
restrict edit on invoices, that have not been sent.
"""
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)
invoice = self.get_one(id)
if invoice is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
if invoice.sent:
flash(
gettext('Invoice has already been sent and cannot be edited.'),
'error')
return redirect(return_url)
return super(AdminInvoiceView, self).edit_view()
def create_view(self):
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_create:
return redirect(return_url)
return self.render(config.WEKO_GRIDLAYOUT_ADMIN_CREATE_WIDGET_SETTINGS,
return_url=return_url)
def approve_edit_view(self):
ao_id = request.args.get('id', '')
return_url = get_redirect_target() or self.get_url('.index_view')
model = Storage.query.filter_by(id=ao_id).first()
if not self.can_edit:
return redirect(return_url)
if model is None:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
column = self.get_edit_details_view_colums(model.instoreCategory)
self._template_args.update({
'table_columns':
self.init_table_columns(column),
'table_datas':
self.get_table_data_from_db(model),
})
model_id = model.id
form = self.edit_form(obj=model)
if not hasattr(form, '_validated_ruleset') or not\
form._validated_ruleset:
self._validate_form_instance(ruleset=self._form_edit_rules,
form=form)
if self.validate_form(form):
if self.update_model(form, model):
if request.method == 'POST' and self.support_flow:
self._custom_action(model, request.form)
flash(gettext('Record was successfully saved.'), 'success')
return redirect(
self.get_save_return_url(model, is_created=False))
perm = ActionNeedPermission('storage', Finish)
refuse_op = ('入库', Finish) if perm.can() else None
form_opts = FormOpts(widget_args=self.form_widget_args,
form_rules=self._form_edit_rules)
details_columns = self.get_column_names(
self.review_details_columns or self.column_details_list, None)
cfg = ActionViewCfg('', 'fa-bell-o', None, ('保存', Edit),
('入库', Finish))
return self.render(self.approve_edit_template,
action=self.get_url('.approve_edit_view',
verb='edit',
id=model_id),
model=model,
details_columns=details_columns,
get_value=self.get_list_value,
return_url=return_url,
cancel_url=return_url,
action_name=cfg.action_name,
icon_value=cfg.icon_value,
form=form,
agreed=cfg.agreed,
refuse=refuse_op,
form_opts=form_opts,
model_id=model_id,
one_line_columns=self.one_line_columns)
def edit_view(self):
"""
Edit model view
"""
if self.support_flow:
if '/edit/' in request.url:
url = request.url.replace('edit', 'approve-edit-view')
return redirect(url)
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:
flash(gettext('Record does not exist.'), 'error')
return redirect(return_url)
form = self.edit_form(obj=model)
if not hasattr(form,
'_validated_ruleset') or not form._validated_ruleset:
self._validate_form_instance(ruleset=self._form_edit_rules,
form=form)
if self.validate_form(form):
if self.update_model(form, model):
flash(gettext('Record was successfully saved.'), 'success')
if '_add_another' in request.form:
return redirect(
self.get_url('.create_view', url=return_url))
elif '_continue_editing' in request.form:
return redirect(request.url)
else:
# save button
return redirect(
self.get_save_return_url(model, is_created=False))
if request.method == 'GET' or form.errors:
self.on_form_prefill(form, id)
form_opts = FormOpts(widget_args=self.form_widget_args,
form_rules=self._form_edit_rules)
if self.edit_modal and request.args.get('modal'):
template = self.edit_modal_template
else:
template = self.edit_template
return self.render(template,
model=model,
form=form,
form_opts=form_opts,
return_url=return_url,
one_line_columns=self.one_line_columns)
def reissue_creds_view(self):
model = self.get_one(request.args.get('id'))
self._issue_creds(model)
self.session.add(model)
self.session.commit()
return_url = get_redirect_target() or self.get_url('.index_view')
flash('The credentials successfully reissued', 'success')
return redirect(return_url)
def status_view_ajax(self):
id = get_mdict_item_or_list(request.args, 'id')
if id is None:
return redirect(get_redirect_target()
or self.get_url('.index_view'))
outlet = self._process_request(id, request)
status = power.get_status(outlet)
return Response(json.dumps(status), mimetype="application/json")
def delete_view(self):
id = request.form.get('id')
if id is not None:
user = db_session.query(User).get(id)
if user and user.superuser and not current_user.superuser:
flash("Only superusers may perform this action.")
return redirect(get_redirect_target())
return super().delete_view()
def edit_view(self):
id = get_mdict_item_or_list(request.args, 'id')
if id is not None:
user = db_session.query(User).get(id)
if user and user.superuser and not current_user.superuser:
flash("Only superusers may perform this action.")
return redirect(get_redirect_target())
return super().edit_view()
def import_view(self):
return_url = get_redirect_target() or self.get_url('.index_view')
form = ImportForm(get_form_data())
if self.validate_form(form):
pair_tuple = form.data['cert'].encode(
'ascii'), form.data['key'].encode('ascii')
info = x509.load_certificate_info(pair_tuple)
if not x509.does_keys_match(pair_tuple):
flash('Failed to import identity: keys does not match.',
'error')
return redirect(return_url)
identity = models.Identity()
identity.name = info.subj_cn
if not info.self_signed:
def find_issuer():
for issuer in models.Identity.query.filter_by(
name=info.issuer_cn):
cert_chain = issuer.get_cert_chain()
try:
x509.verify_certificate_chain(
pair_tuple[0], cert_chain)
except x509.InvalidCertificate:
pass
else:
return issuer
identity.issuer = find_issuer()
if not identity.issuer:
flash(
'Failed to import identity: issuer identity not found.',
'error')
return redirect(return_url)
self.session.add(identity)
pair = models.Pair(*pair_tuple)
pair.identity = identity
self.session.add(pair)
try:
self.session.commit()
except IntegrityError:
flash(
'Failed to import identity: identity with same name already exists.',
'error')
return redirect(return_url)
flash('Identity was successfully imported.', 'success')
return redirect(self.get_save_return_url(identity,
is_created=True))
return self.render('admin/identity_import.html',
form=form,
return_url=return_url)
def custom_export_view(self):
"""
Custom Export view
"""
return_url = get_redirect_target() or self.get_url('.index_view')
if not self.can_custom_export:
return redirect(return_url)
# TODO: Test auto fill form value
"""
# It is neccesserry to only fill the form value when the form is requested NOT posted
if request.method == 'GET':
form = NewForm(formdata=MultiDict({'name': 'foo'}))
else:
form = NewForm()
"""
form = CustomExportForm()
if form.validate_on_submit():
filename = form.file_name.data if form.file_name.data != "" else "export_data"
cols = self.custom_export_columns if hasattr(
self, 'custom_export_columns') else self.column_list
try:
query_sets = self.model.all()
file_stream = pe.save_as(query_sets=query_sets,
column_names=list(cols),
dest_file_type="csv")
return (file_stream.read(), 200, {
'Content-Type':
'application/csv',
'Pragma':
'no-cache',
'Cache-Control':
'no-cache, no-store, must-revalidate',
'Expires':
'0',
'Content-Disposition':
'attachment; filename="%s.csv"' % filename
})
except Exception as err:
# Other errors
logger.error(err)
flash('Unknown error: %s' % err, 'error')
return redirect(
self.get_save_return_url(self.model, is_created=True))
if self.create_modal and request.args.get('modal'):
template = self.custom_export_modal_template
else:
template = self.custom_export_template
return self.render(template,
form=form,
form_opts=None,
return_url=return_url)
def export(self, export_type):
mx_type = request.args.get('mxtype', 'scheduled')
self._export_columns = self.get_export_columns(mx_type)
return_url = get_redirect_target() or self.get_url('.index_view')
if export_type == 'csv':
return self._export_csv(return_url)
else:
return self._export_tablib(export_type, return_url)
def reset_doc(self, id):
return_url = get_redirect_target() or url_for('.index_view')
doc_id = integrate.delay(doc_id=id).get()
doc = Document.objects(id=doc_id).get()
if doc.log:
msg = gettext(doc.log).lower()
prefix = gettext("Problème avec le document : ")
flash("%s %s" % (prefix, msg), 'error')
else:
flash(gettext('Document repassé : %s').format(doc))
return redirect(return_url)
def print_doc(self, id):
return_url = get_redirect_target() or url_for('.index_view')
try:
doc = Document.objects.get(id=id)
printdoc(doc)
job = doc.print_jobs[-1]
msg = gettext("Impression OK ( id du job : %s )")
flash(msg.format(job.cups_job_id))
except Exception as ex:
flash(gettext("Erreur lors de l'impression du document (%s)").format(str(ex)), 'error')
return redirect(return_url)
def delete_view(self):
"""
Delete model view. Only POST method is allowed.
Whether the model could be deleted is decided by model
"""
from flask_admin.helpers import get_redirect_target
return_url = get_redirect_target() or self.get_url('.index_view')
form = self.delete_form()
if self.validate_form(form):
# id is InputRequired()
model_id = form.id.data
model = self.get_one(model_id)
if model is not None and not model.can_delete():
flash(gettext('You are not allowed to delete this object'))
return redirect(return_url)
return super(ModelViewWithAccess, self).delete_view()
def create_view(self):
"""Event create view"""
events = DataGetter.get_all_events()
self._template_args['return_url'] = get_redirect_target() or self.get_url('.index_view')
self.name = "Event | New"
from ....forms.admin.event_form import EventForm
self.form = EventForm()
self.form.logo.choices=DataGetter.get_all_files_tuple()
self.form.logo.choices.insert(0, ('', ''))
if self.form.validate():
if request.method == "POST":
DataManager.create_event(self.form)
flash("Event updated")
return redirect(url_for('.index_view'))
return self.render('admin/model/create_model.html',
form=self.form,
events=events,
cancel_url=url_for('.index_view'))
def create_view(self):
"""Event create view"""
events = DataGetter.get_all_events()
self._template_args['return_url'] = get_redirect_target() or self.get_url('.index_view')
self.name = "Event | New"
from ....forms.admin.event_form import EventForm
self.form = EventForm()
if self.form.validate_on_submit():
try:
DataManager.create_event(self.form)
except Exception as error:
print error
flash("Event updated")
return redirect(url_for('.index_view'))
return self.render('admin/model/create_event.html',
form=self.form,
events=events,
cancel_url=url_for('.index_view'))
def get_model_return_url(self):
from flask_admin.helpers import get_redirect_target
return_url = get_redirect_target() or self.get_url('.index_view')
model_id = get_mdict_item_or_list(request.args, 'id')
model = self.get_one(model_id)
return model, return_url
