Exemple #1
0
def shipping_of_packet( request):
    shipper = 'MRW'
    json_data=json.loads(request.body)
    orders_draw = json_data.get('orders')
    amount=json_data.get('amount')
    guide_shipping = json_data.get('guide_shipping')
    orders = Order.objects.filter(store_order_id__in=orders_draw)

    if len(orders) != len(orders_draw):
        bad_orders = set(orders_draw)
        for order in orders:
            bad_orders.discard(order.store_order_id)

        return JsonResponse({
            'ok':False,
            'msg': f'El envio {guide_shipping}. No se pudo registrar porque la(s) siguiente(s) \
ordene(s) no corresponden con nuestra base de datos. \n{bad_orders}'
        })

    destination = orders[0].destination_place
    for order in orders:
        if destination != order.destination_place:
            destination = ''
            break
    
    if not destination:
        return JsonResponse({
            'ok':False,
            'msg': f'{request.user.first_name}. La guia {guide_shipping} contiene ordenes que debian\
ser enviadas a direcciones distintas. Contacta urgentemente a un supervisor.'
        })

    request_shipping = new_shipping(guide_shipping,amount,shipper,destination)

    if not request_shipping.get('ok'):
        return JsonResponse(request_shipping)

    shipping=request_shipping.get('data')
    bulk_mgr = BulkCreateManager()
    msg = f'Paquete enviado bajo en numero de guia: {guide_shipping}'
    for orden in orders:
        order.state=Order.INTERNATIONAL_DEPARTURE
        order.shipping = shipping
        bulk_mgr.update(order,{'state','shipping'})
        New.objects.create(
            user=request.user,
            message=msg,
            order=order
        )
    
    bulk_mgr.done()

    return JsonResponse({
        'ok':True,
        'msg':f'Envio {guide_shipping}, Registrado con exito.'
    })
    def update_products(self, list_ids):
        logging.getLogger('log_three').info(
            f'Actualizando {len(list_ids)} productos. \n')
        products = Product.objects.filter(provider_sku__in=list_ids)
        path = '/items'
        params = [{
            'ids': ids,
            'attributes': 'id,price,initial_quantity,status,currency_id',
        } for ids in self.split_ids(list_ids)]
        results = self.map_pool_get([path] * len(params), params)
        products_draw = {
            product['body']['id']: product['body']
            for product in results if product.get('body')
        }
        BM = BusinessModel.objects.get(pk=self.SELLER_ID)
        bulk_mgr = BulkCreateManager()
        for product in products:
            id = product.provider_sku
            if id in products_draw:
                if not products_draw[id].get('initial_quantity'):
                    logging.getLogger('log_three').warning(
                        f'Producto {id} NO ACTUALIZADO')
                    continue
                if not products_draw[id]['status'] == 'active':
                    products_draw[id]['initial_quantity'] = 0
                logging.getLogger('log_three').info(
                    f"{product}: quantity: {product.quantity} \
-> {products_draw[id]['initial_quantity']}")
                product.quantity = products_draw[id]['initial_quantity']
                if products_draw[id]['currency_id'] == 'USD':
                    cost_price = ceil(products_draw[id]['price'])
                else:
                    cost_price = ceil(products_draw[id]['price'] / BM.trm)
                sale_cost = ceil(
                    (cost_price + BM.shipping_vzla) * (1 + BM.meli_tax / 100) *
                    (1 + BM.utility / 100))
                product.cost_price = cost_price
                product.sale_price = sale_cost
                product.last_update = timezone.localtime()
                bulk_mgr.update(
                    product,
                    {'quantity', 'cost_price', 'sale_price', 'last_update'})
        bulk_mgr.done()
    def scan_product(self, list_ids):
        path = '/items'
        params = [{
            'ids': ids,
            'attributes': 'id,pictures',
        } for ids in self.split_ids(list_ids)]
        results = self.map_pool_get([path] * len(params), params)

        products_draw = {
            product['body']['id']: product
            for product in results if product.get('body')
        }
        products = Product.objects.filter(
            provider_sku__in=products_draw.keys(), available=True)
        product_with_img = Picture.objects.filter(
            product__in=products).values_list('product', flat=True)
        if product_with_img:
            products = products.exclude(id__in=product_with_img)

        bulk_mgr = BulkCreateManager(250)
        for product in products:
            sku = product.provider_sku
            if not products_draw[sku].get('body'):
                logging.getLogger('log_three').warning(
                    f'Error en la peticion de {product}. Res: {products_draw[sku]}'
                )
                continue
            elif not products_draw[sku]['body'].get('pictures'):
                logging.getLogger('log_three').warning(
                    f'Al producto {product} no se le encontraron imagenes')
                continue

            for image in products_draw[sku]['body']['pictures']:
                if 'resources/frontend/statics/processing' in image[
                        'secure_url']:
                    logging.getLogger('log_three').warning(
                        'Imagen [Procesando por Meli]')
                    continue
                picture = Picture(src=image['secure_url'], product=product)
                bulk_mgr.add(picture)
        bulk_mgr.done()
Exemple #4
0
def received_packet( request, order_id):
    _order = Order.objects.filter(store_order_id=order_id).select_related('shipping').first()
    if not _order:
        return JsonResponse({
            'ok':False,
            'msg': 'Error pedido no encontrado.'
        })

    shipping = _order.shipping
    result = shipment_completed(shipping)
    if not result.get('ok'):
        return JsonResponse(result)

    orders = Order.objects.filter(shipping=shipping).select_related('product').select_related('product__product')

    bulk_mgr = BulkCreateManager()
    number_products = 0
    msg = 'El paquete donde se envio el producto fue recibido.'
    for order in orders:
        New.objects.create(
            user=request.user,
            message=msg,
            order=order
        )

        order.state=Order.RECEIVED_STORE
        number_products += order.quantity
        bulk_mgr.update(order, {'state'})

    bulk_mgr.done()

    message = f'Solicitud Exitosa. El paquete contenia {number_products} producto(s).\
A continuacion se listan los numeros de pedidos con sus respectivos paquetes productos:'
    for order in orders:
        message += f'\nPedido: {order.store_order_id} -> {order.quantity} {order.product.product.title}.'
    return JsonResponse({
        'ok':True,
        'msg': message
    })
class ScraperCategory(Meli):

    category_path = '/categories'
    bulk_mgr = BulkCreateManager()

    def __init__(self):
        Meli.__init__(self)
        self._ids = list()
        self._categories = dict()

    @property
    def ids(self):
        if not self._categories:
            categories = Category.objects.all()
            for category in categories:
                self._categories[category.id] = category
            self._ids = categories.values_list('id', flat=True)
        return self._ids

    @property
    def array(self):
        if not self._categories:
            categories = Category.objects.all()
            for category in categories:
                self._categories[category.id] = category
            self._ids = categories.values_list('id', flat=True)
        return self._categories

    def _set_array(self, id, root, parent, name, approved=False):
        if 'M' == id[0]:
            id = int(id[3:])
        if 'M' == root[0]:
            father = int(father[3:])
        if not id in self.ids:
            parents = Category.objects.filter(id__in=[root, parent])
            self._categories[id] = Category.objects.create(
                id=id,
                root=parents.get(id=root),
                parent=parents.get(id=parent),
                name=name,
                approved=approved)
            self._ids.append(id)

    def scraping_path(self, category_root):
        result = self.get(
            path=f'{self.category_path}/{category_root}',
            params={
                'attributes':
                'id,name,children_categories,total_items_in_this_category,path_from_root'
            })
        children_categories = result.get('children_categories')
        if result.get('id'):
            current_category_id = int(result['id'][3:])
            current_category = Category.objects.filter(
                id=current_category_id).first()
            if not current_category:
                current_category = Category.objects.create(
                    id=current_category_id, name=result['name'])
            elif not children_categories:
                current_category.leaf = True
                current_category.save()
            logging.getLogger('log_three').info(
                f'Padre {current_category} - {len(children_categories)} subcategorias - {result["total_items_in_this_category"]} Items'
            )
        else:
            logging.getLogger('log_three').warn(result)
        if children_categories:
            next_level = list()
            self._categories = dict()
            root_id = int(result['path_from_root'][0]['id'][3:])
            root = self.array[root_id]

            for category in children_categories:
                id = int(category['id'][3:])
                items = int(category['total_items_in_this_category'])
                name = category['name']
                leaf = (items < 10_000)
                if not id in self.ids:
                    self.bulk_mgr.add(
                        Category(id=id,
                                 parent=current_category,
                                 root=root,
                                 name=name,
                                 leaf=leaf))
                else:
                    _category = self.array[id]
                    _category.parent = current_category
                    _category.root = root
                    _category.leaf = leaf
                    self.bulk_mgr.update(_category, {'root', 'parent', 'leaf'})
                logging.getLogger('log_three').info(
                    f'<{id}:{name}[{items} items]>')
                if not leaf:
                    next_level.append(category['id'])

            self.bulk_mgr.done()

            for category in next_level:
                logging.getLogger('log_three').info('-' * 30)
                self.scraping_path(category)

    def update(self, id):
        if not int(id[3:]) in self.ids:
            path = f'/categories/{id}'
            result = self.get(path)
            name = result['name']
            root = result['path_from_root'][0]['id']
            len_path = len(result['path_from_root'])
            parent = result['path_from_root'][len_path - 1]['id']
            if int(root[3:]) != int(parent[3:]):
                self.update(parent)
            self._set_array(id, root, parent, name)

    def category_test_approved(self, category):
        result = self.get(f'{self.category_path}/MLV{category.id}')
        if result.get('id') and (result.get('name') == category.name):
            category.approved = True
            category.save()
            logging.getLogger('log_three').info(
                f'{category} Disponible en VZLA')
    def scan_for_seller(self, seller_id):
        params = {'seller_id': seller_id}
        result = self.get(self.path, params)
        if not result:
            return []
        total = result['paging'][
            'total'] if result['paging']['total'] <= 1000 else 1000
        limit = result['paging']['limit']
        seller_draw = result['seller']
        products_draw = result['results']

        seller = Seller.objects.get(id=seller_draw['id'])
        seller.nickname = seller_draw['nickname']
        seller.save()

        list_params = [{
            'seller_id': seller_id,
            'offset': offset,
            'limit': 50,
            'attributes': 'results'
        } for offset in range(limit, total, limit)]
        products_api = self.map_pool_get(paths=[self.path] * len(list_params),
                                         params=list_params)

        for product in products_api:
            products_draw += product['results']

        categories = ScraperCategory()

        BM = BusinessModel.objects.get(pk=self.SELLER_ID)
        bulk_mgr = BulkCreateManager()

        ids_products = list()
        for product_ in products_draw:
            if ((not product_['shipping']['free_shipping'])
                    or (not product_['condition'] == 'new')):
                continue

            elif (not int(product_['category_id'][3:]) in categories.ids):
                categories.update(product_['category_id'])

            category_id = int(product_['category_id'][3:])
            category_father_id = categories.array[category_id].father
            if not categories.array[category_father_id].approved:
                continue

            cost_price = ceil(product_['price'] / BM.trm)
            sales_cost = ceil((cost_price + BM.shipping_vzla) *
                              (1 + BM.meli_tax / 100) * (1 + BM.utility / 100))
            key_category = category_father_id
            product = Product.objects.get_or_create(
                seller=seller,
                title=product_['title'],
                cost_price=cost_price,
                sale_price=sales_cost,
                provider_sku=product_['id'],
                provider_link=product_['permalink'],
                image=product_['thumbnail'].replace('http', 'https'),
                category=categories.array[key_category],
                quantity=product_['initial_quantity'])
            if product[1]:
                product = product[0]
                ids_products.append(product_['id'])
                for _attribute in product_['attributes']:
                    if _attribute['value_name'] and (350 < len(
                            _attribute['value_name'])):
                        bulk_mgr.add(
                            Attribute(id_meli=_attribute['id'],
                                      value=_attribute['value_name'],
                                      value_id=_attribute.get('value_id'),
                                      product=product))
        bulk_mgr.done()
        return self.scan_product(ids_products)
    def new_products(self, ids: list, business):
        products = self.get(path=f'/items',
                            params={
                                'ids': ids,
                                'include_internal_attributes': True
                            },
                            auth=True)

        bulk_mgr = BulkCreateManager(200)
        categories = ScraperCategory()
        count_products = 0
        logging.getLogger('log_three').info(f'scaneando 20 productos')
        for _product in products:
            if not _product['body'].get('id'):
                continue

            _product_ = _product['body']
            sku = _product_.get('seller_custom_field')
            if not sku:
                logging.getLogger('log_three').info(f'No se encontro el sku')
                continue

            product = Product.objects.filter(provider_sku=sku).first()
            if not product:
                category_id = int(_product_['category_id'][3:])
                if (not category_id in categories.ids):
                    categories.update(_product_['category_id'])

                product = Product.objects.create(
                    seller=None,
                    title=_product_['title'],
                    cost_price=0,
                    ship_price=0,
                    description=_product_['descriptions'][0].get('id'),
                    provider_sku=sku,
                    provider_link=f"https://www.amazon.com/-/es/dp/{sku}?psc=1",
                    image=_product_['secure_thumbnail'],
                    quantity=0)
                for _attribute in _product_['attributes']:
                    if _attribute['value_name'] and (100 > len(
                            _attribute['value_name'])):
                        bulk_mgr.add(
                            Attribute(
                                id_meli=_attribute['id'],
                                value=_attribute['value_name'],
                                value_id=_attribute.get('value_id'),
                                product=product,
                            ))
                for image in _product_['pictures']:
                    if 'resources/frontend/statics/processing' in image[
                            'secure_url']:
                        continue
                    picture = Picture(src=image['secure_url'], product=product)
                    bulk_mgr.add(picture)
            else:
                logging.getLogger('log_three').info(
                    f'Producto {sku} Ya existente')

            bulk_mgr.add(
                ProductForStore(store=business,
                                product=product,
                                sale_price=0,
                                sku=_product_['id'],
                                category=categories.array[category_id]))
            count_products += 1
        bulk_mgr.done()
        logging.getLogger('log_three').info(
            f'{count_products} Productos sincronizados')
    def scan_for_category(self, category):
        params = {
            'offset': 0,
            'sort': 'relevance',
            'shipping': 'mercadoenvios',
            'power_seller': 'yes',
            'has_pictures': 'yes',
            'shipping_cost': 'free',
            'ITEM_CONDITION': 2230284,
            'category': f'MCO{category.id}'
        }

        result_draw = self.get(self.path, params)

        result = self.get(self.path, params)
        if not result:
            return []
        total = result['paging'][
            'total'] if result['paging']['total'] <= 10_000 else 10_000
        limit = result['paging']['limit']
        products_draw = result['results']

        list_params = [{
            'offset': offset,
            'sort': 'relevance',
            'shipping': 'mercadoenvios',
            'power_seller': 'yes',
            'has_pictures': 'yes',
            'shipping_cost': 'free',
            'ITEM_CONDITION': 2230284,
            'category': f'MCO{category.id}',
            'attribute': 'results'
        } for offset in range(limit, total, limit)]

        logging.getLogger('log_three').info(f'Scrapeando {total} productos')
        products_api = self.map_pool_get(paths=[self.path] * len(list_params),
                                         params=list_params,
                                         auths=[True] * len(list_params))

        for product in products_api:
            products_draw += product['results']

        BM = BusinessModel.objects.get(pk=self.SELLER_ID)
        bulk_mgr = BulkCreateManager(200)

        ids_products = list()
        sellers = ScraperSeller()
        bad_sellers = Seller.objects.filter(bad_seller=True).values_list(
            'id', flat=True)
        for product_ in products_draw:
            seller_id = int(product_['seller']['id'])
            if seller_id in bad_sellers:
                continue
            elif seller_id not in sellers.ids:
                sellers.update(seller_id)

            cost_price = ceil(product_['price'] / BM.trm)
            sales_cost = ceil((cost_price + BM.shipping_vzla) *
                              (1 + BM.meli_tax / 100) * (1 + BM.utility / 100))
            product = Product.objects.filter(
                provider_sku=product_['id']).first()
            if not product:
                product = Product.objects.create(
                    seller=sellers.array[seller_id],
                    title=product_['title'],
                    cost_price=cost_price,
                    sale_price=sales_cost,
                    provider_sku=product_['id'],
                    provider_link=product_['permalink'],
                    image=product_['thumbnail'].replace('http', 'https'),
                    category=category,
                    quantity=product_['available_quantity'])
                for _attribute in product_['attributes']:
                    if _attribute['value_name'] and (350 < len(
                            _attribute['value_name'])):
                        bulk_mgr.add(
                            Attribute(id_meli=_attribute['id'],
                                      value=_attribute['value_name'],
                                      value_id=_attribute.get('value_id'),
                                      product=product))

            ids_products.append(product_['id'])

        bulk_mgr.done()
        return self.scan_product(ids_products)