more

app/dao/permissions_dao.py

@@ -1,3 +1,5 @@
+from sqlalchemy import delete, select
+
 from app import db
 from app.dao import DAOClass
 from app.enums import PermissionType
@@ -14,22 +16,29 @@ class PermissionDAO(DAOClass):
             self.create_instance(permission, _commit=False)
 
     def remove_user_service_permissions(self, user, service):
-        query = self.Meta.model.query.filter_by(user=user, service=service)
+        db.session.execute(
-        query.delete()
+            delete(self.Meta.model.filter_by(user=user, service=service))
+        )
+        db.session.commit()
 
     def remove_user_service_permissions_for_all_services(self, user):
-        query = self.Meta.model.query.filter_by(user=user)
+        db.session.execute(delete(self.Meta.model.filter_by(user=user)))
-        query.delete()
+        db.session.commit()
 
     def set_user_service_permission(
         self, user, service, permissions, _commit=False, replace=False
     ):
         try:
             if replace:
-                query = self.Meta.model.query.filter(
+                db.session.execute(
-                    self.Meta.model.user == user, self.Meta.model.service == service
+                    delete(
+                        self.Meta.model.filter(
+                            self.Meta.model.user == user,
+                            self.Meta.model.service == service,
                         )
-                query.delete()
+                    )
+                )
+                db.session.commit()
             for p in permissions:
                 p.user = user
                 p.service = service
@@ -44,17 +53,27 @@ class PermissionDAO(DAOClass):
 
     def get_permissions_by_user_id(self, user_id):
         return (
-            self.Meta.model.query.filter_by(user_id=user_id)
+            db.session.execute(
+                select(
+                    self.Meta.model.filter_by(user_id=user_id)
                     .join(Permission.service)
                     .filter_by(active=True)
+                )
+            )
+            .scalars()
             .all()
         )
 
     def get_permissions_by_user_id_and_service_id(self, user_id, service_id):
         return (
-            self.Meta.model.query.filter_by(user_id=user_id)
+            db.session.commit(
+                select(
+                    self.Meta.model.filter_by(user_id=user_id)
                     .join(Permission.service)
                     .filter_by(active=True, id=service_id)
+                )
+            )
+            .scalars()
             .all()
         )
 

app/dao/service_email_reply_to_dao.py

@@ -1,4 +1,4 @@
-from sqlalchemy import desc
+from sqlalchemy import desc, select
 
 from app import db
 from app.dao.dao_utils import autocommit
@@ -62,7 +62,7 @@ def update_reply_to_email_address(service_id, reply_to_id, email_address, is_def
                 "You must have at least one reply to email address as the default.", 400
             )
 
-    reply_to_update = ServiceEmailReplyTo.query.get(reply_to_id)
+    reply_to_update = db.session.get(ServiceEmailReplyTo, reply_to_id)
     reply_to_update.email_address = email_address
     reply_to_update.is_default = is_default
     db.session.add(reply_to_update)
@@ -71,9 +71,13 @@ def update_reply_to_email_address(service_id, reply_to_id, email_address, is_def
 
 @autocommit
 def archive_reply_to_email_address(service_id, reply_to_id):
-    reply_to_archive = ServiceEmailReplyTo.query.filter_by(
+    reply_to_archive = (
-        id=reply_to_id, service_id=service_id
+        db.session.execute(
-    ).one()
+            select(ServiceEmailReplyTo).filter_by(id=reply_to_id, service_id=service_id)
+        )
+        .scalars()
+        .one()
+    )
 
     if reply_to_archive.is_default:
         raise ArchiveValidationError(

app/dao/service_sms_sender_dao.py

@@ -65,7 +65,7 @@ def dao_update_service_sms_sender(
         if old_default.id == service_sms_sender_id:
             raise Exception("You must have at least one SMS sender as the default")
 
-    sms_sender_to_update = ServiceSmsSender.query.get(service_sms_sender_id)
+    sms_sender_to_update = db.session.get(ServiceSmsSender, service_sms_sender_id)
     sms_sender_to_update.is_default = is_default
     if not sms_sender_to_update.inbound_number_id and sms_sender:
         sms_sender_to_update.sms_sender = sms_sender
@@ -85,9 +85,13 @@ def update_existing_sms_sender_with_inbound_number(
 
 @autocommit
 def archive_sms_sender(service_id, sms_sender_id):
-    sms_sender_to_archive = ServiceSmsSender.query.filter_by(
+    sms_sender_to_archive = (
-        id=sms_sender_id, service_id=service_id
+        db.session.execute(
-    ).one()
+            select(ServiceSmsSender).filter_by(id=sms_sender_id, service_id=service_id)
+        )
+        .scalars()
+        .one()
+    )
 
     if sms_sender_to_archive.inbound_number_id:
         raise ArchiveValidationError("You cannot delete an inbound number")

app/service/rest.py

@@ -314,7 +314,7 @@ def update_service(service_id):
         service.email_branding = (
             None
             if not email_branding_id
-            else EmailBranding.query.get(email_branding_id)
+            else db.session.get(EmailBranding, email_branding_id)
         )
     dao_update_service(service)
 
@@ -892,7 +892,7 @@ def verify_reply_to_email_address(service_id):
     template = dao_get_template_by_id(
         current_app.config["REPLY_TO_EMAIL_ADDRESS_VERIFICATION_TEMPLATE_ID"]
     )
-    notify_service = Service.query.get(current_app.config["NOTIFY_SERVICE_ID"])
+    notify_service = db.session.get(Service, current_app.config["NOTIFY_SERVICE_ID"])
     saved_notification = persist_notification(
         template_id=template.id,
         template_version=template.version,