def group_leave(_ctxt, user_id, group_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
group_member = models.Session.query(models.GroupMember).filter(
models.GroupMember.group_id == group_id).filter(
models.GroupMember.user_id == user_id).first()
group_leaders = models.Session.query(models.User).join(
models.GroupMember,
models.User.id == models.GroupMember.user_id).join(
models.Group,
models.Group.id == models.GroupMember.group_id).join(
models.GroupRole,
models.GroupRole.id == models.GroupMember.role_id
).filter(models.Group.id == group_id).filter(
models.GroupRole.description == 'Group Leader').all()
if (group_member and group_leaders and len(group_leaders) == 1
and group_leaders[0].id == user_id):
flask.flash(
'Unable to leave group when you are the last'
' group leader.', 'danger')
elif group_member:
with models.transaction() as session:
session.delete(group_member)
session.commit()
flask.flash('You left group successfully!', 'success')
else:
flask.flash('Error leaving group.', 'danger')
return flask.redirect(flask.url_for('.show', user_id=user_id))
def delete(_ctxt, image_id, entity_type):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
if entity_type == 'user':
ui = models.UserImage.get_by_image_id(image_id)
session.delete(ui)
elif entity_type == 'group':
gi = models.GroupImage.get_by_image_id(image_id)
session.delete(gi)
elif entity_type == 'organization':
oi = models.OrganizationImage.get_by_image_id(image_id)
session.delete(oi)
i = models.Image.get(image_id)
session.delete(i)
CloudinaryHandler().delete([i.public_id])
flask.flash("Image deleted successfully", "success")
except Exception:
message = "Failed to delete image, please try again later"
LOG.exception(message)
flask.flash(message, "danger")
return flask.redirect(flask.request.referrer)
def show(self, org):
if not org or org.activated_at is None:
flask.flash('Organization not found. Please try again', 'danger')
return flask.redirect(flask.url_for('index'))
cloudinary = dict(entity_id=org.id,
entity_type='organization',
**CloudinaryHandler.cloudinary_elements())
ef = forms.MassEmailForm()
email_form = self.custom_email_form(org.id, ef)
wtforms = {
'mass_email': email_form,
'confirm': forms.ConfirmForm(flask.request.form)
}
context = {
'cloudinary': cloudinary,
'env': CONF.get('environment'),
'google_api_key': CONF.get('google.api.key'),
'invited_users': self.get_invited_users(org.id),
'join_request_url': flask.url_for('orgs.join_request',
org_id=org.id),
'members': self.get_users(org.id),
'org': org,
'video_extensions': tuple(VIDEO_EXTENSIONS),
'wtforms': wtforms
}
return flask.render_template('organization/view.html', **context)
def user_delete(_ctxt, org_id, user_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
ou = helper.get_member(org_id, user_id)
LOG.debug("Removing user '%s' from org '%s'", user_id, org_id)
session.delete(ou)
if form.confirm_checkbox.data:
org_groups = session.query(
models.OrganizationGroup).filter(
models.OrganizationGroup.organization_id ==
org_id).all()
for og in org_groups:
gu = session.query(models.GroupMember).filter(
models.GroupMember.group_id == og.group_id).filter(
models.GroupMember.user_id == user_id).first()
if gu:
LOG.debug("Removing user '%s' from group '%s'",
user_id, og.group_id)
session.delete(gu)
flask.flash('Member removed successfully!', 'success')
except Exception:
LOG.exception("Failed to remove user '%s' from org '%s'", user_id,
org_id)
flask.flash('Failed to remove member.', 'danger')
return flask.redirect(flask.url_for('.edit', org_id=org_id))
def index(_ctxt):
groups_limit = CONF.get('max.groups.on.homepage')
cls = models.Group
query_filter = [
models.GroupPrivacySetting.description.like('Public%'),
cls.archived_at.is_(None)]
order_by = cls.id.desc()
if flask.request.method == 'POST':
form = flask.request.get_json()
if form.get('age'):
query_filter.append(cls.age_range_id == form['age'])
if form.get('gender') or form.get('gender') == '':
query_filter.append(cls.gender_focus == form['gender'])
if form.get('group_types'):
query_filter.append(cls.group_type_id.in_(form['group_types']))
if form.get('order'):
order_by = cls.clicks.desc()
query = models.Session.query(cls).join(
cls.privacy_settings
).filter(*query_filter).order_by(
order_by
).limit(groups_limit)
if flask.request.method == 'POST':
return render_template(
'_partials/featured_groups.html', group_list=query.all())
filter_ages = models.Session.query(models.AgeRange).options(
orm.load_only('id', 'description')).all()
filter_group_types = models.Session.query(models.GroupType).options(
orm.load_only('id', 'description')).all()
wtforms = {
'confirm': forms.ConfirmForm(),
'contact': forms.ContactForm()
}
# TODO: see models.py Group.gender_focus note
context = {
'group_list': query.all(),
'filter': {
'genders': [
('', "Men and Women"),
('M', "Men's Group"),
('F', "Women's Group")
],
'ages': filter_ages,
'group_types': filter_group_types
},
'wtforms': wtforms
}
return render_template('index.html', **context)
def block_as_spam(_ctxt, notification_id):
form = forms.ConfirmForm(flask.request.form)
if form.validate():
LOG.debug("Block Notification as Spam")
notification = models.Notification.get(notification_id)
notification.declined = datetime.datetime.utcnow()
notification.blocked_as_spam = True
notification.save()
flask.flash("Notification blocked successfully!", "success")
else:
flask.flash("Can't block notification as Spam. Please, try again"
" later", "danger")
return flask.redirect(
flask.url_for('users.show', user_id=current_user.id))
def join_request(_ctxt, org_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
return flask.redirect(
flask.redirect(flask.url_for('.show', org_id=org_id)))
try:
with models.transaction() as session:
existing_om = helper.get_member(org_id, current_user.id)
if existing_om:
flask.flash('You are already a member of this organization',
'danger')
return flask.redirect(flask.url_for('.show', org_id=org_id))
org = models.Organization.get(org_id)
if not org:
flask.flash('No organization found', 'danger')
return flask.redirect(flask.url_for('.show', org_id=org_id))
org_admins_and_owners = helper.get_leaders(org_id)
if not org_admins_and_owners:
flask.flash(
'There is not currently any organization'
' owners/administrators for this organization. No request'
' sent Please try again shortly.', 'danger')
else:
notification_type = session.query(
models.NotificationType).filter(
models.NotificationType.description ==
'Organization Join Request').first()
for user in org_admins_and_owners:
notification = models.Notification(
user_to_id=user.id,
user_from_id=current_user.id,
notification_type_id=notification_type.id,
organization_id=org_id)
reminder = helper.send_notification(notification)
mail_to = ','.join([u.email for u in org_admins_and_owners])
email_type = email.OrgJoinRequestEmail()
helper.send_email(email_type,
current_user.email,
mail_to,
reminder,
org=org)
flask.flash('Request to join organization successfully sent!',
'success')
except Exception:
LOG.exception('Failed to send group join request to organization %s',
org_id)
flask.flash('There was an error sending your join request!', 'danger')
return flask.redirect(flask.url_for('.show', org_id=org_id))
def user_delete(_ctxt, group_id, user_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
gu = helper.get_member(group_id, user_id)
session.delete(gu)
flask.flash('Member removed successfully!', 'success')
except Exception:
LOG.exception("Failed to remove user '%s' from group '%s'",
user_id, group_id)
flask.flash('Failed to remove member.', 'error')
return flask.redirect(flask.url_for('.edit', group_id=group_id))
def group_delete(_ctxt, org_id, group_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
group = models.Group.get(group_id)
group.archived_at = datetime.datetime.utcnow(),
session.add(group)
flask.flash('Group archived successfully!', 'success')
except Exception:
LOG.exception("Failed to archive group with id '%s' "
"for org %s", group_id, org_id)
flask.flash('Failed to archive group.', 'error')
return flask.redirect(flask.url_for('.edit', org_id=org_id))
def show(_ctxt, user_id):
if current_user.id != user_id and not current_user.super_admin:
flask.flash('Permission denied.', 'danger')
return flask.redirect('/')
user = models.User.get(user_id)
wtforms = {
'confirm': forms.ConfirmForm(flask.request.form),
'password_reset': forms.PasswordResetForm(flask.request.form),
'user_profile': forms.UserProfileForm(flask.request.form, obj=user)
}
wtforms['user_profile'].timezone_default.data = user.timezone
cloudinary = dict(entity_type='user',
entity_id=user_id,
**CloudinaryHandler.cloudinary_elements())
context = {'cloudinary': cloudinary, 'user': user, 'wtforms': wtforms}
return flask.render_template('user/profile.html', **context)
def edit(_ctxt, org_id):
tf = forms.TextMessageForm()
text_message_form = helper.text_message_form(org_id, tf)
ef = forms.MassEmailForm()
mass_email_form = helper.custom_email_form(org_id, ef)
org = models.Organization.get(org_id)
creator = org.creator
members = helper.get_users(org_id)
invited_users = helper.get_invited_users(org_id)
wtforms = {
'org': forms.OrgForm(),
'mass_email': mass_email_form,
'link': forms.LinkForm(),
'chart_filter': forms.ChartFilterForm(),
'confirm': forms.ConfirmForm(),
'text_message': text_message_form,
'add_member': forms.AddMemberForm(),
'role_forms_dict': {}
}
helper.populate_primary_form(wtforms['org'], org)
for member, role in members:
role_form = forms.RoleForm()
role_form.role.choices = helper.get_role_choices(org_id)
role_form.role.data = role.id
wtforms['role_forms_dict'][member.id] = role_form
charts = Charts(org).get()
cloudinary = dict(entity_id=org.id,
entity_type='org',
**CloudinaryHandler.cloudinary_elements())
context = {
'add_member_return_url': flask.url_for('.edit', org_id=org_id),
'charts': charts,
'cloudinary': cloudinary,
'creator': creator,
'current_user': current_user,
'invited_users': invited_users,
'members': members,
'org': org,
'wtforms': wtforms
}
return flask.render_template('organization/edit.html', **context)
def show(_ctxt, group_id):
tf = forms.TextMessageForm()
text_message_form = helper.text_message_form(group_id, tf)
ef = forms.MassEmailForm()
mass_email_form = helper.custom_email_form(group_id, ef)
group = models.Group.get(group_id)
if not group or group.archived_at:
flask.flash('Group not found. Please try again.', 'danger')
return flask.redirect(flask.url_for('index'))
elif not group.parent_org.activated_at:
flask.flash(
'This group does not exist, please try again or contact'
' an organization administrator for that group', 'danger')
return flask.redirect(flask.url_for('index'))
wtforms = {
'group_leaders_email': forms.GroupLeadersEmailForm(),
'mass_email': mass_email_form,
'add_member': forms.AddMemberForm(),
'text_message': text_message_form,
'group_add_document': forms.GroupAddDocumentForm(),
'group_add_google_doc': forms.GroupAddGoogleDocForm(),
'group_meeting': forms.GroupMeetingForm(),
'confirm': forms.ConfirmForm()
}
cloudinary = dict(entity_type='group',
entity_id=group.id,
**CloudinaryHandler.cloudinary_elements())
google_api = {'key': GOOGLE_API_KEY, 'client_id': GOOGLE_API_CLIENT_ID}
context = {
'add_member_return_url': flask.url_for(".show", group_id=group_id),
'cloudinary': cloudinary,
'current_user': current_user,
'entity_type': 'group',
'google_api': google_api,
'group': group,
'invited_users': helper.get_invited_users(group_id),
'meetings': helper.get_meetings(group_id),
'members': helper.get_users(group_id),
'video_extensions': tuple(VIDEO_EXTENSIONS),
'wtforms': wtforms
}
if current_user.is_authenticated:
context['disqus_config'] = disqus.conf(current_user, group_id)
return flask.render_template('group/view.html', **context)
def document_delete(_ctxt, group_id, document_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
d = models.GroupDocument.get(document_id)
key = d.file_url.split('/')[-1]
filehandler.S3FileHandler.delete(key)
session.delete(d)
flask.flash('Document deleted successfully!', 'success')
except Exception:
LOG.exception("Failed to delete document '%s' for group '%s'",
document_id, group_id)
flask.flash('Failed to delete document.', 'error')
return flask.redirect(flask.url_for('.show', group_id=group_id))
def delete(_ctxt, link_id, group_id=None, organization_id=None):
entity, _, values = get_context(group_id, organization_id)
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
link = models.Link.get(link_id)
session.delete(link)
flask.flash(
'%s link deleted successfully!' % entity.capitalize(),
'success')
except Exception:
LOG.exception("Failed to delete link '%s' for %s '%s'", link_id,
entity, group_id)
flask.flash('Failed to delete %s link.' % entity, 'error')
return flask.redirect(flask.url_for('%ss.edit' % entity, **values))
def join_request(_ctxt, group_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
group_leaders = helper.get_leaders(group_id, texting=True)
if not group_leaders:
flask.flash(
'There are not currently any group leaders for this group.'
' No request sent. Please try again shortly.', 'danger')
else:
helper.join_request_handler(group_leaders, group_id)
except Exception:
LOG.exception("Failed to send group join request to group %s",
group_id)
flask.flash('There was an error sending your join request!',
'danger')
return flask.redirect(flask.url_for('.show', group_id=group_id))
def group_unaffiliate(_ctxt, org_id, group_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
og = session.query(models.OrganizationGroup).filter(
sa.and_(models.OrganizationGroup.organization_id == org_id,
models.OrganizationGroup.group_id ==
group_id)).first()
session.delete(og)
flask.flash('Group unaffiliated successfully!', 'success')
except Exception:
LOG.exception(
"Failed to unaffiliated group with id '%s' "
"for org %s", group_id, org_id)
flask.flash('Failed to unaffiliated group.', 'error')
return flask.redirect(flask.url_for('.edit', org_id=org_id))
def meeting_delete(_ctxt, group_id, meeting_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
m = models.ZoomMeeting.get(meeting_id)
zoom = meeting.ZoomMeetingDriver()
LOG.debug("Deleting meeting id: %s", id)
meeting_info = {
'meeting_id': m.meeting_id,
'current_user': current_user
}
zoom.delete_meeting(**meeting_info)
session.delete(m)
flask.flash('Meeting deleted successfully!', 'success')
except Exception:
LOG.exception("Failed to delete meeting '%s' for group '%s'",
meeting_id, group_id)
flask.flash('Failed to delete meeting.', 'error')
return flask.redirect(flask.url_for('.show', group_id=group_id))
def meeting_text_create(_ctxt, group_id, meeting_id):
form = forms.ConfirmForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
group = models.Group.get(group_id)
zoom_meeting = models.ZoomMeeting.get(meeting_id)
group_leaders = helper.get_leaders(group_id, texting=True)
group_users = helper.get_users(group_id, texting=True)
# Three message sets due to hosts receiving two and leaders receiving
# three separate messages
join_messages = {}
host_messages = {}
leader_messages = {}
for user in group_users:
message = helper.meeting_join_text(user, group, zoom_meeting)
join_messages[user.phone_number] = message
for host in group_users:
if zoom_meeting.can_host_meeting(host.id):
message = helper.meeting_creator_alert_text(
host, group, zoom_meeting)
host_messages[host.phone_number] = message
for leader in group_leaders:
if leader is not current_user:
message = helper.leader_alert_text(leader, current_user, group,
zoom_meeting)
leader_messages[leader.phone_number] = message
# It is assumed that if the Join text is sent, necessary data for the
# others are sent. Logs will be kept on all three, but flashes will
# only occur for Join text
helper.send_text_message(join_messages, flash=True)
helper.send_text_message(host_messages, flash=False)
helper.send_text_message(leader_messages, flash=False)
return flask.redirect(flask.url_for('.show', group_id=group_id))
def edit(_ctxt, group_id):
tf = forms.TextMessageForm()
text_message_form = helper.text_message_form(group_id, tf)
ef = forms.MassEmailForm()
mass_email_form = helper.custom_email_form(group_id, ef)
group = models.Group.get(group_id)
if not group.parent_org.activated_at:
flask.flash(
'This group does not exist, please try again or contact'
' an organization administrator for that group', 'danger')
return flask.redirect(flask.url_for('index'))
other_orgs = helper.get_unaffiliated_orgs_for_group(group_id)
members = helper.get_users(group_id)
invited_users = helper.get_invited_users(group_id)
wtforms = {
'add_member': forms.AddMemberForm(),
'group_add_org': forms.GroupAddOrgForm(),
'confirm': forms.ConfirmForm(),
'group_edit': forms.GroupEditForm(),
'link': forms.LinkForm(),
'mass_email': mass_email_form,
'role_forms': {},
'text_message': text_message_form,
'tinymce_api_key': CONF.get('tinymce.api.key')
}
# TODO This is ripe for optimization. It's nice to get the models
# but we should eager load the meet_time_types at least to
# save N unexpected trips to the database
wtforms['group_edit'].meet_times.data = [
t.meet_time_type for t in group.meet_times
]
wtforms[
'group_edit'].privacy_settings.choices = forms.privacy_setting_choices(
)
helper.populate_primary_form(wtforms['group_edit'], group)
add_member_return_url = flask.url_for(".edit", group_id=group_id)
wtforms['group_add_org'].orgs.choices = [('', 'Select Organization')] + [
(str(o.id), o.name) for o in other_orgs
]
role_forms = {}
org = group.parent_org
if current_user.is_group_admin(org_id=org.id):
group_role_choices = helper.get_role_choices()
elif current_user.role_for_group(group_id):
priority = current_user.role_for_group(group_id).priority
group_role_choices = helper.get_role_choices(priority)
else:
group_role_choices = helper.get_role_choices(0)
for user, group_member, role in members:
group_user_role_form = forms.GroupUserRoleForm()
group_user_role_form.role.choices = group_role_choices
group_user_role_form.role.data = str(role.id)
group_user_role_form.cohost_meeting.data = (
group_member.can_cohost_meeting)
role_forms[user.id] = group_user_role_form
cloudinary = dict(entity_type='group',
entity_id=group.id,
**CloudinaryHandler.cloudinary_elements())
context = {
'add_member_return_url': add_member_return_url,
'cloudinary': cloudinary,
'group': group,
'invited_users': invited_users,
'members': members,
'role_forms': role_forms,
'wtforms': wtforms
}
return flask.render_template('group/edit.html', **context)