def getcustomfields():
"""
Grab the discogs custom fields and insert/update the db
"""
for idx in range(len(user.collection_fields)):
query = None
# Check field table for field
db_instance = dbq.exec_db_query_dict(dbq.get_field,
user.collection_fields[idx].id)
if db_instance == None:
query = dbq.custom_field_insert
query_data = {
'field_id': user.collection_fields[idx].id,
'field_name': user.collection_fields[idx].name,
'insert_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
elif db_instance['field_name'] != user.collection_fields[idx].name:
query = dbq.custom_field_update
query_data = {
'field_id': user.collection_fields[idx].id,
'field_name': user.collection_fields[idx].name,
'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
if query != None:
dbq.exec_db_query(query, query_data, query_type='insert')
def saleschannels(type, stores):
"""
Type is either new or update
"""
if type == "new":
query = dbq.insert_sales_channels
get_query = dbq.get_new_instance_notes
date_field = "insert_date"
elif type == "update":
query = dbq.update_sales_channels
get_query = dbq.get_updated_instance_notes
date_field = "update_date"
db_instance_notes = dbq.exec_db_query_dict(get_query, qty="all")
for inst_idx in range(len(db_instance_notes)):
channels = {}
notes = list(eval(db_instance_notes[inst_idx]['notes']))
for notes_idx in range(len(notes)):
store = dict_switcher(notes[notes_idx]['field_id'], stores)
if store != None:
notes[notes_idx]['value']
channels[store] = notes[notes_idx]['value']
query_data = {
'instance_id': db_instance_notes[inst_idx]['instance_id'],
'sales_channels': str(channels),
date_field: datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
dbq.exec_db_query(query, query_data, query_type='insert')
def discogs_update_releases():
# FIXME: This is a copy on the new function, should probably combine them
"""
Get/Update release table
"""
import_new_releases = dbq.exec_db_query(dbq.get_new_release_list,
qty='all')
import_new_releases = [i[0] for i in import_new_releases]
for index in range(len(import_new_releases)):
release = discogs.release(import_new_releases[index])
release_data = {
'release_id': release.id,
'title': release.title,
'artists': str(release.artists),
'labels': str(release.labels),
'styles': str(release.styles),
'genres': str(release.genres),
'url': str(release.url),
'discogs_date_added': release.date_added,
'discogs_date_changed': release.date_changed,
'insert_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
dbq.exec_db_query(dbq.import_update_release,
release_data,
query_type='insert')
def startup(process):
run_id = str(uuid.uuid4())
query = dbq.start_run
query_data = {'process': process,
'run_id': run_id,
'start_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
dbq.exec_db_query(query, query_data, query_type='insert')
return run_id
def update_attrib_term_list(attrib_name, attrib_id):
"""
Passed the Woo attribute type and woo id, query attribute table for new terms and populate Woo
"""
query_data = attrib_name
query = dbq.woo_get_new_attribs
new_terms = dbq.exec_db_query_dict(query, query_data, qty="all")
for idx in range(len(new_terms)):
data = {"name": new_terms[idx]['attrib_term']}
created = wcapi.post("products/attributes/" + str(attrib_id) + "/terms", data).json()
query_data = {'woo_attrib_id': created["id"],
'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'id': new_terms[idx]['id'] }
query = dbq.update_attribs_woo_id
dbq.exec_db_query(query, query_data, query_type='insert')
def process_products(type, db_products):
"""
Take list of new instance id's, create product page and update instance table with Woo ID
"""
if type == "new":
query = dbq.insert_woo_instance_product
date_field = "insert_date"
elif type == "update":
query = dbq.update_woo_instance_product
date_field = "update_date"
for idx in range(len(db_products)):
# Get instance data from db
instance_data = dbq.exec_db_query_dict(dbq.get_instance_info, db_products[idx]['instance_id'])
dov_sales_status = eval(dbq.exec_db_query_dict(dbq.get_sales_channels, db_products[idx]['instance_id'])['sales_channels'])['Sell on DoV']
# Get release data from Discogs
# release_data = dbq.exec_db_query_dict(dbq.get_release_info, instance_data['release_id'])
release_data = discogs.release(db_products[idx]['release_id'])
# Send data to formater
product_data = formatproduct(instance_data, release_data, dov_sales_status, type)
# Create Woo Product
if type == "new":
product_endpoint = "products"
elif type == "update":
product_endpoint = ("products/" + str(db_products[idx]['woo_id']))
try:
woo_product = wcapi.post(product_endpoint, product_data).json()
except:
print("Instance ID: " + str(db_products[idx]['instance_id']) + " threw an error during a " + type + " product operation talking to Woo. ")
continue
# Update DB with Woo Product ID
query_data = {"woo_id": woo_product['id'],
"instance_id": db_products[idx]['instance_id'],
date_field: datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
dbq.exec_db_query(query, query_data, query_type='insert')
def getattribs(attrib_name):
query_data = []
query = dbq.get_discogs_attribs.format(attrib_name)
dbattribs = dbq.exec_db_query(query, qty='all')
for idx1 in range(len(dbattribs)):
row = eval(dbattribs[idx1][0])
if row != None:
for idx2 in range(len(row)):
query_data.append(row[idx2])
query_data = list(zip(set(query_data)))
insert_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
query_data = [(attrib_name, ) + xs + (insert_date, ) for xs in query_data]
query = dbq.insert_attribs_tmp
dbq.exec_db_query(query, query_data, query_type="insert", query_many="yes")
# insert new genres
dbq.exec_db_query(dbq.update_attribs)
# Truncate temp table
dbq.exec_db_query(dbq.truncate_attribs_tmp)
def discogsImport(discogs_folder):
"""
Imports discogs collections to table
"""
# Set collection
collection = user.collection_folders
# Populate import table
for album in collection[discogs_folder].releases:
query = None
# Concatenate notes
hashing_note = None
if album.notes != None:
for idx in range(len(album.notes)):
hashing_note = str(hashing_note) + str(
album.notes[idx]['field_id']) + str(
album.notes[idx]['value'])
# Hash the notes
notes_chksum = hashNotes(hashing_note)
# Query instance table for instance
db_instance = dbq.exec_db_query_dict(dbq.get_instance_info,
album.instance_id)
# New items
if db_instance == None:
# Build insert data
query_data = {
'instance_id': album.instance_id,
'rating': album.rating,
'title': album.release.title,
'folder_id': album.folder_id,
'discogs_date_added': album.date_added,
'notes': str(album.notes),
'notes_chksum': notes_chksum.hexdigest(),
'release_id': album.id,
'insert_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
}
query = dbq.add_instance
dbq.exec_db_query(query, query_data, query_type='insert')
# Test for existing and changed
elif db_instance['instance_id'] == album.instance_id and \
(db_instance['notes_chksum'] != notes_chksum.hexdigest() or
db_instance['folder_id'] != album.folder_id or
db_instance['release_id'] != album.id ):
# Update notes if hash is different
if db_instance['notes_chksum'] != notes_chksum.hexdigest():
query_data = {
'notes': str(album.notes),
'notes_chksum': notes_chksum.hexdigest(),
'update_date':
datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'instance_id': album.instance_id,
'release_id': album.id
}
query = dbq.update_instance_notes_chksum
dbq.exec_db_query(query, query_data, query_type='insert')
# Update folder id
if db_instance['folder_id'] != album.folder_id:
query_data = {
'folder_id': album.folder_id,
'update_date':
datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'instance_id': album.instance_id
}
query = dbq.update_instance_folder_id
dbq.exec_db_query(query, query_data, query_type='insert')
if db_instance['release_id'] != album.id:
query_data = {
'release_id': album.id,
'instance_id': album.instance_id
}
query = dbq.update_instance_release_id
dbq.exec_db_query(query, query_data, query_type='insert')
def finished(run_id):
query = dbq.finish_run
query_data = {'finish_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'complete': True,
'run_id': run_id}
dbq.exec_db_query(query, query_data, query_type='insert')
