mirror of
https://github.com/lucaspalomodevelop/eventcally.git
synced 2026-03-13 00:07:22 +00:00
250 lines
7.6 KiB
Python
250 lines
7.6 KiB
Python
from flask import flash, make_response, redirect, render_template, request, url_for
|
|
from flask_babelex import gettext
|
|
from flask_security import auth_required, current_user
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
from sqlalchemy.sql import desc, func
|
|
|
|
from project import app, db
|
|
from project.access import (
|
|
get_admin_unit_for_manage,
|
|
get_admin_unit_for_manage_or_404,
|
|
get_admin_units_for_manage,
|
|
has_access,
|
|
)
|
|
from project.forms.admin_unit import UpdateAdminUnitWidgetForm
|
|
from project.forms.event import FindEventForm
|
|
from project.forms.event_place import FindEventPlaceForm
|
|
from project.models import (
|
|
AdminUnitMember,
|
|
AdminUnitMemberInvitation,
|
|
EventOrganizer,
|
|
EventPlace,
|
|
EventSuggestion,
|
|
User,
|
|
)
|
|
from project.services.event import get_events_query
|
|
from project.services.event_search import EventSearchParams
|
|
from project.services.event_suggestion import get_event_reviews_query
|
|
from project.views.event import get_event_category_choices
|
|
from project.views.utils import (
|
|
flash_errors,
|
|
get_pagination_urls,
|
|
handleSqlError,
|
|
permission_missing,
|
|
)
|
|
|
|
|
|
@app.route("/manage")
|
|
@auth_required()
|
|
def manage():
|
|
try:
|
|
if "manage_admin_unit_id" in request.cookies:
|
|
manage_admin_unit_id = int(request.cookies.get("manage_admin_unit_id"))
|
|
admin_unit = get_admin_unit_for_manage(manage_admin_unit_id)
|
|
|
|
if admin_unit:
|
|
return redirect(url_for("manage_admin_unit", id=admin_unit.id))
|
|
except Exception:
|
|
pass
|
|
|
|
return redirect(url_for("manage_admin_units"))
|
|
|
|
|
|
@app.route("/manage/admin_units")
|
|
@auth_required()
|
|
def manage_admin_units():
|
|
admin_units = get_admin_units_for_manage()
|
|
invitations = AdminUnitMemberInvitation.query.filter(
|
|
AdminUnitMemberInvitation.email == current_user.email
|
|
).all()
|
|
|
|
admin_units.sort(key=lambda x: x.name)
|
|
invitations.sort(key=lambda x: x.adminunit.name)
|
|
|
|
return render_template(
|
|
"manage/admin_units.html", invitations=invitations, admin_units=admin_units
|
|
)
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>")
|
|
@auth_required()
|
|
def manage_admin_unit(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
|
|
response = make_response(
|
|
redirect(url_for("manage_admin_unit_events", id=admin_unit.id))
|
|
)
|
|
response.set_cookie("manage_admin_unit_id", str(admin_unit.id))
|
|
return response
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>/reviews")
|
|
@auth_required()
|
|
def manage_admin_unit_event_reviews(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
|
|
event_suggestions_paginate = (
|
|
get_event_reviews_query(admin_unit)
|
|
.order_by(desc(EventSuggestion.created_at))
|
|
.paginate()
|
|
)
|
|
event_suggestions = event_suggestions_paginate.items
|
|
|
|
return render_template(
|
|
"manage/reviews.html",
|
|
admin_unit=admin_unit,
|
|
event_suggestions=event_suggestions,
|
|
pagination=get_pagination_urls(event_suggestions_paginate, id=id),
|
|
)
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>/events")
|
|
@auth_required()
|
|
def manage_admin_unit_events(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
|
|
params = EventSearchParams()
|
|
params.set_default_date_range()
|
|
|
|
form = FindEventForm(formdata=request.args, obj=params)
|
|
form.category_id.choices = get_event_category_choices()
|
|
form.category_id.choices.insert(0, (0, ""))
|
|
|
|
organizers = (
|
|
EventOrganizer.query.filter(EventOrganizer.admin_unit_id == admin_unit.id)
|
|
.order_by(func.lower(EventOrganizer.name))
|
|
.all()
|
|
)
|
|
form.organizer_id.choices = [(o.id, o.name) for o in organizers]
|
|
form.organizer_id.choices.insert(0, (0, ""))
|
|
|
|
if form.validate():
|
|
form.populate_obj(params)
|
|
|
|
params.admin_unit_id = admin_unit.id
|
|
events = get_events_query(params).paginate()
|
|
return render_template(
|
|
"manage/events.html",
|
|
admin_unit=admin_unit,
|
|
form=form,
|
|
events=events.items,
|
|
pagination=get_pagination_urls(events, id=id),
|
|
)
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>/organizers")
|
|
@auth_required()
|
|
def manage_admin_unit_organizers(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
organizers = (
|
|
EventOrganizer.query.filter(EventOrganizer.admin_unit_id == admin_unit.id)
|
|
.order_by(func.lower(EventOrganizer.name))
|
|
.paginate()
|
|
)
|
|
|
|
return render_template(
|
|
"manage/organizers.html",
|
|
admin_unit=admin_unit,
|
|
organizers=organizers.items,
|
|
pagination=get_pagination_urls(organizers, id=id),
|
|
)
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>/event_places")
|
|
@auth_required()
|
|
def manage_admin_unit_event_places(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
|
|
form = FindEventPlaceForm(**request.args)
|
|
|
|
places = (
|
|
EventPlace.query.filter(EventPlace.admin_unit_id == admin_unit.id)
|
|
.order_by(func.lower(EventPlace.name))
|
|
.paginate()
|
|
)
|
|
return render_template(
|
|
"manage/places.html",
|
|
admin_unit=admin_unit,
|
|
form=form,
|
|
places=places.items,
|
|
pagination=get_pagination_urls(places, id=id),
|
|
)
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>/members")
|
|
@auth_required()
|
|
def manage_admin_unit_members(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
|
|
if not has_access(admin_unit, "admin_unit.members:read"):
|
|
return permission_missing(url_for("manage_admin_unit", id=id))
|
|
|
|
members = (
|
|
AdminUnitMember.query.join(User)
|
|
.filter(AdminUnitMember.admin_unit_id == admin_unit.id)
|
|
.order_by(func.lower(User.email))
|
|
.paginate()
|
|
)
|
|
invitations = (
|
|
AdminUnitMemberInvitation.query.filter(
|
|
AdminUnitMemberInvitation.admin_unit_id == admin_unit.id
|
|
)
|
|
.order_by(func.lower(AdminUnitMemberInvitation.email))
|
|
.all()
|
|
)
|
|
|
|
return render_template(
|
|
"manage/members.html",
|
|
admin_unit=admin_unit,
|
|
can_invite_users=has_access(admin_unit, "admin_unit.members:invite"),
|
|
members=members.items,
|
|
invitations=invitations,
|
|
pagination=get_pagination_urls(members, id=id),
|
|
)
|
|
|
|
|
|
@app.route("/manage/admin_unit/<int:id>/widgets", methods=("GET", "POST"))
|
|
@auth_required()
|
|
def manage_admin_unit_widgets(id):
|
|
admin_unit = get_admin_unit_for_manage_or_404(id)
|
|
default_background_color = "#ffffff"
|
|
default_primary_color = "#007bff"
|
|
|
|
form = UpdateAdminUnitWidgetForm(obj=admin_unit)
|
|
|
|
if not form.widget_background_color.data:
|
|
form.widget_background_color.data = default_background_color
|
|
|
|
if not form.widget_primary_color.data:
|
|
form.widget_primary_color.data = default_primary_color
|
|
|
|
if not form.widget_link_color.data:
|
|
form.widget_link_color.data = default_primary_color
|
|
|
|
if form.validate_on_submit():
|
|
if not has_access(admin_unit, "admin_unit:update"):
|
|
return permission_missing(url_for("manage_admin_unit", id=admin_unit.id))
|
|
|
|
form.populate_obj(admin_unit)
|
|
|
|
if form.widget_background_color.data == default_background_color:
|
|
admin_unit.widget_background_color = None
|
|
|
|
if form.widget_primary_color.data == default_primary_color:
|
|
admin_unit.widget_primary_color = None
|
|
|
|
if form.widget_link_color.data == default_primary_color:
|
|
admin_unit.widget_link_color = None
|
|
|
|
try:
|
|
db.session.commit()
|
|
flash(gettext("Settings successfully updated"), "success")
|
|
return redirect(url_for("manage_admin_unit_widgets", id=admin_unit.id))
|
|
except SQLAlchemyError as e:
|
|
db.session.rollback()
|
|
flash(handleSqlError(e), "danger")
|
|
else:
|
|
flash_errors(form)
|
|
|
|
return render_template("manage/widgets.html", form=form, admin_unit=admin_unit)
|