├── blogs
    ├── __init__.py
    ├── tests
    │   ├── __init__.py
    │   ├── tests_forms.py
    │   ├── tests_urls.py
    │   ├── tests_models.py
    │   └── tests_views.py
    ├── migrations
    │   ├── __init__.py
    │   ├── 0008_auto_20210805_1232.py
    │   ├── 0005_auto_20210725_1505.py
    │   ├── 0003_notification_n_count.py
    │   ├── 0014_auto_20211221_1430.py
    │   ├── 0004_blog_slug.py
    │   ├── 0011_auto_20210808_1310.py
    │   ├── 0013_auto_20210810_1913.py
    │   ├── 0010_auto_20210808_1308.py
    │   ├── 0012_auto_20210808_1320.py
    │   ├── 0007_auto_20210805_1221.py
    │   ├── 0009_auto_20210805_1234.py
    │   ├── 0006_auto_20210804_1245.py
    │   ├── 0002_notification.py
    │   └── 0001_initial.py
    ├── templatetags
    │   ├── __init__.py
    │   ├── set_key.py
    │   └── dict_key.py
    ├── apps.py
    ├── static
    │   └── blogs
    │   │   ├── favicon.png
    │   │   ├── script.min.js
    │   │   ├── styles.min.css
    │   │   └── script.js
    ├── admin.py
    ├── context_processors.py
    ├── forms.py
    ├── templates
    │   └── blogs
    │   │   ├── search.html
    │   │   ├── blog_confirm_delete.html
    │   │   ├── blog_form.html
    │   │   ├── notifications.html
    │   │   ├── sample.html
    │   │   ├── view_post.html
    │   │   ├── index.html
    │   │   └── base.html
    ├── urls.py
    ├── test.html
    ├── models.py
    └── views.py
├── users
    ├── __init__.py
    ├── tests
    │   ├── __init__.py
    │   ├── tests_forms.py
    │   ├── tests_urls.py
    │   ├── tests_models.py
    │   └── tests_views.py
    ├── migrations
    │   ├── __init__.py
    │   ├── 0003_auto_20210805_1249.py
    │   ├── 0002_auto_20210804_1247.py
    │   └── 0001_initial.py
    ├── admin.py
    ├── apps.py
    ├── templates
    │   └── users
    │   │   ├── password_reset_done.html
    │   │   ├── password_reset_complete.html
    │   │   ├── logout.html
    │   │   ├── password_reset.html
    │   │   ├── password_reset_confirm.html
    │   │   ├── register.html
    │   │   ├── login.html
    │   │   ├── profile.html
    │   │   ├── update_profile.html
    │   │   ├── view_profile.html
    │   │   └── followers.html
    ├── signals.py
    ├── models.py
    ├── urls.py
    ├── forms.py
    └── views.py
├── blogs_api
    ├── __init__.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── admin.py
    ├── apps.py
    ├── serializers.py
    ├── urls.py
    ├── views.py
    └── DRF_Notes.md
├── Blog_application
    ├── __init__.py
    ├── settings
    │   ├── __init__.py
    │   ├── base.py
    │   ├── development.py
    │   └── production.py
    ├── asgi.py
    ├── wsgi.py
    └── urls.py
├── Procfile
├── screenshots
    ├── README.md
    ├── Screenshot_2021-07-30-22-09-44-19.jpg
    └── Screenshot_2021-07-30-22-10-53-97.jpg
├── media
    ├── default.png
    ├── profile_pics
    │   ├── Superman.jpg
    │   ├── interstellar.jpg
    │   ├── IMG_20200912_220030.jpg
    │   ├── IMG_20200912_223226.jpg
    │   └── 18-180335_transparent-captain-clipart-captain-america-shield-png-png.png
    └── posts_images
    │   ├── Profile_pic.jpg
    │   ├── interstellar.jpg
    │   ├── Tenet_movie_poster.jpg
    │   └── Profile_pic_fqTuRqo.jpg
├── .vscode
    └── settings.json
├── manage.py
├── requirements.txt
├── README.md
└── .gitignore


/blogs/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/users/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/blogs/tests/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/blogs_api/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/users/tests/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/Blog_application/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/blogs/migrations/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/users/migrations/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/blogs/templatetags/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/blogs_api/migrations/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/Blog_application/settings/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: gunicorn Blog_application.wsgi


--------------------------------------------------------------------------------
/screenshots/README.md:
--------------------------------------------------------------------------------
1 | ### Screenshots of the application.
2 | 


--------------------------------------------------------------------------------
/blogs_api/models.py:
--------------------------------------------------------------------------------
1 | from django.db import models
2 | 
3 | # Create your models here.
4 | 


--------------------------------------------------------------------------------
/blogs_api/admin.py:
--------------------------------------------------------------------------------
1 | from django.contrib import admin
2 | 
3 | # Register your models here.
4 | 


--------------------------------------------------------------------------------
/media/default.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/default.png


--------------------------------------------------------------------------------
/blogs/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class BlogsConfig(AppConfig):
5 |     name = 'blogs'
6 | 


--------------------------------------------------------------------------------
/blogs/static/blogs/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/blogs/static/blogs/favicon.png


--------------------------------------------------------------------------------
/media/profile_pics/Superman.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/profile_pics/Superman.jpg


--------------------------------------------------------------------------------
/blogs_api/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class BlogsApiConfig(AppConfig):
5 |     name = 'blogs_api'
6 | 


--------------------------------------------------------------------------------
/media/posts_images/Profile_pic.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/posts_images/Profile_pic.jpg


--------------------------------------------------------------------------------
/media/posts_images/interstellar.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/posts_images/interstellar.jpg


--------------------------------------------------------------------------------
/media/profile_pics/interstellar.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/profile_pics/interstellar.jpg


--------------------------------------------------------------------------------
/media/posts_images/Tenet_movie_poster.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/posts_images/Tenet_movie_poster.jpg


--------------------------------------------------------------------------------
/media/posts_images/Profile_pic_fqTuRqo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/posts_images/Profile_pic_fqTuRqo.jpg


--------------------------------------------------------------------------------
/media/profile_pics/IMG_20200912_220030.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/profile_pics/IMG_20200912_220030.jpg


--------------------------------------------------------------------------------
/media/profile_pics/IMG_20200912_223226.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/profile_pics/IMG_20200912_223226.jpg


--------------------------------------------------------------------------------
/screenshots/Screenshot_2021-07-30-22-09-44-19.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/screenshots/Screenshot_2021-07-30-22-09-44-19.jpg


--------------------------------------------------------------------------------
/screenshots/Screenshot_2021-07-30-22-10-53-97.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/screenshots/Screenshot_2021-07-30-22-10-53-97.jpg


--------------------------------------------------------------------------------
/users/admin.py:
--------------------------------------------------------------------------------
1 | from django.contrib import admin
2 | from .models import Profile, Followers
3 | 
4 | admin.site.register(Profile)
5 | admin.site.register(Followers)  
6 | 
7 | 


--------------------------------------------------------------------------------
/users/apps.py:
--------------------------------------------------------------------------------
1 | from django.apps import AppConfig
2 | 
3 | 
4 | class UsersConfig(AppConfig):
5 |     name = 'users'
6 | 
7 |     def ready(self):
8 |         import users.signals


--------------------------------------------------------------------------------
/media/profile_pics/18-180335_transparent-captain-clipart-captain-america-shield-png-png.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ram-95/blog_application_django/HEAD/media/profile_pics/18-180335_transparent-captain-clipart-captain-america-shield-png-png.png


--------------------------------------------------------------------------------
/users/templates/users/password_reset_done.html:
--------------------------------------------------------------------------------
1 | {% extends "blogs/base.html" %}
2 | {% block content %}
3 | <div class="container">
4 |     <h4>Password Reset instructions successfully sent to your Email ID</h4>
5 | </div>
6 | {% endblock content %}


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "python.testing.unittestArgs": [
 3 |         "-v",
 4 |         "-s",
 5 |         "./Blog_application",
 6 |         "-p",
 7 |         "*test*.py"
 8 |     ],
 9 |     "python.testing.pytestEnabled": false,
10 |     "python.testing.unittestEnabled": true
11 | }


--------------------------------------------------------------------------------
/blogs/admin.py:
--------------------------------------------------------------------------------
1 | from django.contrib import admin
2 | from . models import Blog, Likes_Table, Blog_comments, Notification
3 | 
4 | # Register your models here.
5 | admin.site.register(Blog)
6 | admin.site.register(Likes_Table)
7 | admin.site.register(Blog_comments)
8 | admin.site.register(Notification)
9 | 


--------------------------------------------------------------------------------
/users/templates/users/password_reset_complete.html:
--------------------------------------------------------------------------------
1 | {% extends "blogs/base.html" %}
2 | {% block content %}
3 | <div class="container">
4 |     <h4>Your password has been reset successfully. You can now Login.</h4>
5 |     <a href="{% url 'login' %}" class="btn btn-primary mt-4">Back to Login</a>
6 | </div>
7 | {% endblock content %}


--------------------------------------------------------------------------------
/users/templates/users/logout.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% block content %}
 3 | <div class="content-section">
 4 |     <h2> You have been logged out successfully.</h2>
 5 | 
 6 |     <div class="border-top pt-3">
 7 |         <small class="text-muted">
 8 |             <a href="{% url 'login' %}" class="ml-2">Back to Login</a>
 9 |         </small>
10 |     </div>
11 | </div>
12 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs/migrations/0008_auto_20210805_1232.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-05 07:02
 2 | 
 3 | from django.db import migrations
 4 | 
 5 | 
 6 | class Migration(migrations.Migration):
 7 | 
 8 |     dependencies = [
 9 |         ('blogs', '0007_auto_20210805_1221'),
10 |     ]
11 | 
12 |     operations = [
13 |         migrations.RenameField(
14 |             model_name='blog',
15 |             old_name='desciption',
16 |             new_name='description',
17 |         ),
18 |     ]
19 | 


--------------------------------------------------------------------------------
/Blog_application/asgi.py:
--------------------------------------------------------------------------------
 1 | """
 2 | ASGI config for Blog_application project.
 3 | 
 4 | It exposes the ASGI callable as a module-level variable named ``application``.
 5 | 
 6 | For more information on this file, see
 7 | https://docs.djangoproject.com/en/3.0/howto/deployment/asgi/
 8 | """
 9 | 
10 | import os
11 | 
12 | from django.core.asgi import get_asgi_application
13 | 
14 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Blog_application.settings')
15 | 
16 | application = get_asgi_application()
17 | 


--------------------------------------------------------------------------------
/blogs/tests/tests_forms.py:
--------------------------------------------------------------------------------
 1 | from django.test import SimpleTestCase
 2 | from blogs.forms import CommentForm
 3 | 
 4 | 
 5 | class TestForms(SimpleTestCase):
 6 |     def test_comment_form_valid_data(self):
 7 |         form = CommentForm(data={'content': 'First Comment'})
 8 |         self.assertTrue(form.is_valid())
 9 | 
10 |     def test_comment_form_no_data(self):
11 |         form = CommentForm(data={})
12 |         self.assertFalse(form.is_valid())
13 |         self.assertEquals(len(form.errors), 1)
14 | 


--------------------------------------------------------------------------------
/blogs/migrations/0005_auto_20210725_1505.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-07-25 09:35
 2 | 
 3 | from django.db import migrations, models
 4 | 
 5 | 
 6 | class Migration(migrations.Migration):
 7 | 
 8 |     dependencies = [
 9 |         ('blogs', '0004_blog_slug'),
10 |     ]
11 | 
12 |     operations = [
13 |         migrations.AlterField(
14 |             model_name='blog',
15 |             name='slug',
16 |             field=models.SlugField(max_length=255, unique=True),
17 |         ),
18 |     ]
19 | 


--------------------------------------------------------------------------------
/blogs/migrations/0003_notification_n_count.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-06-29 10:52
 2 | 
 3 | from django.db import migrations, models
 4 | 
 5 | 
 6 | class Migration(migrations.Migration):
 7 | 
 8 |     dependencies = [
 9 |         ('blogs', '0002_notification'),
10 |     ]
11 | 
12 |     operations = [
13 |         migrations.AddField(
14 |             model_name='notification',
15 |             name='n_count',
16 |             field=models.PositiveIntegerField(default=0),
17 |         ),
18 |     ]
19 | 


--------------------------------------------------------------------------------
/blogs/migrations/0014_auto_20211221_1430.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-12-21 09:00
 2 | 
 3 | from django.db import migrations, models
 4 | 
 5 | 
 6 | class Migration(migrations.Migration):
 7 | 
 8 |     dependencies = [
 9 |         ('blogs', '0013_auto_20210810_1913'),
10 |     ]
11 | 
12 |     operations = [
13 |         migrations.AlterField(
14 |             model_name='blog',
15 |             name='slug',
16 |             field=models.SlugField(blank=True, max_length=255, unique=True),
17 |         ),
18 |     ]
19 | 


--------------------------------------------------------------------------------
/blogs/migrations/0004_blog_slug.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-07-25 09:34
 2 | 
 3 | from django.db import migrations, models
 4 | 
 5 | 
 6 | class Migration(migrations.Migration):
 7 | 
 8 |     dependencies = [
 9 |         ('blogs', '0003_notification_n_count'),
10 |     ]
11 | 
12 |     operations = [
13 |         migrations.AddField(
14 |             model_name='blog',
15 |             name='slug',
16 |             field=models.SlugField(default='djangodbmodelsfieldscharfield', max_length=255, unique=False),
17 |         ),
18 |     ]
19 | 


--------------------------------------------------------------------------------
/blogs/migrations/0011_auto_20210808_1310.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-08 07:40
 2 | 
 3 | import ckeditor.fields
 4 | from django.db import migrations
 5 | 
 6 | 
 7 | class Migration(migrations.Migration):
 8 | 
 9 |     dependencies = [
10 |         ('blogs', '0010_auto_20210808_1308'),
11 |     ]
12 | 
13 |     operations = [
14 |         migrations.AlterField(
15 |             model_name='blog',
16 |             name='description',
17 |             field=ckeditor.fields.RichTextField(blank=True, null=True),
18 |         ),
19 |     ]
20 | 


--------------------------------------------------------------------------------
/blogs/migrations/0013_auto_20210810_1913.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-10 13:43
 2 | 
 3 | import ckeditor.fields
 4 | from django.db import migrations
 5 | 
 6 | 
 7 | class Migration(migrations.Migration):
 8 | 
 9 |     dependencies = [
10 |         ('blogs', '0012_auto_20210808_1320'),
11 |     ]
12 | 
13 |     operations = [
14 |         migrations.AlterField(
15 |             model_name='blog',
16 |             name='description',
17 |             field=ckeditor.fields.RichTextField(blank=True, null=True),
18 |         ),
19 |     ]
20 | 


--------------------------------------------------------------------------------
/users/signals.py:
--------------------------------------------------------------------------------
 1 | '''Used to create a Profile when a New user is registerd.'''
 2 | from django.db.models.signals import post_save
 3 | from django.contrib.auth.models import User
 4 | from django.dispatch import receiver
 5 | from .models import Profile
 6 | 
 7 | 
 8 | @receiver(post_save, sender=User)
 9 | def create_profile(sender, instance, created, **kwargs):
10 |     if created:
11 |         Profile.objects.create(user=instance)
12 | 
13 | 
14 | @receiver(post_save, sender=User)
15 | def save_profile(sender, instance, **kwargs):
16 |     instance.profile.save()


--------------------------------------------------------------------------------
/blogs/context_processors.py:
--------------------------------------------------------------------------------
 1 | from .models import Notification
 2 | 
 3 | 
 4 | def notifications_exist(request):
 5 |     if request.user.is_authenticated:
 6 |         unread_notifs = Notification.objects.get_notification_count(request.user)
 7 |         f = len(unread_notifs)
 8 |         
 9 |         status = True if f > 0 else False
10 |         return {
11 |             'status': status,
12 |             'notif_count': f,
13 |             'unread_notifs': unread_notifs,
14 |         }
15 |     else:
16 |         status = False
17 | 
18 |     return {'status': status}
19 | 


--------------------------------------------------------------------------------
/blogs/migrations/0010_auto_20210808_1308.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-08 07:38
 2 | 
 3 | import ckeditor_uploader.fields
 4 | from django.db import migrations
 5 | 
 6 | 
 7 | class Migration(migrations.Migration):
 8 | 
 9 |     dependencies = [
10 |         ('blogs', '0009_auto_20210805_1234'),
11 |     ]
12 | 
13 |     operations = [
14 |         migrations.AlterField(
15 |             model_name='blog',
16 |             name='description',
17 |             field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True),
18 |         ),
19 |     ]
20 | 


--------------------------------------------------------------------------------
/blogs/migrations/0012_auto_20210808_1320.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-08 07:50
 2 | 
 3 | import ckeditor_uploader.fields
 4 | from django.db import migrations
 5 | 
 6 | 
 7 | class Migration(migrations.Migration):
 8 | 
 9 |     dependencies = [
10 |         ('blogs', '0011_auto_20210808_1310'),
11 |     ]
12 | 
13 |     operations = [
14 |         migrations.AlterField(
15 |             model_name='blog',
16 |             name='description',
17 |             field=ckeditor_uploader.fields.RichTextUploadingField(blank=True, null=True),
18 |         ),
19 |     ]
20 | 


--------------------------------------------------------------------------------
/blogs/forms.py:
--------------------------------------------------------------------------------
 1 | from django import forms
 2 | from .models import Blog_comments
 3 | 
 4 | class CommentForm(forms.ModelForm):
 5 |     def __init__(self, *args, **kwargs):
 6 |         super(CommentForm, self).__init__(*args, **kwargs)
 7 |         # Removes the label for 'content' field
 8 |         self.fields['content'].label = False
 9 |     
10 |     class Meta:
11 |         model = Blog_comments
12 |         # To override the textarea of crispy-forms to use 3 rows in the textarea
13 |         widgets = {'content': forms.Textarea(attrs={'rows': 3})}
14 |         fields = ['content']
15 |         


--------------------------------------------------------------------------------
/users/templates/users/password_reset.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load crispy_forms_tags %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <form action="" method="POST">
 6 |         {% csrf_token %}
 7 |         <fieldset class="form-group">
 8 |             <legend class="border-bottom mb-4">
 9 |                 Reset Password
10 |             </legend>
11 |             {{ form|crispy }}
12 |         </fieldset>
13 |         <div class="form-group">
14 |             <button class="btn btn-outline-info" type="submit">Reset Password</button>
15 |         </div>
16 |     </form>
17 | 
18 | </div>
19 | {% endblock content %}


--------------------------------------------------------------------------------
/users/templates/users/password_reset_confirm.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load crispy_forms_tags %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <form action="" method="POST">
 6 |         {% csrf_token %}
 7 |         <fieldset class="form-group">
 8 |             <legend class="border-bottom mb-4">
 9 |                 Reset Password
10 |             </legend>
11 |             {{ form|crispy }}
12 |         </fieldset>
13 |         <div class="form-group">
14 |             <button class="btn btn-outline-info" type="submit">Reset Password</button>
15 |         </div>
16 |     </form>
17 | 
18 | </div>
19 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs/migrations/0007_auto_20210805_1221.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-05 06:51
 2 | 
 3 | import ckeditor.fields
 4 | from django.db import migrations
 5 | 
 6 | 
 7 | class Migration(migrations.Migration):
 8 | 
 9 |     dependencies = [
10 |         ('blogs', '0006_auto_20210804_1245'),
11 |     ]
12 | 
13 |     operations = [
14 |         migrations.RemoveField(
15 |             model_name='blog',
16 |             name='description',
17 |         ),
18 |         migrations.AddField(
19 |             model_name='blog',
20 |             name='desciption',
21 |             field=ckeditor.fields.RichTextField(blank=True, null=True),
22 |         ),
23 |     ]
24 | 


--------------------------------------------------------------------------------
/blogs/templates/blogs/search.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% block content %}
 3 | <div class="search_section content-section">
 4 |     <h4>Search Results</h4>
 5 | 
 6 |     <ul id="searchResults" style="list-style-type: none; margin: 1rem auto;">
 7 |         {% for item in results %}
 8 |         <li>
 9 |             <div class="card mt-2 p-2" style="align-items: flex-start"><a href="{% url 'profile' item.user %}">
10 |                     <img class="rounded-circle round_profile_pics mr-2" src="{{ item.profile_pic }}">{{ item.user }}
11 |                 </a>
12 |             </div>
13 |         </li>
14 |         {% endfor %}
15 |     </ul>
16 | </div>
17 | 
18 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs/templatetags/set_key.py:
--------------------------------------------------------------------------------
 1 | from django import template
 2 | register = template.Library()
 3 | """This is custom filter to extract key value from a Dictionary. 
 4 | This feature is not provided as part of Django Template Language
 5 | So writing our own template function to achieve this.
 6 | 
 7 | - This file should reside in a directory called 'templatetags' along with '__init__.py'
 8 | Reference: https://docs.djangoproject.com/en/dev/howto/custom-template-tags/
 9 | 
10 | To Use this filter: {{ <set_name|set_key:<key to search> }}
11 | """
12 | 
13 | @register.filter(name='set_key')
14 | def get_item(set, key):
15 |     '''Returns the given key from a set.'''
16 |     return key in set
17 |         
18 |     


--------------------------------------------------------------------------------
/users/migrations/0003_auto_20210805_1249.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-05 07:19
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
12 |         ('users', '0002_auto_20210804_1247'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='profile',
18 |             name='user',
19 |             field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/blogs/migrations/0009_auto_20210805_1234.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-05 07:04
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
12 |         ('blogs', '0008_auto_20210805_1232'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='likes_table',
18 |             name='user_id',
19 |             field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/blogs/templatetags/dict_key.py:
--------------------------------------------------------------------------------
 1 | from django import template
 2 | register = template.Library()
 3 | """This is custom filter to extract key value from a Dictionary. 
 4 | This feature is not provided as part of Django Template Language
 5 | So writing our own template function to achieve this.
 6 | 
 7 | - This file should reside in a directory called 'templatetags' along with '__init__.py'
 8 | Reference: https://docs.djangoproject.com/en/dev/howto/custom-template-tags/
 9 | 
10 | To Use this filter: {{ <dictionary_name|dict_key:<key to search> }}
11 | """
12 | 
13 | @register.filter(name='dict_key')
14 | def get_item(dictionary, key):
15 |     '''Returns the given key from a dictionary.'''
16 |     return dictionary.get(key)


--------------------------------------------------------------------------------
/users/migrations/0002_auto_20210804_1247.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-04 07:17
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
12 |         ('users', '0001_initial'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='profile',
18 |             name='user',
19 |             field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='user_profile', to=settings.AUTH_USER_MODEL),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/blogs/migrations/0006_auto_20210804_1245.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-08-04 07:15
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     dependencies = [
11 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
12 |         ('blogs', '0005_auto_20210725_1505'),
13 |     ]
14 | 
15 |     operations = [
16 |         migrations.AlterField(
17 |             model_name='likes_table',
18 |             name='user_id',
19 |             field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_likes', to=settings.AUTH_USER_MODEL),
20 |         ),
21 |     ]
22 | 


--------------------------------------------------------------------------------
/blogs/templates/blogs/blog_confirm_delete.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% block content %}
 3 | <div class="content-section">
 4 |     <form action="" method="POST">
 5 |         {% csrf_token %}
 6 |         <fieldset class="form-group">
 7 |             <legend class="border-bottom mb-4">
 8 |                 Delete Post
 9 |                 <h4>Are you sure you want to delete the Post?</h4>
10 |             </legend>
11 |         </fieldset>
12 |         <div class="form-group">
13 |             <button class="btn btn-outline-danger mr-3" type="submit">Yes, Delete</button>
14 |             <a href="{% url 'view_post' object.id object.slug %}" class="btn btn-outline-info">Cancel</a>
15 |         </div>
16 |     </form>
17 | </div>
18 | {% endblock content %}


--------------------------------------------------------------------------------
/Blog_application/wsgi.py:
--------------------------------------------------------------------------------
 1 | """
 2 | WSGI config for Blog_application project.
 3 | 
 4 | It exposes the WSGI callable as a module-level variable named ``application``.
 5 | 
 6 | For more information on this file, see
 7 | https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
 8 | """
 9 | 
10 | import os
11 | 
12 | from django.core.wsgi import get_wsgi_application
13 | 
14 | 
15 | curr_env = os.environ.get('DJANGO_ENV')
16 | if curr_env == 'DEV':
17 |     os.environ['DJANGO_SETTINGS_MODULE'] = 'Blog_application.settings.development'
18 | elif curr_env == 'PROD':
19 |     os.environ['DJANGO_SETTINGS_MODULE'] = 'Blog_application.settings.production'
20 | 
21 | #os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Blog_application.settings')
22 | 
23 | application = get_wsgi_application()
24 | 


--------------------------------------------------------------------------------
/users/templates/users/register.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load crispy_forms_tags %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <form method="POST">
 6 |         {% csrf_token %}
 7 |         <fieldset class="form-group">
 8 |             <legend class="border-bottom mb-4">
 9 |                 Join Today
10 |             </legend>
11 |             {{ form|crispy }}
12 |         </fieldset>
13 |         <div class="form-group">
14 |             <button class="btn btn-outline-info" type="submit">Sign Up</button>
15 |         </div>
16 |     </form>
17 |     <div class="border-top pt-3">
18 |         <small class="text-muted">
19 |             Already have an account? <a href="{% url 'login' %}" class="ml-2">Sign In</a>
20 |         </small>
21 |     </div>
22 | </div>
23 | {% endblock content %}


--------------------------------------------------------------------------------
/users/templates/users/login.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load crispy_forms_tags %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <form action="" method="POST">
 6 |         {% csrf_token %}
 7 |         <fieldset class="form-group">
 8 |             <legend class="border-bottom mb-4">
 9 |                 Log In
10 |             </legend>
11 |             {{ form|crispy }}
12 |         </fieldset>
13 |         <div class="form-group">
14 |             <button class="btn btn-outline-info" type="submit">Log In</button>
15 |             <a href="{% url 'password_reset' %}" class="ml-3" style="font-size: 14px;">Forgotten Password?</a>
16 |         </div>
17 |     </form>
18 |     <div class="border-top pt-3">
19 |         <small class="text-muted">
20 |             Do you need an account? <a href="{% url 'register' %}" class="ml-2">Sign Up</a>
21 |         </small>
22 |     </div>
23 | </div>
24 | {% endblock content %}


--------------------------------------------------------------------------------
/users/templates/users/profile.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% block content %}
 3 | <div class="content-section">
 4 |     <div class="profile_pane border flex">
 5 |         <img class="rounded-circle border" src="{{ user.profile.profile_pic.url }}" alt="profile_image" height="120px"
 6 |             width="120px">
 7 |         <div style="margin: 12px;">
 8 |             <h2>{{ user.username }}</h2>
 9 |             <small>{{ user.email }}</small>
10 |             <br>
11 |             <a href="{% url 'update_profile' %}"><small>Edit Profile</small></a>
12 |         </div>
13 |     </div>
14 |     <div class="posts_container border">
15 |         <h5>Posts</h5>
16 |         <ul class="list-group list-group-flush">
17 |             {% for blog in user_blogs %}
18 |             <li><a href="{% url 'view_post' blog.pk %}">{{ blog.title }}</a></li>
19 |             {% endfor %}
20 |         </ul>
21 |     </div>
22 | </div>
23 | {% endblock content %}


--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | """Django's command-line utility for administrative tasks."""
 3 | import os
 4 | import sys
 5 | 
 6 | 
 7 | def main():
 8 |     
 9 |     curr_env = os.environ.get('DJANGO_ENV')
10 |     if curr_env == 'DEV':
11 |         os.environ['DJANGO_SETTINGS_MODULE'] = 'Blog_application.settings.development'
12 |     elif curr_env == 'PROD':
13 |         os.environ['DJANGO_SETTINGS_MODULE'] = 'Blog_application.settings.production'
14 |     
15 |     #os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Blog_application.settings')
16 |     try:
17 |         from django.core.management import execute_from_command_line
18 |     except ImportError as exc:
19 |         raise ImportError(
20 |             "Couldn't import Django. Are you sure it's installed and "
21 |             "available on your PYTHONPATH environment variable? Did you "
22 |             "forget to activate a virtual environment?"
23 |         ) from exc
24 |     execute_from_command_line(sys.argv)
25 | 
26 | 
27 | if __name__ == '__main__':
28 |     main()
29 | 


--------------------------------------------------------------------------------
/blogs/templates/blogs/blog_form.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load crispy_forms_tags %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <form method="POST" enctype="multipart/form-data">
 6 |         {% csrf_token %}
 7 |         <fieldset class="form-group">
 8 |             <legend class="border-bottom mb-4">
 9 |                 Create Post
10 |             </legend>
11 |             {{ form.media }}
12 |             {{ form|crispy }}
13 |         </fieldset>
14 |         <div class="form-group">
15 |             <button class="btn btn-outline-info" type="submit">Submit</button>
16 |             {% if object %}
17 |             <!--Used for Update Post. Navigate to Post when user cancels updation.-->
18 |             <a class="btn btn-outline-danger ml-4" href="{% url 'view_post' object.id object.slug %}">Cancel</a>
19 |             {% else %}
20 |             <!--Used for Create Post. Navigate to Index when user cancels creation.-->
21 |             <a class="btn btn-outline-danger ml-4" href="{% url 'index' %}">Cancel</a>
22 |             {% endif %}
23 |         </div>
24 |     </form>
25 | </div>
26 | {% endblock content %}


--------------------------------------------------------------------------------
/users/templates/users/update_profile.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load crispy_forms_tags %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <div class="profile_pane border flex">
 6 |         <img class="rounded-circle border" src="{{ user.profile.profile_pic.url }}" alt="profile_image" height="120px"
 7 |             width="120px">
 8 |         <div style="margin: 10px;">
 9 |             <h2>{{ user.username }}</h2>
10 |             <small>{{ user.email }}</small>
11 |         </div>
12 |     </div>
13 |     <form method="POST" enctype="multipart/form-data">
14 |         {% csrf_token %}
15 |         <fieldset class="form-group">
16 |             <legend class="border-bottom mb-4">
17 |                 Update Profile
18 |             </legend>
19 |             {{ u_form|crispy }}
20 |             {{ p_form|crispy }}
21 |         </fieldset>
22 |         <div class="form-group">
23 |             <button class="btn btn-outline-info" type="submit">Update</button>
24 |             <a href="{% url 'profile' request.user.username %}" class="btn btn-outline-danger ml-3">Cancel</a>
25 |         </div>
26 |     </form>
27 | </div>
28 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs_api/serializers.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth.models import User
 2 | from blogs.models import Blog, Blog_comments
 3 | from rest_framework import serializers
 4 | 
 5 | 
 6 | 
 7 | class UserSerializer(serializers.ModelSerializer):
 8 |     ''' To show User data '''
 9 |     class Meta:
10 |         model = User
11 |         fields = ['username', 'first_name', 'last_name', 'email']
12 | 
13 | 
14 | class BlogSerializer(serializers.ModelSerializer):
15 |     ''' To show Posts data '''
16 |     class Meta:
17 |         model = Blog
18 |         fields = '__all__'
19 | 
20 | 
21 | class CommentSerializer(serializers.ModelSerializer):
22 |     ''' To show Comments data '''
23 |     class Meta:
24 |         model = Blog_comments
25 |         fields = '__all__'
26 | 
27 | 
28 | class ViewPostSerializer(serializers.ModelSerializer):
29 |     ''' To show a specific post along with comments data '''
30 |     # Use the CommentSerilizer to show comments as nested json
31 |     # Refer: https://www.django-rest-framework.org/api-guide/relations/#nested-relationships
32 |     comments = CommentSerializer(many=True, read_only=True)
33 | 
34 |     class Meta:
35 |         model = Blog
36 |         fields = '__all__'
37 | 


--------------------------------------------------------------------------------
/users/models.py:
--------------------------------------------------------------------------------
 1 | from django.db import models
 2 | from django.contrib.auth.models import User
 3 | from PIL import Image
 4 | 
 5 | class Profile(models.Model):
 6 |     user = models.OneToOneField(User, on_delete=models.CASCADE)
 7 |     profile_pic = models.ImageField(upload_to='profile_pics', default='default.png')
 8 | 
 9 |     def __str__(self):
10 |         return f'{self.user.username}\'s Profile'
11 | 
12 |     # Overriding the default save() method. To decrease the resolution of Profile Images
13 |     '''
14 |     def save(self, *args, **kwargs):
15 |         # saves the data of Profile class
16 |         super(Profile, self).save(*args, **kwargs)
17 |         img = Image.open(self.profile_pic.path)
18 |         if img.height > 300 or img.width > 300:
19 |             output_size = (300, 300)
20 |             img.thumbnail(output_size)
21 |             img.save(self.profile_pic.path)
22 |     '''
23 | 
24 | class Followers(models.Model):
25 |     user = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='follow_user')
26 |     followers = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='followers')
27 |     
28 |     
29 |     def __str__(self):
30 |         return f'{self.user} following {self.followers}'
31 |     
32 | 
33 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | aiohttp
 2 | altgraph==0.17
 3 | asgiref==3.2.10
 4 | astroid==2.4.2
 5 | async-timeout==3.0.1
 6 | attrs==19.3.0
 7 | Automat==20.2.0
 8 | autopep8==1.5.3
 9 | certifi==2020.6.20
10 | cffi==1.14.2
11 | chardet==3.0.4
12 | constantly==15.1.0
13 | cryptography==3.3.2
14 | cssselect==1.1.0
15 | dj-database-url==0.5.0
16 | Django==3.1.12
17 | django-cleanup==5.1.0
18 | django-crispy-forms==1.9.2
19 | django-heroku==0.3.1
20 | djangorestframework==3.11.2
21 | future==0.18.2
22 | gunicorn==20.0.4
23 | hyperlink==20.0.1
24 | idna==2.10
25 | incremental==17.5.0
26 | isort==4.3.21
27 | lazy-object-proxy==1.4.3
28 | lxml==4.6.3
29 | mccabe==0.6.1
30 | multidict==5.0.2
31 | oauthlib==3.1.0
32 | pefile==2019.4.18
33 | Pillow==8.2.0
34 | psycopg2==2.8.6
35 | pycodestyle==2.6.0
36 | pycparser==2.20
37 | PyDispatcher==2.0.5
38 | PyHamcrest==2.0.2
39 | pyinstaller-hooks-contrib==2020.11
40 | pylint==2.5.3
41 | pyOpenSSL==19.1.0
42 | PySocks==1.7.1
43 | pytz==2020.1
44 | pywin32-ctypes==0.2.0
45 | requests
46 | requests
47 | six==1.15.0
48 | soupsieve==2.0.1
49 | sqlparse==0.3.1
50 | toml==0.10.1
51 | typing-extensions==3.7.4.3
52 | urllib3
53 | whitenoise==5.2.0
54 | wrapt==1.12.1
55 | yarl==1.6.3
56 | zope.interface==5.1.0
57 | boto3==1.18.1
58 | django-storages==1.11.1
59 | botocore==1.21.1
60 | django-ckeditor==6.1.0


--------------------------------------------------------------------------------
/blogs/urls.py:
--------------------------------------------------------------------------------
 1 | from django.urls import path
 2 | from .views import PostListView, PostCreateView, PostUpdateView, PostDeleteView, PostDetailView
 3 | from . import views
 4 | 
 5 | 
 6 | urlpatterns = [
 7 |     path('', PostListView.as_view(), name="index"),
 8 |     path('create_post/', PostCreateView.as_view(), name="create_post"),
 9 |     path('post/<int:pk>/update/', PostUpdateView.as_view(), name="update_post"),
10 |     path('post/<int:pk>/delete/', PostDeleteView.as_view(), name="delete_post"),
11 |     path('post/<int:pk>/', PostDetailView.as_view(), name="view_post"),
12 |     path('post/<int:pk>/<slug:slug>/', PostDetailView.as_view(), name="view_post"),
13 |     path('delete_comment/', views.delete_comment, name="delete_comment"),
14 |     path('edit_comment/', views.edit_comment, name="edit_comment"),
15 |     path('refresh_comments/', views.refresh_comments, name="refresh_comments"),
16 |     path('vote_up/', views.vote_up, name="vote_up"),
17 |     path('vote_down/', views.vote_down, name="vote_down"),
18 |     path('notifications/', views.notifications, name="notifications"),
19 |     path('mark_notification_as_read/', views.mark_notification_as_read, name="mark_notification_as_read"),
20 |     path('search/', views.search, name="search"),
21 |     path('searchUser/', views.searchModel, name="searchUser"),
22 | ]
23 | 


--------------------------------------------------------------------------------
/blogs/migrations/0002_notification.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-04-03 12:51
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | import django.utils.timezone
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     dependencies = [
12 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
13 |         ('blogs', '0001_initial'),
14 |     ]
15 | 
16 |     operations = [
17 |         migrations.CreateModel(
18 |             name='Notification',
19 |             fields=[
20 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
21 |                 ('is_read', models.BooleanField()),
22 |                 ('category', models.CharField(max_length=10)),
23 |                 ('notification_date', models.DateTimeField(default=django.utils.timezone.now)),
24 |                 ('post_id', models.IntegerField(default=-1)),
25 |                 ('receiver', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='notification_receiver', to=settings.AUTH_USER_MODEL)),
26 |                 ('sender', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='notification_sender', to=settings.AUTH_USER_MODEL)),
27 |             ],
28 |         ),
29 |     ]
30 | 


--------------------------------------------------------------------------------
/blogs_api/urls.py:
--------------------------------------------------------------------------------
 1 | from django.urls import include, path
 2 | from rest_framework import routers, urlpatterns
 3 | from .views import (BlogGenericDetailAPIView, UserViewSet, BlogViewSet,
 4 |                     PostsViewSet, ViewPostViewSet, blog_list, blog_detail, BlogAPIView,
 5 |                     BlogDetailAPIView, BlogGenericAPIView, BlogGenericAPIView, UsersModelViewSet)
 6 | 
 7 | router = routers.DefaultRouter()
 8 | router.register('posts', PostsViewSet, basename='post')
 9 | router.register('users', UsersModelViewSet, basename='user')
10 | 
11 | 
12 | '''
13 | 1. To get user data - /api/users/?username=<username>
14 | 2. To get all posts of a user - /api/posts/?username=<username>
15 | 3. To view a post = /api/view_post/?post_id=<id>
16 | '''
17 | urlpatterns = [
18 |     path('viewset/', include(router.urls)),
19 |     path('viewset/<int:pk>/', include(router.urls)),
20 |     path('users/', UserViewSet.as_view({'get': 'list'})),
21 |     path('posts/', BlogViewSet.as_view()),
22 |     path('view_post/', ViewPostViewSet.as_view()),
23 |     #path('blogs/', blog_list),
24 |     path('blogs/', BlogAPIView.as_view()),
25 |     #path('blog/<int:pk>/', blog_detail),
26 |     path('blog/<int:pk>/', BlogDetailAPIView.as_view()),
27 |     path('generic/blog/<int:pk>/', BlogGenericDetailAPIView.as_view()),
28 |     path('generic/blogs/', BlogGenericAPIView.as_view()),
29 | 
30 | ]
31 | 


--------------------------------------------------------------------------------
/users/urls.py:
--------------------------------------------------------------------------------
 1 | from django.urls import path
 2 | from django.contrib.auth import views as auth_views
 3 | from . import views
 4 | 
 5 | urlpatterns = [
 6 |     path('register/', views.register, name="register"),
 7 |     path('login/', auth_views.LoginView.as_view(template_name="users/login.html"), name="login"),
 8 |     path('logout/', auth_views.LogoutView.as_view(template_name="users/logout.html"), name="logout"),
 9 |     path('password-reset/', auth_views.PasswordResetView.as_view(template_name="users/password_reset.html"), name="password_reset"),
10 |     path('password-reset/done/', auth_views.PasswordResetDoneView.as_view(template_name="users/password_reset_done.html"), name="password_reset_done"),
11 |     path('password-reset-confirm/<uidb64>/<token>/', auth_views.PasswordResetConfirmView.as_view(template_name="users/password_reset_confirm.html"), name="password_reset_confirm"),
12 |     path('password-reset-complete/', auth_views.PasswordResetCompleteView.as_view(template_name="users/password_reset_complete.html"), name="password_reset_complete"),
13 |     path('profile/<str:username>/', views.profile, name='profile'),
14 |     path('update-profile/', views.update_profile, name="update_profile"),
15 |     path('follow/', views.follow, name="follow"),
16 |     path('unfollow/', views.unfollow, name="unfollow"),
17 |     path('view_followers/<str:username>/', views.view_followers, name="view_followers"),
18 | 
19 | ]
20 | 


--------------------------------------------------------------------------------
/users/migrations/0001_initial.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-04-02 08:24
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | 
 7 | 
 8 | class Migration(migrations.Migration):
 9 | 
10 |     initial = True
11 | 
12 |     dependencies = [
13 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
14 |     ]
15 | 
16 |     operations = [
17 |         migrations.CreateModel(
18 |             name='Profile',
19 |             fields=[
20 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
21 |                 ('profile_pic', models.ImageField(default='default.png', upload_to='profile_pics')),
22 |                 ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
23 |             ],
24 |         ),
25 |         migrations.CreateModel(
26 |             name='Followers',
27 |             fields=[
28 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
29 |                 ('followers', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='followers', to='users.Profile')),
30 |                 ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='follow_user', to='users.Profile')),
31 |             ],
32 |         ),
33 |     ]
34 | 


--------------------------------------------------------------------------------
/users/forms.py:
--------------------------------------------------------------------------------
 1 | from django import forms
 2 | from django.contrib.auth.models import User
 3 | from django.contrib.auth.forms import UserCreationForm
 4 | from django.core.exceptions import ValidationError
 5 | from .models import Profile
 6 | 
 7 | 
 8 | class UserRegisterForm(UserCreationForm):
 9 |     first_name = forms.CharField(max_length=20)
10 |     last_name = forms.CharField(max_length=20)
11 |     email = forms.EmailField()
12 | 
13 |     class Meta:
14 |         model = User
15 |         fields = ['username', 'first_name', 'last_name',
16 |                   'email', 'password1', 'password2']
17 | 
18 |     def clean(self):
19 |         """Form Validations"""
20 |         cd = self.cleaned_data
21 |         cd_username = cd.get('username')
22 |         if User.objects.filter(username=cd_username).exists():
23 |             raise ValidationError('Username already taken.')
24 |         cd_email = cd.get('email')
25 |         if User.objects.filter(email=cd_email).exists():
26 |             raise ValidationError('Account with this email already exists.')
27 | 
28 |         return cd
29 | 
30 | 
31 | # Updates the User Model
32 | class UserUpdateForm(forms.ModelForm):
33 |     email = forms.EmailField()
34 | 
35 |     class Meta:
36 |         model = User
37 |         fields =  ['email']
38 | 
39 | 
40 | # Updates the Profile Model
41 | class ProfileUpdateForm(forms.ModelForm):
42 |     class Meta:
43 |         model = Profile
44 |         fields = ['profile_pic']
45 | 


--------------------------------------------------------------------------------
/users/tests/tests_forms.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth.forms import UserCreationForm
 2 | from django.test import TestCase, Client
 3 | from users.forms import UserRegisterForm, UserUpdateForm, ProfileUpdateForm, UserCreationForm
 4 | 
 5 | 
 6 | class TestUserForms(TestCase):
 7 |     """Tests to check forms of users application."""
 8 | 
 9 |     def test_user_created(self):
10 |         data = {
11 |             'username': 'Test',
12 |             'first_name': 'Test',
13 |             'last_name': 'name',
14 |             'email': 'test_mail1@email.com',
15 |             'password1': 'Testing@123',
16 |             'password2': 'Testing@123',
17 |         }
18 |         form = UserRegisterForm(data)
19 |         print(form.errors)
20 |         self.assertTrue(form.is_valid())
21 | 
22 |     def test_username_already_taken(self):
23 |         data = {
24 |             'username': 'Test',
25 |             'first_name': 'Test',
26 |             'last_name': 'name',
27 |             'email': 'test_mail1@email.com',
28 |             'password1': 'Testing@123',
29 |             'password2': 'Testing@123',
30 |         }
31 |         data1 = {
32 |             'username': 'Test',
33 |             'first_name': 'Test1',
34 |             'last_name': 'name1',
35 |             'email': 'test_mail12@email.com',
36 |             'password1': 'Testing@123',
37 |             'password2': 'Testing@123',
38 |         }
39 | 
40 |         form = UserRegisterForm(data)
41 |         form1 = UserRegisterForm(data1)
42 |         print(form1.errors)
43 |         self.assertTrue(form.is_valid())
44 |         self.assertTrue(form1.is_valid())


--------------------------------------------------------------------------------
/users/templates/users/view_profile.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load set_key %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <div class="profile_pane flex border">
 6 |         <img class="media rounded-circle" src="{{ curr_user.profile.profile_pic.url }}" alt="profile_image"
 7 |             height="150px" width="150px">
 8 |         <div class="profile_container">
 9 |             <h2 class="username_field">{{ curr_user.username }}</h2>
10 |             {% if user != curr_user %}
11 |                 {% if not followers|set_key:user.username %}
12 |                     <button class="follow-btn follow"><i class="fas fa-plus"></i>&nbsp;Follow</button>
13 |                 {% else %}
14 |                     <button class="following-btn follow"><i class="fas fa-check-circle"></i>&nbsp;Following</button>
15 |                 {% endif %}
16 |             {% else %}
17 |             <small>{{ user.email }}</small>
18 |             <br>
19 |             <a href="{% url 'update_profile' %}"><small>Edit Profile</small></a>
20 |             {% endif %}
21 |             <div class="followers_section mt-2" title="View connections">
22 |                 <a class="view_followers" href="{% url 'view_followers' curr_user %}"><small><i class="fas fa-users"></i>&nbsp;<b>{{ no_of_followers }}</b> follower{{ no_of_followers|pluralize }}</small>&nbsp;<small>| <b>{{ no_of_following }}</b>
23 |                     following</small></a>
24 |                 
25 |                 </div>
26 | 
27 |         </div>
28 |     </div>
29 |     <div class="posts_container border">
30 |         <h5>Posts</h5>
31 |         <ul class="list-group list-group-flush">
32 |             {% for blog in user_blogs %}
33 |             <li><a href="{% url 'view_post' blog.pk blog.slug %}">{{ blog.title }}</a></li>
34 |             {% endfor %}
35 |         </ul>
36 |     </div>
37 | </div>
38 | {% endblock content %}


--------------------------------------------------------------------------------
/Blog_application/urls.py:
--------------------------------------------------------------------------------
 1 | """Blog_application URL Configuration
 2 | 
 3 | The `urlpatterns` list routes URLs to views. For more information please see:
 4 |     https://docs.djangoproject.com/en/3.0/topics/http/urls/
 5 | Examples:
 6 | Function views
 7 |     1. Add an import:  from my_app import views
 8 |     2. Add a URL to urlpatterns:  path('', views.home, name='home')
 9 | Class-based views
10 |     1. Add an import:  from other_app.views import Home
11 |     2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
12 | Including another URLconf
13 |     1. Import the include() function: from django.urls import include, path
14 |     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
15 | """
16 | import os
17 | from django.contrib import admin
18 | from django.urls import path, include
19 | from django.conf import settings
20 | from django.conf.urls.static import static
21 | from .settings import development, production
22 | from ckeditor_uploader import views as ckeditor_views
23 | from django.contrib.auth.decorators import login_required
24 | from django.views.decorators.cache import never_cache
25 | 
26 | urlpatterns = [
27 |     path('admin/', admin.site.urls),
28 |     path('', include('blogs.urls')),
29 |     path('', include('users.urls')),
30 |     path('api/v1/', include('blogs_api.urls')),
31 |     #path('ckeditor/', include('ckeditor_uploader.urls')),
32 | 
33 |     path('ckeditor/upload/', login_required(ckeditor_views.upload),
34 |          name='ckeditor_upload'),
35 |     path('ckeditor/browse/', never_cache(login_required(ckeditor_views.browse)),
36 |          name='ckeditor_browse'),
37 | ]
38 | 
39 | curr_env = os.environ.get('DJANGO_ENV')
40 | if curr_env == 'PROD':
41 |     urlpatterns += static(production.MEDIA_URL,
42 |                           document_root=production.MEDIA_ROOT)
43 | 
44 | elif curr_env == 'DEV':
45 |     print(f'\n You are in Development.\n\n')
46 |     urlpatterns += static(development.MEDIA_URL,
47 |                           document_root=development.MEDIA_ROOT)
48 |     urlpatterns += static(development.STATIC_URL,
49 |                           document_root=development.STATIC_ROOT)
50 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Blog_application_django
 2 | A Blog application developed using Django framework 3.1. See live at: https://blog-app-pydj.herokuapp.com/
 3 | 
 4 | ### Features:
 5 | - User Authentication - Users can register, login and logout
 6 | - Create, Edit and Delete Posts
 7 | - Users can Like and Comment on posts.
 8 | - Connections - Follow/Unfollow other users.
 9 | 
10 | ### Steps to be followed for first time use
11 | - #### Set these Environment variables along with AWS Credentials
12 | 
13 | ```
14 | DEBUG_VALUE = True
15 | DJANGO_ENV = DEV
16 | SECRET_KEY_BLOG = <Your Secret Key>
17 | ```
18 | - #### Run these commands - This will create your application tables (by the Model definition) in the Database.
19 | ```
20 | python manage.py makemigrations
21 | 
22 | python manage.py migrate
23 | ```
24 | - #### Create an ```admin``` user by running these following commands
25 | ```
26 | python manage.py createsuperuser
27 | ```
28 | - #### Run Tests to ensure everything is set up and working correctly.
29 | ```
30 | python manage.py test
31 | ```
32 | 
33 | ### Blog Application API Endpoints
34 | 
35 | - GET ```https://blog-app-pydj.herokuapp.com/api/v1/viewset/users``` - Returns the list of all users registered.
36 | 
37 | #### Blogposts API Endpoints
38 | - GET ```https://blog-app-pydj.herokuapp.com/api/v1/viewset/posts``` - Returns the list of all posts by all users.
39 | - POST ```https://blog-app-pydj.herokuapp.com/api/v1/viewset/posts``` - Creates a new post. 
40 |     > Data required = ```{"title": "Title", "description": "Description", "author": "Author ID"}```
41 | - GET ```https://blog-app-pydj.herokuapp.com/api/v1/viewset/posts/<id>``` - Returns a post by it's post ID.
42 | - PUT ```https://blog-app-pydj.herokuapp.com/api/v1/viewset/posts/<id>``` - Updates a post by it's post ID.
43 | - DELETE ```https://blog-app-pydj.herokuapp.com/api/v1/viewset/posts/<id>``` - Deletes a post by it's post ID.
44 | - GET ```https://blog-app-pydj.herokuapp.com/api/v1/posts/?username=<username>``` - Returns a list of all posts by a specific user by his username.
45 | 
46 | 
47 | #### API Documentation - https://documenter.getpostman.com/view/18647792/UVJhDuVC
48 | 
49 | #### This will be updated regularly....
50 | 


--------------------------------------------------------------------------------
/users/tests/tests_urls.py:
--------------------------------------------------------------------------------
 1 | from django.test import SimpleTestCase
 2 | from django.urls import resolve, reverse
 3 | from users.views import *
 4 | from django.contrib.auth import views as auth_views
 5 | 
 6 | 
 7 | class TestURLs(SimpleTestCase):
 8 |     """Test to check if URLs resovle correctly."""
 9 | 
10 |     def test_register_is_resolved(self):
11 |         url = reverse('register')
12 |         self.assertEquals(resolve(url).func, register)
13 | 
14 |     def test_login_is_resolved(self):
15 |         url = reverse('login')
16 |         self.assertEquals(resolve(url).func.view_class, auth_views.LoginView)
17 | 
18 |     def test_logout_is_resolved(self):
19 |         url = reverse('logout')
20 |         self.assertEquals(resolve(url).func.view_class, auth_views.LogoutView)
21 | 
22 |     def test_password_reset_is_resolved(self):
23 |         url = reverse('password_reset')
24 |         self.assertEquals(resolve(url).func.view_class,
25 |                           auth_views.PasswordResetView)
26 | 
27 |     def test_password_reset_done_is_resolved(self):
28 |         url = reverse('password_reset_done')
29 |         self.assertEquals(resolve(url).func.view_class,
30 |                           auth_views.PasswordResetDoneView)
31 | 
32 |     def test_password_reset_complete_is_resolved(self):
33 |         url = reverse('password_reset_complete')
34 |         self.assertEquals(resolve(url).func.view_class,
35 |                           auth_views.PasswordResetCompleteView)
36 | 
37 |     def test_profile_is_resolved(self):
38 |         url = reverse('profile', args=['SomeUser'])
39 |         self.assertEquals(resolve(url).func, profile)
40 | 
41 |     def test_update_profile_is_resolved(self):
42 |         url = reverse('update_profile')
43 |         self.assertEquals(resolve(url).func, update_profile)
44 | 
45 |     def test_follow_is_resolved(self):
46 |         url = reverse('follow')
47 |         self.assertEquals(resolve(url).func, follow)
48 | 
49 |     def test_unfollow_is_resolved(self):
50 |         url = reverse('unfollow')
51 |         self.assertEquals(resolve(url).func, unfollow)
52 | 
53 |     def test_view_followers_is_resolved(self):
54 |         url = reverse('view_followers', args=['SomeUser'])
55 |         self.assertEquals(resolve(url).func, view_followers)
56 | 


--------------------------------------------------------------------------------
/blogs/migrations/0001_initial.py:
--------------------------------------------------------------------------------
 1 | # Generated by Django 3.0.8 on 2021-04-02 08:24
 2 | 
 3 | from django.conf import settings
 4 | from django.db import migrations, models
 5 | import django.db.models.deletion
 6 | import django.utils.timezone
 7 | 
 8 | 
 9 | class Migration(migrations.Migration):
10 | 
11 |     initial = True
12 | 
13 |     dependencies = [
14 |         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
15 |     ]
16 | 
17 |     operations = [
18 |         migrations.CreateModel(
19 |             name='Blog',
20 |             fields=[
21 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
22 |                 ('title', models.CharField(max_length=100)),
23 |                 ('description', models.TextField(max_length=10000)),
24 |                 ('publish_date', models.DateTimeField(default=django.utils.timezone.now)),
25 |                 ('likes', models.BigIntegerField(default=0)),
26 |                 ('image', models.ImageField(blank=True, null=True, upload_to='posts_images')),
27 |                 ('views', models.BigIntegerField(default=0)),
28 |                 ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
29 |             ],
30 |         ),
31 |         migrations.CreateModel(
32 |             name='Likes_Table',
33 |             fields=[
34 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
35 |                 ('like_status_id', models.BooleanField()),
36 |                 ('post_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='blogs.Blog')),
37 |                 ('user_id', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
38 |             ],
39 |         ),
40 |         migrations.CreateModel(
41 |             name='Blog_comments',
42 |             fields=[
43 |                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
44 |                 ('date_posted', models.DateTimeField(default=django.utils.timezone.now)),
45 |                 ('content', models.TextField()),
46 |                 ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
47 |                 ('blogpost', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='comments', to='blogs.Blog')),
48 |             ],
49 |         ),
50 |     ]
51 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | To_Do.txt
  2 | 
  3 | # Byte-compiled / optimized / DLL files
  4 | __pycache__/
  5 | *.py[cod]
  6 | *$py.class
  7 | 
  8 | # C extensions
  9 | *.so
 10 | 
 11 | # Distribution / packaging
 12 | .Python
 13 | media/
 14 | build/
 15 | develop-eggs/
 16 | dist/
 17 | downloads/
 18 | eggs/
 19 | .eggs/
 20 | lib/
 21 | lib64/
 22 | parts/
 23 | sdist/
 24 | var/
 25 | wheels/
 26 | pip-wheel-metadata/
 27 | share/python-wheels/
 28 | *.egg-info/
 29 | .installed.cfg
 30 | *.egg
 31 | MANIFEST
 32 | 
 33 | # PyInstaller
 34 | #  Usually these files are written by a python script from a template
 35 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 36 | *.manifest
 37 | *.spec
 38 | 
 39 | # Installer logs
 40 | pip-log.txt
 41 | pip-delete-this-directory.txt
 42 | 
 43 | # Unit test / coverage reports
 44 | htmlcov/
 45 | .tox/
 46 | .nox/
 47 | .coverage
 48 | .coverage.*
 49 | .cache
 50 | nosetests.xml
 51 | coverage.xml
 52 | *.cover
 53 | *.py,cover
 54 | .hypothesis/
 55 | .pytest_cache/
 56 | 
 57 | # Translations
 58 | *.mo
 59 | *.pot
 60 | 
 61 | # Django stuff:
 62 | *.log
 63 | local_settings.py
 64 | db.sqlite3
 65 | db.sqlite3-journal
 66 | 
 67 | # Flask stuff:
 68 | instance/
 69 | .webassets-cache
 70 | 
 71 | # Scrapy stuff:
 72 | .scrapy
 73 | 
 74 | # Sphinx documentation
 75 | docs/_build/
 76 | 
 77 | # PyBuilder
 78 | target/
 79 | 
 80 | # Jupyter Notebook
 81 | .ipynb_checkpoints
 82 | 
 83 | # IPython
 84 | profile_default/
 85 | ipython_config.py
 86 | 
 87 | # pyenv
 88 | .python-version
 89 | 
 90 | # pipenv
 91 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 92 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 93 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 94 | #   install all needed dependencies.
 95 | #Pipfile.lock
 96 | 
 97 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 98 | __pypackages__/
 99 | 
100 | # Celery stuff
101 | celerybeat-schedule
102 | celerybeat.pid
103 | 
104 | # SageMath parsed files
105 | *.sage.py
106 | 
107 | # Environments
108 | .env
109 | .venv
110 | env/
111 | venv/
112 | ENV/
113 | env.bak/
114 | venv.bak/
115 | 
116 | # Spyder project settings
117 | .spyderproject
118 | .spyproject
119 | 
120 | # Rope project settings
121 | .ropeproject
122 | 
123 | # mkdocs documentation
124 | /site
125 | 
126 | # mypy
127 | .mypy_cache/
128 | .dmypy.json
129 | dmypy.json
130 | 
131 | # Pyre type checker
132 | .pyre/
133 | 


--------------------------------------------------------------------------------
/blogs/test.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 |     <meta charset="UTF-8">
 6 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 7 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 8 |     <title>Document</title>
 9 |     <!--Bootstrap-->
10 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
11 |         integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
12 | 
13 |     <!-- JQuery and AJAX CDN -->
14 |     <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
15 | 
16 |     <!-- Javascript File-->
17 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.2/css/all.min.css"
18 |         integrity="sha512-HK5fgLBL+xu6dm/Ii3z4xhlSUyZgTT9tuc/hSrtw6uzJOvgRr2a9jyxxT1ely+B+xFAmJKVSTbpM/CuL7qxO8w=="
19 |         crossorigin="anonymous" />
20 |     <style>
21 |         body {
22 |             box-sizing: border-box;
23 |             padding: 20px;
24 |         }
25 | 
26 |         .follow {
27 |             padding: 8px;
28 |             border-radius: 20px;
29 |             color: white;
30 |             font-size: small;
31 |             font-weight: 600;
32 |             transition: all .3s ease-in;
33 |         }
34 | 
35 |         .follow-btn {
36 |             background-color: rgba(4, 90, 139, 0.74);
37 |         }
38 | 
39 |         .following-btn {
40 |             background-color: rgb(19, 214, 101);
41 |         }
42 | 
43 |         .follow:hover {
44 |             text-decoration: none;
45 |             color: white;
46 |         }
47 |     </style>
48 |     <script>
49 |         $(document).ready(function () {
50 |             $('.follow').on('click', function () {
51 |                 if ($(this).hasClass('follow-btn')) {
52 |                     $(this).removeClass('follow-btn');
53 |                     var following_code = '<i class="fas fa-check-circle"></i>&nbsp;Following';
54 |                     $(this).addClass('following-btn');
55 |                     $(this).html(following_code);
56 |                 }
57 |                 else if($(this).hasClass('following-btn')) {
58 |                     $(this).removeClass('following-btn');
59 |                     var follow_code = '<i class="fas fa-plus"></i>&nbsp;Follow';
60 |                     $(this).addClass('follow-btn');
61 |                     $(this).html(follow_code);
62 |                 }
63 |             });
64 | 
65 |         });
66 |     </script>
67 | </head>
68 | 
69 | <body>
70 |     <span>
71 |         <a href="#" class="follow-btn follow"><i class="fas fa-plus"></i>&nbsp;Follow</a>
72 |     </span>
73 | </body>
74 | 
75 | </html>


--------------------------------------------------------------------------------
/users/templates/users/followers.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load set_key %}
 3 | {% block content %}
 4 | <div class="content-section">
 5 |     <div class="container connections">
 6 |         <h3 style="text-align: center; margin-bottom: 1.5rem;">{{ curr_user }}'s Connections</h3>
 7 |         <ul class="nav nav-tabs nav-justified connections_header" role="tablist" id="myTab">
 8 |             <li class="nav-item">
 9 |                 <a class="nav-link active" id="followers-tab" data-toggle="tab" href="#followers" role="tab"
10 |                     aria-controls="followers" aria-selected="true">Followers <span class="Counter">{{ no_of_followers }}</span></a>
11 |             </li>
12 |             <li class="nav-item">
13 |                 <a class="nav-link" id="following-tab" data-toggle="tab" href="#following" role="tab"
14 |                     aria-controls="following" aria-selected="true">Following <span class="Counter">{{ no_of_following }}</span></a>
15 |             </li>
16 |         </ul>
17 |         <div class="tab-content" id="myTabContent">
18 |             <div id="followers" class="tab-pane fade show active" role="tabpanel" aria-labelledby="followers-tab">
19 |                 <ul class="followers_list media-list">
20 |                     {% for i in followers %}
21 |                     <li class="media p-2 mt-2">
22 |                         <img src="{{ i.user.user.profile.profile_pic.url }}" alt="profile_pic"
23 |                             class="rounded-circle mr-2" style="height: 50px; width: 50px">
24 |                         <a href="{% url 'profile' i.user.user %}" class="media-body m-auto">
25 |                             <p class="mb-1">{{ i.user.user }}</p>
26 |                         </a>
27 |                     </li>
28 |                     {% endfor %}
29 |                 </ul>
30 |             </div>
31 |             <div id="following" class="tab-pane fade" role="tabpanel" aria-labelledby="following-tab">
32 |                 <ul class="followers_list media-list">
33 |                     {% for i in following %}
34 |                     <li class="media p-2 mt-2" style="border-bottom: 1px solid gainsboro;">
35 |                         <img src="{{ i.followers.user.profile.profile_pic.url }}" alt="profile_pic"
36 |                             class="rounded-circle mr-2" style="height: 50px; width: 50px">
37 |                         <a href="{% url 'profile' i.followers.user %}" class="media-body m-auto">
38 |                             <p class="mb-1">{{ i.followers.user }}</p>
39 |                         </a>
40 |                     </li>
41 |                     {% endfor %}
42 |                 </ul>
43 |             </div>
44 |         </div>
45 |     </div>
46 | </div>
47 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs/tests/tests_urls.py:
--------------------------------------------------------------------------------
 1 | from django.test import SimpleTestCase, Client
 2 | from django.urls import resolve, reverse
 3 | from blogs.views import *
 4 | 
 5 | 
 6 | class TestURLs(SimpleTestCase):
 7 |     """Tests to check if the URLs are properly resolved."""
 8 | 
 9 |     def test_index_is_resolved(self):
10 |         url = reverse('index')
11 |         self.assertEquals(resolve(url).func.view_class, PostListView)
12 | 
13 |     def test_view_post_is_resolved(self):
14 |         url = reverse('view_post', args=[1])
15 |         self.assertEquals(resolve(url).func.view_class, PostDetailView)
16 |     
17 |     def test_view_post_with_slug_is_resolved(self):
18 |         url = reverse('view_post', args=[1, 'some-slug'])
19 |         self.assertEquals(resolve(url).func.view_class, PostDetailView)
20 | 
21 |     def test_create_post_is_resolved(self):
22 |         url = reverse('create_post')
23 |         self.assertEquals(resolve(url).func.view_class, PostCreateView)
24 | 
25 |     def test_update_post_is_resolved(self):
26 |         url = reverse('update_post', args=[1])
27 |         self.assertEquals(resolve(url).func.view_class, PostUpdateView)
28 | 
29 |     def test_delete_post_is_resolved(self):
30 |         url = reverse('delete_post', args=[1])
31 |         self.assertEquals(resolve(url).func.view_class, PostDeleteView)
32 | 
33 |     def test_delete_comment_is_resolved(self):
34 |         url = reverse('delete_comment')
35 |         self.assertEquals(resolve(url).func, delete_comment)
36 | 
37 |     def test_edit_comment_is_resolved(self):
38 |         url = reverse('edit_comment')
39 |         self.assertEquals(resolve(url).func, edit_comment)
40 | 
41 |     def test_refresh_comments_is_resolved(self):
42 |         url = reverse('refresh_comments')
43 |         self.assertEquals(resolve(url).func, refresh_comments)
44 | 
45 |     def test_vote_up_is_resolved(self):
46 |         url = reverse('vote_up')
47 |         self.assertEquals(resolve(url).func, vote_up)
48 | 
49 |     def test_vote_down_is_resolved(self):
50 |         url = reverse('vote_down')
51 |         self.assertEquals(resolve(url).func, vote_down)
52 | 
53 |     def test_notifications_is_resolved(self):
54 |         url = reverse('notifications')
55 |         self.assertEquals(resolve(url).func, notifications)
56 | 
57 |     def test_mark_notification_as_read_is_resolved(self):
58 |         url = reverse('mark_notification_as_read')
59 |         self.assertEquals(resolve(url).func, mark_notification_as_read)
60 | 
61 |     def test_search_is_resolved(self):
62 |         url = reverse('search')
63 |         self.assertEquals(resolve(url).func, search)
64 | 
65 |     def test_search_user_is_resolved(self):
66 |         url = reverse('searchUser')
67 |         self.assertEquals(resolve(url).func, searchModel)
68 | 


--------------------------------------------------------------------------------
/users/tests/tests_models.py:
--------------------------------------------------------------------------------
 1 | from django.test import TestCase
 2 | from users.models import Profile, Followers
 3 | from django.contrib.auth.models import User
 4 | 
 5 | 
 6 | class TestModels(TestCase):
 7 |     """Tests to check the models of Users application."""
 8 | 
 9 |     def setUp(self):
10 |         self.user1 = User.objects.create(
11 |             username='Test', first_name='Testname', last_name='Last', email='test@gmail.com', password='testing@123')
12 |         self.user2 = User.objects.create(
13 |             username='Test2', first_name='Testname2', last_name='Last2', email='test2@gmail.com', password='testing2@123')
14 | 
15 |     def test_user_label(self):
16 |         profile = Profile.objects.get(user=self.user1)
17 |         field_label = profile._meta.get_field('user').verbose_name
18 |         self.assertEquals(field_label, 'user')
19 | 
20 |     def test_profile_pic_label(self):
21 |         profile = Profile.objects.get(user=self.user1)
22 |         field_label = profile._meta.get_field('profile_pic').verbose_name
23 |         self.assertEquals(field_label, 'profile pic')
24 | 
25 |     def test_object_name_is_correct(self):
26 |         profile = Profile.objects.get(user=self.user1)
27 |         actual_value = f"{profile.user.username}'s Profile"
28 |         self.assertEquals(actual_value, str(profile))
29 | 
30 |     def test_if_user_is_created(self):
31 |         u = User.objects.filter(id=self.user1.id).exists()
32 |         self.assertTrue(u)
33 | 
34 |     def test_if_user_is_deleted(self):
35 |         User.objects.get(username=self.user2).delete()
36 |         u = User.objects.filter(id=self.user2.id).exists()
37 |         self.assertFalse(u)
38 | 
39 |     def test_if_correct_details_of_user_captured(self):
40 |         self.assertEquals(self.user1.username, 'Test')
41 |         self.assertEquals(self.user1.first_name, 'Testname')
42 |         self.assertEquals(self.user1.last_name, 'Last')
43 |         self.assertEquals(self.user1.email, 'test@gmail.com')
44 |         self.assertEquals(self.user1.password, 'testing@123')
45 | 
46 |     def test_if_profile_is_created_when_user_created(self):
47 |         p = Profile.objects.get(user=self.user1).user
48 |         self.assertEquals(self.user1, p)
49 | 
50 |     def test_if_profile_is_deleted_when_user_deleted(self):
51 |         User.objects.get(username=self.user2).delete()
52 |         p = Profile.objects.filter(user=self.user2).exists()
53 |         self.assertFalse(p)
54 | 
55 |     def test_if_default_profile_pic_is_assigned(self):
56 |         p = Profile.objects.get(user=self.user1)
57 |         self.assertEquals(p.profile_pic, 'default.png')
58 | 
59 |     def test_if_followers_are_created(self):
60 |         profile1 = Profile.objects.get(user=self.user1)
61 |         profile2 = Profile.objects.get(user=self.user2)
62 |         Followers.objects.create(
63 |             user=profile1, followers=profile2)
64 |         follower_exist = Followers.objects.filter(
65 |             user=profile1, followers=profile2).exists()
66 |         self.assertTrue(follower_exist)
67 | 


--------------------------------------------------------------------------------
/blogs/tests/tests_models.py:
--------------------------------------------------------------------------------
 1 | from django.test import TestCase
 2 | from blogs.models import Blog, Likes_Table, Blog_comments, Notification
 3 | from django.contrib.auth.models import User
 4 | from users.models import Profile
 5 | 
 6 | 
 7 | class TestModels(TestCase):
 8 |     """Tests to check Models of Blogs application."""
 9 | 
10 |     def setUp(self):
11 |         self.user1 = User.objects.create(
12 |             username='Test', first_name='Testname', last_name='Last', email='test@gmail.com', password='testing@123')
13 |         self.post1 = Blog.objects.create(
14 |             title='Post1', description='Some content', author=self.user1)
15 |         self.liked = Likes_Table.objects.create(
16 |             user_id=self.user1, post_id=self.post1, like_status_id=True)
17 |         self.comment = Blog_comments.objects.create(
18 |             blogpost=self.post1, author=self.user1, content='First Comment')
19 |         self.profile1 = Profile.objects.get(user=self.user1)
20 | 
21 |     def test_blog_post_created(self):
22 |         self.assertIsInstance(self.post1, Blog)
23 |         b = Blog.objects.get(id=1)
24 |         self.assertEquals(self.post1.id, b.id)
25 |         self.assertEquals(self.post1.title, b.title)
26 |         self.assertEquals(self.post1.description, b.description)
27 |         self.assertEquals(self.post1.author, b.author)
28 |     
29 |     def test_post_assigned_slug_on_creation(self):
30 |         self.assertEquals(self.post1.slug, 'post1')
31 | 
32 |     def test_unique_slug_assinged(self):
33 |         post2 = Blog.objects.create(
34 |             title='Post1', description='Some content-2', author=self.user1)
35 |         self.assertNotEquals(self.post1.slug, post2.slug)
36 | 
37 |     def test_post_liked(self):
38 |         self.assertEquals(self.liked.like_status_id, True)
39 | 
40 | 
41 | class TestComments(TestCase):
42 |     """Tests to check the Blog_comments model."""
43 |     def setUp(self):
44 |         self.user1 = User.objects.create(
45 |             username='Test', first_name='Testname', last_name='Last', email='test@gmail.com', password='testing@123')
46 |         self.post1 = Blog.objects.create(
47 |             title='Post1', description='Some content', author=self.user1)
48 |         self.liked = Likes_Table.objects.create(
49 |             user_id=self.user1, post_id=self.post1, like_status_id=True)
50 |         self.comment = Blog_comments.objects.create(
51 |             blogpost=self.post1, author=self.user1, content='First Comment')
52 | 
53 |     def test_comments_number_of_post(self):
54 |         self.assertEquals(self.post1.number_of_comments(), 1)
55 | 
56 |     def test_comment_inserted_by_user_for_post(self):
57 |         self.assertEquals(self.comment.blogpost, self.post1)
58 | 
59 |     def test_comment_inserted_content_post(self):
60 |         self.assertEquals(self.comment.content, 'First Comment')
61 |     
62 |     def test_comment_objects_str_representation(self):
63 |         self.assertEquals(str(self.comment), f'{self.user1.username}, {self.post1.title[:30]}')
64 |     
65 |     def test_comments_of_user_deleted_if_user_is_deleted(self):
66 |         # Deleting a user
67 |         User.objects.get(id=self.user1.id).delete()
68 |         # Check if the all comments of the user are deleted
69 |         comments = Blog_comments.objects.filter(author=self.user1).exists()
70 |         self.assertFalse(comments)
71 | 
72 | 


--------------------------------------------------------------------------------
/blogs/templates/blogs/notifications.html:
--------------------------------------------------------------------------------
 1 | {% extends "blogs/base.html" %}
 2 | {% load dict_key %}
 3 | {% load humanize %}
 4 | {% block content %}
 5 | <div class="content-section">
 6 |     <div class="list-group notifications_section">
 7 |         <p class="list-group-item"
 8 |             style="text-align: center; font-size: 1.5rem; font-weight: 700; background-color: yellowgreen ;">
 9 |             Notifications</p>
10 |         {% for notif in unread_notifications %}
11 |             {% if notif.n_post_id == -1 %}
12 |                 <a id="{{ notif.n_post_id }}" href="{% url 'profile' notif.n_sender %}"
13 |                     class="list-group-item unread list-group-item-action notification-list">
14 |                 <img class="rounded-circle round_profile_pics mr-2" src="{{ notif.n_profile_pic }}">
15 |                 {% if notif.n_count > 0 %}
16 |                     <span><strong>{{ notif.n_sender }}</strong> and <strong>{{ notif.n_count }} other{{ notif.n_count|pluralize }}</strong> started following you</span>
17 |                 {% else %}
18 |                     <span><strong>{{ notif.n_sender }}</strong> started following you</span>
19 |                 {% endif %}
20 |                 <small class="notif_timestamp">{{ notif.n_timestamp|naturaltime }}</small></a>
21 |             {% else %}
22 |                 <a id="{{ notif.n_post_id }}" href="{% url 'view_post' notif.n_post_id %}"
23 |                     class="list-group-item unread list-group-item-action notification-list">
24 |                 <img class="rounded-circle round_profile_pics mr-2" src="{{ notif.n_profile_pic }}">
25 |                 {% if notif.n_count > 0 %}
26 |                     <span><strong>{{ notif.n_sender }}</strong> and <strong>{{ notif.n_count }} other{{ notif.n_count|pluralize }}</strong> commented on your post</span>
27 |                 {% else %}
28 |                     <span><strong>{{ notif.n_sender }}</strong> commented on your post</span>
29 |                 {% endif %}
30 |                 <small class="notif_timestamp">{{ notif.n_timestamp|naturaltime }}</small>
31 |             </a>
32 |             {% endif %}
33 |             
34 |         {% endfor %}
35 |         {% for notif in read_notifications %}
36 |                 {% if notif.category == 'follow' %}
37 |                     <a id="{{ notif.post_id }}" href="{% url 'profile' notif.sender %}"
38 |                         class="list-group-item read list-group-item-action notification-list">
39 |                     <img class="rounded-circle round_profile_pics mr-2" src="{{ profile_imgs|dict_key:notif.sender }}">
40 |                     {% if notif.n_count > 0 %}
41 |                         <span><strong>{{ notif.sender }}</strong> and <strong>{{ notif.n_count }} other{{ notif.n_count|pluralize }}</strong> started following you</span>
42 |                     {% else %}
43 |                         <span><strong>{{ notif.sender }}</strong> started following you</span>
44 |                     {% endif %}
45 |                 {% else %}
46 |                 <a id="{{ notif.post_id }}" href="{% url 'view_post' notif.post_id %}"
47 |                     class="list-group-item read list-group-item-action notification-list">
48 |                 <img class="rounded-circle round_profile_pics mr-2" src="{{ profile_imgs|dict_key:notif.sender }}">
49 |                     {% if notif.n_count > 0 %}
50 |                         <span><strong>{{ notif.sender }}</strong> and <strong>{{ notif.n_count }} other{{ notif.n_count|pluralize }}</strong> commented on your post</span>
51 |                     {% else %}
52 |                         <span><strong>{{ notif.sender }}</strong> commented on your post</span>
53 |                     {% endif %}
54 |                 {% endif %}
55 |                 <small class="notif_timestamp">{{ notif.notification_date|naturaltime }}</small>
56 |                 </a>
57 |         {% endfor %}
58 |     </div>
59 | </div>
60 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs/static/blogs/script.min.js:
--------------------------------------------------------------------------------
1 | $(document).ready((function(){function refresh_comments(post_id){$.ajax({type:"GET",url:"/refresh_comments/",data:{post_id:post_id},success:function(data){no_of_comments=data.no_of_comments,0==no_of_comments?$(".comments").text("No comments yet."):1==no_of_comments?$(".comments").text(no_of_comments+" Comment"):$(".comments").text(no_of_comments+" Comments")}})}window.setTimeout((function(){$(".alert").fadeTo(500,0).slideUp(500,(function(){$(this).hide()}))}),5e3),$(".follow-btn").on("click",(function(){username=$(".username_field").text();var current_obj=$(this);$.ajax({type:"POST",url:"/follow/",data:{username:username},success:function(data){"success"==data.status&&location.reload()}})})),$(".following-btn").on("click",(function(){username=$(".username_field").text(),$.ajax({type:"POST",url:"/unfollow/",data:{username:username},success:function(data){"success"==data.status&&location.reload()}})})),$(document).on("click",".vote_up",(function(){post_id=$(this).closest("article").attr("id"),likes=$("#"+post_id).find("#votes_count").text(),$.ajax({type:"POST",url:"/vote_up/",cache:!1,data:{post_id:post_id},success:function(data){"success"==data.status?(likes++,$("#"+post_id).find("#votes_count").text(likes),$("#upvote_"+post_id).css("color","#8bf178"),$("#downvote_"+post_id).css("color","")):"Invalid"==data.status&&alert("You cannot vote on your own post!")}})})),$(document).on("click",".vote_down",(function(){post_id=$(this).closest("article").attr("id"),likes=$("#"+post_id).find("#votes_count").text(),$.ajax({type:"POST",url:"/vote_down/",cache:!1,data:{post_id:post_id},success:function(data){"success"==data.status?(likes--,$("#"+post_id).find("#votes_count").text(likes),$("#downvote_"+post_id).css("color","red"),$("#upvote_"+post_id).css("color","")):"Invalid"==data.status&&alert("You cannot vote on your own post.")}})})),$(document).on("click",".delete_comment",(function(){var result;confirm("Are you sure you want to delete your comment?")&&(comment_id=$(this).closest("li").attr("id"),post_id=$("article").attr("id"),$.ajax({type:"POST",url:"/delete_comment/",cache:!1,data:{comment_id:comment_id},success:function(){$("#"+comment_id).hide(),refresh_comments(post_id)}}))})),$((function(){var comment;$(document).on("click",".edit_comment",(function(){comment_id=$(this).closest("li").attr("id"),comment=$("#"+comment_id).find("p").text().trim(),$(".edit_delete").hide(),$("#"+comment_id).find(".comment_p").html("<textarea class='form-control mb-2 comment_edit_text'>"+comment+"</textarea><a href='#' class='save_edit_btn mr-3'>Save</a><a href='#' class='cancel_edit_btn'>Cancel</a>")})),$(document).on("click",".cancel_edit_btn",(function(){comment_id=$(this).closest("li").attr("id"),$(".edit_delete").show(),$("#"+comment_id).find(".comment_p").html('<p class="comment_text">'+comment+"</p>")}))})),$(document).on("click",".save_edit_btn",(function(){comment_id=$(this).closest("li").attr("id"),edit_comment=$(".comment_edit_text").val(),$.ajax({type:"POST",url:"/edit_comment/",cache:!1,data:{comment_id:comment_id,edit_comment:edit_comment},success:function(){$(".edit_delete").show(),$("#"+comment_id).find(".comment_p").html('<p class="comment_text">'+edit_comment+"</p>")}})})),$(document).on("click",".notification-list",(function(){n_id=$(this).attr("id"),$.ajax({type:"POST",url:"/mark_notification_as_read/",cache:!1,data:{n_post_id:n_id},success:function(){}})})),$("#noti_Button").click((function(){return $("#notifications").fadeToggle("fast","linear",(function(){$("#notifications").is(":hidden")})),$("#noti_counter").fadeOut("slow"),!1})),$(document).click((function(){$("#notifications").hide()})),$(".index_blog_full_description img").click((function(){$("#full-image").attr("src",$(this).attr("src")),$("#image-viewer").show()})),$(".blog_image").click((function(){$("#full-image").attr("src",$(this).attr("src")),$("#image-viewer").show()})),$("#image-viewer").on("click",(function(){$("#image-viewer").hide()})),$("#image-viewer .close").click((function(){$("#image-viewer").hide()})),$("#txtSearch").keyup((function(){var val=$(this).val();$.ajax({type:"GET",data:{uname:val},url:"/searchUser/",success:function(data){if(data.results.length>0)for(var key in $("#searchResults").empty(),data)for(var val in data[key]){var htm='<img class="rounded-circle round_profile_pics mr-2" src="'+data[key][val].profile_pic+'"></img>';$("#searchResults").append(htm+"<a href='/profile/"+data[key][val].user+"'><h6>"+data[key][val].user+"</h6></a></li>")}}})}))}));


--------------------------------------------------------------------------------
/blogs/templates/blogs/sample.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | 
  4 | <head>
  5 |     <meta charset="UTF-8">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |     <title>Sample - Flex</title>
  8 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
  9 |         integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
 10 |     <style>
 11 |         * {
 12 |             margin: 0;
 13 |             padding: 0;
 14 |             box-sizing: border-box;
 15 |         }
 16 | 
 17 |         body {
 18 |             max-width: 100%;
 19 |             margin: 2px auto;
 20 |         }
 21 | 
 22 |         .child1,
 23 |         .child2 {
 24 |             border: 1px solid #ccc;
 25 |             padding: 10px;
 26 |         }
 27 | 
 28 |         .child1 {
 29 |             flex: 2;
 30 |         }
 31 | 
 32 |         .child2 {
 33 |             flex: 1;
 34 |             margin-left: 10px;
 35 |             background-color: #fff;
 36 |         }
 37 | 
 38 |         .flex {
 39 |             display: flex;
 40 |             justify-content: center;
 41 |             align-items: flex-start;
 42 |             max-width: 100%;
 43 |             padding: 10px;
 44 |         }
 45 | 
 46 |         p,
 47 |         h2 {
 48 |             text-align: center;
 49 |         }
 50 | 
 51 |         .child2 p {
 52 |             font-size: large;
 53 |             font-weight: bold;
 54 |         }
 55 | 
 56 |         ul {
 57 |             list-style-type: none;
 58 |             padding: 10px;
 59 |         }
 60 |     </style>
 61 | </head>
 62 | 
 63 | <body>
 64 |     <div class="container flex">
 65 |         <div class="child1">
 66 |             <h2>Block-1</h2>
 67 |             <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Molestiae dignissimos, culpa explicabo
 68 |                 cupiditate eaque repellendus? Unde assumenda, placeat necessitatibus eveniet sapiente obcaecati, quas
 69 |                 nulla consequatur ullam adipisci rem omnis repudiandae!
 70 |                 Veritatis, aperiam minus laborum dignissimos pariatur fugiat eveniet sed dolores totam at quisquam
 71 |                 doloribus odit quos ipsum possimus molestiae debitis architecto inventore earum culpa delectus
 72 |                 aspernatur iure. At, consequuntur harum.
 73 |                 Aliquam commodi dignissimos cum perferendis aut consequatur rerum odio in. Excepturi vitae quis sed
 74 |                 doloremque illum eligendi neque vero, minus quaerat libero consectetur dicta quasi adipisci quia
 75 |                 similique id inventore.
 76 |                 Culpa cupiditate esse ipsam doloribus delectus repellat voluptatibus labore obcaecati eaque iusto. Sed
 77 |                 dolorum laborum quasi, incidunt culpa tempora adipisci minus natus facere dignissimos. Unde, ducimus
 78 |                 perspiciatis! Totam, aliquid assumenda!
 79 |                 A, placeat libero excepturi necessitatibus aliquam eaque deleniti repellat natus corporis, assumenda
 80 |                 dolores veritatis nesciunt ipsum culpa soluta ex pariatur vel corrupti, tempore atque nam molestiae
 81 |                 fugit quo iste! Fugiat.
 82 |                 Mollitia, itaque? Hic facilis temporibus quod, iure ipsum non saepe, quidem dolorem omnis sunt ipsa fuga
 83 |                 exercitationem magni deleniti blanditiis assumenda fugiat ut atque reprehenderit delectus nostrum!
 84 |                 Labore, earum obcaecati?
 85 |                 Ullam accusamus numquam repellat magnam quis doloribus reprehenderit maiores rem facere quia, expedita
 86 |                 sapiente reiciendis voluptatibus quidem veritatis, quam magni id quasi aut. Amet recusandae voluptatibus
 87 |                 repudiandae incidunt sapiente harum.
 88 |                 Atque iusto voluptate quae laborum a culpa accusantium sequi itaque ipsa commodi suscipit eum laboriosam
 89 |                 libero ex molestias iste nihil officiis temporibus distinctio in, eius cupiditate saepe non alias. Et!
 90 |                 Praesentium nam earum accusantium ad distinctio autem, eaque numquam dolores quia dolorem nobis officiis
 91 |                 laboriosam consectetur aspernatur iusto nulla qui porro cupiditate mollitia. Tempora, ratione asperiores
 92 |                 rem et voluptate autem?
 93 |                 Quam, quia? Expedita explicabo vitae deserunt aperiam dolore ducimus voluptatibus nisi? Porro voluptates
 94 |                 labore ratione quasi recusandae laborum similique eius! Iste incidunt veritatis amet deserunt aspernatur
 95 |                 quo qui doloremque expedita.</p>
 96 |         </div>
 97 |         <div class="child2">
 98 |             <p>Latest Blogs</p>
 99 |             <ul style="list-style-type: none;">
100 |                 <li>Blog1</li>
101 |                 <li>Blog2</li>
102 |                 <li>Blog3</li>
103 |             </ul>
104 |             <hr>
105 |             <p>Trending Blogs</p>
106 |             <ul>
107 |                 <li>T-Blog1</li>
108 |                 <li>T-Blog2</li>
109 |                 <li>T-Blog3</li>
110 |             </ul>
111 |             <hr>
112 |             <p>Misc</p>
113 |             </ul>
114 |         </div>
115 |     </div>
116 | </body>
117 | 
118 | </html>


--------------------------------------------------------------------------------
/blogs/templates/blogs/view_post.html:
--------------------------------------------------------------------------------
  1 | {% extends "blogs/base.html" %}
  2 | {% load dict_key %}
  3 | {% load crispy_forms_tags %}
  4 | {% block content %}
  5 | <div class="content-section">
  6 |     <article id="{{ blog.id }}" class="border mb-2">
  7 |         <div class="post_div">
  8 |             <div class="votes_container">
  9 |                 {% if user.is_authenticated %}
 10 |                 {% if blog.id in posts_liked %}
 11 |                 {% if posts_liked|dict_key:blog.id is True %}
 12 |                 <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" style="color: #8bf178;"
 13 |                     title="Upvote"></i>
 14 |                 <span id="votes_count">{{ blog.likes }}</span>
 15 |                 <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}" title="Downvote"></i>
 16 |                 {% else %}
 17 |                 <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" title="Upvote"></i>
 18 |                 <span id="votes_count">{{ blog.likes }}</span>
 19 |                 <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}" style="color: red;"
 20 |                     title="Downvote"></i>
 21 |                 {% endif %}
 22 | 
 23 |                 {% else %}
 24 |                 <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" title="Upvote"></i>
 25 |                 <span id="votes_count">{{ blog.likes }}</span>
 26 |                 <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}" title="Downvote"></i>
 27 |                 {% endif %}
 28 | 
 29 |                 {% else %}
 30 |                 <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" title="Upvote"
 31 |                     data-toggle="modal" data-target="#exampleModalCenter"></i>
 32 |                 <span id="votes_count">{{ blog.likes }}</span>
 33 |                 <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}" title="Downvote"
 34 |                     data-toggle="modal" data-target="#exampleModalCenter"></i>
 35 |                 {% endif %}
 36 |             </div>
 37 |             <div class="post_header" style="flex: 2;">
 38 |                 <h2 class="post_header_h2">{{ blog.title }}</h2>
 39 |                 <a href="{% url 'profile' blog.author %}" style="text-decoration: none;"><small
 40 |                         style="margin-right: 5px; font-size: 12px; font-weight: bold;">{{ blog.author }}</small></a>| 
 41 |                 <small class="date">{{ blog.publish_date|date:"F d, Y" }}</small>
 42 |             </div>
 43 |             {% if blog.author == user %}
 44 |             <div class="update_delete_section mt-2">
 45 |                 <a class="update_btn my_btn" href="{% url 'update_post' blog.id %}">Update</a>
 46 |                 <a class="delete_btn my_btn" href="{% url 'delete_post' blog.id %}">Delete</a>
 47 |             </div>
 48 |             {% endif %}
 49 |         </div>
 50 |         
 51 |         
 52 |         <div class="index_blog_full_description">
 53 |             {% if blog.image.url is not null %}
 54 |                 <img class="mt-2 rounded mx-auto d-block blog_image" src="{{ blog.image.url }}">
 55 |             {% endif %}
 56 |             {{ blog.description|safe }}
 57 |         </div>
 58 |     <i class="fas fa-eye ml-1 mr-1" aria-hidden="true"></i>
 59 |     <small class="text-secondary mr-3">{{ blog.views }} view{{ blog.views|pluralize }}</small>
 60 | </article>
 61 |         
 62 |         <!--Comment section-->
 63 |         {% if user.is_authenticated %}
 64 |         <form method="POST">
 65 |             {% csrf_token %}
 66 |             <div class="form-group comment_form">
 67 |                 {{ comment_form|crispy }}
 68 |                 <button class="btn btn-info">Comment <i class="fas fa-comments"></i></button>
 69 |             </div>
 70 |         </form>
 71 |         {% endif %}
 72 |         {% if comments %}
 73 |         <p class="comments">{{ no_of_comments }} Comment{{ no_of_comments|pluralize }}</p>
 74 |         <div class="comment_container p-2">
 75 |             <ul class="media-list" style="list-style-type: none;">
 76 |                 {% for comment in comments %}
 77 |                 <li class="media mb-2" id="{{ comment.pk }}" style="border-bottom: 1px solid gainsboro;">
 78 |                     <img src="{{ comment.author.profile.profile_pic.url }}" alt="" class="rounded-circle mr-2 round_profile_pics">
 79 |                         <div class="media-body">
 80 |                             <a href="{% url 'profile' comment.author %}"><strong class="text-info">{{ comment.author }} </strong></a>
 81 |                             <small class="text-muted date">| {{ comment.date_posted|date:"d F, Y" }}</small>
 82 |                             {% if comment.author == user %}
 83 |                             <span class="edit_delete" style="float: right;">
 84 |                                 <small><a class="mr-2 edit_comment" href="#">Edit</a>
 85 |                                     <a class="mr-2 delete_comment" href="#">Delete</a></small>
 86 |                         </span>
 87 |                         {% endif %}
 88 |                         <div class="mt-1 comment_p">
 89 |                             <p class="comment_text">
 90 |                             {{ comment.content|safe }}
 91 |                         </div>
 92 |                         </p>        
 93 |                     </div>
 94 |                 </li>
 95 |                 {% endfor %}
 96 |             </ul>
 97 |         </div>
 98 |         {% else %}
 99 |         <p class="text-secondary">No comments yet...</p>
100 |         {% endif %}
101 |         
102 |         <!--Image Viewer-->
103 |         <div id="image-viewer">
104 |             <span class="close">&times;</span>
105 |             <img class="modal-content" id="full-image">
106 |           </div>  
107 | </div>
108 | {% endblock content %}


--------------------------------------------------------------------------------
/blogs/models.py:
--------------------------------------------------------------------------------
  1 | import random
  2 | import string
  3 | from django.db import models
  4 | from django.utils import timezone
  5 | from django.contrib.auth.models import User
  6 | from django.urls import reverse
  7 | from django.db.models import Count
  8 | from users.models import Profile
  9 | from django.utils.text import slugify
 10 | from ckeditor.fields import RichTextField
 11 | from ckeditor_uploader.fields import RichTextUploadingField
 12 | 
 13 | 
 14 | class Blog(models.Model):
 15 |     title = models.CharField(max_length=100)
 16 |     #description = RichTextUploadingField(blank=True,null=True)
 17 |     description = RichTextField(blank=True, null=True)
 18 |     #description = models.TextField(max_length=10000)
 19 |     publish_date = models.DateTimeField(default=timezone.now)
 20 |     author = models.ForeignKey(User, on_delete=models.CASCADE)
 21 |     likes = models.BigIntegerField(default=0)
 22 |     image = models.ImageField(upload_to='posts_images', blank=True, null=True)
 23 |     views = models.BigIntegerField(default=0)
 24 |     slug = models.SlugField(max_length=255, unique=True,blank=True)
 25 |         
 26 |     # Generates a slug and saves to the model
 27 |     def save(self, *args, **kwargs):
 28 |         if not self.slug:
 29 |             slug_sample = slugify(self.title)
 30 |             while Blog.objects.filter(slug=slug_sample).exists():
 31 |                 # Generate a random alphanumeric string of length 6
 32 |                 random_string = ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
 33 |                 slug_sample = slugify(self.title + ' ' + random_string)
 34 |             self.slug = slug_sample
 35 |         super(Blog, self).save(*args, **kwargs)
 36 |     
 37 | 
 38 |     def __str__(self):
 39 |         return self.title
 40 | 
 41 |     # This code redirects to 'post/<post_id>/' after successful creation of a Post
 42 |     def get_absolute_url(self):
 43 |         return reverse('view_post', kwargs={'pk': self.pk, 'slug': self.slug})
 44 | 
 45 |     # Function to return the Number of comments for this post
 46 |     def number_of_comments(self):
 47 |         return Blog_comments.objects.filter(blogpost=self).count()
 48 | 
 49 | 
 50 | class Likes_Table(models.Model):
 51 |     '''Table to store which User has Liked/Disliked which Post. Used to highlight Up/Down carets when a particular user is logged in'''
 52 |     user_id = models.ForeignKey(User, on_delete=models.CASCADE)
 53 |     post_id = models.ForeignKey(Blog, on_delete=models.CASCADE)
 54 |     # Denotes the Like status -> 1: User has Liked Post  0: User has Disliked Post
 55 |     like_status_id = models.BooleanField()
 56 | 
 57 | 
 58 | class Blog_comments(models.Model):
 59 |     blogpost = models.ForeignKey(
 60 |         Blog, on_delete=models.CASCADE, related_name='comments')
 61 |     author = models.ForeignKey(User, on_delete=models.CASCADE)
 62 |     date_posted = models.DateTimeField(default=timezone.now)
 63 |     content = models.TextField()
 64 | 
 65 |     def __str__(self):
 66 |         return f'{str(self.author)}, {self.blogpost.title[:30]}'
 67 | 
 68 | 
 69 | # Custom managers to get the Number of comments/follows data from Notification Table.
 70 | # Refer: https://docs.djangoproject.com/en/dev/topics/db/managers/#custom-managers
 71 | # This is used to show notifications like example
 72 | # Comment: Rambabu and 2 others commented on your post
 73 | # Follow: John and 3 others started following you
 74 | class NotificationManager(models.Manager):
 75 |     def get_notification_count(self, user):
 76 |         # Gets the comments data grouped by (post_id, receiver, category) which are not read
 77 |         #notifs_count = (Notification.objects.filter(is_read=False, receiver=user).values('receiver', 'category', 'post_id').annotate(dcount=Count('id')))
 78 |         notifs_count = Notification.objects.filter(
 79 |             is_read=False, receiver=user).order_by('-notification_date')
 80 | 
 81 |         # List to store the required data as dictionary.
 82 |         notif_data = list()
 83 | 
 84 |         for item in notifs_count:
 85 |             n_post_id = item.post_id
 86 |             if n_post_id != -1:
 87 |                 n_slug = Blog.objects.values('slug').filter(id=n_post_id).first()['slug']
 88 |             else:
 89 |                 n_slug = None
 90 |             n_count = item.n_count
 91 |             n_sender = item.sender
 92 |             n_timestamp = item.notification_date
 93 |             n_profile_pic = Profile.objects.filter(
 94 |                 user=n_sender).first().profile_pic.url
 95 | 
 96 |             # Appending the above data as dictionary to notif_data list
 97 |             notif_data.append({'n_post_id': n_post_id, 'n_count': n_count, 'n_sender': n_sender.username,
 98 |                                'n_timestamp': n_timestamp, 'n_profile_pic': n_profile_pic, 'n_slug': n_slug})
 99 | 
100 |         return notif_data
101 | 
102 |     def add_notification(self, sender, receiver, category, post_id):
103 |         existing = Notification.objects.filter(
104 |             receiver=receiver, category=category, is_read=False, post_id=post_id)
105 |         if existing.exists():
106 |             upd_existing = existing.first()
107 |             upd_existing.sender = sender
108 |             upd_existing.notification_date = timezone.now()
109 |             upd_existing.n_count += 1
110 |             upd_existing.save()
111 |         else:
112 |             new_notif = Notification(
113 |                 sender=sender, receiver=receiver, is_read=False, category=category, post_id=post_id)
114 |             new_notif.save()
115 | 
116 |     def remove_notification(self, sender, receiver, category, post_id):
117 |         notif = Notification.objects.filter(
118 |             receiver=receiver, category=category, post_id=post_id, is_read=False).first()
119 |         if notif:
120 |             if notif.n_count == 0:
121 |                 notif.delete()
122 |             else:
123 |                 notif.n_count -= 1
124 |                 notif.save()
125 | 
126 | 
127 | class Notification(models.Model):
128 |     sender = models.ForeignKey(
129 |         User, on_delete=models.CASCADE, related_name='notification_sender')
130 |     receiver = models.ForeignKey(
131 |         User, on_delete=models.CASCADE, related_name='notification_receiver')
132 |     is_read = models.BooleanField()
133 |     category = models.CharField(max_length=10)
134 |     notification_date = models.DateTimeField(default=timezone.now)
135 |     post_id = models.IntegerField(default=-1)
136 |     n_count = models.PositiveIntegerField(default=0)
137 |     objects = NotificationManager()
138 | 
139 |     def __str__(self):
140 |         return f'From: {str(self.sender)} | To: {str(self.receiver)} | Category: {str(self.category)} | Count: {str(self.n_count)}'
141 | 


--------------------------------------------------------------------------------
/blogs/templates/blogs/index.html:
--------------------------------------------------------------------------------
  1 | {% extends "blogs/base.html" %}
  2 | {% load dict_key %}
  3 | {% load static %}
  4 | {% block content %}
  5 | <div class="flex_container">
  6 |     <!--Blog Container-->
  7 |     <div class="blog_container">
  8 |         {% for blog in posts %}
  9 |         <article id="{{ blog.id }}">
 10 |             <div class="post_div">
 11 |                 <div class="votes_container">
 12 |                     {% if user.is_authenticated %}
 13 |                         {% if blog.id in votes %}
 14 |                             {% if votes|dict_key:blog.id is True %}
 15 |                                 <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" style="color: #8bf178;" title="Upvote"></i>
 16 |                                 <span id="votes_count">{{ blog.likes }}</span>
 17 |                                 <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}"
 18 |                                     title="Downvote"></i>
 19 |                             {% else %}
 20 |                                 <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" title="Upvote"></i>
 21 |                                 <span id="votes_count">{{ blog.likes }}</span>
 22 |                                 <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}" style="color: red;"
 23 |                                     title="Downvote"></i>
 24 |                             {% endif %}
 25 |                         {% else %}
 26 |                             <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" title="Upvote"></i>
 27 |                                     <span id="votes_count">{{ blog.likes }}</span>
 28 |                             <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}"
 29 |                                         title="Downvote"></i>
 30 |                         {% endif %}
 31 |                     {% else %}
 32 |                             <!-- Shows Login Required Modal -->
 33 |                             <i class="fas fa-caret-up post_up_down vote_up" id="upvote_{{ blog.id }}" title="Upvote"
 34 |                                 data-toggle="modal" data-target="#exampleModalCenter"></i>
 35 |                             <span id="votes_count">{{ blog.likes }}</span>
 36 |                             <i class="fas fa-caret-down post_up_down vote_down" id="downvote_{{ blog.id }}" title="Downvote"
 37 |                                 data-toggle="modal" data-target="#exampleModalCenter"></i>
 38 |                     {% endif %}
 39 |                 </div>
 40 |                 <!-- Post Header -->
 41 |                 <div class="post_header" style="flex: 2;">
 42 |                     <a class="blog_title_index" href="{% url 'view_post' blog.id blog.slug %}">
 43 |                         <h2 class="post_header_h2" title="View Post">{{ blog.title }}</h2>
 44 |                     </a>
 45 |                     <a href="{% url 'profile' blog.author %}" style="text-decoration: none;"><small
 46 |                             style="margin-right: 5px; font-size: 12px; font-weight: bold;">{{ blog.author }}</small></a>| 
 47 |                     
 48 |                     <small class="date">{{ blog.publish_date|date:"F d, Y" }}</small>
 49 |                 </div>
 50 |                 <!-- End of Post Header -->
 51 |             </div>
 52 |             <a href="{% url 'view_post' blog.id blog.slug %}" style="text-decoration: none; color:black;" title="View Post">
 53 |                 <div class="index_blog_description">
 54 |                         {{ blog.description|safe }}
 55 |                 </div>
 56 |             </a>
 57 |             <hr>
 58 |             <!-- Views part -->
 59 |             {% if blog.views %}
 60 |             <i class="fas fa-eye ml-1 mr-1" aria-hidden="true"></i>
 61 |             <small class="text-secondary mr-3 comments">{{ blog.views }} view{{ blog.views|pluralize }}</small>
 62 |             {% else %}
 63 |             <i class="fas fa-eye ml-1 mr-1"></i><small class="mr-3 text-secondary comments">No Views</small>
 64 |             {% endif %}
 65 |             <!-- Comments part -->
 66 |             {% if blog.number_of_comments %}
 67 |             <i class="fas fa-comment"></i><small class="ml-1 text-secondary comments">{{ blog.number_of_comments }}
 68 |                 Comment{{ blog.number_of_comments|pluralize }}</small>
 69 |             {% else %}
 70 |             <i class="fas fa-comment"></i><small class="ml-1 text-secondary comments">No comments yet</small>
 71 |             {% endif %}
 72 |         </article>
 73 | 
 74 |         {% endfor %}
 75 |         
 76 |         <!--Pagination Code-->
 77 |         <div class="pagination row">
 78 |         {% if is_paginated %}
 79 |             {% if page_obj.has_previous %}
 80 |                 <a href="?page=1" class="btn btn-outline-info mb-4" title="First"><i class="fas fa-fast-backward"></i></a>
 81 |                 <a href="?page={{ page_obj.previous_page_number }}" class="btn btn-outline-success mb-4" title="Previous"><i class="fas fa-chevron-left"></i></a>
 82 |             {% endif %}
 83 |             {% for num in page_obj.paginator.page_range %}
 84 |                 {% if page_obj.number == num %}
 85 |                     <a class="btn btn-outline-success mb-4 active" href="?page={{ num }}">{{ num }}</a>
 86 |                 {% elif num > page_obj.number|add:'-3' and num < page_obj.number|add:'3' %}
 87 |                     <a class="btn btn-outline-success mb-4" href="?page={{ num }}">{{ num }}</a>
 88 |                 {% endif %}
 89 |             {% endfor %}
 90 |             {% if page_obj.has_next %}
 91 |                 <a href="?page={{ page_obj.next_page_number }}" class="btn btn-outline-success mb-4" title="Next"><i class="fas fa-chevron-right"></i></a>
 92 |                 <a href="?page={{ page_obj.paginator.num_pages }}" class="btn btn-outline-info mb-4" title="Last"><i class="fas fa-fast-forward"></i></a>
 93 |             {% endif %}
 94 |         {% endif %}
 95 |         </div>
 96 |     </div>
 97 |     <!--Side container-->
 98 |     <div class="side_container list-group">
 99 |         <ul>
100 |             <p>Popular Blogs</p>
101 |             
102 |                 {% for blog in blogs_list_top5 %}
103 |                 <li>
104 |                     <a href="{% url 'view_post' blog.pk blog.slug %}">{{ blog.title }}</a>
105 |                 </li>
106 |                 {% endfor %}
107 |             </ul>
108 |         
109 |         <ul>
110 |             <p>Top Bloggers</p>
111 |             
112 |                 {% for item in top_authors %}
113 |                 <li><a href="{% url 'profile' item %}">{{ item }}</a></li>
114 |                 {% endfor %}
115 |             </ul>
116 |             
117 |             <ul>
118 |                 <p>Most Viewed Posts</p>
119 |                 
120 |                     {% for item in blogs_list_top_viewed %}
121 |                     <li><a href="{% url 'view_post' item.pk item.slug%}">{{ item }}</a></li>
122 |                     {% endfor %}
123 |                 </ul>
124 |     </div>
125 |     
126 | </div>
127 | {% endblock content %}


--------------------------------------------------------------------------------
/users/views.py:
--------------------------------------------------------------------------------
  1 | from django.shortcuts import render, redirect, get_object_or_404
  2 | from django.urls import reverse
  3 | from django.contrib.auth.forms import UserCreationForm
  4 | from django.views.generic import UpdateView
  5 | from .models import Profile, Followers
  6 | from django.contrib.auth.decorators import login_required
  7 | from django.contrib import messages
  8 | from blogs.models import Blog, Notification
  9 | from django.views.decorators.csrf import csrf_exempt
 10 | from django.http import HttpResponse, JsonResponse
 11 | from .forms import UserRegisterForm, UserUpdateForm, ProfileUpdateForm
 12 | from django.contrib.auth.models import User
 13 | 
 14 | 
 15 | def register(request):
 16 |     form = UserRegisterForm()
 17 |     title = 'Register'
 18 | 
 19 |     if request.method == 'POST':
 20 |         form = UserRegisterForm(request.POST)
 21 |         if form.is_valid():
 22 |             # This statement will save the form contents to the Users table in the DB
 23 |             form.save()
 24 |             #username = form.cleaned_data.get('username')
 25 |             messages.success(
 26 |                 request, f'Account is created successfully. You can now login')
 27 |             return redirect('login')
 28 |     else:
 29 |         form = UserRegisterForm()
 30 |     return render(request, 'users/register.html', {'form': form, 'title': title})
 31 | 
 32 | 
 33 | 
 34 | @login_required
 35 | def profile(request, username):
 36 |     '''Allows users to view other users profile'''
 37 |     user = get_object_or_404(User, username=username)
 38 |     #user = User.objects.filter(username=username).first()
 39 |     curr_profile = Profile.objects.filter(user=user).first()
 40 |     #profile = Profile.objects.filter(user=request.user).first()
 41 |     f = Followers.objects.filter(followers=curr_profile)
 42 |     followers = set()
 43 |     # print(f'\n{f}\n')
 44 |     for i in f:
 45 |         followers.add(i.user.user.username)
 46 |     print(f'\nUsers Following {user}: {followers}\n')
 47 |     user_blogs = user.blog_set.all()
 48 |     title = username
 49 |     no_of_following = Followers.objects.filter(user=curr_profile).count()
 50 |     no_of_followers = Followers.objects.filter(followers=curr_profile).count()
 51 |     context = {
 52 |         'curr_user': user,
 53 |         'user_blogs': user_blogs,
 54 |         'title': title,
 55 |         'followers': followers,
 56 |         'no_of_followers': no_of_followers,
 57 |         'no_of_following': no_of_following,
 58 |     }
 59 |     # print(user.blog_set.all())
 60 |     return render(request, 'users/view_profile.html', context)
 61 | 
 62 | 
 63 | 
 64 | @login_required
 65 | def update_profile(request):
 66 |     if request.method == 'POST':
 67 |         # The instance argument will fill the form with existing user data
 68 |         u_form = UserUpdateForm(request.POST, instance=request.user)
 69 |         # request.FILES since we are expecting an Image update
 70 |         p_form = ProfileUpdateForm(
 71 |             request.POST, request.FILES, instance=request.user.profile)
 72 |         curr_username = request.user.username
 73 |         # Checking and saving if the forms are valid
 74 |         if u_form.is_valid() and p_form.is_valid():
 75 |             u_form.save()
 76 |             p_form.save()
 77 |             messages.success(request, f'Your profile is updated successfully.')
 78 |             
 79 |             # Redirect to Profile page after successful updation
 80 |             return redirect('profile', username=curr_username)
 81 |     else:
 82 |         u_form = UserUpdateForm(instance=request.user)
 83 |         p_form = ProfileUpdateForm(instance=request.user.profile)
 84 |     context = {
 85 |         'u_form': u_form,
 86 |         'p_form': p_form,
 87 |     }
 88 |     return render(request, 'users/update_profile.html', context)
 89 | 
 90 | 
 91 | 
 92 | @csrf_exempt
 93 | @login_required
 94 | def view_followers(request, username):
 95 |     temp = User.objects.filter(username=username).first()
 96 |     user = Profile.objects.filter(user=temp).first()
 97 |     #print(f'\nUsername in view_profile: {user} {user.id}\n')
 98 |     f = Followers.objects.filter(followers=user)
 99 |     g = Followers.objects.filter(user=user)
100 |     #print(f'\nfollowers in view_followers: {user} -> {f}\n')
101 |     #print(f'\nFollowing: {g}\n')
102 |     curr_profile = Profile.objects.filter(
103 |         user=get_object_or_404(User, username=username)).first()
104 |     no_of_following = Followers.objects.filter(user=curr_profile).count()
105 |     no_of_followers = Followers.objects.filter(followers=curr_profile).count()
106 |     context = {
107 |         'followers': f,
108 |         'following': g,
109 |         'curr_user': username,
110 |         'no_of_followers': no_of_followers,
111 |         'no_of_following': no_of_following,
112 |     }
113 |     return render(request, 'users/followers.html', context)
114 | 
115 | 
116 | @csrf_exempt
117 | @login_required
118 | def follow(request):
119 |     '''Code to follow a User. Creates a record in Followers table.'''
120 |     if request.method == 'POST':
121 |         profile = Profile.objects.filter(
122 |             user=User.objects.filter(username=request.user).first()).first()
123 |         follower = Profile.objects.filter(user=User.objects.filter(
124 |             username=request.POST['username']).first()).first()
125 |         f = Followers(user=profile, followers=follower)
126 |         f.save()
127 |         # Inserting the record into the Notification table
128 |         receiver = User.objects.filter(username=request.POST['username']).first()
129 |         Notification.objects.add_notification(request.user, receiver, 'follow', -1)
130 |         #n = Notification(sender=request.user, receiver=User.objects.filter(username=request.POST['username']).first(), is_read=False, category='follow')
131 |         #n.save()
132 |         #print(f'\nCreated:\nUser: {req_user.username}\nFollowing: {follower}\n')
133 |         return JsonResponse({'status': 'success'})
134 |     else:
135 |         return HttpResponse('Request method is not POST.')
136 | 
137 | 
138 | @csrf_exempt
139 | @login_required
140 | def unfollow(request):
141 |     '''Code to unfollow a User. Deletes a record in Followers table.'''
142 |     if request.method == 'POST':
143 |         profile = Profile.objects.filter(
144 |             user=User.objects.filter(username=request.user).first()).first()
145 |         follower = Profile.objects.filter(user=User.objects.filter(
146 |             username=request.POST['username']).first()).first()
147 |         Followers.objects.filter(user=profile, followers=follower).delete()
148 |         #print(f'\nDeleted:\nUser: {req_user.username}\nFollower: {follower}\n')
149 |         # Deleting the record from Notification table when a exising follower unfollows
150 |         receiver=User.objects.filter(username=request.POST['username']).first()
151 |         Notification.objects.remove_notification(request.user, receiver, 'follow', -1)
152 |         '''
153 |         Notification.objects.filter(sender=request.user, receiver=User.objects.filter(
154 |             username=request.POST['username']).first(), category='follow').delete()
155 |         '''
156 |         return JsonResponse({'status': 'success'})
157 |     else:
158 |         return HttpResponse('Request method is not POST.')
159 | 


--------------------------------------------------------------------------------
/Blog_application/settings/base.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Django settings for Blog_application project.
  3 | 
  4 | Generated by 'django-admin startproject' using Django 3.0.8.
  5 | 
  6 | For more information on this file, see
  7 | https://docs.djangoproject.com/en/3.0/topics/settings/
  8 | 
  9 | For the full list of settings and their values, see
 10 | https://docs.djangoproject.com/en/3.0/ref/settings/
 11 | """
 12 | 
 13 | import os
 14 | import django_heroku
 15 | 
 16 | 
 17 | # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 18 | BASE_DIR = os.path.dirname(os.path.dirname(
 19 |     os.path.dirname(os.path.abspath(__file__))))
 20 | 
 21 | 
 22 | # Quick-start development settings - unsuitable for production
 23 | # See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
 24 | 
 25 | # Application definition
 26 | INSTALLED_APPS = [
 27 |     'blogs.apps.BlogsConfig',
 28 |     'users.apps.UsersConfig',
 29 |     'blogs_api.apps.BlogsApiConfig',
 30 |     'crispy_forms',
 31 |     'django.contrib.admin',
 32 |     'django.contrib.auth',
 33 |     'django.contrib.contenttypes',
 34 |     'django.contrib.sessions',
 35 |     'django.contrib.messages',
 36 |     'django.contrib.staticfiles',
 37 |     'django_cleanup',
 38 |     'django.contrib.humanize',
 39 |     'storages',
 40 |     'rest_framework',
 41 |     'rest_framework.authtoken',  # To use Token Authentication in Rest framework
 42 |     'ckeditor',
 43 |     'ckeditor_uploader',
 44 | ]
 45 | 
 46 | # Makes the API to show only JSON Data
 47 | REST_FRAMEWORK = {
 48 |     'DEFAULT_RENDERER_CLASSES': (
 49 |         'rest_framework.renderers.JSONRenderer',
 50 |     ),
 51 |     'DEFAULT_PARSER_CLASSES': (
 52 |         'rest_framework.parsers.JSONParser',
 53 |     )
 54 | }
 55 | 
 56 | 
 57 | CKEDITOR_CONFIGS = {
 58 |     'default': {
 59 |         'toolbar': 'Custom',
 60 |         'width': 'auto',
 61 |         'embed_provider': '//ckeditor.iframe.ly/api/oembed?url={url}&callback={callback}',
 62 |         'toolbar_Custom': [
 63 |             ["Format", "Bold", "Italic", "Underline", "Strike", "SpellChecker"],
 64 |             ['NumberedList', 'BulletedList', "Indent", "Outdent", 'JustifyLeft', 'JustifyCenter',
 65 |              'JustifyRight', 'JustifyBlock'],
 66 |             ["Image", "Table", "Link", "Unlink", "Anchor",
 67 |                 "SectionLink", "Embed"], ['Undo', 'Redo'], ["CodeSnippet"],
 68 |             ["Maximize"]
 69 |         ],
 70 | 
 71 |         # Remove these dialog tabs (semicolon separated dialog:tab)
 72 |         'removeDialogTabs': ';'.join([
 73 |             'image:advanced',
 74 |             'image:Link',
 75 |             'link:upload',
 76 |             'table:advanced',
 77 |             # 'tableProperties:advanced',
 78 |         ]),
 79 | 
 80 |         # Extra plugins to be used in the editor
 81 |         'extraPlugins': ','.join([
 82 |             'mathjax',  # Used to render mathematical formulae
 83 |             'codesnippet',  # Used to add code snippets
 84 |             'image2',  # Loads new and better image dialog
 85 |             'embed',  # Used for embedding media (YouTube/Slideshare etc)
 86 |             'tableresize',  # Used to allow resizing of columns in tables
 87 |         ]),
 88 |     }
 89 | 
 90 | }
 91 | 
 92 | MIDDLEWARE = [
 93 |     'django.middleware.security.SecurityMiddleware',
 94 |     'django.contrib.sessions.middleware.SessionMiddleware',
 95 |     'django.middleware.common.CommonMiddleware',
 96 |     'django.middleware.csrf.CsrfViewMiddleware',
 97 |     'django.contrib.auth.middleware.AuthenticationMiddleware',
 98 |     'django.contrib.messages.middleware.MessageMiddleware',
 99 |     'django.middleware.clickjacking.XFrameOptionsMiddleware',
100 | ]
101 | 
102 | ROOT_URLCONF = 'Blog_application.urls'
103 | 
104 | TEMPLATES = [
105 |     {
106 |         'BACKEND': 'django.template.backends.django.DjangoTemplates',
107 |         'DIRS': [],
108 |         'APP_DIRS': True,
109 |         'OPTIONS': {
110 |             'context_processors': [
111 |                 'django.template.context_processors.debug',
112 |                 'django.template.context_processors.request',
113 |                 'django.contrib.auth.context_processors.auth',
114 |                 'django.contrib.messages.context_processors.messages',
115 |                 'blogs.context_processors.notifications_exist',
116 |             ],
117 |             'libraries':  {
118 |                 'dict_key': 'blogs.templatetags.dict_key',
119 |             }
120 |         },
121 |     },
122 | ]
123 | 
124 | WSGI_APPLICATION = 'Blog_application.wsgi.application'
125 | 
126 | 
127 | # Database
128 | # https://docs.djangoproject.com/en/3.0/ref/settings/#databases
129 | 
130 | DATABASES = {
131 |     'default': {
132 |         'ENGINE': 'django.db.backends.sqlite3',
133 |         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
134 |     }
135 | }
136 | 
137 | 
138 | # Password validation
139 | # https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
140 | 
141 | AUTH_PASSWORD_VALIDATORS = [
142 |     {
143 |         'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
144 |     },
145 |     {
146 |         'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
147 |     },
148 |     {
149 |         'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
150 |     },
151 |     {
152 |         'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
153 |     },
154 | ]
155 | 
156 | 
157 | # Internationalization
158 | # https://docs.djangoproject.com/en/3.0/topics/i18n/
159 | 
160 | LANGUAGE_CODE = 'en-us'
161 | 
162 | TIME_ZONE = 'Asia/Kolkata'
163 | 
164 | USE_I18N = True
165 | 
166 | USE_L10N = True
167 | 
168 | USE_TZ = True
169 | 
170 | 
171 | # Static files (CSS, JavaScript, Images)
172 | # https://docs.djangoproject.com/en/1.9/howto/static-files/
173 | STATIC_ROOT = os.path.join(BASE_DIR, 'static')
174 | STATIC_URL = '/static/'
175 | 
176 | # Extra places for collectstatic to find static files.
177 | '''
178 | STATICFILES_DIRS = (
179 |     os.path.join(BASE_DIR, 'static'),
180 | )
181 | '''
182 | 
183 | # Tells cripsy forms to use bootstrap 4
184 | CRISPY_TEMPLATE_PACK = 'bootstrap4'
185 | 
186 | # Tells which page to show when user successfully logs in
187 | LOGIN_REDIRECT_URL = 'index'
188 | LOGIN_URL = 'login'
189 | 
190 | MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
191 | MEDIA_URL = '/media/'
192 | 
193 | CKEDITOR_UPLOAD_PATH = 'uploads/'
194 | 
195 | 
196 | EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
197 | EMAIL_HOST = 'smtp.gmail.com'
198 | EMAIL_PORT = 587
199 | EMAIL_USE_TLS = True
200 | 
201 | EMAIL_HOST_USER = os.environ.get('EMAIL_USER')
202 | EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_PASS')
203 | 
204 | 
205 | # AWS Credentials
206 | AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY_ID')
207 | AWS_SECRET_ACCESS_KEY = os.environ.get('AWS_SECRET_ACCESS_KEY')
208 | AWS_STORAGE_BUCKET_NAME = os.environ.get('AWS_STORAGE_BUCKET_NAME')
209 | 
210 | # If a user uploads an image with a name already existing (that some other user has already uploaded), the image
211 | # will not be overriden [if set to False]
212 | AWS_S3_FILE_OVERWRITE = False
213 | AWS_DEFAULT_ACL = None
214 | 
215 | AWS_S3_REGION_NAME = 'ap-south-1'
216 | AWS_S3_ADDRESSING_STYLE = "virtual"
217 | 
218 | DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
219 | 
220 | 
221 | # django_heroku.settings(locals())
222 | 


--------------------------------------------------------------------------------
/Blog_application/settings/development.py:
--------------------------------------------------------------------------------
  1 | from .base import *
  2 | 
  3 | # SECURITY WARNING: keep the secret key used in production secret!
  4 | SECRET_KEY = os.environ.get('SECRET_KEY_BLOG')
  5 | 
  6 | # SECURITY WARNING: don't run with debug turned on in production!
  7 | DEBUG = (os.environ.get('DEBUG_VALUE') == "True")
  8 | 
  9 | # To check the site on Mobile and localhost
 10 | ALLOWED_HOSTS = ['192.168.29.49', 'localhost']
 11 | 
 12 | #########################################################
 13 | """
 14 | Django settings for Blog_application project.
 15 | 
 16 | Generated by 'django-admin startproject' using Django 3.0.8.
 17 | 
 18 | For more information on this file, see
 19 | https://docs.djangoproject.com/en/3.0/topics/settings/
 20 | 
 21 | For the full list of settings and their values, see
 22 | https://docs.djangoproject.com/en/3.0/ref/settings/
 23 | 
 24 | 
 25 | import os
 26 | import django_heroku
 27 | 
 28 | 
 29 | # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 30 | BASE_DIR = os.path.dirname(os.path.dirname(
 31 |     os.path.dirname(os.path.abspath(__file__))))
 32 | 
 33 | 
 34 | # Quick-start development settings - unsuitable for production
 35 | # See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
 36 | 
 37 | # SECURITY WARNING: keep the secret key used in production secret!
 38 | SECRET_KEY = os.environ.get('SECRET_KEY_BLOG')
 39 | 
 40 | # SECURITY WARNING: don't run with debug turned on in production!
 41 | DEBUG = (os.environ.get('DEBUG_VALUE') == "True")
 42 | 
 43 | 
 44 | # To check the site on Mobile and localhost
 45 | ALLOWED_HOSTS = ['192.168.29.49', 'localhost']
 46 | #ALLOWED_HOSTS = []
 47 | 
 48 | 
 49 | # Application definition
 50 | 
 51 | INSTALLED_APPS = [
 52 |     'blogs.apps.BlogsConfig',
 53 |     'users.apps.UsersConfig',
 54 |     'blogs_api.apps.BlogsApiConfig',
 55 |     'crispy_forms',
 56 |     'django.contrib.admin',
 57 |     'django.contrib.auth',
 58 |     'django.contrib.contenttypes',
 59 |     'django.contrib.sessions',
 60 |     'django.contrib.messages',
 61 |     'django.contrib.staticfiles',
 62 |     'django_cleanup',
 63 |     'django.contrib.humanize',
 64 |     'storages',
 65 |     'rest_framework',
 66 |     'rest_framework.authtoken',     #To use Token Authentication in Rest framework
 67 |     'ckeditor',
 68 |     'ckeditor_uploader',
 69 | ]
 70 | 
 71 | # Makes the API to show only JSON Data
 72 | REST_FRAMEWORK = {
 73 |     'DEFAULT_RENDERER_CLASSES': (
 74 |         'rest_framework.renderers.JSONRenderer',
 75 |     ),
 76 |     'DEFAULT_PARSER_CLASSES': (
 77 |         'rest_framework.parsers.JSONParser',
 78 |     )
 79 | }
 80 | 
 81 | 
 82 | CKEDITOR_CONFIGS = {
 83 |     'default': {
 84 |         'toolbar': 'Custom',
 85 |         'width': 'auto',
 86 |         'embed_provider': '//ckeditor.iframe.ly/api/oembed?url={url}&callback={callback}',
 87 |         'toolbar_Custom': [
 88 |             ["Format", "Bold", "Italic", "Underline", "Strike", "SpellChecker"],
 89 |             ['NumberedList', 'BulletedList', "Indent", "Outdent", 'JustifyLeft', 'JustifyCenter',
 90 |              'JustifyRight', 'JustifyBlock'],
 91 |             ["Image", "Table", "Link", "Unlink", "Anchor",
 92 |                 "SectionLink", "Embed"], ['Undo', 'Redo'], ["CodeSnippet"],
 93 |             ["Maximize"]
 94 |         ],
 95 | 
 96 |         # Remove these dialog tabs (semicolon separated dialog:tab)
 97 |         'removeDialogTabs': ';'.join([
 98 |             'image:advanced',
 99 |             'image:Link',
100 |             'link:upload',
101 |             'table:advanced',
102 |             #'tableProperties:advanced',
103 |             ]),
104 |         
105 |         # Extra plugins to be used in the editor
106 |         'extraPlugins': ','.join([
107 |             'mathjax',  # Used to render mathematical formulae
108 |             'codesnippet',  # Used to add code snippets
109 |             'image2',  # Loads new and better image dialog
110 |             'embed',  # Used for embedding media (YouTube/Slideshare etc)
111 |             'tableresize',  # Used to allow resizing of columns in tables
112 |         ]),
113 |     }
114 | 
115 | }
116 | 
117 | MIDDLEWARE = [
118 |     'django.middleware.security.SecurityMiddleware',
119 |     'django.contrib.sessions.middleware.SessionMiddleware',
120 |     'django.middleware.common.CommonMiddleware',
121 |     'django.middleware.csrf.CsrfViewMiddleware',
122 |     'django.contrib.auth.middleware.AuthenticationMiddleware',
123 |     'django.contrib.messages.middleware.MessageMiddleware',
124 |     'django.middleware.clickjacking.XFrameOptionsMiddleware',
125 | ]
126 | 
127 | ROOT_URLCONF = 'Blog_application.urls'
128 | 
129 | TEMPLATES = [
130 |     {
131 |         'BACKEND': 'django.template.backends.django.DjangoTemplates',
132 |         'DIRS': [],
133 |         'APP_DIRS': True,
134 |         'OPTIONS': {
135 |             'context_processors': [
136 |                 'django.template.context_processors.debug',
137 |                 'django.template.context_processors.request',
138 |                 'django.contrib.auth.context_processors.auth',
139 |                 'django.contrib.messages.context_processors.messages',
140 |                 'blogs.context_processors.notifications_exist',
141 |             ],
142 |             'libraries':  {
143 |                 'dict_key': 'blogs.templatetags.dict_key',
144 |             }
145 |         },
146 |     },
147 | ]
148 | 
149 | WSGI_APPLICATION = 'Blog_application.wsgi.application'
150 | 
151 | 
152 | # Database
153 | # https://docs.djangoproject.com/en/3.0/ref/settings/#databases
154 | 
155 | DATABASES = {
156 |     'default': {
157 |         'ENGINE': 'django.db.backends.sqlite3',
158 |         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
159 |     }
160 | }
161 | 
162 | 
163 | # Password validation
164 | # https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
165 | 
166 | AUTH_PASSWORD_VALIDATORS = [
167 |     {
168 |         'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
169 |     },
170 |     {
171 |         'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
172 |     },
173 |     {
174 |         'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
175 |     },
176 |     {
177 |         'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
178 |     },
179 | ]
180 | 
181 | 
182 | # Internationalization
183 | # https://docs.djangoproject.com/en/3.0/topics/i18n/
184 | 
185 | LANGUAGE_CODE = 'en-us'
186 | 
187 | TIME_ZONE = 'Asia/Kolkata'
188 | 
189 | USE_I18N = True
190 | 
191 | USE_L10N = True
192 | 
193 | USE_TZ = True
194 | 
195 | 
196 | # Static files (CSS, JavaScript, Images)
197 | # https://docs.djangoproject.com/en/1.9/howto/static-files/
198 | STATIC_ROOT = os.path.join(BASE_DIR, 'static')
199 | STATIC_URL = '/static/'
200 | 
201 | # Extra places for collectstatic to find static files.
202 | '''
203 | STATICFILES_DIRS = (
204 |     os.path.join(BASE_DIR, 'static'),
205 | )
206 | '''
207 | 
208 | # Tells cripsy forms to use bootstrap 4
209 | CRISPY_TEMPLATE_PACK = 'bootstrap4'
210 | 
211 | # Tells which page to show when user successfully logs in
212 | LOGIN_REDIRECT_URL = 'index'
213 | LOGIN_URL = 'login'
214 | 
215 | MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
216 | MEDIA_URL = '/media/'
217 | 
218 | CKEDITOR_UPLOAD_PATH = 'uploads/'
219 | 
220 | 
221 | EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
222 | EMAIL_HOST = 'smtp.gmail.com'
223 | EMAIL_PORT = 587
224 | EMAIL_USE_TLS = True
225 | 
226 | EMAIL_HOST_USER = os.environ.get('EMAIL_USER')
227 | EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_PASS')
228 | 
229 | 
230 | # AWS Credentials
231 | AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY_ID')
232 | AWS_SECRET_ACCESS_KEY = os.environ.get('AWS_SECRET_ACCESS_KEY')
233 | AWS_STORAGE_BUCKET_NAME = os.environ.get('AWS_STORAGE_BUCKET_NAME')
234 | 
235 | # If a user uploads an image with a name already existing (that some other user has already uploaded), the image
236 | # will not be overriden [if set to False]
237 | AWS_S3_FILE_OVERWRITE = False
238 | AWS_DEFAULT_ACL = None
239 | 
240 | AWS_S3_REGION_NAME = 'ap-south-1'
241 | AWS_S3_ADDRESSING_STYLE = "virtual"
242 | 
243 | DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
244 | 
245 | 
246 | #django_heroku.settings(locals())
247 | """


--------------------------------------------------------------------------------
/Blog_application/settings/production.py:
--------------------------------------------------------------------------------
  1 | from .base import *
  2 | 
  3 | # SECURITY WARNING: keep the secret key used in production secret!
  4 | SECRET_KEY = os.environ.get('SECRET_KEY')
  5 | 
  6 | # SECURITY WARNING: don't run with debug turned on in production!
  7 | DEBUG = (os.environ.get('DEBUG_VALUE') == "True")
  8 | 
  9 | # To check the site on Mobile and localhost
 10 | ALLOWED_HOSTS = ['blog-app-pydj.herokuapp.com']
 11 | 
 12 | 
 13 | ################################################################################
 14 | """
 15 | Django settings for Blog_application project.
 16 | 
 17 | Generated by 'django-admin startproject' using Django 3.0.8.
 18 | 
 19 | For more information on this file, see
 20 | https://docs.djangoproject.com/en/3.0/topics/settings/
 21 | 
 22 | For the full list of settings and their values, see
 23 | https://docs.djangoproject.com/en/3.0/ref/settings/
 24 | 
 25 | 
 26 | import os
 27 | import django_heroku
 28 | 
 29 | # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 30 | BASE_DIR = os.path.dirname(os.path.dirname(
 31 |     os.path.dirname(os.path.abspath(__file__))))
 32 | 
 33 | 
 34 | # Quick-start development settings - unsuitable for production
 35 | # See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
 36 | 
 37 | # SECURITY WARNING: keep the secret key used in production secret!
 38 | SECRET_KEY = os.environ.get('SECRET_KEY')
 39 | 
 40 | # SECURITY WARNING: don't run with debug turned on in production!
 41 | DEBUG = (os.environ.get('DEBUG_VALUE') == "True")
 42 | 
 43 | # To check the site on Mobile and localhost
 44 | ALLOWED_HOSTS = ['blog-app-pydj.herokuapp.com']
 45 | 
 46 | 
 47 | # Application definition
 48 | 
 49 | INSTALLED_APPS = [
 50 |     'blogs.apps.BlogsConfig',
 51 |     'users.apps.UsersConfig',
 52 |     'blogs_api.apps.BlogsApiConfig',
 53 |     'crispy_forms',
 54 |     'django.contrib.admin',
 55 |     'django.contrib.auth',
 56 |     'django.contrib.contenttypes',
 57 |     'django.contrib.sessions',
 58 |     'django.contrib.messages',
 59 |     'django.contrib.staticfiles',
 60 |     'django_cleanup',
 61 |     'django.contrib.humanize',
 62 |     'storages',
 63 |     'ckeditor',
 64 |     'rest_framework',
 65 |     'rest_framework.authtoken',
 66 |     'ckeditor_uploader',
 67 | ]
 68 | 
 69 | 
 70 | # Makes the API to show only JSON Data
 71 | REST_FRAMEWORK = {
 72 |     'DEFAULT_RENDERER_CLASSES': (
 73 |         'rest_framework.renderers.JSONRenderer',
 74 |     ),
 75 |     'DEFAULT_PARSER_CLASSES': (
 76 |         'rest_framework.parsers.JSONParser',
 77 |     )
 78 | }
 79 | 
 80 | CKEDITOR_CONFIGS = {
 81 |     'default': {
 82 |         'toolbar': 'Custom',
 83 |         'width': 'auto',
 84 |         'embed_provider': '//ckeditor.iframe.ly/api/oembed?url={url}&callback={callback}',
 85 |         'toolbar_Custom': [
 86 |             ["Format", "Bold", "Italic", "Underline", "Strike", "SpellChecker"],
 87 |             ['NumberedList', 'BulletedList', "Indent", "Outdent", 'JustifyLeft', 'JustifyCenter',
 88 |              'JustifyRight', 'JustifyBlock'],
 89 |             ["Image", "Table", "Link", "Unlink", "Anchor",
 90 |                 "SectionLink", "Embed"], ['Undo', 'Redo'], ["CodeSnippet"],
 91 |             ["Maximize"]
 92 |         ],
 93 | 
 94 |         # Remove these dialog tabs (semicolon separated dialog:tab)
 95 |         'removeDialogTabs': ';'.join([
 96 |             'image:advanced',
 97 |             'image:Link',
 98 |             'link:upload',
 99 |             'table:advanced',
100 |             #'tableProperties:advanced',
101 |             ]),
102 |         
103 |         # Extra plugins to be used in the editor
104 |         'extraPlugins': ','.join([
105 |             'mathjax',  # Used to render mathematical formulae
106 |             'codesnippet',  # Used to add code snippets
107 |             'image2',  # Loads new and better image dialog
108 |             'embed',  # Used for embedding media (YouTube/Slideshare etc)
109 |             'tableresize',  # Used to allow resizing of columns in tables
110 |         ]),
111 |     }
112 | 
113 | }
114 | 
115 | MIDDLEWARE = [
116 |     'django.middleware.security.SecurityMiddleware',
117 |     'django.contrib.sessions.middleware.SessionMiddleware',
118 |     'django.middleware.common.CommonMiddleware',
119 |     'django.middleware.csrf.CsrfViewMiddleware',
120 |     'django.contrib.auth.middleware.AuthenticationMiddleware',
121 |     'django.contrib.messages.middleware.MessageMiddleware',
122 |     'django.middleware.clickjacking.XFrameOptionsMiddleware',
123 | ]
124 | 
125 | ROOT_URLCONF = 'Blog_application.urls'
126 | 
127 | TEMPLATES = [
128 |     {
129 |         'BACKEND': 'django.template.backends.django.DjangoTemplates',
130 |         'DIRS': [],
131 |         'APP_DIRS': True,
132 |         'OPTIONS': {
133 |             'context_processors': [
134 |                 'django.template.context_processors.debug',
135 |                 'django.template.context_processors.request',
136 |                 'django.contrib.auth.context_processors.auth',
137 |                 'django.contrib.messages.context_processors.messages',
138 |                 'blogs.context_processors.notifications_exist',
139 |             ],
140 |             'libraries':  {
141 |                 'dict_key': 'blogs.templatetags.dict_key',
142 |             }
143 |         },
144 |     },
145 | ]
146 | 
147 | WSGI_APPLICATION = 'Blog_application.wsgi.application'
148 | 
149 | 
150 | # Database
151 | # https://docs.djangoproject.com/en/3.0/ref/settings/#databases
152 | 
153 | DATABASES = {
154 |     'default': {
155 |         'ENGINE': 'django.db.backends.sqlite3',
156 |         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
157 |     }
158 | }
159 | 
160 | 
161 | # Password validation
162 | # https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
163 | 
164 | AUTH_PASSWORD_VALIDATORS = [
165 |     {
166 |         'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
167 |     },
168 |     {
169 |         'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
170 |     },
171 |     {
172 |         'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
173 |     },
174 |     {
175 |         'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
176 |     },
177 | ]
178 | 
179 | 
180 | # Internationalization
181 | # https://docs.djangoproject.com/en/3.0/topics/i18n/
182 | 
183 | LANGUAGE_CODE = 'en-us'
184 | 
185 | TIME_ZONE = 'Asia/Kolkata'
186 | 
187 | USE_I18N = True
188 | 
189 | USE_L10N = True
190 | 
191 | USE_TZ = True
192 | 
193 | 
194 | # Static files (CSS, JavaScript, Images)
195 | # https://docs.djangoproject.com/en/3.0/howto/static-files/
196 | STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
197 | STATIC_URL = '/static/'
198 | 
199 | 
200 | # Extra places for collectstatic to find static files.
201 | '''
202 | STATICFILES_DIRS = (
203 |     os.path.join(BASE_DIR, 'static'),
204 | )
205 | '''
206 | 
207 | # Tells cripsy forms to use bootstrap 4
208 | CRISPY_TEMPLATE_PACK = 'bootstrap4'
209 | 
210 | # Tells which page to show when user successfully logs in
211 | LOGIN_REDIRECT_URL = 'index'
212 | LOGIN_URL = 'login'
213 | 
214 | # This is the Directory where the Uploaded images are kept on the File System
215 | MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
216 | MEDIA_URL = '/media/'
217 | 
218 | CKEDITOR_UPLOAD_PATH = 'uploads/'
219 | 
220 | EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
221 | EMAIL_HOST = 'smtp.gmail.com'
222 | EMAIL_PORT = 587
223 | EMAIL_USE_TLS = True
224 | 
225 | EMAIL_HOST_USER = os.environ.get('EMAIL_USER')
226 | EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_PASS')
227 | 
228 | # AWS Credentials
229 | # AWS Credentials
230 | AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY_ID')
231 | AWS_SECRET_ACCESS_KEY = os.environ.get('AWS_SECRET_ACCESS_KEY')
232 | AWS_STORAGE_BUCKET_NAME = os.environ.get('AWS_STORAGE_BUCKET_NAME')
233 | 
234 | # If a user uploads an image with a name already existing (that some other user has already uploaded), the image
235 | # will not be overriden [if set to False]
236 | AWS_S3_FILE_OVERWRITE = False
237 | AWS_DEFAULT_ACL = None
238 | 
239 | AWS_S3_REGION_NAME = 'ap-south-1'
240 | AWS_S3_ADDRESSING_STYLE = "virtual"
241 | 
242 | DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
243 | 
244 | 
245 | django_heroku.settings(locals())
246 | """
247 | 


--------------------------------------------------------------------------------
/blogs_api/views.py:
--------------------------------------------------------------------------------
  1 | from http.client import SERVICE_UNAVAILABLE
  2 | from django.db.models import query
  3 | from django.shortcuts import render
  4 | from django.contrib.auth.models import User
  5 | from django.http import HttpResponse
  6 | from rest_framework.fields import SerializerMethodField
  7 | from blogs.models import Blog, Blog_comments
  8 | from .serializers import UserSerializer, BlogSerializer, ViewPostSerializer
  9 | from rest_framework import serializers, viewsets, generics, mixins
 10 | from rest_framework.exceptions import NotFound
 11 | from rest_framework.response import Response
 12 | from rest_framework import status
 13 | from rest_framework.decorators import api_view, authentication_classes, permission_classes
 14 | from rest_framework.views import APIView
 15 | from rest_framework.authentication import BasicAuthentication, SessionAuthentication, TokenAuthentication
 16 | from rest_framework.permissions import IsAuthenticated
 17 | 
 18 | 
 19 | class UserViewSet(viewsets.ModelViewSet):
 20 |     '''
 21 |     API endpoint to view the users data by username
 22 |     '''
 23 |     serializer_class = UserSerializer
 24 | 
 25 |     def get_queryset(self):
 26 |         queryset = User.objects.all()
 27 |         username = self.request.query_params.get('username')
 28 |         if username is not None:
 29 |             queryset = queryset.filter(username=username)
 30 |             return queryset
 31 |         else:
 32 |             raise NotFound()
 33 | 
 34 | 
 35 | ######################### Function based API Views ######################################
 36 | @api_view(['GET', 'POST'])
 37 | def blog_list(request):
 38 |     blogs = Blog.objects.all()
 39 |     if request.method == 'GET':
 40 |         serializer = BlogSerializer(blogs, many=True)
 41 |         return Response(serializer.data, status=status.HTTP_200_OK)
 42 |     elif request.method == 'POST':
 43 |         serializer = BlogSerializer(data=request.data)
 44 |         if serializer.is_valid():
 45 |             serializer.save()
 46 |             return Response(serializer.data, status=status.HTTP_201_CREATED)
 47 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 48 | 
 49 | 
 50 | @api_view(['GET', 'PUT', 'DELETE'])
 51 | def blog_detail(request, pk):
 52 |     """API to GET, PUT and DELETE a blogpost."""
 53 |     try:
 54 |         blog = Blog.objects.get(pk=pk)
 55 |     except Blog.DoesNotExist:
 56 |         raise NotFound()
 57 |         # return HttpResponse(status=status.HTTP_404_NOT_FOUND)
 58 | 
 59 |     serializer = BlogSerializer(blog)
 60 |     if request.method == 'GET':
 61 |         return Response(serializer.data, status=status.HTTP_200_OK)
 62 |     elif request.method == 'PUT':
 63 |         serializer = BlogSerializer(blog, data=request.data)
 64 |         if serializer.is_valid():
 65 |             serializer.save()
 66 |             return Response(serializer.data, status=status.HTTP_200_OK)
 67 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 68 |     elif request.method == 'POST':
 69 |         serializer = BlogSerializer(blog, data=request.data)
 70 |         if serializer.is_valid():
 71 |             serializer.save()
 72 |             return Response(serializer.data, status=status.HTTP_201_CREATED)
 73 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 74 |     elif request.method == 'DELETE':
 75 |         blog.delete()
 76 |         return HttpResponse(status=status.HTTP_204_NO_CONTENT)
 77 | 
 78 | ######################### END of Function based API Views ######################################
 79 | 
 80 | ######################### CBV APIViews of Function based API Views above. ######################################
 81 | 
 82 | 
 83 | class BlogAPIView(APIView):
 84 |     """Class Based View similar to blog_list FBV above."""
 85 | 
 86 |     def get(self, request):
 87 |         blogs = Blog.objects.all()
 88 |         serializer = BlogSerializer(blogs, many=True)
 89 |         return Response(serializer.data, status=status.HTTP_200_OK)
 90 | 
 91 |     def post(self, request):
 92 |         serializer = BlogSerializer(data=request.data)
 93 |         if serializer.is_valid():
 94 |             serializer.save()
 95 |             return Response(serializer.data, status=status.HTTP_201_CREATED)
 96 |         return Response(serializer.errors,  status=status.HTTP_400_BAD_REQUEST)
 97 | 
 98 | 
 99 | class BlogDetailAPIView(APIView):
100 |     """Class Based View of blog_detail FBV above."""
101 | 
102 |     def get_object(self, pk):
103 |         try:
104 |             blog = Blog.objects.get(pk=pk)
105 |             return blog
106 |         except Blog.DoesNotExist:
107 |             raise NotFound()
108 | 
109 |     def get(self, request, pk):
110 |         blog = self.get_object(pk)
111 |         serializer = BlogSerializer(blog)
112 |         return Response(serializer.data)
113 | 
114 |     def put(self, request, pk):
115 |         blog = self.get_object(pk)
116 |         serializer = BlogSerializer(blog, data=request.data)
117 |         if serializer.is_valid():
118 |             serializer.save()
119 |             return Response(serializer.data, status=status.HTTP_200_OK)
120 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
121 | 
122 |     def delete(self, request, pk):
123 |         blog = self.get_object(pk)
124 |         blog.delete()
125 |         return Response(status=status.HTTP_204_NO_CONTENT)
126 | ######################### End of CBV APIViews of Function based API Views above. ###########################
127 | 
128 | ############################ CBV Generic APIViews ###################################
129 | 
130 | 
131 | class BlogGenericAPIView(generics.GenericAPIView, mixins.CreateModelMixin, mixins.ListModelMixin):
132 |     serializer_class = BlogSerializer
133 |     queryset = Blog.objects.all()
134 |     # If SessionAuthentication is present that is used else BasicAuthentication will be used - That is why a list.
135 |     #authentication_classes = [SessionAuthentication, BasicAuthentication]
136 |     authentication_classes = [TokenAuthentication]
137 |     permission_classes = [IsAuthenticated]
138 | 
139 |     def get(self, request):
140 |         return self.list(request)
141 | 
142 |     def post(self, request):
143 |         return self.create(request)
144 | 
145 | 
146 | class BlogGenericDetailAPIView(generics.GenericAPIView, mixins.ListModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, mixins.RetrieveModelMixin):
147 |     serializer_class = BlogSerializer
148 |     queryset = Blog.objects.all()
149 |     lookup_field = 'pk'
150 |     # If SessionAuthentication is present that is used else BasicAuthentication will be used - That is why a list.
151 |     #authentication_classes = [SessionAuthentication, BasicAuthentication]
152 |     authentication_classes = [TokenAuthentication]
153 |     permission_classes = [IsAuthenticated]
154 | 
155 |     def get(self, request, pk):
156 |         return self.retrieve(request, pk)
157 | 
158 |     def post(self, request):
159 |         return self.create(request)
160 | 
161 |     def put(self, request, pk):
162 |         return self.update(request, pk)
163 | 
164 |     def delete(self, request, pk):
165 |         return self.destroy(request, pk)
166 | 
167 | ############################ END of CBV Generic APIViews ###################################
168 | 
169 | 
170 | class BlogViewSet(generics.ListAPIView):
171 |     '''
172 |     API endpoint to view the posts data by username.
173 |     '''
174 |     serializer_class = BlogSerializer
175 | 
176 |     def get_queryset(self):
177 |         queryset = Blog.objects.all()
178 |         username = self.request.query_params.get('username')
179 |         if username is not None:
180 |             queryset = queryset.filter(author__username=username)
181 |             if queryset.exists():
182 |                 return queryset
183 |         raise NotFound()
184 | 
185 | 
186 | class ViewPostViewSet(generics.ListAPIView):
187 |     '''
188 |     API endpoint to view a specific post by it's id
189 |     '''
190 |     serializer_class = ViewPostSerializer
191 | 
192 |     def get_queryset(self):
193 |         queryset = Blog.objects.all()
194 |         post_id = self.request.query_params.get('post_id')
195 |         if post_id is not None:
196 |             queryset = queryset.filter(id=post_id)
197 |             if queryset.exists():
198 |                 return queryset
199 |         raise NotFound()
200 | 
201 | 
202 | ################## ModelViewSet #####################
203 | class PostsViewSet(viewsets.ModelViewSet):
204 |     serializer_class = ViewPostSerializer
205 |     queryset = Blog.objects.all()
206 | 
207 | 
208 | class UsersModelViewSet(viewsets.ModelViewSet):
209 |     serializer_class = UserSerializer
210 |     queryset = User.objects.all()
211 | 
212 | 
213 | 


--------------------------------------------------------------------------------
/users/tests/tests_views.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | from django.test import TestCase, Client
  3 | from django.contrib.auth.models import User
  4 | from users.models import Profile, Followers
  5 | from django.urls import reverse
  6 | from django.contrib.auth import views as auth_views
  7 | 
  8 | 
  9 | class TestUserViews(TestCase):
 10 |     """Tests the views of Users application."""
 11 | 
 12 |     def setUp(self):
 13 |         self.user1 = User.objects.create_user(
 14 |             username='Test', first_name='Testname', last_name='Last', email='test@gmail.com', password='testing@123')
 15 |         self.user2 = User.objects.create_user(
 16 |             username='Test1', first_name='Testname1', last_name='Last1', email='test1@gmail.com', password='testing@123')
 17 |         self.profile1 = Profile.objects.get(user=self.user1)
 18 |         self.profile2 = Profile.objects.get(user=self.user2)
 19 | 
 20 |     def test_user_register(self):
 21 |         data = {
 22 |             'username': 'gibbsh',
 23 |             'first_name': 'Gibberish',
 24 |             'last_name': 'name',
 25 |             'email': 'test_mail1@email.com',
 26 |             'password1': 'Testing@123',
 27 |             'password2': 'Testing@123',
 28 |         }
 29 |         response = self.client.post(reverse('register'), data=data)
 30 |         user_created = User.objects.filter(username=data['username']).exists()
 31 |         self.assertTrue(user_created)
 32 |         self.assertEquals(response.status_code, 302)
 33 |         self.assertRedirects(response, reverse('login'))
 34 | 
 35 |     def test_user_logged_in(self):
 36 |         response = self.client.get(reverse('login'))
 37 |         self.assertTemplateUsed(response, 'users/login.html')
 38 | 
 39 |     def test_user_logged_out(self):
 40 |         response = self.client.get(reverse('logout'))
 41 |         self.assertTemplateUsed(response, 'users/logout.html')
 42 | 
 43 |     def test_password_reset_view(self):
 44 |         response = self.client.get(reverse('password_reset'))
 45 |         self.assertTemplateUsed(response, 'users/password_reset.html')
 46 | 
 47 |     def test_password_reset_done_view(self):
 48 |         response = self.client.get(reverse('password_reset_done'))
 49 |         self.assertTemplateUsed(response, 'users/password_reset_done.html')
 50 | 
 51 |     def test_password_reset_complete(self):
 52 |         response = self.client.get(reverse('password_reset_complete'))
 53 |         self.assertTemplateUsed(response, 'users/password_reset_complete.html')
 54 | 
 55 |     def test_profile_GET_if_not_logged_in(self):
 56 |         response = self.client.get(
 57 |             reverse('profile', args=[self.user1.username]))
 58 |         self.assertRedirects(response, '/login/?next=/profile/Test/')
 59 | 
 60 |     def test_profile_GET_if_logged_in_self_profile(self):
 61 |         # To login the user
 62 |         login = self.client.login(
 63 |             username=self.user1.username, password='testing@123')
 64 |         response = self.client.get(
 65 |             reverse('profile', args=[self.user1.username]))
 66 |         # Check if the user is successfully logged in
 67 |         self.assertEquals(str(response.context['user']), self.user1.username)
 68 |         # Check that the status_code is 200 i.e. Success
 69 |         self.assertEquals(response.status_code, 200)
 70 |         self.assertTemplateUsed(response, 'users/view_profile.html')
 71 | 
 72 |     def test_profile_GET_if_logged_in_other_profile(self):
 73 |         login = self.client.login(
 74 |             username=self.user1.username, password='testing@123')
 75 |         response = self.client.get(
 76 |             reverse('profile', args=[self.user2.username]))
 77 |         self.assertEquals(str(response.context['user']), self.user1.username)
 78 |         self.assertEquals(response.status_code, 200)
 79 |         self.assertTemplateUsed(response, 'users/view_profile.html')
 80 | 
 81 |     def test_view_followers_GET_if_not_logged_in(self):
 82 |         response = self.client.get(
 83 |             reverse('view_followers', args=[self.user1.username]))
 84 |         self.assertEquals(response.status_code, 302)
 85 |         self.assertRedirects(response, '/login/?next=/view_followers/Test/')
 86 | 
 87 |     def test_view_followers_GET_if_logged_in(self):
 88 |         login = self.client.login(
 89 |             username=self.user1.username, password='testing@123')
 90 |         response = self.client.get(
 91 |             reverse('view_followers', args=[self.user1.username]))
 92 |         self.assertEquals(response.status_code, 200)
 93 |         self.assertTemplateUsed(response, 'users/followers.html')
 94 | 
 95 |     def test_follow_a_user_if_not_logged_in(self):
 96 |         response = self.client.get(reverse('follow'))
 97 |         self.assertRedirects(response, '/login/?next=/follow/')
 98 |         self.assertEquals(response.status_code, 302)
 99 | 
100 |     def test_follow_a_user_if_logged_in(self):
101 |         login = self.client.login(
102 |             username=self.user1.username, password='testing@123')
103 |         self.assertTrue(login)
104 |         response = self.client.post(reverse('follow'), data={
105 |                                     'username': self.user2.username})
106 |         json_status = json.loads(response.content)
107 |         self.assertEquals(response.status_code, 200)
108 |         self.assertEquals(json_status['status'], 'success')
109 |         # Checking if entry added to DB
110 |         f = Followers.objects.get(id=1)
111 |         self.assertEquals(f.user, self.profile1)
112 |         self.assertEquals(f.followers, self.profile2)
113 | 
114 |     def test_unfollow_a_user_if_not_logged_in(self):
115 |         response = self.client.get(reverse('unfollow'))
116 |         self.assertRedirects(response, '/login/?next=/unfollow/')
117 |         self.assertEquals(response.status_code, 302)
118 | 
119 |     def test_unfollow_a_user_if_logged_in(self):
120 |         login = self.client.login(
121 |             username=self.user1.username, password='testing@123')
122 |         self.assertTrue(login)
123 |         # Following the User
124 |         response = self.client.post(reverse('follow'), data={
125 |                                     'username': self.user2.username})
126 |         json_status = json.loads(response.content)
127 |         self.assertEquals(response.status_code, 200)
128 |         self.assertEquals(json_status['status'], 'success')
129 |         # Checking if entry added to DB
130 |         f = Followers.objects.get(id=1)
131 |         self.assertEquals(f.user, self.profile1)
132 |         self.assertEquals(f.followers, self.profile2)
133 | 
134 |         # Unfollowing the User
135 |         response = self.client.post(reverse('unfollow'), data={
136 |                                     'username': self.user2.username})
137 |         json_status = json.loads(response.content)
138 |         self.assertEquals(response.status_code, 200)
139 |         self.assertEquals(json_status['status'], 'success')
140 |         # Checking if entry deleted from  DB
141 |         f = Followers.objects.filter(id=1).exists()
142 |         self.assertFalse(f)
143 | 
144 |     def test_view_followers_if_not_logged_in(self):
145 |         response = self.client.get(
146 |             reverse('view_followers', args=[self.user1.username]))
147 |         self.assertEquals(response.status_code, 302)
148 |         self.assertRedirects(
149 |             response, f'/login/?next=/view_followers/{self.user1.username}/')
150 | 
151 |     def test_view_followers_if_logged_in(self):
152 |         login = self.client.login(
153 |             username=self.user1.username, password='testing@123')
154 |         self.assertTrue(login)
155 |         response = self.client.get(
156 |             reverse('view_followers', args=[self.user1.username]))
157 |         self.assertEquals(response.status_code, 200)
158 |         self.assertTemplateUsed(response, 'users/followers.html')
159 |         #print(response.context['no_of_following'], response.context['followers'])
160 | 
161 |     def test_update_profile_if_not_logged_in_GET(self):
162 |         response = self.client.get(reverse('update_profile'))
163 |         self.assertEquals(response.status_code, 302)
164 |         self.assertRedirects(response, '/login/?next=/update-profile/')
165 | 
166 |     def test_update_profile_if_not_logged_in_POST(self):
167 |         response = self.client.post(reverse('update_profile'))
168 |         self.assertEquals(response.status_code, 302)
169 |         self.assertRedirects(response, '/login/?next=/update-profile/')
170 | 
171 |     def test_update_profile_if_logged_in_GET(self):
172 |         login = self.client.login(
173 |             username=self.user1.username, password='testing@123')
174 |         self.assertTrue(login)
175 |         response = self.client.get(reverse('update_profile'))
176 |         self.assertEquals(response.status_code, 200)
177 |         self.assertTemplateUsed(response, 'users/update_profile.html')
178 | 
179 |     def test_update_profile_if_logged_in_POST(self):
180 |         login = self.client.login(
181 |             username=self.user1.username, password='testing@123')
182 |         self.assertTrue(login)
183 |         new_email = 'update_test_mail1@gmail.com'
184 |         response = self.client.post(reverse('update_profile'), data={
185 |                                     'email': new_email})
186 |         self.assertEquals(response.status_code, 302)
187 |         p = User.objects.get(id=self.user1.id)
188 |         self.assertRedirects(response, reverse('profile', args=[self.user1.username]))
189 |         self.assertEquals(p.email, new_email)
190 | 


--------------------------------------------------------------------------------
/blogs/static/blogs/styles.min.css:
--------------------------------------------------------------------------------
1 | @import url(https://fonts.googleapis.com/css2?family=Andika+New+Basic&family=Hind+Siliguri&family=Nunito:wght@300&family=Roboto+Slab&display=swap);*{box-sizing:border-box;padding:0;margin:0}body{min-height:100vh;position:relative;padding-bottom:80px}.navbar{background-color:#000;height:4.5rem}.nav_container{max-width:100%;margin:0 auto;overflow:hidden;padding:0 40px}.logo{color:#fff}.flex_container{display:flex}.blog_container{flex:2;max-width:75%;margin-right:0;padding:12px}.side_container{float:right;max-width:400px;border-radius:5px;height:fit-content;padding:10px}.side_container ul{padding-left:.5em;padding:10px;box-shadow:3px 3px #d6d6d6}.side_container li{margin-left:1em;list-style-position:outside;list-style-type:none;font-weight:500;border-bottom:1px solid #eaeae9f0;padding:2px}.side_container p{font-weight:700;font-size:1.4rem;color:#fff;background-color:#000;text-align:center}.navbar a{text-decoration:none;color:#fff;margin:10px}.navbar ul{display:flex;list-style-type:none}.navbar .flex{justify-content:space-between}.flex{display:flex;align-items:center;height:100%}.navbar h1{font-size:2.1rem;font-weight:800}.main_container{display:flex;justify-content:center;margin:5px auto;max-width:100%}.navbar li>a{font-size:1rem;padding:10px}.navbar li>a:hover{border-bottom:2px solid #fff}.blog_container article{border:1px solid #bababd;box-shadow:3px 3px #d6d6d6;border-radius:4px;margin:8px auto;max-height:fit-content;max-width:900px;overflow:hidden}.blog_container p{padding:0;line-height:1.3}.blog_container section{padding:5px}.blog_container section>a{text-decoration:none;cursor:pointer}.blog_container section>a:hover{font-weight:700;color:green}.post_up_down{cursor:pointer;font-size:26px;color:#fff;line-height:.8}.post_header{margin-top:8px;margin-left:2px}.fa-caret-up:hover{color:#8bf178}.fa-caret-down:hover{color:#eb1f1f}.votes_container{display:flex;flex-direction:column;align-items:center;flex:1;max-width:50px;max-height:fit-content;margin:-4px}#votes_count{text-align:center;font-size:1.15rem}.blog_title_index{color:#000}.blog_title_index:hover{text-decoration:none}.my_btn{padding:7px;border-radius:20px;color:#fff;font-weight:600;font-size:14px;background-color:gray;margin:5px}navbar-expand-md .my_btn:hover{text-decoration:none;color:#fff;padding:8px}.update_btn{background-color:#2097a7;margin-left:10px}.update_btn:hover{background-color:#037786}.delete_btn{background-color:#d61c1c}.delete_btn:hover{background-color:red}.posts_container ul{list-style-type:none}.posts_container li{font-weight:600}.posts_container a:hover{text-decoration:none}.new_post_container{max-width:900px;margin:0 auto}.required{color:red}.post_title{height:2rem;width:100%;border:0;border-bottom:1px solid #b4becb;font-size:1.2rem;padding:5px;margin:10px auto}.new_post_container textarea{height:25rem;width:100%;font-size:1rem;padding:5px;margin:10px auto;border:1px solid #b4becb}.new_post input,.new_post textarea:focus{outline:0}.btn_class{padding:5px;font-size:1.1rem;color:#fff;border-radius:5px;margin:8px auto;cursor:pointer}.submit_btn{background-color:green}.discard_btn{background-color:red;margin:auto 15px}.new_post{margin:10px auto}.new_post h3{font-size:1.4rem}.content-section{max-width:700px;margin:0 auto}.profile_pane{display:flex;flex-direction:row;padding:10px}.posts_container{padding:10px;margin:10px auto}.blog_image{max-height:300px;max-width:300px}pre{white-space:pre-wrap;white-space:-moz-pre-wrap;white-space:-pre-wrap;white-space:-o-pre-wrap;word-wrap:break-word;padding:0;margin:0;font-family:inherit;font-size:14px;word-break:break-word}.index_blog_description{overflow:hidden;text-overflow:ellipsis;max-height:180px;padding:12px;color:#000!important;font-size:14px}.index_blog_description img{display:flex;max-width:-webkit-fill-available;max-height:400px;margin:auto;object-fit:fill}.comments{font-style:normal;font-weight:600}.save_edit_btn{background-color:#17a2b8;color:#fff;padding:5px;border-radius:5px;font-size:13px;font-weight:600;margin-top:4px}.cancel_edit_btn{background-color:red;color:#fff;padding:5px;border-radius:5px;font-size:13px;font-weight:600;margin-top:4px}.save_edit_btn:hover{background-color:#0c899c;text-decoration:none;color:#fff}.cancel_edit_btn:hover{background-color:#a70404;text-decoration:none;color:#fff}.comment_edit_text{font-size:14px}.comment_text{font-size:14px}.side_container a:hover{text-decoration:none}footer{position:absolute;text-align:center;width:100%;bottom:0}.pagination{width:fit-content;margin:0 auto}.pagination a{margin-left:4px}hr{margin-bottom:5px}.post_header_h2{font-size:18px;margin-bottom:2px}.post_div{display:flex;flex-direction:row;background-color:#5d0303;color:#fff;padding:5px 0}.post_div h2{color:#fff}.post_header a{color:#ff0}.date{font-size:11px}#hint_id_password1{padding-left:18px}.my_btn:hover{text-decoration:none;color:#fff}.follow{padding:8px;border-radius:20px;color:#fff;font-size:small;font-weight:600;transition:all .2s ease-in;border:none;cursor:pointer;outline:0!important}.follow-btn{background-color:rgba(4,90,139,.74)}.following-btn{background-color:#13d665}.follow:hover{text-decoration:none;color:#fff}.profile_container{margin:12px;width:75%}.followers_list{list-style-type:none;padding-left:1rem}.connections_header{font-weight:600;text-decoration:none;background-color:#bbbbbb17}.connections a:hover{text-decoration:none}.view_followers{color:#000}.view_followers:hover{text-decoration:none;color:#000}.new_post{position:fixed;bottom:5rem;width:fit-content;height:fit-content;background-color:#000;border-radius:100%;border:1px solid #000;justify-content:center;text-align:center;padding:1rem;right:6rem;z-index:1}.new_post:hover{transition:transform .6s;transform:rotate(360deg);padding:1.1rem;background-color:rgba(233,15,15,.904)}.new_post i{color:#fff;font-size:2.5rem}.Counter{display:inline-block;min-width:20px;padding:0 6px;font-size:12px;font-weight:500;line-height:18px;text-align:center;background-color:rgb(209 213 218 / 50%);border:1px solid transparent;border-radius:2em}.notification-icon{font-size:1.5rem;padding:3px;color:#fff}.notification_anchor{color:#fff;text-decoration:none;position:relative;display:inline;cursor:pointer}.badge{display:block;position:absolute;background:#e1141e;color:#fff;font-size:12px;font-weight:400;padding:1px 3px;margin:-45px 0 0 42px;border-radius:2px;-moz-border-radius:2px;-webkit-border-radius:2px;z-index:1}.notification-list{color:#000}.notification-list:hover{color:#000}.notif_timestamp{float:right;color:#757575;font-size:.75rem;margin-top:1rem}.unread{border-left:5px solid #215dbf}.read{background-color:#dfdee482}.round_profile_pics{height:50px;width:50px}.notifications_section{font-size:.9rem}#noti_container{position:relative}#notifications{display:none;width:420px;position:absolute;top:2.8rem;right:-11rem;background:#fff;border:solid 1px rgba(100,100,100,.2);padding:0 3px;z-index:1}#notifications:before{content:'';display:block;width:0;height:0;color:transparent;border:10px solid #ccc;border-color:transparent transparent #fff;margin-top:-17px;margin-left:12.25rem;z-index:0}.seeAll{background:#f6f7f8;padding:8px;font-size:12px;font-weight:700;border-top:solid 1px rgba(100,100,100,.3);text-align:center}.seeAll a{color:#3b5998}.seeAll a:hover{background:#f6f7f8;color:#3b5998;text-decoration:underline}#notifications>h3{display:block;color:#333;background:#fff;text-align:center;font-weight:700;font-size:14px;padding:8px;margin:0;border-bottom:solid 1px rgba(100,100,100,.3)}.notification_icon_text{font-size:14px}.notification_icon_text>a{margin-left:0;color:#000}.form-inline>div:not(:last-child){margin-right:2.5rem}.nav_icons{font-size:2rem;padding:10px}.nav_icons:hover{color:#129b9b;background-color:#f5f5f5;border-radius:50%}.blog_image{border-radius:5px;cursor:pointer;transition:.3s}.blog_image:hover{opacity:.7}#image-viewer{display:none;position:fixed;z-index:1;padding-top:100px;left:0;top:0;width:100%;height:100%;overflow:auto;background-color:#000;background-color:rgba(0,0,0,.9)}.modal-content{margin:auto;object-fit:contain;display:block;width:auto;max-width:700px;height:auto;max-height:800px}.modal-content{animation-name:zoom;animation-duration:.6s}@keyframes zoom{from{transform:scale(0)}to{transform:scale(1)}}#image-viewer .close{position:absolute;top:15px;right:35px;color:#f1f1f1;font-size:40px;font-weight:700;transition:.3s}#image-viewer .close:focus,#image-viewer .close:hover{color:#bbb;text-decoration:none;cursor:pointer}#search{width:60%;display:inline-flex;margin-right:auto;margin-left:auto}.index_blog_full_description{padding:1rem 2rem;font-size:14px}.index_blog_full_description img{display:flex;margin:auto;max-width:-webkit-fill-available;max-height:400px;object-fit:contain;cursor:pointer}.search_section{text-align:center;margin-top:1rem}.login-btn{border:1px solid #1e90ff;border-radius:16px;padding:5px;margin-right:1rem;color:#000;background:#1e90ff}.login-btn:hover{padding:6px}.search_bar_icon{background:#fff;margin-left:.51rem;margin-bottom:1.4rem;font-size:1.25rem;padding:8px;color:#000;border-radius:50%;cursor:pointer}.search_bar_icon:hover{color:#006400}#search_btn{background:0 0;border:none;outline:0}@media only screen and (max-width:700px){.modal-content{width:90%;height:auto}div#search_user_part{display:none}}@media only screen and (max-width:820px){.profile_pane h2{font-size:24px}.profile_pane img{height:110px;width:110px}.side_container{visibility:hidden;display:none}.blog_container{max-width:100%;padding:0}.main_container{padding:0;margin:0}.col{padding:10px}.my_btn{padding:5px;font-weight:500;font-size:11px}.navbar{height:auto;padding:.2rem}.navbar li>a{padding:0}.navbar h1{font-size:1.8rem;font-weight:800}.pagination a{padding:.4rem}.new_post{right:2rem;bottom:2rem}.badge{top:auto;right:-2px}.form-inline>div:not(:last-child){margin-right:-1rem}#notifications{width:320px;right:-5.2rem;font-size:13px}#notifications::before{margin-left:12.15rem}.nav_icons{font-size:1.2rem}.badge{margin:-40px 6px 0 0}.notif_timestamp{margin-top:0;font-size:10px}div#search_user_part{display:none}}


--------------------------------------------------------------------------------
/blogs/templates/blogs/base.html:
--------------------------------------------------------------------------------
  1 | {% load static %}
  2 | {% load crispy_forms_tags %}
  3 | {% load humanize %}
  4 | <!DOCTYPE html>
  5 | <html lang="en">
  6 | 
  7 | <head>
  8 |     <meta charset="UTF-8">
  9 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 10 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.1/css/all.min.css"
 11 |         integrity="sha512-+4zCK9k+qNFUR5X+cKL9EIR+ZOhtIloNl9GIKS57V1MyNsYpYcUrUeQc9vNfzsWfV28IaLL3i96P9sdNyeRssA=="
 12 |         crossorigin="anonymous" />
 13 |     <link rel="shortcut icon" href="{%  static 'blogs/favicon.png' %}">
 14 |     <!--Bootstrap-->
 15 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
 16 |         integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
 17 | 
 18 |     <!-- CSS File -->
 19 |     <link rel="stylesheet" href="{% static 'blogs/styles.css' %}">
 20 | 
 21 |     <!-- JQuery and AJAX CDN -->
 22 |     <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
 23 | 
 24 |     <!-- Javascript File-->
 25 |     <script type="text/javascript" src="{% static 'blogs/script.js' %}"></script>
 26 | 
 27 |     <!-- Popper.js and JS for Bootstrap -->
 28 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.16.0/umd/popper.min.js"></script>
 29 |     <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js"></script>
 30 |     <script type='text/javascript'>
 31 |         $(document).ready(function executeQuery() {
 32 |             $('#search_btn').on('click', function () {
 33 |                 var search_query = $('.search_form').val();
 34 |                 //alert(search_query);
 35 |                 if (search_query != '') {
 36 |                     window.location.replace("{% url 'searchUser' %}?uname=" + search_query);
 37 |                 }
 38 | 
 39 | 
 40 |             });
 41 |         });
 42 |     </script>
 43 | 
 44 |     {% if title %}
 45 |     <title>Blog | {{ title }}</title>
 46 |     {% else %}
 47 |     <title>Blog</title>
 48 |     {% endif %}
 49 | </head>
 50 | 
 51 | <body>
 52 |     {% if user.is_authenticated %}
 53 |     <a href="{% url 'create_post' %}" style="color: black; margin: 0;">
 54 |         <div class="border new_post" title="Create New Post">
 55 |             <i class="fas fa-plus" aria-hidden="true"></i>
 56 |         </div>
 57 |     </a>
 58 |     {% endif %}
 59 |     <!-- Navigation bar -->
 60 |     <nav class="navbar navbar-dark justify-content-between navbar-expand-lg">
 61 |         <h1><a class="navbar-brand" style="font-size: 1.8rem;" href="{% url 'index' %}" title="Home">Blog</a></h1>
 62 |         <div class="form-inline">
 63 | 
 64 |             {% if user.is_authenticated %}
 65 |             <div class="input-group" id="search_user_part" style="margin-top: 1rem; margin-right: 18rem;">
 66 |                 <div class="form-outline">
 67 |                     <input id="search-focus" type="search" class="form-control search_form" placeholder="Search" />
 68 |                 </div>
 69 |                 <button id="search_btn" type="submit"><i class="fas fa-search search_bar_icon"></i></button>
 70 |             </div>
 71 | 
 72 | 
 73 |             <!--<div><a href="{% url 'search' %}" title="Profile"><i class="fas fa-search nav_icons"></i></a></div>-->
 74 |             <div id="noti_container"><a class="notification_anchor" id="noti_Button" href="#" title="Notifications">
 75 |                     <i class="fas fa-globe-asia nav_icons"></i>
 76 |                     {% if status %}
 77 |                     <span class="badge" id="noti_counter">{{ notif_count }}</span>
 78 |                     {% endif %}
 79 |                 </a>
 80 |                 <!--THE NOTIFICATIONS DROPDOWN BOX.-->
 81 |                 <div id="notifications">
 82 |                     <h3>Notifications</h3>
 83 |                     <div style="max-height:300px;" class="notification_icon_text">
 84 |                         {% for notif in unread_notifs %}
 85 |                         {% if notif.n_post_id == -1 %}
 86 |                         <a id="{{ notif.n_post_id }}" href="{% url 'profile' notif.n_sender %}"
 87 |                             class="list-group-item unread list-group-item-action notification-list">
 88 |                             <!--<img class="rounded-circle round_profile_pics mr-2" src="{{ notif.n_profile_pic }}">-->
 89 |                             {% if notif.n_count > 0 %}
 90 |                             <span><strong>{{ notif.n_sender }}</strong> and <strong>{{ notif.n_count }} other{{
 91 |                                     notif.n_count|pluralize }}</strong> started following you</span>
 92 |                             {% else %}
 93 |                             <span><strong>{{ notif.n_sender }}</strong> started following you</span>
 94 |                             {% endif %}
 95 |                             <small class="notif_timestamp">{{ notif.n_timestamp|naturaltime }}</small>
 96 |                         </a>
 97 |                         {% else %}
 98 |                         <a id="{{ notif.n_post_id }}" href="{% url 'view_post' notif.n_post_id %}"
 99 |                             class="list-group-item unread list-group-item-action notification-list">
100 |                             <!--img class="rounded-circle round_profile_pics mr-2" src="{{ notif.n_profile_pic }}">-->
101 |                             {% if notif.n_count > 0 %}
102 |                             <span><strong>{{ notif.n_sender }}</strong> and <strong>{{ notif.n_count }} other{{
103 |                                     notif.n_count|pluralize }}</strong> commented on your post</span>
104 |                             {% else %}
105 |                             <span><strong>{{ notif.n_sender }}</strong> commented on your post</span>
106 |                             {% endif %}
107 |                             <small class="notif_timestamp">{{ notif.n_timestamp|naturaltime }}</small>
108 |                         </a>
109 |                         {% endif %}
110 |                         {% endfor %}
111 |                     </div>
112 |                     <div class="seeAll"><a class="seeAll" href="{% url 'notifications' %}">View All</a></div>
113 |                 </div>
114 |             </div>
115 |             <div><a href="{% url 'profile' user.username %}" title="Profile"><i class="fas fa-user nav_icons"></i></a>
116 |             </div>
117 |             <div><a href="{% url 'logout' %}" title="Logout"><i class="fas fa-sign-out-alt nav_icons"></i></a></div>
118 |             {% else %}
119 |             <div class="login-btn"><a href="{% url 'login' %}">Login</a></div>
120 |             <!--<div><a href="{% url 'register' %}">Register</a></div>-->
121 |             {% endif %}
122 |         </div>
123 |     </nav>
124 |     <!--End of Navigation bar -->
125 | 
126 |     <!-- Main Container -->
127 |     <main role="main" class="main_container">
128 |         <!-- Notification section -->
129 |         <div class="col">
130 |             {% if messages %}
131 |             {% for message in messages %}
132 |             <div class="alert general_alerts alert-dismissible alert-info fade show">
133 |                 {{ message }}
134 |                 <button type="button" class="close" data-dismiss="alert" aria-label="Close">
135 |                     <span aria-hidden="true">&times;</span>
136 |                 </button>
137 |             </div>
138 |             {% endfor %}
139 |             {% endif %}
140 |             <!--
141 |             <div id="self_vote" class="alert alert-danger collapse" role="alert">
142 |                 You cannot vote on your own post.
143 |             </div>
144 |             -->
145 |             <!-- Content goes here -->
146 |             {% block content %}{% endblock %}
147 |         </div>
148 |         <!-- Modal to show - Login Required -->
149 |         <div class="modal fade" id="exampleModalCenter" tabindex="-1" role="dialog"
150 |             aria-labelledby="exampleModalCenterTitle" aria-hidden="true">
151 |             <div class="modal-dialog" role="document">
152 |                 <div class="modal-content">
153 |                     <div class="modal-header">
154 |                         <h5 class="modal-title" id="exampleModalLongTitle">Login Required</h5>
155 |                         <button type="button" class="close" data-dismiss="modal" aria-label="Close">
156 |                             <span aria-hidden="true">&times;</span>
157 |                         </button>
158 |                     </div>
159 |                     <div class="modal-body">
160 |                         <form method="POST">
161 |                             {% csrf_token %}
162 |                             <fieldset class="form-group">
163 |                                 {{ form|crispy }}
164 |                             </fieldset>
165 |                             <div class="form-group">
166 |                                 <h6>Please Sign-in to perform your action.</h6>
167 |                                 <a href="{% url 'login' %}" class="btn btn-outline-success mt-3">Sign In</a>
168 |                             </div>
169 |                         </form>
170 |                         <div class="border-top pt-3">
171 |                             <small class="text-muted">
172 |                                 Do you need an account? <a href="{% url 'register' %}" class="ml-2">Sign Up</a>
173 |                             </small>
174 |                         </div>
175 |                     </div>
176 |                 </div>
177 |             </div>
178 |         </div>
179 |         <!--End of Modal-->
180 | 
181 |     </main>
182 |     <footer>
183 |         <hr>
184 |         <p>Powered by <span style="color: darkgreen; font-weight: 600;">Django</span></p>
185 |     </footer>
186 | </body>
187 | 
188 | </html>


--------------------------------------------------------------------------------
/blogs_api/DRF_Notes.md:
--------------------------------------------------------------------------------
  1 | ## Django REST Framework Notes
  2 | 
  3 | ### What is Serialization ?
  4 | * Data serialization is the process of converting structured data to a format that allows sharing or storage of the data in a form that allows recovery of its original structure
  5 | * Read it [here](https://docs.python-guide.org/scenarios/serialization/). Notes based on this [Video](https://www.youtube.com/watch?v=B38aDwUpcFc).
  6 | 
  7 | In the shell
  8 | 
  9 | ```python
 10 | class BlogSerializer(serializers.ModelSerializer):
 11 |     ''' To show Posts data '''
 12 |     class Meta:
 13 |         model = Blog
 14 |         fields = '__all__'
 15 | 
 16 | 
 17 | ser = serializers.BlogSerializer()
 18 | print(repr(ser))    # will give the fields used in this serializer
 19 | 
 20 | Output:
 21 | 
 22 | BlogSerializer():
 23 |     id = IntegerField(label='ID', read_only=True)
 24 |     title = CharField(max_length=100)
 25 |     description = CharField(allow_blank=True, allow_null=True, required=False, style={'base_template': 'textarea.html'})
 26 |     publish_date = DateTimeField(required=False)
 27 |     likes = IntegerField(required=False)
 28 |     image = ImageField(allow_null=True, max_length=100, required=False)
 29 |     views = IntegerField(required=False)
 30 |     slug = SlugField(allow_unicode=False, max_length=255, validators=[<UniqueValidator(queryset=Blog.objects.all())>])
 31 |     author = PrimaryKeyRelatedField(queryset=User.objects.all())
 32 | ```
 33 | 
 34 | 
 35 | #### Function Based API Views
 36 | ```serializers.py```
 37 | ```python
 38 | from blogs.models import Blog, Blog_comments
 39 | from rest_framework import serializers
 40 | 
 41 | class BlogSerializer(serializers.ModelSerializer):
 42 |     ''' To show Posts data '''
 43 |     class Meta:
 44 |         model = Blog
 45 |         fields = '__all__'
 46 | ```
 47 | 
 48 | **Required Imports**
 49 | ```python
 50 | from django.db.models import query
 51 | from django.shortcuts import render
 52 | from django.contrib.auth.models import User
 53 | from django.http import HttpResponse
 54 | from rest_framework.fields import SerializerMethodField
 55 | from blogs.models import Blog, Blog_comments
 56 | from .serializers import UserSerializer, BlogSerializer, ViewPostSerializer
 57 | from rest_framework import serializers, viewsets, generics, mixins
 58 | from rest_framework.exceptions import NotFound
 59 | from rest_framework.response import Response
 60 | from rest_framework import status
 61 | from rest_framework.decorators import api_view, authentication_classes, permission_classes
 62 | from rest_framework.views import APIView
 63 | from rest_framework.authentication import BasicAuthentication, SessionAuthentication, TokenAuthentication
 64 | from rest_framework.permissions import IsAuthenticated
 65 | ```
 66 | 
 67 | ```views.py```
 68 | **Function based API Views**
 69 | ```python
 70 | @api_view(['GET', 'POST'])
 71 | def blog_list(request):
 72 |     blogs = Blog.objects.all()
 73 |     if request.method == 'GET':
 74 |         serializer = BlogSerializer(blogs, many=True)
 75 |         return Response(serializer.data, status=status.HTTP_200_OK)
 76 |     elif request.method == 'POST':
 77 |         serializer = BlogSerializer(data=request.data)
 78 |         if serializer.is_valid():
 79 |             serializer.save()
 80 |             return Response(serializer.data, status=status.HTTP_201_CREATED)
 81 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
 82 | 
 83 | 
 84 | @api_view(['GET', 'PUT', 'DELETE'])
 85 | def blog_detail(request, pk):
 86 |     """API to GET, PUT and DELETE a blogpost."""
 87 |     try:
 88 |         blog = Blog.objects.get(pk=pk)
 89 |     except Blog.DoesNotExist:
 90 |         raise NotFound()
 91 |         # return HttpResponse(status=status.HTTP_404_NOT_FOUND)
 92 | 
 93 |     serializer = BlogSerializer(blog)
 94 |     if request.method == 'GET':
 95 |         return Response(serializer.data, status=status.HTTP_200_OK)
 96 |     elif request.method == 'PUT':
 97 |         serializer = BlogSerializer(blog, data=request.data)
 98 |         if serializer.is_valid():
 99 |             serializer.save()
100 |             return Response(serializer.data, status=status.HTTP_200_OK)
101 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
102 |     elif request.method == 'POST':
103 |         serializer = BlogSerializer(blog, data=request.data)
104 |         if serializer.is_valid():
105 |             serializer.save()
106 |             return Response(serializer.data, status=status.HTTP_201_CREATED)
107 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
108 |     elif request.method == 'DELETE':
109 |         blog.delete()
110 |         return HttpResponse(status=status.HTTP_204_NO_CONTENT)
111 | ```
112 | 
113 | **Class Based API Views of the above FBVs using APIView.**
114 | 
115 | ```python
116 | class BlogAPIView(APIView):
117 |     """Class Based View similar to blog_list FBV above."""
118 | 
119 |     def get(self, request):
120 |         blogs = Blog.objects.all()
121 |         serializer = BlogSerializer(blogs, many=True)
122 |         return Response(serializer.data, status=status.HTTP_200_OK)
123 | 
124 |     def post(self, request):
125 |         serializer = BlogSerializer(data=request.data)
126 |         if serializer.is_valid():
127 |             serializer.save()
128 |             return Response(serializer.data, status=status.HTTP_201_CREATED)
129 |         return Response(serializer.errors,  status=status.HTTP_400_BAD_REQUEST)
130 | 
131 | 
132 | class BlogDetailAPIView(APIView):
133 |     """Class Based View of blog_detail FBV above."""
134 | 
135 |     def get_object(self, pk):
136 |         try:
137 |             blog = Blog.objects.get(pk=pk)
138 |             return blog
139 |         except Blog.DoesNotExist:
140 |             raise NotFound()
141 | 
142 |     def get(self, request, pk):
143 |         blog = self.get_object(pk)
144 |         serializer = BlogSerializer(blog)
145 |         return Response(serializer.data)
146 | 
147 |     def put(self, request, pk):
148 |         blog = self.get_object(pk)
149 |         serializer = BlogSerializer(blog, data=request.data)
150 |         if serializer.is_valid():
151 |             serializer.save()
152 |             return Response(serializer.data, status=status.HTTP_200_OK)
153 |         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
154 | 
155 |     def delete(self, request, pk):
156 |         blog = self.get_object(pk)
157 |         blog.delete()
158 |         return Response(status=status.HTTP_204_NO_CONTENT)
159 | ```
160 | 
161 | #### To use authentications like BasicAuthentication, SessionAuthentication and TokenAuthentication
162 | **Use the below inside the API classes for BasicAuthentication, SessionAuthentication**
163 | 
164 | ```python
165 | # If SessionAuthentication is present that is used else BasicAuthentication will be used - That is why a list.
166 | authentication_classes = [SessionAuthentication, BasicAuthentication]
167 | permission_classes = [IsAuthenticated]
168 | ```
169 | 
170 | ##### Example:
171 | ```python
172 | class BlogGenericAPIView(generics.GenericAPIView, mixins.CreateModelMixin, mixins.ListModelMixin):
173 |     serializer_class = BlogSerializer
174 |     queryset = Blog.objects.all()
175 |     # If SessionAuthentication is present that is used else BasicAuthentication will be used - That is why a list.
176 |     authentication_classes = [SessionAuthentication, BasicAuthentication]
177 |     permission_classes = [IsAuthenticated]
178 | 
179 |     def get(self, request):
180 |         return self.list(request)
181 |     
182 |     def post(self, request):
183 |         return self.create(request)
184 | ```
185 | 
186 | **For TokenAuthentication:**
187 | 
188 | * Add ```rest_framework.authtoken``` to the ```INSTALLED_APPS``` to the ```settings.py``` file.
189 | * Inside the Class Based API Views. Add this
190 |     ```python
191 |         authentication_classes = [TokenAuthentication]
192 |         permission_classes = [IsAuthenticated]
193 |     ```
194 | * Make migrations and this will create a table called ```Tokens``` where the tokens of users will be stored. By default no tokens are created. We must create the tokens explicitly.
195 | * In Postman, Add this ```Token``` as Authorization and only then we can access the API.
196 | 
197 | ##### Example:
198 | ```python
199 | class BlogGenericAPIView(generics.GenericAPIView, mixins.CreateModelMixin, mixins.ListModelMixin):
200 |     serializer_class = BlogSerializer
201 |     queryset = Blog.objects.all()
202 |     
203 |     authentication_classes = [TokenAuthentication]
204 |     permission_classes = [IsAuthenticated]
205 | 
206 |     def get(self, request):
207 |         return self.list(request)
208 |     
209 |     def post(self, request):
210 |         return self.create(request)
211 | ```
212 | 
213 | 
214 | **Class Based API Views (CBV) of the above FBVs using GenericAPIViews.**
215 | 
216 | ```python
217 | class BlogGenericAPIView(generics.GenericAPIView, mixins.CreateModelMixin, mixins.ListModelMixin):
218 |     serializer_class = BlogSerializer
219 |     queryset = Blog.objects.all()
220 | 
221 |     def get(self, request):
222 |         return self.list(request)
223 |     
224 |     def post(self, request):
225 |         return self.create(request)
226 | 
227 | 
228 | class BlogGenericDetailAPIView(generics.GenericAPIView, mixins.ListModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, mixins.RetrieveModelMixin):
229 |     serializer_class = BlogSerializer
230 |     queryset = Blog.objects.all()
231 |     lookup_field = 'pk'
232 | 
233 |     def get(self, request, pk):
234 |         return self.retrieve(request, pk)
235 | 
236 |     def post(self, request):
237 |         return self.create(request)
238 | 
239 |     def put(self, request, pk):
240 |         return self.update(request, pk)
241 | 
242 |     def delete(self, request, pk):
243 |         return self.destroy(request, pk)
244 | ```
245 | 
246 | #### [ModelViewSet](https://www.django-rest-framework.org/api-guide/viewsets/#modelviewset)
247 | 
248 | The ModelViewSet class inherits from GenericAPIView and includes implementations for various actions, by mixing in the behavior of the various mixin classes.
249 | 
250 | The actions provided by the ModelViewSet class are .list(), .retrieve(), .create(), .update(), .partial_update(), and .destroy().
251 | **```views.py```**
252 | 
253 | ```python
254 | class PostsViewSet(viewsets.ModelViewSet):
255 |     serializer_class = ViewPostSerializer
256 |     queryset = Blog.objects.all()
257 | ```
258 | 
259 | **```urls.py```**
260 | 
261 | ```python
262 | router = routers.DefaultRouter()
263 | router.register('post', PostsViewSet, basename='post')
264 | 
265 | urlpatterns = [
266 |     path('viewset/', include(router.urls)),
267 |     path('viewset/<int:pk>/', include(router.urls)),
268 |     ]
269 | ```
270 | 


--------------------------------------------------------------------------------
/blogs/tests/tests_views.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | from django.test import TestCase, Client
  3 | from django.urls import resolve, reverse
  4 | from django.contrib.auth.models import User
  5 | from blogs.models import Blog, Likes_Table, Blog_comments, Notification
  6 | 
  7 | 
  8 | class TestViews(TestCase):
  9 |     """Tests to check the functionality of Views in Blogs application"""
 10 | 
 11 |     def setUp(self):
 12 |         self.client = Client()
 13 |         self.list_url = reverse('index')
 14 |         self.user1 = User.objects.create_user(
 15 |             username='Test', first_name='Testname', last_name='Last', email='test@gmail.com', password='testing@123')
 16 |         self.user2 = User.objects.create_user(
 17 |             username='Test1', first_name='Testname1', last_name='Last1', email='test1@gmail.com', password='testing@123')
 18 |         self.post1 = Blog.objects.create(
 19 |             title='Post1', description='Some content', author=self.user1)
 20 |         self.post2 = Blog.objects.create(
 21 |             title='Post2', description='Some extra content', author=self.user2)
 22 |         self.detail_url = reverse('view_post', args=[self.post1.id, 'post1'])
 23 | 
 24 |     def test_blogs_list_GET(self):
 25 |         response = self.client.get(self.list_url)
 26 |         self.assertEquals(response.status_code, 200)
 27 |         self.assertTemplateUsed(response, 'blogs/index.html')
 28 | 
 29 |     def test_blogs_detail_GET(self):
 30 |         response = self.client.get(self.detail_url)
 31 |         self.assertEquals(response.status_code, 200)
 32 |         self.assertTemplateUsed(response, 'blogs/view_post.html')
 33 | 
 34 |     def test_create_blog_if_not_logged_in_POST(self):
 35 |         response = self.client.post(reverse('create_post'), {
 36 |                                     'title': 'Sample', 'description': 'Some sample description'})
 37 |         self.assertEquals(response.status_code, 302)
 38 |         self.assertRedirects(response, '/login/?next=/create_post/')
 39 | 
 40 |     def test_create_blog_if_logged_in_POST(self):
 41 |         login = self.client.login(username='Test', password='testing@123')
 42 |         self.assertTrue(login)
 43 |         response = self.client.post(reverse('create_post'), {
 44 |                                     'title': 'Sample', 'description': 'Some sample description'})
 45 |         post_id = Blog.objects.last()
 46 |         self.assertRedirects(response, reverse(
 47 |             'view_post', args=[post_id.id, post_id.slug]))
 48 | 
 49 |     def test_vote_up_if_not_logged_in_POST(self):
 50 |         response = self.client.post(reverse('vote_up'), data={
 51 |                                     'post_id': self.post1.id})
 52 |         response_json = json.loads(response.content)
 53 |         self.assertEquals(response.status_code, 200)
 54 |         self.assertEquals(response_json['status'], 'Login Required')
 55 | 
 56 |     def test_vote_up_self_post_if_logged_in_POST(self):
 57 |         login = self.client.login(username='Test', password='testing@123')
 58 |         self.assertTrue(login)
 59 |         response = self.client.post(reverse('vote_up'), data={
 60 |                                     'post_id': self.post1.id})
 61 |         response_json = json.loads(response.content)
 62 |         # print(response_json)
 63 |         self.assertEquals(response.status_code, 200)
 64 |         self.assertEquals(response_json['status'], 'Invalid')
 65 | 
 66 |     def test_vote_up_others_post_if_logged_in_POST(self):
 67 |         login = self.client.login(
 68 |             username=self.user1.username, password='testing@123')
 69 |         self.assertTrue(login)
 70 |         response = self.client.post(reverse('vote_up'), data={
 71 |                                     'post_id': self.post2.id})
 72 |         response_json = json.loads(response.content)
 73 |         # print(response_json)
 74 |         self.assertEquals(response.status_code, 200)
 75 |         self.assertEquals(response_json['status'], 'success')
 76 | 
 77 |     def test_vote_down_if_not_logged_in_POST(self):
 78 |         response = self.client.post(reverse('vote_down'), data={
 79 |                                     'post_id': self.post1.id})
 80 |         response_json = json.loads(response.content)
 81 |         self.assertEquals(response.status_code, 200)
 82 |         self.assertEquals(response_json['status'], 'Login Required')
 83 | 
 84 |     def test_vote_down_self_post_if_logged_in_POST(self):
 85 |         login = self.client.login(username='Test', password='testing@123')
 86 |         self.assertTrue(login)
 87 |         response = self.client.post(reverse('vote_down'), data={
 88 |                                     'post_id': self.post1.id})
 89 |         response_json = json.loads(response.content)
 90 |         # print(response_json)
 91 |         self.assertEquals(response.status_code, 200)
 92 |         self.assertEquals(response_json['status'], 'Invalid')
 93 | 
 94 |     def test_vote_down_others_post_if_logged_in_POST(self):
 95 |         login = self.client.login(
 96 |             username=self.user1.username, password='testing@123')
 97 |         self.assertTrue(login)
 98 |         response = self.client.post(reverse('vote_down'), data={
 99 |                                     'post_id': self.post2.id})
100 |         response_json = json.loads(response.content)
101 |         # print(response_json)
102 |         self.assertEquals(response.status_code, 200)
103 |         self.assertEquals(response_json['status'], 'success')
104 | 
105 |     # Vote up and vote down simultaneously
106 | 
107 |     def test_vote_up_and_vote_down_on_same_post(self):
108 |         login = self.client.login(
109 |             username=self.user1.username, password='testing@123')
110 |         self.assertTrue(login)
111 |         # Upvote
112 |         response = self.client.post(reverse('vote_up'), data={
113 |                                     'post_id': self.post2.id})
114 |         response_json = json.loads(response.content)
115 |         self.assertEquals(response.status_code, 200)
116 |         self.assertEquals(response_json['status'], 'success')
117 | 
118 |         # Downvote
119 |         response = self.client.post(reverse('vote_down'), data={
120 |                                     'post_id': self.post2.id})
121 |         response_json = json.loads(response.content)
122 |         self.assertEquals(response.status_code, 200)
123 |         self.assertEquals(response_json['status'], 'success')
124 | 
125 |     # vote down and vote up simultaneously
126 | 
127 |     def test_vote_down_and_vote_up_on_same_post(self):
128 |         login = self.client.login(
129 |             username=self.user1.username, password='testing@123')
130 |         self.assertTrue(login)
131 |         # Downvote
132 |         response = self.client.post(reverse('vote_down'), data={
133 |                                     'post_id': self.post2.id})
134 |         response_json = json.loads(response.content)
135 |         self.assertEquals(response.status_code, 200)
136 |         self.assertEquals(response_json['status'], 'success')
137 | 
138 |         # Upvote
139 |         response = self.client.post(reverse('vote_up'), data={
140 |                                     'post_id': self.post2.id})
141 |         response_json = json.loads(response.content)
142 |         self.assertEquals(response.status_code, 200)
143 |         self.assertEquals(response_json['status'], 'success')
144 | 
145 |     # Vote up and vote up on same post
146 |     def test_vote_up_multiple_times_on_same_post(self):
147 |         login = self.client.login(
148 |             username=self.user1.username, password='testing@123')
149 |         self.assertTrue(login)
150 |         # Upvote
151 |         response = self.client.post(reverse('vote_up'), data={
152 |                                     'post_id': self.post2.id})
153 |         response_json = json.loads(response.content)
154 |         self.assertEquals(response.status_code, 200)
155 |         self.assertEquals(response_json['status'], 'success')
156 | 
157 |         # Upvote again
158 |         response = self.client.post(reverse('vote_up'), data={
159 |                                     'post_id': self.post2.id})
160 |         response_json = json.loads(response.content)
161 |         self.assertEquals(response.status_code, 200)
162 |         self.assertEquals(response_json['status'], 'Already Upvoted')
163 | 
164 |     # Vote down and vote down on same post
165 | 
166 |     def test_vote_down_multiple_times_on_same_post(self):
167 |         login = self.client.login(
168 |             username=self.user1.username, password='testing@123')
169 |         self.assertTrue(login)
170 |         # Downvote
171 |         response = self.client.post(reverse('vote_down'), data={
172 |                                     'post_id': self.post2.id})
173 |         response_json = json.loads(response.content)
174 |         self.assertEquals(response.status_code, 200)
175 |         self.assertEquals(response_json['status'], 'success')
176 | 
177 |         # Downvote again
178 |         response = self.client.post(reverse('vote_down'), data={
179 |                                     'post_id': self.post2.id})
180 |         response_json = json.loads(response.content)
181 |         self.assertEquals(response.status_code, 200)
182 |         self.assertEquals(response_json['status'], 'Already Downvoted')
183 | 
184 |     def test_search_if_not_logged_in(self):
185 |         response = self.client.get(reverse('search'))
186 |         self.assertEqual(response.status_code, 302)
187 |         self.assertRedirects(response, '/login/?next=/search/')
188 | 
189 |     def test_search_user_if_not_logged_in(self):
190 |         response = self.client.get(reverse('searchUser'))
191 |         self.assertEqual(response.status_code, 302)
192 |         self.assertRedirects(response, '/login/?next=/searchUser/')
193 | 
194 |     def test_search_if_logged_in(self):
195 |         login = self.client.login(
196 |             username=self.user1.username, password='testing@123')
197 |         self.assertTrue(login)
198 |         response = self.client.get(reverse('search'))
199 |         self.assertEqual(response.status_code, 200)
200 |         self.assertTemplateUsed(response, 'blogs/search.html')
201 | 
202 |     def test_search_user_if_logged_in(self):
203 |         login = self.client.login(
204 |             username=self.user1.username, password='testing@123')
205 |         self.assertTrue(login)
206 |         response = self.client.get(reverse('searchUser'))
207 |         self.assertEqual(response.status_code, 200)
208 | 
209 |     def test_notifications_if_not_logged_in(self):
210 |         response = self.client.get(reverse('notifications'))
211 |         self.assertEquals(response.status_code, 302)
212 |         self.assertRedirects(response, '/login/?next=/notifications/')
213 | 
214 |     def test_notifications_if_logged_in(self):
215 |         login = self.client.login(
216 |             username=self.user1.username, password='testing@123')
217 |         self.assertTrue(login)
218 |         response = self.client.get(reverse('notifications'))
219 |         self.assertEquals(response.status_code, 200)
220 |         self.assertTemplateUsed(response, 'blogs/notifications.html')
221 | 


--------------------------------------------------------------------------------
/blogs/static/blogs/script.js:
--------------------------------------------------------------------------------
  1 | $(document).ready(function () {
  2 |     window.setTimeout(function () {
  3 |         $(".alert").fadeTo(500, 0).slideUp(500, function () {
  4 |             $(this).hide();
  5 |         });
  6 |     }, 5000);
  7 | 
  8 | 
  9 |     /* Function to 'Follow' a User. */
 10 |     $('.follow-btn').on('click', function () {
 11 |         username = $('.username_field').text();
 12 |         var current_obj = $(this)
 13 |         //alert(current_obj);
 14 |         $.ajax({
 15 |             type: 'POST',
 16 |             url: '/follow/',
 17 |             data: {
 18 |                 username: username,
 19 |             },
 20 |             success: function (data) {
 21 |                 if (data.status == 'success') {
 22 |                     //alert('Follow Success');
 23 |                     /*current_obj.removeClass('follow-btn');
 24 |                     var following_code = '<i class="fas fa-check-circle"></i>&nbsp;Following';
 25 |                     current_obj.addClass('following-btn');
 26 |                     current_obj.html(following_code);*/
 27 |                     location.reload();
 28 |                 }
 29 |             }
 30 |         });
 31 |     });
 32 | 
 33 |     /* Function to 'Unfollow' a user. */
 34 |     $('.following-btn').on('click', function () {
 35 |         username = $('.username_field').text();
 36 |         //alert(username);
 37 |         $.ajax({
 38 |             type: 'POST',
 39 |             url: '/unfollow/',
 40 |             data: {
 41 |                 username: username,
 42 |             },
 43 |             success: function (data) {
 44 |                 if (data.status == 'success') {
 45 |                     //alert('Unfollow Success');
 46 |                     /*current_obj.removeClass('following-btn');
 47 |                     current_obj.addClass('follow-btn');
 48 |                     var follow_code = '<i class="fas fa-plus"></i>&nbsp;Follow';
 49 |                     current_obj.html(follow_code);*/
 50 |                     location.reload();
 51 |                 }
 52 |             }
 53 |         });
 54 |     });
 55 | 
 56 | 
 57 |     /* Function to send upvote data to server */
 58 |     $(document).on("click", ".vote_up", function () {
 59 |         post_id = $(this).closest('article').attr('id');
 60 |         likes = $("#" + post_id).find("#votes_count").text()
 61 |         //alert('Post Liked: ' + post_id);
 62 |         $.ajax({
 63 |             type: 'POST',
 64 |             url: '/vote_up/',
 65 |             cache: false,
 66 |             data: {
 67 |                 post_id: post_id,
 68 |             },
 69 |             success: function (data) {
 70 |                 //alert(data.status);
 71 |                 if (data.status == 'success') {
 72 |                     likes++;
 73 |                     $("#" + post_id).find("#votes_count").text(likes);
 74 |                     $('#upvote_' + post_id).css('color', '#8bf178');
 75 |                     $('#downvote_' + post_id).css('color', '');
 76 |                 }
 77 |                 else {
 78 |                     if (data.status == 'Invalid') {
 79 |                         alert('You cannot vote on your own post!');
 80 |                     }
 81 |                 }
 82 |             }
 83 |         });
 84 |     });
 85 | 
 86 | 
 87 | 
 88 |     /* Function to send Downvote data to server */
 89 |     $(document).on("click", ".vote_down", function () {
 90 |         post_id = $(this).closest('article').attr('id');
 91 |         likes = $("#" + post_id).find("#votes_count").text()
 92 |         //alert('Post Liked: ' + post_id);
 93 |         $.ajax({
 94 |             type: 'POST',
 95 |             url: '/vote_down/',
 96 |             cache: false,
 97 |             data: {
 98 |                 post_id: post_id,
 99 |             },
100 |             success: function (data) {
101 |                 if (data.status == 'success') {
102 |                     likes--;
103 |                     $("#" + post_id).find("#votes_count").text(likes);
104 |                     $('#downvote_' + post_id).css('color', 'red');
105 |                     $('#upvote_' + post_id).css('color', '');
106 |                 }
107 |                 else {
108 |                     if (data.status == 'Invalid') {
109 |                         alert('You cannot vote on your own post.');
110 |                     }
111 |                 }
112 |             }
113 |         });
114 |     });
115 | 
116 | 
117 |     function refresh_comments(post_id) {
118 |         $.ajax({
119 |             type: 'GET',
120 |             url: '/refresh_comments/',
121 |             data: {
122 |                 post_id: post_id,
123 |             },
124 |             success: function (data) {
125 |                 no_of_comments = data.no_of_comments;
126 |                 if (no_of_comments == 0) {
127 |                     $('.comments').text('No comments yet.');
128 |                 }
129 |                 else if (no_of_comments == 1) {
130 |                     $('.comments').text(no_of_comments + ' Comment');
131 |                 }
132 |                 else {
133 |                     $('.comments').text(no_of_comments + ' Comments');
134 |                 }
135 |                 //alert('Comments Updated.');
136 |             }
137 |         });
138 |     }
139 | 
140 |     /* Script to delete a comment  */
141 |     $(document).on("click", ".delete_comment", function () {
142 |         var result = confirm("Are you sure you want to delete your comment?");
143 |         if (result) {
144 |             comment_id = $(this).closest("li").attr("id");
145 |             post_id = $("article").attr("id");
146 |             //alert('Post: '+ post_id);
147 |             $.ajax({
148 |                 type: 'POST',
149 |                 url: '/delete_comment/',
150 |                 cache: false,
151 |                 data: {
152 |                     comment_id: comment_id,
153 |                 },
154 |                 success: function () {
155 |                     //alert('Success');
156 |                     $("#" + comment_id).hide();
157 |                     refresh_comments(post_id);
158 |                 }
159 |             });
160 |         }
161 |     });
162 | 
163 |     $(function () {
164 | 
165 |         // variable to store the comment text
166 |         var comment;
167 |         /* Function to get the comment ID and the comment text when 'edit' comment is clicked */
168 |         $(document).on("click", ".edit_comment", function () {
169 |             comment_id = $(this).closest("li").attr("id");
170 |             comment = $("#" + comment_id).find("p").text().trim();
171 |             $('.edit_delete').hide();
172 |             //alert(comment);
173 |             $("#" + comment_id).find('.comment_p').html("<textarea class='form-control mb-2 comment_edit_text'>" + comment + "</textarea><a href='#' class='save_edit_btn mr-3'>Save</a><a href='#' class='cancel_edit_btn'>Cancel</a>");
174 |         });
175 | 
176 |         /* Function to putback the comment when edit comment operation is cancelled. 'Cancel' button is clicked */
177 |         $(document).on('click', '.cancel_edit_btn', function () {
178 |             comment_id = $(this).closest("li").attr("id");
179 |             $('.edit_delete').show();
180 |             $("#" + comment_id).find('.comment_p').html('<p class="comment_text">' + comment + '</p>');
181 |         });
182 | 
183 |     });
184 | 
185 | 
186 |     /* Script that runs when comment is edited */
187 |     $(document).on("click", ".save_edit_btn", function () {
188 |         comment_id = $(this).closest("li").attr("id");
189 |         edit_comment = $('.comment_edit_text').val();
190 |         //alert('ID: ' + comment_id + ' Text: ' + edit_comment);
191 |         $.ajax({
192 |             type: 'POST',
193 |             url: '/edit_comment/',
194 |             cache: false,
195 |             data: {
196 |                 comment_id: comment_id,
197 |                 edit_comment: edit_comment,
198 |             },
199 |             success: function () {
200 |                 //alert('success');
201 |                 $('.edit_delete').show();
202 |                 $("#" + comment_id).find('.comment_p').html('<p class="comment_text">' + edit_comment + '</p>');
203 |             }
204 |         });
205 |     });
206 | 
207 | 
208 |     $(document).on("click", ".notification-list", function () {
209 |         n_id = $(this).attr('id');
210 |         //alert(n_id);
211 |         $.ajax({
212 |             type: 'POST',
213 |             url: '/mark_notification_as_read/',
214 |             cache: false,
215 |             data: {
216 |                 n_post_id: n_id,
217 |             },
218 |             success: function () {
219 |                 //alert('Marked as Read.');
220 |             }
221 |         });
222 |     });
223 | 
224 |     $('#noti_Button').click(function () {
225 |         // TOGGLE (SHOW OR HIDE) NOTIFICATION WINDOW.
226 |         $('#notifications').fadeToggle('fast', 'linear', function () {
227 |             if ($('#notifications').is(':hidden')) {
228 |             }
229 |         });
230 | 
231 |         $('#noti_counter').fadeOut('slow');     // HIDE THE COUNTER.
232 | 
233 |         return false;
234 |     });
235 | 
236 |     // HIDE NOTIFICATIONS WHEN CLICKED ANYWHERE ON THE PAGE.
237 |     $(document).click(function () {
238 |         $('#notifications').hide();
239 |     });
240 | 
241 |     /*
242 |     $('#notifications').click(function () {
243 |         return false;       // DO NOTHING WHEN CONTAINER IS CLICKED.
244 |     });*/
245 | 
246 |     $('.index_blog_full_description img').click(function () {
247 |         $("#full-image").attr("src", $(this).attr("src"));
248 |         $('#image-viewer').show();
249 |     });
250 | 
251 | 
252 |     $(".blog_image").click(function () {
253 |         $("#full-image").attr("src", $(this).attr("src"));
254 |         $('#image-viewer').show();
255 |     });
256 | 
257 | 
258 |     $("#image-viewer").on('click', function () {
259 |         $('#image-viewer').hide();
260 |     });
261 | 
262 |     $("#image-viewer .close").click(function () {
263 |         $('#image-viewer').hide();
264 |     });
265 | 
266 | 
267 |     
268 |     /* Search function */
269 | 
270 |     $("#txtSearch").keyup(function () {
271 |         var val = $(this).val();
272 |         //console.log(val);
273 |         $.ajax({
274 |             type: "GET",
275 |             data: { 'uname': val },
276 |             url: '/searchUser/',
277 |             success: function (data) {
278 |                 //console.log(data);
279 | 
280 |                 if (data.results.length > 0) {
281 |                     $('#searchResults').empty();
282 |                     for (var key in data) {
283 |                         for (var val in data[key]) {
284 |                             //console.log(val);
285 |                             var htm = '<img class="rounded-circle round_profile_pics mr-2" src="' + data[key][val].profile_pic + '"></img>'
286 |                             $('#searchResults').append(htm + "<a href='/profile/" + data[key][val].user + "'><h6>" + data[key][val].user + "</h6></a></li>");
287 |                         }
288 |                     }
289 |                 }
290 |             },
291 | 
292 |         });
293 |     });
294 | 
295 | });


--------------------------------------------------------------------------------
/blogs/views.py:
--------------------------------------------------------------------------------
  1 | from users.views import profile
  2 | from django.shortcuts import render, get_object_or_404, redirect
  3 | from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
  4 | import json
  5 | from django.utils import timezone
  6 | from .forms import CommentForm
  7 | # To use messages in Class based views - Use SuccessMessageMixin
  8 | from django.contrib.messages.views import SuccessMessageMixin
  9 | from django.http import HttpResponse, JsonResponse
 10 | from .models import Blog, Likes_Table, Blog_comments, Notification
 11 | from django.contrib.auth.models import User
 12 | from users.models import Profile
 13 | from django.db.models import Count
 14 | from django.contrib import messages
 15 | # Class based View - List, Detail, Create,Update, Delete
 16 | from django.views.generic import (
 17 |     ListView, DetailView, CreateView, UpdateView, DeleteView)
 18 | from django.views.decorators.csrf import csrf_exempt
 19 | from django.contrib.auth.decorators import login_required
 20 | 
 21 | 
 22 | ''' Class Based View - ListView'''
 23 | 
 24 | 
 25 | class PostListView(ListView):
 26 |     model = Blog
 27 |     template_name = 'blogs/index.html'
 28 |     # Will display 4 posts on a page.
 29 |     paginate_by = 4
 30 |     ordering = ['-publish_date']
 31 | 
 32 |     def get_context_data(self, **kwargs):
 33 |         # This function is used to add extra details to context.
 34 |         # Fetching the context details of the PostListView class
 35 |         # will have the queryset - object_list and pagination details like - paginator, page_obj, is_paginated
 36 |         blogs_list = super().get_context_data(**kwargs)
 37 |         # print(blogs_list)
 38 |         # Adding the extra data that we'd like to store in context
 39 |         # context['now'] = timezone.now()
 40 |         # Gets the top 5 visited/Liked posts
 41 |         # NOTE:
 42 |         # blogs_list_top5 = blogs_list['object_list'].order_by('-likes')[:5] will also work provided paginate_by
 43 |         # is NOT set
 44 |         blogs_list_top5 = Blog.objects.order_by('-likes')[:5]
 45 |         blogs_list_top_viewed = Blog.objects.order_by('-views')[:5]
 46 | 
 47 |         # Gets the top 5 authors/contributors
 48 |         # NOTE:
 49 |         # top_authors = Blog.objects.all().values('author').annotate(
 50 |         #    total=Count('author')).order_by('-total')[:5] will also work provided paginate_by is NOT set
 51 |         top_authors = Blog.objects.all().values('author').annotate(
 52 |             total=Count('author')).order_by('-total')[:5]
 53 | 
 54 |         # List to store the top 5 authors usernames
 55 |         authors_list = []
 56 | 
 57 |         # Iterating over the top 5 authors queryset and extracting their usernames
 58 |         for i in top_authors:
 59 |             authors_list.append(User.objects.filter(
 60 |                 id=i['author']).first().username)
 61 | 
 62 |         title = 'Home'
 63 |         context = {
 64 |             'blogs_list': blogs_list,
 65 |             'posts': blogs_list['object_list'],
 66 |             'title': title,
 67 |             'blogs_list_top5': blogs_list_top5,
 68 |             'top_authors': authors_list,
 69 |             'blogs_list_top_viewed': blogs_list_top_viewed,
 70 |         }
 71 |         # If some user is logged in, then get the posts that are upvoted/downvoted by the logged in user
 72 |         # and show the colors appropriately.
 73 |         if self.request.user.is_authenticated:
 74 |             user = self.request.user
 75 |             notification_exists = Notification.objects.filter(
 76 |                 receiver=user, is_read=False).count()
 77 |             vote_qs = Likes_Table.objects.filter(user_id=user.id)
 78 |             votes = {}
 79 |             # Add the {post_id: like_status_id} of every vote by the current logged in user.
 80 |             for i in vote_qs:
 81 |                 votes[i.post_id.id] = i.like_status_id
 82 |             # Adding the votes dictionary to the context
 83 |             context['votes'] = votes
 84 |             context['notification_exists'] = notification_exists
 85 | 
 86 |         # Merging the 'context' dictionary and 'blogs_list' dictionary and sending the context as response
 87 |         # to be used in the template
 88 |         context = {**context, **blogs_list}
 89 |         return context
 90 | 
 91 | 
 92 | class PostDetailView(DetailView):
 93 |     '''Post Detail View'''
 94 |     model = Blog
 95 |     template_name = 'blogs/view_post.html'
 96 | 
 97 |     def get_context_data(self, **kwargs):
 98 |         context = super().get_context_data(**kwargs)
 99 |         blog = self.get_object()
100 |         pk = blog.pk
101 |         # Logic to increment views - If the author of post, views the post then the views are not incremented.
102 |         # if self.request.user.is_authenticated:
103 |         if blog.author != self.request.user:
104 |             view_upd = Blog.objects.filter(pk=pk).first()
105 |             view_upd.views += 1
106 |             view_upd.save()
107 | 
108 |         posts_liked = {}
109 |         title = blog.title
110 |         comments = Blog_comments.objects.filter(
111 |             blogpost=pk).order_by('date_posted')
112 |         no_of_comments = comments.count()
113 |         no_of_likes = Likes_Table.objects.filter(post_id=pk).count()
114 |         context = {
115 |             'blog': blog,
116 |             'title': title,
117 |             'no_of_likes': no_of_likes,
118 |             'comments': comments,
119 |             'no_of_comments': no_of_comments,
120 |         }
121 | 
122 |         if self.request.user.is_authenticated:
123 |             u = self.request.user.likes_table_set.all()
124 |             comment_form = CommentForm(instance=self.request.user)
125 |             for i in u:
126 |                 posts_liked[i.post_id.pk] = i.like_status_id
127 |             # print(posts_liked)
128 |             context['posts_liked'] = posts_liked
129 |             context['comment_form'] = comment_form
130 | 
131 |         return context
132 | 
133 |     # This method saves the contents to Blog_comments table
134 |     def post(self, request, *args, **kwargs):
135 |         new_comment = Blog_comments(content=request.POST.get('content'),
136 |                                     author=self.request.user,
137 |                                     blogpost=self.get_object())
138 |         new_comment.save()
139 |         print('Comment Inserted.')
140 |         # Inserting the Notification details into the Table
141 |         post = self.get_object()
142 |         post_author = post.author
143 |         # Do NOT send any notification if a user has commented on his own post
144 |         if post_author != self.request.user:
145 |             Notification.objects.add_notification(
146 |                 self.request.user, post_author, 'comment', post.pk)
147 | 
148 |         return self.get(self, request, *args, **kwargs)
149 | 
150 | 
151 | # Class Based View to create a post - The HTML file it takes is <app>/<model>_form.html.
152 | # Can be overriden by "template_name" variable. Eg. template_name = 'file.html'
153 | class PostCreateView(SuccessMessageMixin, LoginRequiredMixin, CreateView):
154 |     model = Blog
155 |     fields = ['title', 'description', 'image']
156 |     success_message = 'Post created successfully.'
157 | 
158 |     def form_valid(self, form):
159 |         form.instance.author = self.request.user
160 |         return super().form_valid(form)
161 | 
162 |     def get_context_data(self, **kwargs):
163 |         '''Function to pass the context data to the HTML page. Here I am adding title of the page to context.'''
164 |         context = super().get_context_data(**kwargs)
165 |         context['title'] = 'New Post'
166 |         return context
167 | 
168 | 
169 | # Class based view to Update a post
170 | class PostUpdateView(SuccessMessageMixin, LoginRequiredMixin, UserPassesTestMixin, UpdateView):
171 |     model = Blog
172 |     fields = ['title', 'description', 'image']
173 |     success_message = 'Post Updated successfully.'
174 | 
175 |     def form_valid(self, form):
176 |         form.instance.author = self.request.user
177 |         return super().form_valid(form)
178 | 
179 |     def get_context_data(self, **kwargs):
180 |         '''Function to pass the context data to the HTML page. Here I am adding title of the page to context'''
181 |         context = super().get_context_data(**kwargs)
182 |         context['title'] = 'Update Post'
183 |         return context
184 | 
185 |     # Checks if the post that is to be updated belongs to the current logged user
186 |     def test_func(self):
187 |         post = self.get_object()
188 |         # Checks if the author of post is same as the logged in user
189 |         if self.request.user == post.author:
190 |             return True
191 |         return False
192 | 
193 | 
194 | # Class based view to Delete a post
195 | class PostDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
196 |     model = Blog
197 |     success_url = '/'
198 |     # Checks if the post that is to be deleted belongs to the current logged user
199 | 
200 |     def test_func(self):
201 |         post = self.get_object()
202 |         # Checks if the author of post is same as the logged in user
203 |         if self.request.user == post.author:
204 |             return True
205 |         return False
206 | 
207 |     def get_context_data(self, **kwargs):
208 |         '''Function to pass the context data to the HTML page. Here I am adding title of the page to context'''
209 |         context = super().get_context_data(**kwargs)
210 |         context['title'] = 'Delete Post'
211 |         return context
212 | 
213 | 
214 | # Function based view - Not currently using
215 | def view_post(request, pk):
216 |     # Shows a particular post based on it's PK passed via URL
217 |     blog = get_object_or_404(Blog, pk=pk)
218 |     # Dictionary to store the posts liked by the current logged in user.
219 |     # Stores {<post_id>: <like_status>}
220 |     posts_liked = {}
221 |     title = blog.title
222 |     comments = Blog_comments.objects.filter(
223 |         blogpost=pk).order_by('-date_posted')
224 |     no_of_comments = comments.count()
225 |     no_of_likes = Likes_Table.objects.filter(post_id=pk).count()
226 |     context = {
227 |         'blog': blog,
228 |         'title': title,
229 |         'no_of_likes': no_of_likes,
230 |         'comments': comments,
231 |         'no_of_comments': no_of_comments,
232 |     }
233 | 
234 |     if request.user.is_authenticated:
235 |         u = request.user.likes_table_set.all()
236 |         comment_form = CommentForm(instance=request.user)
237 |         for i in u:
238 |             posts_liked[i.post_id.pk] = i.like_status_id
239 |         # print(posts_liked)
240 |         context['posts_liked'] = posts_liked
241 |         context['comment_form'] = comment_form
242 | 
243 |     return render(request, 'blogs/view_post.html', context)
244 | 
245 | 
246 | @csrf_exempt
247 | # @login_required
248 | def vote_up(request):
249 |     if request.user.is_authenticated and request.method == 'POST':
250 |         post_id = request.POST['post_id']
251 |         post = Blog.objects.get(id=post_id)
252 |         print(f'Post PK: {post.pk}')
253 |         if request.user != post.author:
254 |             # Dictionary to store the posts liked by the current logged in user. Stores {<post_id>: <like_status>}
255 |             posts_liked = {}
256 |             u = request.user.likes_table_set.all()
257 |             for i in u:
258 |                 posts_liked[i.post_id.pk] = i.like_status_id
259 |             print(f'Vote UP: {posts_liked}')
260 | 
261 |             if posts_liked.get(post.pk, None) is False:
262 |                 # If post is already downvoted, then increment the counter and mark like_status as True
263 |                 lt_post = Likes_Table.objects.filter(
264 |                     user_id=request.user, post_id=post.pk).first()
265 |                 lt_post.like_status_id = True
266 |                 lt_post.save()
267 |                 post.likes += 1
268 |                 post.save()
269 |                 return JsonResponse({'status': 'success'})
270 |             elif posts_liked.get(post.pk, None) is True:
271 |                 # if the post is already upvoted by the user, No Action
272 |                 print('User has Already Upvoted the post')
273 |                 return JsonResponse({'status': 'Already Upvoted'})
274 |             else:
275 |                 # If the post is not present in the table, increment the counter and insert record as True
276 |                 lt_post = Likes_Table(
277 |                     user_id=request.user, post_id=post, like_status_id=True)
278 |                 lt_post.save()
279 |                 post.likes += 1
280 |                 post.save()
281 |                 print('Upvote Success. Inserted Record.')
282 |                 return JsonResponse({'status': 'success'})
283 |         else:
284 |             print('You cannot like your own post!')
285 |             return JsonResponse({'status': 'Invalid'})
286 |     else:
287 |         return JsonResponse({'status': 'Login Required'})
288 | 
289 | 
290 | @csrf_exempt
291 | # @login_required
292 | def vote_down(request):
293 |     if request.user.is_authenticated and request.method == 'POST':
294 |         post_id = request.POST['post_id']
295 |         post = Blog.objects.get(id=post_id)
296 | 
297 |         if request.user != post.author:
298 |             # Dictionary to store the posts liked by the current logged in user. Stores {<post_id>: <like_status>}
299 |             posts_unliked = {}
300 |             u = request.user.likes_table_set.all()
301 |             for i in u:
302 |                 posts_unliked[i.post_id.pk] = i.like_status_id
303 |             print(f'Vote Down: {posts_unliked}')
304 | 
305 |             if posts_unliked.get(post.pk, None) is True:
306 |                 # If post is already upvoted, then decrement the counter and mark like_status as False
307 |                 lt_post = Likes_Table.objects.filter(
308 |                     user_id=request.user, post_id=post.pk).first()
309 |                 lt_post.like_status_id = False
310 |                 lt_post.save()
311 |                 post.likes -= 1
312 |                 post.save()
313 |                 return JsonResponse({'status': 'success'})
314 |             elif posts_unliked.get(post.pk, None) is False:
315 |                 # If post is already downvoted, then No Action
316 |                 print('Already Downvoted')
317 |                 return JsonResponse({'status': 'Already Downvoted'})
318 |             else:
319 |                 # If post is not present in table, then decrement counter and insert record as False
320 |                 post.likes -= 1
321 |                 post.save()
322 |                 dlt_post = Likes_Table(
323 |                     user_id=request.user, post_id=post, like_status_id=False)
324 |                 dlt_post.save()
325 |                 print('Downvote Success')
326 |                 return JsonResponse({'status': 'success'})
327 |         else:
328 |             print('You cannot downvote your own post!')
329 |             return JsonResponse({'status': 'Invalid'})
330 |     else:
331 |         return JsonResponse({'status': 'Login Required'})
332 | 
333 | 
334 | @csrf_exempt
335 | def delete_comment(request):
336 |     if request.user.is_authenticated and request.method == 'POST':
337 |         comment_id = request.POST['comment_id']
338 |         Blog_comments.objects.filter(pk=comment_id).delete()
339 |         #print(f'Comment Deleted!')
340 |         return HttpResponse('success')
341 |     else:
342 |         return HttpResponse('Request method is not POST')
343 | 
344 | 
345 | @csrf_exempt
346 | def refresh_comments(request):
347 |     if request.user.is_authenticated and request.method == 'GET':
348 |         blog_id = request.GET.get('post_id')
349 |         no_of_comments = Blog_comments.objects.filter(blogpost=blog_id).count()
350 |         return JsonResponse({'no_of_comments': no_of_comments})
351 |     else:
352 |         return HttpResponse('Request method is not GET')
353 | 
354 | 
355 | @csrf_exempt
356 | def edit_comment(request):
357 |     if request.user.is_authenticated and request.method == 'POST':
358 |         comment_id = request.POST['comment_id']
359 |         edit_comment = request.POST['edit_comment']
360 |         bc = Blog_comments.objects.filter(pk=comment_id).first()
361 |         bc.content = edit_comment
362 |         bc.date_posted = timezone.now()
363 |         bc.save()
364 |         #print('Comment Edit Saved!')
365 |         return HttpResponse('success')
366 |     else:
367 |         return HttpResponse('Request method is not POST')
368 | 
369 | 
370 | @csrf_exempt
371 | @login_required
372 | def notifications(request):
373 |     if request.user.is_authenticated:
374 |         unread_notifs = Notification.objects.get_notification_count(
375 |             request.user)
376 |         read_notifs = Notification.objects.filter(
377 |             receiver=request.user, is_read=True).order_by('-notification_date')
378 |         profile_pics = {}
379 |         for i in read_notifs:
380 |             temp = Profile.objects.filter(
381 |                 user=i.sender).first().profile_pic.url
382 |             if i.sender not in profile_pics:
383 |                 profile_pics[i.sender] = temp
384 | 
385 |         context = {
386 |             'unread_notifications': unread_notifs,
387 |             'notifications_count': len(unread_notifs),
388 |             'read_notifications': read_notifs,
389 |             'profile_imgs': profile_pics,
390 |         }
391 | 
392 |     return render(request, 'blogs/notifications.html', context)
393 | 
394 | 
395 | @csrf_exempt
396 | @login_required
397 | def mark_notification_as_read(request):
398 |     if request.user.is_authenticated:
399 |         notif_id = request.POST['n_post_id']
400 |         Notification.objects.filter(
401 |             receiver=request.user, post_id=notif_id, is_read=False).update(is_read=True)
402 | 
403 |         return JsonResponse({'status': 'success'})
404 | 
405 | 
406 | @login_required
407 | def search(request):
408 |     return render(request, 'blogs/search.html')
409 | 
410 | 
411 | 
412 | @login_required
413 | def searchModel(request):
414 |     if request.method == 'GET':
415 |         search_txt = request.GET.get('uname')
416 |         res = {'results': []}   # {'results': [{'user': 'user1', 'profile_pic': 'image_url'},.,.,]}
417 |         if search_txt:
418 |             suggestions = User.objects.filter(username__icontains=search_txt)
419 |             
420 |             for i in suggestions:
421 |                 temp = {'user': '', 'profile_pic': ''}
422 |                 temp['user'], temp['profile_pic'] = i.username, i.profile.profile_pic.url
423 |                 res['results'].append(temp)
424 |             #print(res)
425 |         #return JsonResponse(res)
426 |         return render(request, 'blogs/search.html', res)
427 |         
428 | 
429 | 
430 | 
431 | ''' Function Based View - Index'''
432 | '''
433 | def index(request):
434 |     # Views the Homepage.
435 |     # Gets all the blogs by all the users
436 |     blogs_list = Blog.objects.order_by('-publish_date')
437 |         
438 |     # Gets the top 5 visited/Liked posts - INCOMPLETE
439 |     blogs_list_top5 = Blog.objects.order_by('-likes')[:5]
440 | 
441 |     # Gets the top 5 authors/contributors
442 |     top_authors = Blog.objects.all().values('author').annotate(
443 |         total=Count('author')).order_by('-total')[:5]
444 |     # List to store the top 5 authors usernames
445 |     authors_list = []
446 |     # Iterating over the top 5 authors queryset and extracting their usernames
447 |     for i in top_authors:
448 |         authors_list.append(User.objects.filter(
449 |             id=i['author']).first().username)
450 | 
451 |     title = 'Home'
452 |     context = {
453 |         'blogs_list': blogs_list,
454 |         'title': title,
455 |         'blogs_list_top5': blogs_list_top5,
456 |         'top_authors': authors_list,
457 |     }
458 |     return render(request, 'blogs/index.html', context)
459 | '''
460 | 


--------------------------------------------------------------------------------