def initialize_redis(): global redis redis = None # Get the credentials from the Bluemix environment if 'VCAP_SERVICES' in os.environ: app.logger.info("Using VCAP_SERVICES...") VCAP_SERVICES = os.environ['VCAP_SERVICES'] services = json.loads(VCAP_SERVICES) creds = services['rediscloud'][0]['credentials'] app.logger.info("Conecting to Redis on host %s port %s" % (creds['hostname'], creds['port'])) redis = connect_to_redis(creds['hostname'], creds['port'], creds['password']) else: app.logger.info( "VCAP_SERVICES not found, checking localhost for Redis") redis = connect_to_redis('127.0.0.1', 6379, None) if not redis: app.logger.info("No Redis on localhost, using: redis") redis = connect_to_redis('redis', 6379, None) if not redis: # if you end up here, redis instance is down. app.logger.error( '*** FATAL ERROR: Could not connect to the Redis Service') # Have the Wishlist model use Redis Wishlist.use_db(redis)
def _createWishlistObject(self, request): """Create Wishlist object, returning WishlistForm/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.websafeSessionKey: raise endpoints.BadRequestException( "Session 'websafeSessionKey' field required") # copy WishlistForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } data['user'] = user_id p_key = ndb.Key(Profile, user_id) w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) data['key'] = w_key Wishlist(**data).put() return request
def addSessionToWishlist(self, request): """ Add a session to the current user's Wishlist """ # get current user user = endpoints.get_current_user() user_id = getUserId(user) p_key = ndb.Key(Profile, user_id) try: # get the session to be wishlisted session = ndb.Key(urlsafe=request.websafeSessionKey).get() except ProtocolBufferDecodeError: raise endpoints.NotFoundException( 'No session found with key: %s' % request.websafeSessionKey) # first try to find wishlist of the current user wishlist = Wishlist.query(ancestor=p_key).get() if not wishlist: # create a wishlist if nothing was found wishlist = Wishlist(userId = user_id) w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) # Add session key to wishlist wishlist.sessionKey.append(session.key) wishlist.put() # Update the session wishlist counter session.wishlistCount += 1 session.put() return self._copyWishlistToForm(wishlist)
def _getProfileFromUser(self): """Return user Profile from datastore, creating new one if non-existent.""" # make sure user is authed user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # get Profile from datastore user_id = getUserId(user) p_key = ndb.Key(Profile, user_id) profile = p_key.get() # create new Profile if not there if not profile: profile = Profile( key = p_key, displayName = user.nickname(), mainEmail= user.email(), teeShirtSize = str(TeeShirtSize.NOT_SPECIFIED), ) w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) wishlist = Wishlist( key = w_key, sessionKeys = [] ) profile.put() wishlist.put() return profile # return Profile
def _createWishlistObject(self, request): """Create or update Wishlist object, returning WishlistForm/request.""" user_id = self._getUser() p_key = self._getUserProfileKey(user_id) wssk = request.websafeSessionKey sess = ndb.Key(urlsafe=wssk).get() if not sess: raise endpoints.NotFoundException("No session found with key: %s" % wssk) w = {} # Create a unique key w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) w["key"] = w_key # Check for an existing wishlist wish = Wishlist.query(ancestor=p_key).get() # If there is already a wishlist record, append this session to it, # otherwise create a new wishlist (unless its already in the wishlist) if not wish: w["sessions"] = [wssk] Wishlist(**w).put() elif wssk in wish.sessions: raise ConflictException("You have already placed this session in your wishlist") else: wish.sessions.append(wssk) wish.put() w["sessions"] = [self._retrieveSession(cs_id) for cs_id in wish.sessions] return self.toWishlistForm(w)
def _createWishlistObject(self, request): """Create Wishlist object, returning WishlistForm/request.""" # as usual make sure user is logged in user = self._getAuthUser() user_id = getUserId(user) data = {field.name: getattr(request, field.name) for field in request.all_fields()} sess = ndb.Key(urlsafe=request.websafeSessionKey).get() p_key = ndb.Key(Profile, user_id) q = Wishlist.query(ancestor=p_key). \ filter(Wishlist.websafeSessionKey==request.websafeSessionKey).get() if q: raise endpoints.BadRequestException('Session already in Wishlist') data['sessionName'] = sess.name data['userId'] = user_id data['duration'] = sess.duration # create Wishlist key with logged in user as the parent w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) data['key'] = w_key # create Wishlist entry wishlist = Wishlist(**data) wishlist.put() return self._copyWishlistToForm(wishlist)
def _createWishlistObject(self, request): """ Create or update Wishlist object, returning WishlistForm """ # Preload and validate necessary data items user = self.get_authed_user() user_id = getUserId(user) prof_key = ndb.Key(Profile, user_id) if not request.websafeKey: raise endpoints.BadRequestException('Session websafeKey required') session = ndb.Key(urlsafe=request.websafeKey) if not session: raise endpoints.NotFoundException( 'No session found with key: {}'.format(request.websafeKey)) # copy WishlistForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } del data['websafeKey'] sess_key = ndb.Key(urlsafe=request.websafeKey) data['session'] = sess_key wishlist_id = Wishlist.allocate_ids(size=1, parent=prof_key)[0] wishlist_key = ndb.Key(Wishlist, wishlist_id, parent=prof_key) data['key'] = wishlist_key Wishlist(**data).put() return self._copyWishlistToForm(wishlist_key.get())
def _getWithlistByUserId(self, user_id): wishlist_key = ndb.Key(Wishlist, user_id) wishlist = wishlist_key.get() if not wishlist: wishlist = Wishlist(key=wishlist_key) wishlist.put() return wishlist
def _makeWishlist(self): user = self._getProfileFromUser() parent_key = user.key new_wish_list = Wishlist(parent=parent_key) # set user_id (mainEmail) for ease of query new_wish_list.userId = user.mainEmail # set wish list as child of current profile new_wish_list.put()
def get_wishlist_list(): """ Returns the Wishlists by searching the keywords of wishlist_name or the customer_id. This function returns a wishlist based on wishlist_name or customer id. If the customer_id and the wishlist id parameters are empty, returns all the wishlists in the database --- tags: - Wishlist produces: - application/json definitions: Wishlist: type: object properties: id: type: integer customer_id: type: integer wishlist_name: type: string parameters: - name: keyword in: query description: the name of the wishlist type: string - name: query in: query description: the id of the customer type: integer responses: 200: description: A Wishlist schema: $ref: '#/definitions/Wishlist' """ query_lists = [] customer_id = request.args.get('customer_id') keyword = request.args.get('keyword') if keyword: query_lists = Wishlist.find_by_wishlist_name(keyword) elif customer_id: query_lists = Wishlist.find_by_customer_id(customer_id) else: """ Returns all of the Wishlists """ query_lists = Wishlist.all() results = [wishlist.serialize() for wishlist in query_lists] return make_response(jsonify(results), status.HTTP_200_OK)
def _deleteSessionToWishlist(self, request): user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # check and see if user currently has wish list wl = Wishlist.query(ancestor=ndb.Key(Profile, user_id)).get() sessionKeys = request.sessionKeys s_keys = [] if wl: # get the session keys and verify if the exist try: sessionKeys = request.sessionKeys for sess in sessionKeys: s_keys.append(ndb.Key(urlsafe=sess).get().key) except: raise endpoints.BadRequestException("Invalid 'session' value") for key in s_keys: if key in wl.sessionKeys: wl.sessionKeys.remove(key) wl.put() return self._copyWishlistToForm(wl) else: raise endpoints.BadRequestException("User does not " "have a Wishlist")
def deleteConference(self, request): """Delete conference.""" wsck = request.websafeConferenceKey conf = self._retrieveConference(wsck) if not conf: raise endpoints.NotFoundException('No conference found with key: %s' % wsck) # Remove the link between the sessions and this conference conf_sess = ConferenceSession.query(ancestor=conf.key) if conf_sess: for sess in conf_sess: wssk = sess.key.urlsafe() # Get all the wishlists that have this session in them and remove this session from them wishes = Wishlist.query(ndb.AND(Wishlist.sessions == wssk)) for wish in wishes: if wish and wssk in wish.sessions: wish.sessions.remove(wssk) wish.put() sess.key.delete() # Unregister the users from this conference if they are registered for it registered_users = Profile.query(ndb.AND(Profile.conferenceKeysToAttend == wsck)) if registered_users: for reg_user in registered_users: if reg_user and wsck in reg_user.conferenceKeysToAttend: reg_user.conferenceKeysToAttend.remove(wsck) reg_user.put() conf.key.delete() return BooleanMessage(data=True)
def remove_wishlist_item(wishlist_id, item_id): """ Delete a Wishlist item This endpoint will delete an item based on the id specified in the path --- tags: - Wishlist Items description: Deletes a Wishlist Item from the database parameters: - name: wishlist_id in: path description: ID of the wishlist type: string required: true - name: item_id in: path description: ID of the item to be deleted type: string required: true responses: 204: description: Item deleted """ wl = Wishlist.find(wishlist_id) if not wl: return make_response( jsonify(message='Wishlist with id %d could not be found' % wishlist_id), status.HTTP_204_NO_CONTENT) try: wl.remove_item(item_id) wl.save_wishlist() return make_response('', status.HTTP_204_NO_CONTENT) except ItemException: message = {'error': 'Item %s was not found' % item_id} return make_response(jsonify(message), status.HTTP_204_NO_CONTENT)
def delete_wishlist(wishlist_id): """ Delete a Wishlist This endpoint will delete a Wishlist based on the id specified in the path --- tags: - Wishlist parameters: - name: wishlist_id in: path description: the id of the wishlist type: integer required: true responses: 204: description: returns no content """ wishlist = Wishlist.get(wishlist_id) if wishlist: items = Item.find_by_wishlist_id(wishlist_id) for item in items: item.delete() wishlist.delete() return make_response('', status.HTTP_204_NO_CONTENT)
def add_to_wishlist(client_id, product_id): app.logger.info('add product {} to wishlist of client {}'.format(product_id, client_id)) client = clientDAO.get(client_id) if client is None: app.logger.warning('client not found') return jsonify({'message': 'client not found'}), 404 if wishlistDAO.exists(client.id, product_id): app.logger.warning('product already exists') return jsonify({'message': 'product already added on wishlist'}), 409 product = ProductService.get(product_id) if product is None: app.logger.warning('product not found') return jsonify({'message': 'product not found'}), 404 favorite_list = favoriteListDAO.get(client.id) if favorite_list is None: app.logger.warning('creating favorite list') favorite_list = FavoriteList(client.id) favoriteListDAO.save(client, favorite_list) wishlist = Wishlist(favorite_list.id, product_id) wishlistDAO.save(wishlist) app.logger.info('successfully to add product on wishlist') return jsonify(wishlist.__dict__), 201
def delete_wishlist(wishlist_id): """ Delete a Wishlist This endpoint will delete a Wishlist based on the id specified in the path --- tags: - Wishlists description: Deletes a Wishlist from the database parameters: - name: wishlist_id in: path description: ID of the wishlist to delete type: integer required: true responses: 204: description: Wishlist deleted """ wl = Wishlist.find(wishlist_id) if wl: wl.delete() return make_response('', status.HTTP_204_NO_CONTENT) else: return make_response( jsonify(message='Wishlist with id %d could not be found' % wishlist_id), status.HTTP_204_NO_CONTENT)
def _createWishlistObject(self, request): """ Create or update Wishlist object, returning WishlistForm """ # Preload and validate necessary data items user = self.get_authed_user() user_id = getUserId(user) prof_key = ndb.Key(Profile, user_id) if not request.websafeKey: raise endpoints.BadRequestException('Session websafeKey required') session = ndb.Key(urlsafe=request.websafeKey) if not session: raise endpoints.NotFoundException( 'No session found with key: {}'.format(request.websafeKey) ) # copy WishlistForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) for field in request.all_fields()} del data['websafeKey'] sess_key = ndb.Key(urlsafe=request.websafeKey) data['session'] = sess_key wishlist_id = Wishlist.allocate_ids(size=1, parent=prof_key)[0] wishlist_key = ndb.Key(Wishlist, wishlist_id, parent=prof_key) data['key'] = wishlist_key Wishlist(**data).put() return self._copyWishlistToForm(wishlist_key.get())
def update_wishlist_item(wishlist_id, item_id): """ The route for modifying the description of an item in a specific wishlist. Example: curl -i -H 'Content-Type: application/json' -X PUT -d '{"description":"update product!"}' http://127.0.0.1:5000/wishlists/1/items/i123 H is for headers, X is used to specify HTTP Method, d is used to pass a message. """ try: data = request.get_json() data['id'] = item_id except TypeError: (jsonify("Invalid input data type"), status.HTTP_400_BAD_REQUEST) if is_valid(data, 'item'): try: wl = Wishlist.find_or_404(wishlist_id) wl.update_item(data) wl.save_wishlist() new_wl = wl.find(wishlist_id) return make_response(jsonify(new_wl.serialize_wishlist()), status.HTTP_200_OK) except WishlistException: message = {'error': 'Wishlist %s was not found' % wishlist_id} return make_response(jsonify(message), status.HTTP_404_NOT_FOUND) except ItemException: message = {'error': 'Item %s was not found' % item_id} return make_response(jsonify(message), status.HTTP_404_NOT_FOUND) else: message = {'error': 'Item data was not valid'} return make_response(jsonify(message), status.HTTP_400_BAD_REQUEST)
def getSessionWishList(self, request): """This function gets all wishlists of user.""" # check for authentication user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # get Profile from datastore p_key = ndb.Key(Profile, user_id) profile = p_key.get() if not profile: raise endpoints.NotFoundException( 'No profile found') # Output all sessions in profile query = Wishlist.query(ancestor=p_key) query = query.fetch() slist = [] for q in query: s_key = ndb.Key(urlsafe=q.sessionKey) slist.append(self._copySessionToForm(s_key.get())) return SessionForms( items=slist)
def getSessionsInWishlist(self, request): """Get user's wishlist's sessions in the conference. """ # Get conference key for urlsafekey. c_key = ndb.Key(urlsafe=request.websafeConferenceKey) # Get current user key. user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = _getUserId() user_key = ndb.Key(Profile, user_id) # Get wishlist of the user. user_wish = Wishlist.query(Wishlist.userKey==user_key).fetch() # Put all wishlist sessionkey into wish_s_list. wish_s_keys = [w.sessionKey for w in user_wish] # Add the sessionkeys which belong to the conference to s_list. s_list = [] for s_key in wish_s_keys: if s_key.parent() == c_key: s_list.append(s_key) # Get sesssion entity by session key in s_list, and copy to sessionForm. return SessionForms( items=[self._copySessionToForm(s.get()) for s in s_list])
def get_wishlist(wishlist_id): """ Retrieve a single Wishlist This endpoint will return a Wishlist based on it's ID --- tags: - Wishlist produces: - application/json parameters: - name: wishlist_id in: path type: integer required: true definitions: Wishlist: type: object properties: id: type: integer customer_id: type: integer wishlist_name: type: string definitions: Item: type: object properties: id: type: integer wishlist_id: type: integer product_id: type: integer name: type: string description: type: string responses: 200: description: List of items in the wishlist schema: $ref: '#/definitions/Wishlist' 404: description: Wishlist with id wishlist_id not found """ wishlist = Wishlist.get(wishlist_id) if not wishlist: raise NotFound("Wishlist with id '{}' was not found.".format(wishlist_id)) return make_response(jsonify(wishlist.serialize()), status.HTTP_200_OK)
def orderSessionsInWishlist(self, request): """Filter Wishlist first by startTime""" # get sessions from wishlist wish_sessions = Wishlist.query() # first order by time by startTime: wish_sessions = wish_sessions.order(Wishlist.startTime) return SessionForms( sessions=[ self._copySessionToForm(session) for session in wish_sessions])
def _createWishlistObject(self, request): """Create or update Wishlist object, returning WishlistForm/request.""" # check auth user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # check sessionName exists if not request.sessionName: raise endpoints.UnauthorizedException('Name required') # get userId user_id = getUserId(user) # get session key this_session = Session.query(Session.name == request.sessionName).get() # populate dict data = { 'userId': user_id, 'sessionName': request.sessionName, 'sessionKey': this_session.key, 'typeOfSession': this_session.typeOfSession } # generate wishlist key from session key p_key = this_session.key c_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] c_key = ndb.Key(Wishlist, c_id, parent=p_key) data['key'] = c_key # query wishlist, filter by userId and sessionName, then count q = Wishlist.query() q = q.filter(Wishlist.userId == user_id) # if this session already in user's wishlist, bounce for i in q: if i.sessionKey == this_session.key: raise endpoints.UnauthorizedException( 'Session already added to wishlist') # save to wishlist Wishlist(**data).put() return request
def test_get_wishlist_item_list(self): """ Test getting a list of Items from one specific Wishlist """ wishlist = Wishlist.find_by_customer_id(1)[0] print wishlist.id resp = self.app.get('/wishlists/{}/items'.format(wishlist.id), content_type='application/json') print json.loads(resp.data) self.assertEqual(resp.status_code, status.HTTP_200_OK) data = json.loads(resp.data) self.assertEqual(len(data), 2)
def test_update_wishlist_no_name(self): """Test updating a existing Wishlist with no name""" wishlist = Wishlist.find_by_customer_id(1)[0] new_wishlist = {'customer_id': 1} '''new_wishlist['items'] = [{"wishlist_id": 3, "product_id": 3, "name": "soda", "description": "I need some soft drinks"}]''' data = json.dumps(new_wishlist) resp = self.app.put('/wishlists/{}'.format(wishlist.id), data=data, content_type='application/json') self.assertEqual(resp.status_code, status.HTTP_400_BAD_REQUEST)
def _addSessionToWishlist(self, session_key): user_id = self._getCurrentUserID() key = ndb.Key(Profile, user_id).get() wish_list = Wishlist.query(ancestor=key.key).get() if wish_list and wish_list.sessionKeys: wish_list.sessionKeys.append(session_key) else: wish_list.sessionKeys = [session_key] wish_list.put()
def _getWishlistFromUser(self): user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) w_key = ndb.Key(Wishlist, user_id) wishlist = w_key.get() if not wishlist: wishlist = Wishlist( key=w_key, ownerId=user_id, public=True, ) wishlist.put() print wishlist return wishlist
def _getSessionsInWishlist(self): user_id = self._getCurrentUserID() wishlist = Wishlist.query(ancestor=ndb.Key(Profile, user_id)).get() forms = SessionForms() for key in wishlist.sessionKeys: query = Session.query(Session.key == key).get() forms.items += [self._copySessionToForm(session=query)] return forms
def test_delete_wishlist(self): """ Test deleting a Wishlist """ wishlist = Wishlist.find_by_customer_id(1)[0] # Save the current number of wishlists for assertion wishlist_count = self.get_wishlist_count() resp = self.app.delete('/wishlists/{}'.format(wishlist.id), content_type='application/json') self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(len(resp.data), 0) new_count = self.get_wishlist_count() self.assertEqual(new_count, wishlist_count - 1)
def setUp(self): """ Runs before each test """ server.init_db() db.create_all() # create new tables item = Item(wishlist_id=1, product_id=1, name='toothpaste', description='I need a toothpaste').save() item = Item(wishlist_id=1, product_id=2, name='toilet paper', description='I need a toilet paper').save() item = Item(wishlist_id=2, product_id=3, name='beer', description='I need a drink').save() wishlist = Wishlist(customer_id=1, wishlist_name='grocery').save() wishlist = Wishlist(customer_id=2, wishlist_name='beverage').save() self.app = server.app.test_client()
def wishlists(): """ The route for accessing all wishlist resources or creating a new wishlist resource via a POST. """ wishlistsList = [] wishlistsList = Wishlist.all() wishlistsList = [ wishlist.serialize_wishlist() for wishlist in wishlistsList ] return make_response(json.dumps(wishlistsList, indent=4), status.HTTP_200_OK)
def addSessionToWishlist(self, request): """Copy Session to Wishlist""" # first of all there is a need to check if this session is # already in wishlist: sessInWishlist = Wishlist.query( Wishlist.sessionKey == request.SessionKey).count() if sessInWishlist != 0: raise endpoints.ForbiddenException( "Denied, you can't create one session in wishlist twice") else: # get session and key: session_key = ndb.Key(urlsafe=request.SessionKey) session = session_key.get() # allocating id for session in wishlist: sess_wish_id = Wishlist.allocate_ids(size=1, parent=session.key)[0] # making key for session in wish, parent is just session: sess_wish_key = ndb.Key(Wishlist, sess_wish_id, parent=session.key) # in order not to deal with converting # dateandtime objects to string setting new # variables: date, startTime = None, None if session.date is not None: date = session.date del session.date if session.startTime is not None: startTime = session.startTime del session.startTime # making form from session to make dict and then give # that dict into Wishlist: session_form = self._copySessionToForm(session) # making dict with all data: data = {field.name: getattr(session_form, field.name) for field in session_form.all_fields()} data['date'] = date data['startTime'] = startTime data['sessionKey'] = session_key.urlsafe() # adding session_wish key to dict: data['key'] = sess_wish_key Wishlist(**data).put() return session_form
def getSessionsInWishlist(self, request): """Get all Wishlist entries for the user.""" user = self._getAuthUser() user_id = getUserId(user) # create ancestor query for all key matches for this user wishlist = Wishlist.query(ancestor=ndb.Key(Profile, user_id)) # return set of WishlistForm objects per Wishlist Entry return WishlistForms( items=[self._copyWishlistToForm(wish) for wish in wishlist] )
def _addSessionToWishlist(self, request): user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') s_keys = [] user_id = getUserId(user) p_key = ndb.Key(Profile, user_id) # Get the session keys and verify if the exist try: sessionKeys = request.sessionKeys for sess in sessionKeys: s_keys.append(ndb.Key(urlsafe=sess).get().key) except: raise endpoints.BadRequestException("Invalid 'session' value") # check and see if user currently has wish list wl = Wishlist.query(ancestor=ndb.Key(Profile, user_id)).get() # if wishlist exists, check to see if session keys exists in wishlist # if not, add if wl: for key in s_keys: if key not in wl.sessionKeys: wl.sessionKeys.append(key) wl.put() return self._copyWishlistToForm(wl) # else create Wishlist object else: # copy WishlistForm/ProtoRPC Message into dict data = {'sessionKeys': s_keys} w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) data['key'] = w_key Wishlist(**data).put() return request
def getWishlistBySession(self, request): """ given a specific session, return all users that have this session on their wishlist """ # get wishlists that contain the sessionKey wishlists = Wishlist.query(Wishlist.sessionKey == request.websafeSessionKey) # get the user keys from the wishlists users = [(ndb.Key(Profile, wishlist.userId)) for wishlist in wishlists] # lookup the profiles profiles = ndb.get_multi(users) return ProfileForms( items=[self._copyProfileToForm(profile) for profile in profiles])
def getSessionsInWishlist(self, request): """Get sessions in wishlist.""" # check auth user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # get userId user_id = getUserId(user) # query wishlist, filter by userId q = Wishlist.query().filter(Wishlist.userId == user_id) return WishlistForms(items=[self._copyWishlistToForm(wish) for wish in q])
def add_item_to_wishlist(wishlist_id): """ Add an Item to an existing wishlist This endpoint will add a wishlist item based on the data in the body that is posted --- tags: - Wishlist consumes: application/json parameters: - name: wishlist_id in: path type: integer description: the id of the Wishlist to add an item required: true - name: body in: body required: true schema: $ref: '#/definitions/Item' responses: 201: description: Successfully added Item to wishlist 404: description: Wishlist with id not found """ check_content_type('application/json') wishlist = Wishlist.get(wishlist_id) if not wishlist: raise NotFound("Wishlist with id '{}' was not found.".format(wishlist_id)) item = Item() json_post = request.get_json() item.deserialize(json_post,wishlist_id) item.save() message = item.serialize() """ check if the item.wishlist_id equals to the wishlist.id """ check_wishlist_id = item.wishlist_id location_url = url_for('get_wishlist', wishlist_id=wishlist.id, _external=True) return make_response(jsonify(message), status.HTTP_201_CREATED, { 'Location': location_url })
def wishlists(): """ Retrieve a list of Wishlists This endpoint will return all wishlists --- tags: - Wishlists responses: 200: description: An array of Wishlists schema: type: array items: schema: id: Wishlist properties: user_id: type: string description: Unique ID of the user(created by the user) name: type: string description: Wishlist Name(created by the user) created: type: string format: date-time description: The time at which the wishlist was created deleted: type: boolean description: Flag to be set when a wishlist is deleted items: type: object properties: wishlist_item_id: type: object properties: item_id: type: string item_description: type: string description: Dictionary to store objects in a wishlist id: type: integer description: Unique ID of the wishlist assigned internally by the server """ wishlistsList = [] wishlistsList = Wishlist.all() wishlistsList = [ wishlist.serialize_wishlist() for wishlist in wishlistsList ] return make_response(json.dumps(wishlistsList, indent=4), status.HTTP_200_OK)
def _createWishlistObject(self, request): """Create or update Wishlist object, returning WishlistForm/request.""" # check auth user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # check sessionName exists if not request.sessionName: raise endpoints.UnauthorizedException('Name required') # get userId user_id = getUserId(user) # get session key this_session = Session.query(Session.name == request.sessionName).get() # populate dict data = {'userId': user_id, 'sessionName': request.sessionName, 'sessionKey': this_session.key, 'typeOfSession': this_session.typeOfSession} # generate wishlist key from session key p_key = this_session.key c_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] c_key = ndb.Key(Wishlist, c_id, parent=p_key) data['key'] = c_key # query wishlist, filter by userId and sessionName, then count q = Wishlist.query() q = q.filter(Wishlist.userId == user_id) # if this session already in user's wishlist, bounce for i in q: if i.sessionKey == this_session.key: raise endpoints.UnauthorizedException('Session already added to wishlist') # save to wishlist Wishlist(**data).put() return request
def read_wishlist(wishlist_id): """ The route for reading wishlists, whether one specifically by id or all wishlists when no id is specified. Example: curl http://127.0.0.1:5000/wishlists/1 """ try: wl = Wishlist.find_or_404(wishlist_id) return make_response(jsonify(wl.serialize_wishlist()), status.HTTP_200_OK) except WishlistException: return make_response( jsonify(message='Cannot retrieve wishlist with id %s' % wishlist_id), status.HTTP_404_NOT_FOUND)
def getSessionsInWishlist(self, request): """Query for all the sessions in a conference that the user is interested in attending""" p_key = self._getUserProfileKey() wish = Wishlist.query(ancestor=p_key).get() if not wish: raise endpoints.NotFoundException('Your wishlist could not be found') wf = {'key': p_key, 'sessions': []} if len(wish.sessions) and any(s for s in wish.sessions): wf['sessions'] = [self._retrieveSession(cs_id) for cs_id in wish.sessions if cs_id is not None] return self.toWishlistForm(wf)
def _addToWishlistObject(self, request): """Add a session to a wishlist, return a wishlist form""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # Camacho - get the user's wishlist wl = Wishlist.query(ancestor=ndb.Key(Profile,user_id)) wl = wl.get() # Camacho - make sure the wishlist exists if not wl: raise endpoints.NotFoundException( 'Your user does not have a wishlist!') # Camacho - save the current keys try: currKeys = wl.sessionKeys except: currKeys = [] # Camacho - get the key specified to add newKey = getattr(request,'sessionKeys') # Camacho - make sure the key specified corresponds # to an existing session try: session = ndb.Key(urlsafe=newKey).get() except: raise endpoints.NotFoundException( 'Session with this key not found %s' % (newKey)) currKeys.append(newKey) setattr(wl, 'sessionKeys', currKeys) wl.put() sessions = [] # Pass a list of the sessions in the wishlist to the # _copySessionToForm function to return SessionForm # object for k in currKeys: sessions.append(ndb.Key(urlsafe=k).get()) return SessionForms( items=[self._copySessionToForm(sess) for sess in \ sessions] )
def update_wishlists(wishlist_id): """ Update a Wishlist This endpoint will update a Wishlist based the body that is posted """ check_content_type('application/json') wishlist = Wishlist.get(wishlist_id) if not wishlist: raise NotFound("Wishlist with id '{}' was not found.".format(wishlist_id)) wishlist.deserialize(request.get_json()) wishlist.id = wishlist_id wishlist.save() return make_response(jsonify(wishlist.serialize()), status.HTTP_200_OK)
def item(wishlist_id): """ The route for getting all items associated with a wishlist or making a new item for a wishlist via a POST. Example: curl http://127.0.0.1:5000/wishlists/1/items """ try: wl = Wishlist.find_or_404(wishlist_id) items = wl.all_items() return make_response(jsonify(items), status.HTTP_200_OK) except WishlistException: return make_response( jsonify(message='Cannot retrieve wishlist with id %s' % wishlist_id), status.HTTP_404_NOT_FOUND)
def getSessionsInWishlist(self, request): """Get sessions in wishlist.""" # check auth user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # get userId user_id = getUserId(user) # query wishlist, filter by userId q = Wishlist.query().filter(Wishlist.userId == user_id) return WishlistForms( items=[self._copyWishlistToForm(wish) for wish in q])
def _getSessionsInWishlist(self): """ Helper method to get Sessions from the wishlist """ user = self.get_authed_user() user_id = getUserId(user) prof_key = ndb.Key(Profile, user_id) wish_keys = Wishlist.query(ancestor=prof_key) sess_keys = [wish_key.session for wish_key in wish_keys] if sess_keys in (None, []): raise endpoints.BadRequestException( 'No wishlist found: {}'.format(sess_keys)) return ndb.get_multi(sess_keys)
def getSessionsInMostWishlists(self, request): """Query top five sessions that are in most wishlists""" sessions = Wishlist.query().group_by([Wishlist.sessionKeysToAttend]) Session.query()..filter(Session.typeOfSession == request.typeOfSession) user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') wishlist = self._getWithlistByUserId(getUserId(user)) keys = [ndb.Key(urlsafe=wkey) for wkey in wishlist.sessionKeysToAttend] sessions = ndb.get_multi(keys) return SessionForms(items=[self._copySessionToForm(session) for session in sessions])
def getSessionsInWishlist(self, request): """Return all sessions in user Wishlist across all conferences.""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) wl = Wishlist.query(ancestor=ndb.Key(Profile, user_id)).get() if not wl: raise endpoints.NotFoundException( 'User does not have a Wishlist!') return self._copyWishlistToForm(wl)
def getSessionsInWishlist(self, request): """Return sessions for a particular speaker across all conferences.""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # Camacho - get the user's wishlist wl = Wishlist.query(ancestor=ndb.Key(Profile,user_id)).get() # Camacho - make sure the wishlist exists if not wl: raise endpoints.NotFoundException( 'Your user does not have a wishlist!') return self._copyWishlistToForm(wl)
def addSessionToWishlist(self, request): user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) p_key = ndb.Key(Profile, user_id) # see if there is a wishlist already query = Wishlist.query(ancestor=p_key) session_key = ndb.Key(urlsafe=request.websafeSessionKey) if query.count(): wishlist = query.get() wishlist.sessions.append(session_key) wishlist.put() else: w_id = Wishlist.allocate_ids(size=1, parent=p_key)[0] w_key = ndb.Key(Wishlist, w_id, parent=p_key) data = {} data['key'] = w_key data['sessions'] = [] data['sessions'].append(session_key) w_key = Wishlist(**data).put() print(w_key) return BooleanMessage(data=True)
def get_wishlist_list(): """ Returns the Wishlists by searching the keywords of wishlist_name --- tags: - Wishlist produces: - application/json parameters: - name: keyword in: query description: the name of the wishlist type: string required: true responses: 200: description: An Item schema: $ref: '#/definitions/Wishlist' """ query_lists = [] keyword = request.args.get('keyword') if keyword: query_lists = Wishlist.find_by_wishlist_name(keyword) else: """ Returns all of the Wishlists """ query_lists = Wishlist.all() results = [wishlist.serialize() for wishlist in query_lists] return make_response(jsonify(results), status.HTTP_200_OK)
def getWishlistByType(self, request): """Get wishlist by type.""" # check auth user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # get userId user_id = getUserId(user) # query wishlist, filter by userId and typeOfSession q = Wishlist.query() q = q.filter(Wishlist.userId == user_id) q = q.filter(Wishlist.typeOfSession == request.typeOfSession) return WishlistForms(items=[self._copyWishlistToForm(wish) for wish in q])
def delete_wishlist(wishlist_id): """ The route for deleting a specific wishlist when the wishlist_id is specified. This only does a soft delete, i.e. update the deleted flag with "true" Example: curl -X DELETE http://127.0.0.1:5000/wishlists/1 """ wl = Wishlist.find(wishlist_id) if wl: wl.delete() return make_response('', status.HTTP_204_NO_CONTENT) else: return make_response( jsonify(message='Wishlist with id %d could not be found' % wishlist_id), status.HTTP_204_NO_CONTENT)
def _creatWishlist(self, request): "Create a Wishlist, add the session to it." # Get the current user, and the its name and key. user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = _getUserId() user_key = ndb.Key(Profile, user_id) user_name = user_key.get().displayName # Get the session key and session name. session_key =ndb.Key(urlsafe=request.websafeSessionKey) session_name = session_key.get().sessionName # Store the user and session data in a wishlist entity. wishlist = Wishlist( userName=user_name, userKey=user_key, sessionKey=session_key, sessionName=session_name) wishlist.put() # Return user and session name as a tuple. return user_name, session_name
def getWishlistByType(self, request): """Get wishlist by type.""" # check auth user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # get userId user_id = getUserId(user) # query wishlist, filter by userId and typeOfSession q = Wishlist.query() q = q.filter(Wishlist.userId == user_id) q = q.filter(Wishlist.typeOfSession == request.typeOfSession) return WishlistForms( items=[self._copyWishlistToForm(wish) for wish in q])
def update_wishlists(wishlist_id): """ Update a Wishlist This endpoint will update a Wishlist based the body that is posted --- tags: - Wishlist parameters: - name: wishlist_id in: path type: integer required: true - name: body in: body schema: id: wishlist_entries required: true - customer_id - wishlist_name properties: customer_id: type: integer description: customer_id default: "345" wishlist_name: type: string description: name of the wishlist default: "new name of the wishlist" responses: 200: description: Update was successful 404: description: Did not find item with the given id in the wishlist """ check_content_type('application/json') wishlist = Wishlist.get(wishlist_id) if not wishlist: raise NotFound("Wishlist with id '{}' was not found.".format(wishlist_id)) wishlist.deserialize(request.get_json()) wishlist.id = wishlist_id wishlist.save() return make_response(jsonify(wishlist.serialize()), status.HTTP_200_OK)
def read_wishlist_item(wishlist_id, item_id): """ Retrieve a single Wishlist item This endpoint will return a Wishlist item based on it's ID --- tags: - Wishlist Items produces: - application/json parameters: - name: wishlist_id in: path description: ID of wishlist to retrieve from type: integer required: true - name: item_id in: path description: ID of item to be retrieved type: string required: true responses: 200: description: Wishlist items matching with the query schema: id: Wishlist properties: id: type: string description: ID of the item matching description: type: string description: Description of the item 404: description: Wishlist not found """ try: wl = Wishlist.find_or_404(wishlist_id) item = wl.find_item(item_id) return make_response(jsonify(item), status.HTTP_200_OK) except ItemException: return make_response( jsonify(message='Item with id %s could not be found' % item_id), status.HTTP_404_NOT_FOUND) except WishlistException: return make_response( jsonify(message='Wishlist with id %d could not be found' % wishlist_id), status.HTTP_404_NOT_FOUND)