Att0ParametersManagment.hxx

Go to the documentation of this file.

// Copyright 2022 Siemens Digital Industries Software
// ==================================================
// Copyright 2023.
// Siemens Product Lifecycle Management Software Inc.
// All Rights Reserved.
// ==================================================
// Copyright 2022 Siemens Digital Industries Software
#ifndef ATT0PARAMETERMANAGEMENT_HXX
#define ATT0PARAMETERMANAGEMENT_HXX

#include <vector>

#include <string>

#include <map>

#include <unidefs.h>

#include <metaframework/BusinessObjectRef.hxx>
#include <Att0attrtargetmgmt/libatt0attrtargetmgmt_exports.h>

#ifdef __cplusplus
extern "C"
{
#endif

    // Property Name Value map
    typedef std::map<std::string, std::vector<std::string>> NameValuesMap;

    typedef enum ATT0_parameter_copy_measurement_e
    {
        LATEST_VALUES_EACH_METHOD = 1,                  
        LATEST_VALUE,                                   
        EMPTY_VALUE,                                    
        NONE 
    } ATT0_parameter_copy_measurement_t;

    typedef enum ATT0_generate_hash_value_options_e
    {
        WITH_LATEST_MEASUREVALUE = 1,                   
        WITH_TABLE_DEFINITION = 2,                      
        WITH_TABLE_CONTENT = 4,                         
        WITH_SEPARATE_GMM = 8                           
    } ATT0_generate_hash_value_options_t;

    typedef struct ATT0_file_properties_s
    {
        std::string clientId;                           
        tag_t dataset;                                  
        std::string fileName;                           
        std::string description;                        
        std::string namedReference;                     
        std::string type;                               
    } ATT0_file_properties_t;

    typedef struct ATT0_measurevalue_input_s
    {
        bool toCreate;                                                  
        tag_t measureValue;                                             
        std::string method;                                             
        std::map<std::string, std::vector<std::string>> propValues;     
    } ATT0_measurevalue_input_t;

    typedef struct ATT0_measurevalue_data_input_s
    {
        bool toCreate;                                                  
        tag_t measureValue;                                             
        std::string method;                                             
        std::map<std::string, std::vector<std::string>> propValues;     
        std::vector<ATT0_file_properties_t> valueFileInputs;            
    } ATT0_measurevalue_data_input_t;

    typedef struct ATT0_parameter_file_data_s
    {
        tag_t dataset;                                                  
        std::string fileName;                                           
        std::string fileTicket;                                         
    } ATT0_parameter_file_data_t;

    typedef enum ATT0_parameter_type_e
    {
        SOURCE_PARAMETER = 1,                                           
        OVERRIDDEN_PARAMETER                                            
    } ATT0_parameter_type_t;

    typedef enum ATT0_parameter_related_object_type_e
    {
        RELATED_SOURCE_PARAMETER = 0,                                   
        RELATED_SOURCE_PARAMETER_RELATION,                              
        RELATED_OVERRIDE_CONTEXT,                                       
        RELATED_VARIANT_CONFIG_OBJECT                                   
    } ATT0_parameter_related_object_type_t;

    typedef enum ATT0_objective_operation_e
    {
        OBJ_CREATE = 1,                                                 
        OBJ_UPDATE,                                                     
        OBJ_DELETE                                                      
    } ATT0_objective_operation_t;

    typedef struct ATT0_objective_data_s
    {
        ATT0_objective_operation_t objectiveOperation;                  
        tag_t objectiveTag;                                             
        std::string objectiveType;                                      
        tag_t affectedObject;                                           
        NameValuesMap objectiveProps;                                   
    } ATT0_objective_data_t;

    typedef struct ATT0_objective_output_data_s
    {
        tag_t objectiveTag;                                             
        int errorCode = 0;                                              
        std::string errorMessage = "";                                  
    } ATT0_objective_output_data_t;

    typedef struct ATT0_parameter_data_s
    {
        tag_t parameter;                                                
        int type;                                                       
        std::string paramDirection;                                     
        std::map<std::string, tag_t> relatedObjects;                    
        bool isVisible;                                                 
        std::vector<ATT0_parameter_file_data_t> goalFiles;              
    } ATT0_parameter_data_t;

    typedef struct ATT0_param_properties_s
    {
        std::string clientId;                                           
        Teamcenter::CreateInput* create_input;                          
        std::string paramDirection;                                     
        std::vector<ATT0_file_properties_t> goalFileInputs;             
    } ATT0_param_properties_t;

    typedef struct ATT0_create_params_input_s
    {
        std::string clientId;                                           
        std::vector<ATT0_param_properties_t> parameters;                
        tag_t parent;                                                   
    } ATT0_create_params_input_t;

    typedef struct ATT0_create_params_output_s
    {
        std::string clientId;                                           
        tag_t parent;                                                   
        std::vector<ATT0_parameter_data_t> createdParamData;            
    } ATT0_create_params_output_t;

    typedef struct ATT0_param_properties_data_s
    {
        std::string clientId;                                           
        bool isNewParam;                                                
        tag_t parameter;                                                
        Teamcenter::CreateInput* paramInput;                            
        std::string paramDirection;                                     
        NameValuesMap paramProps;                                       
        std::vector<ATT0_file_properties_t> goalFileInputs;             
        std::vector<ATT0_measurevalue_data_input_t> valueInputs;        
    } ATT0_param_properties_data_t;

    typedef struct ATT0_measure_value_data_s
    {
        tag_t measureValue;                                             
        std::string method;                                             
        std::vector<ATT0_parameter_file_data_t> valueFiles;             
    } ATT0_measure_value_data_t;

    typedef struct ATT0_update_param_properties_s
    {
        std::string clientId;                                           
        tag_t parameter;                                                
        std::string paramDirection;                                     
        NameValuesMap paramProps;                                       
        std::vector<ATT0_file_properties_t> goalFileInputs;             
        std::vector<ATT0_measurevalue_data_input_t> valueInputs;        
    } ATT0_update_param_properties_t;

    typedef struct ATT0_update_params_input_s
    {
        std::string clientId;                                           
        std::vector<ATT0_update_param_properties_t> parameters;         
        tag_t parent;                                                   
    } ATT0_update_params_input_t;

    typedef struct ATT0_table_cell_s
    {
        int index;                                                      
        std::map<std::string, std::string> cell_values;                 
    } ATT0_table_cell_t;

    typedef struct ATT0_table_row_s
    {
        int index;                                                      
        std::vector<ATT0_table_cell_t> cells;                           
    } ATT0_table_row_t;

    typedef struct ATT0_table_header_data_s
    {
        std::vector<int> indexes;                                       
        std::string title;                                              
        std::string unit_symbol;                                        
        tag_t unit;                                                     
        std::string data_type;                                          
    } ATT0_table_header_data_t;

    typedef struct ATT0_complex_data_s
    {
        std::vector<ATT0_table_header_data_t> column_headers;           
        std::vector<ATT0_table_header_data_t> row_headers;              
        std::vector<ATT0_table_row_t> rows;                             
        std::string table_row_title;                                    
        std::string table_column_title;                                 
        std::vector<std::string> free_text;                             
    } ATT0_complex_data_t;

    typedef struct ATT0_goal_range_table_data_s
    {
        std::string operation;                                          
        std::string file_ticket;                                        
        std::string json_string;                                        
        ATT0_complex_data_t table_data;                                 
    } ATT0_goal_range_table_data_t;

    typedef struct ATT0_value_table_data_s
    {
        std::string operation;                                          
        std::string file_ticket;                                        
        std::string json_string;                                        
        std::vector<ATT0_table_row_t> rows;                             
    } ATT0_value_table_data_t;

    typedef struct ATT0_measurevalue_data_input2_s
    {
        bool to_create;                                                 
        tag_t measure_value;                                            
        std::string method;                                             
        std::map<std::string, std::vector<std::string>> prop_values;    
        std::vector<ATT0_file_properties_t> value_file_inputs;          
        ATT0_value_table_data_t value_table_inputs;                     
    } ATT0_measurevalue_data_input2_t;

    typedef struct ATT0_update_param_properties2_s
    {
        std::string client_id;                                          
        tag_t parameter;                                                
        std::string param_direction;                                    
        NameValuesMap param_props;                                      
        std::vector<ATT0_file_properties_t> goal_file_inputs;           
        std::vector<ATT0_measurevalue_data_input2_t> value_inputs;      
        ATT0_goal_range_table_data_t goal_table_inputs;                 
    } ATT0_update_param_properties2_t;

    typedef struct ATT0_update_params_input2_s
    {
        std::string client_id;                                          
        std::vector<ATT0_update_param_properties2_t> parameters;        
        tag_t parent;                                                   
    } ATT0_update_params_input2_t;

    typedef struct ATT0_update_param_output_data_s
    {
        std::string clientId;                                           
        tag_t inputParameter;                                           
        ATT0_parameter_data_t retParameter;                             
        std::vector<ATT0_measure_value_data_t> retMeasureValues;        
    } ATT0_update_param_output_data_t;

    typedef struct ATT0_update_param_output_s
    {
        std::string clientId;                                           
        tag_t parent;                                                   
        std::vector<ATT0_update_param_output_data_t> updateParamData;   
    } ATT0_update_param_output_t;

    typedef struct ATT0_param_validator_data_s
    {
        std::string Id;                                                 
        std::vector<ATT0_param_properties_data_t> paramDataInfoList;    
        tag_t parent;                                                   
    } ATT0_param_validator_data_t;

    typedef struct ATT0_param_validation_result_s
    {
        std::string clientId;                                           
        int errorCode;                                                  
        std::string errorMessage;                                       
    } ATT0_param_validation_result_t;

    typedef struct ATT0_param_config_rules_s
    {
        tag_t variant_rule;                                             
        tag_t revision_rule;                                            
        date_t effectivity_date;                                        
        bool effective_now;                                             
    } ATT0_param_config_rules_t;

    typedef struct ATT0_Measure_Value_Info_s
    {
        std::string method;                                             
        tag_t measureValue;                                             
    } ATT0_Measure_Value_Info_t;

    typedef struct ATT0_sort_criteria_s
    {
        std::string propertyName;                                       
        std::string sortDirection;                                      
    } ATT0_sort_criteria_t;

    typedef struct ATT0_replace_param_input_s
    {
        tag_t selectedParam;                                            
        tag_t targetParam;                                              
        NameValuesMap revisePropInput;                                  
        bool reviseAndReplace;                                          
    } ATT0_replace_param_input_t;

    typedef struct ATT0_replace_param_output_s
    {
        tag_t parentObj;                                                
        std::vector<tag_t> oldParams;                                   
        std::vector<tag_t> newParams;                                   
        std::vector<tag_t> ignoredParams;                               
    } ATT0_replace_param_output_t;

    typedef struct ATT0_get_structure_param_complexfile_s
    {
        std::string currentValueTableJson;                              
        std::string goalTableJson;                                      
    } ATT0_get_structure_param_complexfile_t;

    typedef struct ATT0_get_structure_params_pref_s
    {
        std::string application;                                        
        std::string parameterDirection;                                 
        std::map<std::string, std::string> options;                     
        bool isComplexDataEnabled;                                      
    } ATT0_get_structure_params_pref_t;

    typedef struct ATT0_get_structure_params_input_s
    {
        std::string clientId;                                           
        std::vector<tag_t> parentBVRs;                                  
        std::vector<tag_t> revisions;                                   
        std::vector<std::string> occThreadChains;                       
        tag_t configuratorContext;                                      
        std::vector<tag_t> variantRules;                                
        tag_t revisionRule;                                             
    } ATT0_get_structure_params_input_t;

    typedef struct ATT0_overridden_structure_params_s
    {
        tag_t parameter;                                                
        tag_t contextInfo;                                              
        tag_t sourceParameter;                                          
        tag_t revRule;                                                  
        ATT0_get_structure_param_complexfile_t complexDataFiles;        
    } ATT0_overridden_structure_params_t;

    typedef struct ATT0_source_structure_params_s
    {
        tag_t parameter;                                                
        std::string paramDirection;                                     
        tag_t revRule;                                                  
        std::vector<tag_t> variantRules;                                
        ATT0_get_structure_param_complexfile_t complexDataFiles;        
    } ATT0_source_structure_params_t;

    typedef struct ATT0_get_structure_params_output_s
    {
        std::string clientId;                                                                       
        std::map<std::string, std::vector<ATT0_overridden_structure_params_t>> overriddenParams;    
        std::map<std::string, std::vector<ATT0_source_structure_params_t>> sourceParameters;        
    } ATT0_get_structure_params_output_t;

    typedef struct ATT0_get_structure_params_response_s
    {
        std::vector<ATT0_get_structure_params_output_t> outputs;        
    } ATT0_get_structure_params_response_t;

    typedef struct ATT0_attach_param_output_s
    {
        tag_t inputParameter;                                           
        tag_t attachedParameter;                                        
    } ATT0_attach_param_output_t;

    extern ATT0ATTRTARGETMGMT_API int ATT0_create_parameters(
        const std::vector<ATT0_create_params_input_t>& createParameterInputs,   
        std::vector<ATT0_create_params_output_t>& createParamOutput,            
        std::vector<ATT0_param_validation_result_t>& validationResults          
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_create_or_update_measurevalue(
        const tag_t parent_object,                                      
        const tag_t parameter,                                          
        ATT0_measurevalue_input_t& value_input,                         
        tag_t& ret_parameter,                                           
        tag_t& ret_measuredvalue                                        
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_update_parameters2(
        const std::vector<ATT0_update_params_input2_t>& update_parameters_input,    
        std::vector<ATT0_update_param_output_t>& update_param_output,               
        std::vector<ATT0_param_validation_result_t>& validation_results             
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_set_parameters_direction(
        const tag_t parent,                                             
        const std::vector<tag_t>& parameters,                           
        const std::string& direction,                                   
        std::vector<tag_t>& updatedParams,                              
        std::vector<tag_t>& ignoredParams,                              
        std::vector<ATT0_param_validation_result_t>& validationResults  
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_attach_parameters(
        tag_t parentObj,                                                
        const std::vector<tag_t>& parameters,                           
        const bool isCopy,                                              
        const std::string& paramDirection,                              
        std::vector<ATT0_attach_param_output_t>& attachedParams,        
        std::vector<tag_t>& ignoredParams,                              
        std::vector<ATT0_param_validation_result_t>& validationResults  
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_get_latestMeasureValue(
        const std::vector<tag_t>& parameters,                                       
        std::vector<std::string>& methods,                                          
        std::map<tag_t, std::vector<ATT0_Measure_Value_Info_t>>& paramValues_Map    
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_saveas_parameters(
        const std::vector<tag_t>& parameters,                           
        const bool isOverride,                                          
        const ATT0_parameter_copy_measurement_t copyMeasurement,        
        std::map<tag_t, tag_t>& copiedParameters                        
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_replace_parameters(
        const std::vector<tag_t>& parent_objects,                           
        const std::vector<ATT0_replace_param_input_t>& replace_inputs,      
        std::vector<ATT0_replace_param_output_t>& replace_outputs           
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_get_parameters_for_structureData(
        const std::vector<ATT0_get_structure_params_input_t>& getStructureParam_inputs,     
        const ATT0_get_structure_params_pref_t& pref,                                       
        ATT0_get_structure_params_response_t& getStructureParams_response                   
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_get_objectives(
        const std::vector<tag_t>& affectedObjects,                                          
        std::map<tag_t, tag_t>& affectedToObjectiveMap                                      
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_set_objectives(
        const std::vector<ATT0_objective_data_t>& objectiveData,                        
        std::vector<ATT0_objective_output_data_t>& objectiveOutputData                  
    );

    extern ATT0ATTRTARGETMGMT_API int ATT0_get_parameters_bulk2(
        const std::vector<tag_t>& parent_Objects,                                       
        const std::string& direciton,                                                   
        const std::string& application,                                                 
        const bool goalFileRequired,                                                    
        std::map<tag_t, std::vector<ATT0_parameter_data_t>>& parameters_map             
    );

#ifdef __cplusplus
}
#endif

#include <Att0attrtargetmgmt/libatt0attrtargetmgmt_undef.h>
#endif