changes to save inventory in ddbb

}

message Component {                         //Defined previously to this section - Tested OK

  Uuid uuid = 1;

  Uuid component_uuid   = 1;

  string name           = 2;

  string type           = 3;

  repeated string child = 4; // list[sub-component.name]

  map<string, string> attributes = 5; // dict[attr.name => json.dumps(attr.value)]

}

message ComponentId {                         //NEW

  DeviceId device_id = 1;

  Uuid endpoint_uuid = 2;

}

message ComponentIdList {                   //NEW

  repeated ComponentId component_ids = 1;

}

// -----------------------------------------------------

message DeviceConfig {

from sqlalchemy.engine import Engine

from sqlalchemy.orm import Session, selectinload, sessionmaker

from sqlalchemy_cockroachdb import run_transaction

from common.proto.context_pb2 import ComponentIdList

from .models.ComponentModel import ComponentModel

from .uuids.Component import component_get_uuid

from .ConfigRule import compose_config_rules_data

LOGGER = logging.getLogger(__name__)

    dict_components : List[Dict] = list()

    for position,component in enumerate(components):

        str_kind = component.WhichOneof('config_rule')

        LOGGER.info("DATA")

        message = (grpc_message_to_json_string(getattr(component, str_kind, {})))

        data = json.loads(message)

        resource_key = data["resource_key"]

        resource_value = data["resource_value"]

        if '/inventory' in resource_key:

            LOGGER.info('Parametros: KEY',resource_key,'Value',resource_value)

            resource_value_data = json.loads(resource_value)

            name = resource_value_data.get('name')

            type = resource_value_data.get('class')

            uuid = resource_value_data.get('uuid')

            if name is not None:

                del resource_value_data['name']

            if type is not None:

                del resource_value_data['class']

            if uuid is not None:

                del resource_value_data['uuid']

            attributes = resource_value_data  #Store the remaining fields in 'attributes'

            dict_component = {

                'data'      : resource_value,

                'name'      : name,

                'type'      : type,

                'attributes' : attributes,

                'created_at': now,

                'updated_at': now,

            }

            parent_kind,parent_uuid = '',None

            if device_uuid is not None:

            dict_component['device_uuid'] = device_uuid

                parent_kind,parent_uuid = 'device',device_uuid

            elif service_uuid is not None:

                dict_component['service_uuid'] = service_uuid

                parent_kind,parent_uuid = 'service',service_uuid

            elif slice_uuid is not None:

                dict_component['slice_uuid'] = slice_uuid

                parent_kind,parent_uuid = 'slice',slice_uuid

            else:

                MSG = 'Parent for Component({:s}) cannot be identified '+\

                    '(device_uuid={:s}, service_uuid={:s}, slice_uuid={:s})'

                str_component = grpc_message_to_json_string(component)

                raise Exception(MSG.format(str_component, str(device_uuid), str(service_uuid), str(slice_uuid)))

            component_name = '{:s}:{:s}:{:s}'.format('device', 'custom', component.custom.resource_key)

            componenet_name = '{:s}:{:s}:{:s}'.format(parent_kind, 'custom', component.custom.resource_key)

            component_uuid = get_uuid_from_string(componenet_name, prefix_for_name=parent_uuid)

            component_uuid = get_uuid_from_string(component_name, prefix_for_name=device_uuid)

            dict_component['component_uuid'] = component_uuid

            dict_components.append(dict_component)

        else:

            continue

    LOGGER.info('Parametros:',dict_components)

    return dict_components

'''

def upsert_components(

    session : Session, components : List[Dict], is_delete : bool = False,

        device_uuid : Optional[str] = None, service_uuid : Optional[str] = None, slice_uuid : Optional[str] = None,

) -> bool:

    if device_uuid is not None and service_uuid is None and slice_uuid is None:

        klass = ComponentModel

    else:

        MSG = 'DataModel cannot be identified (device_uuid={:s})'

        raise Exception(MSG.format(str(device_uuid)))

    uuids_to_upsert : Dict[str, int] = dict()

    rules_to_upsert : List[Dict] = list()

    for component in components:

        component_uuid = component['component_uuid']

        position = uuids_to_upsert.get(component_uuid)

        if position is None:

            # if not added, add it

            rules_to_upsert.append(component)

            uuids_to_upsert[component_uuid] = len(rules_to_upsert) - 1

        else:

            # if already added, update occurrence

            rules_to_upsert[position] = component

    upsert_affected = False

    if len(rules_to_upsert) > 0:

        stmt = insert(klass).values(rules_to_upsert)

        stmt = stmt.on_conflict_do_update(

            index_elements=[klass.component_uuid],

            set_=dict(

                data       = stmt.excluded.data,

                updated_at = stmt.excluded.updated_at,

            )

        )

        stmt = stmt.returning(klass.created_at, klass.updated_at)

        #str_stmt = stmt.compile(dialect=postgresql.dialect(), compile_kwargs={"literal_binds": True})

        #LOGGER.warning('upsert stmt={:s}'.format(str(str_stmt)))

        components_updates = session.execute(stmt).fetchall()

        upsert_affected = any([(updated_at > created_at) for created_at,updated_at in components_updates])

    return upsert_affected

    def component_list_names(db_engine: Engine, request: ComponentIdList) -> List[Dict]:

    component_uuids = {

        component_get_uuid(component_id, allow_random=False)[-1]

        for component_id in request.component_ids

    }

    def callback(session: Session) -> List[Dict]:

        obj_list: List[ComponentModel] = session.query(ComponentModel)\

            .options(selectinload(ComponentModel.device))\

            .filter(ComponentModel.component_uuid.in_(component_uuids)).all()

        return [obj.dump_name() for obj in obj_list]

    return run_transaction(sessionmaker(bind=db_engine), callback)

def compose_components_data(data: Dict[str, any]) -> List[Dict]:

    filtered_data = []

    for item in data:

        for key, value in item:

            if any("inventory" in key):

                filtered_data.append(item)

    LOGGER.info("Filtered Data:")

    LOGGER.info(filtered_data)

    # Return the result

    return filtered_data

'''

 No newline at end of file

    return dict_components

    dict_config_rules : List[Dict] = list()

    for position,config_rule in enumerate(config_rules):

        LOGGER.info("REQUEST")

        LOGGER.info(position,config_rule)

        #LOGGER.info("REQUEST")

        #LOGGER.info(position,config_rule)

        str_kind = config_rule.WhichOneof('config_rule')

        kind = ConfigRuleKindEnum._member_map_.get(str_kind.upper()) # pylint: disable=no-member

        dict_config_rule = {

# limitations under the License.

import datetime, logging

import json

from sqlalchemy.dialects.postgresql import insert

from sqlalchemy.engine import Engine

from sqlalchemy.orm import Session, selectinload, sessionmaker

        updated_components = False

        LOGGER.info("HERE ERRPR DEBUG")

        LOGGER.info(components_data)

        if len(components_data) > 0:

            stmt = insert(ComponentModel).values(components_data)

            stmt = stmt.on_conflict_do_update(

                index_elements=[ComponentModel.component_uuid],

                set_=dict(

                    data             = stmt.excluded.data,

                    name             = str(stmt.excluded.name),

                    type             = str(stmt.excluded.type),

                    attributes       = str(stmt.excluded.attributes),

                    updated_at       = stmt.excluded.updated_at,

                )

            )

    component_uuid  = Column(UUID(as_uuid=False), primary_key=True)     #Unique identifier that serves as a primary key for this table

    device_uuid     = Column(ForeignKey('device.device_uuid',ondelete='CASCADE' ), nullable=False, index=True)  #Foreign Key relationship with the field device_uuid from the Device table (CASCADE' behavior for deletion, meaning when a device is deleted, its components will also be dele)

    # component_name  = Column(String, nullable=False)                    #String field that stores the name of the component

    data            = Column(String, nullable=False)                    #String field that stores data about the component 

    name            = Column(String, nullable=False)                    #String field that stores the name of the component

    type            = Column(String, nullable=False)                    #String field that stores the name of the component

    attributes      = Column(String, nullable=False)                    #String field that stores data about the component 

    created_at      = Column(DateTime, nullable=False)                  #Stores the creaton timestamp for the component

    updated_at      = Column(DateTime, nullable=False)                  #Stores the last upadted timestamp for the component

        }

    def dump(self) -> Dict:

        return {

            'component_id'  : self.dump_id(),

            'data'          : self.data,  

        }

        data['component_uuid'] = self.component_uuid

        data['name'] = self.name

        data['type'] = self.type

        data['attributes'] = self.attributes

        return data

    def dump_name(self) -> Dict:

        return {