Linking tags and log records table

backend/app/models/__init__.py

@@ -11,6 +11,7 @@ def init_app(app):
     from .sign_in_logs import SignInLogs
     from .log_records import LogRecords
     from .tag import Tag
+    from .log_record_tag import LogRecordTag
 
     app.app_context().push()
     db.init_app(app)

backend/app/models/log_record_tag.py

@@ -0,0 +1,32 @@
+from sqlalchemy import inspect
+from sqlalchemy.orm.properties import ColumnProperty
+
+from . import db
+
+
+class LogRecordTag(db.Model):
+    __tablename__ = "log_record_tag"
+
+    log_record_tag_id = db.Column(db.Integer, primary_key=True, nullable=False)
+    log_record_id = db.Column(db.Integer, db.ForeignKey("log_records.log_id"), nullable=False)
+    tag_id = db.Column(db.Integer, db.ForeignKey("tags.tag_id"), nullable=False)
+
+    def to_dict(self, include_relationships=False):
+        # define the entities table
+        cls = type(self)
+
+        mapper = inspect(cls)
+        formatted = {}
+        for column in mapper.attrs:
+            field = column.key
+            attr = getattr(self, field)
+            # if it's a regular column, extract the value
+            if isinstance(column, ColumnProperty):
+                formatted[field] = attr
+            # otherwise, it's a relationship field
+            # (currently not applicable, but may be useful for entity groups)
+            elif include_relationships:
+                # recursively format the relationship
+                # don't format the relationship's relationships
+                formatted[field] = [obj.to_dict() for obj in attr]
+        return formatted

backend/app/models/log_records.py

@@ -14,8 +14,8 @@ class LogRecords(db.Model):
     attn_to = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
     # TODO: replace open String fields with VarChar(NUM_CHARS)
     note = db.Column(db.String, nullable=True)
-    tags = db.Column(db.ARRAY(db.String), nullable=True)
     building = db.Column(db.String, nullable=False)
+    tags = db.relationship("Tag", secondary="log_record_tag", back_populates="log_records")
 
     def to_dict(self, include_relationships=False):
         # define the entities table

backend/app/models/tag.py

@@ -12,6 +12,7 @@ class Tag(db.Model):
     status = db.Column(
         db.Enum("Deleted", "Active", name="status"), nullable=False
     )
+    log_records = db.relationship("LogRecords", secondary="log_record_tag", back_populates="tags")
 
     def to_dict(self, include_relationships=False):
         # define the entities table

backend/app/services/implementations/log_records_service.py

@@ -1,6 +1,6 @@
 from ..interfaces.log_records_service import ILogRecordsService
 from ...models.log_records import LogRecords
-from ...models.user import User
+from ...models.tag import Tag
 from ...models import db
 from datetime import datetime
 from pytz import timezone
@@ -25,13 +25,26 @@ def add_record(self, log_record):
         new_log_record = log_record
         new_log_record["datetime"] = datetime.now()
 
+        tag_names = new_log_record["tags"]
+        del new_log_record["tags"]
+
         try:
             new_log_record = LogRecords(**new_log_record)
+            self.construct_tags(new_log_record, tag_names)
+
             db.session.add(new_log_record)
             db.session.commit()
             return log_record
         except Exception as postgres_error:
             raise postgres_error
+
+    def construct_tags(self, log_record, tag_names):
+        for tag_name in tag_names:
+            tag = Tag.query.filter_by(name=tag_name).first()
+
+            if not tag: 
+                raise Exception(f"Tag with name {tag_name} does not exist")
+            log_record.tags.append(tag)
 
     def to_json_list(self, logs):
         try:
@@ -86,9 +99,9 @@ def filter_by_date_range(self, date_range):
         return f"\ndatetime>='{start_date}' AND datetime<='{end_date}'"
 
     def filter_by_tags(self, tags):
-        sql_statement = f"\n'{tags[0]}'=ANY (tags)"
+        sql_statement = f"\n'{tags[0]}'=ANY (tag_names)"
         for i in range (1, len(tags)):
-            sql_statement = sql_statement + f"\nOR '{tags[i]}'=ANY (tags)"
+            sql_statement = sql_statement + f"\nOR '{tags[i]}'=ANY (tag_names)"
         return sql_statement
 
     def filter_by_flagged(self, flagged):
@@ -101,7 +114,7 @@ def get_log_records(self, page_number,filters=None):
             start_index = (page_number - 1) * results_per_page
             end_index = start_index + results_per_page
 
-            sql = 'SELECT\n \
+            sql = "SELECT\n \
                 logs.log_id,\n \
                 logs.employee_id,\n \
                 logs.resident_first_name,\n \
@@ -110,17 +123,23 @@ def get_log_records(self, page_number,filters=None):
                 logs.flagged,\n \
                 logs.attn_to,\n \
                 logs.note,\n \
-                logs.tags,\n \
                 logs.building,\n \
+                t.tag_names, \n \
                 employees.first_name AS employee_first_name,\n \
                 employees.last_name AS employee_last_name,\n \
                 attn_tos.first_name AS attn_to_first_name,\n \
                 attn_tos.last_name AS attn_to_last_name\n \
                 FROM log_records logs\n \
                 LEFT JOIN users attn_tos ON logs.attn_to = attn_tos.id\n \
-                JOIN users employees ON logs.employee_id = employees.id'
-
-            if filters:   
+                JOIN users employees ON logs.employee_id = employees.id\n \
+                LEFT JOIN\n \
+                    (SELECT logs.log_id, string_to_array(string_agg(tags.name, ','), ',') AS tag_names FROM log_records logs\n \
+                    JOIN log_record_tag lrt ON logs.log_id = lrt.log_record_id\n \
+                    JOIN tags ON lrt.tag_id = tags.tag_id\n \
+                    GROUP BY logs.log_id \n \
+                ) t ON logs.log_id = t.log_id"
+
+            if filters: 
                 is_first_filter = True
 
                 options = {
@@ -137,7 +156,6 @@ def get_log_records(self, page_number,filters=None):
                         is_first_filter = False
                     else: 
                         sql = sql + "\nAND " + options[filter](filters.get(filter))
-
             sql = sql + "\nORDER BY datetime DESC"
             log_records = db.session.execute(text(sql))
             json_list = self.to_json_list(log_records)
@@ -148,13 +166,15 @@ def get_log_records(self, page_number,filters=None):
             raise postgres_error
 
     def delete_log_record(self, log_id):
-        deleted_log_record = LogRecords.query.filter_by(log_id=log_id).delete()
-        if not deleted_log_record:
+        log_record_to_delete = LogRecords.query.filter_by(log_id=log_id).first()
+        if not log_record_to_delete:
             raise Exception(
                 "Log record with id {log_id} not found".format(
                     log_id=log_id
                 )
             )
+        log_record_to_delete.tags = []
+        db.session.delete(log_record_to_delete)
         db.session.commit()
 
     def update_log_record(self, log_id, updated_log_record):
@@ -183,11 +203,10 @@ def update_log_record(self, log_id, updated_log_record):
                 }
             )
         if "tags" in updated_log_record:
-            LogRecords.query.filter_by(log_id=log_id).update(
-                {
-                    LogRecords.tags: updated_log_record["tags"]
-                }
-            )
+            logRecord = LogRecords.query.filter_by(log_id=log_id).first()
+            if (logRecord):
+                logRecord.tags = []
+                self.construct_tags(logRecord, updated_log_record["tags"])
         else: 
             LogRecords.query.filter_by(log_id=log_id).update(
                 {

backend/migrations/versions/65a56c245ad7_create_junction_table_between_log_.py

@@ -0,0 +1,41 @@
+"""create junction table between log records and tags
+
+Revision ID: 65a56c245ad7
+Revises: 82f36cdf325f
+Create Date: 2023-05-20 04:29:49.322186
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '65a56c245ad7'
+down_revision = '82f36cdf325f'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('log_record_tag',
+    sa.Column('log_record_tag_id', sa.Integer(), nullable=False),
+    sa.Column('log_record_id', sa.Integer(), nullable=False),
+    sa.Column('tag_id', sa.Integer(), nullable=False),
+    sa.ForeignKeyConstraint(['log_record_id'], ['log_records.log_id'], ),
+    sa.ForeignKeyConstraint(['tag_id'], ['tags.tag_id'], ),
+    sa.PrimaryKeyConstraint('log_record_tag_id')
+    )
+    with op.batch_alter_table('log_records', schema=None) as batch_op:
+        batch_op.drop_column('tags')
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('log_records', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('tags', postgresql.ARRAY(sa.VARCHAR()), autoincrement=False, nullable=True))
+
+    op.drop_table('log_record_tag')
+    # ### end Alembic commands ###