added celery and tasks but most important added tag_list

application/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import absolute_import, unicode_literals
+# This will make sure celery is always imported when
+# Django starts so that shared_task will use this app.
+from .celeryapp import app as celery_app
+__all__ = ['celery_app']

application/admin.py

@@ -4,6 +4,8 @@ from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
 from django.contrib.auth.models import User
 
 from .models import Post, CustomUser
+from .models import ScheduledReport, ReportRecipient, ScheduledReportGroup
+from .forms import ScheduledReportForm
 
 
 class CustomUserInline(admin.StackedInline):
@@ -20,3 +22,43 @@ admin.site.unregister(User)
 admin.site.register(User, UserAdmin)
 
 admin.site.register(Post)
+
+
+class ReportRecipientAdmin(admin.TabularInline):
+    model = ReportRecipient
+class ScheduledReportAdmin(admin.ModelAdmin):
+    """
+        List display for Scheduled reports in Django admin
+    """
+    model = ScheduledReport
+    list_display = ('id', 'get_recipients')
+    inlines = [
+        ReportRecipientAdmin
+    ]
+    form = ScheduledReportForm
+    def get_recipients(self, model):
+        recipients = model.reportrecep.all().values_list('email', flat=True)
+        if not recipients:
+            return 'No recipients added'
+        recipient_list = ''
+        for recipient in recipients:
+            recipient_list = recipient_list + recipient + ', '
+        return recipient_list[:-2]
+    get_recipients.short_description = 'Recipients'
+    get_recipients.allow_tags = True
+class ScheduledReportGroupAdmin(admin.ModelAdmin):
+    """
+        List display for ScheduledReportGroup Admin
+    """
+    model = ScheduledReportGroup
+    list_display = ('get_scheduled_report_name','get_report_name')
+    def get_scheduled_report_name(self, model):
+        return model.scheduled_report.subject
+    def get_report_name(self, model):
+        return model.report.name
+    get_scheduled_report_name.short_description = "Scheduled Report Name"
+    get_report_name.short_description = "Report Name"
+    show_change_link = True
+    get_report_name.allow_tags = True
+admin.site.register(ScheduledReport, ScheduledReportAdmin)
+admin.site.register(ScheduledReportGroup, ScheduledReportGroupAdmin)

application/celeryapp.py

@@ -0,0 +1,13 @@
+from __future__ import absolute_import
+import os
+from celery import Celery
+# set the default Django settings module for the 'celery' program.
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'application.settings')
+from django.conf import settings
+
+app = Celery('application')
+# Using a string here means the worker don't have to serialize
+# the configuration object to child processes.
+app.config_from_object('django.conf:settings')
+# Load task modules from all registered Django app configs.
+app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)

application/email_service.py

@@ -0,0 +1,57 @@
+from datetime import datetime, timedelta
+from django.core.mail import send_mail
+from django.template import Template, Context
+from django.http import HttpResponse
+from django.conf import settings
+from .models import ScheduledReport, ScheduledReportGroup, ReportRecipient
+class ScheduledReportConfig(object):
+    def __init__(self, scheduled_report):
+        """
+            Expects a scheduled report object and inititializes
+            its own scheduled_report attribute with it
+        """
+        self.scheduled_report = scheduled_report
+    def get_report_config(self):
+        """
+            Returns the configuration related to a scheduled report, needed
+            to populate the email
+        """
+        return {
+                "template_context": self._get_related_reports_data(),
+                "recipients": self._get_report_recipients()
+                }
+    def _get_related_reports_data(self):
+        """
+            Returns the list of reports data which needs to be sent out in a scheduled report
+        """
+        pass
+    def _get_report_recipients(self):
+        """
+            Returns the recipient list for a scheduled report
+        """
+        pass
+def create_email_data(content=None):
+    content = '''
+            
+        
+         ''' + str(content) + ''''''
+    return content
+def send_emails():
+        current_time = datetime.utcnow()
+        scheduled_reports = ScheduledReport.objects.filter(next_run_at__lt = current_time)
+        for scheduled_report in scheduled_reports:
+            report_config = ScheduledReportConfig(scheduled_report).get_report_config()
+            """ Specify the template path you want to send out in the email. """
+            template = Template(create_email_data('path/to/your/email_template.html'))
+            """ //Create your email html using Django's context processor """
+            report_template = template.render(Context(report_config['template_context']))
+            scheduled_report.save()
+            if not scheduled_report.subject:
+               """  Handle exception for subject not provided """
+            if not report_config['recipients']:
+                """ Handle exception for recipients not provided """
+            send_mail(
+                scheduled_report.subject, 'Here is the message.',
+                settings.EMAIL_HOST_USER, report_config['recipients'],
+                fail_silently=False, html_message=report_template
+            )

application/forms.py

@@ -1,8 +1,16 @@
 from django import forms
+from datetime import datetime
+
 from .models import Post, CustomUser
+from django.forms import ModelForm, ValidationError
 from taggit.forms import *
 from django.contrib.auth.forms import UserCreationForm, UserChangeForm
 
+from datetime import datetime
+from croniter import croniter
+from django.forms import ModelForm, ValidationError
+from .models import ScheduledReport
+
 class PostForm(forms.ModelForm):
     class Meta:
         model = Post
@@ -13,3 +21,27 @@ class NewTagForm(forms.ModelForm):
     class Meta:
         model = CustomUser
         fields = ['m_tags']
+
+
+class ScheduledReportForm(ModelForm):
+    class Meta:
+        model = ScheduledReport
+        fields = ['subject', 'cron_expression']
+        fields = ['subject', 'cron_expression']
+        help_texts = {'cron_expression': 'Scheduled time is considered in UTC'}
+    def clean(self):
+        cleaned_data = super(ScheduledReportForm, self).clean()
+        cron_expression = cleaned_data.get("cron_expression")
+        try:
+            iter = croniter(cron_expression, datetime.now())
+        except:
+            raise ValidationError("Incorrect cron expression:\
+            The information you must include is (in order of appearance):\
+            A number (or list of numbers, or range of numbers), m, representing the minute of the hour\
+            A number (or list of numbers, or range of numbers), h, representing the hour of the day\
+            A number (or list of numbers, or range of numbers), dom, representing the day of the month\
+            A number (or list, or range), or name (or list of names), mon, representing the month of the year\
+            A number (or list, or range), or name (or list of names), dow, representing the day of the week\
+            The asterisks (*) in our entry tell cron that for that unit of time, the job should be run every.\
+            Eg. */5 * * * * cron for executing every 5 mins")
+        return cleaned_data

application/migrations/0006_auto_20181021_1347.py

@@ -0,0 +1,51 @@
+# Generated by Django 2.1 on 2018-10-21 11:47
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('application', '0005_auto_20181019_1645'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Report',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('report_text', models.TextField()),
+            ],
+        ),
+        migrations.CreateModel(
+            name='ReportRecipient',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('email', models.EmailField(max_length=254)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='ScheduledReport',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('subject', models.CharField(max_length=200)),
+                ('last_run_at', models.DateTimeField(blank=True, null=True)),
+                ('next_run_at', models.DateTimeField(blank=True, null=True)),
+                ('cron_expression', models.CharField(max_length=200)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='ScheduledReportGroup',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('report', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='report', to='application.Report')),
+                ('scheduled_report', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='relatedscheduledreport', to='application.ScheduledReport')),
+            ],
+        ),
+        migrations.AddField(
+            model_name='reportrecipient',
+            name='scheduled_report',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reportrecep', to='application.ScheduledReport'),
+        ),
+    ]

application/models.py

@@ -2,6 +2,9 @@ from django.db import models
 from django.contrib.auth.models import User
 from django.utils import timezone
 from taggit.managers import TaggableManager
+from datetime import datetime
+from croniter import croniter
+
 
 
 class CustomUser(models.Model):
@@ -24,3 +27,39 @@ class Post(models.Model):
 
     def __str__(self):
         return self.title
+
+class Report(models.Model):
+    report_text = models.TextField()
+
+class ScheduledReport(models.Model):
+    """
+        Contains email subject and cron expression,to evaluate when the email has to be sent
+    """
+    subject = models.CharField(max_length=200)
+    last_run_at = models.DateTimeField(null=True, blank=True)
+    next_run_at = models.DateTimeField(null=True, blank=True)
+    cron_expression = models.CharField(max_length=200)
+    def save(self, *args, **kwargs):
+        """
+        function to evaluate "next_run_at" using the cron expression, so that it is updated once the report is sent.
+        """
+        self.last_run_at = datetime.now()
+        iter = croniter(self.cron_expression, self.last_run_at)
+        self.next_run_at = iter.get_next(datetime)
+        super(ScheduledReport, self).save(*args, **kwargs)
+    def __unicode__(self):
+        return self.subject
+
+class ScheduledReportGroup(models.Model):
+    """
+        Many to many mapping between reports which will be sent out in a scheduled report
+    """
+    report = models.ForeignKey(Report, related_name='report', on_delete=models.CASCADE)
+    scheduled_report = models.ForeignKey(ScheduledReport,
+                               related_name='relatedscheduledreport', on_delete=models.CASCADE)
+class ReportRecipient(models.Model):
+    """
+        Stores all the recipients of the given scheduled report
+    """
+    email = models.EmailField()
+    scheduled_report = models.ForeignKey(ScheduledReport, related_name='reportrecep', on_delete=models.CASCADE)

application/tasks.py

@@ -0,0 +1,7 @@
+from celery.task.schedules import crontab
+from celery.decorators import periodic_task
+from .email_service import send_emails
+# this will run every minute, see http://celeryproject.org/docs/reference/celery.task.schedules.html#celery.task.schedules.crontab
+@periodic_task(run_every=crontab(hour="*", minute="*", day_of_week="*"))
+def trigger_emails():
+    send_emails()

application/templates/tag_list.html

@@ -1,23 +1,24 @@
-{% extends "base.html" %} {% block content %} {% load taggit_templatetags2_tags %} 
+{% extends "base.html" %} {% block content %}
 
-
-<div id="">
-    Your tags:
-    <ul>
-        {% for tag in users %}
-        <li>
-        </li>
-        {% endfor %}
-    </ul>
+<div>
 </div>
 <div>
-    {{ u }} {{ arr }}
-</div>
-<div>
-     from List: {% for tag in tags %} 
-
-     {% for tag in posts %}
-    <p>{{ tag.name }} </p>{% endfor %}{% endfor %}
+{% for post in posts %}
+    <div class="post">
+        <div class="date">
+            {{ post.published_date }}
+        </div>
+        <h1>
+            <a href="{% url 'post_detail' pk=post.pk %}">{{ post.title }}</a>
+        </h1>
+        <p>{{ post.text|linebreaks }}</p>
+        Tags: {% for tag in post.tags.all %}
+        <a href="{% url 'post_list_by_tag' tag.slug %}">{{ tag.name }}</a>
+        {% if not forloop.last %}, {% endif %} {% endfor %} <p>
+            {{ post.author }}
+        </p>
+    </div>
 
+  {% endfor %}
 </div>
 {% endblock %}

application/views.py

@@ -146,13 +146,15 @@ def student_page(request):
 @login_required
 def tag_list(request):
     log = logging.getLogger('mysite')
-    u = CustomUser.objects.get(user=request.user)
-    log.info(u)
-    tags = Tag.objects.filter(customuser__user = u)
-    log.info(tags)
+    u = User.objects.get(username=request.user)
+    if u:
+        tags_user = Tag.objects.filter(customuser__user = u)
+        log.info(tags_user)
     arr = []
-    for tag in tags:
+    for tag in tags_user:
         arr.append(str(tag))
+        log.info(tag)
+        posts = Post.objects.filter(tags__in=[tag]).order_by('-published_date')
     return render(request, 'tag_list.html', locals())
 
 class TagSearch(TagCanvasListView):