brotherton-erpnext/erpnext/hub_node/api.py
2019-12-24 17:39:15 +05:30

232 lines
6.1 KiB
Python

from __future__ import unicode_literals
import frappe
import json
from frappe import _
from frappe.frappeclient import FrappeClient
from frappe.desk.form.load import get_attachments
from six import string_types
current_user = frappe.session.user
@frappe.whitelist()
def register_marketplace(company, company_description):
validate_registerer()
settings = frappe.get_single('Marketplace Settings')
message = settings.register_seller(company, company_description)
if message.get('hub_seller_name'):
settings.registered = 1
settings.hub_seller_name = message.get('hub_seller_name')
settings.save()
settings.add_hub_user(frappe.session.user)
return { 'ok': 1 }
@frappe.whitelist()
def register_users(user_list):
user_list = json.loads(user_list)
settings = frappe.get_single('Marketplace Settings')
for user in user_list:
settings.add_hub_user(user)
return user_list
def validate_registerer():
if current_user == 'Administrator':
frappe.throw(_('Please login as another user to register on Marketplace'))
valid_roles = ['System Manager', 'Item Manager']
if not frappe.utils.is_subset(valid_roles, frappe.get_roles()):
frappe.throw(_('Only users with {0} role can register on Marketplace').format(', '.join(valid_roles)),
frappe.PermissionError)
@frappe.whitelist()
def call_hub_method(method, params=None):
connection = get_hub_connection()
if isinstance(params, string_types):
params = json.loads(params)
params.update({
'cmd': 'hub.hub.api.' + method
})
response = connection.post_request(params)
return response
def map_fields(items):
field_mappings = get_field_mappings()
table_fields = [d.fieldname for d in frappe.get_meta('Item').get_table_fields()]
hub_seller_name = frappe.db.get_value('Marketplace Settings', 'Marketplace Settings', 'hub_seller_name')
for item in items:
for fieldname in table_fields:
item.pop(fieldname, None)
for mapping in field_mappings:
local_fieldname = mapping.get('local_fieldname')
remote_fieldname = mapping.get('remote_fieldname')
value = item.get(local_fieldname)
item.pop(local_fieldname, None)
item[remote_fieldname] = value
item['doctype'] = 'Hub Item'
item['hub_seller'] = hub_seller_name
item.pop('attachments', None)
return items
@frappe.whitelist()
def get_valid_items(search_value=''):
items = frappe.get_list(
'Item',
fields=["*"],
filters={
'disabled': 0,
'item_name': ['like', '%' + search_value + '%'],
'publish_in_hub': 0
},
order_by="modified desc"
)
valid_items = filter(lambda x: x.image and x.description, items)
def prepare_item(item):
item.source_type = "local"
item.attachments = get_attachments('Item', item.item_code)
return item
valid_items = map(prepare_item, valid_items)
return valid_items
@frappe.whitelist()
def publish_selected_items(items_to_publish):
items_to_publish = json.loads(items_to_publish)
items_to_update = []
if not len(items_to_publish):
frappe.throw(_('No items to publish'))
for item in items_to_publish:
item_code = item.get('item_code')
frappe.db.set_value('Item', item_code, 'publish_in_hub', 1)
hub_dict = {
'doctype': 'Hub Tracked Item',
'item_code': item_code,
'published': 1,
'hub_category': item.get('hub_category'),
'image_list': item.get('image_list')
}
if frappe.db.exists('Hub Tracked Item', item_code):
items_to_update.append(item)
hub_tracked_item = frappe.get_doc('Hub Tracked Item', item_code)
hub_tracked_item.update(hub_dict)
hub_tracked_item.save()
else:
frappe.get_doc(hub_dict).insert(ignore_if_duplicate=True)
items_to_publish = list(filter(lambda x: x not in items_to_update, items_to_publish))
new_items = map_fields(items_to_publish)
existing_items = map_fields(items_to_update)
try:
item_sync_preprocess(len(items))
convert_relative_image_urls_to_absolute(items)
# TODO: Publish Progress
connection = get_hub_connection()
connection.insert_many(new_items)
connection.bulk_update(existing_items)
item_sync_postprocess()
except Exception as e:
frappe.log_error(message=e, title='Hub Sync Error')
@frappe.whitelist()
def unpublish_item(item_code, hub_item_name):
''' Remove item listing from the marketplace '''
response = call_hub_method('unpublish_item', {
'hub_item_name': hub_item_name
})
if response:
frappe.db.set_value('Item', item_code, 'publish_in_hub', 0)
else:
frappe.throw(_('Unable to update remote activity'))
@frappe.whitelist()
def get_unregistered_users():
settings = frappe.get_single('Marketplace Settings')
registered_users = [user.user for user in settings.users] + ['Administrator', 'Guest']
all_users = [user.name for user in frappe.db.get_all('User', filters={'enabled': 1})]
unregistered_users = [user for user in all_users if user not in registered_users]
return unregistered_users
def item_sync_preprocess(intended_item_publish_count):
response = call_hub_method('pre_items_publish', {
'intended_item_publish_count': intended_item_publish_count
})
if response:
frappe.db.set_value("Marketplace Settings", "Marketplace Settings", "sync_in_progress", 1)
return response
else:
frappe.throw(_('Unable to update remote activity'))
def item_sync_postprocess():
response = call_hub_method('post_items_publish', {})
if response:
frappe.db.set_value('Marketplace Settings', 'Marketplace Settings', 'last_sync_datetime', frappe.utils.now())
else:
frappe.throw(_('Unable to update remote activity'))
frappe.db.set_value('Marketplace Settings', 'Marketplace Settings', 'sync_in_progress', 0)
def convert_relative_image_urls_to_absolute(items):
from six.moves.urllib.parse import urljoin
for item in items:
file_path = item['image']
if file_path.startswith('/files/'):
item['image'] = urljoin(frappe.utils.get_url(), file_path)
def get_hub_connection():
settings = frappe.get_single('Marketplace Settings')
marketplace_url = settings.marketplace_url
hub_user = settings.get_hub_user(frappe.session.user)
if hub_user:
password = hub_user.get_password()
hub_connection = FrappeClient(marketplace_url, hub_user.user, password)
return hub_connection
else:
read_only_hub_connection = FrappeClient(marketplace_url)
return read_only_hub_connection
def get_field_mappings():
return []