Working on event related models and methods.

app/methods/event_methods.py

@@ -110,6 +110,7 @@ def load_event_obj(
                     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,
+                        enabled=enabled,
                         inc_event_abstract_list=inc_event_abstract_list,
                         inc_event_device_list=inc_event_device_list,
                         inc_event_file_list=inc_event_file_list,

app/methods/event_presentation_methods.py

@@ -11,7 +11,7 @@ from app.lib_general import log, logging
 # 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.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
 
@@ -23,14 +23,14 @@ def load_event_presentation_obj(
     event_presentation_id: int|str,
     enabled: str = 'enabled', # enabled, disabled, all
     inc_event_abstract_list: bool = False,
-    inc_event_badge_list: bool = False,
+    #inc_event_badge_list: bool = False,
     inc_event_device_list: bool = False,
     inc_event_file_list: bool = False,
     inc_event_person_list: bool = False,
     inc_event_presenter_list: bool = False,
-    inc_event_cfg: bool = False,
+    #inc_event_cfg: bool = False,
-    inc_poc_event_person: bool = False,
+    #inc_poc_event_person: bool = False,
-    inc_poc_person: bool = False,
+    #inc_poc_person: bool = False,
     #inc_user: bool = False,
     ) -> Event_Presentation_Base|bool:
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
@@ -53,36 +53,33 @@ def load_event_presentation_obj(
         # event_presentation_obj = Event_Presentation_Base(**event_presentation_rec)
         # log.debug(event_presentation_obj)
 
-        return False
+        #return False
 
-        # *** ** * Everything below needs to be reviewed * ** ***
+        #account_id = event_presentation_rec.get('account_id', None)
-
+        event_id = event_presentation_rec.get('event_id', None)
-        account_id = event_session_rec.get('account_id', None)
+        event_abstract_id = event_presentation_rec.get('event_abstract_id', None)
-        event_id = event_session_rec.get('event_id', None)
+        event_person_id = event_presentation_rec.get('event_person_id', None)
-        event_location_id = event_session_rec.get('event_location_id', None)
+        event_session_id = event_presentation_rec.get('event_session_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_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:
+        if inc_event_presenter_list:
             log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
 
             data = {}
-            data['event_session_id'] = event_session_id
+            data['event_presentation_id'] = event_presentation_id
 
             if enabled in ['enabled', 'disabled', 'all']:
                 if enabled == 'enabled':
                     data['enable'] = True
-                    sql_enabled = f'AND `event_presentation`.enable = :enable'
+                    sql_enabled = f'AND `event_presenter`.enable = :enable'
                 elif enabled == 'disabled':
                     data['enable'] = False
-                    sql_enabled = f'AND `event_presentation`.enable = :enable'
+                    sql_enabled = f'AND `event_presenter`.enable = :enable'
                 elif enabled == 'all':
                     sql_enabled = ''
             # else: event_obj['event_session'] = None
@@ -94,47 +91,37 @@ def load_event_presentation_obj(
             #     sql_limit = ''
 
             sql = f"""
-                SELECT `event_presentation`.id AS 'event_session_id', `event_presentation`.id_random AS 'event_session_id_random'
+                SELECT `event_presenter`.id AS 'event_presenter_id', `event_presenter`.id_random AS 'event_presenter_id_random'
-                FROM `event_presentation` AS `event_presentation`
+                FROM `event_presenter` AS `event_presenter`
-                WHERE `event_presentation`.event_session_id = :event_session_id
+                WHERE `event_presenter`.event_presenter_id = :event_presenter_id
                 {sql_enabled}
-                ORDER BY `event_presentation`.created_on DESC, `event_presentation`.updated_on DESC;
+                ORDER BY `event_presenter`.created_on DESC, `event_presenter`.updated_on DESC;
                 """
 
             log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-            if event_presentation_obj_li_result := sql_select(data=data, sql=sql, as_list=True):
+            if event_presenter_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_presentation_obj_li_result)
+                log.debug(event_presenter_obj_li_result)
-                event_presentation_obj_li = []
+                event_presenter_obj_li = []
-                for event_presentation_obj in event_presentation_obj_li_result:
+                for event_presenter_obj in event_presenter_obj_li_result:
-                    event_presentation_id = event_presentation_obj.get('event_presentation_id', None)
+                    event_presenter_id = event_presenter_obj.get('event_presenter_id', None)
-                    if event_presentation_obj := load_event_presentation_obj(
+                    if event_presenter_obj := load_event_presenter_obj(
-                        event_presentation_id=event_presentation_id,
+                        event_presenter_id=event_presenter_id,
+                        enabled=enabled,
                         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_presentation_obj.dict(by_alias=True, exclude_unset=True)
+                        data = event_presenter_obj.dict(by_alias=True, exclude_unset=True)
-                        event_presentation_obj_li.append(data)
+                        event_presenter_obj_li.append(data)
-                log.debug(event_presentation_obj_li)
+                log.debug(event_presenter_obj_li)
-                event_presentation_obj.event_presentation_list = event_presentation_obj_li
+                event_presenter_obj.event_presenter_list = event_presenter_obj_li
             else:
                 log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-                log.debug(event_presentation_obj_li_result)
+                log.debug(event_presenter_obj_li_result)
             log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-
-
-        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_presentation_obj.poc_person = person_obj
-            log.debug(event_presentation_obj)
         #if inc_user: pass
     else:
         return False

app/methods/event_presenter_methods.py

@@ -0,0 +1,98 @@
+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_file_methods import load_event_file_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_presenter_models import Event_Presenter_Base
+
+
+# ### BEGIN ### API Event Presenter Methods ### load_event_presenter_obj() ###
+def load_event_presenter_obj(
+    event_presenter_id: int|str,
+    enabled: str = 'enabled', # enabled, disabled, all
+    inc_event_abstract_list: bool = False,
+    inc_event_badge: bool = False,
+    inc_event_device_list: bool = False,
+    inc_event_file_list: bool = False,
+    inc_event_person: bool = False,
+    inc_person: bool = False,
+    inc_user: bool = False,
+    ) -> Event_Presenter_Base|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if event_presenter_id := redis_lookup_id_random(record_id_random=event_presenter_id, table_name='event_presenter'): pass
+    else: return False
+
+    if event_presenter_rec := sql_select(table_name='v_event_presenter', record_id=event_presenter_id):
+        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        log.debug(event_presenter_rec)
+
+        try:
+            event_presenter_obj = Event_Presenter_Base(**event_presenter_rec)
+            log.debug(event_presenter_obj)
+        except ValidationError as e:
+            log.error(e.json())
+            return False
+
+        # event_presenter_obj = Event_Presenter_Base(**event_presenter_rec)
+        # log.debug(event_presenter_obj)
+
+        return False
+
+        # *** ** * Everything below needs to be reviewed * ** ***
+
+        #account_id = event_presenter_rec.get('account_id', None)
+        event_id = event_presenter_rec.get('event_id', None)
+        event_abstract_id = event_presenter_rec.get('event_abstract_id', None)
+        event_person_id = event_presenter_rec.get('event_person_id', None)
+        event_presentation_id = event_presenter_rec.get('event_presentation_id', None)
+        event_session_id = event_presenter_rec.get('event_session_id', None)
+        person_id = event_presenter_rec.get('person_id', None)
+        user_id = event_presenter_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_file_list: pass
+        if inc_event_person:
+            log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+
+            if event_person_obj := load_event_person_obj(
+                event_person_id=event_person_id,
+                enabled=enabled
+                ):
+                log.debug(event_person_obj)
+                event_presenter_obj.event_person = event_person_obj
+            else:
+                log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+                log.debug(event_person_obj)
+            log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        if inc_person:
+            log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+
+            if person_obj := load_person_obj(
+                person_id=person_id,
+                enabled=enabled
+                ):
+                log.debug(person_obj)
+                presenter_obj.person = person_obj
+            else:
+                log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+                log.debug(person_obj)
+            log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+        #if inc_user: pass
+    else:
+        return False
+
+    return event_presenter_obj

app/methods/event_session_methods.py

@@ -27,15 +27,12 @@ def load_event_session_obj(
     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_location: 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: 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,
@@ -97,7 +94,7 @@ def load_event_session_obj(
             #     sql_limit = ''
 
             sql = f"""
-                SELECT `event_presentation`.id AS 'event_session_id', `event_presentation`.id_random AS 'event_session_id_random'
+                SELECT `event_presentation`.id AS 'event_presentation_id', `event_presentation`.id_random AS 'event_presentation_id_random'
                 FROM `event_presentation` AS `event_presentation`
                 WHERE `event_presentation`.event_session_id = :event_session_id
                 {sql_enabled}
@@ -113,13 +110,12 @@ def load_event_session_obj(
                     event_presentation_id = event_presentation_obj.get('event_presentation_id', None)
                     if event_presentation_obj := load_event_presentation_obj(
                         event_presentation_id=event_presentation_id,
+                        enabled=enabled,
                         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_presentation_obj.dict(by_alias=True, exclude_unset=True)
                         event_presentation_obj_li.append(data)

app/models/event_abstract_models.py

@@ -0,0 +1,177 @@
+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_person_models import Event_Person_Base
+from .event_presentation_models import Event_Presentation_Base
+#from .event_presenter_models import Event_Presenter_Base # This creates an import loop
+from .event_session_models import Event_Session_Base
+from .event_track_models import Event_Track_Base
+from .person_models import Person_Base
+
+
+class Event_Abstract_Base(BaseModel):
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    id_random: Optional[str] = Field(
+        **base_fields['event_abstract_id_random'],
+        alias='event_abstract_id_random',
+        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
+    )
+    id: Optional[int] = Field(
+        #alias='event_abstract_id'
+    )
+    event_id_random: Optional[str]
+    event_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_presenter_id_random: Optional[str]
+    event_presenter_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]
+    poc_event_person_id_random: Optional[str] # Maybe change this to primary_event_person?
+    poc_event_person_id: Optional[int] # Maybe change this to primary_event_person?
+    poc_person_id_random: Optional[str] # Maybe change this to primary_person?
+    poc_person_id: Optional[int] # Maybe change this to primary_person?
+
+    code: Optional[str]
+
+    name: Optional[str]
+    description: Optional[str]
+    abstract: Optional[str]
+
+    hide: Optional[bool]
+    public: Optional[bool]
+    public_hide: 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_file_list: Optional[list] # Optional[Event_File_Base]
+    event_person: Optional[Event_Person_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_track: Optional[Event_Track_Base]
+    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)
+
+    #@validator('event_abstract_id_random', always=True)
+    def event_abstract_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_abstract_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_abstract')
+        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_person_id', always=True)
+    def event_person_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_person_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_person_id_random'], table_name='event_person')
+        return None
+
+    @validator('event_presentation_id', always=True)
+    def event_presentation_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_presentation_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_presentation_id_random'], table_name='event_presentation')
+        return None
+
+    @validator('event_presenter_id', always=True)
+    def event_presenter_id_lookup(cls, v, values, **kwargs):
+        log.setLevel(logging.WARNING)
+        log.debug(locals())
+
+        if values['event_presenter_id_random']:
+            return redis_lookup_id_random(record_id_random=values['event_presenter_id_random'], table_name='event_presenter')
+        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
+
+    @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
+
+    @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='poc_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='poc_person')
+        return None
+
+    class Config:
+        underscore_attrs_are_private = True
+        fields = base_fields
+
+#Event_Abstract_Base.update_forward_refs()

app/models/event_presentation_models.py

@@ -11,7 +11,9 @@ 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_session_models import Event_Session_Base
+from .person_models import Person_Base
 
 
 class Event_Presentation_Base(BaseModel):

app/routers/event.py

@@ -211,8 +211,6 @@ async def get_event_obj_li(
         return mk_resp(data=False, status_code=404)
 
 
-
-
 @router.get('/{obj_id}', response_model=Resp_Body_Base)
 async def get_event_obj(
         obj_id: str = Query(..., min_length=1, max_length=22),

app/routers/event_session.py

@@ -68,26 +68,142 @@ async def patch_event_session_obj(
     return result
 
 
+# @router.get('/list', response_model=Resp_Body_Base)
+# async def get_event_session_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_session'
+#     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_session_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_file_list: bool = False,
+        inc_event_location: 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_track: 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_session'
+    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 == 'event' and for_obj_id:
-        by_alias=True,
+        data['event_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='event')
-        exclude_unset=True,
+        sql_for_obj_type_id = f'`event_session`.event_id = :event_id'
-        )
+    elif for_obj_type == 'event_location' and for_obj_id:
-    return result
+        data['event_location_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='event_location')
+        sql_for_obj_type_id = f'`event_session`.event_location_id = :event_location_id'
+    elif for_obj_type == 'event_track' and for_obj_id:
+        data['event_track_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='event_track')
+        sql_for_obj_type_id = f'`event_session`.event_track_id = :event_track_id'
+    else:
+        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_session`.enable = :enable'
+        elif enabled == 'disabled':
+            data['enable'] = False
+            sql_enabled = f'AND `event_session`.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_session`.start_datetime >= :from_datetime AND `event_session`.start_datetime <= :to_datetime'
+    elif from_datetime:
+        data['from_datetime'] = from_datetime
+        sql_from_to_datetime = f'AND `event_session`.start_datetime >= :from_datetime'
+    elif to_datetime:
+        data['to_datetime'] = to_datetime
+        sql_from_to_datetime = f'AND `event_session`.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_session`.id AS 'event_session_id', `event_session`.id_random AS 'event_session_id_random'
+        FROM `event_session` AS `event_session`
+        WHERE {sql_for_obj_type_id}
+        {sql_enabled}
+        {sql_from_to_datetime}
+        ORDER BY `event_session`.created_on DESC, `event_session`.updated_on DESC
+        {sql_limit};
+        """
+
+    if event_session_obj_li_result := sql_select(data=data, sql=sql, as_list=True):
+        log.debug(event_obj_li_result)
+        event_session_li = []
+        for event_session in event_session_li_result:
+            event_id = event_session.get('event_id', None)
+            if event_session := load_event_session(
+                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_file_list=inc_event_file_list,
+                inc_event_location=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_track=inc_event_track_list,
+                inc_poc_event_person=inc_poc_event_person,
+                inc_poc_person=inc_poc_person,
+                inc_user=inc_user,
+                ):
+                data = event_session.dict(by_alias=by_alias, exclude_unset=exclude_unset)
+                event_session_li.append(data)
+        return mk_resp(data=event_session_li)
+    else:
+        log.debug(event_session_li_result)
+        return mk_resp(data=False, status_code=404)
 
 
 @router.get('/{obj_id}', response_model=Resp_Body_Base)