from django.db import models
from django.db.models.deletion import SET_DEFAULT, SET_NULL
from django.db.models.fields.related import ManyToManyField
from django.urls import reverse
import uuid
from internal.models import Member, Group, Device
from home.models import Room, Agency, Country, PatentOwner, Pub_type, Committee_status, Grade
from datetime import datetime
from django.template.defaultfilters import slugify
from django.http import HttpResponse
import numpy as np
import os

class Add_Publication(models.Model):
    doi = models.CharField('DOI to be added', max_length=50, blank=True, null=True,default=None)
    title = models.TextField('Title', max_length=500, blank=True, null=True,default=None)
    author = models.CharField('author surname', max_length=40, help_text="e.g. 'Cuniberti'", blank=True, null=True, default=None)
    year = models.IntegerField('Year', blank=True, null=True)
    comment= models.TextField('Comments', max_length=5000, blank=True, null=True)
    added = models.BooleanField(help_text='DOI added to publication', blank=True, null=True)
    doi_in_pubs = models.BooleanField(help_text='DOI already in publications', blank=True, null=True)
    def __str__(self):
        return str(self.id)
    
    class Meta:
        verbose_name_plural='Add publications'   
    # def __str__(self):
    #     try:
    #         return self.doi + self.title
    #     except:
    #         try:
    #             return self.doi
    #         except:
    #             return self.title


def export_as_docx(self, request, queryset):

    meta = self.model._meta
    field_names = [field.name for field in meta.fields]

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename={}.txt'.format(meta)
    with open(response,'w') as out:
        out.write(field_names)
    # for obj in queryset:
    #    row = writer.writerow([getattr(obj, field) for field in field_names])

    return response

def create_slug_publication(doi):
    slug = slugify(doi)
    qs = Publication.objects.filter(slug=slug)
    exists = qs.exists()
    if exists:
        # slug = "%s-%s" %(slug, qs.first().id)
        slug = slug + '_'+str(qs.first().id)
    return slug

def replace_unicode_characters(text):
    replacements = {
        "\u2010": "-",  # Ersetzt den typografischen Apostroph durch einen geraden Apostroph
    }
    for original, replacement in replacements.items():
        text = text.replace(original, replacement)
    return text


class Publication(models.Model):
    """Model representing a single publication entry."""
    doi = models.CharField('DOI', max_length=50, help_text='Enter <a href="https://www.crossref.org">DOI</a>. (Only DOI, not the Link/URL)')
    page = models.CharField('Page', max_length=20, help_text='Enter Page', null=True, blank=True)
    type_choices = [ ('Reg','regular'), ('Rev,','review'), ('Let','letter'), ('Bo','book'),('Conf','Conference proceeding')]
    pub_type = models.CharField(max_length=20, default='Reg', choices=type_choices, help_text='Publication  type')
    journal_short = models.CharField('Journal short', max_length=100, help_text='Enter Journal Abbreviation (PRB)')
    journal = models.CharField('Journal', max_length=100,help_text='Enter Journal Name', null=True, blank=True)
    cvselected = models.BooleanField(default=False, help_text='Publication  selected for CV')
    title = models.TextField(max_length=500)
    abstract = models.TextField(max_length=5000, help_text='Enter publication abstract', null=True, blank=True)
    author_list = models.TextField(max_length=2000,blank=True)
    author = models.ManyToManyField(Member, through=Member.publication.through, related_name="publication_author")
    year = models.IntegerField('year')
    volume = models.CharField('Volume', max_length=10, null=True, blank=True)
    pub_date = models.DateField(null=True)
    cover_image = models.ImageField(upload_to='uploads/publication/img/', verbose_name='Image', blank=True, null=True)
    pdf_file = models.FileField(upload_to='uploads/publication/pdf/', blank=True, null=True)
    pdf_public = models.BooleanField(default=False, help_text='Publication public?')
    chair_pub = models.BooleanField(default=True, help_text='if no, not shown in publication but at member site', blank=True, null=True)
    tweet_abstract = models.TextField(max_length=280, blank=True, null=True)
    project = models.ManyToManyField('Project',related_name="publication_project",blank=True)
    group = models.ManyToManyField(Group,related_name="publication_group",blank=True)
    open_access_url = models.URLField('Link to open access pdf.',blank=True, default=None, null=True)
    arxiv_url = models.URLField('arXiv url',blank=True, default=None, null=True)
    # arxiv_doi_url = models.URLField('arXiv doi url',blank=True, default=None, null=True)
    approved = models.BooleanField(default=True, help_text='Publication approved? If not, not shown on webpage!')
    open_access = models.BooleanField(default=False, help_text='OpenAccess', blank=True, null=True)
    slug=models.SlugField(max_length=100, help_text="URL where publication is shown(if empty:DOI)",null=True,blank=True)
    
    created_date = models.DateTimeField(auto_now_add=True,null=True,blank=True,verbose_name='Created date of DB entry')
    # id = models.UUIDField(primary_key=True, default=uuid.uuid4, unique=True, help_text='Unique ID for this particular publication')
    
    def __str__(self):
        """String for representing the Model object."""
        return str(self.pub_date) +' - '+self.title +' - '+self.author_list
        
    def get_id(self):
        return self.id

    def get_absolute_url_2(self):
        """Returns the url to access a detail record for this publication."""
        return reverse('publication-detail', args=[str(self.id)])
        
    def get_absolute_url(self):
        """Returns the url to access a detail record for this publication."""
        # return reverse('member-detail', args=[str(self.id)])
        return reverse('publication-detail', kwargs={'slug':self.slug})
        
    def display_reference(self):
        """Create a string for the reference."""
        # return f'<i>{self.journal_short}<i>'
        return 'test'
    def save(self, *args, **kwargs):
        self.title=replace_unicode_characters(self.title)
        if not self.slug or self.slug=='':
            self.slug =  create_slug_publication(self.doi)
        #return super().save(*args, **kwargs)
        super(Publication, self).save(*args, **kwargs)
    actions=['export_as_docx']
    display_reference.short_description = 'reference'
        
    class Meta:
        ordering = ['-year','-pub_date']
    


class JournalCover(models.Model):
    publication = models.ForeignKey(Publication, related_name="journalCover_publication", default=None, on_delete=models.CASCADE)
    doi = models.CharField('DOI', max_length=50, help_text='Please enter only <a href="https://www.crossref.org">DOI</a> without https://doi.org/', blank=True,null=True)
    url = models.URLField(blank=True,help_text='Instead of DOI if DOI is not avaliable',null=True)
    cover_image = models.ImageField(upload_to='uploads/publication/img_JournalCover/', blank=True, null=True)
    
    def __str__(self):
        """String for representing the Model object."""
        return str(self.doi)
        
    def get_id(self):
        return self.id



class ProjectContainer(models.Model):
    name_german = models.CharField('Title (German)', max_length=100, null=True)
    name_english = models.CharField('Title (English)', max_length=100, null=True)
    funding_acr = models.CharField('Funding acronym', max_length=100, null=True)
    project_id = models.CharField('Project container ID', max_length=100, null=True,blank=True)
    agency = models.ForeignKey(Agency, on_delete=SET_NULL,null=True)
    info_url = models.URLField('URL to Project',blank=True)
    description = models.TextField('Description',max_length=5000, null=True, blank=True)
    #image_project=models.ImageField('Image of projectcontainer',upload_to='uploads/project/img/', null=True, blank=True)
    funding_scheme = models.CharField('Funding scheme', max_length=100, null=True)
    funding_id = models.CharField('Funding id', max_length=100, null=True)
    coordinated_by = models.CharField('Coordinated by', max_length=100, null=True)
    start_date = models.DateField('Start date',null=True,blank=True)
    end_date = models.DateField('End date',null=True, blank=True)

            
    def __str__(self):
        """String for representing the Model object."""
        return self.name_english

    class Meta:
        ordering = ['agency']
        verbose_name_plural='Project container'     

class ResearchEquipment_maintaince(models.Model):
    research_eq=models.ForeignKey("ResearchEquipment",related_name="researchequipment_maintaince",default=None,on_delete=models.CASCADE)
    date = models.DateField('Maintaince date',null=True)
    works = models.BooleanField(default='True',help_text='Does the equipment works?',null=True)
    notes = models.TextField(max_length=5000, null=True, blank=True)
    room = models.ForeignKey(Room, default=None, on_delete=models.SET_NULL, null=True)
    image = models.ImageField(upload_to='uploads/research_equipment/img_maintaince/', blank=True, null=True)
    file = models.FileField(upload_to='uploads/research_equipment/files_maintaince/',blank=True)
    def __str__(self):
        """String for representing the Model object."""
        return self.research_eq.name_common

    def get_id(self):
        return self.id


    class Meta:
        ordering = ['-date']
        verbose_name='Maintaince'
        verbose_name_plural='Research Equipment maintaince'


class ResearchEquipment_calibration(models.Model):
    research_eq=models.ForeignKey("ResearchEquipment",related_name="researchequipment_calibration",default=None,on_delete=models.CASCADE)
    date = models.DateField('Calibration date',null=True)
    works = models.BooleanField(default='True',help_text='Does the equipment works?',null=True)
    notes = models.TextField(max_length=5000, null=True, blank=True)
    room = models.ForeignKey(Room, default=None, on_delete=models.SET_NULL, null=True)
    image = models.ImageField(upload_to='uploads/research_equipment/img_calibration/', blank=True, null=True)
    file = models.FileField(upload_to='uploads/research_equipment/files_calibration/',blank=True)
    def __str__(self):
        """String for representing the Model object."""
        return self.research_eq.name_common

    def get_id(self):
        return self.id


    class Meta:
        ordering = ['-date']
        verbose_name='Calibration'
        verbose_name_plural='Research Equipment calibration'


class ResearchEquipment_inventory(models.Model):
    research_eq=models.ForeignKey("ResearchEquipment",related_name="researchequipment_inventory",default=None,on_delete=models.CASCADE)
    date = models.DateField('Inventory date',null=True,auto_now_add=True,help_text='will be filled automatically')
    works = models.BooleanField(default='True',help_text='Does the equipment works?',null=True)
    notes = models.TextField(max_length=5000, null=True, blank=True)
    room = models.ForeignKey(Room, default=None, on_delete=models.SET_NULL, null=True)
    image = models.ImageField(upload_to='uploads/research_equipment/img_inventory/', blank=True, null=True)
    def __str__(self):
        """String for representing the Model object."""
        return self.research_eq.name_common

    def get_id(self):
        return self.id


    class Meta:
        ordering = ['-date']
        verbose_name='Inventory'
        verbose_name_plural='Research Equipment inventory'




class ResearchEquipment(models.Model):
    name_common = models.CharField('Common name', max_length=100,null=True)
    name = models.CharField('Technical Name', max_length=100,null=True)
    manufacturer = models.CharField('Manufacturer', max_length=100,null=True,blank=True)
    model = models.CharField('Model', max_length=100,null=True,blank=True)
    facility=models.CharField('Facility', max_length=200,default='Chair of Materials Science and Nanotechnology',help_text='e. g. Chair of Materials Science and Nanotechnology')
    partner=models.CharField('Partner', max_length=200,default='TU Dresden',help_text='e. g. TU Dresden')
    inventory_nr = models.CharField('Inventory number', null=True, blank=True, max_length=100)
    active = models.BooleanField(verbose_name='Show public',default='True',help_text='Shown on webpage?',null=True)
    description = models.TextField(max_length=5000, null=True, blank=True)
    technicalSpecs = models.TextField(max_length=5000, null=True, blank=True)
    price = models.FloatField(blank=True, null=True,help_text='In Euro')
    info_url = models.URLField(null=True, blank=True,help_text='Link to webpage of manufacturer for further details')
    techPortalTUD_url = models.URLField(null=True, blank=True,help_text='Link to technology portal of TU Dresden (https://dresden-technologieportal.de/en/)')
    group = models.ManyToManyField(Group, related_name="researchequipment_group", default=None, blank=True)
    room = models.ForeignKey(Room, default=None, on_delete=models.SET_NULL, null=True)
    project = models.ManyToManyField("Project", default=None, blank=True, related_name="researchequipment_project")
    category = models.ManyToManyField("Equipment_Category", default=None, blank=True, related_name="researchequipment_equipment_category")
    responsible_person = models.ManyToManyField(Member, related_name="researchequipment_responsible_person", default=None)
    device = models.ManyToManyField(Device, related_name="researchequipment_device", default=None,blank=True)
    image = models.ImageField(upload_to='uploads/research_equipment/', blank=True, null=True)
    maintenance = models.TextField(max_length=5000, null=True, blank=True, help_text = "Internal information. Not shown on webpage" )
    #public = models.BooleanField(default=False)
    def __str__(self):
        """String for representing the Model object."""
        return self.name_common+' - '+self.name

    def get_id(self):
        return self.id

    def get_absolute_url(self):
        return reverse('research_equipment-detail', args=[str(self.id)])

    class Meta:
        ordering = ['-price']
        verbose_name_plural='Research equipment'


def create_slug_projects(string,id_nr):
    slug = slugify(string)
    
    qs = Project.objects.filter(slug=slug)
    exists = qs.exists()
    if exists:
        # slug_add=slugify(nameStr)
        # slug = "%s-%s" %(slug, qs.first().id)
        #slug = slug + str(qs.first().id)
        slug = slug+'_'+str(id_nr)
    return slug


class Equipment_Category(models.Model):
    name = models.CharField(max_length=200, null=True, blank=True)
    equipment=models.ManyToManyField(ResearchEquipment,through=ResearchEquipment.category.through,related_name='equipment_category',verbose_name="Category of research equipment",blank=True)
    order_index = models.IntegerField('Index for order of reasearch equipment',null=True)
    def __str__(self):
        """String for representing the Model object."""
        return self.name
    class Meta:
        ordering=["order_index"]
        verbose_name_plural='Research Equipment Categories'     





'''class Project_acknowledgement(models.Model):
    project = models.ForeignKey("Project", default=None, on_delete=models.CASCADE)
    name = models.CharField(max_length=200, default=None, null=True,verbose_name='Name',help_text='Name of institution/person')
    short_name = models.CharField(max_length=200, default=None, null=True, blank=True,verbose_name='Short name')
    description = models.TextField('Description',max_length=5000, null=True, help_text='This part will be displayed on project website')
    image = models.FileField('Image',upload_to='uploads/project/acknowledgement/',blank=True,null=True)
    def __str__(self):
        return str(self.name)
    class Meta:
        verbose_name ='Acknowledgement'
'''


class Project(models.Model):
    show_public = models.BooleanField(default=True,help_text='Show on webpage?')
    name = models.CharField('Name', max_length=300, null=True)
    project_acr = models.CharField('Project acronym', max_length=100, null=True)
    project_id = models.CharField('Project ID', max_length=100, null=True,blank=True)
    start_date = models.DateField('Start date')
    end_date = models.DateField('End date',null=True, blank=True)
    info_url = models.URLField('URL to Project',blank=True)
    gepris_url = models.URLField('Only for DFG-funded projects. URL to project on website of Gepris',blank=True)
    agency_url = models.URLField('URL to project agency',blank=True)
    description = models.TextField('Description',max_length=5000, null=True, blank=True)
    image_descr=models.ImageField(verbose_name="Image of description",upload_to='uploads/project/img/', null=True, blank=True)
    acknowledgement = models.TextField('Acknowledgements',max_length=5000, null=True, blank=True)
    copyright_image_descr=models.CharField(max_length=200, null=True, blank=True,verbose_name="Copyright of image of description")
    image_project=models.ImageField(verbose_name="Image of project",upload_to='uploads/project/img/', null=True, blank=True)
    copyright_image_project=models.CharField(max_length=200, null=True, blank=True,verbose_name="Copyright of image")
    #image_agency=models.ImageField(upload_to='uploads/project/img/', null=True, blank=True)
    agency = models.ForeignKey(Agency, on_delete=SET_NULL,null=True)
    funding_scheme = models.CharField('Funding scheme', max_length=100, null=True,blank=True)
    funding_sum = models.FloatField('Funding sum', max_length=100, null=True,blank=True)
    funding_id = models.CharField('Funding id', max_length=100, null=True,blank=True)
    project_member=models.ManyToManyField(Member,related_name="project_member")
    group=models.ManyToManyField(Group, related_name="project_group",blank=True)
    superordinateProject=models.ForeignKey(ProjectContainer, verbose_name="Project container", default=None, on_delete=models.SET_NULL, null=True,blank=True)
    equipment=models.ManyToManyField(ResearchEquipment,through=ResearchEquipment.project.through,related_name='project_equipment',verbose_name="Research equipment",blank=True)
    publication=models.ManyToManyField(Publication,through=Publication.project.through,related_name='project_publication',verbose_name="Publication",blank=True)
    # acknowledgement=models.ManyToManyField(Acknowledgement,related_name='project_acknowledgement',verbose_name="Acknowledgement",blank=True)
    slug=models.SlugField(max_length=150, null=True, blank=True, help_text="URL where project is shown(if empty:year+acronym)")    
    def __str__(self):
        """String for representing the Model object."""
        return f'{self.project_acr} | {self.name}'
    
    # def get_absolute_url(self):
    #    return reverse('project-detail', args=[str(self.id)])



    def save(self, *args, **kwargs):
        if not self.slug:
            if self.project_acr!=None:
                agency_list =self.agency.name
                if self.end_date == None or self.end_date=='':
                    argument = str(self.start_date.year) +'_'+str(self.agency.name)+'_'+ self.project_acr
                else:
                    argument=str(self.end_date.year)+'_'+str(self.agency.name)+'_'+str(self.project_acr)
            else:
                argument = str(self.end_date.year)+'_'+str(self.agency.name)
            self.slug = create_slug_projects(argument,self.id)
        return super().save(*args, **kwargs)
    #
    def get_absolute_url(self):
        """Returns the url to access a detail record for this publication."""
        # return reverse('member-detail', args=[str(self.id)])
        return reverse('project-detail', kwargs={'slug':self.slug})

    class Meta:
        #ordering = ['agency']
        ordering = ['-end_date']
        verbose_name_plural='Projects'        


class ProjectFile(models.Model):
    """ class needed to allow multiple file upload in class Group"""
    project = models.ForeignKey(Project, default=None, on_delete=models.CASCADE)
    file = models.FileField(upload_to = 'uploads/project/img/',verbose_name='image/video')
    copyright=models.CharField(max_length=200, default=None, null=True, blank=True)
    title = models.CharField(max_length=200, default=None, null=True, blank=True)
    description = models.TextField(max_length=5000, default=None, null=True, blank=True)
    def __str__(self):
        return self.project.name
    def get_extension(self):
        name, extension = os.path.splitext(self.file.name)
        return extension
    class Meta:
        verbose_name = "Project image/video"
        verbose_name_plural = "Project images/videos"



class Open_Thesis(models.Model):
    """Model representing a single thesis entry."""
    # pub_date = models.DateField('Publication Date', auto_now_add=True)
    edit_date = models.DateTimeField('Edit of the post',  auto_now=True)

    # type_choices = [ ('Project','Project'),('Bachelor','Bachelor'), ('Master,','Master'), ('Diplom','Diplom'), ('PhD','PhD')]
    # pub_type = models.CharField(max_length=20, default='Master', choices=type_choices, help_text='Thesis type', null=True, blank=True)
    title = models.TextField(max_length=500)
    abstract = models.TextField(max_length=5000, help_text='Enter thesis abstract', null=True, blank=True)
    public =  models.BooleanField(default=True, help_text='Shown on web page?')
    cover_image = models.ImageField(upload_to='uploads/thesis/img/', blank=True, null=True)
    copyright = models.CharField(max_length=100, blank=True, null=True)
    pdf_file = models.FileField(upload_to='uploads/open_thesis/pdf/', blank=True, null=True)
    
    theory = models.BooleanField(default = False, help_text='Theoretical work?')
    experimental = models.BooleanField(default = True, help_text='Experimental work?')
    publication_type = models.ManyToManyField(Pub_type, related_name="openthesis_pub_type")
    supervisor = models.ManyToManyField(Member, related_name="openthesis_supervisor")
    project = models.ManyToManyField('Project', related_name="openthesis_project", blank=True)
    group = models.ManyToManyField(Group, related_name="openthesis_group", blank=True)
    publication = models.ManyToManyField(Publication, related_name="openthesis_publication", blank=True)
    def __str__(self):
        """String for representing the Model object."""
        return self.title
        
    def get_id(self):
        return self.id

    def get_absolute_url(self):
        """Returns the url to access a detail record for this publication."""
        return reverse('open_thesis-detail', args=[str(self.id)])
        
        
    class Meta:
        ordering = ['-theory','-edit_date']
        verbose_name_plural='Open Thesis'


def create_slug_thesis(slug_str):
    slug = slugify(slug_str)
    qs = Thesis.objects.filter(slug=slug)
    exists = qs.exists()
    if exists:
        slug = f"{slug}_{qs.first().id}"
    return slug


class Thesis(models.Model):
    """Model representing a single thesis entry."""
    slub = models.URLField(blank=True, help_text="Link to physical thesis in slub. Typically: https://katalog.slub-dresden.de/...")
    qucosa = models.URLField(blank=True, help_text="Link to digital thesis (https://www.qucosa.de/).")
    type_choices = [ ('Project','Project'),('Bachelor','Bachelor'), ('Master','Master'), ('Diplom','Diplom'), ('PhD','PhD'),('habil.','habil.')]
    pub_type = models.CharField(max_length=20, default='PhD', choices=type_choices, verbose_name='Thesis type')
    title = models.TextField(max_length=500)
    abstract = models.TextField(max_length=5000, help_text='Enter thesis abstract', null=True, blank=True)
    author_new = models.ManyToManyField(Member, related_name="thesis_author",blank=True, verbose_name="Author")
    author_manual = models.CharField(verbose_name='Author (not chair related)',max_length=100,blank=True,help_text='Please enter the full name of the author if the author is and was not a member of this chair.')
    supervisor = models.ManyToManyField(Member, related_name="thesis_supervisor", verbose_name="Supervisor/Reviewer")
    supervisor_manual = models.CharField(max_length=50, verbose_name='Supervisor (not chair related)',blank=True,null=True)
    function_cuniberti=models.ForeignKey(Committee_status,related_name="thesis_function_cuniberti",on_delete=SET_DEFAULT,default=None,verbose_name="Status in committee")
    reviewer = models.ManyToManyField(Member, related_name="thesis_reviewer",blank=True)
    reviewer_manual = models.CharField(max_length=50, verbose_name='Reviewer (not chair related)',blank=True,null=True)
    start_date = models.DateField('Start date',null=True,blank=True)
    end_date = models.DateField('End date',null=True,blank=True)
    def_date = models.DateField('Defense date',null=True,blank=True)
    status_presentation=models.BooleanField(blank=True,default=False,help_text="Promotion regulations 03/2018")
    cover_image = models.ImageField(upload_to='uploads/thesis/img/', blank=True, null=True,help_text="Please upload one highlight figure of the thesis.")
    pdf_file = models.FileField(upload_to='uploads/thesis/pdf/', blank=True, null=True)
    chair_pub = models.BooleanField(default=True, help_text='if no, not shown in thesises but at member site', blank=True, null=True)
    faculty=models.CharField(max_length=100, default='Fakultät Maschinenwesen')
    university=models.CharField(max_length=100, default='TU Dresden')
    rigorosum_notes=models.TextField(max_length=400,blank=True,null=True)
    project = models.ManyToManyField('Project',related_name="thesis_project",blank=True)
    group = models.ManyToManyField(Group,related_name="thesis_group",blank=True)
    slug=models.SlugField(max_length=150, null=True, blank=True, help_text="Part of URL where patent is shown")
    grade = models.ForeignKey(
                Grade,
                on_delete=models.SET_NULL,
                null=True, blank=True,
                verbose_name="Grade")
    
    
    def __str__(self):
        """String for representing the Model object."""
        return str(self.def_date) +' - '+self.title
        
    def get_id(self):
        return self.id

    def get_absolute_url(self):
        """Returns the url to access a detail record for this publication."""
        return reverse('thesis-detail', kwargs={'slug':self.slug})
    
    def save(self, *args, **kwargs):
        if not self.slug:
            author_first = self.author_new.first()
            if self.def_date is not None:
                slug_str_sub=f"{self.def_date}"
            else:
                slug_str_sub=""
            if author_first is not None:
                slug_str=f"{author_first.given_name}_{author_first.last_name}_{slug_str_sub}"  
            elif author_first is None:
                slug_str=f"{self.author_manual}__{slug_str_sub}"  
            self.slug =  create_slug_thesis(slug_str=slug_str)
        return super().save(*args, **kwargs)
        
    class Meta:
        ordering = ['-start_date']
        verbose_name_plural='Theses'


def create_slug_patents(string,id_nr):
    slug = slugify(string)
    
    qs = Patent.objects.filter(slug=slug)
    exists = qs.exists()
    if exists:
        # slug_add=slugify(nameStr)
        # slug = "%s-%s" %(slug, qs.first().id)
        #slug = slug + str(qs.first().id)
        slug = slug+'_'+str(id_nr)
    return slug


class Patent(models.Model):
    """Model representing a single thesis entry."""
    url_family = models.URLField('DPMA',blank=True,help_text='Link to patent family')
    google_patents = models.URLField(blank=True)
    orbit = models.URLField(blank=True)
    cvselected = models.BooleanField(default=False, help_text='Publication  selected for CV')
    title_german = models.TextField(max_length=500,null=True)
    title_english = models.TextField(max_length=500,null=True,blank=True)
    abstract_german = models.TextField(max_length=5000, help_text='Enter patent abstract', null=True, blank=True)
    abstract_english = models.TextField(max_length=5000, help_text='Enter patent abstract', null=True, blank=True)
    author_list = models.TextField(max_length=500,blank=True)
    application_fields = models.TextField(max_length=500,blank=True)
    inventor = models.ManyToManyField(Member, related_name="patent_author",verbose_name='Inventor')
    owner = models.ManyToManyField(PatentOwner,verbose_name='Patent owner',related_name='patent_owner')
    cover_image = models.ImageField(upload_to='uploads/patent/img/', blank=True, null=True)
    pdf_file = models.FileField(upload_to='uploads/patent/pdf/', blank=True, null=True)
    chair_pub = models.BooleanField(default=True, help_text='if no, not shown in publication but at member site', blank=True, null=True)
    project = models.ManyToManyField('Project',related_name="patent_project",blank=True)
    group = models.ManyToManyField(Group,related_name="patent_group",blank=True)
    slug=models.SlugField(max_length=150, null=True, blank=True, help_text="Part of URL where patent is shown")

    def __str__(self):
        """String for representing the Model object."""
        return self.title_german
        
    def get_id(self):
        return self.id

    
    def get_absolute_url(self):
        """Returns the url to access a detail record for this publication."""
        # return reverse('member-detail', args=[str(self.id)])
        return reverse('patent-detail', kwargs={'slug':self.slug})


    def save(self, *args, **kwargs):
        if self.patentchild_patent.all():
            patent_sub = self.patentchild_patent.all()
            argument = str(patent_sub[0].number)
        else:
            if self.title_english:
                argument = str(self.title_english)
            else:
                argument=str(self.title_german)
        self.slug = create_slug_patents(argument,self.id)
        return super().save(*args, **kwargs)
        

class PatentChild(models.Model):
    """Model representing a single thesis entry."""
    patent=models.ForeignKey(Patent,related_name="patentchild_patent",default=None,on_delete=models.CASCADE)
    url = models.URLField(blank=True)
    type_choices = [ ('active','active'),('passive','passive')]
    pub_type = models.CharField(max_length=20, default='active', choices=type_choices,verbose_name='Patent status', help_text='e.g. passive = Offenlegungsschrift (i.e. in proof or no active property rights)')
    number = models.CharField('ID',max_length=200)
    country=models.ForeignKey(Country,related_name="patentchild_country",default=None,on_delete=SET_DEFAULT)
    app_date = models.DateField(verbose_name='Date of Application',null=True,blank=True)
    pub_date = models.DateField(verbose_name='Pub date',null=True,blank=True)
    issue_date = models.DateField(verbose_name='Date of issuing to active patent',null=True,blank=True)
    pdf_file = models.FileField(upload_to='uploads/patent/pdf/', blank=True, null=True)
    
    def __str__(self):
        """String for representing the Model object."""
        return str(self.patent.title_german)+' - '+str(self.number)
        
    def get_id(self):
        return self.id
        
        
    class Meta:
        ordering = ['-pub_date']