303 lines
10 KiB
Python
303 lines
10 KiB
Python
import logging
|
|
import datetime
|
|
from decimal import Decimal
|
|
|
|
from django.db.models import Q
|
|
from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector, TrigramSimilarity
|
|
from django.db.models import Max, Min
|
|
from django.conf import settings
|
|
from django.utils import timezone
|
|
from django.contrib.gis.geos import Point
|
|
from django.contrib.gis.measure import D
|
|
|
|
import requests
|
|
|
|
from products.models import Product
|
|
from companies.models import Company
|
|
from history.models import HistorySync
|
|
from PIL import Image
|
|
from io import BytesIO
|
|
from django.core.files import File
|
|
|
|
|
|
logging.basicConfig(
|
|
filename='logs/csv-load.log',
|
|
filemode='w',
|
|
format='%(levelname)s:%(message)s',
|
|
level=logging.INFO,
|
|
)
|
|
|
|
|
|
def extract_search_filters(result_set):
|
|
"""
|
|
Returned object should look something like:
|
|
|
|
{
|
|
"tags": {
|
|
'singles': set(),
|
|
'header1': []
|
|
},
|
|
"attributes": {
|
|
'singles': set(),
|
|
'header1': []
|
|
},
|
|
}
|
|
"""
|
|
filter_dict = {
|
|
"tags": {
|
|
'singles': set(),
|
|
},
|
|
"attributes": {
|
|
'singles': set(),
|
|
}
|
|
}
|
|
for item in result_set:
|
|
try:
|
|
# extract tags
|
|
tags = item.tags.all()
|
|
for tag in tags:
|
|
if len(tag.name.split('/')) == 1:
|
|
filter_dict['tags']['singles'].add(tag.name)
|
|
else:
|
|
# set penultimate tag as header
|
|
chunks = tag.name.split('/')
|
|
header = chunks[-2]
|
|
name = chunks[-1]
|
|
# check if
|
|
entry = filter_dict['tags'].get(header)
|
|
if entry is None:
|
|
filter_dict['tags'][header] = set()
|
|
filter_dict['tags'][header].add(name)
|
|
# extract attributes
|
|
attributes = item.attributes.all()
|
|
for tag in attributes:
|
|
if len(tag.name.split('/')) == 1:
|
|
filter_dict['attributes']['singles'].add(tag.name)
|
|
else:
|
|
# set penultimate tag as header
|
|
chunks = tag.name.split('/')
|
|
header = chunks[-2]
|
|
name = chunks[-1]
|
|
# check if
|
|
entry = filter_dict['attributes'].get(header)
|
|
if entry is None:
|
|
filter_dict['attributes'][header] = set()
|
|
filter_dict['attributes'][header].add(name)
|
|
except Exception as e:
|
|
logging.error(f'Extacting filters for {item}')
|
|
return filter_dict
|
|
|
|
|
|
def get_related_products(product):
|
|
"""Make different db searches until you get 10 instances to return
|
|
"""
|
|
total_results = []
|
|
|
|
# search by category
|
|
category_qs = Product.objects.filter(category=product.category)[:10]
|
|
# add to results
|
|
for item in category_qs:
|
|
total_results.append(item)
|
|
|
|
# check size
|
|
if len(total_results) < 10:
|
|
# search by tags
|
|
tags_qs = Product.objects.filter(tags__in=product.tags.all())[:10]
|
|
# add to results
|
|
for item in tags_qs:
|
|
total_results.append(item)
|
|
|
|
# check size
|
|
if len(total_results) < 10:
|
|
# search by coop
|
|
coop_qs = Product.objects.filter(company=product.company)[:10]
|
|
# add to results
|
|
for item in coop_qs:
|
|
total_results.append(item)
|
|
|
|
# check size
|
|
if len(total_results) < 10:
|
|
# search by latest
|
|
latest_qs = Product.objects.order_by('-created')[:10]
|
|
# add to results
|
|
for item in coop_qs:
|
|
total_results.append(item)
|
|
|
|
return total_results[:10]
|
|
|
|
|
|
def ranked_product_search(keywords, shipping_cost=None, discount=None, category=None, tags=None, price_min=None,price_max=None, coordinates=None):
|
|
"""
|
|
Ranked product search
|
|
|
|
SearchVectors for the fields
|
|
SearchQuery for the value
|
|
SearchRank for relevancy scoring and ranking
|
|
|
|
allow filtering by:
|
|
- shipping cost
|
|
|
|
Response includes:
|
|
- result_set
|
|
- min_price
|
|
- max_price
|
|
- georesult
|
|
"""
|
|
vector = SearchVector('name') + SearchVector('description') + SearchVector('tags__label') + SearchVector('attributes__label') + SearchVector('category__label') + SearchVector('company__company_name')
|
|
|
|
query = SearchQuery(keywords, search_type='plain')
|
|
|
|
products_qs = Product.objects.annotate(
|
|
rank=SearchRank(vector, query)
|
|
).filter(rank__gt=0.05, active=True)
|
|
# geolocation filtering
|
|
if coordinates is not None:
|
|
point = Point(coordinates)
|
|
filtered_qs = products_qs.filter(company__geo__distance_lte=(point, D(km=10)))
|
|
georesult = '10k'
|
|
if filtered_qs.count() <= 10:
|
|
products_qs = products_qs.filter(company__geo__distance_lte=(point, D(km=50)))
|
|
georesult = '50k'
|
|
if filtered_qs.count() <= 10:
|
|
products_qs = products_qs.filter(company__geo__distance_lte=(point, D(km=200)))
|
|
georesult = '200k'
|
|
if filtered_qs.count() > 10:
|
|
products_qs = filtered_qs
|
|
else:
|
|
georesult = None
|
|
else:
|
|
georesult = None
|
|
|
|
# filter by category
|
|
if category is not None:
|
|
products_qs = products_qs.filter(category=category)
|
|
|
|
# filter by tags
|
|
if tags is not None:
|
|
products_qs = products_qs.filter(tags=tags)
|
|
|
|
# filter by shipping cost
|
|
if shipping_cost is True:
|
|
# only instances with shipping costs
|
|
products_qs = products_qs.filter(
|
|
Q(shipping_cost__isnull=False)&
|
|
Q(shipping_cost__gte=1)
|
|
)
|
|
elif shipping_cost is False:
|
|
# only intances without shpping costs
|
|
products_qs = products_qs.filter(Q(shipping_cost=None)|Q(shipping_cost=0.00))
|
|
|
|
# filter by discount
|
|
if discount is True:
|
|
# only instances with shipping costs
|
|
products_qs = products_qs.filter(
|
|
Q(discount__isnull=False)&
|
|
Q(discount__gte=1)
|
|
)
|
|
elif discount is False:
|
|
# only intances without shpping costs
|
|
products_qs = products_qs.filter(Q(discount=None)|Q(discount=0.00))
|
|
|
|
# filter by price
|
|
if price_min is not None:
|
|
products_qs = products_qs.filter(price__gte=price_min)
|
|
if price_max is not None:
|
|
products_qs = products_qs.filter(price__lte=price_max)
|
|
|
|
# get min_price and max_price
|
|
min_price = products_qs.aggregate(Min('price'))
|
|
max_price = products_qs.aggregate(Max('price'))
|
|
|
|
|
|
return set(products_qs), min_price, max_price, georesult
|
|
|
|
|
|
def product_loader(csv_reader, user, company=None):
|
|
"""
|
|
Parse csv data and extract:
|
|
|
|
- product data
|
|
|
|
Returns count
|
|
"""
|
|
counter = 0
|
|
# get company
|
|
if company is None and user is not None:
|
|
if user.company is not None:
|
|
company = user.company
|
|
else:
|
|
# cannot add products without a company
|
|
return None
|
|
|
|
# create historysync instance
|
|
history = HistorySync.objects.create(company=company, sync_date=timezone.now())
|
|
for row in csv_reader:
|
|
# trim strings
|
|
for key in row:
|
|
try:
|
|
if row[key]:
|
|
if 'imagen' in key or 'categoria' in key:
|
|
row[key] = row[key].strip()
|
|
elif key in ['precio', 'gastos-envio']:
|
|
row[key] = Decimal(row[key][:-1].strip().replace(',','.'))
|
|
else:
|
|
row[key] = row[key].strip()
|
|
else:
|
|
row[key] = None
|
|
except Exception as e:
|
|
logging.error(f"Could not access key {key}: {str(e)}")
|
|
continue
|
|
# check required data
|
|
if '' in (row['nombre-producto'], row['descripcion'], row['precio'],):
|
|
logging.error(f"Required data missing: {row}")
|
|
continue
|
|
try:
|
|
# TODO: if tags is empty, auto-generate tags
|
|
# assemble instance data
|
|
product_data = {
|
|
'company': company,
|
|
'sku': row['sku'],
|
|
'name': row['nombre-producto'],
|
|
'description': row['descripcion'],
|
|
'url': row['url'].strip(),
|
|
'price': row['precio'],
|
|
'shipping_cost': row['gastos-envio'],
|
|
'shipping_terms': row['cond-envio'],
|
|
'discount': row['descuento'],
|
|
'stock': row['stock'],
|
|
'tags': row['tags'],
|
|
'category': row['categoria'],
|
|
'identifiers': row['identificadores'],
|
|
'history': history,
|
|
'creator': user,
|
|
# 'valid': True
|
|
}
|
|
|
|
product = Product.objects.create(**product_data)
|
|
# image logo data
|
|
if row['imagen'] is not None:
|
|
try:
|
|
# get image
|
|
headers={"User-Agent" : "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36"}
|
|
response = requests.get(row['imagen'], stream=True, headers=headers)
|
|
assert(response.status_code==200)
|
|
response.raw.decode_content = True
|
|
image = Image.open(response.raw)
|
|
# save using File object
|
|
img_io = BytesIO()
|
|
image.save(img_io, format=image.format)
|
|
product.image.save(f"{product.company.company_name}{product.name}.{image.format.lower()}", File(img_io), save=False)
|
|
product.save()
|
|
except AssertionError as e:
|
|
logging.error(f"Source image [{row['imagen']}] not reachable: {response.status_code}")
|
|
except Exception as e:
|
|
logging.error(f"Could not add image to product from [{row['imagen']}]: {str(e)}")
|
|
logging.info(f"Created Product {product.id}")
|
|
counter += 1
|
|
except Exception as e:
|
|
logging.error(f"Could not parse {counter}: {str(e)}")
|
|
|
|
history.quantity = counter
|
|
history.save()
|
|
return counter
|