Feat(Python): Main business objects for Dog Command Link page created.

business_objects/base.py

@@ -56,6 +56,7 @@ class Base():
     FLAG_NAME_ATTR_OPTION_VALUE: ClassVar[str] = 'NAME_ATTR_OPTION_VALUE'
     FLAG_NAME_SINGULAR: ClassVar[str] = 'name_singular'
     FLAG_NAME_PLURAL: ClassVar[str] = 'name_plural'
+    FLAG_NOTES: ClassVar[str] = "notes"
     FLAG_PHONE_NUMBER: ClassVar[str] = 'phone_number'
     FLAG_POSTCODE: ClassVar[str] = 'postcode'
     FLAG_PRIORITY: ClassVar[str] = 'priority'

business_objects/dog/command.py

@@ -9,6 +9,7 @@ Feature:    Command Business Object
 
 # internal
 from business_objects.base import Base
+from business_objects.dog.command_category import Command_Category
 from business_objects.db_base import SQLAlchemy_ABC
 import lib.argument_validation as av
 from extensions import db
@@ -19,43 +20,42 @@ from typing import ClassVar
 
 
 class Command(SQLAlchemy_ABC, Base):
-    FLAG_ALTCHA: ClassVar[str] = 'altcha'
     FLAG_COMMAND: ClassVar[str] = 'command'
-    FLAG_NAME_COMPANY: ClassVar[str] = 'name-company'
-    FLAG_NAME_CONTACT: ClassVar[str] = 'name-contact'
-    FLAG_MESSAGE: ClassVar[str] = 'message'
-    FLAG_RECEIVE_MARKETING_COMMUNICATIONS: ClassVar[str] = 'receive-marketing-communications'
+    FLAG_HAND_SIGNAL_DEFAULT_DESCRIPTION: ClassVar[str] = 'hand-signal-default-description'
+    FLAG_CAN_HAVE_BUTTON: ClassVar[str] = 'can-have-button'
     NAME_ATTR_OPTION_VALUE: ClassVar[str] = FLAG_COMMAND
-    NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_EMAIL
+    NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_NAME
 
-    __tablename__ = 'PH_Command'
+    __tablename__ = 'DOG_Command'
     __table_args__ = { 'extend_existing': True }
 
     id_command = db.Column(db.Integer, primary_key=True)
-    email = db.Column(db.String(250))
-    name_contact = db.Column(db.String(250))
-    name_company = db.Column(db.String(250))
-    message = db.Column(db.Text)
-    receive_marketing_communications = db.Column(db.Boolean)
+    id_command_category = db.Column(db.Integer)
+    name = db.Column(db.String(250))
+    hand_signal_default_description = db.Column(db.Text)
+    can_have_button = db.Column(db.Boolean)
+    notes = db.Column(db.Text)
     active = db.Column(db.Boolean)
     created_on = db.Column(db.DateTime)
     
     def __init__(self):
         self.id_command = 0
         self.is_new = False
+        self.has_button = False
         super().__init__()
         
-    def from_DB_Command(query_row):
-        _m = 'Command.from_DB_Command'
+    def from_DB_Dog_Command(query_row):
+        _m = 'Command.from_DB_Dog_Command'
         command = Command()
-        command.id_command = query_row[0]
-        command.email = query_row[1]
-        command.name_contact = query_row[2]
-        command.name_company = query_row[3]
-        command.message = query_row[4]
-        command.receive_marketing_communications = av.input_bool(query_row[5], 'receive_marketing_communications', _m)
-        command.active = av.input_bool(query_row[6], 'active', _m)
-        command.created_on = query_row[7]
+        command.id_command = query_row[5]
+        command.id_command_category = query_row[3]
+        command.name = query_row[7]
+        # command.hand_signal_default_description = query_row[2]
+        # command.can_have_button = av.input_bool(query_row[5], 'can_have_button', _m)
+        command.has_button = av.input_bool(query_row[7], 'has_button', _m)
+        # command.notes = query_row[4]
+        command.active = av.input_bool(True, 'active', _m)
+        # command.created_on = query_row[7]
         return command
     
     @classmethod
@@ -65,25 +65,24 @@ class Command(SQLAlchemy_ABC, Base):
         if json is None: return Command
         Helper_App.console_log(f'{_m}\njson: {json}')
         command.id_command = -1
-        command.email = json[cls.FLAG_EMAIL]
-        command.name_contact = json[cls.FLAG_NAME_CONTACT]
-        command.name_company = json[cls.FLAG_NAME_COMPANY]
-        command.message = json[cls.FLAG_MESSAGE]
-        command.receive_marketing_communications = json[cls.FLAG_RECEIVE_MARKETING_COMMUNICATIONS]
+        command.id_command_category = json[Command_Category.FLAG_COMMAND_CATEGORY]
+        command.name = json[cls.FLAG_NAME]
+        command.hand_signal_default_description = json[cls.FLAG_HAND_SIGNAL_DEFAULT_DESCRIPTION]
+        command.can_have_button = json[cls.FLAG_CAN_HAVE_BUTTON]
+        command.notes = json[cls.FLAG_NOTES]
         command.active = json[cls.FLAG_ACTIVE]
         command.created_on = json.get(cls.FLAG_CREATED_ON, None)
         Helper_App.console_log(f'Command: {command}')
         return command
     
-    
     def to_json(self):
         as_json = {
               self.FLAG_COMMAND: self.id_command
-            , self.FLAG_EMAIL: self.email
-            , self.FLAG_NAME_CONTACT: self.name_contact
-            , self.FLAG_NAME_COMPANY: self.name_company
-            , self.FLAG_MESSAGE: self.message
-            , self.FLAG_RECEIVE_MARKETING_COMMUNICATIONS: self.receive_marketing_communications
+            , Command_Category.FLAG_COMMAND_CATEGORY: self.id_command_category
+            , self.FLAG_NAME: self.name
+            , self.FLAG_HAND_SIGNAL_DEFAULT_DESCRIPTION: self.hand_signal_default_description
+            , self.FLAG_CAN_HAVE_BUTTON: self.can_have_button
+            , self.FLAG_NOTES: self.notes
             , self.FLAG_ACTIVE: self.active
             , self.FLAG_CREATED_ON: self.created_on
         }
@@ -94,26 +93,26 @@ class Command(SQLAlchemy_ABC, Base):
         return f'''
 {self.__class__.__name__}(
     {self.FLAG_COMMAND}: {self.id_command}
-    {self.FLAG_EMAIL}: {self.email}
-    {self.FLAG_NAME_CONTACT}: {self.name_contact}
-    {self.FLAG_NAME_COMPANY}: {self.name_company}
-    {self.FLAG_MESSAGE}: {self.message}
-    {self.FLAG_RECEIVE_MARKETING_COMMUNICATIONS}: {self.receive_marketing_communications}
+    {Command_Category.FLAG_COMMAND_CATEGORY}: {self.id_command_category}
+    {self.FLAG_NAME}: {self.name}
+    {self.FLAG_HAND_SIGNAL_DEFAULT_DESCRIPTION}: {self.hand_signal_default_description}
+    {self.FLAG_CAN_HAVE_BUTTON}: {self.can_have_button}
+    {self.FLAG_NOTES}: {self.notes}
     {self.FLAG_ACTIVE}: {self.active}
     {self.FLAG_CREATED_ON}: {self.created_on}
 )
             '''
 
 class Command_Temp(db.Model, Base):
-    __tablename__ = 'PH_Command_Temp'
+    __tablename__ = 'DOG_Command_Temp'
     __table_args__ = { 'extend_existing': True }
     id_temp = db.Column(db.Integer, primary_key=True)
     id_command = db.Column(db.Integer)
-    email = db.Column(db.String(250))
-    name_contact = db.Column(db.String(250))
-    name_company = db.Column(db.String(250))
-    message = db.Column(db.Text)
-    receive_marketing_communications = db.Column(db.Boolean)
+    id_command_category = db.Column(db.Integer)
+    name = db.Column(db.String(250))
+    hand_signal_default_description = db.Column(db.Text)
+    can_have_button = db.Column(db.Boolean)
+    notes = db.Column(db.Text)
     active = db.Column(db.Boolean)
     created_on = db.Column(db.DateTime)
     guid: str = db.Column(db.String(36))
@@ -122,15 +121,15 @@ class Command_Temp(db.Model, Base):
         super().__init__()
 
     @classmethod
-    def from_command(cls, command):
+    def from_Command(cls, command):
         _m = 'Command_Temp.from_Command'
         temp = cls()
         temp.id_command = command.id_command
-        temp.email = command.email
-        temp.name_contact = command.name_contact
-        temp.name_company = command.name_company
-        temp.message = command.message
-        temp.receive_marketing_communications = command.receive_marketing_communications
+        temp.id_command_category = command.id_command_category
+        temp.name = command.name
+        temp.hand_signal_default_description = command.hand_signal_default_description
+        temp.can_have_button = command.can_have_button
+        temp.notes = command.notes
         temp.active = command.active
         temp.created_on = command.created_on
         return temp

business_objects/dog/command_category.py

@@ -0,0 +1,104 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: Business Objects
+Feature:    Command Category Business Object
+"""
+
+# internal
+from business_objects.base import Base
+from business_objects.db_base import SQLAlchemy_ABC
+import lib.argument_validation as av
+from extensions import db
+from helpers.helper_app import Helper_App
+# external
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+class Command_Category(SQLAlchemy_ABC, Base):
+    FLAG_COMMAND_CATEGORY: ClassVar[str] = 'command-category'
+    NAME_ATTR_OPTION_VALUE: ClassVar[str] = FLAG_COMMAND_CATEGORY
+    NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_NAME
+
+    __tablename__ = 'DOG_Command_Category'
+    __table_args__ = { 'extend_existing': True }
+
+    id_command_category = db.Column(db.Integer, primary_key=True)
+    code = db.Column(db.String(100))
+    name = db.Column(db.String(250))
+    active = db.Column(db.Boolean)
+    
+    def __init__(self):
+        self.id_command_category = 0
+        self.is_new = False
+        super().__init__()
+        
+    def from_DB_Dog_Command(query_row):
+        _m = 'Command_Category.from_DB_Dog_Command'
+        level = Command_Category()
+        level.id_command_category = query_row[5]
+        level.code = query_row[6]
+        level.name = query_row[7]
+        level.active = True
+        return level
+    
+    @classmethod
+    def from_json(cls, json):
+        _m = 'Command_Category.from_json'
+        command_category = cls()
+        if json is None: return Command_Category
+        Helper_App.console_log(f'{_m}\njson: {json}')
+        command_category.id_command_category = -1
+        command_category.code = json[cls.FLAG_CODE]
+        command_category.name = json[cls.FLAG_NAME]
+        command_category.active = json[cls.FLAG_ACTIVE]
+        Helper_App.console_log(f'Command_Category: {command_category}')
+        return command_category
+    
+    
+    def to_json(self):
+        as_json = {
+              self.FLAG_COMMAND_CATEGORY: self.id_command_category
+            , self.FLAG_CODE: self.code
+            , self.FLAG_NAME: self.name
+            , self.FLAG_ACTIVE: self.active
+        }
+        Helper_App.console_log(f'as_json: {as_json}')
+        return as_json
+        
+    def __repr__(self):
+        return f'''
+{self.__class__.__name__}(
+    {self.FLAG_COMMAND_CATEGORY}: {self.id_command_category}
+    {self.FLAG_CODE}: {self.code}
+    {self.FLAG_NAME}: {self.name}
+    {self.FLAG_ACTIVE}: {self.active}
+)
+            '''
+
+
+class Command_Category_Temp(db.Model, Base):
+    __tablename__ = 'DOG_Command_Category_Temp'
+    __table_args__ = { 'extend_existing': True }
+    id_temp = db.Column(db.Integer, primary_key=True)
+    id_command_category = db.Column(db.Integer)
+    code = db.Column(db.String(100))
+    name = db.Column(db.String(250))
+    active = db.Column(db.Boolean)
+    guid: str = db.Column(db.String(36))
+
+    def __init__(self):
+        super().__init__()
+
+    @classmethod
+    def from_command_category(cls, command_category):
+        _m = 'Command_Category_Temp.from_Command_Category'
+        temp = cls()
+        temp.id_command_category = command_category.id_command_category
+        temp.code = command_category.code
+        temp.name = command_category.name
+        temp.active = command_category.active
+        return temp

business_objects/dog/dog.py

@@ -26,7 +26,7 @@ class Dog(SQLAlchemy_ABC, Base):
     NAME_ATTR_OPTION_VALUE: ClassVar[str] = FLAG_DOG
     NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_EMAIL
 
-    __tablename__ = 'PH_Dog'
+    __tablename__ = 'DOG_Dog'
     __table_args__ = { 'extend_existing': True }
 
     id_dog = db.Column(db.Integer, primary_key=True)
@@ -41,15 +41,17 @@ class Dog(SQLAlchemy_ABC, Base):
         self.is_new = False
         super().__init__()
     
-    def from_DB_Dog(query_row):
+    def from_DB_Dog_Command(query_row):
         _m = 'Dog.from_DB_Dog'
         dog = Dog()
-        dog.id_dog = query_row[0]
-        dog.name = query_row[1]
+        dog.id_dog = query_row[1]
+        dog.name = query_row[2]
+        """
         dog.appearance = query_row[2]
         dog.mass_kg = query_row[3]
         dog.notes = query_row[4]
-        dog.active = av.input_bool(query_row[5], 'active', _m)
+        """
+        dog.active = av.input_bool(True, 'active', _m)
         return dog
     
     @classmethod
@@ -92,17 +94,15 @@ class Dog(SQLAlchemy_ABC, Base):
 )
             '''
 
-"""
 class Dog_Temp(db.Model, Base):
-    __tablename__ = 'PH_Dog_Temp'
+    __tablename__ = 'DOG_Dog_Temp'
     __table_args__ = { 'extend_existing': True }
     id_temp = db.Column(db.Integer, primary_key=True)
     id_dog = db.Column(db.Integer)
-    email = db.Column(db.String(250))
-    name_contact = db.Column(db.String(250))
-    name_company = db.Column(db.String(250))
-    message = db.Column(db.Text)
-    receive_marketing_communications = db.Column(db.Boolean)
+    name = db.Column(db.String(250))
+    appearance = db.Column(db.String(1000))
+    mass_kg = db.Column(db.Numeric(precision=7, scale=3))
+    notes = db.Column(db.Text)
     active = db.Column(db.Boolean)
     created_on = db.Column(db.DateTime)
     guid: str = db.Column(db.String(36))
@@ -115,12 +115,10 @@ class Dog_Temp(db.Model, Base):
         _m = 'Dog_Temp.from_Dog'
         temp = cls()
         temp.id_dog = dog.id_dog
-        temp.email = dog.email
-        temp.name_contact = dog.name_contact
-        temp.name_company = dog.name_company
-        temp.message = dog.message
-        temp.receive_marketing_communications = dog.receive_marketing_communications
+        temp.name = dog.name
+        temp.appearance = dog.appearance
+        temp.mass_kg = dog.mass_kg
+        temp.notes = dog.notes
         temp.active = dog.active
         temp.created_on = dog.created_on
         return temp
-"""

business_objects/dog/dog_command_link.py

@@ -0,0 +1,149 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: Business Objects
+Feature:    Dog Command Link Business Object
+"""
+
+# internal
+from business_objects.base import Base
+from business_objects.dog.command import Command
+from business_objects.dog.command_category import Command_Category
+from business_objects.db_base import SQLAlchemy_ABC
+from business_objects.dog.dog import Dog
+from business_objects.dog.obedience_level import Obedience_Level
+from business_objects.dog.understanding_level import Understanding_Level
+import lib.argument_validation as av
+from extensions import db
+from helpers.helper_app import Helper_App
+# external
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+class Dog_Command_Link(SQLAlchemy_ABC, Base):
+    FLAG_DOG_COMMAND_LINK: ClassVar[str] = 'dog_command_link'
+    FLAG_HAND_SIGNAL_DESCRIPTION: ClassVar[str] = 'hand-signal-description'
+    FLAG_CAN_HAVE_BUTTON: ClassVar[str] = 'can-have-button'
+    NAME_ATTR_OPTION_VALUE: ClassVar[str] = FLAG_DOG_COMMAND_LINK
+    NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_NAME
+
+    __tablename__ = 'DOG_Dog_Command_Link'
+    __table_args__ = { 'extend_existing': True }
+
+    id_dog_command_link = db.Column(db.Integer, primary_key=True)
+    id_dog = db.Column(db.Integer)
+    id_command = db.Column(db.Integer)
+    id_understanding_level = db.Column(db.Integer)
+    id_obedience_level = db.Column(db.Integer)
+    hand_signal_description = db.Column(db.Text)
+    notes = db.Column(db.Text)
+    active = db.Column(db.Boolean)
+    created_on = db.Column(db.DateTime)
+    
+    def __init__(self):
+        self.id_dog_command_link = 0
+        self.is_new = False
+        #self.id_command_category = None
+        super().__init__()
+        
+    def from_DB_Dog_Command(query_row):
+        _m = 'Dog_Command_Link.from_DB_Dog_Command'
+        dog_command_link = Dog_Command_Link()
+        dog_command_link.id_dog_command_link = query_row[0]
+        dog_command_link.id_dog = query_row[1]
+        #dog_command_link.id_command_category = query_row[3]
+        dog_command_link.id_command = query_row[5]
+        dog_command_link.id_understanding_level = query_row[8]
+        dog_command_link.id_obedience_level = query_row[11]
+        dog_command_link.hand_signal_description = query_row[14]
+        dog_command_link.notes = query_row[15]
+        dog_command_link.active = av.input_bool(query_row[16], 'active', _m)
+        # dog_command_link.created_on = query_row[7]
+        return dog_command_link
+    
+    @classmethod
+    def from_json(cls, json):
+        _m = 'Dog_Command_Link.from_json'
+        dog_command_link = cls()
+        if json is None: return dog_command_link
+        Helper_App.console_log(f'{_m}\njson: {json}')
+        dog_command_link.id_dog_command_link = -1
+        dog_command_link.id_dog = json[Dog.FLAG_DOG]
+        dog_command_link.id_command = json[Command.FLAG_COMMAND]
+        dog_command_link.id_understanding_level = json[Understanding_Level.FLAG_UNDERSTANDING_LEVEL]
+        dog_command_link.id_obedience_level = json[Obedience_Level.FLAG_OBEDIENCE_LEVEL]
+        dog_command_link.hand_signal_description = json[cls.FLAG_HAND_SIGNAL_DESCRIPTION]
+        dog_command_link.notes = json[cls.FLAG_NOTES]
+        dog_command_link.active = json[cls.FLAG_ACTIVE]
+        dog_command_link.created_on = json.get(cls.FLAG_CREATED_ON, None)
+        # dog_command_link.id_command_category = json[Command_Category.FLAG_COMMAND_CATEGORY]
+        Helper_App.console_log(f'Dog Command Link: {dog_command_link}')
+        return dog_command_link
+    
+    def to_json(self):
+        as_json = {
+              self.FLAG_DOG_COMMAND_LINK: self.id_dog_command_link
+            , Dog.FLAG_DOG: self.id_dog
+            , Command.FLAG_COMMAND: self.id_command
+            , Understanding_Level.FLAG_UNDERSTANDING_LEVEL: self.id_understanding_level
+            , Obedience_Level.FLAG_OBEDIENCE_LEVEL: self.id_obedience_level
+            , self.FLAG_HAND_SIGNAL_DESCRIPTION: self.hand_signal_description
+            , self.FLAG_NOTES: self.notes
+            , self.FLAG_ACTIVE: self.active
+            , self.FLAG_CREATED_ON: self.created_on
+        }
+        #   , Command_Category.FLAG_COMMAND_CATEGORY: self.id_command_category
+        Helper_App.console_log(f'as_json: {as_json}')
+        return as_json
+        
+    def __repr__(self):
+        return f'''
+{self.__class__.__name__}(
+    {self.FLAG_DOG_COMMAND_LINK}: {self.id_dog_command_link}
+    {Dog.FLAG_DOG}: {self.id_dog}
+    {Command.FLAG_COMMAND}: {self.id_command}
+    {Understanding_Level.FLAG_UNDERSTANDING_LEVEL}: {self.id_understanding_level}
+    {Obedience_Level.FLAG_OBEDIENCE_LEVEL}: {self.id_obedience_level}
+    {self.FLAG_HAND_SIGNAL_DESCRIPTION}: {self.hand_signal_description}
+    {self.FLAG_NOTES}: {self.notes}
+    {self.FLAG_ACTIVE}: {self.active}
+    {self.FLAG_CREATED_ON}: {self.created_on}
+)
+            '''
+#   {Command_Category.FLAG_COMMAND_CATEGORY}: {self.id_command_category}
+
+class Dog_Command_Link_Temp(db.Model, Base):
+    __tablename__ = 'DOG_Dog_Command_Link_Temp'
+    __table_args__ = { 'extend_existing': True }
+    id_temp = db.Column(db.Integer, primary_key=True)
+    id_dog_command_link = db.Column(db.Integer)
+    id_dog = db.Column(db.Integer)
+    id_command = db.Column(db.Integer)
+    id_understanding_level = db.Column(db.Integer)
+    id_obedience_level = db.Column(db.Integer)
+    hand_signal_description = db.Column(db.Text)
+    notes = db.Column(db.Text)
+    active = db.Column(db.Boolean)
+    created_on = db.Column(db.DateTime)
+    guid: str = db.Column(db.String(36))
+
+    def __init__(self):
+        super().__init__()
+
+    @classmethod
+    def from_Dog_Command_Link(cls, dog_command_link):
+        _m = 'Dog_Command_Link_Temp.from_Dog_Command_Link'
+        temp = cls()
+        temp.id_dog_command_link = dog_command_link.id_dog_command_link
+        temp.id_dog = dog_command_link.id_dog
+        temp.id_command = dog_command_link.id_command
+        temp.id_understanding_level = dog_command_link.id_understanding_level
+        temp.id_obedience_level = dog_command_link.id_obedience_level
+        temp.hand_signal_description = dog_command_link.hand_signal_description
+        temp.notes = dog_command_link.notes
+        temp.active = dog_command_link.active
+        temp.created_on = dog_command_link.created_on
+        return temp

business_objects/dog/obedience_level.py

@@ -0,0 +1,104 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: Business Objects
+Feature:    Obedience Level Business Object
+"""
+
+# internal
+from business_objects.base import Base
+from business_objects.db_base import SQLAlchemy_ABC
+import lib.argument_validation as av
+from extensions import db
+from helpers.helper_app import Helper_App
+# external
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+class Obedience_Level(SQLAlchemy_ABC, Base):
+    FLAG_OBEDIENCE_LEVEL: ClassVar[str] = 'obedience-level'
+    NAME_ATTR_OPTION_VALUE: ClassVar[str] = FLAG_OBEDIENCE_LEVEL
+    NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_NAME
+
+    __tablename__ = 'DOG_Obedience_Level'
+    __table_args__ = { 'extend_existing': True }
+
+    id_obedience_level = db.Column(db.Integer, primary_key=True)
+    code = db.Column(db.String(100))
+    name = db.Column(db.String(250))
+    active = db.Column(db.Boolean)
+    
+    def __init__(self):
+        self.id_obedience_level = 0
+        self.is_new = False
+        super().__init__()
+        
+    def from_DB_Dog_Command(query_row):
+        _m = 'Obedience_Level.from_DB_Dog_Command'
+        level = Obedience_Level()
+        level.id_obedience_level = query_row[5]
+        level.code = query_row[6]
+        level.name = query_row[7]
+        level.active = True
+        return level
+    
+    @classmethod
+    def from_json(cls, json):
+        _m = 'Obedience_Level.from_json'
+        obedience_level = cls()
+        if json is None: return Obedience_Level
+        Helper_App.console_log(f'{_m}\njson: {json}')
+        obedience_level.id_obedience_level = -1
+        obedience_level.code = json[cls.FLAG_CODE]
+        obedience_level.name = json[cls.FLAG_NAME]
+        obedience_level.active = json[cls.FLAG_ACTIVE]
+        Helper_App.console_log(f'Obedience_Level: {obedience_level}')
+        return obedience_level
+    
+    
+    def to_json(self):
+        as_json = {
+              self.FLAG_OBEDIENCE_LEVEL: self.id_obedience_level
+            , self.FLAG_CODE: self.code
+            , self.FLAG_NAME: self.name
+            , self.FLAG_ACTIVE: self.active
+        }
+        Helper_App.console_log(f'as_json: {as_json}')
+        return as_json
+        
+    def __repr__(self):
+        return f'''
+{self.__class__.__name__}(
+    {self.FLAG_OBEDIENCE_LEVEL}: {self.id_obedience_level}
+    {self.FLAG_CODE}: {self.code}
+    {self.FLAG_NAME}: {self.name}
+    {self.FLAG_ACTIVE}: {self.active}
+)
+            '''
+
+
+class Obedience_Level_Temp(db.Model, Base):
+    __tablename__ = 'DOG_Obedience_Level_Temp'
+    __table_args__ = { 'extend_existing': True }
+    id_temp = db.Column(db.Integer, primary_key=True)
+    id_obedience_level = db.Column(db.Integer)
+    code = db.Column(db.String(100))
+    name = db.Column(db.String(250))
+    active = db.Column(db.Boolean)
+    guid: str = db.Column(db.String(36))
+
+    def __init__(self):
+        super().__init__()
+
+    @classmethod
+    def from_obedience_level(cls, obedience_level):
+        _m = 'Obedience_Level_Temp.from_Obedience_Level'
+        temp = cls()
+        temp.id_obedience_level = obedience_level.id_obedience_level
+        temp.code = obedience_level.code
+        temp.name = obedience_level.name
+        temp.active = obedience_level.active
+        return temp

business_objects/dog/understanding_level.py

@@ -0,0 +1,104 @@
+"""
+Project:    PARTS Website
+Author:     Edward Middleton-Smith
+            Precision And Research Technology Systems Limited
+
+Technology: Business Objects
+Feature:    Understanding Level Business Object
+"""
+
+# internal
+from business_objects.base import Base
+from business_objects.db_base import SQLAlchemy_ABC
+import lib.argument_validation as av
+from extensions import db
+from helpers.helper_app import Helper_App
+# external
+from dataclasses import dataclass
+from typing import ClassVar
+
+
+class Understanding_Level(SQLAlchemy_ABC, Base):
+    FLAG_UNDERSTANDING_LEVEL: ClassVar[str] = 'understanding-level'
+    NAME_ATTR_OPTION_VALUE: ClassVar[str] = FLAG_UNDERSTANDING_LEVEL
+    NAME_ATTR_OPTION_TEXT: ClassVar[str] = Base.FLAG_NAME
+
+    __tablename__ = 'DOG_Understanding_Level'
+    __table_args__ = { 'extend_existing': True }
+
+    id_understanding_level = db.Column(db.Integer, primary_key=True)
+    code = db.Column(db.String(100))
+    name = db.Column(db.String(250))
+    active = db.Column(db.Boolean)
+    
+    def __init__(self):
+        self.id_understanding_level = 0
+        self.is_new = False
+        super().__init__()
+        
+    def from_DB_Dog_Understanding_Level(query_row):
+        _m = 'Understanding_Level.from_DB_Dog_Understanding_Level'
+        level = Understanding_Level()
+        level.id_understanding_level = query_row[5]
+        level.code = query_row[6]
+        level.name = query_row[7]
+        level.active = True
+        return level
+    
+    @classmethod
+    def from_json(cls, json):
+        _m = 'Understanding_Level.from_json'
+        understanding_level = cls()
+        if json is None: return Understanding_Level
+        Helper_App.console_log(f'{_m}\njson: {json}')
+        understanding_level.id_understanding_level = -1
+        understanding_level.code = json[cls.FLAG_CODE]
+        understanding_level.name = json[cls.FLAG_NAME]
+        understanding_level.active = json[cls.FLAG_ACTIVE]
+        Helper_App.console_log(f'Understanding_Level: {understanding_level}')
+        return understanding_level
+    
+    
+    def to_json(self):
+        as_json = {
+              self.FLAG_UNDERSTANDING_LEVEL: self.id_understanding_level
+            , self.FLAG_CODE: self.code
+            , self.FLAG_NAME: self.name
+            , self.FLAG_ACTIVE: self.active
+        }
+        Helper_App.console_log(f'as_json: {as_json}')
+        return as_json
+        
+    def __repr__(self):
+        return f'''
+{self.__class__.__name__}(
+    {self.FLAG_UNDERSTANDING_LEVEL}: {self.id_understanding_level}
+    {self.FLAG_CODE}: {self.code}
+    {self.FLAG_NAME}: {self.name}
+    {self.FLAG_ACTIVE}: {self.active}
+)
+            '''
+
+
+class Understanding_Level_Temp(db.Model, Base):
+    __tablename__ = 'DOG_Understanding_Level_Temp'
+    __table_args__ = { 'extend_existing': True }
+    id_temp = db.Column(db.Integer, primary_key=True)
+    id_understanding_level = db.Column(db.Integer)
+    code = db.Column(db.String(100))
+    name = db.Column(db.String(250))
+    active = db.Column(db.Boolean)
+    guid: str = db.Column(db.String(36))
+
+    def __init__(self):
+        super().__init__()
+
+    @classmethod
+    def from_understanding_level(cls, understanding_level):
+        _m = 'Understanding_Level_Temp.from_Understanding_Level'
+        temp = cls()
+        temp.id_understanding_level = understanding_level.id_understanding_level
+        temp.code = understanding_level.code
+        temp.name = understanding_level.name
+        temp.active = understanding_level.active
+        return temp

static/MySQL/7203_p_dog_get_many_dog_command.sql

@@ -146,8 +146,11 @@ BEGIN
     
     CREATE TEMPORARY TABLE tmp_Command (
 		  id_command INT NOT NULL
+        , id_command_category INT NOT NULL
+        , name_command_category VARCHAR(250)
     --  , code VARCHAR(100)
         , name VARCHAR(250)
+        , has_button BIT
     );
     
     CREATE TEMPORARY TABLE tmp_Understanding_Level (
@@ -318,14 +321,25 @@ BEGIN
 		ELSE
 			INSERT INTO tmp_Command (
 				  id_command
+                , id_command_category
+                , name_command_category
                 , name
+                , has_button
 			)
 			SELECT 
 				  COMMAND.id_command
+                , COMMAND.id_command_category
+                , COMMAND_CATEGORY.name AS name_command_category
             --  , COMMAND.code
                 , COMMAND.name
+                , CASE WHEN ISNULL(COMMANDS_WITH_BUTTONS.id_command) THEN 0 ELSE 1 END AS has_button
 			FROM tmp_Split t_SPLIT
 			RIGHT JOIN parts.DOG_Command COMMAND ON t_SPLIT.as_int = COMMAND.id_command
+            LEFT JOIN parts.DOG_Command_Category COMMAND_CATEGORY ON COMMAND.id_command_category = COMMAND_CATEGORY.id_command_category
+            LEFT JOIN (
+                SELECT DISTINCT COMMAND_BUTTON_LINK.id_command 
+                FROM parts.DOG_Command_Button_Link COMMAND_BUTTON_LINK
+            ) COMMANDS_WITH_BUTTONS ON COMMAND.id_command = COMMANDS_WITH_BUTTONS.id_command
 			WHERE 
                 (
 					    a_get_all_command = 1
@@ -584,10 +598,13 @@ BEGIN
     SELECT 
           DOG_COMMAND_LINK.id_link AS id_dog_command_link
         , t_DOG.id_dog
-        , t_DOG.name
+        , t_DOG.name AS name_dog
+        , t_COMMAND.id_command_category
+        , t_COMMAND.name_command_category
         , t_COMMAND.id_command
     --  , t_COMMAND.code
-        , t_COMMAND.name
+        , t_COMMAND.name AS name_command
+        , t_COMMAND.has_button AS command_has_button
         , t_UNDERSTANDING_LEVEL.id_understanding_level
         , t_UNDERSTANDING_LEVEL.code AS code_understanding_level
         , t_UNDERSTANDING_LEVEL.name AS name_understanding_level