def register(_ctxt):
form = forms.RegisterEmailForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
elif not recaptcha.verify():
flask.flash("Invalid Captcha. Please make sure to confirm you "
"are human.", "danger")
else:
try:
mail_from = CONF.get("email.mailfrom")
mail_to = form.email.data
# Don't leak emails to people just guessing, let them
# think we're always sending something
if not users.is_existing_user(form.email.data):
r = email.RegistrationEmail()
r.send(mail_from, mail_to,
return_route="register/validate")
else:
r = email.UserExistsRegistrationEmail()
r.send(mail_from, mail_to,
return_route="forgot-password/validate")
flask.flash("Validation email has been sent. "
"Please check your email box to "
"complete the registration.",
'success')
except Exception:
LOG.exception("Error sending registration token")
flask.flash('There was an error getting you registered.'
' Please try again later.', 'danger')
return redirect(url_for('login'))
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 forgot_password(_ctxt):
form = forms.ForgotPasswordForm(flask.request.form)
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
else:
try:
user = users.existing_user(form.email.data)
if not user:
flask.flash("User with that email does not exist."
" Please try a different email address.",
'danger')
return redirect(url_for('forgot_password'))
mail_from = CONF.get("email.mailfrom")
mail_to = form.email.data
r = email.ForgotPasswordEmail()
r.send(mail_from, mail_to,
return_route="forgot-password/validate")
flask.flash("You've successfully sent a password reset email. "
"Please click the link in your email to "
"reset your password.",
'success')
return redirect(url_for('login'))
except Exception:
LOG.exception("Forgot Password failed for user with email "
"'%s'", form.email.data)
flask.flash('There was an error sending the password reset'
' email. Please try again later.',
'danger')
return redirect(url_for('forgot_password'))
return render_template('forgot_password.html', form=form)
def create(_ctxt, group_id=None, organization_id=None):
entity, entity_id, values = get_context(group_id, organization_id)
form = forms.LinkForm(flask.request.form)
can_edit_entity = getattr(current_user, 'can_edit_' + entity)
if not can_edit_entity(entity_id) or not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
link = models.Link(link_type_id=form.link_type.data.id,
url=form.link.data,
**(values if group_id else {
'organization_id': entity_id
}))
session.add(link)
flask.flash(
'You successfully added %s %s link!' %
('a' if group_id else 'an', entity), 'success')
except Exception:
LOG.exception("Failed to create link for %s '%s'", entity,
entity_id)
flask.flash(
"""There was an error adding the %s link.
Please try again later""" % entity, 'danger')
return flask.redirect(flask.url_for('%ss.edit' % entity, **values))
def user_add(_ctxt, org_id):
form = forms.AddMemberForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
org = models.Organization.get(org_id)
orgr = models.OrganizationRole.get_by_description('Member')
user = models.User.get_by_email(form.email.data)
if not user:
try:
content = {'org': org, 'role': orgr}
mail = email.OrgInviteNewMemberEmail()
mail.send(current_user.email, form.email.data, **content)
flask.flash('New member sent invite', 'success')
except Exception:
LOG.exception('Error sending org invite email.')
flask.flash(
'Error sending invite email, please try again later.',
'danger')
else:
om = helper.get_member(org_id, user.id)
if om:
flask.flash(
'User is already a member of the organization. User not'
' added.', 'info')
return flask.redirect(flask.url_for('.edit', org_id=org.id))
try:
helper.notify_join(user, org)
except Exception:
message = 'Error occurred, please try again later'
LOG.exception(message)
flask.flash(message, 'danger')
return flask.redirect(form.return_url.data)
def search(_ctxt):
form = forms.OrgSearchForm(flask.request.form)
context = dict(form=form)
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
else:
with models.transaction() as session:
filters = [models.Organization.activated_at.isnot(None)]
form_pairs = {
"name": models.Organization.name,
"city": models.Address.city,
"state": models.Address.state,
"zip_code": models.Address.zip_code
}
for form_field, model_field in form_pairs.items():
form_data = form[form_field].data
if form_data:
filters.append(
model_field.like('{}%'.format(form_data)))
query = session.query(models.Organization).join(
models.Address, models.Address.id ==
models.Organization.address_id).filter(*filters).order_by(
models.Organization.name)
context['orgs'] = query.all()
return flask.render_template('organization/search.html',
**context)
return flask.render_template('organization/search.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 contact(_ctxt):
form = forms.ContactForm(flask.request.form)
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
elif not recaptcha.verify():
flask.flash("Invalid Captcha. Please make sure to confirm you "
"are human.", "danger")
else:
try:
e = email.ContactEmail()
e.send(
form.email.data,
CONF.get("support.email.address"),
**form.data)
flask.flash('You successfully submitted your contact request,'
' someone will contact you shortly.'
' Thanks for your feedback/interest!',
'success')
return redirect(url_for('contact'))
except Exception:
LOG.exception("Error sending contact form information")
flask.flash('There was a problem submitting your contact '
'request. Sorry for the inconvenience. We will '
'fix this as soon as we can. Please try again '
'shortly.', 'danger')
return render_template('contact-us.html', form=form)
def login(_ctxt):
if current_user.is_authenticated:
return redirect('profile')
form = forms.LoginForm(flask.request.form)
if flask.request.method == 'POST':
if form.validate():
user = models.User.get_by_email(form.email.data)
if not user:
flask.flash('Invalid login credentials.', 'danger')
elif user.verified_at is None:
flask.flash("Your account has not been activated. Please "
"check your email to verify your account",
"danger")
else:
try:
valid_password = bcrypt.check_password_hash(
user.hashed_password, form.password.data)
if not valid_password:
flask.flash('Invalid login credentials.', 'danger')
else:
login_user(user)
flask.flash('Logged in successfully.', 'success')
return redirect_dest(url_for('users.show',
user_id=user.id))
except ValueError:
LOG.exception(
"User %s hasn't updated their password from"
" legacy system", form.email.data)
flask.flash('Invalid login credentials.', 'danger')
return redirect_dest(home=url_for('login'))
else:
app_utils.flash_errors(form)
return render_template('login.html', form=form)
def user_add(_ctxt, group_id):
form = forms.AddMemberForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
group = models.Group.get(group_id)
gr = models.GroupRole.get_by_description('Member')
user = models.User.get_by_email(form.email.data)
if not user:
try:
content = {'group': group, 'role': gr}
mail = email.GroupInviteNewMemberEmail()
mail.send(current_user.email, form.email.data, **content)
flask.flash("New member sent invite", "success")
except Exception:
LOG.exception("Error sending org invite email.")
flask.flash(
"Error sending invite email, please try again later.",
"danger")
else:
gm = helper.get_member(group_id, user.id)
if gm:
flask.flash(
"User is already a member of the group. "
"User not invited.", "info")
return flask.redirect(flask.url_for('.edit',
group_id=group_id))
try:
helper.notify_join(user, group)
except Exception:
message = "Error occurred, please try again later"
LOG.exception(message)
flask.flash(message, 'danger')
return flask.redirect(form.return_url.data)
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 document_add(_ctxt, group_id):
form = forms.GroupAddDocumentForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
googledoc = forms.GroupAddGoogleDocForm(flask.request.form)
if googledoc.link.data:
helper.google_doc_add(group_id, googledoc)
return flask.redirect(flask.url_for('.show', group_id=group_id))
helper.document_upload(group_id, form)
return flask.redirect(flask.url_for('.show', group_id=group_id))
def update(_ctxt, group_id):
form = forms.GroupEditForm(flask.request.form)
form.privacy_settings.choices = forms.privacy_setting_choices()
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
update_group = models.Group.get(group_id)
if update_group:
# TODO I wish form.populate_obj worked here, but it doesn't
update_group.description = form.description.data
update_group.member_limit = form.member_limit.data
update_group.privacy_setting_id = form.privacy_settings.data
update_group.anonymous = form.anonymous.data
update_group.age_range_id = (form.age_range.data.id if
form.age_range.data else None)
update_group.gender_focus = form.gender_focus.data
group_meet_times = []
for m in form.meet_times.data:
group_meet_time = models.GroupMeetTime(
group_id=group_id, meet_time_type_id=m.id)
group_meet_times.append(group_meet_time)
# NOTE: We can't just .clear(). It actually only sets
# the group_id column to NULL on each record for this user,
# then we issue N inserts after. Instead we can either
# 1) delete then insert
# 2) set math, delete if necessary, insert if necessary
# Considering there's no downside to deleting, and it's
# simpler, that's the approach below.
for mt in update_group.meet_times:
session.delete(mt)
update_group.meet_times.extend(group_meet_times)
update_group.group_type_id = (form.group_category.data.id
if form.group_category.data
else None)
session.add(update_group)
flask.flash('You successfully updated the group profile!',
'success')
else:
flask.flash('No group found to update', 'danger')
return flask.redirect(
flask.url_for('.show', group_id=group_id))
except Exception:
LOG.exception("Failed to update group profile for group "
"%s", group_id)
flask.flash('There was an error updating the group profile!',
'danger')
return flask.redirect(flask.url_for('.edit', group_id=group_id))
def email_leaders(_ctxt, group_id):
form = forms.GroupLeadersEmailForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
with models.transaction() as session:
group_users = 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(
sa.and_(
models.Group.id == group_id,
models.GroupRole.description ==
'Group Leader')).all()
subject = form.subject.data
# TODO: need to wrap this data in a cleaner (NEVER TRUST USER INPUT)
message = form.message.data
group_leader_emails = [u.email for u in group_users]
group_leader_emails = ','.join(group_leader_emails)
if not group_leader_emails:
flask.flash(
'There are not currently any group leaders for'
' this group. No message sent'
' Please try again shortly.', 'danger')
else:
try:
group = models.Group.get(group_id)
mail_content = {
'to': group_leader_emails,
'subject': subject,
'message': message,
'user': current_user,
'group': group
}
group_leaders_email = email.GroupLeadersEmail()
group_leaders_email.send(current_user.email,
group_leader_emails,
**mail_content)
flask.flash('You successfully sent your email message.',
'success')
except Exception:
LOG.exception("Error sending email to group leaders")
flask.flash(
'There was a problem sending your message.'
' Sorry for the inconvenience.'
' We will fix this as soon as we can.'
' Please try again shortly.', 'danger')
return flask.redirect(flask.url_for('.show', group_id=group_id))
def register_user_by_invite_create(_ctxt, token):
form = forms.RegisterForm(flask.request.form)
try:
invite_mail = email.OrgInviteNewMemberEmail()
content = invite_mail.decrypt_token(token)
address = content.get('mail_to')
if not address:
raise signature.InvalidSignature()
if address and users.is_existing_user(address):
raise exception.UserAlreadyExists(email=address)
except (signature.InvalidSignature, exception.MalformedToken):
LOG.exception('Error decrypting token')
flask.flash(
'Error occurred. Please try link in email again or'
' ask person to resend invite.', 'danger')
return flask.redirect(flask.url_for('index'))
except exception.UserAlreadyExists:
LOG.exception('User already exists')
flask.flash(
'A user is already registered for {}.'
' Please login instead.'.format(address), 'danger')
return flask.redirect(flask.url_for('login'))
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
else:
try:
user = app_utils.create_user_from_form(form)
helper.handle_invite(content, user)
except Exception:
LOG.exception("Failed to register user with email '%s'",
form.email.data)
models.Session.rollback()
flask.flash(
'There was an error getting you registered.'
' Please try again later.', 'danger')
return flask.redirect(flask.url_for('login'))
flask.flash("You've successfully registered.", 'success')
return flask.redirect(flask.url_for('login'))
form.email.data = address
form_url = flask.url_for('.register_user_by_invite_create', token=token)
context = {
'form': form,
'form_url': form_url,
'minyears': CONF.get("user.minyears")
}
return flask.render_template('register_after_email.html', **context)
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 meeting_create(_ctxt, group_id):
form = forms.GroupMeetingForm(flask.request.form)
group = models.Group.get(group_id)
if not group:
flask.flash('Group not found, please try again.', 'danger')
return flask.redirect(flask.url_for('index'))
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
cohosts = session.query(models.GroupMember).filter(
models.GroupMember.group_id == group_id).filter(
models.GroupMember.can_cohost_meeting == 1).all()
zoom = meeting.ZoomMeetingDriver()
meeting_info = {
'current_user': current_user,
'cohosts': cohosts,
'topic': form.topic.data,
'type': form.meeting_type.data,
'duration': form.duration.data,
'start_time': form.start_datetime.data
}
result = zoom.schedule_meeting(**meeting_info)
utc_meeting_start = helper.get_utc_date_time(
current_user.timezone, form.start_datetime.data)
with models.transaction() as session:
m = models.ZoomMeeting(
meeting_id=result['id'],
duration=form.duration.data,
meeting_start=utc_meeting_start,
repeat_type=form.meeting_type.data,
topic=form.topic.data,
start_url=result['start_url'],
join_url=result['join_url'],
repeat_end_date=form.repeat_end_date.data,
user_id=current_user.id,
group_id=group_id)
session.add(m)
flask.flash(
"You successfully created your meeting! "
"Your meeting ID is {}".format(m.meeting_id), 'success')
except Exception:
message = "Failed to create meeting for group {}".format(
group.name)
LOG.exception(message)
flask.flash(message, 'danger')
return flask.redirect(flask.url_for('.show', group_id=group_id))
def billing_update(_ctxt, org_id):
form = forms.LicenseUpdateForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
subscription_driver = subscription.ChargifyDriver(org_id)
result = subscription_driver.update_license_quantity(
org_id, form.quantity.data)
if result:
message = ("{} leader licenses now available to organizations"
" you have created.").format(form.quantity.data)
flask.flash(message, 'success')
else:
flask.flash("Please update your billing information first.",
'danger')
return flask.redirect(flask.url_for('.billing', org_id=org_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 new(_ctxt, org_id):
org = models.Organization.get(org_id)
if not current_user.can_add_group(org_id=org.id):
flask.flash("You can't add group.", 'danger')
return flask.redirect(
flask.url_for('users.show', user_id=current_user.id))
if not org.is_payed_up and not org.is_in_trial():
return helper.need_leaders(org.id)
form = forms.GroupNewForm(flask.request.form)
form.privacy_settings.choices = forms.privacy_setting_choices()
form.org.choices = helper.group_creation_org_choices(org_id)
form.org.data = org_id
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
elif not helper.unique_group_name(form.org.data, form.name.data):
flask.flash(
'{} is the name of another group in your organization.'
' Please try again.'.format(form.name.data), 'danger')
else:
try:
return helper.creation_workflow(form, org)
except Exception:
LOG.exception("Group creation failed for user id '%s'",
current_user.id)
context = {}
subscription_driver = subscription.ChargifyDriver(org_id)
available = org.available_licenses or org.is_in_trial()
if org.creator.id == current_user.id:
context['prices'] = subscription_driver.get_component_prices()
else:
if not available:
flask.flash(
"Your organization {} has no available Group leaders."
" Please contact {}".format(org.name,
org.creator.full_name_and_email),
'danger')
return flask.redirect(flask.url_for('orgs.edit', org_id=org_id))
context['available'] = available
context = {'form': form, 'org': org}
return flask.render_template('group/create.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 billing(_ctxt, org_id):
subscription_driver = subscription.ChargifyDriver(org_id)
org = models.Organization.get(org_id)
subscription_data = org.subscription_data
credit_card = subscription_data.get('credit_card')
card_info_form = forms.CardInfoForm(flask.request.form
or MultiDict(mapping=credit_card))
if flask.request.method == 'POST':
if not card_info_form.validate():
app_utils.flash_errors(card_info_form)
else:
if subscription_data:
if org.cancel_at_end_of_period:
subscription_driver.stop_cancellation(org_id)
result = subscription_driver.update_card_info(
org_id, card_info_form.data)
else:
result = subscription_driver.subscribe(current_user, org,
card_info_form.data)
if 'errors' in result:
for error in result['errors']:
flask.flash(error, 'danger')
else:
message = "Your card information has been safely stored."
flask.flash(message, 'success')
return flask.redirect(flask.request.path)
product_price = subscription_driver.get_product()['price_in_cents']
if credit_card:
card_info_form.full_number.data = credit_card['masked_card_number']
context = {
'user': current_user,
'org': org,
'wtforms': {
'card_info':
card_info_form,
'license_update':
forms.LicenseUpdateForm(quantity=org.purchased_licenses),
},
'prices': subscription_driver.get_component_prices(),
'product_price': product_price,
'quantity': org.group_leaders
}
return flask.render_template('organization/billing.html', **context)
def register_validation(_ctxt, token):
form = forms.RegisterForm(flask.request.form)
try:
reg_email = email.RegistrationEmail()
content = reg_email.decrypt_token(token)
address = content.get('mail_to', None)
if not address:
raise signature.InvalidSignature()
if address and users.is_existing_user(address):
raise exception.UserAlreadyExists(email=address)
form.email.default = address
except (signature.InvalidSignature, exception.MalformedToken):
flask.flash("Error occurred. Please restart registration process",
"danger")
return redirect(url_for("login"))
except exception.UserAlreadyExists:
flask.flash("A user is already registered for {}."
" Please login instead.".format(address), "danger")
return redirect(url_for("login"))
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
else:
try:
app_utils.create_user_from_form(form)
flask.flash("You've successfully registered."
" Please login to continue.",
'success')
return redirect(url_for('login'))
except Exception:
LOG.exception("Error creating user via token registration")
models.Session.rollback()
flask.flash("There was an error getting you registered."
" Please try again later.",
'danger')
return redirect(url_for('register'))
form.email.data = address
form_url = url_for("register_validation", token=token)
context = {
'form': form,
'form_url': form_url,
'minyears': CONF.get("user.minyears")
}
return render_template('register_after_email.html', **context)
def update(_ctxt, org_id):
form = forms.OrgForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
try:
with models.transaction() as session:
org_to_update = models.Organization.get(org_id)
helper.populate_org(org_to_update, form)
session.add(org_to_update)
flask.flash('You successfully updated the organization profile!',
'success')
except Exception:
LOG.exception('Failed to update org profile %s', org_id)
flask.flash(
'There was an error updating the organization '
'profile!', 'danger')
return flask.redirect(flask.url_for('.edit', org_id=org_id))
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 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 password_reset(_ctxt):
form = forms.PasswordResetForm(flask.request.form)
if not form.validate():
app_utils.flash_errors(form)
else:
password = form.password.data
user = models.User.get(current_user.id)
try:
with models.transaction() as session:
hashed_password = bcrypt.generate_password_hash(
password).decode('utf-8')
user.hashed_password = hashed_password
session.add(user)
flask.flash("Password reset successfully!", 'success')
except Exception:
LOG.exception("Password reset failed for user id '%s'",
current_user.id)
flask.flash("Error changing password.", 'danger')
return redirect(url_for('users.show', user_id=current_user.id))
def search(_ctxt):
form = forms.GroupSearchForm(flask.request.form)
if flask.request.method == 'POST':
if not form.validate():
app_utils.flash_errors(form)
else:
with models.transaction() as session:
groups_query = session.query(models.Group).join(
models.GroupPrivacySetting, models.Group.privacy_setting_id
== models.GroupPrivacySetting.id).join(
models.OrganizationGroup,
models.OrganizationGroup.group_id ==
models.Group.id).join(
models.Organization, models.Organization.id ==
models.OrganizationGroup.organization_id).join(
models.Address, models.Address.id ==
models.Organization.address_id)
# TODO Seeing a lot of this pattern. We should consider mapping
# forms -> models. Django serializers ish?
form_pairs = {
"name": models.Group.name,
"city": models.Address.city,
"state": models.Address.state,
"zip_code": models.Address.zip_code,
"group_category": models.GroupType.description,
"gender_focus": models.Group.gender_focus,
"age_range": models.AgeRange.description
}
for form_field, model_field in form_pairs.items():
form_data = getattr(form, form_field).data
if form_data:
groups_query = groups_query.filter(
model_field.like("{}%".format(form_data)))
groups_query = groups_query.filter(
models.GroupPrivacySetting.description.like("Public%"))
groups_query = groups_query.filter(
models.Group.archived_at.is_(None))
all_groups = groups_query.order_by(models.Group.name).all()
return flask.render_template('group/search.html',
form=form,
groups=all_groups)
return flask.render_template('group/search.html', form=form)
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))
