def update_about_us_page_setting(self,
args) -> (dict, MassEnergizeAPIError):
about_us_page_setting, err = self.store.update_about_us_page_setting(
args)
if err:
return None, err
return serialize(about_us_page_setting), None
def list_about_us_page_settings(
self, about_us_page_setting_id) -> (list, MassEnergizeAPIError):
about_us_page_setting, err = self.store.list_about_us_page_settings(
about_us_page_setting_id)
if err:
return None, err
return serialize(about_us_page_setting), None
def create_user(self, context: Context,
args) -> Tuple[dict, MassEnergizeAPIError]:
res, err = self.store.create_user(context, args)
if err:
return None, err
community = res["community"]
user = res["user"]
community_name = community.name if community else "Global Massenergize Community"
community_logo = community.logo.file.url if community and community.logo else 'https://s3.us-east-2.amazonaws.com/community.massenergize.org/static/media/logo.ee45265d.png'
subdomain = community.subdomain if community else "global"
subject = f'Welcome to {community_name}, a MassEnergize community'
homelink = f'{COMMUNITY_URL_ROOT}/{subdomain}'
content_variables = {
'name': user.preferred_name,
'community': community_name,
'homelink': homelink,
'logo': community_logo,
'actionslink': f'{homelink}/actions',
'eventslink': f'{homelink}/events',
'serviceslink': f'{homelink}/services',
'privacylink': f"{homelink}/policies?name=Privacy%20Policy"
}
send_massenergize_rich_email(subject, user.email,
'user_registration_email.html',
content_variables)
return serialize(user, full=True), None
def delete_tag_collection(
self, tag_collection_id) -> Tuple[dict, MassEnergizeAPIError]:
tag_collection, err = self.store.delete_tag_collection(
tag_collection_id)
if err:
return None, err
return serialize(tag_collection), None
def message_admin(self, context, args) -> (dict, MassEnergizeAPIError):
admins, err = self.store.message_admin(context, args)
if err:
return None, err
# dont want to send emails all the time, just show up in the admin site and if they want they can send emails
# need to define a send email function
return serialize(admins), None
def message_admin(self, context,
args) -> Tuple[dict, MassEnergizeAPIError]:
message_info, err = self.message_store.message_team_admin(
context, args)
if err:
return None, err
return serialize(message_info), None
def get_community_info(self, context, args) -> (dict, MassEnergizeAPIError):
community, err = self.store.get_community_info(context, args)
if err:
return None, err
#send an email to the community admin
return serialize(community, full=True), None
def update_tag_collection(self, tag_collection_id,
args) -> (dict, MassEnergizeAPIError):
tag_collection, err = self.store.update_tag_collection(
tag_collection_id, args)
if err:
return None, err
return serialize(tag_collection), None
def get_tag_collection_info(
self, tag_collection_id) -> (dict, MassEnergizeAPIError):
tag_collection, err = self.store.get_tag_collection_info(
tag_collection_id)
if err:
return None, err
return serialize(tag_collection), None
def delete_actions_page_setting(self,
args) -> (dict, MassEnergizeAPIError):
actions_page_setting, err = self.store.delete_actions_page_setting(
args)
if err:
return None, err
return serialize(actions_page_setting), None
def delete_testimonial(self, context,
testimonial_id) -> (dict, MassEnergizeAPIError):
testimonial, err = self.store.delete_testimonial(
context, testimonial_id)
if err:
return None, err
return serialize(testimonial), None
def create_subscriber(self, community_id,
args) -> Tuple[dict, MassEnergizeAPIError]:
subscriber, err = self.store.create_subscriber(community_id, args)
if err:
return None, err
subject = 'Thank you for subscribing'
content_variables = {
'name':
subscriber.name,
'id':
subscriber.id,
'logo':
subscriber.community.logo.file.url
if subscriber.community and subscriber.community.logo else
'https://s3.us-east-2.amazonaws.com/community.massenergize.org/static/media/logo.ee45265d.png',
'community':
subscriber.community.name if subscriber.community
and subscriber.community.name else 'MassEnergize',
'homelink':
'%s/%s' % (COMMUNITY_URL_ROOT, subscriber.community.subdomain)
if subscriber.community else COMMUNITY_URL_ROOT
}
send_massenergize_rich_email(subject, subscriber.email,
'subscriber_registration_email.html',
content_variables)
return serialize(subscriber), None
def get_actions_page_setting_info(self,
args) -> (dict, MassEnergizeAPIError):
actions_page_setting, err = self.store.get_actions_page_setting_info(
args)
if err:
return None, err
return serialize(actions_page_setting), None
def get_community_info(self, context,
args) -> Tuple[dict, MassEnergizeAPIError]:
community, err = self.store.get_community_info(context, args)
if err:
return None, err
return serialize(community, full=True), None
def list_home_page_settings(
self, home_page_setting_id) -> Tuple[list, MassEnergizeAPIError]:
home_page_setting, err = self.store.list_home_page_settings(
home_page_setting_id)
if err:
return None, err
return serialize(home_page_setting), None
def get_home_page_setting_info(self, context,
args) -> Tuple[dict, MassEnergizeAPIError]:
home_page_setting, err = self.store.get_home_page_setting_info(
context, args)
if err:
return None, err
return serialize(home_page_setting, full=True), None
def create_community(self,context, args) -> (dict, MassEnergizeAPIError):
community, err = self.store.create_community(context, args)
if err:
return None, err
# send all emails
return serialize(community), None
def leave_community(self, context: Context, args) -> (dict, MassEnergizeAPIError):
user, err = self.store.leave_community(context, args)
if err:
return None, err
#send an email to the community admin
return serialize(user, full=True), None
def join_community(self, context: Context,
args) -> (dict, MassEnergizeAPIError):
community, err = self.store.join_community(context, args)
if err:
return None, err
#send an email to the community admin
return serialize(community), None
def get_carbon_equivalencies(self,
args) -> Tuple[dict, MassEnergizeAPIError]:
carbon_data, err = self.store.get_carbon_equivalencies(args)
if err:
return None, err
if type(carbon_data) == QuerySet:
return serialize_all(carbon_data), None
else:
return serialize(carbon_data), None
def create_goal(self, community_id, team_id, user_id, args) -> Tuple[dict, MassEnergizeAPIError]:
#validate the args
ok, err = self.validate(args)
if not ok:
return None, CustomMassenergizeError(err)
goal, err = self.store.create_goal(community_id, team_id, user_id, args)
if err:
return None, err
return serialize(goal), None
def create_team(self, context, args) -> (dict, MassEnergizeAPIError):
team, err = self.store.create_team(context, args)
if err:
return None, err
# within store.create_team, an e-mail was sent to the community admin
#
# TODO: the following functionality is needed
# message to the effect that you have been named as a team admin
#message_info, err = self.message_store.message_team_admin(context, args)
#
# message to community admins that a team was created (needs to be recorded in admin portal because the e-mail may be lost)
#message_info, err = self.message_store.message_admin(context, args)
return serialize(team), None
def login(self, context: Context):
# This does the same work as verify
try:
args = context.args or {}
firebase_id_token = args.get('idToken', None)
if firebase_id_token:
decoded_token = auth.verify_id_token(firebase_id_token)
user_email = decoded_token.get("email")
user = UserProfile.objects.filter(email=user_email).first()
if (not user):
# there is a case where user is authenticated with firebase but
# does has not completed a massenergize registration form
# to sign up in our system
return None, None, CustomMassenergizeError(
"authenticated_but_needs_registration")
if context.is_admin_site and not (user.is_super_admin
or user.is_community_admin):
raise PermissionError
payload = {
"user_id": str(user.id),
"email": user.email,
"is_super_admin": user.is_super_admin,
"is_community_admin": user.is_community_admin,
"iat": decoded_token.get("iat"),
"exp": decoded_token.get("exp"),
}
massenergize_jwt_token = jwt.encode(
payload, SECRET_KEY, algorithm='HS256').decode('utf-8')
return serialize(user,
full=True), str(massenergize_jwt_token), None
else:
return None, None, CustomMassenergizeError("invalid_auth")
except PermissionError:
capture_message("not_an_admin", level="error")
return None, None, CustomMassenergizeError('not_an_admin')
except Exception as e:
capture_message("Authentication Error", level="error")
return None, None, CustomMassenergizeError(e)
def add_super_admin(self, context, args) -> (dict, MassEnergizeAPIError):
admin, err = self.store.add_super_admin(context, args)
if err:
return None, err
subject = 'Welcome to the MassEnergize Team'
content_variables = {
'name':
admin.full_name,
'adminlink':
ADMIN_URL_ROOT,
'admintype':
'Super',
'admintext':
"Now that you are a super admin, you have access the MassEnergize admin website at %s. You have full control over the content of our sites, can publish new communities and add new admins"
% (ADMIN_URL_ROOT)
}
send_massenergize_rich_email(subject, admin.email,
'new_admin_email.html', content_variables)
return serialize(admin, full=True), None
def message_admin(self, context,
args) -> Tuple[dict, MassEnergizeAPIError]:
message, err = self.store.message_admin(context, args)
if err:
return None, err
# Original comment: dont want to send emails all the time, just show up in the admin site and if they want they can send emails
# Now community admins are requesting e-mail messages. We don't have contact preferences defined yet but will do that.
# For now, send e-mail to primary community contact for a site
admin_email = message.community.owner_email
admin_name = message.community.owner_name
first_name = admin_name.split(" ")[0]
if not first_name or first_name == "":
first_name = admin_name
subject = 'A message was sent to the Community Admin for ' + message.community.name
content_variables = {
'name': first_name,
'message_url': f"{ADMIN_URL_ROOT}/admin/edit/{message.id}/message",
"community_name": message.community.name,
"from_name": message.user_name,
"email": message.email,
"subject": message.title,
"message_body": message.body,
}
send_massenergize_rich_email(subject, admin_email,
'contact_admin_email.html',
content_variables)
send_slack_message(
SLACK_COMMUNITY_ADMINS_WEBHOOK_URL, {
"from_name": message.user_name,
"email": message.email,
"subject": message.title,
"message": message.body,
"url": f"{ADMIN_URL_ROOT}/admin/edit/{message.id}/message",
"community": message.community.name
})
return serialize(message), None
def whoami(self, context: Context):
try:
user_id = context.user_id
user_email = context.user_email
user = None
if user_id:
user = UserProfile.objects.get(pk=user_id)
elif user_email:
user = UserProfile.objects.get(pk=user_email)
if user and context.is_admin_site and not (
user.is_super_admin or user.is_community_admin):
raise PermissionError
return serialize(user, full=True), None
except Exception as e:
capture_message(str(e), level="error")
return None, CustomMassenergizeError(e)
def create_tag_collection(self, args) -> Tuple[dict, MassEnergizeAPIError]:
tag_collection, err = self.store.create_tag_collection(args)
if err:
return None, err
return serialize(tag_collection), None
def copy_policy(self, policy_id) -> Tuple[dict, MassEnergizeAPIError]:
policy, err = self.store.copy_policy(policy_id)
if err:
return None, err
return serialize(policy), None
def update_policy(self, policy_id,
args) -> Tuple[dict, MassEnergizeAPIError]:
policy, err = self.store.update_policy(policy_id, args)
if err:
return None, err
return serialize(policy), None
def create_policy(self, community_id,
args) -> Tuple[dict, MassEnergizeAPIError]:
policy, err = self.store.create_policy(community_id, args)
if err:
return None, err
return serialize(policy), None
