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 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 email_org(_ctxt, org_id):
form = forms.MassEmailForm(flask.request.form)
subject = form.subject.data
message = form.message.data
if form.recipient.data != "all":
LOG.info("Sending email to %s", form.recipient.data)
user = models.User.get(form.recipient.data)
org_member_emails = user.email
else:
org_member_emails = ''
org_users = helper.get_users(org_id, emails=True)
for user, _ in org_users:
org_member_emails += user.email + ', '
# TODO: need to wrap this data in a cleaner (NEVER TRUST USER INPUT)
if not org_member_emails:
flask.flash('There was an error sending this email.')
else:
try:
org = models.Organization.get(org_id)
mail_content = {
'to': org_member_emails,
'subject': subject,
'message': message,
'user': current_user,
'org': org
}
org_mass_email = email.OrgMassEmail()
org_mass_email.send(current_user.email, org_member_emails,
**mail_content)
LOG.info("Sending email to %s", org_member_emails)
flask.flash('You successfully sent your email message.', 'success')
except Exception:
LOG.exception("Error sending email to group")
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', org_id=org_id))
def email_group(_ctxt, group_id):
form = forms.MassEmailForm(flask.request.form)
subject = form.subject.data
message = form.message.data
if form.recipient.data != "all":
LOG.info("Sending email to %s", form.recipient.data)
user = models.User.get(form.recipient.data)
group_member_emails = user.email
else:
group_member_emails = ''
group_users = helper.get_users(group_id, emails=True)
for user, _, _ in group_users:
group_member_emails += user.email + ', '
if not group_member_emails:
flask.flash('There was an error sending this email.')
else:
try:
group = models.Group.get(group_id)
mail_content = {
'to': group_member_emails,
'subject': subject,
'message': message,
'user': current_user,
'group': group
}
group_mass_email = email.GroupMassEmail()
group_mass_email.send(current_user.email, group_member_emails,
**mail_content)
flask.flash('You successfully sent your email message.', 'success')
except Exception:
LOG.exception("Error sending email to group")
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 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)