def setup_recommendations_and_likes(self): """This method sets up recommendationss to be tested in other test methods. """ r1 = Recommendation( title="Fire Doughnuts in Canada", content= "Ever tried jerk flavored doughnuts?, then you haven't lived!. Marley's yard gotchu!", business_name="Marleys Yard", business_address="2345 67 Ave NW", business_city="Edmonton", business_state="Alberta", business_country="Canada", business_rating=4, user_id=self.testuser_id) r2 = Recommendation( id=365, title="Deep Dish Pizza in Edmonton, Canada", content= "Looking for delicious deep dish pizza?, Chicago 001 has the best on Whyte Ave", business_name="Chicago 001", business_address="1946 Whyte Ave NW", business_city="Edmonton", business_state="Alberta", business_country="Canada", business_rating=5, user_id=self.u2id) db.session.add_all([r1, r2]) db.session.commit() l1 = Likes(user_id=self.testuser_id, recommendation_id=365) db.session.add(l1) db.session.commit()
def test_delete_recommend_post(self): with self.client as client: with client.session_transaction() as sess: sess[KEY]=999 new_user = User( id=1002, username='******', first_name='test', last_name='user3', password='******', email='*****@*****.**', ) db.session.add(new_user) new_recommend = Recommendation(recommender_id=1002, recommend_to_user_id=999, drink_id='1') rec_id = 9999 new_recommend.id = rec_id db.session.add(new_recommend) resp = client.post('/user/recommendations', json={'recId': 9999}, follow_redirects=True) self.assertIn("You don\\\'t have any recommendations yet", str(resp.data)) del_new_user = User.query.get(1002) db.session.delete(del_new_user)
def test_recommend_add_remove(self): new_user = User( username='******', first_name='rec', last_name='user', password='******', email='*****@*****.**', ) new_user.id = 11114 db.session.add(new_user) new_rec = Recommendation(recommender_id=11114, recommend_to_user_id=11111, drink_id=1) new_rec.id = 10000 db.session.add(new_rec) rec = Recommendation.query.get(10000) self.assertEqual(rec.id, 10000) self.assertEqual(rec.recommender_id, 11114) self.assertEqual(rec.recommend_to_user_id, 11111) self.assertEqual(rec.drink_id, 1) db.session.delete(rec) db.session.commit() check_rec = Recommendation.query.get(10000) self.assertEqual(check_rec, None)
def _create_recommendation(user, offer, mediation=None): recommendation = Recommendation() recommendation.user = user if offer: recommendation.offer = offer else: offer = offer_queries.find_offer_by_id(mediation.offerId) recommendation.offer = offer if mediation: recommendation.mediation = mediation else: mediation = Mediation.query \ .filter(Mediation.offer == offer) \ .filter(Mediation.isActive) \ .order_by(func.random()) \ .first() recommendation.mediation = mediation if recommendation.mediation: recommendation.validUntilDate = datetime.utcnow() + timedelta(days=3) else: recommendation.validUntilDate = datetime.utcnow() + timedelta(days=1) if offer.lastStock and offer.lastStock.bookingLimitDatetime: recommendation.validUntilDate = min( recommendation.validUntilDate, offer.lastStock.bookingLimitDatetime - timedelta(minutes=1)) PcObject.save(recommendation) return recommendation
def get(self): """ Returns all Recommendations """ type_name = request.args.get('type') product_id = request.args.get('product_id') results = [] rec_type = None if type_name: rec_type = RecommendationType.find_by_name(type_name) if not rec_type: raise NotFound( "Recommendations with type '{}' was not found.".format( type_name)) if rec_type and product_id: recs = Recommendation.find_by_product_id_and_type( product_id, rec_type) elif rec_type: recs = Recommendation.find_by_type(rec_type) elif product_id: recs = Recommendation.find_by_product_id(product_id) else: recs = Recommendation.all() results = [rec.serialize() for rec in recs if rec is not None] return results, status.HTTP_200_OK
def recommend(userid, model): global model_version global canary_version if model == 1: if userid in predictions.index: row = predictions.loc[userid] labels = row.nlargest(20).keys().tolist() result = ",".join(labels) app.logger.info(str(userid) + "->" + result) # Store the recommendation in database reco = Recommendation(user_id=userid, movie_ids=labels, model=model_version, model_num=1) createRecommendation(reco) return result else: app.logger.info("User not indexed. Returning defaults") # Store the recommendation in database reco = Recommendation(user_id=userid, movie_ids=getDefaults().split(','), model=model_version, model_num=1) createRecommendation(reco) # Return response return getDefaults() if model == 2: if userid in canary_predictions.index: row = predictions.loc[userid] labels = row.nlargest(20).keys().tolist() result = ",".join(labels) app.logger.info(str(userid) + "->" + result) # Store the recommendation in database reco = CanaryRecommendation(user_id=userid, movie_ids=labels, model=canary_version, model_num=2) createCanaryRecommendation(reco) return result else: app.logger.info("User not indexed. Returning defaults") # Store the recommendation in database reco = CanaryRecommendation(user_id=userid, movie_ids=getDefaults().split(','), model=canary_version, model_num=2) createCanaryRecommendation(reco) # Return response return getDefaults()
def test_list_recommendations(self): """This test method tests to confirm that the logged in user can only view recommendations in their state and city.""" L = Location(name="Home", address="False Test Creek SW, Long Beach CA", long=143.12, lat=-234.5, city="Long Beach", state="CA", user_id=self.testuser_id) L_id = 124 L.id = L_id db.session.add(L) db.session.commit() r1 = Recommendation( title="Fire Doughnuts in LA", content= "Bro these mf doughnuts be smacking like gahdamn!. Check out Leonards bro!", business_name="Leonards", business_address="2345 Rodeo Ave", business_city="Long Beach", business_state="CA", business_country="US", business_rating=5, user_id=self.testuser_id) r2 = Recommendation( id=365, title="Deep Dish Pizza in Edmonton, Canada", content= "Looking for delicious deep dish pizza?, Chicago 001 has the best on Whyte Ave", business_name="Chicago 001", business_address="1946 Whyte Ave NW", business_city="Edmonton", business_state="Alberta", business_country="Canada", business_rating=5, user_id=self.u2id) db.session.add_all([r1, r2]) db.session.commit() with self.client as c: with c.session_transaction() as sess: sess[CURR_USER_KEY] = self.testuser_id sess[CURR_LOCATION] = L_id resp = c.get("/recommendations/list") self.assertEqual(resp.status_code, 200) self.assertIn("Fire Doughnuts in LA", str(resp.data)) self.assertNotIn("Deep Dish Pizza in Edmonton, Canada", str(resp.data))
def create_recommendation(offer=None, user=None, mediation=None, idx=None, date_read=None, valid_until_date=datetime.utcnow() + timedelta(days=7), search=None, is_clicked=False): recommendation = Recommendation() recommendation.id = idx recommendation.offer = offer recommendation.user = user recommendation.mediation = mediation recommendation.dateRead = date_read recommendation.validUntilDate = valid_until_date recommendation.search = search recommendation.isClicked = is_clicked return recommendation
def create_tuto_mediation_if_non_existent_for_user(user, tuto_mediation): already_existing_tuto_recommendation = Recommendation.query\ .filter_by(mediation=tuto_mediation, user=user)\ .first() if already_existing_tuto_recommendation: return recommendation = Recommendation() recommendation.user = user recommendation.mediation = tuto_mediation recommendation.validUntilDate = datetime.utcnow() + timedelta(weeks=2) PcObject.save(recommendation)
def add_recommendation(): """This view function renders the form to add a new recommendation if a GET request is made. If form validates, it adds new recommendation to dateMeet db and redirect to recommendations page. """ if not g.user: flash("Access unauthorized.", "danger") return redirect("/") form = UserRecommendationAddForm() if form.validate_on_submit(): recommendation = Recommendation( title=form.title.data, content=form.content.data, business_name=form.business_name.data, business_address=form.business_address.data, business_city=form.business_city.data, business_state=form.business_state.data, business_country=form.business_country.data, business_rating=form.business_rating.data) g.user.recommendations.append(recommendation) db.session.commit() return redirect(f"/users/{g.user.id}") return render_template('recommendations/new.html', form=form)
def _format_recommendation_response( response: dict, ) -> List[Recommendation]: if not response or not response.get('tracks'): raise NoContentFound( f'Invalid or missing content in response {response}') formatted_data = [] recommendations = response['tracks'] for recommendation in recommendations: formatted_data.append( Recommendation( **{ 'playlist': recommendation['album']['name'], 'url': recommendation['external_urls']['spotify'], 'artists': [ artist['name'] for artist in recommendation['artists'] ], 'total_tracks': round(recommendation['album']['total_tracks']), 'duration_seconds': round(recommendation['duration_ms'] / 60, 2), })) return formatted_data
def test_like_recommendation(self): """This test method tests to confirm that the like recommendation functionality works. """ r = Recommendation( id=3000, title="Jamaican Doughnuts in Canada", content="Jamaican Doughnuts are the bomb, got to Marley's on 67th!", business_name="Marleys Yard", business_address="2345 67 Ave NW", business_city="Edmonton", business_state="Alberta", business_country="Canada", business_rating=5, user_id=self.u2id) db.session.add(r) db.session.commit() with self.client as c: with c.session_transaction() as sess: sess[CURR_USER_KEY] = self.testuser_id resp = c.post("/recommendations/3000/like", follow_redirects=True) self.assertEqual(resp.status_code, 200) likes = Likes.query.filter(Likes.recommendation_id == 3000).all() self.assertEqual(len(likes), 1) self.assertEqual(likes[0].user_id, self.testuser_id)
def test_delete_recommendation(self): """This test method tests to confirm that a recommendation is deleted when a delete request is sent by a logged in user.""" r = Recommendation( id=419, title="Fire Doughnuts in LA", content= "Bro these mf doughnuts be smacking like gahdamn!. Check out Leonards bro!", business_name="Leonards", business_address="2345 Rodeo Ave", business_city="Long Beach", business_state="CA", business_country="US", business_rating=5, user_id=self.testuser_id) db.session.add(r) db.session.commit() with self.client as c: with c.session_transaction() as sess: sess[CURR_USER_KEY] = self.testuser_id resp = c.post("/recommendations/419/delete", follow_redirects=True) self.assertEqual(resp.status_code, 200) r = Recommendation.query.get(419) self.assertIsNone(r)
def recommend_song(): data = request.get_json() if not data['to_user']: return jsonify({"msg": "Missing to_user parameter"}), 400 if not data['from_user']: return jsonify({"msg": "Missing from_user parameter"}), 400 if not data['song_id']: return jsonify({"msg": "Missing song_id parameter"}), 400 to_user = data['to_user'] from_user = data['from_user'] song_id = data['song_id'] message = data['message'] try: new_recommendation = Recommendation(to_user=to_user, from_user=from_user, song_id=song_id, message=message) db.session.add(new_recommendation) db.session.commit() return jsonify({"msg": "Recommendation sent!"}), 201 except Exception as e: print(e) return jsonify({"msg": "Something went wrong making the rec."}), 400
def test_recommendation_likes(self): """This test method tests recommendation likes model""" r1 = Recommendation( title="Fire Doughnuts in Canada", content= "Ever tried jerk flavored doughnuts?, then you haven't lived!. Marley's yard gotchu!", business_name="Marleys Yard", business_address="2345 67 Ave NW", business_city="Edmonton", business_state="Alberta", business_country="Canada", business_rating=4, user_id=self.uid) u = User.register("User2", "Test", "*****@*****.**", "testuser2", "passWord4u2", None, None) uid2 = 2222 u.id = uid2 db.session.add(r1) db.session.commit() u.likes.append(r1) db.session.commit() l = Likes.query.filter(Likes.user_id == uid2).all() # There should be only one liked message and it should be m1 self.assertEqual(len(l), 1) self.assertEqual(l[0].recommendation_id, r1.id)
def make_blank_recommendations(user): firstrec = Recommendation( student_id=user.user_id, recommender_id=User.query.filter_by(email=user.rec1email, role=2).first().user_id) secondrec = Recommendation( student_id=user.user_id, recommender_id=User.query.filter_by(email=user.rec2email, role=2).first().user_id) thirdrec = Recommendation( student_id=user.user_id, recommender_id=User.query.filter_by(email=user.rec3email, role=2).first().user_id) db.session.add(firstrec) db.session.add(secondrec) db.session.add(thirdrec) db.session.commit()
def rec_detail(recommendation_id): """ Manage Recommendation Detail""" rec = Recommendation.find_by_id(recommendation_id) recJSON = rec.serialize() return render_template( 'manage/detail.html', detail_id=recJSON["id"], product_id=recJSON["product_id"], rec_type=recJSON["rec_type"]["id"], rec_product_id=recJSON["rec_product_id"], weight=recJSON["weight"], status=recJSON["rec_type"]["is_active"]), status.HTTP_200_OK
def create_recommendations(recommendation_id): """ Create Recommendation View """ data = request.get_json() rec = Recommendation() rec.deserialize(data) rec.save() message = rec.serialize() return render_template('manage.html', name="Manage", result=message), status.HTTP_201_CREATED
def generate_recommendations(): original = get_user_track_array() original_pd = pd.DataFrame(original) song_to_song = pd.DataFrame(index=original_pd.columns, columns=original_pd.columns) for i in xrange(len(song_to_song.columns)): for j in xrange(len(song_to_song.columns)): similarity = 1 - cosine(original_pd.ix[:, i], original_pd.ix[:, j]) song_to_song.ix[i, j] = similarity if math.isnan(similarity): song_to_song.ix[i, j] = 0 data_neighbours = pd.DataFrame(index=song_to_song.columns, columns=[range(1, 11)]) for i in range(0, len(song_to_song.columns)): data_neighbours.ix[i, :10] = song_to_song.ix[0:, i].sort_values( ascending=False)[:10].index data_sims = pd.DataFrame(index=original_pd.index, columns=original_pd.columns) for i in range(0, len(data_sims.index)): for j in range(0, len(data_sims.columns)): user = data_sims.index[i] product = data_sims.columns[j] if original_pd.ix[i][j] == 1: data_sims.ix[i][j] = 0 else: product_top_names = data_neighbours.ix[product][1:10] product_top_sims = song_to_song.ix[product].sort_values( ascending=False)[1:10] user_purchases = original_pd.ix[user, product_top_names] data_sims.ix[i][j] = getScore(user_purchases, product_top_sims) result_dict = {} for i in xrange(len(data_sims.index)): top_matches = data_sims.ix[i, :].sort_values( ascending=False)[0:10].index.values result_dict[i + 1] = [x + 1 for x in top_matches] for user_id, track_ids in result_dict.items(): recommendations = [] for track_id in track_ids: recommendations.append( Recommendation(user_id=user_id, track_id=track_id)) db.session.add_all(recommendations) db.session.commit()
def recommendations(): return [ Recommendation( **{ 'playlist': 'album name', 'url': 'https://open.spotify.com/track/7GhIk7Il098yCjg4BQjzvb', 'artists': ['artist_1', 'artist_2'], 'total_tracks': 11, 'duration_seconds': round(11700 / 60, 2), } ) for _ in range(2) ]
def sanitize_recommendation(rec: Recommendation): description = rec.description description = description.replace('\n', ' ') tokens = [] for word in description.split(' '): if is_symbol_name(word): tokens.append('{term}') elif word.endswith('%'): tokens.append('{per}') elif is_url(word): tokens.append(word) elif has_path(word): tokens.append('{path}') elif is_methodname(word): tokens.append('{method}') elif is_num(word): tokens.append('{num}') else: tokens.append(word) sanitized = ' '.join(tokens) rec.set_sanitized_descr(sanitized)
def delete(self, recommendation_id): """ Delete a Recommendation This endpoint will delete a Recommendation based the id specified in the path """ recommendation = Recommendation.find_by_id(recommendation_id) if not recommendation: raise NotFound("Recommendation with id '{}' was not found.".format( recommendation_id)) recommendation.delete() return '', status.HTTP_204_NO_CONTENT
def execute(self, user: User, data) -> Recommendation: if user is None: raise BadUserException() if data is None: raise BadArgException recommendation = Recommendation() recommendation.user_id = user.id recommendation.title = data.get('title') recommendation.content = data.get('content') recommendation.estimated_success_time = data.get( 'estimated_success_time') recommendation.difficulty_level = data.get('difficulty_level') recommendation.benefit = data.get('benefit') recommendation.type = data.get('type') BaseObject.check_and_save(recommendation) return recommendation
def put(self, recommendation_id): """ Update a Recommendation This endpoint will update a Recommendations based the body that is posted """ recommendation = Recommendation.find_by_id(recommendation_id) if not recommendation: raise NotFound("Recommendation with id '{}' was not found.".format( recommendation_id)) recommendation.deserialize(request.get_json()) recommendation.id = recommendation_id recommendation.save() return recommendation.serialize(), status.HTTP_200_OK
def get(self, recommendation_id): """ Retrieve a single Recommendation This endpoint will return a Recommendations based on it's id """ recommendation = Recommendation.find_by_id(recommendation_id) recJSON = "" if not recommendation: raise NotFound( "Recommendations with id '{}' was not found.".format( recommendation_id)) else: recJSON = recommendation.serialize() return recJSON, status.HTTP_200_OK
def test_unauthorized_recommendation_delete(self): """This test method confirms that an unauthorized user cannot delete a recommendation. """ # We create a separate user first u = User.register(first_name="Userrrr", last_name="Test", email="*****@*****.**", username="******", password="******", image_url=None, header_url=None) u.id = 589 # Now we create a recommendation made by testuser r = Recommendation( id=419, title="Fire Doughnuts in LA", content= "Bro these mf doughnuts be smacking like gahdamn!. Check out Leonards bro!", business_name="Leonards", business_address="2345 Rodeo Ave", business_city="Long Beach", business_state="CA", business_country="US", business_rating=5, user_id=self.testuser_id) db.session.add_all([u, r]) db.session.commit() with self.client as c: with c.session_transaction() as sess: sess[CURR_USER_KEY] = 589 resp = c.post("/recommendations/419/delete", follow_redirects=True) self.assertEqual(resp.status_code, 200) self.assertIn("Access unauthorized.", str(resp.data)) r = Recommendation.query.get(419) self.assertIsNotNone(r)
def recommend_form(drink_id): """Show form for posting recommendations, creates new recommendations from POST""" if 'user' not in session: flash('Please log in or sign up to send recommendations', 'danger') return redirect('/') form = RecommendForm() user_id = session['user'] user = User.query.get(user_id) drink = Drink.query.get(drink_id) form = RecommendForm() form.recommend_to_name.choices = [ (user.id, user.username) for user in User.query.filter(User.id != user_id).all() ] form.username.data = user.username form.drink.data = drink.name if request.method == 'POST': username = form.username.data recommend_to_id = form.recommend_to_name.data drink = form.drink.data user = User.query.filter(User.username == username).first() drink = Drink.query.filter(Drink.name == drink).first() new_recommend = Recommendation(recommender_id=user.id, recommend_to_user_id=recommend_to_id, drink_id=drink.id) db.session.add(new_recommend) db.session.commit() return redirect('/user/favorites') else: return render_template('form.html', form=form, drink_id=drink_id)
def post(self): """ Creates a Recommendation This endpoint will create a Recommendations based the data in the body that is posted. We assume when a user ask for a recommendation they will provide a Product Id And a Type in the following format: { 'product_id': <int>, 'type': '<[up-sell|accessory|cross-sell]>' } """ #data = request.get_json() rec = Recommendation() rec.deserialize(api.payload) rec.save() location_url = api.url_for(RecommendationResource, recommendation_id=rec.id, _external=True) return rec.serialize(), status.HTTP_201_CREATED, { 'Location': location_url }
def test_recommendation_model(self): """Does the basic recommendation model work?""" r = Recommendation( title="The best burger in the world", content= "The best burger in the entire world definitely is Marcos Famous DT Edmonton", business_name="Marcos Famous", business_address="13425 36 Ave NW", business_city="Edmonton", business_state="Alberta", business_country="Canada", business_rating=4, user_id=self.uid) db.session.add(r) db.session.commit() # User should have 1 message self.assertEqual(self.user.recommendations[0].business_country, "Canada") self.assertEqual(self.user.recommendations[0].business_rating, 4) self.assertEqual(len(self.user.recommendations), 1)
def add_like(username, movie_id): """Handle Likes""" find_fav(movie_id) favorites = find_fav(movie_id) #update the form data id = favorites['ID'] title_id = favorites['Title'] actors = favorites['Actors'] plot = favorites['Plot'] username = favorites['Username'] #Movie Model Blueprint movie = Recommendation(id=(id), title_id=(title_id), actors=(actors), plot=(plot), username=(username)) db.session.add(movie) db.session.commit() return redirect(f"/users/{username}")