Merge branch 'master' into primary-provider

Conflicts:
	app/dao/notifications_dao.py
	app/dao/provider_statistics_dao.py
	app/schemas.py
	tests/app/conftest.py

app/dao/notifications_dao.py

@@ -1,4 +1,5 @@
-from sqlalchemy import desc, func
+from sqlalchemy import (desc, func, Integer)
+from sqlalchemy.sql.expression import cast
 
 from datetime import (
     datetime,
@@ -50,6 +51,33 @@ def dao_get_notification_statistics_for_service_and_day(service_id, day):
     ).order_by(desc(NotificationStatistics.day)).first()
 
 
+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
+    )
+
+
 def dao_get_template_statistics_for_service(service_id, limit_days=None):
     filter = [TemplateStatistics.service_id == service_id]
     if limit_days is not None:
@@ -201,11 +229,10 @@ def get_notifications_for_job(service_id, job_id, filter_dict=None, page=1, page
         page_size = current_app.config['PAGE_SIZE']
     query = Notification.query.filter_by(service_id=service_id, job_id=job_id)
     query = filter_query(query, filter_dict)
-    pagination = query.order_by(desc(Notification.created_at)).paginate(
+    return query.order_by(desc(Notification.created_at)).paginate(
         page=page,
         per_page=page_size
     )
-    return pagination
 
 
 def get_notification(service_id, notification_id):
@@ -216,7 +243,11 @@ def get_notification_by_id(notification_id):
     return Notification.query.filter_by(id=notification_id).first()
 
 
-def get_notifications_for_service(service_id, filter_dict=None, page=1, page_size=None, limit_days=None):
+def get_notifications_for_service(service_id,
+                                  filter_dict=None,
+                                  page=1,
+                                  page_size=None,
+                                  limit_days=None):
     if page_size is None:
         page_size = current_app.config['PAGE_SIZE']
     filters = [Notification.service_id == service_id]
@@ -227,11 +258,10 @@ def get_notifications_for_service(service_id, filter_dict=None, page=1, page_siz
 
     query = Notification.query.filter(*filters)
     query = filter_query(query, filter_dict)
-    pagination = query.order_by(desc(Notification.created_at)).paginate(
+    return query.order_by(desc(Notification.created_at)).paginate(
         page=page,
         per_page=page_size
     )
-    return pagination
 
 
 def filter_query(query, filter_dict=None):

app/dao/provider_details_dao.py

@@ -3,6 +3,7 @@ from app.dao.dao_utils import transactional
 from app.models import ProviderDetails
 from app import db
 
+
 def get_provider_details():
     return ProviderDetails.query.order_by(asc(ProviderDetails.priority)).all()
 

app/dao/services_dao.py

@@ -9,6 +9,21 @@ from app.dao.dao_utils import (
     version_class
 )
 
+from app.models import (
+    NotificationStatistics,
+    TemplateStatistics,
+    ProviderStatistics,
+    VerifyCode,
+    ApiKey,
+    Template,
+    Job,
+    Notification,
+    Permission,
+    User,
+    InvitedUser,
+    Service
+)
+
 
 def dao_fetch_all_services():
     return Service.query.order_by(asc(Service.created_at)).all()
@@ -66,3 +81,31 @@ def dao_remove_user_from_service(service, user):
         raise e
     else:
         db.session.commit()
+
+
+def delete_service_and_all_associated_db_objects(service):
+
+    def _delete_commit(query):
+        query.delete()
+        db.session.commit()
+
+    _delete_commit(NotificationStatistics.query.filter_by(service=service))
+    _delete_commit(TemplateStatistics.query.filter_by(service=service))
+    _delete_commit(ProviderStatistics.query.filter_by(service=service))
+    _delete_commit(InvitedUser.query.filter_by(service=service))
+    _delete_commit(Permission.query.filter_by(service=service))
+    _delete_commit(ApiKey.query.filter_by(service=service))
+    _delete_commit(Notification.query.filter_by(service=service))
+    _delete_commit(Job.query.filter_by(service=service))
+    _delete_commit(Template.query.filter_by(service=service))
+
+    verify_codes = VerifyCode.query.join(User).filter(User.id.in_([x.id for x in service.users]))
+    list(map(db.session.delete, verify_codes))
+    db.session.commit()
+    users = [x for x in service.users]
+    map(service.users.remove, users)
+    [service.users.remove(x) for x in users]
+    db.session.delete(service)
+    db.session.commit()
+    list(map(db.session.delete, users))
+    db.session.commit()

app/dao/templates_dao.py

@@ -1,7 +1,7 @@
 import uuid
 from app import db
 from app.models import (Template, Service)
-from sqlalchemy import asc
+from sqlalchemy import (asc, desc)
 
 from app.dao.dao_utils import (
     transactional,
@@ -22,11 +22,20 @@ def dao_update_template(template):
     db.session.add(template)
 
 
-def dao_get_template_by_id_and_service_id(template_id, service_id):
+def dao_get_template_by_id_and_service_id(template_id, service_id, version=None):
+    if version is not None:
+        return Template.get_history_model().query.filter_by(
+            id=template_id,
+            service_id=service_id,
+            version=version).one()
     return Template.query.filter_by(id=template_id, service_id=service_id).one()
 
 
-def dao_get_template_by_id(template_id):
+def dao_get_template_by_id(template_id, version=None):
+    if version is not None:
+        return Template.get_history_model().query.filter_by(
+            id=template_id,
+            version=version).one()
     return Template.query.filter_by(id=template_id).one()
 
 
@@ -36,3 +45,8 @@ def dao_get_all_templates_for_service(service_id):
     ).order_by(
         asc(Template.updated_at), asc(Template.created_at)
     ).all()
+
+
+def dao_get_template_versions(service_id, template_id):
+    history_model = Template.get_history_model()
+    return history_model.query.filter_by(service_id=service_id, id=template_id).order_by(desc(history_model.version))

app/dao/users_dao.py

@@ -67,6 +67,11 @@ def delete_model_user(user):
     db.session.commit()
 
 
+def delete_user_verify_codes(user):
+    VerifyCode.query.filter_by(user=user).delete()
+    db.session.commit()
+
+
 def get_model_users(user_id=None):
     if user_id:
         return User.query.filter_by(id=user_id).one()