Working on all the routes, methods, and models.

app/methods/account_methods.py

@@ -14,6 +14,7 @@ from app.methods.contact_methods import get_contact_rec_list, load_contact_obj
 from app.methods.event_methods import get_event_rec_list, load_event_obj
 from app.methods.hosted_file_methods import get_hosted_file_rec_list, load_hosted_file_obj
 from app.methods.journal_methods import get_journal_rec_list, load_journal_obj
+from app.methods.membership_methods import get_membership_rec_list, load_membership_obj
 from app.methods.order_methods import get_order_rec_list, load_order_obj
 # from app.methods.order_cart_methods import get_order_cart_rec_list, load_order_cart_obj
 from app.methods.organization_methods import get_organization_rec_list, load_organization_obj
@@ -292,6 +293,30 @@ def load_account_obj(
             account_obj.journal_list = journal_dict_list
         else: account_obj.journal_list = []
 
+    # Updated 2021-06-18
+    if inc_membership_list:
+        if membership_rec_list_result := get_membership_rec_list(
+                for_obj_type = 'account',
+                for_obj_id = account_id,
+                limit = limit,
+                enabled = enabled,
+                ):
+            membership_result_list = []
+            for membership_rec in membership_rec_list_result:
+                membership_result_list.append(
+                    load_membership_obj(
+                        membership_id = membership_rec.get('membership_id', None),
+                        limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
+                        model_as_dict = model_as_dict,
+                        inc_membership_member_list = inc_membership_member_list,
+                        inc_product_list = inc_product_list,
+                        )
+                    )
+            account_obj.membership_list = membership_result_list
+        else: account_obj.membership_list = []
+
     # Updated 2021-06-17
     if inc_order_list:
         if order_rec_list_result := get_order_rec_list(
@@ -306,6 +331,8 @@ def load_account_obj(
                     load_order_obj(
                         order_id = order_rec.get('order_id', None),
                         limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         enabled = enabled,
                         inc_order_line_list = inc_order_line_list,
@@ -331,6 +358,8 @@ def load_account_obj(
                     load_organization_obj(
                         organization_id = organization_rec.get('organization_id', None),
                         limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         enabled = enabled,
                         inc_address = inc_address,
@@ -342,30 +371,6 @@ def load_account_obj(
             account_obj.organization_list = organization_dict_list
         else: account_obj.organization_list = []
 
-    # Updated 2021-06-17
-    if inc_post_list:
-        if post_rec_list_result := get_post_rec_list(
-                for_obj_type = 'account',
-                for_obj_id = account_id,
-                limit = limit,
-                enabled = enabled,
-                ):
-            post_dict_list = []
-            for post_rec in post_rec_list_result:
-                post_dict_list.append(
-                    load_post_obj(
-                        post_id = post_rec.get('post_id', None),
-                        limit = limit,
-                        model_as_dict = model_as_dict,
-                        enabled = enabled,
-                        inc_post_comment_list = inc_post_comment_list,
-                        inc_person = inc_person,
-                        inc_user = inc_user,
-                        )
-                    )
-            account_obj.post_list = post_dict_list
-        else: account_obj.post_list = []
-
     # Updated 2021-06-17
     if inc_person_list:
         if person_rec_list_result := get_person_rec_list(
@@ -374,12 +379,14 @@ def load_account_obj(
                 limit = limit,
                 enabled = enabled,
                 ):
-            person_dict_list = []
+            person_result_list = []
             for person_rec in person_rec_list_result:
-                person_dict_list.append(
+                person_result_list.append(
                     load_person_obj(
                         person_id = person_rec.get('person_id', None),
                         limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         enabled = enabled,
                         inc_address = inc_address,
@@ -388,9 +395,35 @@ def load_account_obj(
                         inc_user = inc_user,
                         )
                     )
-            account_obj.person_list = person_dict_list
+            account_obj.person_list = person_result_list
         else: account_obj.person_list = []
 
+    # Updated 2021-06-18
+    if inc_post_list:
+        if post_rec_list_result := get_post_rec_list(
+                for_obj_type = 'account',
+                for_obj_id = account_id,
+                limit = limit,
+                enabled = enabled,
+                ):
+            post_result_list = []
+            for post_rec in post_rec_list_result:
+                post_result_list.append(
+                    load_post_obj(
+                        post_id = post_rec.get('post_id', None),
+                        limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
+                        model_as_dict = model_as_dict,
+                        enabled = enabled,
+                        inc_post_comment_list = inc_post_comment_list,
+                        inc_person = inc_person,
+                        inc_user = inc_user,
+                        )
+                    )
+            account_obj.post_list = post_result_list
+        else: account_obj.post_list = []
+
     # Updated 2021-06-17
     if inc_product_list:
         if product_rec_list_result := get_product_rec_list(
@@ -399,15 +432,17 @@ def load_account_obj(
                 limit = limit,
                 enabled = enabled,
                 ):
-            product_dict_list = []
+            product_result_list = []
             for product_rec in product_rec_list_result:
-                product_dict_list.append(
+                product_result_list.append(
                     load_product_obj(
                         product_id = product_rec.get('product_id', None),
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         )
                     )
-            account_obj.product_list = product_dict_list
+            account_obj.product_list = product_result_list
         else: account_obj.product_list = []
 
     # Updated 2021-06-17
@@ -440,12 +475,14 @@ def load_account_obj(
                 limit = limit,
                 enabled = enabled,
                 ):
-            user_dict_list = []
+            user_result_list = []
             for user_rec in user_rec_list_result:
-                user_dict_list.append(
+                user_result_list.append(
                     load_user_obj(
                         user_id = user_rec.get('user_id', None),
                         limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         enabled = enabled,
                         inc_address = inc_address,
@@ -462,7 +499,7 @@ def load_account_obj(
                         inc_user_role_list = inc_user_role_list,
                         )
                     )
-            account_obj.user_list = user_dict_list
+            account_obj.user_list = user_result_list
         else: account_obj.user_list = []
 
     if model_as_dict:

app/methods/address_methods.py

@@ -59,7 +59,7 @@ def load_address_obj(
         return False
 
     if model_as_dict:
-        return address_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return address_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return address_obj
 # ### END ### API Address Methods ### load_address_obj() ###

app/methods/event_session_methods.py

@@ -195,7 +195,7 @@ def load_event_session_obj(
         log.debug(event_session_obj)
 
     if model_as_dict:
-        return event_session_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return event_session_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return event_session_obj
 

app/methods/membership_cfg_methods.py

@@ -13,6 +13,8 @@ from app.models.membership_cfg_models import Membership_Cfg_Base
 # ### BEGIN ### API Membership Cfg Methods ### load_membership_cfg_obj() ###
 def load_membership_cfg_obj(
         account_id: int|str,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         ) -> Membership_Cfg_Base|dict|bool:
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
@@ -36,7 +38,7 @@ def load_membership_cfg_obj(
         log.error(e.json())
 
     if model_as_dict:
-        return membership_cfg_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return membership_cfg_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return membership_cfg_obj
 # ### END ### API Membership Cfg Methods ### load_membership_cfg_obj() ###

app/methods/membership_group_methods.py

@@ -0,0 +1,167 @@
+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.models.membership_group_models import Membership_Group_Base
+
+
+# ### BEGIN ### API Membership Group Methods ### create_membership_group_obj() ###
+def create_membership_group_obj(membership_group_obj_new:Membership_Group_Base) -> bool|int:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    membership_group_obj_data = membership_group_obj_new.dict(by_alias=False, exclude_defaults=False, exclude_unset=True, exclude={'created_on', 'updated_on'})
+
+    if membership_group_obj_in_result := sql_insert(
+            data=membership_group_obj_data,
+            table_name='membership_group',
+            rm_id_random=True,
+            id_random_length=8
+            ): pass
+    else: return False
+
+    log.debug(membership_group_obj_in_result)
+
+    membership_group_id = membership_group_obj_in_result
+
+    log.debug(f'New membership_group_id: {membership_group_id}')
+    return membership_group_id
+# ### END ### API Membership Group Methods ### create_membership_group_obj() ###
+
+
+# ### BEGIN ### API Membership Group Methods ### load_membership_group_obj() ###
+def load_membership_group_obj(
+        membership_group_id: int|str,
+        # limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
+        model_as_dict: bool = False,
+        inc_membership: bool = False,
+        inc_parent_membership_group: bool = False,
+        ) -> Membership_Group_Base|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if membership_group_id := redis_lookup_id_random(record_id_random=membership_group_id, table_name='membership_group'): pass
+    else: return False
+    log.debug(membership_group_id)
+
+    if membership_group_rec := sql_select(table_name='v_membership_group', record_id=membership_group_id):
+        log.debug(membership_group_rec)
+    else: return False
+    log.debug(membership_group_rec)
+
+    try:
+        membership_group_obj = Membership_Group_Base(**membership_group_rec)
+        log.debug(membership_group_obj)
+    except ValidationError as e:
+        log.error(e.json())
+
+    # Updated 2021-06-18
+    if inc_parent_membership_group:
+        membership_group_id = membership_group_rec.get('membership_group_id', None)
+        log.debug(membership_group_id)
+        if membership_group_result := load_membership_group_obj(
+                membership_group_id = membership_group_id,
+                by_alias = by_alias,
+                exclude_unset = exclude_unset,
+                model_as_dict = model_as_dict,
+                ):
+            membership_group_obj.membership_group = membership_group_result
+        else: membership_group_obj.membership_group = None
+        log.debug(membership_group_result)
+
+    if model_as_dict:
+        return membership_group_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
+    else:
+        return membership_group_obj
+# ### END ### API Membership Group Methods ### load_membership_group_obj() ###
+
+
+# ### BEGIN ### API Membership Group Methods ### update_membership_group_obj() ###
+def update_membership_group_obj(
+        membership_group_id: int|str, # This allows for updating of the id_random value.
+        membership_group_obj_up: Membership_Group_Base,
+        create_missing_obj: bool = False,
+        ) -> bool:
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if membership_group_id := redis_lookup_id_random(record_id_random=membership_group_id, table_name='membership_group'): pass
+    else: return False
+
+    membership_group_obj_up.id = membership_group_id
+
+    log.debug(membership_group_obj_up)
+    log.debug(membership_group_obj_up.dict(by_alias=False, exclude_unset=True))
+    # log.debug(membership_group_obj_up.dict(by_alias=False, exclude_unset=False))
+
+    journal_dict_up = membership_group_obj_up.dict(by_alias=False, exclude_unset=True)
+    log.debug(journal_dict_up)
+
+    if membership_group_obj_up_result := sql_update(data=journal_dict_up, table_name='membership_group', rm_id_random=True):
+        log.debug(membership_group_obj_up_result)
+        return True
+    else:
+        log.debug(membership_group_obj_up_result)
+        return False
+# ### END ### API Membership Group Methods ### update_membership_group_obj() ###
+
+
+# ### BEGIN ### API Membership Group Methods ### get_membership_group_rec_list() ###
+def get_membership_group_rec_list(
+        for_obj_type: str,
+        for_obj_id: str,
+        limit: int = 1000,
+        enabled: str = 'enabled', # enabled, disabled, all
+        ) -> list|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if for_obj_id := redis_lookup_id_random(record_id_random=for_obj_id, table_name='for_obj_type'): pass
+    else: return False
+    data = {}
+    data[f'{for_obj_type}_id'] = for_obj_id
+    # data['for_obj_type'] = for_obj_type
+    sql_obj_type_id = f'`tbl`.{for_obj_type}_id = :{for_obj_type}_id'
+
+    if enabled in ['enabled', 'disabled', 'all']:
+        if enabled == 'enabled':
+            data['enable'] = True
+            sql_enabled = f'AND `tbl`.enable = :enable'
+        elif enabled == 'disabled':
+            data['enable'] = False
+            sql_enabled = f'AND `tbl`.enable = :enable'
+        elif enabled == 'all':
+            sql_enabled = ''
+
+    if limit:
+        data['limit'] = limit
+        sql_limit = f'LIMIT :limit'
+    else:
+        sql_limit = ''
+
+    sql = f"""
+        SELECT `tbl`.id AS 'membership_group_id', `tbl`.id_random AS 'membership_group_id_random'
+        FROM `membership_group` AS `tbl`
+        WHERE
+            {sql_obj_type_id}
+            {sql_enabled}
+        ORDER BY `tbl`.created_on DESC, `tbl`.updated_on DESC
+        {sql_limit};
+        """
+
+    if membership_group_rec_li_result := sql_select(data=data, sql=sql, as_list=True):
+        membership_group_rec_li = membership_group_rec_li_result
+    else:
+        membership_group_rec_li = []
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(membership_group_rec_li_result)
+
+    return membership_group_rec_li
+# ### END ### API Membership Group Methods ### get_membership_group_rec_list() ###

app/methods/membership_member_methods.py

@@ -7,13 +7,12 @@ from pydantic import BaseModel, EmailStr, Field, PrivateAttr, ValidationError, v
 from app.lib_general import log, logging
 from app.db_sql import redis_lookup_id_random, sql_insert_or_update, sql_select
 
-#from .address_models import Address_Base
+from app.methods.membership_group_methods import get_membership_group_rec_list, load_membership_group_obj
-#from .contact_models import Contact_Base
+from app.methods.membership_profile_methods import get_membership_profile_rec_list, load_membership_profile_obj
+from app.methods.person_methods import load_person_obj
+from app.methods.user_methods import load_user_obj
+
 from app.models.membership_member_models import Membership_Member_Base
-from app.models.membership_profile_models import Membership_Profile_Base
-#from .organization_models import Organization_Base
-#from .person_models import Person_Base
-#from .user_models import User_Base
 
 
 # ### BEGIN ### API Membership Member Methods ### save_membership_member_obj() ###
@@ -167,6 +166,8 @@ def save_membership_member_obj(order_obj_new:Membership_Member_Base=None):
 def load_membership_member_obj(
         membership_member_id:int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
         inc_address: bool = False,
@@ -194,196 +195,89 @@ def load_membership_member_obj(
     except ValidationError as e:
         log.error(e.json())
 
+    # Updated 2021-06-18
+    if inc_membership_group_list:
+        if membership_group_rec_list_result := get_membership_group_rec_list(
+                for_obj_type = 'membership_member',
+                for_obj_id = membership_member_id,
+                limit = limit,
+                enabled = enabled,
+                ):
+            membership_group_result_list = []
+            for membership_group_rec in membership_group_rec_list_result:
+                membership_group_result_list.append(
+                    load_membership_group_obj(
+                        membership_group_id = membership_group_rec.get('membership_group_id', None),
+                        # limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
+                        model_as_dict = model_as_dict,
+                        # enabled = enabled,
+                        )
+                    )
+            membership_member_obj.membership_group_list = membership_group_result_list
+        else: membership_member_obj.membership_group_list = []
+
+    # Updated 2021-06-18
     if inc_membership_profile:
         membership_profile_id = membership_member_rec.get('membership_profile_id', None)
         log.debug(membership_profile_id)
-        if membership_profile_dict := load_membership_profile_obj(
+        if membership_profile_result := load_membership_profile_obj(
                 membership_profile_id = membership_profile_id,
+                by_alias = by_alias,
+                exclude_unset = exclude_unset,
                 model_as_dict = model_as_dict,
                 inc_address = inc_address,
                 inc_contact = inc_contact,
                 # inc_membership = inc_membership,
                 # inc_organization = inc_organization,
                 ):
-            membership_member_obj.membership_profile = membership_profile_dict
+            membership_member_obj.membership_profile = membership_profile_result
         else: membership_member_obj.membership_profile = None
-        log.debug(membership_profile_dict)
+        log.debug(membership_profile_result)
 
+    # Updated 2021-06-18
     if inc_person:
         person_id = membership_member_rec.get('person_id', None)
         log.debug(person_id)
-        if person_dict := load_person_obj(
+        if person_result := load_person_obj(
                 person_id = person_id,
+                by_alias = by_alias,
+                exclude_unset = exclude_unset,
                 model_as_dict = model_as_dict,
                 inc_address = inc_address,
                 inc_contact = inc_contact,
                 # inc_organization = inc_organization,
                 # inc_user = inc_user,
                 ):
-            membership_member_obj.person = person_dict
+            membership_member_obj.person = person_result
         else: membership_member_obj.person = None
-        log.debug(person_dict)
+        log.debug(person_result)
 
+    # Updated 2021-06-18
     if inc_user:
         user_id = membership_member_rec.get('user_id', None)
-        if user_dict := load_user_obj(
+        if user_result := load_user_obj(
                 user_id = user_id,
+                by_alias = by_alias,
+                exclude_unset = exclude_unset,
                 model_as_dict = model_as_dict,
                 inc_address = inc_address,
                 inc_contact = inc_contact,
                 # inc_organization = inc_organization,
                 # inc_person = inc_person,
                 ):
-            membership_member_obj.user = user_dict
+            membership_member_obj.user = user_result
         else: membership_member_obj.user = None
-        log.debug(user_dict)
+        log.debug(user_result)
-
-    if membership_member_rec := sql_select(table_name='v_membership', record_id=membership_member_id):
-        #log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-        log.debug(membership_member_rec)
-
-        if inc_membership_member_profile:
-            if membership_member_profile_rec := sql_select(table_name='v_membership_member_profile', field_name='membership_member_id', field_value=membership_member_id):
-                #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-                log.debug(membership_member_profile_rec)
-
-                membership_member_rec['profile'] = membership_member_profile_rec
-
-        if inc_membership_member_cfg:
-            if membership_member_cfg_rec := sql_select(table_name='v_membership_member_cfg', field_name='account_id', field_value=membership_member_rec.get('account_id', None)):
-                #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-                log.debug(membership_member_cfg_rec)
-
-                membership_member_rec['cfg'] = membership_member_cfg_rec
-
-        if inc_extended_profile:
-            account_code = membership_member_rec.get('account_code', None)
-            table_name = f'c_{account_code}_membership_member_profile'
-            if extended_profile_rec := sql_select(table_name=table_name, field_name='membership_member_id', field_value=membership_member_id):
-                #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-                log.debug(extended_profile_rec)
-
-                membership_member_rec['extended_profile'] = extended_profile_rec
-
-        if inc_person:
-            if person_rec := sql_select(table_name='v_person', record_id=membership_member_rec.get('person_id')):
-                #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-                log.debug(person_rec)
-
-                membership_member_rec['person'] = person_rec
-
-        if inc_user:
-            if user_rec := sql_select(table_name='v_user', record_id=membership_member_rec.get('user_id')):
-                #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-                log.debug(user_rec)
-
-                membership_member_rec['user'] = user_rec
-
-        #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-        log.debug(membership_member_rec)
-    else:
-        return False
 
     if model_as_dict:
-        return membership_member_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return membership_member_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return membership_member_obj
 # ### END ### API Membership Member Methods ### load_membership_member_obj() ###
 
 
-
-# ### BEGIN ### API Membership Member Methods ### load_membership_member_obj_list() ###
-def load_membership_member_obj_list(
-        account_id: int|str|None = None,
-        membership_id: int|str|None = None,
-        limit: int = 1000,
-        model_as_dict: bool = False,
-        enabled: str = 'enabled', # enabled, disabled, all
-        inc_address: bool = False,
-        inc_contact: bool = False,
-        inc_membership_cfg: bool = False,
-        inc_membership_group_list: bool = False,
-        inc_membership_profile: bool = False,
-        # inc_membership_profile_cust: bool = False,
-        inc_organization: bool = False,
-        inc_person: bool = False,
-        inc_user: bool = False
-        ) -> list|bool:
-    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-    log.debug(locals())
-
-    data = {}
-    if account_id:
-        if account_id := redis_lookup_id_random(record_id_random=account_id, table_name='account'): pass
-        else: return False
-        data['account_id'] = account_id
-        sql_obj_type_id = f'`tbl`.account_id = :account_id'
-    elif membership_id:
-        if membership_id := redis_lookup_id_random(record_id_random=membership_id, table_name='membership'): pass
-        else: return False
-        data['membership_id'] = membership_id
-        sql_obj_type_id = f'`tbl`.membership_id = :membership_id'
-
-    if enabled in ['enabled', 'disabled', 'all']:
-        if enabled == 'enabled':
-            data['enable'] = True
-            sql_enabled = f'AND `tbl`.enable = :enable'
-        elif enabled == 'disabled':
-            data['enable'] = False
-            sql_enabled = f'AND `tbl`.enable = :enable'
-        elif enabled == 'all':
-            sql_enabled = ''
-    # else: tbl_obj['account'] = None
-
-    if limit:
-        data['limit'] = limit
-        sql_limit = f'LIMIT :limit'
-    else:
-        sql_limit = ''
-
-    sql = f"""
-        SELECT `tbl`.id AS 'membership_member_id', `tbl`.id_random AS 'membership_member_id_random'
-        FROM `membership_member` AS `tbl`
-        WHERE
-            {sql_obj_type_id}
-            {sql_enabled}
-        ORDER BY `tbl`.created_on DESC, `tbl`.updated_on DESC
-        {sql_limit};
-        """
-
-    if membership_member_rec_li_result := sql_select(data=data, sql=sql, as_list=True):
-        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-        log.debug(membership_member_rec_li_result)
-        membership_member_result_li = []
-        for membership_member_rec in membership_member_rec_li_result:
-            membership_member_id = membership_member_rec.get('membership_member_id', None)
-            if membership_member_result := load_membership_member_obj(
-                    membership_member_id = membership_member_id,
-                    model_as_dict = model_as_dict,
-                    enabled = enabled,
-                    # inc_membership = inc_membership,
-                    inc_membership_group_list = inc_membership_group_list,
-                    inc_membership_profile = inc_membership_profile,
-                    inc_organization = inc_organization,
-                    inc_person = inc_person,
-                    # inc_product = inc_product,
-                    inc_user = inc_user,
-                    ):
-                log.debug(membership_member_result)
-                membership_member_result_li.append(membership_member_result)
-            else:
-                log.debug(membership_member_result)
-                membership_member_result_li.append(None)
-        log.debug(membership_member_result_li)
-    else:
-        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
-        log.debug(membership_member_rec_li_result)
-        membership_member_result_li = []
-
-    return membership_member_result_li
-# ### END ### API Membership Member Methods ### load_membership_member_obj_list() ###
-
-
 # ### BEGIN ### API Membership Member Methods ### get_membership_member_rec_list() ###
 def get_membership_member_rec_list(
         for_obj_type: str,

app/methods/membership_methods.py

@@ -27,6 +27,8 @@ def save_membership_obj(membership_obj_new:Membership_Base):
 def load_membership_obj(
         membership_id:int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
         inc_address: bool = False,
@@ -58,12 +60,18 @@ def load_membership_obj(
     except ValidationError as e:
         log.error(e.json())
 
+    # Updated 2021-06-18
     if inc_membership_cfg:
-        if membership_cfg_rec := sql_select(table_name='v_membership_cfg', field_name='account_id', field_value=membership_rec.get('account_id', None)):
+        membership_cfg_result = load_membership_cfg_obj(
-            log.debug(membership_cfg_rec)
+            account_id = membership_rec.get('account_id', None),
-
+            by_alias = by_alias,
-            membership_rec['cfg'] = membership_cfg_rec
+            exclude_unset = exclude_unset,
+            model_as_dict = model_as_dict,
+            enabled = enabled,
+            )
+        membership_rec['cfg'] = membership_cfg_result
 
+    # Updated 2021-06-18
     if inc_membership_member_list:
         if membership_member_rec_list_result := get_membership_member_rec_list(
                 for_obj_type = 'membership',
@@ -71,15 +79,16 @@ def load_membership_obj(
                 limit = limit,
                 enabled = enabled,
                 ):
-            membership_member_dict_list = []
+            membership_member_result_list = []
             for membership_member_rec in membership_member_rec_list_result:
-                membership_member_dict_list.append(
+                membership_member_result_list.append(
                     load_membership_member_obj(
                         membership_member_id = membership_member_rec.get('membership_member_id', None),
                         limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         enabled = enabled,
-                        # inc_membership = inc_membership,
                         inc_membership_group_list = inc_membership_group_list,
                         inc_membership_profile = inc_membership_profile,
                         inc_organization = inc_organization,
@@ -88,9 +97,10 @@ def load_membership_obj(
                         inc_user = inc_user,
                         )
                     )
-            membership_obj.membership_member_list = membership_member_dict_list
+            membership_obj.membership_member_list = membership_member_result_list
         else: membership_obj.membership_member_list = []
 
+    # Updated 2021-06-18
     if inc_product_list:
         if product_rec_list_result := get_product_rec_list(
                 for_obj_type = 'membership',
@@ -98,19 +108,74 @@ def load_membership_obj(
                 limit = limit,
                 enabled = enabled,
                 ):
-            product_dict_list = []
+            product_result_list = []
             for product_rec in product_rec_list_result:
-                product_dict_list.append(
+                product_result_list.append(
                     load_product_obj(
                         product_id = product_rec.get('product_id', None),
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
                         model_as_dict = model_as_dict,
                         )
                     )
-            membership_obj.product_list = product_dict_list
+            membership_obj.product_list = product_result_list
         else: membership_obj.product_list = []
 
     if model_as_dict:
-        return membership_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return membership_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return membership_obj
 # ### END ### API Membership Methods ### load_membership_obj() ###
+
+# ### BEGIN ### API Membership Methods ### get_membership_rec_list() ###
+def get_membership_rec_list(
+        for_obj_type: str,
+        for_obj_id: str,
+        limit: int = 1000,
+        enabled: str = 'enabled', # enabled, disabled, all
+        ) -> list|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if for_obj_id := redis_lookup_id_random(record_id_random=for_obj_id, table_name='for_obj_type'): pass
+    else: return False
+    data = {}
+    data[f'{for_obj_type}_id'] = for_obj_id
+    # data['for_obj_type'] = for_obj_type
+    sql_obj_type_id = f'`tbl`.{for_obj_type}_id = :{for_obj_type}_id'
+
+    if enabled in ['enabled', 'disabled', 'all']:
+        if enabled == 'enabled':
+            data['enable'] = True
+            sql_enabled = f'AND `tbl`.enable = :enable'
+        elif enabled == 'disabled':
+            data['enable'] = False
+            sql_enabled = f'AND `tbl`.enable = :enable'
+        elif enabled == 'all':
+            sql_enabled = ''
+
+    if limit:
+        data['limit'] = limit
+        sql_limit = f'LIMIT :limit'
+    else:
+        sql_limit = ''
+
+    sql = f"""
+        SELECT `tbl`.id AS 'membership_id', `tbl`.id_random AS 'membership_id_random'
+        FROM `membership` AS `tbl`
+        WHERE
+            {sql_obj_type_id}
+            {sql_enabled}
+        ORDER BY `tbl`.created_on DESC, `tbl`.updated_on DESC
+        {sql_limit};
+        """
+
+    if membership_rec_li_result := sql_select(data=data, sql=sql, as_list=True):
+        membership_rec_li = membership_rec_li_result
+    else:
+        membership_rec_li = []
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(membership_rec_li_result)
+
+    return membership_rec_li
+# ### END ### API Membership Methods ### get_membership_rec_list() ###

app/methods/membership_profile_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_select
+from app.lib_general import log, logging
+
+from app.models.membership_profile_models import Membership_Profile_Base
+
+
+# ### BEGIN ### API Membership Profile Methods ### load_membership_profile_obj() ###
+def load_membership_profile_obj(
+        membership_profile_id: int|str,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
+        model_as_dict: bool = False,
+        inc_contact: bool = False,
+        inc_organization: bool = False,
+        ) -> Membership_Profile_Base|dict|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if membership_profile_id := redis_lookup_id_random(record_id_random=membership_profile_id, table_name='membership_profile'): pass
+    else: return False
+
+    if membership_profile_rec := sql_select(
+        table_name='v_membership_profile',
+        record_id=membership_profile_id,
+        ): pass
+    else: return False
+    log.debug(membership_profile_rec)
+    try:
+        membership_profile_obj = Membership_Profile_Base(**membership_profile_rec)
+        log.debug(membership_profile_obj)
+    except ValidationError as e:
+        log.error(e.json())
+
+    if model_as_dict:
+        return membership_profile_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
+    else:
+        return membership_profile_obj
+# ### END ### API Membership Profile Methods ### load_membership_profile_obj() ###
+
+
+# ### BEGIN ### API Membership Profile Methods ### get_membership_profile_rec_list() ###
+def get_membership_profile_rec_list(
+        for_obj_type: str,
+        for_obj_id: str,
+        limit: int = 1000,
+        enabled: str = 'enabled', # enabled, disabled, all
+        ) -> list|bool:
+    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(locals())
+
+    if for_obj_id := redis_lookup_id_random(record_id_random=for_obj_id, table_name='for_obj_type'): pass
+    else: return False
+    data = {}
+    data[f'{for_obj_type}_id'] = for_obj_id
+    # data['for_obj_type'] = for_obj_type
+    sql_obj_type_id = f'`tbl`.{for_obj_type}_id = :{for_obj_type}_id'
+
+    if enabled in ['enabled', 'disabled', 'all']:
+        if enabled == 'enabled':
+            data['enable'] = True
+            sql_enabled = f'AND `tbl`.enable = :enable'
+        elif enabled == 'disabled':
+            data['enable'] = False
+            sql_enabled = f'AND `tbl`.enable = :enable'
+        elif enabled == 'all':
+            sql_enabled = ''
+
+    if limit:
+        data['limit'] = limit
+        sql_limit = f'LIMIT :limit'
+    else:
+        sql_limit = ''
+
+    sql = f"""
+        SELECT `tbl`.id AS 'membership_profile_id', `tbl`.id_random AS 'membership_profile_id_random'
+        FROM `membership_profile` AS `tbl`
+        WHERE
+            {sql_obj_type_id}
+            {sql_enabled}
+        ORDER BY `tbl`.created_on DESC, `tbl`.updated_on DESC
+        {sql_limit};
+        """
+
+    if membership_profile_rec_li_result := sql_select(data=data, sql=sql, as_list=True):
+        membership_profile_rec_li = membership_profile_rec_li_result
+    else:
+        membership_profile_rec_li = []
+    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
+    log.debug(membership_profile_rec_li_result)
+
+    return membership_profile_rec_li
+# ### END ### API Membership Profile Methods ### get_membership_profile_rec_list() ###

app/methods/order_methods.py

@@ -161,6 +161,8 @@ def save_order_obj(order_obj_new:Order_Base, repl_order_line_li:bool=False):
 def load_order_obj(
         order_id: int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
         inc_order_line_list: bool = False,
@@ -210,7 +212,10 @@ def load_order_obj(
     except ValidationError as e:
         log.error(e.json())
 
-    return order_obj
+    if model_as_dict:
+        return order_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
+    else:
+        return order_obj
 # ### END ### API Order Methods ### load_order_obj() ###
 
 

app/methods/organization_methods.py

@@ -18,6 +18,8 @@ from app.models.organization_models import Organization_Base
 def load_organization_obj(
         organization_id:int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
         inc_contact:bool=False,
@@ -41,21 +43,24 @@ def load_organization_obj(
     except ValidationError as e:
         log.error(e.json())
 
+    # Updated 2021-06-18
     if inc_contact:
-        #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
         contact_id = organization_rec.get('contact_id', None)
         log.debug(contact_id)
-        # from app.methods.contact_methods import load_contact_obj
+        if contact_result := load_contact_obj(
-        if contact_dict := load_contact_obj(
             contact_id = contact_id,
+            limit = limit,
+            by_alias = by_alias,
+            exclude_unset = exclude_unset,
             model_as_dict = model_as_dict,
+            enabled = enabled,
             inc_address = inc_address,
             ):
-            organization_obj.contact = contact_dict
+            organization_obj.contact = contact_result
         else: organization_obj.contact = None
 
     if model_as_dict:
-        return organization_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return organization_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return organization_obj
 # ### END ### API Organization Methods ### load_organization_obj() ###

app/methods/person_methods.py

@@ -63,6 +63,8 @@ def create_person_obj(person_obj_new:Person_Base):
 def load_person_obj(
         person_id: int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
         inc_address: bool = False, # Under contact
@@ -85,25 +87,31 @@ def load_person_obj(
     except ValidationError as e:
         log.error(e.json())
 
+    # Updated 2021-06-18
     if inc_contact:
         contact_id = person_rec.get('contact_id', None)
         log.debug(contact_id)
-        if contact_dict := load_contact_obj(
+        if contact_result := load_contact_obj(
             contact_id = contact_id,
             limit = limit,
+            by_alias = by_alias,
+            exclude_unset = exclude_unset,
             model_as_dict = model_as_dict,
             enabled = enabled,
             inc_address = inc_address,
             ):
-            person_obj.contact = contact_dict
+            person_obj.contact = contact_result
         else: person_obj.contact = None
 
+    # Updated 2021-06-18
     if inc_organization:
         organization_id = person_rec.get('organization_id', None)
         log.debug(organization_id)
         if organization_dict := load_organization_obj(
             organization_id = organization_id,
             limit = limit,
+            by_alias = by_alias,
+            exclude_unset = exclude_unset,
             model_as_dict = model_as_dict,
             enabled = enabled,
             inc_address = inc_address,
@@ -112,18 +120,23 @@ def load_person_obj(
             person_obj.organization = organization_dict
         else: person_obj.organization = None
 
+    # Updated 2021-06-18
     if inc_user:
         user_id = person_rec.get('user_id', None)
-        if user_obj_result := load_user_obj(user_id=user_id):
+        log.debug(user_id)
-            user_obj = user_obj_result
+        if user_result := load_user_obj(
-            # person_rec['user'] = user_obj
+            user_id = user_id,
-            # log.debug(person_rec)
+            limit = limit,
-            #person_obj.user = user_obj.dict(by_alias=True, exclude_unset=True)
+            by_alias = by_alias,
-            person_obj.user = user_obj
+            exclude_unset = exclude_unset,
+            model_as_dict = model_as_dict,
+            enabled = enabled,
+            ):
+            person_obj.user = user_result
         else: person_obj.user = None
 
     if model_as_dict:
-        return person_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return person_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return person_obj
 # ### END ### API Person Methods ### load_person_obj() ###

app/methods/post_comment_methods.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel, EmailStr, Field, PrivateAttr, ValidationError, v
 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.person_methods import load_person_obj
+# from app.methods.person_methods import load_person_obj
 # from app.methods.user_methods import load_user_obj
 
 from app.models.post_comment_models import Post_Comment_Base
@@ -66,25 +66,33 @@ def load_post_comment_obj(
         log.error(e.json())
         return False
 
+    # Updated 2021-06-18
     if inc_person:
-        person_id = post_comment_rec.get('person_id', None)
+        from app.methods.person_methods import load_person_obj
-        if person_obj_result := load_person_obj(person_id=person_id):
+        person_result = load_person_obj(
-            person_obj = person_obj_result
+            person_id = post_comment_rec.get('person_id', None),
-            # post_comment_rec['person'] = person_obj
+            limit = limit,
-            # log.debug(post_comment_rec)
+            by_alias = by_alias,
-            #post_comment_obj.person = person_obj.dict(by_alias=True, exclude_unset=True)
+            exclude_unset = exclude_unset,
-            post_comment_obj.person = person_obj
+            model_as_dict = model_as_dict,
-        else: post_comment_obj.person = None
+            enabled = enabled,
+            )
+        post_comment_obj.person = person_result
+    else: post_comment_obj.person = None
 
+    # Updated 2021-06-18
     if inc_user:
-        user_id = post_comment_rec.get('user_id', None)
+        from app.methods.user_methods import load_user_obj
-        if user_obj_result := load_user_obj(user_id=user_id):
+        user_result = load_user_obj(
-            user_obj = user_obj_result
+            user_id = post_comment_rec.get('user_id', None),
-            # post_comment_rec['user'] = user_obj
+            limit = limit,
-            # log.debug(post_comment_rec)
+            by_alias = by_alias,
-            #post_comment_obj.user = user_obj.dict(by_alias=True, exclude_unset=True)
+            exclude_unset = exclude_unset,
-            post_comment_obj.user = user_obj
+            model_as_dict = model_as_dict,
-        else: post_comment_obj.user = None
+            enabled = enabled,
+            )
+        post_comment_obj.user = user_result
+    else: post_comment_obj.user = None
 
     if model_as_dict:
         return post_comment_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member

app/methods/post_methods.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel, EmailStr, Field, PrivateAttr, ValidationError, v
 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.person_methods import load_person_obj
+# from app.methods.person_methods import load_person_obj
 # from app.methods.post_comment_methods import create_post_comment_obj, update_post_comment_obj
 from app.methods.post_comment_methods import get_post_comment_rec_list, load_post_comment_obj
 # from app.methods.user_methods import load_user_obj
@@ -46,8 +46,8 @@ def load_post_obj(
         exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
-        inc_post_comment_list: bool = False,
         inc_person: bool = False,
+        inc_post_comment_list: bool = False,
         inc_user: bool = False,
         ) -> Post_Base|bool:
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
@@ -70,15 +70,19 @@ def load_post_obj(
     except ValidationError as e:
         log.error(e.json())
 
+    # Updated 2021-06-18
     if inc_person:
-        person_id = post_rec.get('person_id', None)
+        from app.methods.person_methods import load_person_obj
-        if person_obj_result := load_person_obj(person_id=person_id):
+        person_result = load_person_obj(
-            person_obj = person_obj_result
+            person_id = post_rec.get('person_id', None),
-            # post_rec['person'] = person_obj
+            limit = limit,
-            # log.debug(post_rec)
+            by_alias = by_alias,
-            #post_obj.person = person_obj.dict(by_alias=True, exclude_unset=True)
+            exclude_unset = exclude_unset,
-            post_obj.person = person_obj
+            model_as_dict = model_as_dict,
-        else: post_obj.person = None
+            enabled = enabled,
+            )
+        post_obj.person = person_result
+    else: post_obj.person = None
 
     # Updated 2021-06-17
     if inc_post_comment_list:
@@ -105,18 +109,22 @@ def load_post_obj(
             post_obj.post_comment_list = post_comment_result_list
         else: post_obj.post_comment_list = []
 
+    # Updated 2021-06-18
     if inc_user:
-        user_id = post_rec.get('user_id', None)
+        from app.methods.user_methods import load_user_obj
-        if user_obj_result := load_user_obj(user_id=user_id):
+        user_result = load_user_obj(
-            user_obj = user_obj_result
+            user_id = post_rec.get('user_id', None),
-            # post_rec['user'] = user_obj
+            limit = limit,
-            # log.debug(post_rec)
+            by_alias = by_alias,
-            #post_obj.user = user_obj.dict(by_alias=True, exclude_unset=True)
+            exclude_unset = exclude_unset,
-            post_obj.user = user_obj
+            model_as_dict = model_as_dict,
-        else: post_obj.user = None
+            enabled = enabled,
+            )
+        post_obj.user = user_result
+    else: post_obj.user = None
 
     if model_as_dict:
-        return post_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return post_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return post_obj
 # ### END ### API Post Methods ### load_post_obj() ###

app/methods/product_methods.py

@@ -14,6 +14,8 @@ from app.models.product_models import Product_Base
 def load_product_obj(
         product_id: int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         ) -> Product_Base:
     log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
@@ -32,7 +34,7 @@ def load_product_obj(
         log.error(e.json())
 
     if model_as_dict:
-        return product_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return product_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return product_obj
 # ### END ### API Product Methods ### load_product_obj() ###

app/methods/user_methods.py

@@ -8,11 +8,10 @@ from app.db_sql import redis_lookup_id_random, sql_insert, sql_select, sql_updat
 from app.lib_general import log, logging
 
 from app.methods.contact_methods import load_contact_obj, update_contact_obj
-# from app.methods.event_methods import load_event_obj_list
+# from app.methods.event_methods import get_event_rec_list
 from app.methods.organization_methods import load_organization_obj, update_organization_obj
 # from app.methods.person_methods import load_person_obj, update_person_obj
-# from app.methods.post_methods import load_post_obj_list
+from app.methods.post_methods import get_post_rec_list, load_post_obj
-# from app.methods.post_list_methods import load_post_obj_list
 
 from app.models.user_models import User_Base, User_New_Base, User_Out_Base
 from app.models.user_role_models import User_Role_Base
@@ -76,6 +75,8 @@ def create_user_obj(user_obj_new:User_New_Base) -> int|bool:
 def load_user_obj(
         user_id: int|str,
         limit: int = 1000,
+        by_alias: bool = True,
+        exclude_unset: bool = True,
         model_as_dict: bool = False,
         enabled: str = 'enabled', # enabled, disabled, all
         inc_address: bool = False,
@@ -110,17 +111,20 @@ def load_user_obj(
         log.error(e.json())
         return False
 
+    # Updated 2021-06-18
     if inc_contact:
         contact_id = user_rec.get('contact_id', None)
         log.debug(contact_id)
-        if contact_dict := load_contact_obj(
+        if contact_result := load_contact_obj(
             contact_id = contact_id,
             limit = limit,
+            by_alias = by_alias,
+            exclude_unset = exclude_unset,
             model_as_dict = model_as_dict,
             enabled = enabled,
             inc_address = inc_address,
             ):
-            user_obj.contact = contact_dict
+            user_obj.contact = contact_result
         else: user_obj.contact = None
 
     if inc_event_list:
@@ -134,49 +138,67 @@ def load_user_obj(
             user_obj.event_list = event_dict_list
         else: user_obj.event_list = []
 
+    # Updated 2021-06-18
     if inc_organization:
         organization_id = user_rec.get('organization_id', None)
         log.debug(organization_id)
-        if organization_dict := load_organization_obj(
+        if organization_result := load_organization_obj(
             organization_id = organization_id,
             limit = limit,
+            by_alias = by_alias,
+            exclude_unset = exclude_unset,
             model_as_dict = model_as_dict,
             enabled = enabled,
             inc_address = inc_address,
             inc_contact = inc_contact,
             ):
-            user_obj.organization = organization_dict
+            user_obj.organization = organization_result
         else: user_obj.organization = None
 
+    # Updated 2021-06-18
     if inc_person:
-        #log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
         person_id = user_rec.get('person_id', None)
         log.debug(person_id)
-        from app.methods.person_methods import load_person_obj
+        if person_result := load_person_obj(
-        if person_dict := load_person_obj(
+                person_id = person_id,
-            person_id = person_id,
+                by_alias = by_alias,
-            limit = limit,
+                exclude_unset = exclude_unset,
-            model_as_dict = model_as_dict,
+                model_as_dict = model_as_dict,
-            enabled = enabled,
+                inc_address = inc_address,
-            inc_address = inc_address,
+                inc_contact = inc_contact,
-            inc_contact = inc_contact,
+                # inc_organization = inc_organization,
-            inc_organization = inc_organization,
+                # inc_user = inc_user,
-            ):
+                ):
-            user_obj.person = person_dict
+            user_obj.person = person_result
         else: user_obj.person = None
+        log.debug(person_result)
 
+    # Updated 2021-06-18
     if inc_post_list:
-        from app.methods.post_methods import load_post_obj_list
+        if post_rec_list_result := get_post_rec_list(
-        if post_dict_list := load_post_obj_list(
+                for_obj_type = 'user',
-            user_id = user_id,
+                for_obj_id = user_id,
-            limit = limit,
+                limit = limit,
-            model_as_dict = model_as_dict,
+                enabled = enabled,
-            enabled = enabled,
+                ):
-            ):
+            post_result_list = []
-            user_obj.post_list = post_dict_list
+            for post_rec in post_rec_list_result:
+                post_result_list.append(
+                    load_post_obj(
+                        post_id = post_rec.get('post_id', None),
+                        limit = limit,
+                        by_alias = by_alias,
+                        exclude_unset = exclude_unset,
+                        model_as_dict = model_as_dict,
+                        enabled = enabled,
+                        inc_post_comment_list = inc_post_comment_list,
+                        inc_person = inc_person,
+                        # inc_user = inc_user,
+                        )
+                    )
+            user_obj.post_list = post_result_list
         else: user_obj.post_list = []
 
-
     # NOTE: Including user roles should probably be reviewed
     if inc_user_role_list:
         if role_rec_li := sql_select(table_name='v_user_role_detail', field_name='user_id', field_value=user_id, as_list=True):
@@ -189,7 +211,7 @@ def load_user_obj(
     log.debug(user_obj)
 
     if model_as_dict:
-        return user_obj.dict(by_alias=True, exclude_unset=True) # pylint: disable=no-member
+        return user_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
     else:
         return user_obj
 # ### END ### API User Methods ### load_user_obj() ###

app/models/membership_models.py

@@ -69,8 +69,9 @@ class Membership_Base(BaseModel):
     # additional_terms_conditions: Optional[dict] = {} # Is this useful?
 
     # Including other related objects
-    product: Optional[list] # Product_Base() List of products (for_type and for_id) that get this membership option
     cfg: Optional[Membership_Cfg_Base] = Membership_Cfg_Base()
+    membership_member_list: Optional[list] # Membership_Member_Base() List of membership members
+    product_list: Optional[list] # Product_Base() List of products (for_type and for_id) that get this membership option
 
     _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)
 

app/routers/account.py

@@ -144,6 +144,7 @@ async def get_account_obj_new(
         # inc_membership: bool = False,
         inc_membership_cfg: bool = False,
         inc_membership_list: bool = False,
+        inc_membership_member_list: bool = False,
         # inc_order: bool = False,
         inc_order_list: bool = False,
         # inc_order_cart: bool = False,
@@ -214,6 +215,7 @@ async def get_account_obj_new(
         # inc_membership = inc_membership,
         inc_membership_cfg = inc_membership_cfg,
         inc_membership_list = inc_membership_list,
+        inc_membership_member_list = inc_membership_member_list,
         # inc_order = inc_order,
         inc_order_list = inc_order_list,
         # inc_order_cart = inc_order_cart,