Working on event related models and methods. Also, a lot of general clean up of everything.

app/db_sql.py

@@ -6,7 +6,7 @@ from app.config import settings
 from .log import *
 #from .lib_general import lookup_id_random_pop
 
-from sqlalchemy import create_engine, text
+from sqlalchemy import create_engine, text, Time
 from sqlalchemy.exc import IntegrityError, OperationalError
 
 
@@ -384,10 +384,21 @@ def sql_select(
         return False # Not successful
 
     #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug('*** ** * ** ***')
     log.debug(sql)
+    log.debug('*** ** * ** ***')
     log.debug(data)
+    log.debug('*** ** * ** ***')
+    log.debug(vars(sql))
+    log.debug('*** ** * ** ***')
+    log.debug(dir(sql))
+    log.debug('*** ** * ** ***')
 
     try:
+        # https://docs.sqlalchemy.org/en/13/core/tutorial.html#using-textual-sql
+        # https://docs.sqlalchemy.org/en/13/core/sqlelement.html#sqlalchemy.sql.expression.TextClause.columns
+        # https://docs.sqlalchemy.org/en/13/core/type_basics.html
+        sql = sql.columns(recurring_start_time=Time, recurring_end_time=Time)
         if data:
             log.info('Executing with SQL statement and data...')
             result = db.execute(sql, data)

app/methods/event_methods.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+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_insert, sql_select, sql_update
+from app.lib_general import log, logging
+
+from app.methods.event_session_methods import load_event_session_obj
+from app.methods.person_methods import load_person_obj
+from app.methods.user_methods import load_user_obj
+
+from app.models.event_models import Event_Base
+
+
+# ### BEGIN ### API Event Methods ### load_event_obj() ###
+def load_event_obj(
+    event_id: int|str,
+    enabled: str = 'enabled', # enabled, disabled, all
+    inc_event_abstract_list: bool = False,
+    inc_event_badge_list: bool = False,
+    inc_event_device_list: bool = False,
+    inc_event_exhibit_list: bool = False,
+    inc_event_file_list: bool = False,
+    inc_event_location_list: bool = False,
+    inc_event_person_list: bool = False,
+    inc_event_presentation_list: bool = False,
+    inc_event_presenter_list: bool = False,
+    inc_event_registration_list: bool = False,
+    inc_event_session_list: bool = False,
+    inc_event_track_list: bool = False,
+    inc_event_cfg: bool = False,
+    inc_event_registration_cfg: bool = False,
+    inc_poc_event_person: bool = False,
+    inc_poc_person: bool = False,
+    inc_user: bool = False,
+    ) -> Event_Base|bool:
+    log.setLevel(logging.WARNING) # 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
+    else: return False
+
+    if event_rec := sql_select(table_name='v_event', record_id=event_id):
+        #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.debug(event_rec)
+
+        try:
+            event_obj = Event_Base(**event_rec)
+            log.debug(event_obj)
+        except ValidationError as e:
+            log.error(e.json())
+            return False
+
+        account_id = event_rec.get('account_id', None)
+        event_id = event_rec.get('event_id', None)
+        poc_event_person_id = event_rec.get('poc_event_person_id', None)
+        poc_person_id = event_rec.get('poc_person_id', None)
+        user_id = event_rec.get('user_id', None)
+
+        #if inc_event: pass
+        if inc_event_abstract_list: pass
+        if inc_event_badge_list: pass
+        if inc_event_device_list: pass
+        if inc_event_exhibit_list: pass
+        if inc_event_file_list: pass
+        if inc_event_location_list: pass
+        if inc_event_person_list: pass
+        if inc_event_presentation_list: pass
+        if inc_event_presenter_list: pass
+        if inc_event_registration_list: pass
+        if inc_event_session_list:
+            log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+
+            data = {}
+            data['event_id'] = event_id
+
+            if enabled in ['enabled', 'disabled', 'all']:
+                if enabled == 'enabled':
+                    data['enable'] = True
+                    sql_enabled = f'AND `event_session`.enable = :enable'
+                elif enabled == 'disabled':
+                    data['enable'] = False
+                    sql_enabled = f'AND `event_session`.enable = :enable'
+                elif enabled == 'all':
+                    sql_enabled = ''
+            # else: event_obj['event_session'] = None
+
+            # if limit:
+            #     data['limit'] = limit
+            #     sql_limit = f'LIMIT :limit'
+            # else:
+            #     sql_limit = ''
+
+            sql = f"""
+                SELECT `event_session`.id AS 'event_session_id', `event_session`.id_random AS 'event_session_id_random'
+                FROM `event_session` AS `event_session`
+                WHERE `event_session`.event_id = :event_id
+                {sql_enabled}
+                ORDER BY `event_session`.created_on DESC, `event_session`.updated_on DESC;
+                """
+
+            log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+            if event_session_obj_li_result := sql_select(data=data, sql=sql, as_list=True):
+                log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+                log.debug(event_session_obj_li_result)
+                event_session_obj_li = []
+                for event_session_obj in event_session_obj_li_result:
+                    event_session_id = event_session_obj.get('event_session_id', None)
+                    if event_session_obj := load_event_session_obj(
+                        event_session_id=event_session_id,
+                        inc_event_abstract_list=inc_event_abstract_list,
+                        inc_event_device_list=inc_event_device_list,
+                        inc_event_file_list=inc_event_file_list,
+                        inc_event_person_list=inc_event_person_list,
+                        inc_event_presentation_list=inc_event_presentation_list,
+                        inc_event_presenter_list=inc_event_presenter_list,
+                        inc_event_track_list=inc_event_track_list,
+                        ):
+                        data = event_session_obj.dict(by_alias=True, exclude_unset=True)
+                        event_session_obj_li.append(data)
+                log.debug(event_session_obj_li)
+                #event_rec['event_session_list'] = event_session_obj_li
+                event_obj.event_session_list = event_session_obj_li
+            else:
+                log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+                log.debug(event_session_obj_li_result)
+            log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+
+        if inc_event_track_list: pass
+        if inc_event_cfg: pass
+        if inc_event_registration_cfg: pass
+        if inc_poc_event_person: pass
+        if inc_poc_person:
+            person_obj = load_person_obj(person_id=poc_person_id)
+            log.debug(person_obj)
+            #event_rec['poc_person'] = person_obj
+            #log.debug(event_rec)
+            event_obj.poc_person = person_obj
+            log.debug(event_obj)
+        if inc_user:
+            user_obj = load_user_obj(user_id=user_id)
+            log.debug(user_obj)
+            #event_rec['user'] = user_obj
+            #log.debug(event_rec)
+            event_obj.user = user_obj
+            log.debug(event_obj)
+    else:
+        return False
+
+    return event_obj

app/methods/event_session_methods.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+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_insert, sql_select, sql_update
+from app.lib_general import log, logging
+
+# from app.methods.event_methods import load_event_obj
+# from app.methods.event_file_methods import load_event_file_obj
+# from app.methods.event_location_methods import load_event_location_obj
+# from app.methods.event_presentation_methods import load_event_presentation_obj
+# from app.methods.event_presenter_methods import load_event_presenter_obj
+from app.methods.person_methods import load_person_obj
+# from app.methods.user_methods import load_user_obj
+
+from app.models.event_session_models import Event_Session_Base
+
+
+# ### BEGIN ### API Event Session Methods ### load_event_session_obj() ###
+def load_event_session_obj(
+    event_session_id: int|str,
+    enabled: str = 'enabled', # enabled, disabled, all
+    inc_event_abstract_list: bool = False,
+    inc_event_badge_list: bool = False,
+    inc_event_device_list: bool = False,
+    inc_event_exhibit_list: bool = False,
+    inc_event_file_list: bool = False,
+    inc_event_location_list: bool = False,
+    inc_event_person_list: bool = False,
+    inc_event_presentation_list: bool = False,
+    inc_event_presenter_list: bool = False,
+    inc_event_registration_list: bool = False,
+    inc_event_session_list: bool = False,
+    inc_event_track_list: bool = False,
+    inc_event_cfg: bool = False,
+    inc_event_registration_cfg: bool = False,
+    inc_poc_event_person: bool = False,
+    inc_poc_person: bool = False,
+    #inc_user: bool = False,
+    ) -> Event_Session_Base|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if event_session_id := redis_lookup_id_random(record_id_random=event_session_id, table_name='event_session'): pass
+    else: return False
+
+    if event_session_rec := sql_select(table_name='v_event_session', record_id=event_session_id):
+        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.debug(event_session_rec)
+
+        event_session_obj = Event_Session_Base(**event_session_rec)
+        log.debug(event_session_obj)
+
+        account_id = event_session_rec.get('account_id', None)
+        event_id = event_session_rec.get('event_id', None)
+        event_location_id = event_session_rec.get('event_location_id', None)
+        event_track_id = event_session_rec.get('event_track_id', None)
+        poc_event_person_id = event_session_rec.get('poc_event_person_id', None)
+        poc_person_id = event_session_rec.get('poc_person_id', None)
+
+        #if inc_event: pass
+        if inc_event_abstract_list: pass
+        if inc_event_badge_list: pass
+        if inc_event_device_list: pass
+        if inc_event_file_list: pass
+        if inc_event_person_list: pass
+        if inc_event_presentation_list: pass
+        if inc_event_presenter_list: pass
+        if inc_poc_event_person: pass
+        if inc_poc_person:
+            person_obj = load_person_obj(person_id=poc_person_id)
+            log.debug(person_obj)
+            event_session_rec['poc_person'] = person_obj
+            log.debug(event_session_rec)
+        #if inc_user: pass
+    else:
+        return False
+
+    try:
+        event_session_obj = Event_Session_Base(**event_session_rec)
+        log.debug(event_session_obj)
+    except ValidationError as e:
+        log.error(e.json())
+        return False
+
+    return event_session_obj

app/models/event_location_models.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+import datetime, hashlib, logging, os, pytz, redis, secrets
+
+from typing import Dict, List, Optional, Set, Union
+from pydantic import BaseModel, EmailStr, Field, Json, PrivateAttr, ValidationError, validator
+
+from app.db_sql import redis_lookup_id_random
+from app.lib_general import log, logging
+
+from .common_field_schema import base_fields, default_num_bytes
+
+#from .event_models import Event_Base
+
+
+class Event_Location_Base(BaseModel):
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    id_random: Optional[str] = Field(
+        **base_fields['event_location_id_random'],
+        alias='event_location_id_random',
+        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
+    )
+    id: Optional[int] = Field(
+        #alias='event_location_id'
+    )
+    event_id_random: Optional[str]
+    event_id: Optional[int]
+    event_track_id_random: Optional[str] # Can a track be assigned to one location?
+    event_track_id: Optional[int] # Can a track be assigned to one location?
+
+    lu_location_type_id: Optional[int]
+    location_type_code: Optional[str]
+    location_type: Optional[str]
+
+    name: Optional[str]
+    description: Optional[str]
+
+    enable: Optional[bool]
+    enable_from: Optional[datetime.datetime] = None
+    enable_to: Optional[datetime.datetime] = None
+
+    hide: Optional[bool]
+    public: Optional[bool]
+    public_hide: Optional[bool]
+    hide_event_launcher: Optional[bool]
+
+    priority: Optional[bool]
+    sort: Optional[int]
+    group: Optional[str]
+
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime] = None
+    updated_on: Optional[datetime.datetime] = None
+
+    # Including other related objects
+    #event: Optional[Event_Base]
+    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base]
+    event_device_list: Optional[list] # Optional[Event_Device_Base]
+    event_file_list: Optional[list] # Optional[Event_File_Base]
+    event_presentation_list: Optional[list] # Optional[Event_Presentation_Base]
+    event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
+    event_session_list: Optional[list] # Optional[Event_Session_Base]
+    event_track_list: Optional[list] # Optional[Event_Track_Base]
+
+    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
+
+    #@validator('event_location_id_random', always=True)
+    def event_location_id_random_copy(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            return values['id_random']
+        return None
+
+    @validator('id', always=True)
+    def event_location_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            log.debug(values['id_random'])
+            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_location')
+        return None
+
+    @validator('event_id', always=True)
+    def event_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
+        return None
+
+    @validator('event_track_id', always=True)
+    def event_track_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_track_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_track_id_random'], table_name='event_track')
+        return None
+
+    class Config:
+        underscore_attrs_are_private = True
+        fields = base_fields
+
+#Event_Location_Base.update_forward_refs()

app/models/event_models.py

@@ -9,6 +9,12 @@ from app.lib_general import log, logging
 
 from .common_field_schema import base_fields, default_num_bytes
 
+from .address_models import Address_Base
+from .contact_models import Contact_Base
+from .event_person_models import Event_Person_Base
+from .person_models import Person_Base
+from .user_models import User_Base
+
 
 class Event_Base(BaseModel):
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
@@ -24,6 +30,10 @@ class Event_Base(BaseModel):
     )
     account_id_random: Optional[str]
     account_id: Optional[int]
+    poc_event_person_id_random: Optional[str]
+    poc_event_person_id: Optional[int]
+    poc_person_id_random: Optional[str]
+    poc_person_id: Optional[int]
     user_id_random: Optional[str]
     user_id: Optional[int]
     lu_event_type_id: Optional[int]
@@ -90,6 +100,23 @@ class Event_Base(BaseModel):
     created_on: Optional[datetime.datetime] = None
     updated_on: Optional[datetime.datetime] = None
 
+    # Including other related objects
+    address_location: Optional[Address_Base]
+    contact_1: Optional[Contact_Base]
+    contact_2: Optional[Contact_Base]
+    contact_3: Optional[Contact_Base]
+    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base]
+    event_device_list: Optional[list] # Optional[Event_Device_Base]
+    event_file_list: Optional[list] # Optional[Event_File_Base]
+    event_location_list: Optional[list] # Optional[Event_Location_Base]
+    event_presentation_list: Optional[list] # Optional[Event_Presentation_Base]
+    event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
+    event_session_list: Optional[list] # Optional[Event_Session_Base]
+    event_track_list: Optional[list] # Optional[Event_Track_Base]
+    poc_event_person: Optional[Event_Person_Base]
+    poc_person: Optional[Person_Base]
+    user: Optional[User_Base]
+
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
 
     #@validator('event_id_random', always=True)
@@ -120,6 +147,25 @@ class Event_Base(BaseModel):
             return redis_lookup_id_random(record_id_random=values['account_id_random'], table_name='account')
         return None
 
+    @validator('poc_event_person_id', always=True)
+    def poc_event_person_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['poc_event_person_id_random']:
+            return redis_lookup_id_random(record_id_random=values['poc_event_person_id_random'], table_name='event_person')
+        return None
+
+    @validator('poc_person_id', always=True)
+    def poc_person_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['poc_person_id_random']:
+            return redis_lookup_id_random(record_id_random=values['poc_person_id_random'], table_name='person')
+        return None
+
+
     @validator('user_id', always=True)
     def user_id_lookup(cls, v, values, **kwargs):
         log.setLevel(logging.WARNING)

app/models/event_person_detail_models.py

@@ -8,6 +8,7 @@ from app.db_sql import redis_lookup_id_random
 from app.lib_general import log, logging
 
 from .common_field_schema import base_fields, default_num_bytes
+
 #from .event_presentation_models import Event_Presentation_Base
 #from .event_presenter_models import Event_Presenter_Base
 from .event_session_models import Event_Session_Base
@@ -28,6 +29,15 @@ class Event_Person_Detail_Base(BaseModel):
     event_person_id_random: Optional[str]
     event_person_id: Optional[int]
 
+    priority: Optional[bool]
+    sort: Optional[int]
+    group: Optional[str]
+
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime] = None
+    updated_on: Optional[datetime.datetime] = None
+
+    # Including other related objects
     #event_abstract: Optional[Event_Abstract_Base]
     #event_exhibit: Optional[Event_Exhibit_Base]
     #event_file: Optional[Event_File_Base]
@@ -37,14 +47,6 @@ class Event_Person_Detail_Base(BaseModel):
     event_session: Optional[Event_Session_Base]
     #event_track: Optional[Event_Track_Base]
 
-    priority: Optional[bool]
-    sort: Optional[int]
-    group: Optional[str]
-
-    notes: Optional[str]
-    created_on: Optional[datetime.datetime] = None
-    updated_on: Optional[datetime.datetime] = None
-
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
 
     #@validator('event_person_detail_id_random', always=True)

app/models/event_person_models.py

@@ -8,7 +8,8 @@ from app.db_sql import redis_lookup_id_random
 from app.lib_general import log, logging
 
 from .common_field_schema import base_fields, default_num_bytes
-from .event_models import Event_Base
+
+#from .event_models import Event_Base
 from .event_badge_models import Event_Badge_Base
 from .event_person_detail_models import Event_Person_Detail_Base
 from .event_registration_models import Event_Registration_Base
@@ -16,6 +17,135 @@ from .person_models import Person_Base
 from .user_models import User_Base, User_Out_Base
 
 
+class Event_Person_Base(BaseModel):
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    id_random: Optional[str] = Field(
+        **base_fields['event_person_id_random'],
+        alias='event_person_id_random',
+        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
+    )
+    id: Optional[int] = Field(
+        #alias='event_person_id'
+    )
+    account_id_random: Optional[str]
+    account_id: Optional[int]
+    event_id_random: Optional[str]
+    event_id: Optional[int]
+    event_registration_id_random: Optional[str]
+    event_registration_id: Optional[int]
+    event_badge_id_random: Optional[str]
+    event_badge_id: Optional[int]
+    person_id_random: Optional[str]
+    person_id: Optional[int]
+    user_id_random: Optional[str]
+    user_id: Optional[int]
+
+    priority: Optional[bool]
+    sort: Optional[int]
+    group: Optional[str]
+
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime] = None
+    updated_on: Optional[datetime.datetime] = None
+
+    # Including other related objects
+    #event: Optional[Event_Base]
+    event_abstract: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more abstracts
+    event_badge: Optional[Event_Badge_Base]
+    event_exhibit: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more exhibits
+    event_file: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more files
+    event_location: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more locations (but unlikely?)
+    event_presentation: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more presentations
+    event_presenter: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more presenters (part of multiple presentations)
+    event_session: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more sessions
+    event_track: Optional[list] # Use event_person_detail table. An event_person record can be linked to one or more tracks
+    #event_person_detail_list: Optional[list] # list of Event_Person_Detail
+    event_registration: Optional[Event_Registration_Base]
+    person: Optional[Person_Base]
+    user: Optional[User_Base]
+
+    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
+
+    #@validator('event_person_id_random', always=True)
+    def event_person_id_random_copy(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            return values['id_random']
+        return None
+
+    @validator('id', always=True)
+    def event_person_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            log.debug(values['id_random'])
+            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_person')
+        return None
+
+    @validator('account_id', always=True)
+    def account_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['account_id_random']:
+            return redis_lookup_id_random(record_id_random=values['account_id_random'], table_name='account')
+        return None
+
+    @validator('event_id', always=True)
+    def event_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
+        return None
+
+    @validator('event_registration_id', always=True)
+    def event_registration_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_registration_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_registration_id_random'], table_name='event_registration')
+        return None
+
+    @validator('event_badge_id', always=True)
+    def event_badge_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_badge_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_badge_id_random'], table_name='event_badge')
+        return None
+
+    @validator('person_id', always=True)
+    def person_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['person_id_random']:
+            return redis_lookup_id_random(record_id_random=values['person_id_random'], table_name='person')
+        return None
+
+    @validator('user_id', always=True)
+    def user_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['user_id_random']:
+            return redis_lookup_id_random(record_id_random=values['user_id_random'], table_name='user')
+        return None
+
+    class Config:
+        underscore_attrs_are_private = True
+        fields = base_fields
+
+
 class Event_Person_New_Base(BaseModel):
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
     log.debug(locals())
@@ -99,133 +229,4 @@ class Event_Person_New_Base(BaseModel):
 
     class Config:
         underscore_attrs_are_private = True
-        fields = base_fields
+        fields = base_fields
-
-
-class Event_Person_Base(BaseModel):
-    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-    log.debug(locals())
-
-    id_random: Optional[str] = Field(
-        **base_fields['event_person_id_random'],
-        alias='event_person_id_random',
-        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
-    )
-    id: Optional[int] = Field(
-        #alias='event_person_id'
-    )
-    account_id_random: Optional[str]
-    account_id: Optional[int]
-    event_id_random: Optional[str]
-    event_id: Optional[int]
-    event_registration_id_random: Optional[str]
-    event_registration_id: Optional[int]
-    event_badge_id_random: Optional[str]
-    event_badge_id: Optional[int]
-    person_id_random: Optional[str]
-    person_id: Optional[int]
-    user_id_random: Optional[str]
-    user_id: Optional[int]
-
-    event_abstract: Optional[list] # An event_person record can be linked to one or more abstracts
-    event_exhibit: Optional[list] # An event_person record can be linked to one or more exhibits
-    event_file: Optional[list] # An event_person record can be linked to one or more files
-    event_location: Optional[list] # An event_person record can be linked to one or more locations (but unlikely?)
-    event_presentation: Optional[list] # An event_person record can be linked to one or more presentations
-    event_presenter: Optional[list] # An event_person record can be linked to one or more presenters (part of multiple presentations)
-    event_session: Optional[list] # An event_person record can be linked to one or more sessions
-    event_track: Optional[list] # An event_person record can be linked to one or more tracks
-
-    event: Optional[Event_Base] = Event_Base()
-    event_badge: Optional[Event_Badge_Base] = Event_Badge_Base()
-    event_person_detail: Optional[Event_Person_Detail_Base] = Event_Person_Detail_Base()
-    event_registration: Optional[Event_Registration_Base] = Event_Registration_Base()
-    person: Optional[Person_Base] = Person_Base()
-    user: Optional[User_Out_Base] = User_Out_Base()
-
-    priority: Optional[bool]
-    sort: Optional[int]
-    group: Optional[str]
-
-    notes: Optional[str]
-    created_on: Optional[datetime.datetime] = None
-    updated_on: Optional[datetime.datetime] = None
-
-    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
-
-    #@validator('event_person_id_random', always=True)
-    def event_person_id_random_copy(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['id_random']:
-            return values['id_random']
-        return None
-
-    @validator('id', always=True)
-    def event_person_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['id_random']:
-            log.debug(values['id_random'])
-            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_person')
-        return None
-
-    @validator('account_id', always=True)
-    def account_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['account_id_random']:
-            return redis_lookup_id_random(record_id_random=values['account_id_random'], table_name='account')
-        return None
-
-    @validator('event_id', always=True)
-    def event_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['event_id_random']:
-            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
-        return None
-
-    @validator('event_registration_id', always=True)
-    def event_registration_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['event_registration_id_random']:
-            return redis_lookup_id_random(record_id_random=values['event_registration_id_random'], table_name='event_registration')
-        return None
-
-    @validator('event_badge_id', always=True)
-    def event_badge_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['event_badge_id_random']:
-            return redis_lookup_id_random(record_id_random=values['event_badge_id_random'], table_name='event_badge')
-        return None
-
-    @validator('person_id', always=True)
-    def person_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['person_id_random']:
-            return redis_lookup_id_random(record_id_random=values['person_id_random'], table_name='person')
-        return None
-
-    @validator('user_id', always=True)
-    def user_id_lookup(cls, v, values, **kwargs):
-        log.setLevel(logging.WARNING)
-        log.debug(locals())
-
-        if values['user_id_random']:
-            return redis_lookup_id_random(record_id_random=values['user_id_random'], table_name='user')
-        return None
-
-    class Config:
-        underscore_attrs_are_private = True
-        fields = base_fields

app/models/event_presentation_models.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+import datetime, hashlib, logging, os, pytz, redis, secrets
+
+from typing import Dict, List, Optional, Set, Union
+from pydantic import BaseModel, EmailStr, Field, Json, PrivateAttr, ValidationError, validator
+
+from app.db_sql import redis_lookup_id_random
+from app.lib_general import log, logging
+
+from .common_field_schema import base_fields, default_num_bytes
+
+#from .event_models import Event_Base
+from .event_abstract_models import Event_Abstract_Base
+from .event_session_models import Event_Session_Base
+
+
+class Event_Presentation_Base(BaseModel):
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    id_random: Optional[str] = Field(
+        **base_fields['event_presentation_id_random'],
+        alias='event_presentation_id_random',
+        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
+    )
+    id: Optional[int] = Field(
+        #alias='event_presentation_id'
+    )
+    event_id_random: Optional[str]
+    event_id: Optional[int]
+    event_abstract_id_random: Optional[str]
+    event_abstract_id: Optional[int]
+    #event_location_id_random: Optional[str]
+    #event_location_id: Optional[int]
+    event_session_id_random: Optional[str]
+    event_session_id: Optional[int]
+    #event_track_id_random: Optional[str]
+    #event_track_id: Optional[int]
+
+    for_type: Optional[str]
+    for_id: Optional[int]
+
+    code: Optional[str]
+
+    name: Optional[str]
+    description: Optional[str]
+
+    start_datetime: Optional[datetime.datetime]
+    end_datetime: Optional[datetime.datetime]
+
+    enable: Optional[bool]
+    enable_from: Optional[datetime.datetime] = None
+    enable_to: Optional[datetime.datetime] = None
+
+    hide: Optional[bool]
+    public: Optional[bool]
+    public_hide: Optional[bool]
+    hide_event_launcher: Optional[bool]
+
+    priority: Optional[bool]
+    sort: Optional[int]
+    group: Optional[str]
+
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime] = None
+    updated_on: Optional[datetime.datetime] = None
+
+    # Including other related objects
+    #event: Optional[Event_Base]
+    event_abstract: Optional[Event_Abstract_Base]
+    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base] Is more than one abstract allowed per presenter?
+    #event_device_list: Optional[list] # Optional[Event_Device_Base]
+    event_file_list: Optional[list] # Optional[Event_File_Base]
+    event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
+    #event_location: Optional[Event_Location_Base]
+    event_session: Optional[Event_Session_Base]
+    #event_track: Optional[Event_Track_Base]
+
+    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
+
+    #@validator('event_presentation_id_random', always=True)
+    def event_presentation_id_random_copy(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            return values['id_random']
+        return None
+
+    @validator('id', always=True)
+    def event_presentation_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            log.debug(values['id_random'])
+            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_presentation')
+        return None
+
+    @validator('event_id', always=True)
+    def event_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
+        return None
+
+    @validator('event_abstract_id', always=True)
+    def event_abstract_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_abstract_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_abstract_id_random'], table_name='event_abstract')
+        return None
+
+    @validator('event_session_id', always=True)
+    def event_session_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_session_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_session_id_random'], table_name='event_session')
+        return None
+
+    class Config:
+        underscore_attrs_are_private = True
+        fields = base_fields
+
+#Event_Presentation_Base.update_forward_refs()

app/models/event_presenter_models.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+import datetime, hashlib, logging, os, pytz, redis, secrets
+
+from typing import Dict, List, Optional, Set, Union
+from pydantic import BaseModel, EmailStr, Field, Json, PrivateAttr, ValidationError, validator
+
+from app.db_sql import redis_lookup_id_random
+from app.lib_general import log, logging
+
+from .common_field_schema import base_fields, default_num_bytes
+
+#from .event_models import Event_Base
+from .event_abstract_models import Event_Abstract_Base
+from .event_person_models import Event_Person_Base
+from .event_presentation_models import Event_Presentation_Base
+from .event_session_models import Event_Session_Base
+from .person_models import Person_Base
+
+
+class Event_Presenter_Base(BaseModel):
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    id_random: Optional[str] = Field(
+        **base_fields['event_presenter_id_random'],
+        alias='event_presenter_id_random',
+        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
+    )
+    id: Optional[int] = Field(
+        #alias='event_presenter_id'
+    )
+    event_id_random: Optional[str]
+    event_id: Optional[int]
+    event_abstract_id_random: Optional[str]
+    event_abstract_id: Optional[int]
+    #event_location_id_random: Optional[str]
+    #event_location_id: Optional[int]
+    event_person_id_random: Optional[str]
+    event_person_id: Optional[int]
+    event_presentation_id_random: Optional[str]
+    event_presentation_id: Optional[int]
+    event_session_id_random: Optional[str]
+    event_session_id: Optional[int]
+    #event_track_id_random: Optional[str]
+    #event_track_id: Optional[int]
+    person_id_random: Optional[str]
+    person_id: Optional[int]
+
+    for_type: Optional[str]
+    for_id: Optional[int]
+
+    code: Optional[str]
+
+    given_name: Optional[str]
+    family_name: Optional[str]
+    middle_name: Optional[str]
+    prefix: Optional[str]
+    suffix: Optional[str]
+    full_name: Optional[str]
+    informal_name: Optional[str]
+    title: Optional[str]
+
+    email: Optional[str]
+
+    degree: Optional[str]
+    degrees: Optional[str] # Do we want this?
+    credentials: Optional[str]
+
+    affiliation: Optional[str]
+    affiliations: Optional[str] # Do we want this?
+
+    website_url: Optional[str]
+    biography: Optional[str]
+    picture_path: Optional[str]
+    picture_bg_color: Optional[str]
+
+    role: Optional[str]
+
+    enable: Optional[bool]
+    enable_from: Optional[datetime.datetime] = None
+    enable_to: Optional[datetime.datetime] = None
+
+    hide: Optional[bool]
+    public: Optional[bool]
+    public_hide: Optional[bool]
+    hide_event_launcher: Optional[bool]
+
+    priority: Optional[bool]
+    sort: Optional[int]
+    group: Optional[str]
+
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime] = None
+    updated_on: Optional[datetime.datetime] = None
+
+    # Including other related objects
+    #event: Optional[Event_Base]
+    event_abstract: Optional[Event_Abstract_Base]
+    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base] Is more than one abstract allowed per presenter?
+    #event_device_list: Optional[list] # Optional[Event_Device_Base]
+    event_file_list: Optional[list] # Optional[Event_File_Base]
+    #event_location: Optional[Event_Location_Base]
+    event_person: Optional[Event_Person_Base]
+    event_presentation: Optional[Event_Presentation_Base]
+    event_session: Optional[Event_Session_Base]
+    #event_track: Optional[Event_Track_Base]
+    person: Optional[Person_Base]
+
+    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
+
+    #@validator('event_presenter_id_random', always=True)
+    def event_presenter_id_random_copy(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            return values['id_random']
+        return None
+
+    @validator('id', always=True)
+    def event_presenter_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            log.debug(values['id_random'])
+            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_presenter')
+        return None
+
+    @validator('event_id', always=True)
+    def event_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
+        return None
+
+    @validator('event_abstract_id', always=True)
+    def event_abstract_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_abstract_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_abstract_id_random'], table_name='event_abstract')
+        return None
+
+    @validator('event_session_id', always=True)
+    def event_session_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_session_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_session_id_random'], table_name='event_session')
+        return None
+
+    class Config:
+        underscore_attrs_are_private = True
+        fields = base_fields
+
+#Event_Presenter_Base.update_forward_refs()

app/models/event_session_models.py

@@ -9,6 +9,10 @@ from app.lib_general import log, logging
 
 from .common_field_schema import base_fields, default_num_bytes
 
+#from .event_models import Event_Base
+from .event_location_models import Event_Location_Base
+from .event_track_models import Event_Track_Base
+
 
 class Event_Session_Base(BaseModel):
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
@@ -33,7 +37,6 @@ class Event_Session_Base(BaseModel):
     session_type_id: Optional[int]
     session_type_code: Optional[str]
 
-
     name: Optional[str]
     description: Optional[str]
 
@@ -76,6 +79,16 @@ class Event_Session_Base(BaseModel):
     created_on: Optional[datetime.datetime] = None
     updated_on: Optional[datetime.datetime] = None
 
+    # Including other related objects
+    #event: Optional[Event_Base]
+    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base]
+    event_device_list: Optional[list] # Optional[Event_Device_Base]
+    event_file_list: Optional[list] # Optional[Event_File_Base]
+    event_location: Optional[Event_Location_Base]
+    event_presentation_list: Optional[list] # Optional[Event_Presentation_Base]
+    event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
+    event_track: Optional[Event_Track_Base]
+
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
 
     #@validator('event_session_id_random', always=True)

app/models/event_track_models.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+import datetime, hashlib, logging, os, pytz, redis, secrets
+
+from typing import Dict, List, Optional, Set, Union
+from pydantic import BaseModel, EmailStr, Field, Json, PrivateAttr, ValidationError, validator
+
+from app.db_sql import redis_lookup_id_random
+from app.lib_general import log, logging
+
+from .common_field_schema import base_fields, default_num_bytes
+
+#from .event_models import Event_Base
+
+
+class Event_Track_Base(BaseModel):
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    id_random: Optional[str] = Field(
+        **base_fields['event_track_id_random'],
+        alias='event_track_id_random',
+        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
+    )
+    id: Optional[int] = Field(
+        #alias='event_track_id'
+    )
+    event_id_random: Optional[str]
+    event_id: Optional[int]
+    event_location_id_random: Optional[str] # Can a location be assigned to one track?
+    event_location_id: Optional[int] # Can a location be assigned to one track?
+
+    lu_track_type_id: Optional[int]
+    track_type_code: Optional[str]
+    track_type: Optional[str]
+
+    name: Optional[str]
+    description: Optional[str]
+
+    start_datetime: Optional[datetime.datetime]
+    end_datetime: Optional[datetime.datetime]
+
+    enable: Optional[bool]
+    enable_from: Optional[datetime.datetime] = None
+    enable_to: Optional[datetime.datetime] = None
+
+    hide: Optional[bool]
+    public: Optional[bool]
+    public_hide: Optional[bool]
+    hide_event_launcher: Optional[bool]
+
+    priority: Optional[bool]
+    sort: Optional[int]
+    group: Optional[str]
+
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime] = None
+    updated_on: Optional[datetime.datetime] = None
+
+    # Including other related objects
+    #event: Optional[Event_Base]
+    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base]
+    event_device_list: Optional[list] # Optional[Event_Device_Base]
+    event_file_list: Optional[list] # Optional[Event_File_Base]
+    event_presentation_list: Optional[list] # Optional[Event_Presentation_Base]
+    event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
+    event_session_list: Optional[list] # Optional[Event_Session_Base]
+    event_track_list: Optional[list] # Optional[Event_Track_Base]
+
+    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
+
+    #@validator('event_track_id_random', always=True)
+    def event_track_id_random_copy(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            return values['id_random']
+        return None
+
+    @validator('id', always=True)
+    def event_track_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['id_random']:
+            log.debug(values['id_random'])
+            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_track')
+        return None
+
+    @validator('event_id', always=True)
+    def event_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
+        return None
+
+    @validator('event_location_id', always=True)
+    def event_location_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_location_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_location_id_random'], table_name='event_location')
+        return None
+
+    class Config:
+        underscore_attrs_are_private = True
+        fields = base_fields
+
+#Event_Track_Base.update_forward_refs()

app/models/order_cart_models.py

@@ -210,9 +210,9 @@ class Order_Cart_Base(BaseModel):
     created_on: Optional[datetime.datetime] = None
     updated_on: Optional[datetime.datetime] = None
 
+    # Including other related objects
     order_cart_line_li: List[Order_Cart_Line_Base] = []
-
+    cfg: Optional[Order_Cart_Cfg_Base] = Order_Cart_Cfg_Base() # Should this be renamed to order_cart_cfg?
-    cfg: Optional[Order_Cart_Cfg_Base] = Order_Cart_Cfg_Base()
 
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
 

app/models/person_models.py

@@ -63,6 +63,7 @@ class Person_Base(BaseModel):
     created_on: Optional[datetime.datetime] = None
     updated_on: Optional[datetime.datetime] = None
 
+    # Including other related objects
     contact: Optional[Contact_Base]
     organization: Optional[Organization_Base]
     user: Optional[User_Base]

app/models/user_models.py

@@ -8,6 +8,7 @@ from app.db_sql import redis_lookup_id_random
 from app.lib_general import log, logging
 
 from .common_field_schema import base_fields, default_num_bytes
+
 #from .account_models import Account_Base
 from .contact_models import Contact_Base
 from .organization_models import Organization_Base
@@ -176,15 +177,17 @@ class User_Out_Base(BaseModel):
     logged_in_on: Optional[datetime.datetime]
     last_activity_on: Optional[datetime.datetime]
 
+    notes: Optional[str]
+    created_on: Optional[datetime.datetime]
+    updated_on: Optional[datetime.datetime]
+
+    # Including other related objects
     #account: Optional[Account_Base]
     contact: Optional[Contact_Base]
     organization: Optional[Organization_Base]
     #person: Optional[Person_Base]# Causes circular import
     role_list: Optional[list] = []
 
-    notes: Optional[str]
-    created_on: Optional[datetime.datetime]
-    updated_on: Optional[datetime.datetime]
 
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
 

app/routers/event.py

@@ -11,6 +11,8 @@ from app.db_sql import *
 
 from .api_crud import delete_obj_template, get_obj_template, get_obj_li_template, patch_obj_template, post_obj_template
 
+from app.methods.event_methods import load_event_obj
+
 from app.models.event_models import Event_Base
 from app.models.response_models import *
 
@@ -68,26 +70,147 @@ async def patch_event_obj(
     return result
 
 
+# @router.get('/list', response_model=Resp_Body_Base)
+# async def get_event_obj_li(
+#         for_obj_type: Optional[str] = Query(None, min_length=2, max_length=50),
+#         for_obj_id: Optional[str] = Query(None, min_length=1, max_length=22),
+#         x_account_id: str = Header(...),
+#         by_alias: Optional[bool] = True,
+#         exclude_unset: Optional[bool] = True,
+#         ):
+#     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+#     log.debug(locals())
+
+#     obj_type = 'event'
+#     result = get_obj_li_template(
+#         obj_type=obj_type,
+#         for_obj_type=for_obj_type,
+#         for_obj_id=for_obj_id,
+#         by_alias=True,
+#         exclude_unset=True,
+#         )
+#     return result
+
+
+
 @router.get('/list', response_model=Resp_Body_Base)
 async def get_event_obj_li(
-        for_obj_type: Optional[str] = Query(None, min_length=2, max_length=50),
+        for_obj_type: Optional[str] = Query(None, min_length=2, max_length=50), # account
         for_obj_id: Optional[str] = Query(None, min_length=1, max_length=22),
+        enabled: str = 'enabled', # enabled, disabled, all
+        from_datetime: Optional[datetime.datetime] = None, # based on start_datetime
+        to_datetime: Optional[datetime.datetime] = None, # based on start_datetime
+        limit: int = None,
+        inc_event_abstract_list: bool = False,
+        inc_event_badge_list: bool = False,
+        inc_event_device_list: bool = False,
+        inc_event_exhibit_list: bool = False,
+        inc_event_file_list: bool = False,
+        inc_event_location_list: bool = False,
+        inc_event_person_list: bool = False,
+        inc_event_presentation_list: bool = False,
+        inc_event_presenter_list: bool = False,
+        inc_event_registration_list: bool = False,
+        inc_event_session_list: bool = False,
+        inc_event_track_list: bool = False,
+        inc_event_cfg: bool = False,
+        inc_event_registration_cfg: bool = False,
+        inc_poc_event_person: bool = False,
+        inc_poc_person: bool = False,
+        inc_user: bool = False,
         x_account_id: str = Header(...),
-        by_alias: Optional[bool] = True,
+        by_alias: bool = True,
-        exclude_unset: Optional[bool] = True,
+        exclude_unset: bool = True,
         ):
-    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
     log.debug(locals())
 
-    obj_type = 'event'
+    data = {}
-    result = get_obj_li_template(
+    if for_obj_type == 'account' and for_obj_id:
-        obj_type=obj_type,
+        data['account_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='account')
-        for_obj_type=for_obj_type,
+        sql_for_obj_type_id = f'`event`.account_id = :account_id'
-        for_obj_id=for_obj_id,
+    # elif for_obj_type == 'test' and for_obj_id:
-        by_alias=True,
+    #     data['test_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='test')
-        exclude_unset=True,
+    #     sql_for_obj_type_id = f'`test`.test_id = :test_id'
-        )
+    else:
-    return result
+        sql_for_obj_type_id = ''
+        return mk_resp(data=False, status_code=400)
+
+    if enabled in ['enabled', 'disabled', 'all']:
+        if enabled == 'enabled':
+            data['enable'] = True
+            sql_enabled = f'AND `event`.enable = :enable'
+        elif enabled == 'disabled':
+            data['enable'] = False
+            sql_enabled = f'AND `event`.enable = :enable'
+        elif enabled == 'all':
+            sql_enabled = ''
+    else:
+        return mk_resp(data=False, status_code=400)
+
+    if from_datetime and to_datetime:
+        data['from_datetime'] = from_datetime
+        data['to_datetime'] = to_datetime
+        sql_from_to_datetime = f'AND `event`.start_datetime >= :from_datetime AND `event`.start_datetime <= :to_datetime'
+    elif from_datetime:
+        data['from_datetime'] = from_datetime
+        sql_from_to_datetime = f'AND `event`.start_datetime >= :from_datetime'
+    elif to_datetime:
+        data['to_datetime'] = to_datetime
+        sql_from_to_datetime = f'AND `event`.start_datetime <= :to_datetime'
+    else:
+        sql_from_to_datetime = ''
+
+    if limit:
+        data['limit'] = limit
+        sql_limit = f'LIMIT :limit'
+    else:
+        sql_limit = ''
+
+    sql = f"""
+        SELECT `event`.id AS 'event_id', `event`.id_random AS 'event_id_random'
+        FROM `event` AS `event`
+        WHERE {sql_for_obj_type_id}
+        {sql_enabled}
+        {sql_from_to_datetime}
+        ORDER BY `event`.created_on DESC, `event`.updated_on DESC
+        {sql_limit};
+        """
+
+    if event_obj_li_result := sql_select(data=data, sql=sql, as_list=True):
+        log.debug(event_obj_li_result)
+        event_obj_li = []
+        for event_obj in event_obj_li_result:
+            event_id = event_obj.get('event_id', None)
+            if event_obj := load_event_obj(
+                event_id=event_id,
+                enabled=enabled,
+                inc_event_abstract_list=inc_event_abstract_list,
+                inc_event_badge_list=inc_event_badge_list,
+                inc_event_device_list=inc_event_device_list,
+                inc_event_exhibit_list=inc_event_exhibit_list,
+                inc_event_file_list=inc_event_file_list,
+                inc_event_location_list=inc_event_location_list,
+                inc_event_person_list=inc_event_person_list,
+                inc_event_presentation_list=inc_event_presentation_list,
+                inc_event_presenter_list=inc_event_presenter_list,
+                inc_event_registration_list=inc_event_registration_list,
+                inc_event_session_list=inc_event_session_list,
+                inc_event_track_list=inc_event_track_list,
+                inc_event_cfg=inc_event_cfg,
+                inc_event_registration_cfg=inc_event_registration_cfg,
+                inc_poc_event_person=inc_poc_event_person,
+                inc_poc_person=inc_poc_person,
+                inc_user=inc_user,
+                ):
+                data = event_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset)
+                event_obj_li.append(data)
+        return mk_resp(data=event_obj_li)
+    else:
+        log.debug(event_obj_li_result)
+        return mk_resp(data=False, status_code=404)
+
+
 
 
 @router.get('/{obj_id}', response_model=Resp_Body_Base)