Apprendre python : coder une Food app en 3 mois (sunday clone python)

#models.py


# GEO KEY
key = 'XXXXXXXXXXXXXXXXXXXXX'
geocoder = OpenCageGeocode(key)

# RANDOM SLUG
def random_string_generator(size=10, chars=string.ascii_lowercase + string.digits):
    return ''.join(random.choice(chars) for _ in range(size))

def unique_slugify(instance, slug):
    model = instance.__class__
    unique_slug = slug
    while model.objects.filter(slug=unique_slug).exists():
        unique_slug = slug
        unique_slug += random_string_generator(size=4)
    return unique_slug

# UserProfile    
class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL,on_delete=models.CASCADE)
    image = models.ImageField(default='user/user-30.png',upload_to='user/',null=True,blank=True)
    full_address = models.CharField(max_length=128)
    image_url = models.URLField(max_length=300,null=True,blank=True)
    is_certified = models.BooleanField(default=False)
    is_seller = models.BooleanField(default=False)
    #API
    latitude = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    longitude = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    town = models.CharField(editable=False,null=True,blank=True,max_length=60)
    zipcode = models.CharField(editable=False,null=True,blank=True,max_length=20)
    state = models.CharField(editable=False,null=True,blank=True,max_length=60)
    country = models.CharField(editable=False,null=True,blank=True,max_length=60)
    country_code = models.CharField(editable=False,null=True,blank=True,max_length=10)
    currency_code = models.CharField(editable=False,null=True,blank=True,max_length=10)
    timezone = models.CharField(editable=False,null=True,blank=True,max_length=10)
    slug = models.SlugField(editable=False, unique=True)
    created_on = models.DateTimeField(auto_now_add=True,null=True,blank=True)
    
    def save(self, *args,**kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.user.username))
        
        if self.full_address:
            result = geocoder.geocode(self.full_address)

            if result and len(result):
                try:
                    self.longitude = result[0]['geometry']['lng']
                except Exception as e:
                    self.longitude = None
                try:
                    self.latitude  = result[0]['geometry']['lat']
                except Exception as e:
                    self.latitude = None
                try:
                    self.zipcode  = result[0]['components']['postcode']
                except Exception as e:
                    self.zipcode = None
                try:
                    self.town  = result[0]['components']['municipality']
                except Exception as e:
                    self.town = None
                try:
                    self.state  = result[0]['components']['state']
                except Exception as e:
                    self.state = None
                try:
                    self.country  = result[0]['components']['country']
                except Exception as e:
                    self.country = None
                try:
                    self.country_code = result[0]['components']['country_code']
                except Exception as e:
                    self.country_code = None
                try:
                    self.currency_code = result[0]['annotations']['currency']['iso_code']
                except Exception as e:
                    self.currency_code = None
                try:
                    self.timezone  = result[0]['annotations']['timezone']['offset_string']
                except Exception as e:
                    self.timezone = None
                    
        super(UserProfile, self).save(*args, **kwargs)
        
        img = Image.open(self.image.path)
        if img.height > 200 or img.width > 200:
            new_size = (200, 200)
            img.thumbnail(new_size)
            img.save(self.image.path)
    
    def __str__(self):
        return self.user.username  
    
        

# SAVE AUTOMATIC USERPROFILE        
def create_user_profile(sender,instance,created,**kwargs):
    if created:
        UserProfile.objects.create(user=instance)
        
post_save.connect(create_user_profile,sender=settings.AUTH_USER_MODEL)



# STRIPE ACCOUNT
class CustomerProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL,on_delete=models.CASCADE,primary_key=True)
    stripe_customer_id = models.CharField(max_length=120)
    
    def __str__(self):
        return self.user.username


# SAVE AUTOMATIC STRIPE ACCOUNT      
@receiver(post_save, sender=User)
def _on_update_user(sender, instance, created, **kwargs):
    if created: 

        customer = stripe.Customer.create(
            email=instance.email,
            name=instance.get_full_name(),
            metadata={
                'user_id': instance.pk,
                'username': instance.username
            },
            description='Créé via Feedcool',
        )

        profile = CustomerProfile.objects.create(user=instance, stripe_customer_id=customer.id)
        profile.save()

#models.py

# TYPE
class Typerepas(models.Model):
    name = models.CharField(max_length=20, unique=True)
    image_url = models.URLField(max_length=200,blank=True)
    slug = models.SlugField(editable=False)
    status = models.IntegerField(choices=STATUS, default=1)     
    
    def save(self, *args,**kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.name))
        super(Typerepas, self).save(*args, **kwargs)  
    
    def __str__(self):
        return self.name

# ALIMENT
class ListAliments(models.Model):
    name = models.CharField(max_length=40, unique=True)
    image_url = models.URLField(max_length=200,blank=True)
    strength = models.CharField(max_length=100,unique=False,blank=True,null=True)
    slug = models.SlugField(editable=False)
    status = models.IntegerField(choices=STATUS, default=1)     
    
    def save(self, *args,**kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.name))
        super(ListAliments, self).save(*args, **kwargs)  
    
    def __str__(self):
        return self.name

# ORIENTATION
class Sperepas(models.Model):
    name = models.CharField(max_length=40, unique=True)
    image_url = models.URLField(max_length=200,blank=True)
    slug = models.SlugField(editable=False)
    status = models.IntegerField(choices=STATUS, default=1)     
    
    def save(self, *args,**kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.name))
        super(Sperepas, self).save(*args, **kwargs)  
    
    def __str__(self):
        return self.name


# PROMO
class Promo(models.TextChoices):
    UN_ACHETE_UN_OFFERT = '1 acheté = 1 offert'
    UN_ACHETE_UN_CADEAU_OFFERT = '1 acheté = 1 cadeau offert'
    
# REPAS
class Cuisine(models.Model):
    # MANU
    title = models.CharField(max_length=90)
    user = models.ForeignKey(User,on_delete=models.CASCADE,related_name='cuisine_user')
    image = models.ImageField(upload_to='nutriscore/')
    description = models.TextField(max_length=1000, blank=True)
    prix = models.DecimalField(max_digits=4,decimal_places=2)
    a_la_carte = models.BooleanField(default=True)
    # PROMO
    discount_prix = models.DecimalField(max_digits=4, decimal_places=2,blank=True,null=True)
    # CLIC & CO
    clic_and_collect = models.BooleanField(default=False)
    is_delivered = models.BooleanField(default=False)
    start_time = models.TimeField(blank=True,null=True)
    deadline_time = models.TimeField(blank=True,null=True)
    start_date = models.DateField(blank=True,null=True)
    quantity = models.IntegerField(default=1)
    # PROMO 
    is_promoted = models.BooleanField(default=False)
    promotion = models.CharField(max_length=50,choices=Promo.choices,default=Promo.UN_ACHETE_UN_OFFERT,)
    # LOCATION
    latitude_user = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    longitude_user = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    town = models.TextField(max_length=200, blank=True)
    # EXIF
    latitude = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    longitude = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    date = models.CharField(max_length=200, blank=True)
    software = models.CharField(max_length=200, blank=True)
    lensmodel = models.CharField(max_length=200, blank=True)
    make = models.CharField(max_length=200, blank=True)
    model = models.CharField(max_length=200, blank=True)
    subectlocation = models.CharField(max_length=200, blank=True)
    gpsinfo = models.CharField(max_length=1000, blank=True)
    metadata = models.TextField(max_length=1000, blank=True)
    # API
    score = models.CharField(max_length=1,null=True,blank=True)
    aliments = models.ManyToManyField('ListAliments',blank=True, related_name='listaliments_cuisine') #list des aliments
    # MAN
    typederepas = models.ManyToManyField('Typerepas',blank=True, related_name='typederepas_cuisine') #Déjeuner, Diner, Petit-Dej
    specificitederepas = models.ManyToManyField('Sperepas',blank=True, related_name='specificitederepas_cuisine') #Vegan
    # DATA
    publishing_date = models.DateField(auto_now_add=True)
    created_on = models.DateTimeField(auto_now_add=True, blank=True, null=True)
    status = models.IntegerField(choices=STATUS, default=0)
    slug = models.SlugField(max_length=200, unique=True)
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.title))
            super(Cuisine, self).save(*args, **kwargs)
        
        # EXIF
        
        path = self.image.path
        img = Image.open(path)
        
        # CLASSIQUE
        exif_data = {}
        for tag, value in img.getexif().items():
            if tag in TAGS:
                exif_data[TAGS[tag]] = value
        
        # GPS
        def get_geotagging(exifgps):
        
            geotagging = {}
            for (idx, tag) in TAGS.items():
                if tag == 'GPSInfo':
                    if idx not in exifgps:
                        raise ValueError("No EXIF geotagging found")
        
                    for (key, val) in GPSTAGS.items():
                        if key in exifgps[idx]:
                            geotagging[val] = exifgps[idx][key]
        
            return geotagging
        
        # FORMAT GPS    
        def get_decimal_from_dms(dms, ref):

            degrees = dms[0]
            minutes = dms[1] / 60.0
            seconds = dms[2] / 3600.0
        
            if ref in ['S', 'W']:
                degrees = -degrees
                minutes = -minutes
                seconds = -seconds
        
            return round(degrees + minutes + seconds, 5)
        # GPS    
        def get_lat_coordinates(geotags):
                lat = get_decimal_from_dms(geotags['GPSLatitude'], geotags['GPSLatitudeRef'])
                return lat
        
        # GPS           
        def get_lon_coordinates(geotags):
                lon = get_decimal_from_dms(geotags['GPSLongitude'], geotags['GPSLongitudeRef'])
                return lon
        
        if 'DateTime' in exif_data:
            self.date = exif_data['DateTime']
            
        if 'Software' in exif_data:
            self.software = exif_data['Software']
            
        if 'LensModel' in exif_data:
            self.lensmodel = exif_data['LensModel']
            
        if 'Artist' in exif_data:
            self.artist = exif_data['Artist']
            
        if 'Make' in exif_data:
            self.make = exif_data['Make']
            
        if 'Model' in exif_data:
            self.model = exif_data['Model']
            
        if 'SubjectLocation' in exif_data:
            self.subectlocation = exif_data['SubjectLocation']
            
        if 'GPSInfo' in exif_data:
            try:
                exifgps = img.getexif()
                geotags = get_geotagging(exifgps)
                self.gpsinfo = geotags
            except Exception as e:
                pass
            
            try:
                exifgps = img.getexif()
                geotags = get_geotagging(exifgps)
                self.latitude = get_lat_coordinates(geotags)
            except Exception as e:
                pass
            
            try:
                exifgps = img.getexif()
                geotags = get_geotagging(exifgps)
                self.longitude = get_lon_coordinates(geotags)
            except Exception as e:
                pass
        
        self.metadata = exif_data
        
        
        if self.image:
            request = service_pb2.PostModelOutputsRequest(
                model_id='',
                inputs=[
                    resources_pb2.Input(data=resources_pb2.Data(image=resources_pb2.Image(url="https://feedcool.fr" + self.image.url)))
                ])
            response = stub.PostModelOutputs(request, metadata=metadata_cla)
            
            if response:
                names = []
                for concept in response.outputs[0].data.concepts:
                    current_aliments = ListAliments.objects.filter(name=concept.name)
                    current_post = get_object_or_404(Cuisine, slug=self.slug)
                    if current_aliments.count()<1:
                        create_aliments = self.aliments.create(name=concept.name)
                        current_post.aliments.add(create_aliments)
                    else:
                        existed_aliments = ListAliments.objects.get(name=concept.name)
                        current_post.aliments.add(existed_aliments)
        
        super(Cuisine, self).save(*args, **kwargs)
    
    class Meta:
        ordering = ['-created_on']
    
    def __str__(self):
        return self.title
        
    def distance_post(self, request):
        post_situation = (self.longitude_user, self.latitude_user)
        user_situation = (self.request.user.userprofile.longitude, self.request.user.userprofile.latitude)
        
        return geodesic(post_situation, user_situation).km
        
    # NB VENTE  
    def post_sold(self):
        return self.order_post.filter(is_paid=1).distinct().count()
    
    # NB VENTE LIVREE
    def post_vente_livre(self):
        return self.order_post.filter(is_paid=1).filter(is_received=1).distinct().count()
    
    # NB VENTE A LIVRER
    def post_vente_a_livrer(self):
        return self.order_post.filter(is_paid=1).filter(is_received=0).distinct().count()

#models.py

# Restaurant QR Code
class Restaurant(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL,on_delete=models.CASCADE)
    resto_id_table = models.CharField(blank=True, null=True, max_length=6, unique=True)
    full_address = models.CharField(max_length=128,blank=True, null=True)
    image = models.ImageField(upload_to='restaurant/',null=True,blank=True)
    name = models.CharField(max_length=100, unique=True, blank=True, null=True)
    place_id = models.CharField(max_length=100, unique=True, blank=True, null=True)
    qr_code = models.ImageField(upload_to='qr_codes', blank=True)
    # Table Qrcode
    qr_code_table = models.ManyToManyField('TableQrcode',blank=True, related_name='restaurant_tableqrcode')
    #API Google
    capacity_max = models.IntegerField(blank=True, null=True)
    nb_table = models.IntegerField(blank=True, null=True)
    open_time = models.TimeField(blank=True, null=True)
    closed_time = models.TimeField(blank=True, null=True)
    days_closed = models.CharField(max_length=150,choices=Closed_days.choices,blank=True, null=True)
    # User Location
    latitude_user = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    longitude_user = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    #API
    restaurant_latitude = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    restaurant_longitude = models.DecimalField(max_digits=9, decimal_places=6, blank=True, default='0')
    town = models.CharField(editable=False,null=True,blank=True,max_length=60)
    zipcode = models.CharField(editable=False,null=True,blank=True,max_length=20)
    state = models.CharField(editable=False,null=True,blank=True,max_length=60)
    country = models.CharField(editable=False,null=True,blank=True,max_length=60)
    country_code = models.CharField(editable=False,null=True,blank=True,max_length=10)
    currency_code = models.CharField(editable=False,null=True,blank=True,max_length=10)
    timezone = models.CharField(editable=False,null=True,blank=True,max_length=10)
    # Link M2M
    restaurant_typederepas = models.ManyToManyField('Typerepas',blank=True, related_name='restaurant_typederepas')
    restaurant_specificitederepas = models.ManyToManyField('Sperepas',blank=True, related_name='restaurant_specificitederepas')
    #
    accept_resa = models.BooleanField(default=True)
    date_created = models.DateTimeField(auto_now_add=True, null=True, blank=True)
    slug = models.SlugField(max_length=200, editable=False, unique=True)
    
    def __str__(self):
        return str(self.name)
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.name))
            self.resto_id_table = secrets.token_urlsafe(6)
            
            super(Restaurant, self).save(*args, **kwargs)
        
        if self.full_address:
            result = geocoder.geocode(self.full_address)

            if result and len(result):
                try:
                    self.restaurant_longitude = result[0]['geometry']['lng']
                except Exception as e:
                    self.restaurant_longitude = None
                try:
                    self.restaurant_latitude  = result[0]['geometry']['lat']
                except Exception as e:
                    self.restaurant_latitude = None
                try:
                    self.zipcode  = result[0]['components']['postcode']
                except Exception as e:
                    self.zipcode = None
                try:
                    self.town  = result[0]['components']['municipality']
                except Exception as e:
                    self.town = None
                try:
                    self.state  = result[0]['components']['state']
                except Exception as e:
                    self.state = None
                try:
                    self.country  = result[0]['components']['country']
                except Exception as e:
                    self.country = None
                try:
                    self.country_code = result[0]['components']['country_code']
                except Exception as e:
                    self.country_code = None
                try:
                    self.currency_code = result[0]['annotations']['currency']['iso_code']
                except Exception as e:
                    self.currency_code = None
                try:
                    self.timezone  = result[0]['annotations']['timezone']['offset_string']
                except Exception as e:
                    self.timezone = None
                
                super(Restaurant, self).save(*args, **kwargs)
            
        if not self.qr_code:
            qrcode_img = qrcode.make("https://feedcool.fr/restaurant/" + self.slug)
            canvas = Image.new('RGB', (380, 380), 'white')
            canvas.paste(qrcode_img)
            fname = f'qr_code-{self.name}.png'
            buffer = BytesIO()
            canvas.save(buffer,'PNG')
            self.qr_code.save(fname, File(buffer), save=False)
            canvas.close()
            
            super(Restaurant, self).save(*args, **kwargs)
            
            
        super(Restaurant, self).save(*args, **kwargs)

#models.py

class TableQrcode(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL,on_delete=models.CASCADE)
    qr_code = models.ImageField(upload_to='qr_codes_table/', blank=True, null=True)
    number = models.IntegerField(blank=True, null=True)
    capacity = models.IntegerField(blank=True, null=True)
    date_created = models.DateTimeField(auto_now_add=True)
    slug = models.SlugField(editable=False, unique=True)
    
    def save(self, *args,**kwargs):
        if not self.slug:
            self.slug = self.user.restaurant.slug + secrets.token_urlsafe(12)
        
        #super().save(*args, **kwargs) 
        
        if not self.qr_code:
            qrcode_img = qrcode.make("https://feedcool.fr/" + self.user.restaurant.resto_id_table + "/order/" + self.slug)
            canvas = Image.new('RGB', (420, 420), 'white')
            canvas.paste(qrcode_img)
            fname = f'qr_code_table_{self.user.restaurant.name}_{secrets.token_urlsafe(12)}.png'
            buffer = BytesIO()
            canvas.save(buffer,'PNG')
            self.qr_code.save(fname, File(buffer), save=False)
            canvas.close()
            
        super(TableQrcode, self).save(*args, **kwargs)
    
    def __str__(self):
        return self.slug
    
    class Meta:
        ordering = ['-date_created']

#models.py

class Order(models.Model):
    oder_id = models.CharField(max_length=8, editable=False, unique=True)
    code_verif = models.CharField(max_length=6, editable=False, unique=True)
    code_verif_try = models.CharField(max_length=6, blank=True, null=True)
    consumer = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="order_consumer")
    seller = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="order_seller")
    post = models.ForeignKey(Cuisine,on_delete=models.CASCADE,related_name="order_post", null=True,blank=True)
    prix = models.DecimalField(max_digits=4,decimal_places=2)
    # DATA
    start_time = models.TimeField(blank=True,null=True)
    deadline_time = models.TimeField(blank=True,null=True)
    start_date = models.DateField(blank=True,null=True)
    quantity = models.IntegerField(default=1)
    is_delivered = models.BooleanField(default=False)
    date_created = models.DateTimeField(auto_now_add=True)
    is_paid = models.BooleanField('', default=False)
    date_paid = models.DateTimeField(null=True,blank=True)
    is_ready = models.BooleanField('', default=False)
    # CODE
    is_received = models.BooleanField('', default=False)
    # CASH
    seller_get_monney = models.BooleanField('', default=False)
    is_cancelled = models.BooleanField('', default=False)
    slug = models.SlugField(editable=False,unique=True)
    
    
    def save(self, *args, **kwargs):
        # Enregistrement des données confidentielles
        if not self.slug:
            self.slug = secrets.token_urlsafe(12)
            
        if not self.oder_id:
            self.oder_id = secrets.token_urlsafe(8)
            
        if not self.code_verif:
            self.code_verif = secrets.token_urlsafe(6)
            
        super().save(*args, **kwargs)
        
    class Meta:
        ordering = ['-date_created']
        
    def __str__(self):
        return self.post.title
    
    def total_amount(self):
        return self.quantity * self.prix

#models.py

def notifs_order(sender, instance, *args, **kwargs):
	order = instance
	sender = order.consumer
	no_seller = order.seller
	order_paid = order.is_paid and not order.is_ready and not order.is_received
	order_ready = order.is_paid and order.is_ready  and not order.is_received
	order_received = order.is_paid and order.is_ready and order.is_received
	if order_paid:
	    notify = Notification(order=order, sender=sender, user=no_seller, notification_type=1)
	    title = "Feedcool - Commande - un utilisateur vient de commander"
	    message_infos = render_to_string('notifs_commande.html', {'sender': order.consumer,'date': order.start_date,'quantity': order.quantity,'n_userb': no_seller,'channel': order.post.slug,})
	
	elif order_received:
	    notify = Notification(order=order, sender=sender, user=no_seller, notification_type=1)
	    title = "Feedcool - Commande - votre repas a bien été collecté"
	    message_infos = render_to_string('notifs_livre.html', {'sender': order.consumer,'n_userb': no_seller,'channel': order.post.slug,})
	
	elif order_ready:
	    notify = Notification(order=order, sender=no_seller, user=sender, notification_type=6)
	    title = "Feedcool - Commande - votre commande est prête"
	    message_infos = render_to_string('notifs_ready.html', {'sender': order.consumer,'n_userb': no_seller, 'restaurant':order.seller.restaurant.name, 'addresse': order.seller.restaurant.full_address,'channel': order.post.slug, 'code': order.code_verif, 'number':order.oder_id,})
	
	else:
	    notify = Notification(order=order, sender=sender, user=no_seller, notification_type=2)
	    title = "Feedcool - Panier - un utilisateur a ajouté votre repas à son panier"
	    message_infos = render_to_string('notifs_panier.html', {'sender': order.consumer,'n_userb': no_seller,'channel': order.post.slug,})
	    #pass
	notify.save()
	
	send_mail(
    	    subject = title,
    	    message = message_infos,
    	    from_email="yep@nutri.feedcool.fr",
    	    recipient_list=[sender.email]
        )
        
post_save.connect(notifs_order, sender=Order)

#models.py

class Subscriber(models.Model):
    email = models.EmailField(unique=True)
    conf_num = models.CharField(max_length=15)
    confirmed = models.BooleanField(default=False)

    def __str__(self):
        return self.email + " (" + ("not " if not self.confirmed else "") + "confirmed)"

class Newsletter(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    subject = models.CharField(max_length=150)
    contents = models.FileField(upload_to='uploaded_newsletters/')

    def __str__(self):
        return self.subject + " " + self.created_at.strftime("%B %d, %Y")
    
    def send(self, request):
        contents = self.contents.read().decode('utf-8')
        subscribers = Subscriber.objects.filter(confirmed=True)
        sg = SendGridAPIClient(settings.SENDGRID_API_KEY)
        for sub in subscribers:
            message = Mail(
                    from_email=settings.FROM_EMAIL_SENDGRID,
                    to_emails=sub.email,
                    subject=self.subject,
                    html_content=contents + (
                        '<br><a href="{}newsletters/delete/?email={}&conf_num={}">Unsubscribe</a>.').format(
                            request.build_absolute_uri('newsletters/delete/'),
                            sub.email,
                            sub.conf_num))
            sg.send(message)

#models.py

class Blog(models.Model):
    title = models.CharField(max_length=70)
    user = models.ForeignKey(User, on_delete= models.CASCADE,related_name='blog_user')
    tableofcontent = RichTextField(blank=True, null=True)
    content = RichTextField(blank=True, null=True)
    image = models.ImageField(upload_to='blog/')
    section = models.ManyToManyField('Blogcategory', related_name='blog_section')
    related = models.ManyToManyField('self',blank=True, related_name="blog_related")
    seo_keyword = models.TextField(blank=True, null=True)
    seo_schema = RichTextField(blank=True, null=True)
    #updated_on = models.DateTimeField(auto_now= True)
    created_on = models.DateTimeField(auto_now_add=True)
    status = models.IntegerField(choices=STATUS, default=0)
    slug = models.SlugField(editable=False)
    
    def save(self, *args,**kwargs):
        if not self.slug:
            self.slug = unique_slugify(self, slugify(self.title))
        super(Blog, self).save(*args, **kwargs)
        
    class Meta:
        ordering = ['-created_on']    

    def __str__(self): 
        return self.title