Python Session.urlsafe方法代码示例

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
    def _createSessionObject(self, request):
        """Create or update Session object, returning SessionForm/request."""
        # Load user data and check to see if authorized
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        user_id = user.email()

        # Check that Session name exists
        if not request.name:
            raise endpoints.BadRequestException("Session 'name' field required")
        # Check that Session speaker's name exists
        if not request.speaker:
            raise endpoints.BadRequestException("Session 'speaker' field required")

        # Copy SessionForm/ProtoRPC message into dictionary
        data = {field.name: getattr(request, field.name) for field in request.all_fields()}
        data['conference'] = ndb.Key(urlsafe=request.websafeConferenceKey)
        del data['websafeConferenceKey']
        del data['sessionKey']

        # Convert date from string to date object
        if data['startDate']:
            data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").date()

        # Create Session
        new_key = Session(**data).put()

        # Add get_featured_speaker to task queue
        taskqueue.add(params={'conferenceKey': request.websafeConferenceKey,
                              'speaker': data['speaker']},
                      url='/tasks/get_featured_speaker')

        request.sessionKey = new_key.urlsafe()
        return self._copySessionToForm(request)

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
    def _createSessionObject(self, request):
        """Create or update Session object, returning SessionForm/request."""
        # preload necessary data items
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        if not request.name:
            raise endpoints.BadRequestException("Session 'name' field required")

        # check the user is the owner of the conference
        user_id = getUserId(user)
        conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
        if user_id != conf.organizerUserId:
            raise endpoints.ForbiddenException(
                'Only the conference organizer can create sessions.')

        # copy SessionForm/ProtoRPC Message into dict
        data = {field.name: getattr(request, field.name) for field in request.all_fields()}
        data['conference'] = ndb.Key(urlsafe=request.websafeConferenceKey)
        del data['websafeConferenceKey']
        del data['sessionKey']

        # convert dates from strings
        try:
            data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").date()
        except Exception:
            raise ValueError("'startDate' required in this format (year-month-day)")

        try:
            data['startTime'] = datetime.strptime(data['startTime'], '%H:%M').time()
        except Exception:
            raise ValueError("'startTime' needed: '%H:%M' ")

        # check if duration is an integer
        try:
            data['duration'] = int(data['duration'])
        except Exception:
            raise ValueError("'duration' required and has to be a number.")

        # creation of Session and return SessionForm
        new_key = Session(**data).put()
        request.sessionKey = new_key.urlsafe()

        # Check to see if the speaker is present in more than one
        # session and if it is then add a task queue
        speaker_sessions = Session.query(Session.speaker == data['speaker']).count()
        if speaker_sessions > 1:
            taskqueue.add(params={'speaker': data['speaker'],
                          'websafeConferenceKey': request.websafeConferenceKey},
                          url='/tasks/set_featured_speaker'
                          )

        return self._copySessionToForm(request)

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
    def createSession(self, request):
        """Create Session object, returning SessionForm/request."""

        # Make sure user is logged in
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException("Authorization required")
        user_id = getUserId(user)

        # Get conference
        conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
        if not conf:
            raise endpoints.NotFoundException("No conference found with key: %s" % request.websafeConferenceKey)

        # Is the user not the organizer of the conference?  Send an Unauthorized exception
        if conf.organizerUserId != user_id:
            raise endpoints.UnauthorizedException(
                "You are not authorized to create a session for this conference, %s" % conf.organizerUserId
            )

        # copy SessionForm/ProtoRPC Message into dict
        data = {field.name: getattr(request, field.name) for field in request.all_fields()}
        del data["websafeKey"]
        del data["websafeSessionKey"]

        # Set conferenceName
        data["conferenceName"] = conf.name

        # convert dates from strings to Date objects; set month based on start_date
        if data["date"]:
            data["date"] = datetime.strptime(data["date"][:10], "%Y-%m-%d").date()

        # create Session
        sess_key = Session(**data).put()

        # Get created session
        sess = ndb.Key(urlsafe=sess_key.urlsafe()).get()

        # Does speaker have more than one session at this conference?  Set up a task to
        # set them as the featured speaker
        speakerSessions = Session.query(
            Session.speaker == data["speaker"], Session.websafeConferenceKey == request.websafeConferenceKey
        )
        if speakerSessions.count() > 1:
            taskqueue.add(
                params={"speaker": data["speaker"], "sessions": ", ".join([s.name for s in speakerSessions])},
                url="/tasks/set_featured_speaker",
            )

        return self._copySessionToForm(sess)

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
    def _createSessionObject(self, request):
        """Create or update session object, returning SessionForm/request."""
        # preload necessary data items
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        user_id = getUserId(user)

        if not request.name:
            raise endpoints.BadRequestException("Session 'name' field required")  # noqa

        conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
        if not conf:
            raise endpoints.NotFoundException('No conference found with key: %s' % request.websafeConferenceKey)  # noqa

        if user_id != conf.organizerUserId:
            raise endpoints.ForbiddenException("Only the owner can create a conference's session.")  # noqa

        data = {field.name: getattr(request, field.name)
                for field in request.all_fields()}
        del data['websafeConferenceKey']
        del data['sessionKey']

        # convert dates from strings to Date objects
        if data['date']:
            data['date'] = datetime.strptime(data['date'][:10],
                                             "%Y-%m-%d").date()

        # convert from strings to Time objects
        if data['startTime']:
            data['startTime'] = datetime.strptime(data['startTime']
                                                  [:5], "%H:%M").time()

        # generate Conference Key based on parent/child relationship
        c_key = conf.key
        s_id = Session.allocate_ids(size=1, parent=c_key)[0]
        s_key = ndb.Key(Session, s_id, parent=c_key)
        data['key'] = s_key

        # create Session
        new_key = Session(**data).put()
        taskqueue.add(params={'speaker': data['speaker'],
                      'websafeConferenceKey': request.websafeConferenceKey},
                      url='/tasks/set_featured_speaker')
        request.sessionKey = new_key.urlsafe()
        return self._copySessionToForm(s_key.get())

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
 def test_addSessionToWishlist(self):
     # Check that no profiles exist in datastore
     prof = Profile.query().get()
     self.assertEqual(prof, None)
     # Create conference and get websafe key
     conf = Conference(name='Test_conference')
     wck = conf.put()
     # Add a session
     props = {'name': 'Monkey Business', 'date': date(2015,8,8),
              'parent': wck, 'conferenceKey': wck.urlsafe(),
              'typeOfSession': 'lecture', 'startTime': time(18,15)}
     sk = Session(speaker=['Sarah', 'Frodo'], **props).put()
     # Test the endpoint (This also creates a Profile record)
     url = '/wishlist/{0}'.format(sk.urlsafe())
     res = urlfetch.fetch(self.urlbase + url, method='POST')
     self.assertEqual(res.status_code, 200)
     self.assertTrue(json.loads(res.content)['data'])
     sleep(0.1)
     # Get profile and check for one session key
     prof = Profile.query().get()
     self.assertEqual(len(prof.sessionKeysToAttend), 1)

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
    def _createSessionObject(self, request):
        """Create or update Session object, returning SessionForm/request."""

        if not request.name or not request.speaker:
            raise endpoints.BadRequestException("Session 'name' and 'speaker' fields required")

        # copy SessionForm/ProtoRPC Message into dict
        data = {field.name: getattr(request, field.name) for field in request.all_fields()}
        data['conference'] = ndb.Key(urlsafe=request.websafeConferenceKey)
        del data['websafeConferenceKey']
        del data['sessionKey']

        # convert dates from strings
        try:
            data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").date()
        except Exception:
            raise ValueError("'startDate' needed. Cannot be void or in the wrong format (year-month-day)")

        try:
            data['startTime'] = datetime.strptime(data['startTime'], '%H:%M').time()
        except Exception:
            raise ValueError("'startTime' needed: '%H:%M' ")

        # check if duration is an integer
        try:
            data['duration'] = int(data['duration'])
        except Exception:
            raise ValueError("'duration' needed. Has to be an integer (minutes) and cannot be void")

        # creation of Session & return (modified) SessionForm
        new_key = Session(**data).put()

        taskqueue.add(params={'conferenceKey': request.websafeConferenceKey,
            'speaker': data['speaker']},
            url='/tasks/get_featured_speaker'
        )

        request.sessionKey = new_key.urlsafe()
        return self._copySessionToForm(request)

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
 def test_getSessionsInWishlist(self):
     # Create conference and get websafe key
     conf = Conference(name='Test_conference')
     wck = conf.put()
     # Add a session
     props = {'name': 'Monkey Business', 'date': date(2015,8,8),
              'parent': wck, 'conferenceKey': wck.urlsafe(),
              'typeOfSession': 'lecture', 'startTime': time(18,15)}
     sk = Session(speaker=['Sarah', 'Frodo'], **props).put()
     # Have endpoint create default Profile record
     res = urlfetch.fetch(self.urlbase + '/profile')
     self.assertEqual(res.status_code, 200)
     sleep(0.1)
     # Create profile with session key in wishlist
     profile = Profile.query().get()
     profile.sessionKeysToAttend = [sk.urlsafe()]
     profile.put()
     # Test the endpoint
     url = '/wishlist/{0}'.format(wck.urlsafe())
     res = urlfetch.fetch(self.urlbase + url, method='GET')
     self.assertEqual(res.status_code, 200)
     # Test if one entry in returned items list
     self.assertEqual(len(json.loads(res.content)['items']), 1)

# 需要导入模块: from models import Session [as 别名]
# 或者: from models.Session import urlsafe [as 别名]
    def _createSessionObject(self, request):
        """Create or update Session object, returning SessionForm/request."""
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        user_id = getUserId(user)

        # add session to existing conference
        # check that conference exists
        c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
        conf = c_key.get()
        if not conf:
            raise endpoints.NotFoundException(
                'No conference found with key: %s' % request.websafeConferenceKey)   

        # check that user is owner
        if user_id != conf.organizerUserId:
            raise endpoints.ForbiddenException(
                'Only the owner can add sessions to the conference.')

        # copy SessionForm/ProtoRPC Message into dict
        data = {field.name: getattr(request, field.name) for field in request.all_fields()}
        del data['websafeConferenceKey']
        del data['conferenceWebSafeKey']
        del data['sessionWebSafeKey']

        # add default values for those missing (both data model & outbound Message)
        for df in DEFAULTS_SESSION:
            if data[df] in (None, []):
                data[df] = DEFAULTS_SESSION[df]
                setattr(request, df, DEFAULTS_SESSION[df])

        # convert dates from strings to Date objects;
        if data['date']:
            data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()

        # convert time from string to Datetime object
        if data['startTime']:
            data['startTime'] = datetime.strptime(data['startTime'][:10], "%H:%M").time()

        # generate Session ID and Key based on parent's conference Key
        s_id = Session.allocate_ids(size=1, parent=c_key)[0]
        s_key = ndb.Key(Session, s_id, parent=c_key)
        data['key'] = s_key

        
        # create Session, add session key to speaker's 
        # & return (modified) SessionForm
        # creation of Session 
        sess = Session(**data).put()

        # Gather all sessions by this speaker
        if len(data['speakerEmail']) > 0:
            speakerEmail = str(data['speakerEmail'])
            speakerSessions = Session.query(ancestor=ndb.Key(urlsafe=request.websafeConferenceKey))
            speakerSessions = speakerSessions.filter(Session.speakerEmail == speakerEmail)

            #If more than 1 session, then make featured speaker
            if speakerSessions.count() > 1:
                # Lookup Speaker name
                speaker = ndb.Key(Speaker, data['speakerEmail']).get()
                # Set the featured speaker and sessions in taskqueue
                taskqueue.add(params={'speakerEmail': speakerEmail,
                    'speakerName': speaker.displayName},
                    url='/tasks/check_featured_speaker'
                )

        # add session key to speaker's entity
        if data["speakerEmail"]:
            speak = ndb.Key(Speaker, data["speakerEmail"]).get()
            speak.sessionKeysToAttend.append(str(sess.urlsafe()))
            speak.put()

        return self._copySessionToForm(s_key.get())