General clean up. Workon event abstracts.

app/main.py

@@ -18,7 +18,7 @@ from . import config
 from app.log import log, logging
 
 # Import the routers here first:
-from app.routers import aether_cfg, api_crud, api, importing, sql, account, activity_log, address, archive, archive_content, contact, cont_edu_cert, cont_edu_cert_person, data_store, event, event_badge, event_badge_importing, event_badge_template, event_device, event_exhibit, event_exhibit_tracking, event_file, event_importing, event_location, event_person, event_person_detail, event_person_tracking, event_presentation, event_presenter, event_registration, event_session, flask_cfg, fundraising, hosted_file, journal, journal_entry, log_client_viewing, lookup, membership_cfg, membership_group, membership_person_group, membership_person, membership_person_profile, membership_type, membership_person_type, order, order_v3, order_line, order_cart, organization, page, person, person_user, post, post_comment, product, qr, site, site_domain, user, websockets, e_cvent, c_idaa, e_impexium, e_stripe
+from app.routers import aether_cfg, api_crud, api, importing, sql, account, activity_log, address, archive, archive_content, contact, cont_edu_cert, cont_edu_cert_person, data_store, event, event_abstract, event_badge, event_badge_importing, event_badge_template, event_device, event_exhibit, event_exhibit_tracking, event_file, event_importing, event_location, event_person, event_person_detail, event_person_tracking, event_presentation, event_presenter, event_registration, event_session, flask_cfg, fundraising, hosted_file, journal, journal_entry, log_client_viewing, lookup, membership_cfg, membership_group, membership_person_group, membership_person, membership_person_profile, membership_type, membership_person_type, order, order_v3, order_line, order_cart, organization, page, person, person_user, post, post_comment, product, qr, site, site_domain, user, websockets, e_cvent, c_idaa, e_impexium, e_stripe
 
 from app.db_sql import sql_select # , sql_connect
 
@@ -175,6 +175,10 @@ app.include_router(
     # prefix='/event',
     tags=['Event'],
 )
+app.include_router(
+    event_abstract.router,
+    tags=['Event Abstract'],
+)
 app.include_router(
     event_badge.router,
     tags=['Event Badge'],

app/methods/event_abstract_methods.py

@@ -0,0 +1,363 @@
+import datetime
+
+from typing import Dict, List, Optional, Set, Union
+from pydantic import BaseModel, EmailStr, Field, PrivateAttr, ValidationError, validator
+
+from app.db_sql import redis_lookup_id_random, sql_delete, sql_insert, sql_select, sql_update, sql_enable_part, sql_limit_offset_part
+from app.lib_general import log, logging, logger_reset
+
+# from app.methods.event_abstract_tracking_methods import get_event_abstract_tracking_rec_list, load_event_abstract_tracking_obj
+# from app.methods.event_person_methods import load_event_person_obj
+
+from app.models.common_field_schema import default_num_bytes
+from app.models.event_abstract_models import Event_Abstract_Base
+
+
+# ### BEGIN ### API Event Abstract Methods ### load_event_abstract_obj() ###
+# Updated 2023-03-20
+@logger_reset
+def load_event_abstract_obj(
+        event_abstract_id: int|str,
+
+        enabled: str = 'enabled', # enabled, disabled, all
+        approved: str = 'all', # approved, not_approved, all
+        hidden: str = 'not_hidden', # hidden, not_hidden, all
+        review: str = 'all', # ready, not_ready, all
+
+        inc_event_file_list: bool = False,
+        inc_event_person: bool = False,
+        inc_event_presentation_list: bool = False,
+        inc_event_presenter_list: bool = False,
+        inc_hosted_file: bool = False,
+
+        limit: int = 1500,
+        offset: int = 0,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
+        model_as_dict: bool = False,
+        ) -> Event_Abstract_Base|dict|bool:
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    # if event_abstract_id := redis_lookup_id_random(record_id_random=event_abstract_id, table_name='event_abstract'): pass
+    # else: return False
+
+    if event_abstract_rec := sql_select(table_name='v_event_abstract', record_id=event_abstract_id): pass
+    else: return False
+
+    try:
+        event_abstract_obj = Event_Abstract_Base(**event_abstract_rec)
+        log.debug(event_abstract_obj)
+    except ValidationError as e:
+        log.error(e.json())
+        return False
+
+    # Updated 2023-03-20
+    if inc_event_file_list:
+        # log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.info('Need to include event file list...')
+
+        from app.methods.event_file_methods import get_event_file_rec_list, load_event_file_obj
+        if event_file_rec_list_result := get_event_file_rec_list(
+                for_type = 'event_abstract',
+                for_id = event_abstract_id,
+                # file_purpose_id = event_file_file_purpose_id,
+                # file_purpose = event_file_file_purpose,
+                # priority = event_file_priority,
+                # group = event_file_group,
+                enabled = enabled,
+                limit = limit,
+                ):
+            event_file_result_list = []
+            for event_file_rec in event_file_rec_list_result:
+                if load_event_file_result := load_event_file_obj(
+                        event_file_id = event_file_rec.get('event_file_id', None),
+                        enabled = enabled,
+                        inc_hosted_file = inc_hosted_file,
+                        # model_as_dict = True,
+                        # by_alias = by_alias,
+                        # exclude_unset = False,
+                        ):
+                    event_file_result_list.append(load_event_file_result)
+                else:
+                    event_file_result_list.append(None)
+            log.debug(event_file_result_list)
+            event_abstract_obj.event_file_list = event_file_result_list
+        elif isinstance(event_file_rec_list_result, list):
+            event_abstract_obj.event_file_list = []
+        else:
+            event_abstract_obj.event_file_list = None
+
+    # Updated 2023-03-20
+    if inc_event_person:
+        # log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.info('Need to include event person...')
+
+        if event_person_obj := load_event_person_obj(
+                event_person_id = event_abstract_obj.event_person_id,
+                enabled = enabled,
+                # inc_address = inc_address,
+                # inc_contact = inc_contact,
+                # inc_event_abstract = inc_event_abstract,
+                # inc_event_person_profile = inc_event_person_profile,
+                # inc_event_registration = inc_event_registration,
+                # inc_person = inc_person,
+                # inc_user = inc_user,
+                ):
+            log.debug(event_person_obj)
+            event_abstract_obj.event_person = event_person_obj
+        else:
+            log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+            log.debug(event_person_obj)
+            event_abstract_obj.event_person = None
+        log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+
+    # Updated 2023-03-20
+    if inc_event_presenter_list:
+        log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.info('Need to include Event Presenter List data...')
+        if event_presenter_rec_list_result := get_event_presenter_rec_list(
+                event_abstract_id = event_abstract_id,
+                limit = limit,
+                enabled = enabled,
+                hidden = hidden,
+                ):
+            event_presenter_result_list = []
+            for event_presenter_rec in event_presenter_rec_list_result:
+                event_presenter_result_list.append(
+                    load_event_presenter_obj(
+                        event_presenter_id = event_presenter_rec.get('event_presenter_id'),
+                        inc_event_person = inc_event_person,
+                        )
+                    )
+            event_abstract_obj.event_abstract_list = event_abstract_result_list
+        else: event_abstract_obj.event_abstract_list = []
+        # log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+
+    if model_as_dict:
+        return event_abstract_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
+    else:
+        return event_abstract_obj
+# ### END ### API Event Abstract Methods ### load_event_abstract_obj() ###
+
+
+# ### BEGIN ### API Event Abstract Methods ### get_event_abstract_rec_list() ###
+# Updated 2023-03-20
+@logger_reset
+def get_event_abstract_rec_list(
+        event_id: None|str = None,
+        event_person_id: None|str = None,
+
+        abstract_type_code: str = None, # not sure yet
+
+        approved: str = 'all', # not_approved, approved, all
+
+        enabled: str = 'enabled', # enabled, disabled, all
+        limit: int = 250,
+        offset: int = 0,
+        ) -> list|bool:
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if event_id := redis_lookup_id_random(record_id_random=event_id, table_name='event'): pass
+    elif event_id is None: pass
+    else: return False
+
+    if event_person_id := redis_lookup_id_random(record_id_random=event_person_id, table_name='event_person'): pass
+    elif event_person_id is None: pass
+    else: return False
+
+    data = {}
+    # data['event_id'] = event_id
+
+    if event_id:
+        data['event_id'] = event_id
+        sql_event_id = f'AND `event_abstract`.event_id = :event_id'
+    else: sql_event_id = '1=1'
+
+    if event_person_id:
+        data['event_person_id'] = event_person_id
+        sql_event_person_id = f'AND `event_abstract`.event_person_id = :event_person_id'
+    else: sql_event_person_id = ''
+
+    if abstract_type_code:
+        data['abstract_type_code'] = abstract_type_code
+        sql_abstract_type_code = f'AND `event_abstract`.abstract_type_code = :abstract_type_code'
+    else: sql_abstract_type_code = ''
+
+    if approved in ['not_approved', 'approved', 'all']:
+        log.info(f'Creating partial SQL string for "approved" check. Printed: {approved}')
+        if approved == 'not_approved':
+            sql_abstract_approved = f'AND (`event_abstract`.approve IS NULL OR `event_abstract`.approved = FALSE)'
+        elif approved == 'approved':
+            sql_abstract_approved = f'AND `event_abstract`.approve = TRUE'
+        elif approved == 'all':
+            sql_abstract_approved = f'AND (`event_abstract`.approve IS NULL OR `event_abstract`.approve IS NOT NULL)'
+        log.debug(sql_abstract_approved)
+    else: sql_abstract_approved = ''
+
+    sql_enabled, data['enable'] = sql_enable_part(table_name='event_abstract', enabled=enabled) # Reasonably safe return str and bool
+    sql_limit = sql_limit_offset_part(limit=limit, offset=offset) # Reasonably safe return str
+
+    sql = f"""
+        SELECT `event_abstract`.id AS 'event_abstract_id', `event_abstract`.id_random AS 'event_abstract_id_random'
+        FROM `v_event_abstract` AS `event_abstract`
+        WHERE
+            {sql_event_id}
+            {sql_event_person_id}
+            {sql_abstract_type_code}
+            {sql_abstract_approved}
+            {sql_enabled}
+        ORDER BY event_abstract.priority DESC, event_abstract.sort DESC, event_abstract.name ASC, `event_abstract`.created_on DESC, `event_abstract`.updated_on DESC
+        {sql_limit};
+        """
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(sql)
+
+    if event_abstract_rec_li_result := sql_select(data=data, sql=sql, as_list=True):
+        event_abstract_rec_li = event_abstract_rec_li_result
+    else: # [] or False
+        event_abstract_rec_li = event_abstract_rec_li_result
+
+    log.debug(event_abstract_rec_li_result)
+
+    return event_abstract_rec_li
+# ### END ### API Event Abstract Methods ### get_event_abstract_rec_list() ###
+
+
+# ### BEGIN ### API Event Abstract Methods ### create_update_event_abstract_obj() ###
+# Updated 2023-03-20
+@logger_reset
+def create_update_event_abstract_obj(
+        event_abstract_dict_obj: Event_Abstract_Base|dict,
+        event_abstract_id: int|str = None,
+        event_id: int|str = None,
+        event_person_id: int|str = None,
+        create_sub_obj: bool = False,
+        fail_any: bool = False, # Fail if any thing goes wrong for sub objects
+        return_outline: bool = False,
+        ) -> int|bool:
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    log.info('Checking requirements...')
+    if event_abstract_id:
+        log.info(f'Event Abstract ID passed. Update existing Event Abstract. Event Abstract ID: {event_abstract_id}')
+
+        if event_abstract_id := redis_lookup_id_random(record_id_random=event_abstract_id, table_name='event_abstract'): pass
+        else:
+            log.error('Event Abstract ID passed but is invalid. Failed requirement.')
+            return False
+
+        if event_id := redis_lookup_id_random(record_id_random=event_id, table_name='event'):
+            log.info(f'Event ID: {event_id}')
+        elif event_id is None:
+            log.error('Missing Event ID. Not required. Ignoring.')
+            log.info(f'Event ID: {event_id}')
+        else:
+            log.error('Invalid Event ID passed. Not required. But not ignoring since it is likely invalid.')
+            log.info(f'Event ID: {event_id}')
+            return False
+    else:
+        log.info('No Event Abstract ID passed. Create new Event Abstract. Required: Event ID')
+
+        if event_id := redis_lookup_id_random(record_id_random=event_id, table_name='event'):
+            log.info(f'Event ID: {event_id}')
+        elif event_id is None:
+            log.error('Missing Event ID. Failed requirement.')
+            log.info(f'Event ID: {event_id}')
+            return False
+        else:
+            log.error('Invalid Event ID passed. Failed requirement.')
+            log.info(f'Event ID: {event_id}')
+            return False
+        # else:
+        #     log.error('Missing or invalid Event ID passed. Failed requirement.')
+        #     log.info(f'Event ID: {event_id}')
+        #     return False
+
+    log.debug(type(event_abstract_dict_obj))
+    if isinstance(event_abstract_dict_obj, dict):
+        event_abstract_dict = event_abstract_dict_obj
+        if event_abstract_id:
+            event_abstract_dict['event_abstract_id'] = event_abstract_id
+        if event_id:
+            event_abstract_dict['event_id'] = event_id
+        if event_person_id:
+            event_abstract_dict['event_person_id'] = event_person_id
+        try:
+            event_abstract_obj = Event_Abstract_Base(**event_abstract_dict)
+            log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+            log.debug(event_abstract_obj)
+        except ValidationError as e:
+            log.error(e.json())
+            return False
+    else:
+        event_abstract_obj = event_abstract_dict_obj
+        if event_abstract_id:
+            # NOTE: Can't update the ID alias if it was never set.
+            event_abstract_obj.id = event_abstract_id
+        if event_id:
+            event_abstract_obj.event_id = event_id
+        if event_person_id:
+            event_abstract_obj.event_person_id = event_person_id
+
+        event_abstract_dict = event_abstract_obj.dict(by_alias=False, exclude_defaults=False, exclude_unset=True, exclude={'event_person', 'event_person_list', 'created_on', 'updated_on'})
+
+    if event_abstract_id:
+        if event_abstract_dict_up_result := sql_update(data=event_abstract_dict, table_name='event_abstract', rm_id_random=True): pass
+        else:
+            log.warning(f'Event Abstract not updated. Event Abstract ID: {event_abstract_id}')
+            log.debug(event_abstract_dict_up_result)
+            return False
+        log.debug(event_abstract_dict_up_result)
+    else:
+        if event_abstract_dict_in_result := sql_insert(data=event_abstract_dict, table_name='event_abstract', rm_id_random=True, id_random_length=None): pass
+        else:
+            log.warning(f'Event Abstract not created.')
+            log.debug(event_abstract_dict_in_result)
+            return False
+        log.debug(event_abstract_dict_in_result)
+
+        event_abstract_id = event_abstract_dict_in_result
+
+    event_abstract_outline = {}
+    event_abstract_outline['event_id'] = event_id
+    event_abstract_outline['event_abstract_id'] = event_abstract_id
+    event_abstract_outline['event_person_id'] = event_person_id
+    # event_abstract_outline['event_presenter_list'] = []
+
+    # if event_abstract_obj.event_presenter_list and isinstance(event_abstract_obj.event_presenter_list, list):
+    #     log.info(f'Event Presenter List was found. Loop through and create a new Event Presenter for each and link them to the new Event Abstract. Event Abstract ID: {event_abstract_id}')
+    #     for event_presenter_obj in event_abstract_obj.event_presenter_list:
+    #         # NOTE: Use object model version because of better type checking and validations
+    #         log.debug(event_presenter_obj)
+    #         if event_presenter_id := event_presenter_obj.id: pass
+    #         else: event_presenter_id = None
+    #         # event_presenter_obj.event_id = event_id
+    #         # event_presenter_obj.event_session_id = event_session_id
+    #         create_update_event_presenter_obj_result = create_update_event_presenter_obj_v4(
+    #                 event_presenter_dict_obj = event_presenter_obj,
+    #                 event_presenter_id = event_presenter_id,
+    #                 event_id = event_id,
+    #                 event_session_id = event_session_id,
+    #                 event_abstract_id = event_abstract_id,
+    #                 fail_any = fail_any,
+    #                 return_outline = return_outline,
+    #                 )
+    #         if isinstance(create_update_event_presenter_obj_result, int):
+    #             event_presenter_id = create_update_event_presenter_obj_result
+    #         elif create_update_event_presenter_obj_result == True: pass
+    #         else:
+    #             log.warning(f'Create or Update failed while trying create_update_event_presenter_obj_v4(): {create_update_event_presenter_obj_result}')
+    #             event_presenter_id = None
+
+    #         event_abstract_outline['event_presenter_id'] = event_presenter_id
+
+    if return_outline:
+        log.debug(f'Returning the Event Abstract Outline: {event_abstract_outline}')
+        return event_abstract_outline
+    else:
+        log.debug(f'Returning the Event Abstract ID: {event_abstract_id}')
+        return event_abstract_id
+# ### END ### API Event Abstract Methods ### create_update_event_abstract_obj() ###

app/methods/event_person_methods.py

@@ -80,12 +80,44 @@ def load_event_person_obj(
     # person_id = event_person_obj.person_id
     # user_id = event_person_obj.user_id
 
-    if inc_event_abstract_list: pass
+    # Updated 2023-03-20
+    if inc_event_abstract_list:
+        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.info('Need to include event abstract list...')
+        from app.methods.event_abstract_methods import get_event_abstract_rec_list, load_event_abstract_obj
+        if event_abstract_rec_list_result := get_event_abstract_rec_list(
+                event_id = None,
+                event_person_id = event_person_id,
+                # event_presentation_id = event_presentation_id,
+                enabled = enabled,
+                limit = limit,
+                ):
+            event_abstract_result_list = []
+            for event_abstract_rec in event_abstract_rec_list_result:
+                if load_event_abstract_result := load_event_abstract_obj(
+                        event_abstract_id = event_abstract_rec.get('event_abstract_id', None),
+                        enabled = enabled,
+                        limit = limit,
+                        # inc_event_file_list = inc_event_file_list,
+                        # inc_event_person = False,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
+                        # model_as_dict = model_as_dict,
+                        ):
+                    event_abstract_result_list.append(load_event_abstract_result)
+                else:
+                    event_abstract_result_list.append(None)
+            log.debug(event_abstract_result_list)
+            event_person_obj.event_abstract_list = event_abstract_result_list
+        # elif isinstance(event_abstract_rec_list_result, list):
+        #     event_person_obj.event_abstract_list = []
+        else:
+            event_person_obj.event_abstract_list = [] # None
 
     # Updated 2021-08-17
     if inc_event_badge:
+        log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
         log.info('Need to include event badge data...')
-        # log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
         event_badge_id = event_person_rec.get('event_badge_id', None)
         if event_badge_obj := load_event_badge_obj(
                 event_badge_id = event_badge_id

app/methods/event_presenter_methods.py

@@ -211,7 +211,7 @@ def get_event_presenter_rec_list(
         limit: int = 100,
         offset: int = 0,
         ) -> list|bool:
-    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
     log.debug(locals())
 
     if event_person_id := redis_lookup_id_random(record_id_random=event_person_id, table_name='event_person'): pass
@@ -288,7 +288,7 @@ def get_event_presenter_rec_list(
 def get_event_session_id_w_event_presentation_id(
         event_presentation_id: int|str,
         ) -> bool|int|None:
-    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
     log.debug(locals())
 
     if event_presentation_id := redis_lookup_id_random(record_id_random=event_presentation_id, table_name='event_presentation'): pass
@@ -330,7 +330,7 @@ def create_update_event_presenter_obj_v4(
         fail_any: bool = False, # Fail if any thing goes wrong for sub objects
         return_outline: bool = False,
         ) -> int|bool:
-    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
     log.debug(locals())
 
     log.info('Checking requirements...')

app/models/event_abstract_models.py

@@ -9,10 +9,10 @@ from app.lib_general import log, logging
 from app.models.common_field_schema import base_fields, default_num_bytes
 
 #from app.models.event_models import Event_Base
-from app.models.event_person_models import Event_Person_Base
+# from app.models.event_person_models import Event_Person_Base
-from app.models.event_presentation_models import Event_Presentation_Base
+# from app.models.event_presentation_models import Event_Presentation_Base
 #from app.models.event_presenter_models import Event_Presenter_Base # This creates an import loop
-from app.models.event_session_models import Event_Session_Base
+# from app.models.event_session_models import Event_Session_Base
 
 
 # ### BEGIN ### API Event Abstract Models ### Event_Abstract_Base() ###
@@ -56,10 +56,10 @@ class Event_Abstract_Base(BaseModel):
     description: Optional[str]
     abstract: Optional[str]
 
-    hide: Optional[bool]
+    data_json: Optional[Json]
-    public: Optional[bool]
-    public_hide: Optional[bool]
 
+    enable: Optional[bool]
+    hide: Optional[bool]
     priority: Optional[bool]
     sort: Optional[int]
     group: Optional[str]
@@ -71,13 +71,13 @@ class Event_Abstract_Base(BaseModel):
     # Including other related objects
     #event: Optional[Event_Base]
     event_file_list: Optional[list] # Optional[Event_File_Base]
-    event_person: Optional[Event_Person_Base]
+    # event_person: Optional[Event_Person_Base]
-    event_presentation: Optional[Event_Presentation_Base]
+    # event_presentation: Optional[Event_Presentation_Base]
     #event_presenter: Optional[Event_Presenter_Base] # This creates an import loop
     event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
-    event_session: Optional[Event_Session_Base]
+    # event_session: Optional[Event_Session_Base]
     # event_track: Optional[Event_Track_Base]
-    poc_event_person: Optional[Event_Person_Base] # Maybe change this to primary_event_person?
+    # poc_event_person: Optional[Event_Person_Base] # Maybe change this to primary_event_person?
     # poc_person: Optional[Person_Base] # Maybe change this to primary_person?
 
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)

app/models/event_exhibit_tracking_models.py

@@ -43,8 +43,8 @@ class Event_Exhibit_Tracking_Base(BaseModel):
     # responses_json: Optional[Json] = Field(
     #     default_factory = lambda:[{'test': ''}]
     # )
-    # json_data: Optional[str]
+    data_json: Optional[Json]
-    json_data: Optional[Json]
+    # data_json: Optional[str]
 
     enable: Optional[bool]
     hide: Optional[bool]

app/models/event_person_models.py

@@ -8,6 +8,7 @@ from app.lib_general import log, logging
 
 from app.models.common_field_schema import base_fields, default_num_bytes
 # from app.models.event_models import Event_Base # Causes an import loop
+from app.models.event_abstract_models import Event_Abstract_Base
 from app.models.event_badge_models import Event_Badge_Base
 # from app.models.event_exhibit_tracking_models import Event_Exhibit_Tracking_Base # Causes an import loop
 from app.models.event_person_profile_models import Event_Person_Profile_Base
@@ -113,7 +114,7 @@ class Event_Person_Base(BaseModel):
 
     # Including other related objects
     # event: Optional[Event_Base] # Causes an import loop
-    event_abstract_list: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more abstracts
+    event_abstract_list: Optional[list[Event_Abstract_Base]] # Use event_person_detail table. An event_person record can be linked to one or more abstracts
     event_badge: Optional[Event_Badge_Base] # Default attendee badge
     event_badge_vendor: Optional[Event_Badge_Base] # Additional vendor badge
     event_badge_vip: Optional[Event_Badge_Base] # Additional VIP badge

app/models/person_models.py

@@ -120,6 +120,7 @@ class Person_Base(BaseModel):
     # Maybe add timezone in the future?
 
     # Including JSON data
+    data_json: Optional[Json]
     other_json: Optional[Json]
     meta_json: Optional[Json]
 

app/routers/event_abstract.py

@@ -0,0 +1,168 @@
+import datetime, json
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Response, status
+from pydantic import BaseModel, EmailStr, Field
+from typing import Dict, List, Optional, Set, Union
+
+from app.lib_general import log, logging, common_route_params, Common_Route_Params
+from app.config import settings
+from app.db_sql import sql_insert, sql_update, sql_insert_or_update, sql_select, sql_delete, get_id_random, redis_lookup_id_random
+
+from app.routers.api_crud import delete_obj_template, get_obj_template, get_obj_li_template, patch_obj_template, post_obj_template
+
+from app.methods.event_abstract_methods import create_update_event_abstract_obj, load_event_abstract_obj, get_event_abstract_rec_list
+
+from app.models.event_abstract_models import Event_Abstract_Base
+from app.models.response_models import Resp_Body_Base, mk_resp
+
+
+router = APIRouter()
+
+
+# ### BEGIN ### API Event Abstract ### post_event_abstract_obj() ###
+# Updated 2023-03-20
+@router.post('/event/abstract', response_model=Resp_Body_Base)
+async def post_event_abstract_obj(
+        event_abstract_obj: Event_Abstract_Base,
+        create_sub_obj: bool = False,
+        fail_any: bool = True, # Fail if any thing goes wrong for sub objects
+
+        inc_event_presentation_list: bool = False,
+        inc_event_presenter_list: bool = False,
+
+        commons: Common_Route_Params = Depends(common_route_params),
+        ):
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    # There should probably be a check for the event ID before calling the create function?
+    if create_event_abstract_obj_result := create_update_event_abstract_obj(
+            event_abstract_dict_obj = event_abstract_obj,
+            event_id = event_abstract_obj.event_id,
+            create_sub_obj = create_sub_obj,
+            fail_any = fail_any,
+            return_outline = False,
+            ): pass
+    else: return mk_resp(data=False, status_code=400, response=commons.response, status_message='The event abstract was not created. Check the field names and data types.')
+
+    if isinstance(create_event_abstract_obj_result, int):
+        event_abstract_id = create_event_abstract_obj_result
+        if return_obj:
+            if load_event_abstract_obj_result := load_event_abstract_obj(
+                    event_abstract_id = event_abstract_id,
+                    inc_event_presentation_list = inc_event_presentation_list,
+                    inc_event_presenter_list = inc_event_presenter_list,
+                    ):
+                data = load_event_abstract_obj_result
+            else:
+                data = False
+        else:
+            event_abstract_id = event_abstract_id
+            event_abstract_id_random = get_id_random(record_id=event_abstract_id, table_name='event_abstract')
+            data = {}
+            data['event_abstract_id'] = event_abstract_id
+            data['event_abstract_id_random'] = event_abstract_id_random
+        return mk_resp(data=data, response=commons.response, status_message='The event abstract was created.')
+    else:
+        return mk_resp(data=False, status_code=400, response=commons.response, status_message='The result from trying to create an event abstract was unexpected.')
+# ### END ### API Event Abstract ### post_event_abstract_obj() ###
+
+
+# ### BEGIN ### API Event Abstract ### patch_event_abstract_obj() ###
+# Updated 2023-03-20
+@router.patch('/event/abstract/{event_abstract_id}', response_model=Resp_Body_Base)
+async def patch_event_abstract_obj(
+        event_abstract_obj: Event_Abstract_Base,
+        event_abstract_id: str = Query(..., min_length=11, max_length=22),
+        create_sub_obj: bool = False,
+        fail_any: bool = True, # Fail if any thing goes wrong for sub objects
+
+        inc_event_presentation_list: bool = False,
+        inc_event_presenter_list: bool = False,
+
+        commons: Common_Route_Params = Depends(common_route_params),
+        ):
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if event_abstract_id := redis_lookup_id_random(record_id_random=event_abstract_id, table_name='event_abstract'): pass
+    else: return mk_resp(data=None, status_code=404, response=commons.response)
+
+    if update_event_abstract_obj_result := create_update_event_abstract_obj(
+            event_abstract_dict_obj = event_abstract_obj,
+            event_abstract_id = event_abstract_id,
+            event_id = event_abstract_obj.event_id,
+            create_sub_obj = create_sub_obj,
+            fail_any = fail_any,
+            return_outline = False,
+            ): pass
+    else: return mk_resp(data=False, status_code=400, response=commons.response, status_message='The event abstract was not created. Check the field names and data types.')
+
+    if update_event_abstract_obj_result:
+        if return_obj:
+            if load_event_abstract_obj_result := load_event_abstract_obj(
+                    event_abstract_id = event_abstract_id,
+                    inc_event_presentation_list = inc_event_presentation_list,
+                    inc_event_presenter_list = inc_event_presenter_list,
+                    ):
+                data = load_event_abstract_obj_result
+            else:
+                data = False
+        else:
+            event_abstract_id_random = get_id_random(record_id=event_abstract_id, table_name='event_abstract')
+            data = {}
+            data['event_abstract_id'] = event_abstract_id
+            data['event_abstract_id_random'] = event_abstract_id_random
+        return mk_resp(data=data, response=commons.response, status_message='The event abstract was created or updated.')
+    else:
+        return mk_resp(data=False, status_code=400, response=commons.response, status_message='The result from trying to create an event abstract was unexpected.')
+# ### END ### API Event Abstract ### patch_event_abstract_obj() ###
+
+
+# ### BEGIN ### API Event Abstract ### get_event_abstract_obj() ###
+# Updated 2023-03-20
+@router.get('/event/abstract/{event_abstract_id}', response_model=Resp_Body_Base)
+async def get_event_abstract_obj(
+        event_abstract_id: str = Query(..., min_length=11, max_length=22),
+
+        inc_event_person: bool = False,
+        # inc_event_person_profile: bool = False,
+        inc_event_presentation_list: bool = False,
+        inc_event_presenter_list: bool = False,
+
+        approved: str = 'all', # approved, not_approved, all
+        hidden: str = 'not_hidden', # hidden, not_hidden, all
+        review: str = 'all', # hidden, not_hidden, all
+
+        commons: Common_Route_Params = Depends(common_route_params),
+        ):
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    # time.sleep(.5)
+
+    # ### SECTION ### Secondary data validation
+    event_abstract_id_random = event_abstract_id # This is used later for the response data
+    if event_abstract_id := redis_lookup_id_random(record_id_random=event_abstract_id, table_name='event_abstract'): pass
+    else: return mk_resp(data=None, status_code=404, response=commons.response, status_message='The Event Abstract ID was invalid or not found.')
+
+    if event_abstract_obj_result := load_event_abstract_obj(
+            event_abstract_id = event_abstract_id,
+
+            enabled = commons.enabled,
+            approved = approved, # approved, not_approved, all
+            hidden = hidden, # hidden, not_hidden, all
+            review = review, # ready, not_ready, all
+
+            inc_event_person = inc_event_person,
+            inc_event_presentation_list = inc_event_presentation_list,
+            inc_event_presenter_list = inc_event_presenter_list,
+            ):
+        log.info('Loading successful. Returning result')
+        return mk_resp(data=event_abstract_obj_result, response=commons.response) # Success
+    elif isinstance(event_abstract_obj_result, list) or event_abstract_obj_result is None: # Empty list or None
+        log.info('No results')
+        return mk_resp(data=None, status_code=404, response=commons.response) # Not Found
+    else:
+        log.warning('Likely bad request')
+        return mk_resp(data=False, status_code=400, response=commons.response) # Bad Request
+# ### END ### API Event Abstract ### get_event_abstract_obj() ###

app/routers/person.py

@@ -340,7 +340,7 @@ async def get_person_obj(
 
         commons: Common_Route_Params = Depends(common_route_params),
         ):
-    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
     log.debug(locals())
 
     # ### SECTION ### Secondary data validation