Teamcenter_NX集成开发：UF_UGMGR函数的使用

该内容已在博客园发布。Teamcenter_NX集成开发：UF_UGMGR函数的使用 - huangym1 - 博客园 (cnblogs.com)

最近工作中经常使用Teamcenter、NX集成开发的情况，因此在这里记录UF_UGMGR函数的使用。使用UF_UGMGR相关函数需要有Teamcenter使用经验，理解Teamcenter中文件夹、伪文件夹、零组件、零组件版本、数据集、关系、表单、命名引用等对象。

相关的可以看帮助中 Teamcenter Integration for NX的内容 及 UF_UGMGR Overview 介绍的数据模型及使用方法、注意事项。

主要操作：

1-初始化UGMGR环境成功后就可以连接到Teamcenter。

2-获取指定ID编码零组件标识和Latest Working（没记错的话应该是最新版本）版本ID。

3-UF_UGMGR相关函数使用

// Mandatory UF Includes
#include <uf.h>
#include <uf_object_types.h>
#include <uf_ugmgr.h>
#include <uf_part.h>
#include <uf_disp.h>
#include <uf_modl.h>
#include <uf_obj.h>
#include <uf_assem.h>

// Internal+External Includes
#include <NXOpen/Annotations.hxx>
#include <NXOpen/Assemblies_Component.hxx>
#include <NXOpen/Assemblies_ComponentAssembly.hxx>
#include <NXOpen/Body.hxx>
#include <NXOpen/BodyCollection.hxx>
#include <NXOpen/Face.hxx>
#include <NXOpen/Line.hxx>
#include <NXOpen/NXException.hxx>
#include <NXOpen/NXObject.hxx>
#include <NXOpen/Part.hxx>
#include <NXOpen/PartCollection.hxx>
#include <NXOpen/Session.hxx>

#include <NXOpen/PDM_PdmSession.hxx>
#include <NXOpen/PDM_SoaConnectionHandle.hxx>
#include <teamcenter/soa/client/Connection.hxx>
#include <teamcenter/services/core/DatamanagementService.hxx>
#include <teamcenter/soa/common/Version.hxx>

// Std C++ Includes
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>

using namespace NXOpen;
using namespace Teamcenter::Soa::Client;
using namespace Teamcenter::Services::Core;
using std::string;
using std::exception;
using std::stringstream;
using std::endl;
using std::cout;
using std::cerr;

static int indent_level = 0;

#define CHECK( func_ ) \
    ifail = (func_); \
if (ifail != 0) {\
printf("ERROR: %s returned %d", # func_, ifail); \
return ifail;}

#define PRINT( content_ ) \
{ int ii; \
for (ii = 0; ii < indent_level; ii++) \
{ printf("  "); } \
    printf content_; \
    printf("\n"); }

static int  list_in_part(UF_UGMGR_tag_t part)
{
    int _errCode = 0;
    UF_UGMGR_tag_t*  revisions;
    int              i, j, k;
    int              count;
    int              dep_count;
    int              rev_count;
    char**           names;
    char**           file_types;
    char**           file_names;
    char             part_name[MAX_FSPEC_SIZE + 1];
    char             revision_id[UF_UGMGR_NAME_SIZE + 1];
    char             part_number[UF_UGMGR_NAME_SIZE + 1];
    if (part == UF_UGMGR_null_tag)
        return -1;

    _errCode = UF_UGMGR_ask_part_number(part, part_number);// 获取零组件ItemID
    PRINT(("Part: %s", part_number));
    indent_level++;
    _errCode = UF_UGMGR_list_part_revisions(part, &rev_count, &revisions);// 获取零组件所有版本
    for (j = 0; j < rev_count; j++)
    {
        _errCode = UF_UGMGR_ask_part_revision_id(revisions[j], revision_id);// 获取版本ID
        _errCode = UF_UGMGR_encode_part_filename(part_number, revision_id, "", "", part_name);// encode文件名
        PRINT(("Rev.: %s - Type: %s", revision_id, "master"));
        indent_level++;

        _errCode = UF_UGMGR_ask_dependent_files(part_name, &dep_count, &names);// 获取关联文件
        for (k = 0; k < dep_count; k++)
            PRINT(("Dependent files: %s", names[k]));

        indent_level--;
        if (dep_count > 0)
            UF_free_string_array(dep_count, names);

        _errCode = UF_UGMGR_list_part_rev_files(revisions[j], &count, &file_types, &file_names);// 列出版本下数据集
        for (i = 0; i < count; i++)
        {
            _errCode = UF_UGMGR_encode_part_filename(part_number, revision_id, file_types[i], file_names[i], part_name);// 根据ItemID、版本、文件类型、文件名encode成新的文件名
            PRINT(("Rev.: %s - Type: %s, Name: %s", revision_id, file_types[i], file_names[i]));
            indent_level++;
            _errCode = UF_UGMGR_ask_dependent_files(part_name, &dep_count, &names);// 获取关联文件
            for (k = 0; k < dep_count; k++)
                PRINT(("Dependent files: %s", names[k]));

            indent_level--;
            if (dep_count > 0)
                UF_free_string_array(dep_count, names);
        }
        if (count > 0){
            UF_free_string_array(count, file_types);
            UF_free_string_array(count, file_names);
        }
    }
    indent_level--;
    UF_free(revisions);
    revisions = NULL;
    return _errCode;
}

static int list_in_folder(UF_UGMGR_tag_t folder)
{
    int _errCode = 0;
    char folder_name[UF_UGMGR_NAME_SIZE + 1];
    if (folder == UF_UGMGR_null_tag) return -1;

    _errCode = UF_UGMGR_ask_folder_name(folder, folder_name);// 获取文件夹名称
    PRINT(("Folder: %s", folder_name));
    indent_level++;

    UF_UGMGR_object_type_t object_type;
    int root_folder_contents_count = 0;
    UF_UGMGR_tag_t * folder_contents = NULL;
    _errCode = UF_UGMGR_list_folder_contents(folder, &root_folder_contents_count, &folder_contents);// 列出文件夹下的所有文件
    for (int idx = 0; idx < root_folder_contents_count; idx++)
    {
        _errCode = UF_UGMGR_ask_object_type(folder_contents[idx], &object_type);// 获取文件类型
        switch (object_type)
        {
        case UF_UGMGR_type_folder:
            list_in_folder(folder_contents[idx]);// 是文件夹
            break;
        case UF_UGMGR_type_part:
            list_in_part(folder_contents[idx]);// 是零组件
            break;
        default:
            printf("Invalid object type found");
            break;
        }
    }
    UF_free(folder_contents);
    folder_contents = NULL;
    indent_level--;
    return _errCode;
}

void do_it()
{
    int _errCode = 0;

    tag_t partTag = NULL_TAG;
    UF_PART_load_status_t error_status;
    UF_UGMGR_tag_t database_part_tag = NULL_TAG;
    UF_UGMGR_tag_t part_revision = NULL_TAG;
    UF_UGMGR_tag_t root_folder_tag = NULL_TAG;
    UF_UGMGR_tag_t user_folder_tag = NULL_TAG;

    char current_rule[UF_UGMGR_NAME_BUFSIZE] = { 0 };
    char revision_id[UF_UGMGR_NAME_BUFSIZE] = { 0 };
    char export_dir_name[MAX_FSPEC_BUFSIZE] = { 0 };
    char encoded_name[MAX_FSPEC_BUFSIZE] = { 0 };
    char user_role[UF_UGMGR_ROLE_BUFSIZE] = { 0 };

    _errCode = UF_UGMGR_ask_part_tag("000000000AA000082", &database_part_tag);// 获取编码为000000000AA000082的部件标识
    _errCode = UF_UGMGR_ask_config_rule(current_rule);// 获取默认配置规则
    std::cout << "默认配置规则：" << current_rule << std::endl;
    _errCode = UF_UGMGR_set_config_rule("Latest Working");// 设置配置规则
    _errCode = UF_UGMGR_ask_configured_rev(database_part_tag, &part_revision);// 获取配置版本
    _errCode = UF_UGMGR_ask_part_revision_id(part_revision, revision_id);// 获取版本ID

    _errCode = UF_UGMGR_ask_root_folder(&root_folder_tag);// 获取用户根文件夹，即HOME文件夹标识
    _errCode = UF_UGMGR_ask_user_folder("infodba", &user_folder_tag);// 获取用户文件夹
    _errCode = UF_UGMGR_ask_user_role(user_role);// 获取用户角色

    std::cout << "\n=================用户文件夹下文件=================" << std::endl;
    _errCode = list_in_folder(root_folder_tag);// 列出该文件夹下地下所有文件夹和零组件
    std::cout << "=================用户文件夹下文件=================\n" << std::endl;

    int config_rules_count = 0;
    char ** config_rules = NULL;
    _errCode = UF_UGMGR_list_config_rules(&config_rules_count, &config_rules);// 列出所有配置规则，并打印到控制台
    std::cout << "\n=================所有配置规则=================" << std::endl;
    for (int idx = 0; idx < config_rules_count; idx++)
        std::cout << config_rules[idx] << std::endl;
    UF_free(config_rules);
    config_rules = NULL;
    std::cout << "=================所有配置规则=================\n" << std::endl;

    int file_count = 0;
    char** file_types = NULL;
    char** file_names = NULL;
    _errCode = UF_UGMGR_list_part_rev_files(part_revision, &file_count, &file_types, &file_names);// 列出版本下所有数据集文件
    if (file_count <= 0) return;

    for (int idx = 0; idx < file_count; idx++){
        if (file_names[idx] == NULL) continue;

        _errCode = UF_UGMGR_encode_part_filename("000000000AA000082", revision_id, file_types[idx], file_names[idx], encoded_name);// encode组成文件名
        _errCode = UF_PART_open(encoded_name, &partTag, &error_status);// NX后台打开
        _errCode = UF_UGMGR_ask_export_directory(partTag, export_dir_name);// 获取export文件夹目录
        std::cout << "临时export文件夹目录：" << export_dir_name << std::endl;
        _errCode = UF_PART_free_load_status(&error_status);
        _errCode = UF_PART_close(partTag, 1, 1);
    }
    if (file_count > 0){
        UF_free_string_array(file_count, file_names);
        UF_free_string_array(file_count, file_types);
    }
    file_types = NULL;
    file_names = NULL;
}

//===================
// Entry Point
//===================
int main(int argc, char* argv[])
{
    try{
        int _errCode = 0;
        const char** consolePara = (const char**)(argv);
        logical is_active;
        _errCode = UF_is_ugmanager_active(&is_active);// 判断ugmanager环境是否已经初始化
        if (!is_active)
            _errCode = UF_UGMGR_initialize(argc, consolePara);// 初始化ugmanager环境
        do_it();
        _errCode = UF_UGMGR_terminate();
        return _errCode;
    }
    catch (const NXException& e1){
        cerr << "NXException: " << e1.ErrorCode() << endl;
        cerr << e1.Message() << endl;
    }
    catch (const exception& e2){
        cerr << "Exception: " << e2.what() << endl;
    }
    catch (...){
        cerr << "Unknown Exception: " << endl;
    }
}

调试截图：

NX版本配置规则截图：