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.utils.translation import ugettext_lazy as _

from lib.poiskznakov import TrademarkSearchAPI, SearchResultsThread

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


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()

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

    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)
    ext_id = models.IntegerField()
    application_id = models.IntegerField()
    cert_id = models.IntegerField()
    owner = models.ForeignKey(Owner)
    image_url = models.URLField(blank=True)
    nices = models.ManyToManyField(Nice)
    status = models.CharField(max_length=20)
    source_url = models.URLField(blank=True)

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

    access_key = models.CharField(max_length=20)

    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)
    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

    def create_searches(self):
        contains = Search(keyword_id=self.id, similarity=100)
        similar = Search(keyword_id=self.id, similarity=97)
        searches = [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":
                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

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

        self.search_id = data['search_id']

        self.save()


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

        for key, trademark in results.iteritems():
            owner, created = Owner.objects.get_or_create(title=trademark['owner'][0]['name'])

            instance, created = Trademark.objects.get_or_create(
                title=trademark['wdesc'],
                application_id=trademark['appnum'],
                cert_id=trademark['certnum'],
                owner=owner,
                image_url=trademark.get('image', ''),
                status=trademark['status'],

                application_at=trademark['dateapp'],
                registration_at=trademark['datereg'],

                ext_id=trademark['id'],
                access_key=trademark['access_key']
            )

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

            instance.save()

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

            result.save()

        trademark_ids = [int(ext_id) for ext_id in self.results.values_list('ext_id', flat=True)]
        trademark_keys = [str(key) for key in self.results.values_list('access_key', flat=True)]

        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.owner.name = trademark['owner'][0]['name']
            instance.source_url = trademark.get('source', '')
            instance.expiration_at = trademark.get('dateexp', '')
            instance.renewed_at = trademark.get('renewed', '')

            instance.save()

        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()


@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.create_searches()

    SearchResultsThread(instance).start()