You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
7.2 KiB
245 lines
7.2 KiB
#-*- 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.CharField(max_length=20, unique=True)
|
|
application_id = models.IntegerField()
|
|
cert_id = models.IntegerField()
|
|
owner = models.TextField()
|
|
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
|
|
|
|
@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":
|
|
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)
|
|
|
|
self.search_id = data['search_id']
|
|
|
|
self.save()
|
|
|
|
|
|
def get_results(self):
|
|
results, status = TrademarkAPI.get_results(self.search_id)
|
|
|
|
# print status['search_status']
|
|
if status['search_status'] == 'failed':
|
|
self.send_request
|
|
return
|
|
|
|
if results == None:
|
|
self.status = 'finished'
|
|
self.save()
|
|
|
|
return
|
|
|
|
if results == {}:
|
|
self.status = status['progress']
|
|
|
|
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['icgs']:
|
|
nice, created = Nice.objects.get_or_create(nice_id=nice_id)
|
|
instance.nices.add(nice)
|
|
|
|
|
|
trademark_ids = [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
|
|
|
|
self.status = 'finished'
|
|
self.save()
|
|
|
|
|
|
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', '')
|
|
|
|
instance.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.create_searches()
|
|
|