|
|
#pragma warning (disable: 4996)
|
|
|
#pragma warning (disable: 4819)
|
|
|
|
|
|
#include "kutil.h"
|
|
|
|
|
|
FILE* logFile = NULL;
|
|
|
|
|
|
#define MAX_PATH_LENGTH 200
|
|
|
#define MAX_PRINTLINE_LENGTH 400000
|
|
|
|
|
|
|
|
|
//void sendGetRequest()
|
|
|
//{
|
|
|
// //开始进行socket初始化;
|
|
|
// WSADATA wData;
|
|
|
// ::WSAStartup(MAKEWORD(2, 2), &wData);
|
|
|
//
|
|
|
// SOCKET clientSocket = socket(AF_INET, 1, 0);
|
|
|
// struct sockaddr_in ServerAddr = { 0 };
|
|
|
// int Ret = 0;
|
|
|
// int AddrLen = 0;
|
|
|
// HANDLE hThread = 0;
|
|
|
//
|
|
|
// char *bufSend = "Get /check?+参数 HTTP/1.1\r\n"
|
|
|
// "Connection:Keep-Alive\r\n"
|
|
|
// "Accept-Encoding:gzip, deflate\r\n"
|
|
|
// "Accept-Language:zh-CN,en,*\r\n"
|
|
|
// "host:www.baidu.com\r\n"
|
|
|
// "User-Agent:Mozilla/5.0\r\n\r\n";
|
|
|
//
|
|
|
// char addIp[256] = { 0 };
|
|
|
// GetIpByDomainName("www.baidu.com", addIp);
|
|
|
// ServerAddr.sin_addr.s_addr = inet_addr(addIp);
|
|
|
// ServerAddr.sin_port = htons(80);;
|
|
|
// ServerAddr.sin_family = AF_INET;
|
|
|
// char bufData[3069] = { 0 };
|
|
|
// char bufRecv[3069] = { 0 };
|
|
|
// int errNo = 0;
|
|
|
// errNo = connect(clientSocket, (sockaddr*)&ServerAddr, sizeof(ServerAddr));
|
|
|
// if (errNo == 0)
|
|
|
// {
|
|
|
// //如果发送成功，则返回发送成功的字节数;
|
|
|
// if (send(clientSocket, bufSend, strlen(bufData), 0)>0)
|
|
|
// {
|
|
|
// cout << "发送成功\n";;
|
|
|
// }
|
|
|
// //如果接受成功，则返回接受的字节数;
|
|
|
// if (recv(clientSocket, bufRecv, 3069, 0)>0)
|
|
|
// {
|
|
|
// cout << "接受的数据:" << bufRecv << endl;
|
|
|
// }
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// errNo = WSAGetLastError();
|
|
|
// }
|
|
|
// //socket环境清理;
|
|
|
// ::WSACleanup();
|
|
|
//}
|
|
|
//
|
|
|
//BOOL GetIpByDomainName(char *szHost, char* szIp)
|
|
|
//{
|
|
|
// WSADATA wsaData;
|
|
|
//
|
|
|
// HOSTENT *pHostEnt;
|
|
|
// int nAdapter = 0;
|
|
|
// struct sockaddr_in sAddr;
|
|
|
// if (WSAStartup(0x0101, &wsaData))
|
|
|
// {
|
|
|
// printf(" gethostbyname error for host:\n");
|
|
|
// return FALSE;
|
|
|
// }
|
|
|
//
|
|
|
// pHostEnt = gethostbyname(szHost);
|
|
|
// if (pHostEnt)
|
|
|
// {
|
|
|
// if (pHostEnt->h_addr_list[nAdapter])
|
|
|
// {
|
|
|
// memcpy(&sAddr.sin_addr.s_addr, pHostEnt->h_addr_list[nAdapter], pHostEnt->h_length);
|
|
|
// sprintf(szIp, "%s", inet_ntoa(sAddr.sin_addr));
|
|
|
// }
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// // DWORD dwError = GetLastError();
|
|
|
// // CString csError;
|
|
|
// // csError.Format("%d", dwError);
|
|
|
// }
|
|
|
// WSACleanup();
|
|
|
// return TRUE;
|
|
|
//}
|
|
|
|
|
|
int write_string_to_file_append(const std::string & file_string, const std::string str)
|
|
|
{
|
|
|
std::ofstream OsWrite(file_string, std::ofstream::app);
|
|
|
OsWrite << str;
|
|
|
OsWrite << std::endl;
|
|
|
OsWrite.close();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
void setProperty(tag_t formValue, char * propertyName, tag_t toValue, char * toPropertyName)
|
|
|
{
|
|
|
PROP_value_type_t propertyType;
|
|
|
char * valtype_n = NULL;
|
|
|
//获取属性类型
|
|
|
AOM_ask_value_type(formValue, propertyName, &propertyType, &valtype_n);
|
|
|
switch (propertyType)
|
|
|
{
|
|
|
case PROP_date:
|
|
|
date_t propertyValue;
|
|
|
AOM_ask_value_date(formValue, propertyName, &propertyValue);
|
|
|
//先lock
|
|
|
AOM_lock(toValue);
|
|
|
AOM_set_value_date(toValue, toPropertyName, propertyValue);
|
|
|
//再save
|
|
|
AOM_save(toValue);
|
|
|
//最后unlock
|
|
|
AOM_unlock(toValue);
|
|
|
AOM_refresh(toValue, FALSE);
|
|
|
break;
|
|
|
case PROP_double:
|
|
|
double propertyValue2;
|
|
|
AOM_ask_value_double(formValue, propertyName, &propertyValue2);
|
|
|
//先lock
|
|
|
AOM_lock(toValue);
|
|
|
AOM_set_value_double(toValue, toPropertyName, propertyValue2);
|
|
|
//再save
|
|
|
AOM_save(toValue);
|
|
|
//最后unlock
|
|
|
AOM_unlock(toValue);
|
|
|
AOM_refresh(toValue, FALSE);
|
|
|
break;
|
|
|
case PROP_int:
|
|
|
int propertyValue3;
|
|
|
AOM_ask_value_int(formValue, propertyName, &propertyValue3);
|
|
|
//先lock
|
|
|
AOM_lock(toValue);
|
|
|
AOM_set_value_int(toValue, toPropertyName, propertyValue3);
|
|
|
//再save
|
|
|
AOM_save(toValue);
|
|
|
//最后unlock
|
|
|
AOM_unlock(toValue);
|
|
|
AOM_refresh(toValue, FALSE);
|
|
|
break;
|
|
|
case PROP_string:
|
|
|
char * propertyValue4;
|
|
|
AOM_ask_value_string(formValue, propertyName, &propertyValue4);
|
|
|
//先lock
|
|
|
AOM_lock(toValue);
|
|
|
AOM_set_value_string(toValue, toPropertyName, propertyValue4);
|
|
|
//再save
|
|
|
AOM_save(toValue);
|
|
|
//最后unlock
|
|
|
AOM_unlock(toValue);
|
|
|
AOM_refresh(toValue, FALSE);
|
|
|
DOFREE(propertyValue4);
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
DOFREE(valtype_n);
|
|
|
}
|
|
|
|
|
|
bool is_str_utf8(const char* str)
|
|
|
{
|
|
|
unsigned int nBytes = 0;//UFT8可用1-6个字节编码,ASCII用一个字节
|
|
|
unsigned char chr = *str;
|
|
|
bool bAllAscii = true;
|
|
|
for (unsigned int i = 0; str[i] != '\0'; ++i) {
|
|
|
chr = *(str + i);
|
|
|
//判断是否ASCII编码,如果不是,说明有可能是UTF8,ASCII用7位编码,最高位标记为0,0xxxxxxx
|
|
|
if (nBytes == 0 && (chr & 0x80) != 0) {
|
|
|
bAllAscii = false;
|
|
|
}
|
|
|
if (nBytes == 0) {
|
|
|
//如果不是ASCII码,应该是多字节符,计算字节数
|
|
|
if (chr >= 0x80) {
|
|
|
if (chr >= 0xFC && chr <= 0xFD) {
|
|
|
nBytes = 6;
|
|
|
}
|
|
|
else if (chr >= 0xF8) {
|
|
|
nBytes = 5;
|
|
|
}
|
|
|
else if (chr >= 0xF0) {
|
|
|
nBytes = 4;
|
|
|
}
|
|
|
else if (chr >= 0xE0) {
|
|
|
nBytes = 3;
|
|
|
}
|
|
|
else if (chr >= 0xC0) {
|
|
|
nBytes = 2;
|
|
|
}
|
|
|
else {
|
|
|
return false;
|
|
|
}
|
|
|
nBytes--;
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
//多字节符的非首字节,应为 10xxxxxx
|
|
|
if ((chr & 0xC0) != 0x80) {
|
|
|
return false;
|
|
|
}
|
|
|
//减到为零为止
|
|
|
nBytes--;
|
|
|
}
|
|
|
}
|
|
|
//违返UTF8编码规则
|
|
|
if (nBytes != 0) {
|
|
|
return false;
|
|
|
}
|
|
|
if (bAllAscii) { //如果全部都是ASCII, 也是UTF8
|
|
|
return true;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool find_prop(int prop_cnt, char** props, const char* prop) {
|
|
|
for (int i = 0; i < prop_cnt; i++) {
|
|
|
if (tc_strcmp(props[i], prop) == 0) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
string itoa_self(int i)
|
|
|
{
|
|
|
stringstream ss;
|
|
|
ss << i;
|
|
|
return ss.str();
|
|
|
}
|
|
|
|
|
|
//从文件读入到string里
|
|
|
string readFileIntoString(char * filename)
|
|
|
{
|
|
|
//string line;
|
|
|
|
|
|
//ifstream infile(filename, ios::in);
|
|
|
|
|
|
//if (infile) // 有该文件
|
|
|
//{
|
|
|
// while (getline(infile, line, '\n')) // line中不包括每行的换行符
|
|
|
// {
|
|
|
// cout << line << endl;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
//
|
|
|
////返回与流对象buf关联的字符串
|
|
|
//cout << line<<endl;
|
|
|
|
|
|
std::ifstream f{ filename, std::ios::binary };
|
|
|
std::stringstream ss;
|
|
|
ss << f.rdbuf();
|
|
|
return ss.str();
|
|
|
}
|
|
|
|
|
|
map<string, string> jsonstr2map(const string& json)
|
|
|
{
|
|
|
//cout << json << endl;
|
|
|
Json::Reader reader;
|
|
|
Json::Value value;
|
|
|
map<string, string> maps;
|
|
|
|
|
|
if (json.length() > 0)
|
|
|
{
|
|
|
if (reader.parse(json, value))
|
|
|
{
|
|
|
Json::Value::Members members = value.getMemberNames();
|
|
|
for (Json::Value::Members::iterator it = members.begin(); it != members.end(); it++)
|
|
|
{
|
|
|
Json::ValueType vt = value[*it].type();
|
|
|
switch (vt)
|
|
|
{
|
|
|
case Json::stringValue:
|
|
|
{
|
|
|
maps.insert(pair<string, string>(*it, value[*it].asString()));
|
|
|
break;
|
|
|
}
|
|
|
case Json::intValue:
|
|
|
{
|
|
|
int intTmp = value[*it].asInt();
|
|
|
maps.insert(pair<string, string>(*it, itoa_self(intTmp)));
|
|
|
break;
|
|
|
}
|
|
|
case Json::arrayValue:
|
|
|
{
|
|
|
std::string strid;
|
|
|
for (unsigned int i = 0; i < value[*it].size(); i++)
|
|
|
{
|
|
|
strid += value[*it][i].asString();
|
|
|
strid += ",";
|
|
|
}
|
|
|
if (!strid.empty())
|
|
|
{
|
|
|
strid = strid.substr(0, strid.size() - 1);
|
|
|
}
|
|
|
maps.insert(pair<string, string>(*it, strid));
|
|
|
break;
|
|
|
}
|
|
|
default:
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
}//end switch
|
|
|
}//end for
|
|
|
}//end if
|
|
|
}
|
|
|
|
|
|
return maps;
|
|
|
}
|
|
|
|
|
|
|
|
|
//获取当前时间
|
|
|
void getCurrentTime(date_t * now)
|
|
|
{
|
|
|
time_t tim = time(NULL);
|
|
|
time(&tim);
|
|
|
struct tm * gmt = NULL;
|
|
|
gmt = localtime(&tim);
|
|
|
//char temp[MAX_PATH_LENGTH];
|
|
|
//sprintf(temp, "%d-%d-%d", gmt->tm_year, gmt->tm_mon, gmt->tm_mday);
|
|
|
cout << now->year << 1900 + gmt->tm_year; //02021
|
|
|
cout << now->month << 1 + gmt->tm_mon; //8
|
|
|
cout << now->day << gmt->tm_mday;
|
|
|
cout << now->hour << gmt->tm_hour;
|
|
|
cout << now->minute << gmt->tm_min;
|
|
|
}
|
|
|
|
|
|
//获取当前年的后两位
|
|
|
int getLast2Year(char* &year)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
time_t now = time(0);
|
|
|
tm* ltm = localtime(&now);
|
|
|
char temp[200] = "";
|
|
|
snprintf(temp, sizeof(temp), "%d", 1900 + ltm->tm_year);
|
|
|
string year2(temp);
|
|
|
year2 = year2.substr(2);
|
|
|
strcpy(temp, year2.c_str());
|
|
|
year = temp;
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
//设置只读属性的值
|
|
|
int connor_set_prop_value(char* propname, const char* propvalue, tag_t &tag_instance) {
|
|
|
int ifail = ITK_ok;
|
|
|
|
|
|
POM_AM__set_application_bypass(true);
|
|
|
char * class_id = NULL;
|
|
|
tag_t attr_id = NULLTAG, class_tag = NULLTAG;
|
|
|
|
|
|
ITKCALL(AOM_lock(tag_instance));
|
|
|
ITKCALL(ifail = POM_class_of_instance(tag_instance, &class_tag));
|
|
|
ITKCALL(ifail = POM_name_of_class(class_tag, &class_id));
|
|
|
ITKCALL(ifail = POM_attr_id_of_attr(propname, class_id, &attr_id));
|
|
|
ITKCALL(POM_refresh_instances_any_class(1, &tag_instance, POM_modify_lock));
|
|
|
ITKCALL(POM_set_attr_string(1, &tag_instance, attr_id, propvalue));
|
|
|
ITKCALL(POM_save_instances(1, &tag_instance, true));
|
|
|
ITKCALL(AOM_unlock(tag_instance));
|
|
|
DOFREE(class_id);
|
|
|
POM_AM__set_application_bypass(false);
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
|
|
|
//设置只读属性的值
|
|
|
int connor_set_prop_value(void *returnValue)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
WriteLog(ifail, "> 开始执行 <设置不可修改的属性> ");
|
|
|
char *propname = NULL, *propvalue = NULL, *class_id = NULL;
|
|
|
tag_t tag_instance = NULLTAG, attr_id = NULLTAG, class_tag = NULLTAG;
|
|
|
ITKCALL(ifail = USERARG_get_string_argument(&propname));
|
|
|
ITKCALL(ifail = USERARG_get_string_argument(&propvalue));
|
|
|
ITKCALL(ifail = USERARG_get_tag_argument(&tag_instance));
|
|
|
WriteLog(ifail, ">>> propname = %s 、 propvalue = %s", propname, propvalue);
|
|
|
|
|
|
{
|
|
|
POM_AM__set_application_bypass(true);
|
|
|
ITKCALL(AOM_lock(tag_instance));
|
|
|
ITKCALL(ifail = POM_class_of_instance(tag_instance, &class_tag));
|
|
|
ITKCALL(ifail = POM_name_of_class(class_tag, &class_id));
|
|
|
ITKCALL(ifail = POM_attr_id_of_attr(propname, class_id, &attr_id));
|
|
|
ITKCALL(POM_refresh_instances_any_class(1, &tag_instance, POM_modify_lock));
|
|
|
ITKCALL(POM_set_attr_string(1, &tag_instance, attr_id, propvalue));
|
|
|
ITKCALL(POM_save_instances(1, &tag_instance, true));
|
|
|
ITKCALL(AOM_unlock(tag_instance));
|
|
|
DOFREE(class_id);
|
|
|
POM_AM__set_application_bypass(false);
|
|
|
}
|
|
|
//设置返回值
|
|
|
char server_string[10];
|
|
|
if (ifail == ITK_ok)
|
|
|
{
|
|
|
tc_strcpy(server_string, "true");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
tc_strcpy(server_string, "false");
|
|
|
}
|
|
|
|
|
|
*((char **)returnValue) = (char *)MEM_alloc((strlen(server_string) + 1) * sizeof(char));
|
|
|
tc_strcpy(*((char **)returnValue), server_string);
|
|
|
WriteLog(ifail, "> 执行结束 <设置不可修改的属性> ");
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
判断对象objtag是否属于type_name类型
|
|
|
*/
|
|
|
bool isTypeOf(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;
|
|
|
}
|
|
|
|
|
|
void initUserDir(char *userId) {
|
|
|
char logFileDir[MAX_PATH_LENGTH];
|
|
|
memset(logFileDir, 0, sizeof(logFileDir));
|
|
|
sprintf(logFileDir, "%s", getenv("TEMP"));
|
|
|
strcat(logFileDir, "\\tc_");
|
|
|
strcat(logFileDir, userId);
|
|
|
if (chdir(logFileDir) != ITK_ok) {
|
|
|
printf(">> 新建路径：%s\n", logFileDir);
|
|
|
mkdir(logFileDir);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool copyFile(const char *SRC, const char* DEST)
|
|
|
{
|
|
|
std::ifstream src(SRC, std::ios::binary);
|
|
|
std::ofstream dest(DEST, std::ios::binary);
|
|
|
dest << src.rdbuf();
|
|
|
return src && dest;
|
|
|
}
|
|
|
|
|
|
int WriteToFile(logical debug, FILE* file, const char* format, ...)
|
|
|
{
|
|
|
va_list arg;
|
|
|
char tmp[MAX_PRINTLINE_LENGTH];
|
|
|
|
|
|
//get the message
|
|
|
memset(tmp, 0, sizeof(tmp));
|
|
|
va_start(arg, format);
|
|
|
vsprintf(tmp, format, arg);
|
|
|
va_end(arg);
|
|
|
//print message to log file
|
|
|
WriteLog(debug, "写入内容：%s", tmp);
|
|
|
if (file)
|
|
|
{
|
|
|
fprintf(file, "%s", tmp);
|
|
|
fflush(file);
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
WriteLog(debug, "写入文件失败，文件不存在");
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void WriteLog(logical debug, const char* format, ...)
|
|
|
{
|
|
|
va_list arg;
|
|
|
char tmp[MAX_PRINTLINE_LENGTH];
|
|
|
char date_string[MAX_PATH_LENGTH];
|
|
|
time_t now;
|
|
|
struct tm *p;
|
|
|
|
|
|
//get the message
|
|
|
memset(tmp, 0, sizeof(tmp));
|
|
|
va_start(arg, format);
|
|
|
vsprintf(tmp, format, arg);
|
|
|
va_end(arg);
|
|
|
//----------print to command window for trace--------//
|
|
|
//printf("%s\n", tmp);
|
|
|
printf("%s\n", tmp);
|
|
|
//print message to log file
|
|
|
TC_write_syslog("%s\n", tmp);
|
|
|
}
|
|
|
|
|
|
void WriteLog2(logical debug, const char* format, ...)
|
|
|
{
|
|
|
va_list arg;
|
|
|
char tmp[MAX_PRINTLINE_LENGTH];
|
|
|
char date_string[MAX_PATH_LENGTH];
|
|
|
time_t now;
|
|
|
struct tm *p;
|
|
|
|
|
|
//get the message
|
|
|
memset(tmp, 0, sizeof(tmp));
|
|
|
va_start(arg, format);
|
|
|
vsprintf(tmp, format, arg);
|
|
|
va_end(arg);
|
|
|
//----------print to command window for trace--------//
|
|
|
//printf("%s\n", tmp);
|
|
|
printf("%s\n", tmp);
|
|
|
//print message to log file
|
|
|
if (!debug) {
|
|
|
return;
|
|
|
}
|
|
|
if (logFile)
|
|
|
{
|
|
|
time(&now);
|
|
|
//current_time(&status_now);
|
|
|
p = localtime(&now);
|
|
|
memset(date_string, 0, sizeof(date_string));
|
|
|
sprintf(date_string, "%02d:%02d:%02d", p->tm_hour, p->tm_min, p->tm_sec);
|
|
|
fprintf(logFile, "[%s] %s\n", date_string, tmp);
|
|
|
fflush(logFile);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
printf("*!Error!*: Log File Not Exist\n");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void CloseLog(void)
|
|
|
{
|
|
|
if (logFile)
|
|
|
{
|
|
|
fclose(logFile);
|
|
|
logFile = NULL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
int CreateTempFile(logical debug, const char* temp_path, char *file_name, char* ext, char **fullname, FILE **file)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
char logFileName[MAX_PATH_LENGTH];
|
|
|
|
|
|
if (chdir(temp_path) != ITK_ok) {
|
|
|
printf(">> 新建路径：%s", temp_path);
|
|
|
mkdir(temp_path);
|
|
|
}
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
//get session_uid to make sure the log file name unique
|
|
|
//POM_ask_session(&session_tag);
|
|
|
//ITK__convert_tag_to_uid(session_tag, &session_uid);
|
|
|
//get logFileName
|
|
|
sprintf(logFileName, "%s.%s", file_name, ext);
|
|
|
//printf("log file name: %s\n", logFileName);
|
|
|
|
|
|
*fullname = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
sprintf(*fullname, "%s\\%s", temp_path, logFileName);
|
|
|
|
|
|
//for(i = 0; _access((char *)logFileName, 4) == 0; i++)
|
|
|
/*{
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
sprintf(logFileName, "%s_%s_%s_%d.log", FunctionName, session_uid, date_string, i);
|
|
|
}
|
|
|
printf("final log file name: %s\n", logFileName);*/
|
|
|
|
|
|
//create log file
|
|
|
*file = fopen(logFileName, "a");
|
|
|
return ITK_ok;
|
|
|
//CLEANUP:;
|
|
|
//DOFREE(date_string);
|
|
|
/*if(session_uid!=NULL){
|
|
|
MEM_free(session_uid);
|
|
|
session_uid=NULL;
|
|
|
}*/
|
|
|
}
|
|
|
|
|
|
|
|
|
int CreateTempFile(logical debug, const char* temp_path, char *file_name, char* user_id, char* ext, char **fullname, FILE **file)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
//date_t status_now;
|
|
|
//char* date_string = NULL;
|
|
|
char date_string[MAX_PATH_LENGTH];
|
|
|
char logFileName[MAX_PATH_LENGTH];
|
|
|
//char* session_uid = NULL;
|
|
|
//tag_t session_tag = NULLTAG;
|
|
|
|
|
|
time_t now;
|
|
|
struct tm *p;
|
|
|
|
|
|
time(&now);
|
|
|
|
|
|
//logFile = NULL;
|
|
|
//current_time(&status_now);
|
|
|
p = localtime(&now);
|
|
|
|
|
|
memset(date_string, 0, sizeof(date_string));
|
|
|
sprintf(date_string, "%4d%02d%02d%02d%02d%02d", 1900 + p->tm_year, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
|
|
|
//sprintf(date_string, "%4d%02d%02d", 1900 + p->tm_year, p->tm_mon + 1, p->tm_mday);
|
|
|
//if( DATE_date_to_string( status_now, "%Y%m%d%H%M%S", &date_string) != ITK_ok )
|
|
|
//ifail = ITK_date_to_string (status_now, &date_string );
|
|
|
//if (ifail)
|
|
|
//{
|
|
|
// printf("!*ERROR*!: Failed to get current date time\n");
|
|
|
// goto CLEANUP;
|
|
|
//}
|
|
|
if (chdir(temp_path) != ITK_ok) {
|
|
|
printf(">> 新建路径：%s", temp_path);
|
|
|
mkdir(temp_path);
|
|
|
}
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
//get session_uid to make sure the log file name unique
|
|
|
//POM_ask_session(&session_tag);
|
|
|
//ITK__convert_tag_to_uid(session_tag, &session_uid);
|
|
|
//get logFileName
|
|
|
sprintf(logFileName, "%s_%s_%s.%s", file_name, user_id, date_string, ext);
|
|
|
//printf("log file name: %s\n", logFileName);
|
|
|
|
|
|
*fullname = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
sprintf(*fullname, "%s\\%s", temp_path, logFileName);
|
|
|
|
|
|
//for(i = 0; _access((char *)logFileName, 4) == 0; i++)
|
|
|
/*{
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
sprintf(logFileName, "%s_%s_%s_%d.log", FunctionName, session_uid, date_string, i);
|
|
|
}
|
|
|
printf("final log file name: %s\n", logFileName);*/
|
|
|
|
|
|
//create log file
|
|
|
*file = fopen(logFileName, "a");
|
|
|
return ITK_ok;
|
|
|
//CLEANUP:;
|
|
|
//DOFREE(date_string);
|
|
|
/*if(session_uid!=NULL){
|
|
|
MEM_free(session_uid);
|
|
|
session_uid=NULL;
|
|
|
}*/
|
|
|
}
|
|
|
|
|
|
|
|
|
int CreateUserFile(logical debug, char* FunctionName, char *userId, char **fullname, FILE **file)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
//date_t status_now;
|
|
|
//char* date_string = NULL;
|
|
|
char date_string[MAX_PATH_LENGTH];
|
|
|
char logFileDir[MAX_PATH_LENGTH];
|
|
|
char logFileName[MAX_PATH_LENGTH];
|
|
|
//char* session_uid = NULL;
|
|
|
//tag_t session_tag = NULLTAG;
|
|
|
|
|
|
time_t now;
|
|
|
struct tm *p;
|
|
|
|
|
|
time(&now);
|
|
|
|
|
|
//logFile = NULL;
|
|
|
//current_time(&status_now);
|
|
|
p = localtime(&now);
|
|
|
|
|
|
memset(date_string, 0, sizeof(date_string));
|
|
|
sprintf(date_string, "%4d%02d%02d%02d%02d%02d", 1900 + p->tm_year, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
|
|
|
//sprintf(date_string, "%4d%02d%02d", 1900 + p->tm_year, p->tm_mon + 1, p->tm_mday);
|
|
|
//if( DATE_date_to_string( status_now, "%Y%m%d%H%M%S", &date_string) != ITK_ok )
|
|
|
//ifail = ITK_date_to_string (status_now, &date_string );
|
|
|
//if (ifail)
|
|
|
//{
|
|
|
// printf("!*ERROR*!: Failed to get current date time\n");
|
|
|
// goto CLEANUP;
|
|
|
//}
|
|
|
|
|
|
memset(logFileDir, 0, sizeof(logFileDir));
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
//get log dir
|
|
|
sprintf(logFileDir, "%s", getenv("TEMP"));
|
|
|
strcat(logFileDir, "\\tc_");
|
|
|
strcat(logFileDir, userId);
|
|
|
//printf("\n log file dir: %s\n", logFileDir);
|
|
|
//try to change dir to TC_USER_LOG_DIR
|
|
|
if (chdir(logFileDir) != ITK_ok)
|
|
|
{
|
|
|
//not set TC_USER_LOG_DIR
|
|
|
//log in to default TC_LOG
|
|
|
memset(logFileDir, 0, sizeof(logFileDir));
|
|
|
sprintf(logFileDir, "%s", getenv("TC_LOG"));
|
|
|
WriteLog(debug, "TC_USER_LOG_DIR invalide, log file dir: %s", logFileDir);
|
|
|
//printf("\n TC_USER_LOG_DIR invalide, log file dir: %s\n", logFileDir);
|
|
|
if (chdir(logFileDir) != ITK_ok)
|
|
|
{
|
|
|
//still can not change to log dir
|
|
|
WriteLog(debug, "!*ERROR*!: Failed to change dir to TC_USER_LOG_DIR");
|
|
|
//printf("!*ERROR*!: Failed to change dir to TC_USER_LOG_DIR\n");
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//get session_uid to make sure the log file name unique
|
|
|
//POM_ask_session(&session_tag);
|
|
|
//ITK__convert_tag_to_uid(session_tag, &session_uid);
|
|
|
//get logFileName
|
|
|
sprintf(logFileName, "%s_%s_%s.txt", FunctionName, userId, date_string);
|
|
|
//printf("log file name: %s\n", logFileName);
|
|
|
|
|
|
*fullname = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
sprintf(*fullname, "%s\\%s", logFileDir, logFileName);
|
|
|
|
|
|
//for(i = 0; _access((char *)logFileName, 4) == 0; i++)
|
|
|
/*{
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
sprintf(logFileName, "%s_%s_%s_%d.log", FunctionName, session_uid, date_string, i);
|
|
|
}
|
|
|
printf("final log file name: %s\n", logFileName);*/
|
|
|
|
|
|
//create log file
|
|
|
*file = fopen(logFileName, "a");
|
|
|
return ITK_ok;
|
|
|
//CLEANUP:;
|
|
|
//DOFREE(date_string);
|
|
|
/*if(session_uid!=NULL){
|
|
|
MEM_free(session_uid);
|
|
|
session_uid=NULL;
|
|
|
}*/
|
|
|
}
|
|
|
|
|
|
|
|
|
void CreateLogFile(char* FunctionName, char *userId, char **fullname)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
//date_t status_now;
|
|
|
//char* date_string = NULL;
|
|
|
char date_string[MAX_PATH_LENGTH];
|
|
|
char logFileDir[MAX_PATH_LENGTH];
|
|
|
char logFileName[MAX_PATH_LENGTH];
|
|
|
//char* session_uid = NULL;
|
|
|
//tag_t session_tag = NULLTAG;
|
|
|
|
|
|
time_t now;
|
|
|
struct tm *p;
|
|
|
|
|
|
time(&now);
|
|
|
|
|
|
logFile = NULL;
|
|
|
//current_time(&status_now);
|
|
|
p = localtime(&now);
|
|
|
|
|
|
memset(date_string, 0, sizeof(date_string));
|
|
|
//sprintf(date_string,"%4d%02d%02d%02d%02d%02d",1900+p->tm_year,p->tm_mon+1 ,p->tm_mday ,p->tm_hour,p->tm_min ,p->tm_sec );
|
|
|
sprintf(date_string, "%4d%02d%02d", 1900 + p->tm_year, p->tm_mon + 1, p->tm_mday);
|
|
|
//if( DATE_date_to_string( status_now, "%Y%m%d%H%M%S", &date_string) != ITK_ok )
|
|
|
//ifail = ITK_date_to_string (status_now, &date_string );
|
|
|
//if (ifail)
|
|
|
//{
|
|
|
// printf("!*ERROR*!: Failed to get current date time\n");
|
|
|
// goto CLEANUP;
|
|
|
//}
|
|
|
|
|
|
memset(logFileDir, 0, sizeof(logFileDir));
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
//get log dir
|
|
|
sprintf(logFileDir, "%s", getenv("TEMP"));
|
|
|
strcat(logFileDir, "\\tc_");
|
|
|
strcat(logFileDir, userId);
|
|
|
//printf("\n log file dir: %s\n", logFileDir);
|
|
|
//try to change dir to TC_USER_LOG_DIR
|
|
|
if (chdir(logFileDir) != ITK_ok)
|
|
|
{
|
|
|
//not set TC_USER_LOG_DIR
|
|
|
//log in to default TC_LOG
|
|
|
memset(logFileDir, 0, sizeof(logFileDir));
|
|
|
sprintf(logFileDir, "%s", getenv("TC_LOG"));
|
|
|
printf("\n TC_USER_LOG_DIR invalide, log file dir: %s\n", logFileDir);
|
|
|
if (chdir(logFileDir) != ITK_ok)
|
|
|
{
|
|
|
//still can not change to log dir
|
|
|
printf("!*ERROR*!: Failed to change dir to TC_USER_LOG_DIR\n");
|
|
|
goto CLEANUP;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//get session_uid to make sure the log file name unique
|
|
|
//POM_ask_session(&session_tag);
|
|
|
//ITK__convert_tag_to_uid(session_tag, &session_uid);
|
|
|
//get logFileName
|
|
|
sprintf(logFileName, "%s_%s_%s.log", FunctionName, userId, date_string);
|
|
|
//printf("log file name: %s\n", logFileName);
|
|
|
|
|
|
*fullname = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
sprintf(*fullname, "%s\\%s", logFileDir, logFileName);
|
|
|
|
|
|
//for(i = 0; _access((char *)logFileName, 4) == 0; i++)
|
|
|
/*{
|
|
|
memset(logFileName, 0, sizeof(logFileName));
|
|
|
sprintf(logFileName, "%s_%s_%s_%d.log", FunctionName, session_uid, date_string, i);
|
|
|
}
|
|
|
printf("final log file name: %s\n", logFileName);*/
|
|
|
|
|
|
//create log file
|
|
|
logFile = fopen(logFileName, "a");
|
|
|
|
|
|
CLEANUP:;
|
|
|
//DOFREE(date_string);
|
|
|
/*if(session_uid!=NULL){
|
|
|
MEM_free(session_uid);
|
|
|
session_uid=NULL;
|
|
|
}*/
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void set_bypass(logical bypass)
|
|
|
{
|
|
|
//AM__set_application_bypass(bypass);
|
|
|
POM_AM__set_application_bypass(bypass);
|
|
|
}
|
|
|
|
|
|
bool isClass(tag_t class_id, char *className) {
|
|
|
tag_t *pclass_ids = NULL;
|
|
|
char* class_name = NULL;
|
|
|
int pclass_count = 0, ifail = ITK_ok;
|
|
|
ITKCALL(POM_name_of_class(class_id, &class_name));
|
|
|
printf("class name = %s\n", class_name);
|
|
|
bool isType = false;
|
|
|
if (strcmp(class_name, className) == 0) {
|
|
|
isType = true;
|
|
|
}
|
|
|
DOFREE(class_name);
|
|
|
if (isType) {
|
|
|
return true;
|
|
|
}
|
|
|
ITKCALL(ifail = POM_superclasses_of_class(class_id, &pclass_count, &pclass_ids));
|
|
|
for (int i = 0; i < pclass_count; i++) {
|
|
|
isType = isClass(pclass_ids[i], className);
|
|
|
if (isType) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool isType(tag_t item, char* type) {
|
|
|
tag_t class_id = NULLTAG, *pclass_ids = NULL;
|
|
|
char* class_name = NULL;
|
|
|
int pclass_count = 0, ifail = ITK_ok;
|
|
|
|
|
|
ITKCALL(POM_class_of_instance(item, &class_id));
|
|
|
return isClass(class_id, type);
|
|
|
}
|
|
|
|
|
|
void deleteFile(bool debug, char *path) {
|
|
|
//删除文件
|
|
|
if (remove(path) == 0) {
|
|
|
WriteLog(debug, "删除文件成功：%s", path);
|
|
|
WriteLog2(debug, "删除文件成功：%s", path);
|
|
|
}
|
|
|
else {
|
|
|
WriteLog(debug, "删除文件失败：%s", path);
|
|
|
WriteLog2(debug, "删除文件失败：%s", path);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
int readError(bool debug, char *errFilePath, int errCode) {
|
|
|
fstream _file;
|
|
|
_file.open(errFilePath, ios::in);
|
|
|
if (_file) {
|
|
|
WriteLog(debug, "找到异常临时文件：%s", errFilePath);
|
|
|
ifstream fin(errFilePath);
|
|
|
string s;
|
|
|
while (getline(fin, s))
|
|
|
{
|
|
|
WriteLog(debug, s.c_str());
|
|
|
EMH_store_error_s1(EMH_severity_error, errCode, s.c_str());
|
|
|
}
|
|
|
_file.close();
|
|
|
return errCode;
|
|
|
}
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
|
|
|
//导入数据集
|
|
|
int import_dataset_file(tag_t dataset, const char *ref_name, char *ext, char *fullfilename, char *original_name)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t new_file_tag = NULLTAG;
|
|
|
IMF_file_t file_descriptor = NULL;
|
|
|
AOM_refresh(dataset, FALSE);
|
|
|
char *new_file_name = NULL;
|
|
|
char new_ds_name[WSO_name_size_c + 1] = "";
|
|
|
char *filename = NULL;
|
|
|
new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);
|
|
|
filename = strrchr(fullfilename, '\\') + 1;
|
|
|
if (filename == NULL)
|
|
|
return ITK_ok;
|
|
|
|
|
|
ITKCALL(ifail = IMF_import_file(fullfilename, new_file_name, SS_TEXT, &new_file_tag, &file_descriptor));
|
|
|
if (ifail != ITK_ok) {
|
|
|
ITKCALL(ifail = IMF_import_file(fullfilename, new_file_name, SS_BINARY, &new_file_tag, &file_descriptor));
|
|
|
}
|
|
|
ITKCALL(ifail = IMF_set_original_file_name2(new_file_tag, original_name));
|
|
|
|
|
|
ITKCALL(ifail = IMF_close_file(file_descriptor));
|
|
|
ITKCALL(ifail = AOM_save(new_file_tag));
|
|
|
AOM_unlock(new_file_tag);
|
|
|
ITKCALL(ifail = AOM_refresh(new_file_tag, FALSE));
|
|
|
|
|
|
ITKCALL(AOM_lock(dataset));
|
|
|
if (ifail != ITK_ok) { return ifail; }
|
|
|
ITKCALL(ifail = RES_checkout2(dataset, "import file", NULL, getenv("TEMP"), RES_EXCLUSIVE_RESERVE));
|
|
|
if (ifail != ITK_ok) { return ifail; }
|
|
|
ITKCALL(ifail = AE_remove_dataset_named_ref2(dataset, ref_name));
|
|
|
ITKCALL(ifail = AOM_save(dataset));
|
|
|
|
|
|
ITKCALL(ifail = AE_add_dataset_named_ref2(dataset, ref_name, AE_PART_OF, new_file_tag));
|
|
|
AOM_save(dataset);
|
|
|
ITKCALL(ifail = RES_checkin(dataset));
|
|
|
AOM_unlock(dataset);
|
|
|
|
|
|
//ITKCALL( AOM_refresh( dataset, FALSE ) );
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
//导入数据集
|
|
|
int import_dataset_file_binary(tag_t dataset, const char* temp_path, const char *ref_name, char *ext, char *fullfilename, char *original_name)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t new_file_tag = NULLTAG;
|
|
|
IMF_file_t file_descriptor = NULL;
|
|
|
AOM_refresh(dataset, FALSE);
|
|
|
char *new_file_name = NULL;
|
|
|
char new_ds_name[WSO_name_size_c + 1] = "";
|
|
|
char *filename = NULL;
|
|
|
new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);
|
|
|
filename = strrchr(fullfilename, '\\') + 1;
|
|
|
if (filename == NULL)
|
|
|
return ITK_ok;
|
|
|
ITKCALL(ifail = IMF_import_file(fullfilename, new_file_name, SS_BINARY, &new_file_tag, &file_descriptor));
|
|
|
ITKCALL(ifail = IMF_set_original_file_name2(new_file_tag, original_name));
|
|
|
|
|
|
ITKCALL(ifail = IMF_close_file(file_descriptor));
|
|
|
ITKCALL(ifail = AOM_save(new_file_tag));
|
|
|
AOM_unlock(new_file_tag);
|
|
|
ITKCALL(ifail = AOM_refresh(new_file_tag, FALSE));
|
|
|
//添加至命名引用
|
|
|
ITKCALL(ifail = AOM_lock(dataset));
|
|
|
if (ifail != ITK_ok) { return ifail; }
|
|
|
ITKCALL(ifail = RES_checkout2(dataset, "import file", NULL, temp_path, RES_EXCLUSIVE_RESERVE));
|
|
|
if (ifail != ITK_ok) { return ifail; }
|
|
|
ITKCALL(ifail = AE_remove_dataset_named_ref2(dataset, ref_name));
|
|
|
if (ifail != ITK_ok) { return ifail; }
|
|
|
ITKCALL(ifail = AOM_save(dataset));
|
|
|
ITKCALL(ifail = AE_add_dataset_named_ref2(dataset, ref_name, AE_PART_OF, new_file_tag));
|
|
|
AOM_save(dataset);
|
|
|
ITKCALL(ifail = RES_checkin(dataset));
|
|
|
AOM_unlock(dataset);
|
|
|
//ITKCALL( AOM_refresh( dataset, FALSE ) );
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
|
|
|
void Split(string strArg, char spliter, vector<string> &ans)
|
|
|
{
|
|
|
ans.clear();
|
|
|
size_t index0 = 0;
|
|
|
string one_arg;
|
|
|
if (strArg.find_first_not_of(' ') == string::npos)
|
|
|
strArg = "";
|
|
|
while (strArg.size() > 0)
|
|
|
{
|
|
|
index0 = strArg.find_first_of(spliter);
|
|
|
if (index0 != string::npos)
|
|
|
{
|
|
|
one_arg = strArg.substr(0, index0);
|
|
|
strArg = strArg.substr(index0 + 1);
|
|
|
ans.push_back(one_arg);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ans.push_back(strArg);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void Split(string strArg, string spliter, vector<string> &ans)
|
|
|
{
|
|
|
ans.clear();
|
|
|
size_t index0 = 0;
|
|
|
string one_arg;
|
|
|
if (strArg.find_first_not_of(' ') == string::npos)
|
|
|
strArg = "";
|
|
|
while (strArg.size() > 0)
|
|
|
{
|
|
|
index0 = strArg.find_first_of(spliter);
|
|
|
if (index0 != string::npos)
|
|
|
{
|
|
|
one_arg = strArg.substr(0, index0);
|
|
|
strArg = strArg.substr(index0 + 1);
|
|
|
ans.push_back(one_arg);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ans.push_back(strArg);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool inArray(vector<string> types, string type) {
|
|
|
int len = types.size();
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
if (strcmp(types[i].c_str(), type.c_str()) == 0) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
int getIndexInArray(vector<string> types, string type) {
|
|
|
int len = types.size();
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
if (strcmp(types[i].c_str(), type.c_str()) == 0) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
bool CheckType(string config, char* type, char spliter) {
|
|
|
vector<string> types;
|
|
|
Split(config, spliter, types);
|
|
|
int len = types.size();
|
|
|
for (int i = 0; i < len; i++) {
|
|
|
if (strcmp(types[i].c_str(), type) == 0) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
int GetProcessTargets(bool debug, int att_cnt, tag_t *attachments, vector<tag_t> &targets, char* formType, char splitter) {
|
|
|
char *object_name = NULL, *object_type = NULL;
|
|
|
int ifail = ITK_ok;
|
|
|
WriteLog(debug, "开始检索流程目标对象：%d", att_cnt);
|
|
|
for (int i = 0; i < att_cnt; i++) {
|
|
|
ITKCALL(ifail = WSOM_ask_name2(attachments[i], &object_name));
|
|
|
ITKCALL(ifail = WSOM_ask_object_type2(attachments[i], &object_type));
|
|
|
WriteLog(debug, "%d. 流程对象<%s>，类型：%s", i + 1, object_name, object_type);
|
|
|
//if (strcmp(object_type, TYPE_ITEM_PZJ.c_str()) == 0) {
|
|
|
if (CheckType(formType, object_type, splitter)) {
|
|
|
targets.push_back(attachments[i]);
|
|
|
}
|
|
|
DOFREE(object_name);
|
|
|
DOFREE(object_type);
|
|
|
}
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
|
|
|
int findUser(bool debug, string userStr, tag_t *user_tag) {
|
|
|
int ind1 = userStr.find_first_of('(');
|
|
|
int ind2 = userStr.find_first_of(')');
|
|
|
WriteLog(debug, "查询用户：%s", userStr.c_str());
|
|
|
if (ind1 != string::npos&&ind2 != string::npos&&ind1 < ind2) {
|
|
|
userStr = userStr.substr(ind1 + 1, ind2 - ind1 - 1);
|
|
|
WriteLog(debug, ">> 用户id: %s", userStr.c_str());
|
|
|
}
|
|
|
int ifail = ITK_ok;
|
|
|
ITKCALL(ifail = SA_find_user2(userStr.c_str(), user_tag));
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
int GetBomLinePropString(bool debug, tag_t line, char* propName, int errCode, char** attr_val) {
|
|
|
int attribute_id = 0, ifail = ITK_ok;
|
|
|
ITKCALL(ifail = BOM_line_look_up_attribute(propName, &attribute_id));
|
|
|
if (attribute_id == 0) {
|
|
|
WriteLog(debug, "BOM行属性不存在：%s", propName);
|
|
|
EMH_store_error_s2(EMH_severity_error, errCode, "BOM行属性不存在", propName);
|
|
|
return errCode;
|
|
|
}
|
|
|
else {
|
|
|
ITKCALL(ifail = BOM_line_ask_attribute_string(line, attribute_id, &*attr_val));
|
|
|
return ifail;
|
|
|
}
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
|
|
|
int GetStringProp(tag_t obj, char* propName, char** attr_val) {
|
|
|
return AOM_ask_value_string(obj, propName, &*attr_val);
|
|
|
}
|
|
|
|
|
|
void CreateDirectoryAndFile(const char* directory_path, const char* file_path) {
|
|
|
// 将目录路径转换为宽字符串
|
|
|
wchar_t w_directory_path[MAX_PATH];
|
|
|
MultiByteToWideChar(CP_UTF8, 0, directory_path, -1, w_directory_path, MAX_PATH);
|
|
|
|
|
|
// 检查文件夹是否存在，如果不存在则创建
|
|
|
DWORD dwAttrib = GetFileAttributes(w_directory_path);
|
|
|
if (dwAttrib == INVALID_FILE_ATTRIBUTES || !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) {
|
|
|
// 文件夹不存在，尝试创建
|
|
|
if (_wmkdir(w_directory_path) != 0) {
|
|
|
perror("Failed to create directory.");
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 将文件路径转换为宽字符串
|
|
|
wchar_t w_file_path[MAX_PATH];
|
|
|
MultiByteToWideChar(CP_UTF8, 0, file_path, -1, w_file_path, MAX_PATH);
|
|
|
|
|
|
// 检查文件是否存在，如果不存在则创建
|
|
|
FILE* file = fopen(file_path, "r");
|
|
|
if (file == NULL) {
|
|
|
// 文件不存在，尝试创建并打开（这里以追加模式打开）
|
|
|
file = fopen(file_path, "a+");
|
|
|
if (file == NULL) {
|
|
|
perror("Failed to create and open file.");
|
|
|
return;
|
|
|
}
|
|
|
fclose(file); // 关闭刚创建的文件
|
|
|
}
|
|
|
else {
|
|
|
fclose(file); // 如果文件已存在，则关闭打开的文件句柄
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool isRev(char* object_type) {
|
|
|
if (((strstr(object_type, "Revision") != NULL) || (strstr(object_type, "revision") != NULL))
|
|
|
&& (strstr(object_type, "Master") == NULL) && (strstr(object_type, "master") == NULL)
|
|
|
&& (strstr(object_type, "BOM") == NULL) && (strstr(object_type, "bom") == NULL) && (strstr(object_type, "Bom") == NULL)) {
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
int GetBomView(tag_t rev_tag, char* viewtype, tag_t *bomView, tag_t *bomBVR, bool debug)
|
|
|
{
|
|
|
WriteLog(debug, "开始获取BOM视图：%s", viewtype);
|
|
|
int ifail = ITK_ok, bvr_count = 0;
|
|
|
tag_t *bvr_list = NULL, bom_view = NULLTAG, view_type = NULLTAG;
|
|
|
*bomBVR = NULLTAG;
|
|
|
*bomView = NULLTAG;
|
|
|
ITKCALL(ITEM_rev_list_bom_view_revs(rev_tag, &bvr_count, &bvr_list));
|
|
|
if (bvr_count > 0)
|
|
|
{
|
|
|
for (int i = 0; i < bvr_count; i++)
|
|
|
{
|
|
|
ITKCALL(PS_ask_bom_view_of_bvr(bvr_list[i], &bom_view));
|
|
|
|
|
|
ITKCALL(PS_ask_bom_view_type(bom_view, &view_type));
|
|
|
//ITKCALL( PS_find_view_type(bom_view, &view_type));
|
|
|
char *view_type_name = NULL;
|
|
|
ITKCALL(PS_ask_view_type_name(view_type, &view_type_name));
|
|
|
WriteLog(debug, "找到视图 类型：%s", view_type_name);
|
|
|
if (tc_strcmp(view_type_name, viewtype) == 0)
|
|
|
{
|
|
|
*bomBVR = bvr_list[i];
|
|
|
*bomView = bom_view;
|
|
|
}
|
|
|
DOFREE(view_type_name);
|
|
|
}
|
|
|
}
|
|
|
//else {
|
|
|
// WriteLog(debug, "没有找到bvr开始进行创建");
|
|
|
// tag_t bv = NULLTAG, bvr = NULLTAG, item_tag = NULLTAG;
|
|
|
// int bvCnt = 0;
|
|
|
// tag_t* bvTags = NULL;
|
|
|
|
|
|
|
|
|
// ITKCALL(ifail = ITEM_ask_item_of_rev(rev_tag, &item_tag));
|
|
|
|
|
|
|
|
|
// tag_t tWindow = NULLTAG;
|
|
|
// ITKCALL(BOM_create_window(&tWindow));
|
|
|
|
|
|
// tag_t tTopLine = NULLTAG;
|
|
|
// ITKCALL(BOM_set_window_top_line(tWindow, item_tag, NULLTAG, NULLTAG, &tTopLine));
|
|
|
|
|
|
// //查找原BOM视图
|
|
|
// ITKCALL(ifail=ITEM_list_bom_views(item_tag, &bvCnt, &bvTags));
|
|
|
// if (bvCnt > 0) {
|
|
|
// WriteLog(debug, "对象已存在BOM视图：%d", bvCnt);
|
|
|
// bv = bvTags[0];
|
|
|
// }
|
|
|
// ITKCALL(AOM_lock(item_tag));
|
|
|
// if (bv == NULLTAG) {
|
|
|
// ITKCALL(ifail=PS_create_bom_view(NULLTAG, "", "", item_tag, &bv));
|
|
|
// if (ifail != ITK_ok) {
|
|
|
// ITKCALL(AOM_unlock(item_tag));
|
|
|
// return ifail;
|
|
|
// }
|
|
|
// ITKCALL(AOM_save(bv));
|
|
|
// }
|
|
|
// ITKCALL(ifail=PS_create_bvr(bv, "", "", false, rev_tag, &bvr));
|
|
|
// if (ifail != ITK_ok) {
|
|
|
// ITKCALL(AOM_unlock(item_tag));
|
|
|
// return ifail;
|
|
|
// }
|
|
|
// ITKCALL(AOM_save(bvr));
|
|
|
// ITKCALL(AOM_save(bv));
|
|
|
// ITKCALL(AOM_save(item_tag));
|
|
|
|
|
|
// tag_t tChildLine = NULLTAG;
|
|
|
|
|
|
// ITKCALL(BOM_save_window(tWindow));
|
|
|
// ITKCALL(BOM_close_window(tWindow));
|
|
|
|
|
|
// ITKCALL(AOM_unlock(item_tag));
|
|
|
// *bomBVR = bvr;
|
|
|
// *bomView = bv;
|
|
|
// WriteLog(debug, "bvr新建完成");
|
|
|
// DOFREE(bvTags);
|
|
|
|
|
|
//}
|
|
|
DOFREE(bvr_list);
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
bool propExist(bool debug, tag_t obj, const char *propName) {
|
|
|
tag_t clTag = NULLTAG, *superClass = NULL;
|
|
|
char *clName = NULL;
|
|
|
int ifail = ITK_ok, cnt = 0;
|
|
|
logical exists = false;
|
|
|
ITKCALL(ifail = POM_class_of_instance(obj, &clTag));
|
|
|
if (ifail != ITK_ok) { return false; }
|
|
|
ITKCALL(ifail = POM_name_of_class(clTag, &clName));
|
|
|
if (ifail != ITK_ok) { return false; }
|
|
|
WriteLog(debug, ">> 检查%s属性: %s", clName, propName);
|
|
|
ITKCALL(ifail = POM_attr_exists(propName, clName, &exists));
|
|
|
if (ifail != ITK_ok) { return false; }
|
|
|
DOFREE(clName);
|
|
|
if (exists) {
|
|
|
//WriteLog(debug,"属性存在");
|
|
|
return exists;
|
|
|
}
|
|
|
ITKCALL(ifail = POM_superclasses_of_class(clTag, &cnt, &superClass));
|
|
|
for (int i = 0; i < cnt; i++) {
|
|
|
ITKCALL(ifail = POM_name_of_class(superClass[i], &clName));
|
|
|
if (ifail != ITK_ok) { return false; }
|
|
|
WriteLog(debug, ">> 检查%s属性: %s", clName, propName);
|
|
|
ITKCALL(ifail = POM_attr_exists(propName, clName, &exists));
|
|
|
DOFREE(clName);
|
|
|
if (exists) {
|
|
|
//WriteLog(debug, "属性存在");
|
|
|
return exists;
|
|
|
}
|
|
|
}
|
|
|
WriteLog(debug, "属性不存在");
|
|
|
return exists;
|
|
|
}
|
|
|
|
|
|
char* U2G(const char* utf8)
|
|
|
{
|
|
|
int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
|
|
|
wchar_t* wstr = new wchar_t[len + 1];
|
|
|
memset(wstr, 0, len + 1);
|
|
|
MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
|
|
|
len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
|
|
|
char* str = new char[len + 1];
|
|
|
memset(str, 0, len + 1);
|
|
|
WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
|
|
|
if (wstr) delete[] wstr;
|
|
|
return str;
|
|
|
}
|
|
|
|
|
|
|
|
|
char* G2U(const char* gb2312)
|
|
|
{
|
|
|
int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
|
|
|
wchar_t* wstr = new wchar_t[len + 1];
|
|
|
memset(wstr, 0, len + 1);
|
|
|
MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
|
|
|
len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
|
|
|
char* str = new char[len + 1];
|
|
|
memset(str, 0, len + 1);
|
|
|
WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
|
|
|
if (wstr) delete[] wstr;
|
|
|
return str;
|
|
|
}
|
|
|
|
|
|
int getPrefStrings(const char *preference, TC_preference_search_scope_t scope, vector<string> &pref_vec)
|
|
|
{
|
|
|
int ifail = ITK_ok, i = 0, j = 0, k = 0, num = 0;
|
|
|
char **values;
|
|
|
TC_preference_search_scope_t old_scope;
|
|
|
//ITKCALL(ifail = PREF_ask_search_scope(&old_scope));
|
|
|
//ITKCALL(ifail = PREF_set_search_scope(scope));
|
|
|
//ITKCALL(ifail = PREF_ask_char_values(preference, &num, &values));
|
|
|
ITKCALL(ifail = PREF_ask_char_values_at_location(preference, scope, &num, &values));
|
|
|
if (ifail != ITK_ok) {
|
|
|
return ifail;
|
|
|
}
|
|
|
for (i = 0; i < num; i++)
|
|
|
{
|
|
|
pref_vec.push_back(values[i]);
|
|
|
}
|
|
|
DOFREE(values);
|
|
|
//ITKCALL(ifail = PREF_set_search_scope(old_scope));
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
int getPrefStrings2(const char *preference, TC_preference_search_scope_t scope, char splitter, vector<string> &pref_vec)
|
|
|
{
|
|
|
int ifail = ITK_ok, i = 0, j = 0, k = 0, num = 0;
|
|
|
char **values;
|
|
|
TC_preference_search_scope_t old_scope;
|
|
|
//ITKCALL(ifail = PREF_ask_search_scope(&old_scope));
|
|
|
//ITKCALL(ifail = PREF_set_search_scope(scope));
|
|
|
//ITKCALL(ifail = PREF_ask_char_values(preference, &num, &values));
|
|
|
ITKCALL(ifail = PREF_ask_char_values_at_location(preference, scope, &num, &values));
|
|
|
if (ifail != ITK_ok) {
|
|
|
return ifail;
|
|
|
}
|
|
|
for (i = 0; i < num; i++)
|
|
|
{
|
|
|
vector<string> split;
|
|
|
Split(values[i], splitter, split);
|
|
|
for each (string val in split)
|
|
|
{
|
|
|
pref_vec.push_back(val);
|
|
|
}
|
|
|
}
|
|
|
DOFREE(values);
|
|
|
//ITKCALL(ifail = PREF_set_search_scope(old_scope));
|
|
|
return ifail;
|
|
|
}
|
|
|
|
|
|
|
|
|
//导出数据集文件
|
|
|
int export_dataset_file_to_dir(bool debug, tag_t dataset, const char *ref_name, const char* temp_path, char *ext, char **filename, char **original_name)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t ref_object = NULLTAG,
|
|
|
datasettype = NULLTAG,
|
|
|
new_ds = NULLTAG,
|
|
|
tool = NULLTAG,
|
|
|
folder_tag = NULLTAG,
|
|
|
spec_dataset_rev = NULLTAG;
|
|
|
AE_reference_type_t reference_type;
|
|
|
tag_t new_file_tag = NULLTAG;
|
|
|
IMF_file_t file_descriptor;
|
|
|
char *target_ds_name = NULL;
|
|
|
char *new_file_name;
|
|
|
WSOM_ask_name2(dataset, &target_ds_name);
|
|
|
WriteLog(debug, "开始从数据集<%s>下载文件", target_ds_name);
|
|
|
DOFREE(target_ds_name);
|
|
|
*filename = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
*original_name = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
strcpy(*filename, "");
|
|
|
AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev);
|
|
|
AE_ask_dataset_named_ref2(dataset, ref_name, &reference_type, &ref_object);
|
|
|
if (ref_object == NULLTAG)
|
|
|
{
|
|
|
WriteLog(debug, "文件引用为空");
|
|
|
return 1;
|
|
|
}
|
|
|
if (reference_type == AE_PART_OF)
|
|
|
{
|
|
|
char *pathname2 = NULL;
|
|
|
IMF_ask_file_pathname2(ref_object, SS_WNT_MACHINE, &pathname2);
|
|
|
DOFREE(pathname2);
|
|
|
char *origin_file_name2 = NULL;
|
|
|
IMF_ask_original_file_name2(ref_object, &origin_file_name2);
|
|
|
strcpy(*original_name, origin_file_name2);
|
|
|
DOFREE(origin_file_name2);
|
|
|
char new_ds_name[WSO_name_size_c + 1] = "";
|
|
|
char *new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);
|
|
|
char temp_file[SS_MAXPATHLEN] = "";
|
|
|
strcpy(temp_file, temp_path);
|
|
|
strcat(temp_file, "\\");
|
|
|
strcat(temp_file, new_file_name);
|
|
|
WriteLog(debug, "临时文件路径：%s", temp_file);
|
|
|
if ((_access(temp_file, 0)) != -1) {
|
|
|
if (!remove(temp_file)) {
|
|
|
remove(temp_file);
|
|
|
}
|
|
|
}
|
|
|
ITKCALL(ifail = IMF_export_file(ref_object, temp_file));
|
|
|
strcpy(*filename, temp_file);
|
|
|
return ifail;
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
bool exists_test0(const std::string& name) {
|
|
|
ifstream f(name.c_str());
|
|
|
return f.good();
|
|
|
}
|
|
|
|
|
|
//导出数据集文件
|
|
|
int export_dataset_file(tag_t dataset, char *ref_name, char *ext, char **filename, char **original_name)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t ref_object = NULLTAG,
|
|
|
datasettype = NULLTAG,
|
|
|
new_ds = NULLTAG,
|
|
|
tool = NULLTAG,
|
|
|
folder_tag = NULLTAG,
|
|
|
spec_dataset_rev = NULLTAG;
|
|
|
AE_reference_type_t reference_type;
|
|
|
tag_t new_file_tag = NULLTAG;
|
|
|
IMF_file_t file_descriptor;
|
|
|
char new_ds_name[WSO_name_size_c + 1] = "";
|
|
|
char *new_file_name;
|
|
|
|
|
|
*filename = (char *)MEM_alloc(sizeof(char) * 5120);
|
|
|
*original_name = (char *)MEM_alloc(sizeof(char) * 5120);
|
|
|
strcpy(*filename, "");
|
|
|
AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev);
|
|
|
AE_ask_dataset_named_ref2(dataset, ref_name, &reference_type, &ref_object);
|
|
|
if (ref_object == NULLTAG)
|
|
|
{
|
|
|
//ECHO("ref_object is NULLTAG\n");
|
|
|
return 1;
|
|
|
}
|
|
|
//WriteLog("\reference_type=%d\n",reference_type);
|
|
|
if (reference_type == AE_PART_OF)
|
|
|
{
|
|
|
char *pathname = NULL;
|
|
|
IMF_ask_file_pathname2(ref_object, SS_WNT_MACHINE, &pathname);
|
|
|
char *origin_file_name = NULL;
|
|
|
IMF_ask_original_file_name2(ref_object, &origin_file_name);
|
|
|
strcpy(*original_name, origin_file_name);
|
|
|
char new_ds_name[WSO_name_size_c + 1] = "";
|
|
|
char *new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);
|
|
|
char *temp_dir = getenv("TEMP");
|
|
|
char temp_file[SS_MAXPATHLEN] = "";
|
|
|
strcpy(temp_file, temp_dir);
|
|
|
strcat(temp_file, "\\");
|
|
|
strcat(temp_file, new_file_name);
|
|
|
//ECHO("temp_file=%s\n", temp_file);
|
|
|
|
|
|
IMF_export_file(ref_object, temp_file);
|
|
|
strcpy(*filename, temp_file);
|
|
|
}
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
|
|
|
|
|
|
//导出数据集文件
|
|
|
int export_dataset_file(bool debug, tag_t dataset, const char *ref_name, char* userId, char *ext, char **filename, char **original_name)
|
|
|
{
|
|
|
int ifail = ITK_ok;
|
|
|
tag_t ref_object = NULLTAG,
|
|
|
datasettype = NULLTAG,
|
|
|
new_ds = NULLTAG,
|
|
|
tool = NULLTAG,
|
|
|
folder_tag = NULLTAG,
|
|
|
spec_dataset_rev = NULLTAG;
|
|
|
AE_reference_type_t reference_type;
|
|
|
tag_t new_file_tag = NULLTAG;
|
|
|
IMF_file_t file_descriptor;
|
|
|
char *target_ds_name = NULL;
|
|
|
char *new_file_name;
|
|
|
WSOM_ask_name2(dataset, &target_ds_name);
|
|
|
WriteLog(debug, "开始从数据集<%s>下载文件", target_ds_name);
|
|
|
DOFREE(target_ds_name);
|
|
|
*filename = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
*original_name = (char *)MEM_alloc(sizeof(char) * 512);
|
|
|
strcpy(*filename, "");
|
|
|
AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev);
|
|
|
AE_ask_dataset_named_ref2(dataset, ref_name, &reference_type, &ref_object);
|
|
|
if (ref_object == NULLTAG)
|
|
|
{
|
|
|
WriteLog(debug, "文件引用为空");
|
|
|
return 1;
|
|
|
}
|
|
|
if (reference_type == AE_PART_OF)
|
|
|
{
|
|
|
char *pathname2 = NULL;
|
|
|
IMF_ask_file_pathname2(ref_object, SS_WNT_MACHINE, &pathname2);
|
|
|
DOFREE(pathname2);
|
|
|
char *origin_file_name2 = NULL;
|
|
|
IMF_ask_original_file_name2(ref_object, &origin_file_name2);
|
|
|
strcpy(*original_name, origin_file_name2);
|
|
|
DOFREE(origin_file_name2);
|
|
|
char new_ds_name[WSO_name_size_c + 1] = "";
|
|
|
char *new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);
|
|
|
char *temp_dir = getenv("TEMP");
|
|
|
char temp_file[SS_MAXPATHLEN] = "";
|
|
|
strcpy(temp_file, temp_dir);
|
|
|
strcat(temp_file, "\\tc_");
|
|
|
strcat(temp_file, userId);
|
|
|
strcat(temp_file, "\\");
|
|
|
strcat(temp_file, new_file_name);
|
|
|
WriteLog(debug, "临时文件路径：%s", temp_file);
|
|
|
|
|
|
if ((_access(temp_file, 0)) != -1) {
|
|
|
if (!remove(temp_file)) {
|
|
|
remove(temp_file);
|
|
|
}
|
|
|
}
|
|
|
IMF_export_file(ref_object, temp_file);
|
|
|
strcpy(*filename, temp_file);
|
|
|
return ITK_ok;
|
|
|
}
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
//得到文件中的所有内容
|
|
|
char* getfileall(const char* fname)
|
|
|
{
|
|
|
FILE* fp;
|
|
|
char* str;
|
|
|
char txt[1000];
|
|
|
int filesize;
|
|
|
//打开一个文件
|
|
|
if ((fp = fopen(fname, "r")) == NULL) {
|
|
|
printf("打开文件%s错误\n", fname);
|
|
|
return NULL;
|
|
|
}
|
|
|
//将文件指针移到末尾
|
|
|
fseek(fp, 0, SEEK_END);
|
|
|
filesize = ftell(fp);//通过ftell函数获得指针到文件头的偏移字节数。
|
|
|
|
|
|
str = (char*)malloc(filesize);//动态分配str内存
|
|
|
// str=malloc(filesize);//动态分配str内存
|
|
|
str[0] = 0;//字符串置空
|
|
|
// memset(str,filesize*sizeof(char),0);//清空数组,字符串置空第二种用法
|
|
|
rewind(fp);
|
|
|
|
|
|
while ((fgets(txt, 1000, fp)) != NULL) {//循环读取1000字节,如果没有数据则退出循环
|
|
|
strcat(str, txt);//拼接字符串
|
|
|
}
|
|
|
fclose(fp);
|
|
|
return str;
|
|
|
} |
