def ReturnSelectExecution(sql_query, query_var):
"""
Voert een query uit, met de meegegeven variabelen.
(Gaat uit van een 'SELECT' query waarbij data terug moet worden gehaald.)
Geeft de geselecteerde waardes terug.
"""
rdbcon, rdbcur = conrdb()
rdbcur.execute(sql_query, query_var)
returnvalue = []
try:
returnvalue = rdbcur.fetchone()[0]
rdbcur.close()
rdbcon.close()
except TypeError:
pass
return returnvalue
def return_selection(sql_query, query_var):
"""
Voert een query uit, met de meegegeven variabelen.
(Gaat uit van een 'SELECT' query waarbij data terug moet worden gehaald.)
Geeft de geselecteerde waardes terug.
:param sql_query: str: query die uitgevoerd moet worden
:param query_var: tuple: variabelen die nodig zijn om de query uit te voeren
:returns: opgevraagde element
"""
rdbcon, rdbcur = conrdb()
rdbcur.execute(sql_query, query_var)
returnvalue = []
try:
returnvalue = rdbcur.fetchone()[0]
rdbcur.close()
rdbcon.close()
except TypeError:
pass
return returnvalue
from time import perf_counter
from collections import Counter
from rdbconnection2 import conrdb
rdbcon, rdbcur = conrdb()
class Pactum:
"""
De similar recommendation class ofwel pactum. Hierin zitten alle
functies die je nodig hebt om met een instance van de class
similar recommendations te maken.
"""
def __init__(self, conn):
"""
De initiate functie deze word gecalled met een postgresql open connection
deze variabele word aan de instance toegewezen met "self" en zo kan elke functie
die self als parameter heeft de connectie gebruiken
"""
self.conn = conn
def get_n_recommended(self, product_id, n):
"""
Deze functie returned met een gegeven product-id een n aantal recommendations
"""
res = self.recommend_products(
product_id
) # vraag de response van de functie recommend_products deze returned een aantal lists in een dict
products = res["occurences"].most_common(
n
) # pak n aantal recommendations van de opgetelde lijst van de recomend_products functie
def get(self, profileid, count, type_rec, shopping_list, pagecat,
huidige_klik_events, productid):
""" This function represents the handler for GET requests coming in
through the API. It currently returns a random sample of products.
:param type_rec: str : is één van de keys uit 'recommendationtypes' huw.py
:param shopping_list: str: str met daarin de boodschappenlijst """
if type_rec == "popular":
pagecat = ast.literal_eval(pagecat)
cat = pagecat[0].replace("-", " ")
cat = cat.replace(" en ", " & ")
cat = cat.replace("make up", "make-up")
huidige_klik_events = ast.literal_eval(huidige_klik_events)
prodids = popularrec.return_recommended_products(
profileid, cat, huidige_klik_events)
prodids = [
niet_leeg_element for niet_leeg_element in prodids
if niet_leeg_element
]
elif type_rec == "similar":
pact = pactum.Pactum(personalrec.rdbcon)
products = pact.get_n_recommended(productid, count)
if products:
prodids = [p[0] for p in products]
else:
prodids = [] # todo alternative/fallback
elif type_rec == "combination":
mogelijke_genders = ['Man', 'Vrouw']
shopping_l = ast.literal_eval(shopping_list)
genders_in_shopping_list = []
uitvoerings_check = 0
for item in shopping_l:
gender1 = ReturnSelectExecution(
"""SELECT gender from product Where product_id = %s""",
[item[0]])
genders_in_shopping_list.append(gender1)
if 'Man' in genders_in_shopping_list:
uitvoerings_check += 1
if 'Vrouw' in genders_in_shopping_list:
uitvoerings_check += 1
if uitvoerings_check == 2:
hoeveelheid_man = 0
hoeveelheid_vrouw = 0
gender_count_list = [hoeveelheid_man, hoeveelheid_vrouw]
prod_man_list = []
prod_vrouw_list = []
bruikbare_producten = []
prodids = []
for i in shopping_l:
product_data = ReturnSelectExecution(
"SELECT array[gender, sub_category] FROM product WHERE product_id = %s",
[i[0]])
if product_data[0] in mogelijke_genders:
if product_data[0] == 'Man':
hoeveelheid_man += 1
prod_man_list.append(i[0])
if product_data[0] == 'Vrouw':
hoeveelheid_vrouw += 1
prod_vrouw_list.append(i[0])
if hoeveelheid_vrouw >= hoeveelheid_man:
product = prod_vrouw_list[0]
if hoeveelheid_man > hoeveelheid_vrouw:
product = prod_man_list[0]
gender = product_data[0]
sub_category = product_data[1]
index = mogelijke_genders.index(gender)
for i in range(4):
output = ReturnSelectExecution(
"SELECT product_id FROM product WHERE sub_category=%s AND gender=%s ORDER BY RANDOM() LIMIT 1",
[sub_category, mogelijke_genders[index - 1]])
prodids.append(output)
else:
randcursor = database.products.aggregate([{
'$sample': {
'size': count
}
}])
prodids = list(map(lambda x: x['_id'], list(randcursor)))
elif type_rec == "personal":
prodids = personalrec.giveRecommendation(profileid)
elif type_rec == "behaviour":
rdbcon, rdbcur = conrdb()
huidige_klik_events = ast.literal_eval(huidige_klik_events)
fyp_list = [
p for product in huidige_klik_events for p in pactum.Pactum(
rdbcon).recommend_products(product)["products"]
]
prodids = [prod[0] for prod in Counter(fyp_list).most_common(4)]
else:
randcursor = database.products.aggregate([{
'$sample': {
'size': count
}
}])
prodids = list(map(lambda x: x['_id'], list(randcursor)))
return prodids, 200