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