|
|
#include "handler.h"
|
|
|
|
|
|
#define ARGS_LENGTH 200
|
|
|
#define MAX_PRINTLINE_LENGTH 2000
|
|
|
#define MAX_PATH_LENGTH 2000
|
|
|
#define MAX_ARGUMENT_LENGTH 400
|
|
|
#define MAX_PARAMNAME_LENGTH 50
|
|
|
#define MAX_FILE_EXT_LENGTH 10
|
|
|
#define TRUE_FLAG 1
|
|
|
#define FALSE_FLAG 0
|
|
|
#define DETAILLOG 1
|
|
|
#define DOFREE(obj) \
|
|
|
{ \
|
|
|
if(obj) \
|
|
|
{ \
|
|
|
MEM_free(obj); \
|
|
|
obj = NULL; \
|
|
|
} \
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int delete_release_status(EPM_action_message_t msg) {
|
|
|
int ifail = ITK_ok, att_cnt = 0, rel_cnt = 0;
|
|
|
EPM_target_attachment;
|
|
|
tag_t task = NULLTAG, rootTask_tag = NULLTAG, *attchments = NULL, *releases = NULL, release_status = NULL;
|
|
|
|
|
|
ITKCALL(EPM_ask_root_task(msg.task, &rootTask_tag));
|
|
|
ITKCALL(EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attchments));
|
|
|
POM_AM__set_application_bypass(true);
|
|
|
for (int i = 0; i < att_cnt; i++)
|
|
|
{
|
|
|
ITKCALL(AOM_ask_value_tags(attchments[i], "release_status_list", &rel_cnt, &releases));
|
|
|
for (int j = rel_cnt - 1; j > -1; j--)
|
|
|
{
|
|
|
EPM_remove_status_from_targets(releases[j], rootTask_tag);
|
|
|
}
|
|
|
}
|
|
|
POM_AM__set_application_bypass(false);
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* 获取包含中文字符的字符串长度
|
|
|
*/
|
|
|
int getCharLength(char str[])
|
|
|
{
|
|
|
int count = 0;
|
|
|
for (int i = 0; str[i]; i++)
|
|
|
{
|
|
|
if (str[i] < 0) i++;
|
|
|
count++;
|
|
|
}
|
|
|
return count;
|
|
|
}
|
|
|
//发布对象
|
|
|
int set_release_status(tag_t item, char release_name[]) {
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t release_status = NULL;
|
|
|
|
|
|
ITKCALL(ifail = RELSTAT_create_release_status(release_name, &release_status));
|
|
|
ITKCALL(ifail = RELSTAT_add_release_status(release_status, 1, &item, TRUE));
|
|
|
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
bool contans(const char* types, char* type) {
|
|
|
vector<string> ans;
|
|
|
Split(types, ",", ans);
|
|
|
//判断类型
|
|
|
for (int i = 0; i < ans.size(); i++) {
|
|
|
if (strcmp(ans[i].c_str(), type) == 0) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
int reviseDesignPost(METHOD_message_t* msg, va_list va)
|
|
|
{
|
|
|
|
|
|
int ifail = ITK_ok, rev_cnt = 0;
|
|
|
tag_t new_rev = va_arg(va, tag_t);
|
|
|
tag_t item = NULLTAG;
|
|
|
tag_t* rev_list = NULLTAG;
|
|
|
|
|
|
POM_AM__set_application_bypass(true);
|
|
|
|
|
|
//力源对象版本升版后操
|
|
|
char* type;
|
|
|
ITKCALL(AOM_ask_value_string(new_rev, "object_type", &type));
|
|
|
ITKCALL(ITEM_ask_item_of_rev(new_rev, &item));
|
|
|
ITKCALL(AOM_ask_value_tags(item, "revision_list", &rev_cnt, &rev_list));
|
|
|
tag_t pre_rev = rev_list[rev_cnt - 2];
|
|
|
//获取首选项匹配类型
|
|
|
int cnt = 0;
|
|
|
char** vals = NULL;
|
|
|
//获取首选项的值
|
|
|
PREF_ask_char_values("LY6_ReviseDesignPost", &cnt, &vals);
|
|
|
for (int i = 0; i < cnt; i++) {
|
|
|
char* val = vals[i];
|
|
|
vector<string> ans;
|
|
|
Split(val, "=", ans);
|
|
|
//判断类型
|
|
|
if (strcmp(ans[0].c_str(), type) == 0) {
|
|
|
printf("%s升版后操开始执行\n", &type);
|
|
|
//获取关系
|
|
|
int wlcount = 0; tag_t* wltags;
|
|
|
ITKCALL(AOM_ask_value_tags(pre_rev, ans[1].c_str(), &wlcount, &wltags));
|
|
|
for (int j = 0; j < wlcount; j++) {
|
|
|
char* wltype;
|
|
|
ITKCALL(AOM_ask_value_string(wltags[j], "object_type", &wltype));
|
|
|
//匹配关系对象类型
|
|
|
if (contans(ans[2].c_str(), wltype)) {
|
|
|
tag_t wlobj;
|
|
|
ITKCALL(ITEM_ask_item_of_rev(wltags[j], &wlobj));
|
|
|
if (wlobj != NULL) {
|
|
|
//获取最新版本
|
|
|
tag_t newwlrev;
|
|
|
int status = ITEM_ask_latest_rev(wlobj, &newwlrev);
|
|
|
if (status == ITK_ok)
|
|
|
{
|
|
|
printf("start 开始删除关系\n");
|
|
|
tag_t gx_gx_type = NULLTAG; tag_t gx_relation = NULLTAG;
|
|
|
ITKCALL(GRM_find_relation_type(ans[1].c_str(), &gx_gx_type));
|
|
|
GRM_find_relation(new_rev, wltags[j], gx_gx_type, &gx_relation);
|
|
|
GRM_delete_relation(gx_relation);
|
|
|
printf("end 删除关系完毕\n");
|
|
|
|
|
|
printf("start 开始添加关系\n");
|
|
|
tag_t relation = NULLTAG;
|
|
|
ITKCALL(GRM_create_relation(new_rev, newwlrev, gx_gx_type, NULLTAG, &relation));
|
|
|
ITKCALL(GRM_save_relation(relation));
|
|
|
printf("end 添加关系完毕\n");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
POM_AM__set_application_bypass(false);
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
|
|
|
bool isTypeOf1(tag_t objtag, const char* type_name) {
|
|
|
tag_t type = NULLTAG;
|
|
|
TCTYPE_ask_object_type(objtag, &type);
|
|
|
tag_t item_type = NULLTAG;
|
|
|
TCTYPE_find_type(type_name, "", &item_type);
|
|
|
bool is_type = false;
|
|
|
if (item_type != NULLTAG) {
|
|
|
logical isok = FALSE;
|
|
|
TCTYPE_is_type_of(type, item_type, &isok);
|
|
|
if (isok) {
|
|
|
is_type = true;
|
|
|
}
|
|
|
}
|
|
|
return is_type;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* @brief 根据不确定类型的tag_t对象，获取item和itemRev对象
|
|
|
* @param check_tag
|
|
|
* @param item_tag
|
|
|
* @param rev_tag
|
|
|
* @return
|
|
|
*/
|
|
|
int get_item_and_rev(tag_t check_tag, tag_t* item_tag, tag_t* rev_tag) {
|
|
|
int ifail = ITK_ok;
|
|
|
if (isTypeOf1(check_tag, "Item")) {
|
|
|
printf("====当前处理的对象是item对象！\n");
|
|
|
*item_tag = check_tag;
|
|
|
ITEM_ask_latest_rev(*item_tag, rev_tag);
|
|
|
}
|
|
|
else if (isTypeOf1(check_tag, "ItemRevision")) {
|
|
|
printf("====当前处理的对象是Revision对象！\n");
|
|
|
*rev_tag = check_tag;
|
|
|
ITEM_ask_item_of_rev(*rev_tag, item_tag);
|
|
|
}
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
std::vector<std::string> split(const std::string& str, char delimiter) {
|
|
|
std::vector<std::string> tokens;
|
|
|
std::string token;
|
|
|
std::istringstream tokenStream(str);
|
|
|
|
|
|
while (std::getline(tokenStream, token, delimiter)) {
|
|
|
tokens.push_back(token);
|
|
|
}
|
|
|
|
|
|
return tokens;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*检查对象属性唯一性校验：item和itemRev对象前操都会走这个方法*/
|
|
|
int Connor_checkItem_unique(METHOD_message_t* msg, va_list va) {//创建item生效
|
|
|
int ifail = ITK_ok;
|
|
|
char* type;
|
|
|
char* name;
|
|
|
char* itemID;
|
|
|
printf("=================================================================================================== \n");
|
|
|
printf("=========触发前操校验唯一性方法==METHOD_find_method('Item/ItemRevision', 'IMAN_save', &mth_tag);\n");
|
|
|
tag_t check_tag = va_arg(va, tag_t);//获取要保存的tag对象
|
|
|
tag_t item_tag = NULLTAG;
|
|
|
tag_t rev_tag = NULLTAG;
|
|
|
ITKCALL(ifail = get_item_and_rev(check_tag, &item_tag, &rev_tag));
|
|
|
if (item_tag == NULLTAG) {
|
|
|
printf("通过check_tag对象获取item对象失败！\n");
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
else if (rev_tag == NULLTAG)
|
|
|
{
|
|
|
printf("通过check_tag对象获取rev对象失败！\n");
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
//操作对象的类型
|
|
|
ITKCALL(ifail = AOM_ask_value_string(check_tag, "object_type", &type));
|
|
|
ITKCALL(ifail = AOM_ask_value_string(check_tag, "object_name", &name));
|
|
|
ITKCALL(ifail = AOM_ask_value_string(check_tag, "item_id", &itemID));
|
|
|
|
|
|
printf("===当前操处理对象的type = %s\n", type);
|
|
|
|
|
|
//获取首选项
|
|
|
int url_num = 0;
|
|
|
char** url_vals = NULL;
|
|
|
ITKCALL(PREF_ask_char_values("LY6_MultiFieldKeys", &url_num, &url_vals));
|
|
|
if (url_num == 0) {
|
|
|
printf("LY6_MultiFieldKeys首选项获取失败！\n");
|
|
|
}else{
|
|
|
printf("LY6_MultiFieldKeys首选项获取成功！\n");
|
|
|
for (int i = 0; i < url_num; i++) {
|
|
|
printf("==>url_vals[%d] = %s\n", i, url_vals[i]);
|
|
|
}
|
|
|
//===================1开始根据首选项中的配置信息校验对象属性=======================================================================================================
|
|
|
for (int i = 0; i < url_num; i++) {
|
|
|
string multiFieldKey = "";//逐行取出首选项中的每一条配置信息
|
|
|
if (url_vals != nullptr && url_vals[i] != nullptr) {
|
|
|
multiFieldKey.assign(url_vals[i]); // LY6_Product:MFK_LY6_Product=item.object_desc.string:object_desc,...
|
|
|
}
|
|
|
size_t posColon = multiFieldKey.find(":");
|
|
|
if (posColon != std::string::npos) {
|
|
|
string compareType = multiFieldKey.substr(0, posColon); // 获取首选项中每条记录前的比较类型:LY6_Product
|
|
|
printf("首选项中获取的compareType = %s\n", compareType.c_str());
|
|
|
if (stricmp(type, compareType.c_str()) == 0) { // 如果操作对象的类型type匹配compareType，开始获取属性并调用查询进行验证唯一性
|
|
|
printf(">>>当前操作对象的类型：%s，与首选项中的一条multiFieldKey匹配=========%s\n", type, multiFieldKey.c_str());
|
|
|
string afterCompare = multiFieldKey.substr(posColon + 1);//MFK_LY6_Product=item.obiect_desc.string:obiect_desc,...
|
|
|
size_t posEqual = afterCompare.find("=");
|
|
|
printf("afterCompare = %s\n", afterCompare.c_str());
|
|
|
|
|
|
//-----------------------------------1KUMA shangmiandaimameiwenti---------------------
|
|
|
if (posEqual != std::string::npos) {
|
|
|
// 提取查询构建器的名称
|
|
|
string cx_name = afterCompare.substr(0, posEqual);//cx_name = MFK_LY6_Product
|
|
|
tag_t query;
|
|
|
ITKCALL(ifail = QRY_find2(cx_name.c_str(), &query));
|
|
|
printf("》》》成功获取到查询构建器query_name==%s\n", cx_name.c_str());
|
|
|
|
|
|
// 获取查询构建器的查询属性条目和值，每个查询条目保存到vector中
|
|
|
string compare_attribute = afterCompare.substr(posEqual + 1); //item.obiect_desc.string:obiect_desc,rev...
|
|
|
vector<string> compare_attr_vals = split(compare_attribute, ',');
|
|
|
int qry_num = compare_attr_vals.size();//查询属性条目个数
|
|
|
//------------------------------------KUMA shangmiandaimameiwenti--------------------------------------------------------
|
|
|
char** qry_entries = new char* [qry_num];
|
|
|
char** qry_values = new char* [qry_num];
|
|
|
int n_found;
|
|
|
tag_t* tags;
|
|
|
int i = 0;
|
|
|
for each (string var in compare_attr_vals)
|
|
|
{//var就是一个查询条目item.obiect_desc.string:obiect_desc
|
|
|
string cx_tm = split(var, ':')[1];//查询构建器条目obiect_desc
|
|
|
printf(">>>获取到查询构建器的查询条目：%s \n", cx_tm.c_str());
|
|
|
string attribute = split(var, ':')[0];//item.obiect_desc.string
|
|
|
string attribut_type = split(attribute, '.')[0];//item
|
|
|
string attribute_name = split(attribute, '.')[1];//obiect_desc
|
|
|
string attribute_t = split(attribute, '.')[2];//string
|
|
|
char* attribute_value = NULL;//属性值
|
|
|
if (stricmp(attribut_type.c_str(), "item") == 0) {//如果当前属性是item属性
|
|
|
char* itemArr = NULL;
|
|
|
ITKCALL(ifail = AOM_ask_value_string(item_tag, "object_name", &itemArr));
|
|
|
printf("开始根据item属性==[%s]获取属性值\n", attribute_name.c_str());
|
|
|
ITKCALL(ifail = AOM_ask_value_string(item_tag, attribute_name.c_str(), &attribute_value));
|
|
|
printf("item属性string类型(属性名)==%s，获取得到的属性值==%s\n", attribute_name.c_str(), attribute_value);
|
|
|
MEM_free(itemArr);
|
|
|
}
|
|
|
else {//非item属性，即rev属性
|
|
|
char* revArr = NULL;
|
|
|
ITKCALL(ifail = AOM_ask_value_string(rev_tag, "object_name", &revArr));
|
|
|
printf("开始根据revision==【%s】的属性==[%s]获取属性值\n",revArr, attribute_name.c_str());
|
|
|
ITKCALL(ifail = AOM_ask_value_string(rev_tag, attribute_name.c_str(), &attribute_value));
|
|
|
printf("revision属性string类型(属性名)==%s，获取得到的属性值==%s\n", attribute_name.c_str(), attribute_value);
|
|
|
MEM_free(revArr);
|
|
|
}
|
|
|
//已经得到属性值attribute_value
|
|
|
if (attribute_value == NULL) {
|
|
|
printf("属性获取失败！\n");
|
|
|
}
|
|
|
else {
|
|
|
printf("属性获取成功qry_values[%d]==%s \n", i, attribute_value);
|
|
|
qry_entries[i] = (char*)calloc(48, sizeof(char));
|
|
|
if (!cx_name.empty()) {
|
|
|
tc_strcpy(qry_entries[i], cx_tm.c_str());
|
|
|
}
|
|
|
qry_values[i] = (char*)calloc(48, sizeof(char));
|
|
|
if (attribute_value != nullptr && strlen(attribute_value) > 0) {
|
|
|
tc_strcpy(qry_values[i], attribute_value);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
printf("写入属性条目数据后的数组：\n");
|
|
|
printf(">>>qry_entries[%d]==%s >>>qry_values[%d]==%s\n", i, qry_entries[i], i, qry_values[i]);
|
|
|
i++;
|
|
|
if (attribute_value != NULL) { MEM_free(attribute_value); }
|
|
|
else { printf("TNND!"); }
|
|
|
}
|
|
|
//-------------------------------------KUMA 上面代码没问题！---------------------------------------------------------
|
|
|
printf("开始调用查询构建器，查询条目数量：%d，具体查询条目如下：\n", qry_num);
|
|
|
for (int j = 0; j < qry_num; j++) {
|
|
|
printf("》》》传入查询构建器的键值对：qry_entries[%d]:%s = qry_values[%d]:%s\n", j, qry_entries[j], j, qry_values[j]);
|
|
|
}
|
|
|
ITKCALL(ifail = QRY_execute(query, qry_num, qry_entries, qry_values, &n_found, &tags));
|
|
|
//释放数组内存
|
|
|
for (int j = 0; j < qry_num; j++) {
|
|
|
delete[] qry_values[j];
|
|
|
delete[] qry_entries[j];
|
|
|
}
|
|
|
delete[] qry_values;
|
|
|
delete[] qry_entries;
|
|
|
printf(">>>查询结果条数：%d\n", n_found);
|
|
|
//-------------------------------------KUMA 上面代码没问题！-------------------------------------------------------
|
|
|
|
|
|
if (n_found > 0) {
|
|
|
//if (n_found == 1) {
|
|
|
// char* itemId = NULL;
|
|
|
// printf("查询结果条数 == 1，判断是否是自身！\n");
|
|
|
// tag_t se = tags[0];
|
|
|
// ITKCALL(ifail = AOM_ask_value_string(se, "item_id", &itemId));
|
|
|
// printf(">>>>查询构建器查询到的对象itemId==[%s]\n", itemId);
|
|
|
// printf(">>>>当前正在操作的对象itemID==[%s]\n", itemID);
|
|
|
// if (strcmp(itemId, itemID) == 0) {//查询到的就是自身
|
|
|
// printf("查询到的结果的item_id == [%s],当前操作的对象item_id == [%s]，仅包含自身--允许放行！\n", itemId, itemID);
|
|
|
// break;
|
|
|
// }
|
|
|
// printf("1 \n");
|
|
|
// if (itemId != NULL) { MEM_free(itemId); }
|
|
|
// else { printf("TNND!"); }
|
|
|
//}
|
|
|
//printf("查询构建器查询到已存在相同属性的数据，不允许创建！\n");
|
|
|
////--------------------------------KUMA 上面代码没问题！------------------------------------------------------------------------
|
|
|
//char errs[2500] = "\0";
|
|
|
//sprintf(errs, "对象[%s]中的首选项配置属性不唯一请检查!!", name);
|
|
|
//EMH_store_error_s1(EMH_severity_information, 919012, errs);//错误弹窗
|
|
|
//printf(">>>返回错误提示！\n");
|
|
|
//ifail = -1;
|
|
|
//break;
|
|
|
|
|
|
for (int i = 0; i < n_found;i++) {
|
|
|
char* itemId = NULL;
|
|
|
ITKCALL(ifail = AOM_ask_value_string(tags[i], "item_id", &itemId));
|
|
|
if (strcmp(itemId, itemID) == 0) {//查询到的就是自身
|
|
|
printf("查询到的结果的item_id == [%s],当前操作的对象item_id == [%s]，仅包含自身--允许放行！\n", itemId, itemID);
|
|
|
MEM_free(itemId);
|
|
|
continue;
|
|
|
}else {
|
|
|
char errs[2500] = "\0";
|
|
|
sprintf(errs, "对象[%s]中的首选项配置属性不唯一请检查!!", name);
|
|
|
EMH_store_error_s1(EMH_severity_information, 919012, errs);//错误弹窗
|
|
|
printf(">>>返回错误提示！\n");
|
|
|
ifail = -1;
|
|
|
MEM_free(itemId);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
if (ifail == -1) {
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf("属性唯一校验通过！\n");
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else {
|
|
|
printf("未在首选项配置信息：：%s中找到符号‘=’。\n", multiFieldKey.c_str());
|
|
|
}
|
|
|
break;
|
|
|
}else{
|
|
|
printf(">>>当前操作对象的类型：%s，与首选项中的配置类型：%s不匹配=========\n", type, compareType.c_str());
|
|
|
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
printf("未在首选项配置信息：：%s中找到冒号，无法正常取得比较类型。\n", multiFieldKey.c_str());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (url_vals != NULL) { MEM_free(url_vals); }
|
|
|
else { printf("TNND!"); }
|
|
|
if (itemID != NULL) { MEM_free(itemID); }
|
|
|
else { printf("TNND!"); }
|
|
|
if (name != NULL) { MEM_free(name); }
|
|
|
else { printf("TNND!"); }
|
|
|
if (type != NULL) { MEM_free(type); }
|
|
|
else { printf("TNND!"); }
|
|
|
printf("==>beybey! \n");
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 检查关系下对象状态
|
|
|
* @param msg
|
|
|
*/
|
|
|
int rule_handler_LY_CheckItem(EPM_rule_message_t msg) {
|
|
|
printf(">>>触发规则处理器：rule_handler_LY_CheckItem。开始检查关系下对象状态！\n");
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t* attachmentTags = NULL,//流程目标下的所有对象
|
|
|
attachmentTag = NULLTAG;//流程目标下的某一个对象
|
|
|
int attachmentCount = 0;
|
|
|
int i = 0;
|
|
|
//流程下的参数
|
|
|
char* itemTypeValue = (char*)MEM_alloc(1028 * sizeof(char));
|
|
|
char* relationValue = (char*)MEM_alloc(1028 * sizeof(char));
|
|
|
char* itemChildTypeValue = (char*)MEM_alloc(1028 * sizeof(char));
|
|
|
char* itemChildRevValue = (char*)MEM_alloc(1028 * sizeof(char));//配置参数：需要检查的版本-单值
|
|
|
char* releaseStatusValue = (char*)MEM_alloc(1028 * sizeof(char));
|
|
|
tag_t rootTask = NULLTAG;
|
|
|
char* arg = NULL,
|
|
|
* argName = NULL,
|
|
|
* argValues = NULL;
|
|
|
ITKCALL(ifail = EPM_ask_root_task(msg.task, &rootTask));
|
|
|
ITKCALL(ifail = EPM_ask_attachments(rootTask, EPM_target_attachment, &attachmentCount, &attachmentTags));
|
|
|
//获取流程目标下的参数（5个）
|
|
|
int argCnt = TC_number_of_arguments(msg.arguments);
|
|
|
if (argCnt > 0)
|
|
|
{
|
|
|
for (i = 0; i < argCnt; i++) {
|
|
|
arg = TC_next_argument(msg.arguments);
|
|
|
ITKCALL(ifail = ITK_ask_argument_named_value((const char*)arg, &argName, &argValues));
|
|
|
printf("处理流程下的参数：argName[%s]->argValue[%s]\n", argName, argValues);
|
|
|
if (tc_strcmp("itemType", argName) == 0) {
|
|
|
itemTypeValue = argValues;
|
|
|
printf(">>>argValues[%s] TO itemTypeValue[%s]\n", argValues, itemTypeValue);
|
|
|
}
|
|
|
else if (tc_strcmp("Relation", argName) == 0) {
|
|
|
tc_strcpy(relationValue, argValues);
|
|
|
printf(">>>argValues[%s] TO relationValue[%s]\n", argValues, relationValue);
|
|
|
}
|
|
|
else if (tc_strcmp("itemChildType", argName) == 0) {
|
|
|
tc_strcpy(itemChildTypeValue, argValues);
|
|
|
printf(">>>argValues[%s] TO itemChildTypeValue[%s]\n", argValues, itemChildTypeValue);
|
|
|
}
|
|
|
else if (tc_strcmp("itemChildRev", argName) == 0) {
|
|
|
tc_strcpy(itemChildRevValue, argValues);
|
|
|
printf(">>>argValues[%s] TO itemChildRevValue[%s]\n", argValues, itemChildRevValue);
|
|
|
}
|
|
|
else if (tc_strcmp("releaseStatus", argName) == 0) {
|
|
|
tc_strcpy(releaseStatusValue, argValues);
|
|
|
printf(">>>argValues[%s] TO releaseStatusValue[%s]\n", argValues, releaseStatusValue);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
printf("》》》未在流程下获取到任何配置参数！\n");
|
|
|
}
|
|
|
printf("获取到的流程下的参数：itemTypeValue==%s,relationValue==%s,itemChildTypeValue==%s,itemChildRevValue==%s,releaseStatusValue==%s \n", itemTypeValue, relationValue, itemChildTypeValue, itemChildRevValue, releaseStatusValue);
|
|
|
|
|
|
//逐个遍历所有的流程目标下的对象
|
|
|
for (i = 0; i < attachmentCount; i++) {
|
|
|
tag_t item_tag = NULLTAG;
|
|
|
tag_t rev_tag = NULLTAG;
|
|
|
char* objectType = NULL;
|
|
|
char* objectName = NULL;
|
|
|
char* result = NULL;
|
|
|
int tag_num = 0;
|
|
|
tag_t* relation_tags = NULL;
|
|
|
|
|
|
attachmentTag = attachmentTags[i];
|
|
|
//获取流程下某一对象的item_tag和rev_tag以及对象类型和名称
|
|
|
ITKCALL(ifail = get_item_and_rev(attachmentTag, &item_tag, &rev_tag));
|
|
|
ITKCALL(ifail = AOM_ask_value_string(attachmentTag,"object_type", &objectType));
|
|
|
ITKCALL(ifail = AOM_ask_value_string(attachmentTag,"object_name", &objectName));
|
|
|
printf("当前遍历的流程下对象类型为：objectType==%s\n", objectType);
|
|
|
if (itemTypeValue != NULL) {
|
|
|
printf(">>>配置参数：-itemType === %s \n", itemTypeValue);
|
|
|
result = strstr(itemTypeValue, objectType);
|
|
|
}
|
|
|
if (result == nullptr) {//不存在
|
|
|
printf("当前流程下的对象类型==%s不在配置的类型参数==%s中，放行当前对象【%s】。\n", objectType, itemTypeValue,objectName);
|
|
|
continue;
|
|
|
}else{
|
|
|
printf("流程下的当前对象的类型==[%s]与itemType参数中的信息==[%s]匹配，开始获取被检查对象 == [%s]！\n", objectType, itemTypeValue, objectName);
|
|
|
vector<string> relations = split(relationValue, ',');
|
|
|
printf(">>>配置参数：-Relation === %s \n", relationValue);
|
|
|
for (string relation : relations) {
|
|
|
tag_t relation_tag = NULL;
|
|
|
printf("开始GET对象==[%s]的[%s]关系下的（被检查）对象们\n", objectName,relation.c_str());
|
|
|
ITKCALL(ifail = AOM_ask_value_tags(attachmentTag, relation.c_str(),&tag_num,&relation_tags));
|
|
|
if (tag_num > 0) {
|
|
|
for (int i = 0; i < tag_num; i++) {
|
|
|
printf("开始循环遍历[%s]关系下的“被检查对象”,关系下共有%d个被检查对象\n",relation.c_str(), tag_num);
|
|
|
char* relation_child_type = NULL;//被检查对象类型
|
|
|
char* relation_child_rev = NULL;//被检查对象版本号
|
|
|
tag_t* relation_child_release = NULL;//被检查对象的发布状态数组
|
|
|
int release_num = 0;
|
|
|
relation_tag = relation_tags[i];//被检查对象
|
|
|
ITKCALL(ifail = AOM_ask_value_string(relation_tag, "object_type", &relation_child_type));
|
|
|
ITKCALL(ifail = AOM_ask_value_string(relation_tag, "item_revision_id", &relation_child_rev));
|
|
|
ITKCALL(ifail = AOM_ask_value_tags(relation_tag, "release_status_list",&release_num, &relation_child_release));
|
|
|
|
|
|
vector<string> itemChildTypes = split(itemChildTypeValue, ',');
|
|
|
printf(">>>配置参数：-itemChildTypeValue === %s \n", itemChildTypeValue);
|
|
|
int tagR = 0;
|
|
|
for (string itemChildType : itemChildTypes) {
|
|
|
if (stricmp(itemChildType.c_str(), relation_child_type) == 0) {//被检查对象的类型[relation_child_type]与参数[itemChildTypes]中匹配
|
|
|
printf(">>>流程对象：%s下的被检查对象类型：%s 与参数::%s中匹配！允许发起\n", objectName,relation_child_type, itemChildTypeValue);
|
|
|
if (itemChildRevValue != NULL && stricmp(itemChildRevValue,"")!=0) {
|
|
|
printf(">>>配置的参数版本号：%s\n", itemChildRevValue);
|
|
|
if (stricmp(itemChildRevValue, relation_child_rev) != 0) {//配置的被检查对象版本参数只有一个
|
|
|
printf("被检查对象的版本不在配置的版本参数中，不允许发起");
|
|
|
char* error_msg = objectName;
|
|
|
strcat(error_msg, "对象下关系绑定对象不正确，请检查！");
|
|
|
EMH_store_error_s1(EMH_severity_error, EMH_USER_error_base, error_msg);
|
|
|
return EPM_nogo;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf(">>>首选项中配置的参数版本号：[%s]为空!\n", itemChildRevValue);
|
|
|
}
|
|
|
if (releaseStatusValue != NULL && stricmp(releaseStatusValue, "") != 0) {
|
|
|
if (stricmp(releaseStatusValue,"none") == 0) {
|
|
|
printf(">>>配置的发布状态为:none\n");
|
|
|
if (release_num > 0) {//被检查对象有发布状态，不发起
|
|
|
printf("当配置的发布状态为none时，被检查对象的发布状态有值，不允许发起");
|
|
|
char* error_msg = objectName;
|
|
|
strcat(error_msg, "对象下关系绑定对象不正确，请检查！");
|
|
|
EMH_store_error_s1(EMH_severity_error, EMH_USER_error_base, error_msg);
|
|
|
return EPM_nogo;
|
|
|
}
|
|
|
}else
|
|
|
{//配置的发布状态参数有值，且不为none
|
|
|
printf(">>>配置的参数:发布状态：%s\n", releaseStatusValue);
|
|
|
if (release_num > 0) {//被检查对象有发布状态，开始检查
|
|
|
int k = 0;
|
|
|
for (int j = 0; j < release_num; j++) {//遍历被检查对象的发布状态
|
|
|
printf("开始循环遍历被检查对象的发布状态，发布状态有%d个\n", release_num);
|
|
|
char* relation_child_release_value = NULL;//被检查对象的发布状态的其中一个的名称
|
|
|
tag_t child_release = relation_child_release[j];
|
|
|
ITKCALL(ifail = AOM_ask_value_string(child_release, "current_name", &relation_child_release_value));
|
|
|
|
|
|
if (strstr(releaseStatusValue, relation_child_release_value) == nullptr) {//被检查对象的发布状态中，任一【child_release】不在配置的参数releaseStatusValue中，不发起
|
|
|
printf("被检查对象的发布状态数组中，任一【%s】不在配置的参数releaseStatusValue【%s】中，不发起！ \n", relation_child_release_value, releaseStatusValue);
|
|
|
char* error_msg = objectName;
|
|
|
strcat(error_msg, "对象下关系绑定对象不正确，请检查！");
|
|
|
EMH_store_error_s1(EMH_severity_error, EMH_USER_error_base, error_msg);
|
|
|
return EPM_nogo;
|
|
|
}
|
|
|
MEM_free(relation_child_release_value);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
printf("被检查对象的发布状态数组为空，不满足配置！\n");
|
|
|
char* error_msg = objectName;
|
|
|
strcat(error_msg, "被检查对象的发布状态数组为空，不满足配置！");
|
|
|
EMH_store_error_s1(EMH_severity_error, EMH_USER_error_base, error_msg);
|
|
|
return EPM_nogo;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
tagR++;
|
|
|
}
|
|
|
}
|
|
|
if (tagR == 0) {//当前被检查对象类型不在参数中，则不执行
|
|
|
printf("流程下对象的关系下的“被检查对象”中，不存在与itemchildtype参数中匹配的对象，不可发起！ \n");
|
|
|
char* error_msg = objectName;
|
|
|
strcat(error_msg, "对象下关系绑定对象不正确，请检查！");
|
|
|
EMH_store_error_s1(EMH_severity_error, EMH_USER_error_base, error_msg);
|
|
|
|
|
|
return EPM_nogo;
|
|
|
}
|
|
|
MEM_free(relation_child_release);
|
|
|
MEM_free(relation_child_rev);
|
|
|
MEM_free(relation_child_type);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf("流程下当前[%s]对象的[%s]关系下不存在“被检查对象”，拦截\n", objectName, relation.c_str());
|
|
|
return EPM_nogo;
|
|
|
}
|
|
|
MEM_free(relation_tags);
|
|
|
}
|
|
|
}
|
|
|
MEM_free(objectName);
|
|
|
MEM_free(objectType);
|
|
|
}
|
|
|
MEM_free(argValues);
|
|
|
MEM_free(argName);
|
|
|
MEM_free(attachmentTags);
|
|
|
return EPM_go;
|
|
|
}
|
|
|
|
|
|
|
|
|
int Connor_ItemRevision_Save(METHOD_message_t* msg, va_list va)
|
|
|
{
|
|
|
|
|
|
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t new_rev = va_arg(va, tag_t);
|
|
|
tag_t item = NULLTAG;
|
|
|
tag_t* rev_list;
|
|
|
char* type = NULL;
|
|
|
char* desc = NULL;
|
|
|
printf("图纸保存后操作\n");
|
|
|
ITKCALL(ITEM_ask_item_of_rev(new_rev, &item));
|
|
|
//获取首选项
|
|
|
int url_num = 0;
|
|
|
char** url_vals = NULL;
|
|
|
ITKCALL(PREF_ask_char_values("connor_CheckMaterialDesc", &url_num, &url_vals));
|
|
|
char* pref = url_vals[0];
|
|
|
printf("pref=========%s\n", pref);
|
|
|
if (item != NULLTAG) {
|
|
|
ITKCALL(AOM_ask_value_string(item, "object_type", &type));
|
|
|
printf("object_type=========%s\n", type);
|
|
|
if (strstr(pref, type)) {
|
|
|
ITKCALL(AOM_ask_value_string(new_rev, "ly6_materialDesc", &desc));
|
|
|
printf("desc=========%s\n", desc);
|
|
|
// 计算字符串长度
|
|
|
//size_t length = strlen(desc);
|
|
|
int count = getCharLength(desc);
|
|
|
printf("count=========%d\n", count);
|
|
|
// 判断字符串长度是否超过40个字符
|
|
|
if (count > 40) {
|
|
|
EMH_store_error_s2(EMH_severity_error,
|
|
|
919012,
|
|
|
"提示",
|
|
|
"物料描述不能超过40个字符，请检查后重新输入!");
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
//
|
|
|
//int Connor_CreateItemPost(METHOD_message_t* msg, va_list va)
|
|
|
//{
|
|
|
//
|
|
|
// char* desc = NULL;
|
|
|
// char* type = NULL;
|
|
|
// //tag_t new_item_tag = NULLTAG;
|
|
|
// printf("----------------------------------------------------\n");
|
|
|
// const char* temp = NULL;
|
|
|
// //while ((temp = va_arg(va, const char*)) != NULL && strlen(temp) > 0) {
|
|
|
// // printf("Number: %s\n", temp);
|
|
|
// //}
|
|
|
//
|
|
|
// //printf("--------------------------------\n");
|
|
|
// const char* item_id = va_arg(va, const char*);
|
|
|
// const char* item_name = va_arg(va, const char*);
|
|
|
// const char* item_type = va_arg(va, const char*);
|
|
|
// const char* rev_id = va_arg(va, const char*);
|
|
|
// printf("item_id=========%s\n", item_id);
|
|
|
// printf("item_name=========%s\n", item_name);
|
|
|
// printf("item_type=========%s\n", item_type);
|
|
|
// printf("rev_id=========%s\n", rev_id);
|
|
|
// tag_t* new_item_tag = va_arg(va, tag_t*);//创建后的对象
|
|
|
// //获取首选项
|
|
|
//
|
|
|
// int url_num = 0;
|
|
|
// char** url_vals = NULL;
|
|
|
// ITKCALL(PREF_ask_char_values("connor_CheckMaterialDesc", &url_num, &url_vals));
|
|
|
// char* pref = url_vals[0];
|
|
|
// printf("pref=========%s\n", pref);
|
|
|
//
|
|
|
// if (new_item_tag)
|
|
|
// {
|
|
|
//
|
|
|
// ITKCALL(AOM_ask_value_string(*new_item_tag, "object_type", &type));
|
|
|
// printf("object_type=========%s\n", type);
|
|
|
// if (strstr(pref,type)) {
|
|
|
// tag_t rev = NULLTAG;
|
|
|
// ITKCALL(ITEM_ask_latest_rev(*new_item_tag, &rev));
|
|
|
// if (rev != NULLTAG) {
|
|
|
// printf("1111111111111111111111111111\n");
|
|
|
// ITKCALL(AOM_ask_value_string(rev, "ly6_materialDesc", &desc));
|
|
|
// printf("desc=========%s\n", desc);
|
|
|
// // 计算字符串长度
|
|
|
// size_t length = strlen(desc);
|
|
|
//
|
|
|
// // 判断字符串长度是否超过40个字符
|
|
|
// if (length > 40) {
|
|
|
// EMH_store_error_s2(EMH_severity_error,
|
|
|
// 919012,
|
|
|
// "提示",
|
|
|
// "物料描述不能超过40个字符，请检查后重新输入!");
|
|
|
// return -1;
|
|
|
// }
|
|
|
// }
|
|
|
//
|
|
|
//
|
|
|
// }
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
//
|
|
|
// }
|
|
|
// return 0;
|
|
|
//}
|
