From b1effc128a2373badbe0932b7aff7af95c949128 Mon Sep 17 00:00:00 2001 From: Scott Idem Date: Fri, 28 May 2021 16:03:17 -0400 Subject: [PATCH] Working on event related models and methods. Also, a lot of general clean up of everything. --- app/db_sql.py | 13 +- app/methods/event_methods.py | 152 +++++++++++++ app/methods/event_session_methods.py | 88 ++++++++ app/models/event_location_models.py | 109 ++++++++++ app/models/event_models.py | 46 ++++ app/models/event_person_detail_models.py | 18 +- app/models/event_person_models.py | 263 ++++++++++++----------- app/models/event_presentation_models.py | 131 +++++++++++ app/models/event_presenter_models.py | 161 ++++++++++++++ app/models/event_session_models.py | 15 +- app/models/event_track_models.py | 112 ++++++++++ app/models/order_cart_models.py | 4 +- app/models/person_models.py | 1 + app/models/user_models.py | 9 +- app/routers/event.py | 149 +++++++++++-- 15 files changed, 1112 insertions(+), 159 deletions(-) create mode 100644 app/methods/event_methods.py create mode 100644 app/methods/event_session_methods.py create mode 100644 app/models/event_location_models.py create mode 100644 app/models/event_presentation_models.py create mode 100644 app/models/event_presenter_models.py create mode 100644 app/models/event_track_models.py diff --git a/app/db_sql.py b/app/db_sql.py index b0b3d8f..bf9e7e9 100644 --- a/app/db_sql.py +++ b/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) diff --git a/app/methods/event_methods.py b/app/methods/event_methods.py new file mode 100644 index 0000000..f4e0469 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/app/methods/event_session_methods.py b/app/methods/event_session_methods.py new file mode 100644 index 0000000..9bacbb3 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/app/models/event_location_models.py b/app/models/event_location_models.py new file mode 100644 index 0000000..9de0ad1 --- /dev/null +++ b/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() diff --git a/app/models/event_models.py b/app/models/event_models.py index e315086..dc06c18 100644 --- a/app/models/event_models.py +++ b/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) diff --git a/app/models/event_person_detail_models.py b/app/models/event_person_detail_models.py index 4e26f06..fb05845 100644 --- a/app/models/event_person_detail_models.py +++ b/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) diff --git a/app/models/event_person_models.py b/app/models/event_person_models.py index 072cf6c..803a10c 100644 --- a/app/models/event_person_models.py +++ b/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 - - -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 + fields = base_fields \ No newline at end of file diff --git a/app/models/event_presentation_models.py b/app/models/event_presentation_models.py new file mode 100644 index 0000000..ed4c5e2 --- /dev/null +++ b/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() diff --git a/app/models/event_presenter_models.py b/app/models/event_presenter_models.py new file mode 100644 index 0000000..1fd3989 --- /dev/null +++ b/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() diff --git a/app/models/event_session_models.py b/app/models/event_session_models.py index a19ba47..87fa899 100644 --- a/app/models/event_session_models.py +++ b/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) diff --git a/app/models/event_track_models.py b/app/models/event_track_models.py new file mode 100644 index 0000000..0ca0593 --- /dev/null +++ b/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() diff --git a/app/models/order_cart_models.py b/app/models/order_cart_models.py index ed586f4..28c729c 100644 --- a/app/models/order_cart_models.py +++ b/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() + cfg: Optional[Order_Cart_Cfg_Base] = Order_Cart_Cfg_Base() # Should this be renamed to order_cart_cfg? _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now) diff --git a/app/models/person_models.py b/app/models/person_models.py index 24a10dd..454442f 100644 --- a/app/models/person_models.py +++ b/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] diff --git a/app/models/user_models.py b/app/models/user_models.py index 65d3456..dc4d3e2 100644 --- a/app/models/user_models.py +++ b/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) diff --git a/app/routers/event.py b/app/routers/event.py index 492efe9..2bfedd2 100644 --- a/app/routers/event.py +++ b/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, - exclude_unset: Optional[bool] = True, + by_alias: 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' - 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 + data = {} + if for_obj_type == 'account' and for_obj_id: + data['account_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='account') + sql_for_obj_type_id = f'`event`.account_id = :account_id' + # elif for_obj_type == 'test' and for_obj_id: + # data['test_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='test') + # sql_for_obj_type_id = f'`test`.test_id = :test_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`.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)