Added badge for number of seums for each counter, beautified code

counter/templates/counterTemplate.html

 {% extends 'baseTemplate.html' %} {% block title %}{{counter.trigramme}}{% endblock %} {% block content %}
 <div class="text-center">
-  <h1>{{counter.trigramme}} <small>{{ counter.name }}</small></h1>
+  <h1>
+      {{counter.trigramme}} <small>{{ counter.name }}</small>
+  </h1>
 </div>
 <div class="container-fluid">
   <div class="row">
     <div class="col-md-3">
       <div class="panel panel-primary">
         <div class="panel-heading">
-          <h2 class="panel-title">Dernier seum</h2>
+          <h2 class="panel-title">Dernier seum {% if not counter.lastReset.noSeum %}<span class="badge pull-right">{{ counter.seumCount }}</span>{% endif %}</h2>
         </div>
         <div class="seum-counter panel-body">
           {% if counter.lastReset.noSeum %}

counter/templates/homeTemplate.html

 		<div class="col-md-4 col-sm-6 col-lg-3">
 			<div class="panel panel-{{counter.CSSclass}}" style="opacity:{{counter.opacity}}">
 				<div class="panel-heading">
-					<a class="counter-link" href="{% url 'counter' id_counter=counter.id %}"><h2 class="panel-title">{{ counter.trigramme }} <small>{{ counter.name }}</small></h2></a>
+					<a class="counter-link" href="{% url 'counter' id_counter=counter.id %}">
+						<h2 class="panel-title">{{ counter.trigramme }} <small>{{ counter.name }}</small>
+							{% if not counter.lastReset.noSeum %}<span class="pull-right badge">{{ counter.seumCount }}</span>{% endif %}
+						</h2>
+					</a>
 				</div>
 				<div class="seum-counter panel-body">
 					{% if counter.lastReset.noSeum %}
 					<div class="text-center text-muted">
 						<p>Personne n'a le seum...</p>
 					</div>
-					{% else %}
-					{{ col_chart.as_html }}
-					{% endif %}
+					{% else %} {{ col_chart.as_html }} {% endif %}
 				</div>
 			</div>
 		</div>
 					<div class="text-center text-muted">
 						<p>Pas de seum dans les dernières 24 heures...</p>
 					</div>
-					{% else %}
-					{{ line_chart.as_html }}
-					{% endif %}
+					{% else %} {{ line_chart.as_html }} {% endif %}
 				</div>
 			</div>
 		</div>

counter/views.py

 from django.shortcuts import render
-from counter.models import Counter,Reset
+from counter.models import Counter, Reset
 from babel.dates import format_timedelta, format_datetime
-from datetime import datetime,timedelta
+from datetime import datetime, timedelta
 from django import forms
 from django.http import HttpResponseRedirect
 from django.core import serializers
 import math
 from django.utils import timezone
 
+
 class resetCounterForm(forms.ModelForm):
+
     class Meta:
         model = Reset
-        fields = ['reason','counter']
+        fields = ['reason', 'counter']
+
 
 def home(request):
-    #JSS above this limit will not be displayed on the col graph
+    # JSS above this limit will not be displayed on the col graph
     JSS_limit = 7
-    #Display counters
+    # Display counters
     counters = Counter.objects.all()
     lastResets = []
-    #Calculates infos for each counter
+    # Calculates infos for each counter
     maxJSS = 0
     timezero = timedelta(0)
     for counter in counters:
-        lastReset = Reset.objects.filter(counter=counter).order_by('-timestamp')
+        lastReset = Reset.objects.filter(
+            counter=counter).order_by('-timestamp')
         if (lastReset.count() == 0):
+            # This person never had the seum
             counter.lastReset = Reset()
             counter.lastReset.delta = timezero
             counter.lastReset.noSeum = True
         else:
             counter.lastReset = lastReset[0]
             counter.lastReset.noSeum = False
-            counter.lastReset.delta = datetime.now()-counter.lastReset.timestamp.replace(tzinfo=None)
-            if ((counter.lastReset.delta.total_seconds())/(24*3600)<JSS_limit):
-                #If more thant 7 JSS do not display on graph
-                lastResets.append([counter.trigramme,{'v' : (counter.lastReset.delta.total_seconds())/(24*3600), 'f' : str(round((counter.lastReset.delta.total_seconds())/(24*3600),1))} ])
-                counter.CSSclass = "primary"
-                if (counter.lastReset.delta.total_seconds())/(24*3600) > maxJSS:
-                    maxJSS = (counter.lastReset.delta.total_seconds())/(24*3600)
-            else:
-                counter.CSSclass = "primary"
-            counter.opacity = 0.3 + 0.7*math.exp(-(counter.lastReset.delta.total_seconds())/(7*24*3600))
-        counter.lastReset.formatted_delta = format_timedelta(counter.lastReset.delta,locale='fr',threshold=1)
+            counter.lastReset.delta = datetime.now(
+            ) - counter.lastReset.timestamp.replace(tzinfo=None)
+            if ((counter.lastReset.delta.total_seconds()) / (24 * 3600) <
+                    JSS_limit):
+                # Less than 7 JSS -> display on graph
+                lastResets.append(
+                    [counter.trigramme,
+                     {'v': (counter.lastReset.delta.total_seconds()) /
+                      (24 * 3600),
+                      'f': str(round(
+                          (counter.lastReset.delta.total_seconds()) /
+                          (24 * 3600), 1))}])
+                # Updating the max JSS displayed on the graph to compute scale
+                if (counter.lastReset.delta.total_seconds() / (24 * 3600) >
+                        maxJSS):
+                    maxJSS = (counter.lastReset.delta.total_seconds() /
+                              (24 * 3600))
+            # Defining CSS attributes for the counter
+            counter.CSSclass = "primary"
+            counter.opacity = 0.3 + 0.7 * \
+                math.exp(-(counter.lastReset.delta.total_seconds()) /
+                         (7 * 24 * 3600))
+            # Computing the total number of resets for this counter
+            counter.seumCount = Reset.objects.filter(
+                counter=counter).count()
+        counter.lastReset.formatted_delta = format_timedelta(
+            counter.lastReset.delta, locale='fr', threshold=1)
         counter.isHidden = "hidden"
-    counters = sorted(counters,key=lambda t: t.lastReset.delta)
-    #Column graph
-    if (len(lastResets) ==0):
+    counters = sorted(counters, key=lambda t: t.lastReset.delta)
+    # Column graph
+    if (len(lastResets) == 0):
         noGraph = True
         col_chart = None
     else:
         noGraph = False
         lastResets.sort(key=lambda x: x[1]['v'])
-        lastResets.insert(0,['Trigramme','Jours sans seum'])
+        lastResets.insert(0, ['Trigramme', 'Jours sans seum'])
         col_data = SimpleDataSource(lastResets)
-        col_chart = gchart.ColumnChart(col_data,options={
-            'title' : '',
-            'legend' : 'none',
-            'vAxis' : {
-                'viewWindow' : {
-                    'max' : max(maxJSS,1) ,
-                    'min' : 0
-                    },
-                'ticks' : [1,2,3,4,5,6,7],
-                'title' : 'Jours sans seum'
+        col_chart = gchart.ColumnChart(col_data, options={
+            'title': '',
+            'legend': 'none',
+            'vAxis': {
+                'viewWindow': {
+                    'max': max(maxJSS, 1),
+                    'min': 0
                 },
-            'hAxis' : {'title' : 'Trigramme' },
+                'ticks': [1, 2, 3, 4, 5, 6, 7],
+                'title': 'Jours sans seum'
+            },
+            'hAxis': {'title': 'Trigramme'},
         })
 
-    ###Timeline graph
-    #Data pre-processing
-    resets = Reset.objects.filter(timestamp__gte=timezone.now() - timedelta(days=1))
+    # Timeline graph
+    # Data pre-processing
+    resets = Reset.objects.filter(
+        timestamp__gte=timezone.now() - timedelta(days=1))
     if (resets.count() == 0):
         noTimeline = True
         line_chart = None
     else:
         noTimeline = False
         for reset in resets:
-            reset.timestamp={
-                'v' : reset.timestamp.timestamp(),
-                'f' : "Il y a "+format_timedelta(datetime.now()-reset.timestamp.replace(tzinfo=None),locale='fr',threshold=1)
-                }
-            reset.Seum={'v' : 0, 'f' : reset.counter.trigramme+" : "+reset.reason}
-            #Drawing the graph
-        line_data = ModelDataSource(resets,fields=['timestamp','Seum'])
+            reset.timestamp = {
+                'v': reset.timestamp.timestamp(),
+                'f': "Il y a " + format_timedelta(datetime.now() -
+                                                  reset.timestamp.replace(
+                                                      tzinfo=None),
+                                                  locale='fr', threshold=1)
+            }
+            reset.Seum = {
+                'v': 0, 'f': reset.counter.trigramme + " : " + reset.reason}
+        # Drawing the graph
+        line_data = ModelDataSource(resets, fields=['timestamp', 'Seum'])
         line_chart = gchart.LineChart(line_data, options={
-            'lineWidth' : 0,
-            'pointSize' : 10,
-            'title' : '',
-            'vAxis' : { 'ticks' : []},
-            'hAxis' : {
-                'ticks' : [
-                        {'v' : (datetime.now() - timedelta(days=1)).timestamp(), 'f' : 'Il y a 24 h' },
-                        { 'v' :datetime.now().timestamp(), 'f' : 'Présent'}
-                    ]
-                },
-            'legend' : 'none',
-            'height' : 90
-            })
-
-    return render(request,'homeTemplate.html', {
-        'counters' : counters,
-        'col_chart' : col_chart,
-        'line_chart' : line_chart,
-        'noTimeline' : noTimeline,
-        'noGraph' : noGraph
+            'lineWidth': 0,
+            'pointSize': 10,
+            'title': '',
+            'vAxis': {'ticks': []},
+            'hAxis': {
+                'ticks': [
+                    {'v': (datetime.now() - timedelta(days=1)
+                           ).timestamp(), 'f': 'Il y a 24 h'},
+                    {'v': datetime.now().timestamp(), 'f': 'Présent'}
+                ]
+            },
+            'legend': 'none',
+            'height': 90
         })
 
+    return render(request, 'homeTemplate.html', {
+        'counters': counters,
+        'col_chart': col_chart,
+        'line_chart': line_chart,
+        'noTimeline': noTimeline,
+        'noGraph': noGraph
+    })
+
+
 def resetCounter(request):
-    #Update Form counter
+    # Update Form counter
     if (request.method == 'POST'):
         # create a form instance and populate it with data from the request:
         data = dict(request.POST)
-        counter =  Counter.objects.get(pk=int(data['counter'][0]))
+        counter = Counter.objects.get(pk=int(data['counter'][0]))
         reset = Reset()
         reset.counter = counter
         reset.reason = data['reason'][0]
         reset.timestamp = datetime.now()
         reset.save()
-        emails = [u[0] for u in Counter.objects.all().values_list('email') if u[0] != 'null@localhost']
-        #Now send emails to everyone
-        email_to_send = EmailMessage( counter.name+' a le seum', data['reason'][0]+'''
+        # We send the emails only to those who have an email address
+        emails = [u[0] for u in Counter.objects.all().values_list('email')
+                  if u[0] != 'null@localhost']
+        # Now send emails to everyone
+        email_to_send = EmailMessage(counter.name + ' a le seum',
+                                     data['reason'][0] + '''
 
 --
 SeumBook™ - http://seum.merigoux.ovh
 
 P.S. : Pour ne plus recevoir ces messages, envoie un mail à denis.merigoux@gmail.com''',
-        'SeumMan <seum@merigoux.ovh>', emails,[],reply_to=emails)
+                                     'SeumMan <seum@merigoux.ovh>', emails, [],
+                                     reply_to=emails)
     email_to_send.send()
 
     return HttpResponseRedirect(data['redirect'][0])
 
+
 def counter(request, id_counter):
 
     counter = Counter.objects.get(pk=id_counter)
     resets = Reset.objects.filter(counter=counter).order_by('-timestamp')
     timezero = timedelta(0)
-    #Display
+    # Display
     if (resets.count() == 0):
         counter.lastReset = Reset()
         counter.lastReset.delta = timezero
     else:
         counter.lastReset = resets[0]
         counter.lastReset.noSeum = False
-        counter.lastReset.delta = datetime.now()-counter.lastReset.timestamp.replace(tzinfo=None)
-        counter.lastReset.formatted_delta = format_timedelta(counter.lastReset.delta,locale='fr',threshold=1)
+        counter.lastReset.delta = datetime.now(
+        ) - counter.lastReset.timestamp.replace(tzinfo=None)
+        counter.lastReset.formatted_delta = format_timedelta(
+            counter.lastReset.delta, locale='fr', threshold=1)
+        counter.seumCount = Reset.objects.filter(
+            counter=counter).count()
 
     for reset in resets:
-        reset.date = format_datetime(reset.timestamp,locale='fr',format="EEEE dd MMMM Y 'à' HH:mm:ss").capitalize()
-    ###Timeline graph
-    #Data pre-processing
-    resets_graph=resets
+        reset.date = format_datetime(
+            reset.timestamp, locale='fr',
+            format="EEEE dd MMMM Y 'à' HH:mm:ss").capitalize()
+    # Timeline graph
+    # Data pre-processing
+    resets_graph = resets
     for reset in resets_graph:
-        reset.timestamp={'v' : reset.timestamp.timestamp(), 'f' : "Il y a "+format_timedelta(datetime.now()-reset.timestamp.replace(tzinfo=None),locale='fr',threshold=1) }
-        reset.Seum={'v' : 0, 'f' : reset.reason}
-    #Drawing the graph
-    data = ModelDataSource(resets,fields=['timestamp','Seum'])
+        reset.timestamp = {
+            'v': reset.timestamp.timestamp(),
+            'f': "Il y a " + format_timedelta(
+                datetime.now() - reset.timestamp.replace(tzinfo=None),
+                locale='fr', threshold=1)
+        }
+        reset.Seum = {'v': 0, 'f': reset.reason}
+    # Drawing the graph
+    data = ModelDataSource(resets, fields=['timestamp', 'Seum'])
     chart = gchart.LineChart(data, options={
-        'lineWidth' : 0,
-        'pointSize' : 10,
-        'title' : '',
-        'vAxis' : { 'ticks' : []},
-        'hAxis' : {'ticks' : [{'v' : datetime(2016,3,9,23,0,0,0).timestamp(), 'f' : 'ADD des X2013' }, { 'v' :datetime.now().timestamp(), 'f' : 'Présent'}]},
-        'legend' : 'none',
-        'height' : 90
+        'lineWidth': 0,
+        'pointSize': 10,
+        'title': '',
+        'vAxis': {'ticks': []},
+        'hAxis': {'ticks': [{
+            'v': datetime(2016, 3, 9, 23, 0, 0, 0).timestamp(),
+            'f': 'ADD des X2013'
+        }, {
+            'v': datetime.now().timestamp(),
+            'f': 'Présent'}
+        ]},
+        'legend': 'none',
+        'height': 90
     })
 
-    return render(request,'counterTemplate.html', { 'counter' : counter, 'chart' : chart, 'resets' : resets })
+    return render(request, 'counterTemplate.html', {'counter': counter, 'chart': chart, 'resets': resets})