Merge branch 'master' into test-fixes

app/dao/jobs_dao.py

@@ -1,9 +1,24 @@
-from datetime import date, timedelta
-
 from sqlalchemy import desc, cast, Date as sql_date
 from app import db
 from app.dao import days_ago
-from app.models import Job
+from app.models import Job, NotificationHistory
+from app.statsd_decorators import statsd
+from sqlalchemy import func, asc
+
+
+@statsd(namespace="dao")
+def dao_get_notification_outcomes_for_job(service_id, job_id):
+    query = db.session.query(
+        func.count(NotificationHistory.status).label('count'),
+        NotificationHistory.status.label('status')
+    )
+
+    return query \
+        .filter(NotificationHistory.service_id == service_id) \
+        .filter(NotificationHistory.job_id == job_id)\
+        .group_by(NotificationHistory.status) \
+        .order_by(asc(NotificationHistory.status)) \
+        .all()
 
 
 def dao_get_job_by_service_id_and_job_id(service_id, job_id):

app/dao/notifications_dao.py

@@ -7,9 +7,8 @@ from datetime import (
 
 from flask import current_app
 from werkzeug.datastructures import MultiDict
-from sqlalchemy import (desc, func, Integer, or_, and_, asc)
+from sqlalchemy import (desc, func, or_, and_, asc)
 from sqlalchemy.orm import joinedload
-from sqlalchemy.sql.expression import cast
 
 from app import db
 from app.dao import days_ago
@@ -34,31 +33,14 @@ from app.dao.dao_utils import transactional
 from app.statsd_decorators import statsd
 
 
-@statsd(namespace="dao")
-def dao_get_notification_statistics_for_service(service_id, limit_days=None):
-    query_filter = [NotificationStatistics.service_id == service_id]
-    if limit_days is not None:
-        query_filter.append(NotificationStatistics.day >= days_ago(limit_days))
-    return NotificationStatistics.query.filter(
-        *query_filter
-    ).order_by(
-        desc(NotificationStatistics.day)
-    ).all()
-
-
-@statsd(namespace="dao")
 def dao_get_notification_statistics_for_service_and_day(service_id, day):
+    # only used by stat-updating code in tasks.py
     return NotificationStatistics.query.filter_by(
         service_id=service_id,
         day=day
     ).order_by(desc(NotificationStatistics.day)).first()
 
 
-@statsd(namespace="dao")
-def dao_get_notification_statistics_for_day(day):
-    return NotificationStatistics.query.filter_by(day=day).all()
-
-
 @statsd(namespace="dao")
 def dao_get_potential_notification_statistics_for_day(day):
     all_services = db.session.query(
@@ -107,37 +89,8 @@ def create_notification_statistics_dict(service_id, day):
     }
 
 
-@statsd(namespace="dao")
-def dao_get_7_day_agg_notification_statistics_for_service(service_id,
-                                                          date_from,
-                                                          week_count=52):
-    doy = date_from.timetuple().tm_yday
-    return db.session.query(
-        cast(func.floor((func.extract('doy', NotificationStatistics.day) - doy) / 7), Integer),
-        cast(func.sum(NotificationStatistics.emails_requested), Integer),
-        cast(func.sum(NotificationStatistics.emails_delivered), Integer),
-        cast(func.sum(NotificationStatistics.emails_failed), Integer),
-        cast(func.sum(NotificationStatistics.sms_requested), Integer),
-        cast(func.sum(NotificationStatistics.sms_delivered), Integer),
-        cast(func.sum(NotificationStatistics.sms_failed), Integer)
-    ).filter(
-        NotificationStatistics.service_id == service_id
-    ).filter(
-        NotificationStatistics.day >= date_from
-    ).filter(
-        NotificationStatistics.day < date_from + timedelta(days=7 * week_count)
-    ).group_by(
-        func.floor(((func.extract('doy', NotificationStatistics.day) - doy) / 7))
-    ).order_by(
-        desc(func.floor(((func.extract('doy', NotificationStatistics.day) - doy) / 7)))
-    ).limit(
-        week_count
-    )
-
-
 @statsd(namespace="dao")
 def dao_get_template_usage(service_id, limit_days=None):
-
     table = NotificationHistory
 
     if limit_days and limit_days <= 7:  # can get this data from notifications table
@@ -155,28 +108,18 @@ def dao_get_template_usage(service_id, limit_days=None):
         query_filter.append(table.created_at >= days_ago(limit_days))
 
     return query.filter(*query_filter) \
-        .join(Template)\
-        .group_by(table.template_id, Template.name, Template.template_type)\
-        .order_by(asc(Template.name))\
+        .join(Template) \
+        .group_by(table.template_id, Template.name, Template.template_type) \
+        .order_by(asc(Template.name)) \
         .all()
 
 
 @statsd(namespace="dao")
-def dao_get_template_statistics_for_service(service_id, limit_days=None):
-    query_filter = [TemplateStatistics.service_id == service_id]
-    if limit_days is not None:
-        query_filter.append(TemplateStatistics.day >= days_ago(limit_days))
-    return TemplateStatistics.query.filter(*query_filter).order_by(
-        desc(TemplateStatistics.updated_at)).all()
-
-
-@statsd(namespace="dao")
-def dao_get_template_statistics_for_template(template_id):
-    return TemplateStatistics.query.filter(
-        TemplateStatistics.template_id == template_id
-    ).order_by(
-        desc(TemplateStatistics.updated_at)
-    ).all()
+def dao_get_last_template_usage(template_id):
+    return NotificationHistory.query.filter(NotificationHistory.template_id == template_id)\
+        .join(Template) \
+        .order_by(desc(NotificationHistory.created_at)) \
+        .first()
 
 
 @statsd(namespace="dao")

app/dao/services_dao.py

@@ -180,3 +180,25 @@ def dao_fetch_weekly_historical_stats_for_service(service_id):
     ).order_by(
         asc(monday_of_notification_week), NotificationHistory.status
     ).all()
+
+
+@statsd(namespace='dao')
+def dao_fetch_todays_stats_for_all_services():
+    return db.session.query(
+        Notification.notification_type,
+        Notification.status,
+        Notification.service_id,
+        func.count(Notification.id).label('count')
+    ).select_from(
+        Service
+    ).join(
+        Notification
+    ).filter(
+        func.date(Notification.created_at) == date.today()
+    ).group_by(
+        Notification.notification_type,
+        Notification.status,
+        Notification.service_id
+    ).order_by(
+        Notification.service_id
+    )