Presik
/
trytonpsk-sale_web_channel
mirror of https://bitbucket.org/presik/trytonpsk-sale_web_channel.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
trytonpsk-sale_web_channel/web.py

327 lines
13 KiB
Python
Raw Permalink Blame History

from trytond.model import fields, ModelView
from trytond.pool import PoolMeta, Pool
from trytond.pyson import Eval, And
from datetime import datetime, timedelta
from trytond.wizard import (Wizard, StateTransition, StateView, Button)
from .exceptions import ErrorSynchronizingSale
from trytond.i18n import gettext
from trytond.transaction import Transaction
from . mercado_libre import MercadoLibre
from . shopify import Shopify
from . import rappi
TYPES = [
('', ''),
('mercadolibre', 'Mercado Libre'),
('melhous', 'Melhous'),
('shopify', 'Shopify'),
('rappi', 'Rappi'),
]
TYPE_INVOICE = [
('', ''),
('C', 'Computador'),
('P', 'POS'),
('M', 'Manual'),
('1', 'Venta Electronica'),
('2', 'Exportacion'),
('3', 'Factura por Contingencia Facturador'),
('4', 'Factura por Contingencia DIAN'),
('91', 'Nota Crédito Eléctronica'),
('92', 'Nota Débito Eléctronica'),
]
# TODO FOR EXECUTE in database
"""
alter database rename table sale_web_channel to web_shop
RENAME COLUMN channel_name by type
RENAME COLUMN creation_time by token_create_date
"""
class Shop(metaclass=PoolMeta):
__name__ = 'web.shop'
secret_key = fields.Char('Secret Key')
app_id = fields.Char('Application ID')
redirect_uri = fields.Char('Redirect URI', states={
'invisible': (Eval('type') != 'mercadolibre'),
})
authorization_code = fields.Char('Authorization Code', states={
'invisible': (Eval('type') != 'mercadolibre'),
})
shop = fields.Many2One('sale.shop', 'Shop', domain=[
('company', '=', Eval('company'))
])
access_token = fields.Char('Access Token', states={
'invisible': And(
Eval('type') != 'mercadolibre',
Eval('type') != 'rappi'),
})
token_create_date = fields.DateTime('Token Create Date', states={
'invisible': (Eval('type') != 'mercadolibre'),
})
status_token = fields.Function(fields.Selection([
('expired', 'Expired'),
('active', 'Active'),
], 'Status Token', readonly=True, states={
'invisible': (Eval('type') != 'mercadolibre'),
}), 'get_status_token')
refresh_token = fields.Char('Refresh Token', states={
'invisible': (Eval('type') != 'mercadolibre'),
})
# state = fields.Selection([
# ('draft', 'Draft'),
# ('active', 'Active'),
# ('finished', 'Finished'),
# ], 'State', select=True, readonly=True)
freight_product = fields.Many2One('product.product', 'Freight Product')
# states=STATES)
bonus_product = fields.Many2One('product.product', 'Bonus Product', states={
'invisible': (Eval('type') != 'mercadolibre'),
})
tip_product = fields.Many2One('product.product', 'Tip Product', states={
'invisible': (Eval('type') != 'shopify'),
})
generic_product = fields.Many2One('product.product', 'Generic Product', states={
'invisible': (Eval('type') != 'shopify'),
})
report = fields.Many2One('ir.action.report', 'Report')
invoice_type = fields.Selection(TYPE_INVOICE, 'Type Invoice')
seller_id = fields.Char('Seller ID', states={
'invisible': ~Eval('type').in_(['mercadolibre', 'rappi']),
})
password_api = fields.Char('Api Password', states={
'invisible': (Eval('type') != 'shopify'),
})
host_name = fields.Char('Host Name', states={
'invisible': And(
Eval('type') != 'shopify',
Eval('type') != 'rappi'),
})
api_key = fields.Char('Api Key', states={
'invisible': (Eval('type') != 'shopify'),
})
price_list = fields.Many2One('product.price_list', 'Price list', ondelete="RESTRICT")
@classmethod
def __setup__(cls):
super(Shop, cls).__setup__()
cls.type.selection = TYPES
cls._buttons.update({
'generate_token_access': {
'invisible': ~Eval('type').in_(['mercadolibre', 'rappi']),
},
'send_products': {
'invisible': ~Eval('type').in_(['mercadolibre', 'rappi']),
},
'get_orders': {
'invisible': ~Eval('type').in_(['mercadolibre', 'rappi']),
},
})
def get_status_token(self, name):
if self.token_create_date:
now = datetime.now()
res = (now - self.token_create_date).total_seconds()
if res >= 21600:
return 'expired'
else:
return 'active'
else:
return 'expired'
@classmethod
@ModelView.button
def generate_token_access(cls, records):
if records:
for record in records:
if record.type == 'mercadolibre':
# MercadoLibre = Pool().get('web.shop')
mercadolibre_rec = MercadoLibre(record)
# record.access_token, refresh_token, client_id, client_secret = mercadolibre_rec._validate_token()
record.access_token = mercadolibre_rec._validate_token()
record.save()
if record.type == 'rappi':
rappi_rec = rappi.Rappi(record)
record.access_token = rappi_rec.get_token_access()['access_token']
record.save()
@classmethod
@ModelView.button
def send_products(cls, records):
for record in records:
if record.type == 'rappi':
rappi_rec = rappi.Rappi(record)
rappi_rec.synchronize_menu_rappi(record.products, record.categories)
@classmethod
@ModelView.button
def get_orders(cls, records):
for record in records:
if record.type == 'rappi':
rappi_rec = rappi.Rappi(record)
rappi_rec.create_sales()
class SynchronizeChannelOrdersStart(ModelView):
'Synchronize Channel orders Start'
__name__ = 'sale_web_channel.synchronize_orders.start'
company = fields.Many2One('company.company', 'Company', required=True)
shop = fields.Many2One('sale.shop', 'Shop', required=True, domain=[
('company', '=', Eval('company'))
])
channel = fields.Many2One('web.shop', 'Channel', required=True,
domain=[
('shop', '=', Eval('shop'))
])
operation = fields.Selection([
('', ''),
('orders_for_day', 'Orders for day'),
('especific_order', 'Especific Orders')
], 'Operation', required=True)
type = fields.Selection([
('', ''),
('shopify', 'Shopify'),
('mercadolibre', 'Mercado libre')
], 'Name Channel', required=True)
order_id = fields.Char('Order ID', states={
'invisible': (Eval('operation') != 'especific_order'),
'required': (Eval('operation') == 'especific_order'),
})
date = fields.Date('Date', states={
'invisible': (Eval('operation') != 'orders_for_day'),
'required': (Eval('operation') == 'orders_for_day'),
})
date_end = fields.Date('Finish Date', states={
'invisible': (Eval('operation') != 'orders_for_day') | (Eval('name_channel') != 'shopify'),
'required': (Eval('operation') == 'orders_for_day') & (Eval('name_channel') != 'mercadolibre'),
})
@staticmethod
def default_company():
return Transaction().context.get('company')
@fields.depends('channel')
def on_change_channel(self):
self.type = self.channel.type if self.channel else None
class SynchronizeChannelOrders(Wizard):
'Synchronize Channel Orders'
__name__ = 'sale_web_channel.synchronize_orders'
start = StateView('sale_web_channel.synchronize_orders.start',
'sale_web_channel.synchronize_orders_view_form', [
Button('Cancel', 'end', 'tryton-cancel'),
Button('Create', 'accept',
'tryton-ok', default=True),
])
accept = StateTransition()
done = StateView('sale_web_channel.synchronize_orders.done',
'sale_web_channel.synchronize_orders_done', [
Button('Done', 'end', 'tryton-ok', default=True),
])
@classmethod
def __setup__(cls):
super(SynchronizeChannelOrders, cls).__setup__()
def transition_accept(self):
pool = Pool()
Sale = pool.get('sale.sale')
channel = self.start.channel
operation = self.start.operation
if channel.type == 'mercadolibre':
mercado_libre = MercadoLibre(channel)
if operation == 'especific_order':
order_id = self.start.order_id
result = mercado_libre._validate_number_id(order_id, channel.access_token)
if not result:
raise ErrorSynchronizingSale(
gettext('sale_web_channel.msg_error_synchronizing_sale', s=result))
sale_created = result
if sale_created:
generic_code = self.start.channel.generic_product.code if self.start.channel.generic_product else None
product_generic = [
line.product.code for line in sale_created.lines if line.product.code == generic_code and generic_code]
if not sale_created.pack_id and \
sale_created.comment in ['shipped', 'delivered'] and \
len(product_generic) < 1:
Sale.process([sale_created])
else:
date_from = str(self.start.date) + 'T00:00:00.000-00:00'
date_to = str(self.start.date + timedelta(days=1)
) + 'T00:00:00.000-00:00'
URI = 'https://api.mercadolibre.com/orders/search?seller=%s&order.date_created.from=%s&order.date_created.to=%s&access_token=%s&order.status=paid' % (
channel.seller_id, date_from, date_to, channel.access_token)
result = MercadoLibre.get_response(URI).json()
for res in result['results']:
sales = Sale.search([('reference', 'like', '%' + str(res['id']) + '%' )])
shipment_status = ''
if not sales:
sale_created = channel.validate_sale(res)
shipment_status = sale_created.comment
sales = [sale_created]
else:
sfm_id = res['shipping']['id']
shipment_ = channel.get_shipment_api(sfm_id)
shipment_status = shipment_['status']
if res.get('pack_id') or not shipment_status:
continue
if shipment_status in ['shipped', 'delivered']:
for sale in sales:
if not sale.invoices:
Sale.process([sale])
if channel.type == 'shopify':
shopify = Shopify(channel)
# channel, = Shopify.search([('shop', '=', self.start.shop.id), ])
if operation == 'especific_order':
order_id = self.start.order_id
URI = 'https://%s:%s@%s/admin/api/2020-10/orders.json?status=any&ids=%s' % (
channel.api_key, channel.password_api, channel.host_name, order_id)
result = shopify.get_response(URI).json()
if not result:
raise ErrorSynchronizingSale(
gettext('sale_web_channel.msg_error_synchronizing_sale', s=result))
sale_created = shopify._create_sale(result['orders'][0])
if sale_created and \
sale_created.description.count('fulfilled'):
Sale.process([sale_created])
else:
date_from = str(self.start.date) + 'T00:00:00.000-00:00'
date_to = str(self.start.date_end) + 'T00:00:00.000-00:00'
URI = 'https://%s:%s@%s/admin/api/2020-10/orders.json?status=any&created_at_min=%s&created_at_max=%s' % (
channel.api_key, channel.password_api, channel.host_name, date_from, date_to)
result = Shopify.get_response(URI).json()
print('quantity orders----> ', len(result['orders']))
for res in result['orders']:
sales = Sale.search([('reference', '=', str(res['id']))])
fulfillment_status = ''
if not sales:
sale_created = channel._create_sale(res)
fulfillment_status = sale_created.description
sales = [sale_created]
else:
fulfillment_status = res['fulfillment_status']
if not fulfillment_status:
continue
if fulfillment_status.count('fulfilled'):
for sale in sales:
if not sale.invoices:
Sale.process([sale])
return 'done'
class SynchronizeChannelOrdersDone(ModelView):
'Synchronize Channel Orders Done'
__name__ = 'sale_web_channel.synchronize_orders.done'
result = fields.Char('Result', readonly=True)
@staticmethod
def default_result():
return 'successful synchronization'
Reference in New Issue View Git Blame Copy Permalink