def _handle_parameters(self): response = self.request.response # Make sure the _LOCATION_ cookie is correctly set: The old version GUI # version used to store the map center and the zoom level which is not # understood by new GUI (which stores the map extent as 4 coordinates) if '_LOCATION_' in self.request.cookies: c = urllib.unquote(self.request.cookies['_LOCATION_']) if len(c.split('|')) == 3: response.delete_cookie('_LOCATION_') # Check if language (_LOCALE_) is set if self.request is not None: if '_LOCALE_' in self.request.params: response.set_cookie('_LOCALE_', self.request.params.get( '_LOCALE_'), timedelta(days=90)) elif '_LOCALE_' in self.request.cookies: pass # Check if profile (_PROFILE_) is set if self.request is not None: if '_PROFILE_' in self.request.params: # Set the profile cookie profile_code = self.request.params.get('_PROFILE_') response.set_cookie( '_PROFILE_', profile_code, timedelta(days=90)) # Update _LOCATION_ from cookies to profile geometry bbox # retrieved from database profile_db = DBSession.query(Profile).\ filter(Profile.code == profile_code).\ first() if profile_db is not None: # Calculate and transform bounding box bbox = DBSession.scalar(geofunctions.envelope( geofunctions.transform( profile_db.geometry, '900913')).wkt) geojson = utils.from_wkt(bbox) coords = geojson['coordinates'][0] p1 = coords[0] p2 = coords[2] l = '%s,%s' % (','.join([str(x) for x in p1]), ','.join([str(x) for x in p2])) response.set_cookie( '_LOCATION_', urllib.quote(l), timedelta(days=90)) elif '_PROFILE_' in self.request.cookies: # Profile already set, leave it pass else: # If no profile is set, set the default profile response.set_cookie('_PROFILE_', get_default_profile( self.request), timedelta(days=90))
def get_current_profile(request): """ Return the currently selected :term:`Profile`. First, parameters in the request are considered. If no parameter is set, the profile cookie is used. As a fallback, the default profile is returned. .. seealso:: :class:`lmkp.views.config.get_default_profile` Args: ``request`` (pyramid.request): A :term:`Pyramid` Request object with optional parameter ``_PROFILE_`` or a cookie ``_PROFILE_`` set. Returns: ``str``. The name of the :term:`Profile` or the default profile. """ return request.params.get( '_PROFILE_', request.cookies.get( '_PROFILE_', get_default_profile(request)))
def activate(self): """ """ activation_uuid = self.request.params.get("uuid") username = self.request.params.get("username") # Get the user user = Session.query(User).filter(and_( User.activation_uuid == activation_uuid, User.username == username, User.is_active == False)).first() # Raise a BadRequest if no user is found if user is None: raise HTTPBadRequest() # A timedelta of 48 hours equals 2 days delta = timedelta(hours=48) # Create a timezone info tz = psycopg2.tz.FixedOffsetTimezone(offset=0, name="UTC") # Check if the registration timestamp is not older than 48 hours if (datetime.now(tz) - delta) > user.registration_timestamp: raise HTTPBadRequest("Activation link has been expired.") # Set the user active and set the activation uuid to NULL user.is_active = True user.activation_uuid = None approval_dict = { "username": user.username, "firstname": user.firstname, "lastname": user.lastname, "email": user.email, "profiles": ",".join([p.code for p in user.profiles]), "approval_link": "http://%s/users/approve?user=%s&name=%s" % ( self.request.environ['HTTP_HOST'], user.uuid, user.username) } # Send an email to all moderators of the profile in which the user # registered. email_text = render( get_customized_template_path( self.request, 'emails/account_approval_request.mak'), approval_dict, request=self.request) # Determine profile. Each user should only have one profile when # registering! profiles = [p.code for p in user.profiles] if len(profiles) == 0: profile = get_default_profile(self.request) else: profile = profiles[0] # Find moderators of this profile moderators = Session.query(User).\ join(users_groups).\ join(Group).\ join(users_profiles).\ join(Profile).\ filter(Group.name == 'moderators').\ filter(Profile.code == profile) # A list with email addresses the email is sent to email_addresses = [] for m in moderators.all(): email_addresses.append(m.email) if len(email_addresses) == 0: # If no moderator, try to contact the administrators for admin_user in Session.query(User).join(users_groups).join( Group).filter(func.lower(Group.name) == 'administrators'): email_addresses.append(admin_user.email) log.debug( "No moderator found for profile %s. Approval emails will be " "sent to administrators: %s" % (profile, email_addresses)) else: log.debug( "Approval emails will be sent to moderators of %s profile: %s" % (profile, email_addresses)) # Send the email self._send_email( email_addresses, "User %s requests approval" % user.username, email_text) return render_to_response( get_customized_template_path( self.request, 'users/activation_successful.mak'), { 'username': user.username }, self.request)