zuykov/trademark/models.py

#-*- coding: utf-8 -*-
from django.db import models
from django.db.models.signals import post_save, pre_save
from django.dispatch import receiver
from django.db import connection

from django.utils.translation import ugettext_lazy as _

from lib.poiskznakov import TrademarkSearchAPI

from unidecode import unidecode
from django.template.defaultfilters import slugify

from datetime import date
from datetime import timedelta
# from .cms_appconfig import TrademarkConfig

from collections import defaultdict
import re

TrademarkAPI = TrademarkSearchAPI()

class Owner(models.Model):
    title = models.CharField(max_length=255)
    country = models.CharField(max_length=4)
    address = models.CharField(max_length=255)
    legnat = models.CharField(max_length=255)

    class Meta:
        verbose_name = _('owner')
        verbose_name_plural = _('owners')

    def __unicode__(self):  # Python 3: def __str__(self):
        return self.title

    def __str__(self):
        return self.title


class Nice(models.Model):
    nice_id = models.IntegerField()
    title = models.CharField(max_length=255)
    description = models.TextField()
    glyph = models.CharField(max_length=255)

    class Meta:
        verbose_name = _('nice')
        verbose_name_plural = _('classes')
        ordering = ('nice_id', )

    def __unicode__(self):  # Python 3: def __str__(self):
        return self.title

    def __str__(self):
        return self.title

    @property
    def popular_products(self):
        ids = [str(pid) for pid in Product.objects.filter(nice_id=self.nice_id).values_list('id', flat=True)]
        cursor = connection.cursor()
        query = "SELECT product_id, count(trademark_id) FROM trademark_trademark_products WHERE product_id IN (%s) GROUP BY product_id ORDER BY count(trademark_id) DESC" % ','.join(ids)
        cursor.execute(query)
        top_ids = [result[0] for result in cursor.fetchall() if result[1] > 10]
        products = Product.objects.filter(id__in=top_ids)

        return sorted(products, key=lambda p: top_ids.index(p.pk))

    @property
    def popular_products_alphabet(self):
        alphabet = defaultdict(lambda : defaultdict(list))
        for product in self.popular_products:
            letter = product.title[0].upper()
            first_word = product.title.split(' ')[0]

            # if title_sense:
            alphabet[letter][first_word.capitalize()].append(product)
            # elif not alphabet[letter][first_word.capitalize()]:
            #     alphabet[letter][first_word.capitalize()] = []

        for letter, words in alphabet.items():
            for first_word, products in words.items():
                if len(products) == 1:
                    del alphabet[letter][first_word]
                    product = products.pop()
                    words = product.title
                    alphabet[letter][words] = product.id
                else:
                    words = []
                    for product in alphabet[letter][first_word]:
                        title = re.sub("[\(\[].*?[\)\]]", "", product.title)
                        title_sense = title.replace(first_word, '').strip()
                        if title_sense:
                            words.append(title_sense)
                    # words = [product.title for product in alphabet[letter][first_word]]

                    alphabet[letter][first_word] = ', '.join(set(words))
            letter_items = alphabet[letter]
            alphabet[letter] = sorted(letter_items.items(), key=lambda x: type(x[1]), reverse=True)
            # alphabet[letter] = letter_items.items()

        print alphabet
        return sorted(alphabet.items())



class Product(models.Model):
    title = models.TextField()
    nice_id = models.IntegerField()

    class Meta:
        verbose_name = _('product')
        verbose_name_plural = _('products')
        ordering = ('nice_id', )

    def __unicode__(self):  # Python 3: def __str__(self):
        return self.title

    def __str__(self):
        return self.title


class Trademark(models.Model):
    title = models.CharField(max_length=255, null=True)
    ext_id = models.CharField(max_length=20, unique=True)
    application_id = models.CharField(max_length=12, null=True)
    cert_id = models.CharField(max_length=12, null=True)
    owner = models.TextField(null=True)
    image_url = models.URLField(null=True)
    nices = models.ManyToManyField(Nice)
    products = models.ManyToManyField(Product)
    status = models.CharField(max_length=20)
    source_url = models.URLField(null=True)

    application_at = models.DateField(null=True)
    registration_at = models.DateField(null=True)
    expiration_at = models.DateField(null=True)
    renewed_at = models.DateField(null=True)
    priority_at = models.DateField(null=True)

    access_key = models.CharField(max_length=20, null=True)

    class Meta:
        verbose_name = _('trademark')
        verbose_name_plural = _('trademarks')

    def __unicode__(self):  # Python 3: def __str__(self):
        return self.title

    def __str__(self):
        return self.title


class Keyword(models.Model):
    request = models.CharField(max_length=200)
    nices = models.CharField(max_length=200)
    slug = models.CharField(max_length=200)
    status = models.IntegerField(default=0)
    loaded = models.IntegerField(default=0)

    class Meta:
        verbose_name = _('keyword')
        verbose_name_plural = _('keywords')

    def __unicode__(self):  # Python 3: def __str__(self):
        return self.request

    def __str__(self):
        return self.request

    @property
    def nice_objects(self):
        if not self.nices:
            nices = range(1,46)
        else:
            nices = self.nices.split(',')

        return Nice.objects.filter(nice_id__in=nices)

    @property
    def contains_results(self):
        search = self.searches.filter(similarity=100)[0]

        return search.results.all().order_by('similarity')


    def create_searches(self):
        identity = Search(keyword_id=self.id, similarity=146)
        contains = Search(keyword_id=self.id, similarity=100)
        similar = Search(keyword_id=self.id, similarity=97)
        searches = [identity, contains, similar]

        for search in searches:
            search.save()
            search.send_request()

    def load_results(self):
        for search in self.searches.all():
            if search.status != "finished" or date.today() > search.loaded_at + timedelta(days=30):
                search.get_results()

        if len(self.searches.all()) == len(self.searches.filter(status="finished")):
            return True
        else:
            return False


class Search(models.Model):
    keyword = models.ForeignKey(Keyword, related_name='searches')
    search_id = models.CharField(max_length=100)
    results = models.ManyToManyField(Trademark, through='SearchResult')
    similarity = models.IntegerField()
    status = models.CharField(max_length=20)
    loaded_at = models.DateField(auto_now_add=True)

    class Meta:
        verbose_name = _('search')
        verbose_name_plural = _('searches')

    def __unicode__(self):  # Python 3: def __str__(self):
        return self.keyword.request

    def __str__(self):
        return self.keyword.request

    @property
    def nices(self):
        nices = self.results.values_list('nices__nice_id', flat=True).distinct()

        return nices

    def send_request(self):
        data = TrademarkAPI.search_trademark(keyword=self.keyword.request, similarity=self.similarity, nices=self.keyword.nices)

        self.search_id = data['search_id']

        self.save()

    def parse_products(self, nice_id, nice_description):
        if len(nice_description) == 0:
            return

        if nice_description[0:1].isdigit():
            nice_description = nice_description[nice_description.find('-') + 1:].strip()

        titles = nice_description.split(';')

        if len(titles) == 1:
            try:
                titles = nice_description.split(',')
            except:
                print nice_description

        if len(titles) > 0:
            products = []
            for line in titles:
                if len(line.strip()) == 0:
                    continue

                line = line.strip().replace('[', '(').replace(']', ')')

                if line[-1] == ".":
                    line = line[0].upper() + line[1:-1]
                else:
                    line = line[0].upper() + line[1:]

                line = line.replace('\n', ' ')
                line = ' '.join(line.split())

                product, created = Product.objects.get_or_create(nice_id=nice_id, title=line)
                products.append(product)

            return products


    def get_results(self):
        results, status = TrademarkAPI.get_results(self.search_id)

        if status['search_status'] == 'failed':
            self.send_request
            return

        if results == None:
            self.status = 'finished'
            self.save()

            return

        if self.status == 'loading':
            return

        if results == {}:
            self.status = status['progress']
        else:
            self.status = 'loading'
            self.save()

        for key, trademark in results.iteritems():
            if trademark['siml'] < 97 and self.similarity < 100:
                continue

            instance, created = Trademark.objects.get_or_create(ext_id=trademark['id'])

            result = SearchResult(search=self, trademark=instance, similarity=trademark['siml'])
            result.save()

            if not created:
                continue

            instance.title = trademark['wdesc']
            instance.application_id = trademark['appnum']
            instance.cert_id = trademark['certnum']
            instance.owner = trademark['owner'][0]['name'].encode('utf-8')
            instance.image_url = trademark.get('image', '')
            instance.status = trademark['status']

            instance.application_at = trademark['dateapp']
            instance.registration_at = trademark['datereg']

            instance.access_key = trademark['access_key']

            instance.save()

            for nice_id in trademark.get('icgs', []):
                nice, created = Nice.objects.get_or_create(nice_id=nice_id)
                instance.nices.add(nice)


        trademark_ids = self.results.values_list('ext_id', flat=True).order_by('ext_id')
        trademark_keys = self.results.values_list('access_key', flat=True).order_by('ext_id')

        if len(trademark_ids) == 0:
            return


        details = TrademarkAPI.get_details(ids=trademark_ids, keys=trademark_keys)

        for key, trademark in details.iteritems():
            instance = Trademark.objects.get(ext_id=trademark['id'])
            instance.source_url = trademark.get('source', '')
            instance.expiration_at = trademark.get('dateexp', '')
            instance.renewed_at = trademark.get('renewed', '')

            for nice_id, nice_description in trademark.get('icgs', {}).iteritems():
                nice_obj, created = Nice.objects.get_or_create(nice_id=nice_id)

                products = self.parse_products(nice_id, nice_description)

                instance.products.add(*products)

            instance.save()

        self.loaded_at = date.today()
        self.status = 'finished'
        self.save()


class SearchResult(models.Model):
    search = models.ForeignKey(Search, on_delete=models.CASCADE)
    trademark = models.ForeignKey(Trademark, on_delete=models.CASCADE)
    similarity = models.IntegerField()

    class Meta:
        ordering = ('similarity',)

@receiver(pre_save, sender=Keyword)
def update_fields(sender, instance, **kwargs):
    if instance._state.adding is True:
        instance.slug = slugify(unidecode(instance.request))

    instance.loaded = instance.loaded + 1

@receiver(post_save, sender=Keyword)
def create_searches(sender, instance, created, **kwargs):
    if created:
        instance.slug = instance.slug + u'-' + unicode(instance.id)
        instance.save()
        instance.create_searches()