Components

component_name/
├── __init__.py
├── base/
│   ├── component_name_action_mapper.py
│   └── component_name_domain.py
├── configuration/
│   ├── component_name_constants.py
│   ├── business_rules/
│   └── model_definitions/
├── controllers/
│   ├── component_name_controller.py
│   ├── component_name_general_controller.py
│   └── component_name_persistence.py
├── domain/
│   ├── _event.py
│   ├── _component_property.py
│   └── model_constants/
└── component_name_facade.py

from digitalpy.core.component_management.impl.component_registration_handler import ComponentRegistrationHandler

# Create registration handler
registration_handler = ComponentRegistrationHandler()

# Register component
registration_handler.register_component(
    component_name="CompanionParrot",
    component_path="FreeTAKServer.components.extended.companion_parrot",
    component_class="CompanionParrotFacade"
)

# 1. Receive CoT message
raw_cot = receive_from_client()

# 2. Route to component
request = ObjectFactory.get_new_instance("request")
request.set_value("cot_message", raw_cot)
request.set_action("ProcessCoT")

# 3. Component processes
action_mapper = ObjectFactory.get_instance("actionMapper")
response = ObjectFactory.get_new_instance("response")
action_mapper.process_action(request, response)

# 4. Get result
processed_cot = response.get_value("processed_cot")

# 5. Distribute to clients
send_to_all_clients(processed_cot)

# Graceful component shutdown
def shutdown_component(component_name):
    # Get component instance
    component = ObjectFactory.get_instance(component_name)
    
    # Call cleanup method
    if hasattr(component, 'cleanup'):
        component.cleanup()
    
    # Unregister from action mapper
    registration_handler.unregister_component(component_name)

# FreeTAKServer/components/core/abstract_component/cot_node.py:8-33
class CoTNode(Node, FTSProtocolObject):
    def __init__(self, node_type, configuration, model, oid=None):
        # Dictionary containing CoT attributes
        self.cot_attributes = {}
        # XML representation
        self.xml: etree.ElementTree = etree.Element(self.__class__.__name__)
        self.text = ""
        super().__init__(node_type, configuration, model, oid)
    
    def add_child(self, child):
        """Add child node to CoT structure"""
        if self.validate_child_addition(child):
            self._children[child.get_oid().str_val] = child
            self.cot_attributes[child.__class__.__name__] = child
            child.set_parent(self)
        else:
            raise TypeError("child must be an instance of Node")

from FreeTAKServer.components.core.abstract_component.cot_property import CoTProperty

class MyCoTNode(CoTNode):
    @CoTProperty
    def callsign(self):
        return self.cot_attributes.get("callsign", None)
    
    @callsign.setter
    def callsign(self, value):
        self.cot_attributes["callsign"] = value

# FreeTAKServer/components/core/abstract_component/domain.py:6-66
class Domain(Controller):
    def __init__(self, config_path_template, domain, **kwargs):
        super().__init__(**kwargs)
        self.config_loader = LoadConfiguration(config_path_template)
        self.domain = domain
    
    def create_node(self, message_type, object_class_name, **kwargs):
        """Create a new domain node"""
        configuration = self.config_loader.find_configuration(message_type)
        object_class = getattr(self.domain, object_class_name)
        object_class_instance = object_class(configuration, self.domain)
        self.response.set_value("model_object", object_class_instance)
    
    def add_child(self, node: Node, child, **kwargs):
        """Add child to node"""
        return node.add_child(child)
    
    def get_children_ex(self, id, node: Node, children_type, 
                        values, properties, use_regex=True, **kwargs):
        """Get children matching criteria"""
        self.response.set_value(
            "children",
            node.get_children_ex(
                id, node, children_type, values, properties, use_regex
            )
        )

mkdir -p components/extended/my_component/{base,configuration,controllers,domain}
touch components/extended/my_component/__init__.py
touch components/extended/my_component/my_component_facade.py

# base/my_component_action_mapper.py
from digitalpy.core.main.controller import Controller

class MyComponentActionMapper(Controller):
    def __init__(self):
        super().__init__()
        self.action_mapping = {
            "ProcessMyCoT": self.process_my_cot,
        }
    
    def process_my_cot(self, cot_event):
        # Process CoT
        pass

# domain/_event.py
from FreeTAKServer.components.core.abstract_component.cot_node import CoTNode
from FreeTAKServer.components.core.abstract_component.cot_property import CoTProperty

class Event(CoTNode):
    def __init__(self, configuration, model):
        super().__init__(self.__class__.__name__, configuration, model)
    
    @CoTProperty
    def my_property(self):
        return self.cot_attributes.get("my_property", None)
    
    @my_property.setter
    def my_property(self, value):
        self.cot_attributes["my_property"] = value

# controllers/my_component_controller.py
from digitalpy.core.main.controller import Controller

class MyComponentController(Controller):
    def execute(self, method=None):
        return getattr(self, method)(**self.request.get_values())
    
    def process_cot(self, cot_event, **kwargs):
        # Business logic
        processed = self.do_processing(cot_event)
        self.response.set_value("processed_cot", processed)
        return processed

# my_component_facade.py
from digitalpy.core.component_management.component_facade import ComponentFacade

class MyComponentFacade(ComponentFacade):
    def process_cot(self, cot_event):
        self.request.set_value("cot_event", cot_event)
        self.request.set_action("ProcessMyCoT")
        
        self.sync_action_mapper.process_action(
            self.request,
            self.response
        )
        
        return self.response.get_value("processed_cot")

# In FTS initialization
registration_handler.register_component(
    component_name="MyComponent",
    component_path="FreeTAKServer.components.extended.my_component",
    component_class="MyComponentFacade"
)