remove service letter contact model

app/dao/services_dao.py

@@ -32,7 +32,6 @@ from app.models import (
     Service,
     ServiceContactList,
     ServiceEmailReplyTo,
-    ServiceLetterContact,
     ServicePermission,
     ServiceSmsSender,
     Template,
@@ -369,7 +368,6 @@ def delete_service_and_all_associated_db_objects(service):
 
     _delete_commit(ServiceSmsSender.query.filter_by(service=service))
     _delete_commit(ServiceEmailReplyTo.query.filter_by(service=service))
-    _delete_commit(ServiceLetterContact.query.filter_by(service=service))
     _delete_commit(ServiceContactList.query.filter_by(service=service))
     _delete_commit(InvitedUser.query.filter_by(service=service))
     _delete_commit(Permission.query.filter_by(service=service))

app/dao/templates_dao.py

@@ -38,36 +38,6 @@ def dao_update_template(template):
     db.session.add(template)
 
 
-@autocommit
-def dao_update_template_reply_to(template_id, reply_to):
-    Template.query.filter_by(id=template_id).update(
-        {"service_letter_contact_id": reply_to,
-         "updated_at": datetime.utcnow(),
-         "version": Template.version + 1,
-         }
-    )
-    template = Template.query.filter_by(id=template_id).one()
-
-    history = TemplateHistory(**
-                              {
-                                  "id": template.id,
-                                  "name": template.name,
-                                  "template_type": template.template_type,
-                                  "created_at": template.created_at,
-                                  "updated_at": template.updated_at,
-                                  "content": template.content,
-                                  "service_id": template.service_id,
-                                  "subject": template.subject,
-                                  "created_by_id": template.created_by_id,
-                                  "version": template.version,
-                                  "archived": template.archived,
-                                  "process_type": template.process_type,
-                                  "service_letter_contact_id": template.service_letter_contact_id,
-                              })
-    db.session.add(history)
-    return template
-
-
 @autocommit
 def dao_redact_template(template, user_id):
     template.template_redacted.redact_personalisation = True

app/models.py

@@ -512,10 +512,6 @@ class Service(db.Model, Versioned):
         default_reply_to = [x for x in self.reply_to_email_addresses if x.is_default]
         return default_reply_to[0].email_address if default_reply_to else None
 
-    def get_default_letter_contact(self):
-        default_letter_contact = [x for x in self.letter_contacts if x.is_default]
-        return default_letter_contact[0].contact_block if default_letter_contact else None
-
     def has_permission(self, permission):
         return permission in [p.permission for p in self.permissions]
 
@@ -916,34 +912,20 @@ class TemplateBase(db.Model):
 
     redact_personalisation = association_proxy('template_redacted', 'redact_personalisation')
 
-    @declared_attr
+    # TODO: possibly unnecessary after removing letters
-    def service_letter_contact_id(cls):
-        return db.Column(UUID(as_uuid=True), db.ForeignKey('service_letter_contacts.id'), nullable=True)
-
-    @declared_attr
-    def service_letter_contact(cls):
-        return db.relationship('ServiceLetterContact', viewonly=True)
-
     @property
     def reply_to(self):
-        if self.template_type == LETTER_TYPE:
+        return None
-            return self.service_letter_contact_id
-        else:
-            return None
 
     @reply_to.setter
     def reply_to(self, value):
-        if self.template_type == LETTER_TYPE:
+        if value is None:
-            self.service_letter_contact_id = value
-        elif value is None:
             pass
         else:
             raise ValueError('Unable to set sender for {} template'.format(self.template_type))
 
     def get_reply_to_text(self):
-        if self.template_type == LETTER_TYPE:
+        if self.template_type == EMAIL_TYPE:
-            return self.service_letter_contact.contact_block if self.service_letter_contact else None
-        elif self.template_type == EMAIL_TYPE:
             return self.service.get_default_reply_to_email_address()
         elif self.template_type == SMS_TYPE:
             return try_validate_and_format_phone_number(self.service.get_default_sms_sender())
@@ -983,7 +965,6 @@ class TemplateBase(db.Model):
                 }
                 for key in self._as_utils_template().placeholders
             },
-            "letter_contact_block": self.service_letter_contact.contact_block if self.service_letter_contact else None,
         }
 
         return serialized
@@ -1924,32 +1905,6 @@ class ServiceEmailReplyTo(db.Model):
         }
 
 
-class ServiceLetterContact(db.Model):
-    __tablename__ = "service_letter_contacts"
-
-    id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-
-    service_id = db.Column(UUID(as_uuid=True), db.ForeignKey('services.id'), unique=False, index=True, nullable=False)
-    service = db.relationship(Service, backref=db.backref("letter_contacts"))
-
-    contact_block = db.Column(db.Text, nullable=False, index=False, unique=False)
-    is_default = db.Column(db.Boolean, nullable=False, default=True)
-    archived = db.Column(db.Boolean, nullable=False, default=False)
-    created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
-    updated_at = db.Column(db.DateTime, nullable=True, onupdate=datetime.datetime.utcnow)
-
-    def serialize(self):
-        return {
-            'id': str(self.id),
-            'service_id': str(self.service_id),
-            'contact_block': self.contact_block,
-            'is_default': self.is_default,
-            'archived': self.archived,
-            'created_at': self.created_at.strftime(DATETIME_FORMAT),
-            'updated_at': get_dt_string_or_none(self.updated_at),
-        }
-
-
 class AuthType(db.Model):
     __tablename__ = 'auth_type'
 

app/schemas.py

@@ -249,9 +249,6 @@ class ServiceSchema(BaseSchema, UUIDsAsStringsMixin):
 
         return in_data
 
-    def get_letter_contact(self, service):
-        return service.get_default_letter_contact()
-
     class Meta(BaseSchema.Meta):
         model = models.Service
         exclude = (
@@ -267,7 +264,6 @@ class ServiceSchema(BaseSchema, UUIDsAsStringsMixin):
             'inbound_number',
             'inbound_sms',
             'jobs',
-            'letter_contacts',
             'reply_to_email_addresses',
             'returned_letters',
             'service_sms_senders',
@@ -360,7 +356,7 @@ class BaseTemplateSchema(BaseSchema):
 
     class Meta(BaseSchema.Meta):
         model = models.Template
-        exclude = ("service_id", "jobs", "service_letter_contact_id")
+        exclude = ("service_id", "jobs")
 
 
 class TemplateSchema(BaseTemplateSchema, UUIDsAsStringsMixin):
@@ -405,7 +401,6 @@ class TemplateSchemaNoDetail(TemplateSchema):
             'reply_to',
             'reply_to_text',
             'service',
-            'service_letter_contact',
             'subject',
             'template_redacted',
             'updated_at',

app/service/service_data_retention_schema.py

@@ -5,7 +5,7 @@ add_service_data_retention_request = {
     "type": "object",
     "properties": {
         "days_of_retention": {"type": "integer"},
-        "notification_type": {"enum": ["sms", "letter", "email"]},
+        "notification_type": {"enum": ["sms", "email"]},
     },
     "required": ["days_of_retention", "notification_type"]
 }

app/template/rest.py

@@ -14,7 +14,6 @@ from app.dao.templates_dao import (
     dao_get_template_versions,
     dao_redact_template,
     dao_update_template,
-    dao_update_template_reply_to,
 )
 from app.errors import InvalidRequest, register_errors
 from app.models import SMS_TYPE, Template
@@ -111,11 +110,6 @@ def update_template(service_id, template_id):
     if data.get('redact_personalisation') is True:
         return redact_template(fetched_template, data)
 
-    if "reply_to" in data:
-        check_reply_to(service_id, data.get("reply_to"), fetched_template.template_type)
-        updated = dao_update_template_reply_to(template_id=template_id, reply_to=data.get("reply_to"))
-        return jsonify(data=template_schema.dump(updated)), 200
-
     current_data = dict(template_schema.dump(fetched_template).items())
     updated_template = dict(template_schema.dump(fetched_template).items())
     updated_template.update(data)

migrations/versions/0388_no_serv_letter_contact.py

@@ -0,0 +1,45 @@
+"""
+
+Revision ID: 0388_no_serv_letter_contact.py
+Revises: 0387_remove_letter_perms_.py
+Create Date: 2023-02-17 14:42:52.679425
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+revision = '0388_no_serv_letter_contact.py'
+down_revision = '0387_remove_letter_perms_.py'
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index('ix_service_letter_contacts_service_id', table_name='service_letter_contacts')
+    op.drop_constraint('templates_service_letter_contact_id_fkey', 'templates', type_='foreignkey')
+    op.drop_column('templates', 'service_letter_contact_id')
+    op.drop_constraint('templates_history_service_letter_contact_id_fkey', 'templates_history', type_='foreignkey')
+    op.drop_column('templates_history', 'service_letter_contact_id')
+    op.drop_table('service_letter_contacts')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('templates_history', sa.Column('service_letter_contact_id', postgresql.UUID(), autoincrement=False, nullable=True))
+    op.create_foreign_key('templates_history_service_letter_contact_id_fkey', 'templates_history', 'service_letter_contacts', ['service_letter_contact_id'], ['id'])
+    op.add_column('templates', sa.Column('service_letter_contact_id', postgresql.UUID(), autoincrement=False, nullable=True))
+    op.create_foreign_key('templates_service_letter_contact_id_fkey', 'templates', 'service_letter_contacts', ['service_letter_contact_id'], ['id'])
+    op.create_table('service_letter_contacts',
+        sa.Column('id', postgresql.UUID(), autoincrement=False, nullable=False),
+        sa.Column('service_id', postgresql.UUID(), autoincrement=False, nullable=False),
+        sa.Column('contact_block', sa.TEXT(), autoincrement=False, nullable=False),
+        sa.Column('is_default', sa.BOOLEAN(), autoincrement=False, nullable=False),
+        sa.Column('created_at', postgresql.TIMESTAMP(), autoincrement=False, nullable=False),
+        sa.Column('updated_at', postgresql.TIMESTAMP(), autoincrement=False, nullable=True),
+        sa.Column('archived', sa.BOOLEAN(), server_default=sa.text('false'), autoincrement=False, nullable=False),
+        sa.ForeignKeyConstraint(['service_id'], ['services.id'], name='service_letter_contacts_service_id_fkey'),
+        sa.PrimaryKeyConstraint('id', name='service_letter_contacts_pkey')
+    )
+    op.create_index('ix_service_letter_contacts_service_id', 'service_letter_contacts', ['service_id'], unique=False)
+    # ### end Alembic commands ###

tests/app/celery/test_tasks.py

@@ -9,7 +9,6 @@ from celery.exceptions import Retry
 from freezegun import freeze_time
 from notifications_utils.recipients import Row
 from notifications_utils.template import (
-    LetterPrintTemplate,
     PlainTextEmailTemplate,
     SMSMessageTemplate,
 )
@@ -39,7 +38,6 @@ from app.models import (
     JOB_STATUS_FINISHED,
     JOB_STATUS_IN_PROGRESS,
     KEY_TYPE_NORMAL,
-    LETTER_TYPE,
     NOTIFICATION_CREATED,
     SMS_TYPE,
     Job,
@@ -53,7 +51,6 @@ from tests.app.db import (
     create_api_key,
     create_inbound_sms,
     create_job,
-    create_letter_contact,
     create_notification,
     create_reply_to_email,
     create_service,
@@ -976,49 +973,6 @@ def test_get_sms_template_instance(mocker, sample_template, sample_job):
     ]
 
 
-@pytest.mark.skip(reason="Needs updating for TTS: Remove mail")
-def test_get_letter_template_instance(mocker, sample_job):
-    mocker.patch(
-        'app.celery.tasks.s3.get_job_and_metadata_from_s3',
-        return_value=('', {}),
-    )
-    sample_contact_block = create_letter_contact(
-        service=sample_job.service,
-        contact_block='((reference number))'
-    )
-    sample_template = create_template(
-        service=sample_job.service,
-        template_type=LETTER_TYPE,
-        reply_to=sample_contact_block.id,
-    )
-    sample_job.template_id = sample_template.id
-
-    (
-        recipient_csv,
-        template,
-        _sender_id,
-    ) = get_recipient_csv_and_template_and_sender_id(sample_job)
-
-    assert isinstance(template, LetterPrintTemplate)
-    assert template.contact_block == (
-        '((reference number))'
-    )
-    assert template.placeholders == {
-        'reference number'
-    }
-    assert recipient_csv.placeholders == [
-        'reference number',
-        'address line 1',
-        'address line 2',
-        'address line 3',
-        'address line 4',
-        'address line 5',
-        'address line 6',
-        'postcode',
-        'address line 7',
-    ]
-
-
 def test_send_inbound_sms_to_service_post_https_request_to_service(notify_api, sample_service):
     inbound_api = create_service_inbound_api(service=sample_service, url="https://some.service.gov.uk/",
                                              bearer_token="something_unique")

tests/app/conftest.py

@@ -49,7 +49,6 @@ from tests.app.db import (
     create_inbound_number,
     create_invited_org_user,
     create_job,
-    create_letter_contact,
     create_notification,
     create_service,
     create_template,
@@ -238,12 +237,6 @@ def _sample_service_full_permissions(notify_db_session):
     return service
 
 
-@pytest.fixture(scope='function', name='sample_service_custom_letter_contact_block')
-def _sample_service_custom_letter_contact_block(sample_service):
-    create_letter_contact(sample_service, contact_block='((contact block))')
-    return sample_service
-
-
 @pytest.fixture(scope='function')
 def sample_template(sample_user):
     service = create_service(service_permissions=[EMAIL_TYPE, SMS_TYPE], check_if_service_exists=True)

tests/app/dao/test_templates_dao.py

@@ -11,10 +11,9 @@ from app.dao.templates_dao import (
     dao_get_template_versions,
     dao_redact_template,
     dao_update_template,
-    dao_update_template_reply_to,
 )
 from app.models import Template, TemplateHistory, TemplateRedacted
-from tests.app.db import create_letter_contact, create_template
+from tests.app.db import create_template
 
 
 @pytest.mark.parametrize('template_type, subject', [
@@ -52,23 +51,6 @@ def test_create_template_creates_redact_entry(sample_service):
     assert redacted.updated_by_id == sample_service.created_by_id
 
 
-def test_create_template_with_reply_to(sample_service, sample_user):
-    letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
-
-    data = {
-        'name': 'Sample Template',
-        'template_type': "letter",
-        'content': "Template content",
-        'service': sample_service,
-        'created_by': sample_user,
-        'reply_to': letter_contact.id,
-    }
-    template = Template(**data)
-    dao_create_template(template)
-
-    assert dao_get_all_templates_for_service(sample_service.id)[0].reply_to == letter_contact.id
-
-
 def test_update_template(sample_service, sample_user):
     data = {
         'name': 'Sample Template',
@@ -87,85 +69,6 @@ def test_update_template(sample_service, sample_user):
     assert dao_get_all_templates_for_service(sample_service.id)[0].name == 'new name'
 
 
-def test_dao_update_template_reply_to_none_to_some(sample_service, sample_user):
-    letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
-
-    data = {
-        'name': 'Sample Template',
-        'template_type': "letter",
-        'content': "Template content",
-        'service': sample_service,
-        'created_by': sample_user,
-    }
-    template = Template(**data)
-    dao_create_template(template)
-    created = Template.query.get(template.id)
-    assert created.reply_to is None
-    assert created.service_letter_contact_id is None
-
-    dao_update_template_reply_to(template_id=template.id,
-                                 reply_to=letter_contact.id)
-
-    updated = Template.query.get(template.id)
-    assert updated.reply_to == letter_contact.id
-    assert updated.version == 2
-    assert updated.updated_at
-
-    template_history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
-    assert template_history.service_letter_contact_id == letter_contact.id
-    assert template_history.updated_at == updated.updated_at
-
-
-def test_dao_update_template_reply_to_some_to_some(sample_service, sample_user):
-    letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
-    letter_contact_2 = create_letter_contact(sample_service, 'London, N1 1DE')
-
-    data = {
-        'name': 'Sample Template',
-        'template_type': "letter",
-        'content': "Template content",
-        'service': sample_service,
-        'created_by': sample_user,
-        'service_letter_contact_id': letter_contact.id,
-    }
-    template = Template(**data)
-    dao_create_template(template)
-    created = Template.query.get(template.id)
-    dao_update_template_reply_to(template_id=created.id, reply_to=letter_contact_2.id)
-    updated = Template.query.get(template.id)
-    assert updated.reply_to == letter_contact_2.id
-    assert updated.version == 2
-    assert updated.updated_at
-
-    updated_history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
-    assert updated_history.service_letter_contact_id == letter_contact_2.id
-    assert updated_history.updated_at == updated_history.updated_at
-
-
-def test_dao_update_template_reply_to_some_to_none(sample_service, sample_user):
-    letter_contact = create_letter_contact(sample_service, 'Edinburgh, ED1 1AA')
-    data = {
-        'name': 'Sample Template',
-        'template_type': "letter",
-        'content': "Template content",
-        'service': sample_service,
-        'created_by': sample_user,
-        'service_letter_contact_id': letter_contact.id,
-    }
-    template = Template(**data)
-    dao_create_template(template)
-    created = Template.query.get(template.id)
-    dao_update_template_reply_to(template_id=created.id, reply_to=None)
-    updated = Template.query.get(template.id)
-    assert updated.reply_to is None
-    assert updated.version == 2
-    assert updated.updated_at
-
-    history = TemplateHistory.query.filter_by(id=created.id, version=2).one()
-    assert history.service_letter_contact_id is None
-    assert history.updated_at == updated.updated_at
-
-
 def test_redact_template(sample_template):
     redacted = TemplateRedacted.query.one()
     assert redacted.template_id == sample_template.id

tests/app/db.py

@@ -57,7 +57,6 @@ from app.models import (
     ServiceEmailReplyTo,
     ServiceGuestList,
     ServiceInboundApi,
-    ServiceLetterContact,
     ServicePermission,
     ServiceSmsSender,
     Template,
@@ -578,26 +577,6 @@ def create_service_sms_sender(
     return service_sms_sender
 
 
-def create_letter_contact(
-        service,
-        contact_block,
-        is_default=True,
-        archived=False
-):
-    data = {
-        'service': service,
-        'contact_block': contact_block,
-        'is_default': is_default,
-        'archived': archived,
-    }
-    letter_content = ServiceLetterContact(**data)
-
-    db.session.add(letter_content)
-    db.session.commit()
-
-    return letter_content
-
-
 def create_annual_billing(
         service_id, free_sms_fragment_limit, financial_year_start
 ):

tests/app/service/send_notification/test_send_one_off_notification.py

@@ -21,7 +21,6 @@ from app.models import (
 from app.service.send_notification import send_one_off_notification
 from app.v2.errors import BadRequestError, TooManyRequestsError
 from tests.app.db import (
-    create_letter_contact,
     create_reply_to_email,
     create_service,
     create_service_sms_sender,
@@ -307,56 +306,6 @@ def test_send_one_off_notification_should_add_email_reply_to_text_for_notificati
     assert notification.reply_to_text == reply_to_email.email_address
 
 
-def test_send_one_off_letter_notification_should_use_template_reply_to_text(sample_letter_template, celery_mock):
-    letter_contact = create_letter_contact(sample_letter_template.service, "Edinburgh, ED1 1AA", is_default=False)
-    sample_letter_template.reply_to = str(letter_contact.id)
-
-    data = {
-        'to': 'user@example.com',
-        'template_id': str(sample_letter_template.id),
-        'personalisation': {
-            'name': 'foo',
-            'address_line_1': 'First Last',
-            'address_line_2': '1 Example Street',
-            'address_line_3': 'SW1A 1AA',
-        },
-        'created_by': str(sample_letter_template.service.created_by_id)
-    }
-
-    notification_id = send_one_off_notification(service_id=sample_letter_template.service.id, post_data=data)
-    notification = Notification.query.get(notification_id['id'])
-    celery_mock.assert_called_once_with(
-        notification=notification,
-        research_mode=False,
-        queue=None
-    )
-
-    assert notification.reply_to_text == "Edinburgh, ED1 1AA"
-
-
-@pytest.mark.skip(reason="Needs updating for TTS: Remove letters")
-def test_send_one_off_letter_should_not_make_pdf_in_research_mode(sample_letter_template):
-
-    sample_letter_template.service.research_mode = True
-
-    data = {
-        'to': 'A. Name',
-        'template_id': str(sample_letter_template.id),
-        'personalisation': {
-            'name': 'foo',
-            'address_line_1': 'First Last',
-            'address_line_2': '1 Example Street',
-            'address_line_3': 'SW1A 1AA',
-        },
-        'created_by': str(sample_letter_template.service.created_by_id)
-    }
-
-    notification = send_one_off_notification(service_id=sample_letter_template.service.id, post_data=data)
-    notification = Notification.query.get(notification['id'])
-
-    assert notification.status == "delivered"
-
-
 def test_send_one_off_sms_notification_should_use_sms_sender_reply_to_text(sample_service, celery_mock):
     template = create_template(service=sample_service, template_type=SMS_TYPE)
     sms_sender = create_service_sms_sender(

tests/app/service/test_service_data_retention_rest.py

@@ -10,8 +10,6 @@ def test_get_service_data_retention(client, sample_service):
     sms_data_retention = create_service_data_retention(service=sample_service)
     email_data_retention = create_service_data_retention(service=sample_service, notification_type='email',
                                                          days_of_retention=10)
-    letter_data_retention = create_service_data_retention(service=sample_service, notification_type='letter',
-                                                          days_of_retention=30)
 
     response = client.get(
         '/service/{}/data-retention'.format(str(sample_service.id)),
@@ -20,10 +18,9 @@ def test_get_service_data_retention(client, sample_service):
 
     assert response.status_code == 200
     json_response = json.loads(response.get_data(as_text=True))
-    assert len(json_response) == 3
+    assert len(json_response) == 2
     assert json_response[0] == email_data_retention.serialize()
     assert json_response[1] == sms_data_retention.serialize()
-    assert json_response[2] == letter_data_retention.serialize()
 
 
 def test_get_service_data_retention_returns_empty_list(client, sample_service):
@@ -99,7 +96,7 @@ def test_create_service_data_retention_returns_400_when_notification_type_is_inv
     json_resp = json.loads(response.get_data(as_text=True))
     assert response.status_code == 400
     assert json_resp['errors'][0]['error'] == 'ValidationError'
-    assert json_resp['errors'][0]['message'] == 'notification_type unknown is not one of [sms, letter, email]'
+    assert json_resp['errors'][0]['message'] == 'notification_type unknown is not one of [sms, email]'
 
 
 def test_create_service_data_retention_returns_400_when_data_retention_for_notification_type_already_exists(

tests/app/template/test_rest.py

@@ -17,18 +17,12 @@ from app.models import (
     TemplateHistory,
 )
 from tests import create_admin_authorization_header
-from tests.app.db import (
+from tests.app.db import create_service, create_template, create_template_folder
-    create_letter_contact,
-    create_service,
-    create_template,
-    create_template_folder,
-)
 
 
 @pytest.mark.parametrize('template_type, subject', [
     (SMS_TYPE, None),
     (EMAIL_TYPE, 'subject'),
-    (LETTER_TYPE, 'subject'),
 ])
 def test_should_create_a_new_template_for_a_service(
     client, sample_user, template_type, subject
@@ -473,7 +467,6 @@ def test_should_get_return_all_fields_by_default(
         'reply_to',
         'reply_to_text',
         'service',
-        'service_letter_contact',
         'subject',
         'template_redacted',
         'template_type',
@@ -759,32 +752,6 @@ def test_update_set_process_type_on_template(client, sample_template):
     assert template.process_type == 'priority'
 
 
-def test_create_a_template_with_reply_to(admin_request, sample_user):
-    service = create_service(service_permissions=['letter'])
-    letter_contact = create_letter_contact(service, "Edinburgh, ED1 1AA")
-    data = {
-        'name': 'my template',
-        'subject': 'subject',
-        'template_type': 'letter',
-        'content': 'template <b>content</b>',
-        'service': str(service.id),
-        'created_by': str(sample_user.id),
-        'reply_to': str(letter_contact.id),
-    }
-
-    json_resp = admin_request.post('template.create_template', service_id=service.id, _data=data, _expected_status=201)
-
-    assert json_resp['data']['template_type'] == 'letter'
-    assert json_resp['data']['reply_to'] == str(letter_contact.id)
-    assert json_resp['data']['reply_to_text'] == letter_contact.contact_block
-
-    template = Template.query.get(json_resp['data']['id'])
-    from app.schemas import template_schema
-    assert sorted(json_resp['data']) == sorted(template_schema.dump(template))
-    th = TemplateHistory.query.filter_by(id=template.id, version=1).one()
-    assert th.service_letter_contact_id == letter_contact.id
-
-
 @pytest.mark.parametrize('post_data, expected_errors', [
     (
         {},
@@ -813,58 +780,6 @@ def test_create_template_validates_against_json_schema(
     assert response['errors'] == expected_errors
 
 
-@pytest.mark.parametrize('template_default, service_default',
-                         [('template address', 'service address'),
-                          (None, 'service address'),
-                          ('template address', None),
-                          (None, None)
-                          ])
-def test_get_template_reply_to(client, sample_service, template_default, service_default):
-    auth_header = create_admin_authorization_header()
-    if service_default:
-        create_letter_contact(
-            service=sample_service, contact_block=service_default, is_default=True
-        )
-    if template_default:
-        template_default_contact = create_letter_contact(
-            service=sample_service, contact_block=template_default, is_default=False
-        )
-    reply_to_id = str(template_default_contact.id) if template_default else None
-    template = create_template(service=sample_service, template_type='letter', reply_to=reply_to_id)
-
-    resp = client.get('/service/{}/template/{}'.format(template.service_id, template.id),
-                      headers=[auth_header])
-
-    assert resp.status_code == 200, resp.get_data(as_text=True)
-    json_resp = json.loads(resp.get_data(as_text=True))
-
-    assert 'service_letter_contact_id' not in json_resp['data']
-    assert json_resp['data']['reply_to'] == reply_to_id
-    assert json_resp['data']['reply_to_text'] == template_default
-
-
-def test_update_template_reply_to_set_to_blank(client, notify_db_session):
-    auth_header = create_admin_authorization_header()
-    service = create_service(service_permissions=['letter'])
-    letter_contact = create_letter_contact(service, "Edinburgh, ED1 1AA")
-    template = create_template(service=service, template_type='letter', reply_to=letter_contact.id)
-
-    data = {
-        'reply_to': None,
-    }
-
-    resp = client.post('/service/{}/template/{}'.format(template.service_id, template.id),
-                       data=json.dumps(data),
-                       headers=[('Content-Type', 'application/json'), auth_header])
-
-    assert resp.status_code == 200, resp.get_data(as_text=True)
-
-    template = dao_get_template_by_id(template.id)
-    assert template.service_letter_contact_id is None
-    th = TemplateHistory.query.filter_by(id=template.id, version=2).one()
-    assert th.service_letter_contact_id is None
-
-
 def test_update_redact_template(admin_request, sample_template):
     assert sample_template.redact_personalisation is False
 

tests/app/template/test_rest_history.py

@@ -5,7 +5,6 @@ from flask import url_for
 
 from app.dao.templates_dao import dao_update_template
 from tests import create_admin_authorization_header
-from tests.app.db import create_letter_contact
 
 
 def test_template_history_version(notify_api, sample_user, sample_template):
@@ -99,22 +98,3 @@ def test_all_versions_of_template(notify_api, sample_template):
             assert json_resp['data'][1]['content'] == newer_content
             assert json_resp['data'][1]['updated_at']
             assert json_resp['data'][2]['content'] == old_content
-
-
-def test_update_template_reply_to_updates_history(client, sample_letter_template):
-    auth_header = create_admin_authorization_header()
-    letter_contact = create_letter_contact(sample_letter_template.service, "Edinburgh, ED1 1AA")
-
-    sample_letter_template.reply_to = letter_contact.id
-    dao_update_template(sample_letter_template)
-
-    resp = client.get(
-        '/service/{}/template/{}/version/2'.format(sample_letter_template.service_id, sample_letter_template.id),
-        headers=[auth_header]
-    )
-    assert resp.status_code == 200
-
-    hist_json_resp = json.loads(resp.get_data(as_text=True))
-    assert 'service_letter_contact_id' not in hist_json_resp['data']
-    assert hist_json_resp['data']['reply_to'] == str(letter_contact.id)
-    assert hist_json_resp['data']['reply_to_text'] == letter_contact.contact_block

tests/app/v2/template/test_get_template.py

@@ -1,10 +1,10 @@
 import pytest
 from flask import json
 
-from app.models import EMAIL_TYPE, LETTER_TYPE, SMS_TYPE, TEMPLATE_TYPES
+from app.models import EMAIL_TYPE, SMS_TYPE, TEMPLATE_TYPES
 from app.utils import DATETIME_FORMAT
 from tests import create_service_authorization_header
-from tests.app.db import create_letter_contact, create_template
+from tests.app.db import create_template
 
 valid_version_params = [None, 1]
 
@@ -41,7 +41,6 @@ def test_get_template_by_id_returns_200(
         "subject": expected_subject,
         'name': expected_name,
         'personalisation': {},
-        'letter_contact_block': None,
     }
 
     assert json_response == expected_response
@@ -98,44 +97,6 @@ def test_get_template_by_id_returns_placeholders(
     assert json_response['personalisation'] == expected_personalisation
 
 
-@pytest.mark.parametrize("version", valid_version_params)
-def test_get_letter_template_by_id_returns_placeholders(
-    client,
-    sample_service,
-    version,
-):
-    contact_block = create_letter_contact(
-        service=sample_service,
-        contact_block='((contact block))',
-    )
-    template = create_template(
-        sample_service,
-        template_type=LETTER_TYPE,
-        subject="((letterSubject))",
-        content="((letter_content))",
-        reply_to=contact_block.id,
-    )
-    auth_header = create_service_authorization_header(service_id=sample_service.id)
-
-    version_path = '/version/{}'.format(version) if version else ''
-
-    response = client.get(path='/v2/template/{}{}'.format(template.id, version_path),
-                          headers=[('Content-Type', 'application/json'), auth_header])
-
-    json_response = json.loads(response.get_data(as_text=True))
-    assert json_response['personalisation'] == {
-        "letterSubject": {
-            "required": True,
-        },
-        "letter_content": {
-            "required": True,
-        },
-        "contact block": {
-            "required": True,
-        },
-    }
-
-
 def test_get_template_with_non_existent_template_id_returns_404(client, fake_uuid, sample_service):
     auth_header = create_service_authorization_header(service_id=sample_service.id)