convapi.pc

unix 下用pro*c tuxedo 开发的东西

		}
		trim(zfjbh);
/*		strcat(messagesj,zfjbh);
		strcat(messagesj,",");
		itoa(num_zjfs,tempstr,10);
		trim(tempstr);
		strcat(messagesj,tempstr);
		strcat(messagesj,",");
*/
		sprintf(messagesj,"%s%s,%ld,",messagesj,zfjbh,num_zjfs);
	}
	strcat(messagesj,"\n");
	EXEC SQL CLOSE cur_pdsj;
	return(0);
}

int CallConvertPDYS( long int key,char *sjbh )
{
	char tempstr[MID_LEN];
	char tempstring[MID_LEN];
	char temp_bkdh[MID_LEN];
	char ch[2];
	char tempstrqdqb[MID_LEN];
	char jsfs[SHORT_LEN];
	char temp,tmp_jsfs;
	char fbkjbh[3];
	char file_locat[MID_LEN];
	char SJ_name[MID_LEN];
	char SJ_name_no[MID_LEN];
	int  i, avoid_repeat;
	int  tempnum, retcode,flag ;
	struct stPDYSSMDBRec PDSMDB;
	short dingj_id,dyzs_id,dyk_id,lszs_id,lsk_id,qdqb_id,zdqa_id,zdqb_id;
	
	ch[0]='\0';
	EXEC SQL WHENEVER SQLERROR DO sqlerror();
	EXEC SQL SELECT * INTO
		:PDSMDB.bkdh,:PDSMDB.yslx,:PDSMDB.wjbh,:PDSMDB.qdqa,:PDSMDB.qdqb :qdqb_id,
		:PDSMDB.zdqa :zdqa_id,:PDSMDB.zdqb :zdqb_id,
		:PDSMDB.kq,:PDSMDB.dingj :dingj_id,:PDSMDB.dyzs :dyzs_id,:PDSMDB.dyk :dyk_id,
		:PDSMDB.lszs :lszs_id,:PDSMDB.lsk :lsk_id,:PDSMDB.sjbh,:PDSMDB.yxnf,:PDSMDB.jsxh 
		FROM t_jspdyssm WHERE jsxh=:key AND sjbh=:sjbh;
	if( ERROR!=0 )
	{
		ERROR=0;
		return(-1);
	}
	temp=PDSMDB.yslx[0];
	trim(PDSMDB.bkdh);
/*	printf("bkdh%s\n",PDSMDB.bkdh);*/
	GetPATH(PDSMDB.bkdh,PDSMDB.sjbh,PDSMDB.yxnf,fbkjbh);
	EXEC SQL SELECT jsfs INTO :jsfs FROM t_fbkj WHERE fbkjbh=:fbkjbh;
	trim(jsfs);
	tmp_jsfs=jsfs[0];

/*** this is the clause to insert into temp table t_tempysflag ***/
	EXEC SQL SELECT COUNT(*) INTO :avoid_repeat FROM t_tempysflag WHERE jsxh=:key AND sjbh=:sjbh;

	if ( avoid_repeat==0 )
		EXEC SQL INSERT INTO t_tempysflag VALUES ( :fbkjbh,:tmp_jsfs,:key,:sjbh,sysdate );
/*** ***/

/*	printf("jsfs%s\n",jsfs);*/
	if( (strcmp(jsfs,"0")!=0)&&(strcmp(jsfs,"3")!=0) )
	{
		
/*		UpdateJSRZ_cved(key,sjbh);
*/		return(0);
	}
	messagepd=(char *)malloc((YSSM_LEN+1)*sizeof(char));
	if( messagepd==NULL )
	{
		ProcessError(LOG_ERROR,"PCS_Convert_File: no space in memory when use ","CallConvertPDYS");
		return(-1);
	}
	messagepd[0]='\0';
	
	tempstr[0]='\0';
	strcpy(tempstr,FBKJ_PATH);
	strcat(tempstr,fbkjbh);
	strcat(tempstr,"/bak/");
	strcpy(file_locat,tempstr);
	switch( temp )
	{
		case BPZ:	strcat(tempstr,"BPZY");
			break;
		case BPJ:	strcat(tempstr,"BPJY");
			flag=qdqbconv(PDSMDB.qdqb,ch);
			if( flag!=0 )
			ProcessError(LOG_ERROR,"PCS_Convert_File: error qdqb > 31 when use ","CallConvertPDYS");
			break;
		case KPZ:	strcat(tempstr,"KPZY");
			break;
		case KPJ:	strcat(tempstr,"KPJY");
			break;
		default:	ErrorEnded("PCS_Convert_File: error in function CallConvertPDYS yslx is not in pdys");
				return(-1);
	}
	/* get pdys data filename */
/*	strcpy(tempstring,PDSMDB.bkdh);
	trim(tempstring);
	strcat(tempstr,tempstring);
*/
/*	strcat(tempstr,".");
	strcpy(tempstring,PDSMDB.sjbh);
	trim(tempstring);
	strcat(tempstr,tempstring);
*/
/*	strcat(tempstr,ch);
*/	h_pdys=fopen(tempstr,"a");
	if( h_pdys == NULL )
	{
		ProcessError(LOG_ERROR,"PCS_Convert_File: cannot open ",tempstr);
		createdir();
		free(messagepd);
		return(-1);
	}
	fseek(h_pdys,0,SEEK_END);
	messagepd[0]='\0';
	str_givenlen(PDSMDB.bkdh,6,RIGHT);
	strcat(messagepd,PDSMDB.bkdh);
	strcat(messagepd,BsbhFromT);
	strcat(messagepd,PDSMDB.sjbh);
	itoa(PDSMDB.qdqa,tempstr,2);
	strcat(messagepd,tempstr);
	/**/
	if( qdqb_id!=-1 ) 
	{
		itoa(PDSMDB.qdqb,tempstr,2);
		strcat(messagepd,tempstr);
	}
	else
		strcat(messagepd,"  ");
	if( zdqa_id==-1)
		strcat(messagepd,"  ");
	else
	{
		itoa(PDSMDB.zdqa,tempstr,2);
		strcat(messagepd,tempstr);
	}
	/**/
	if( zdqb_id!=-1 )
	{
		itoa(PDSMDB.zdqb,tempstr,2);
		strcat(messagepd,tempstr);
	}
	else 
		strcat(messagepd,"  ");
	strcat(messagepd,PDSMDB.kq);
	if(dingj_id==-1)
		strcat(messagepd,"      ");
	else
	{
		ftoa(PDSMDB.dingj,tempstr,2,7);
		str_givenlen(tempstr,6,LEFT);
		strcat(messagepd,tempstr);
	}
	if(dyzs_id==-1)
		strcat(messagepd,"          ");
	else
	{
		itoa(PDSMDB.dyzs,tempstr,10);
		str_givenlen(tempstr,10,LEFT);
		strcat(messagepd,tempstr);
	}
	if(dyk_id==-1)
		strcat(messagepd,"           ");
	else
	{
		ftoa(PDSMDB.dyk,tempstr,2,12);
		str_givenlen(tempstr,11,LEFT);
		strcat(messagepd,tempstr);
	}
	tempstr[0]='\0';
	if(lszs_id==-1)
		strcat(messagepd,"          ");
	else
	{
		itoa(PDSMDB.lszs,tempstr,10);
		str_givenlen(tempstr,10,LEFT);
		strcat(messagepd,tempstr);
	}
	tempstr[0]='\0';
	if(lsk_id==-1)
		strcat(messagepd,"           ");
	else
	{
		ftoa(PDSMDB.lsk,tempstr,2,12);
		str_givenlen(tempstr,11,LEFT);
		strcat(messagepd,tempstr);
	}
	if( ((PDSMDB.yxnf)%2)==1 )
		strcpy(tempstr,"1");
	else
		strcpy(tempstr,"0");
	strcat(messagepd,tempstr);
	strcat(messagepd,"\n");
	fputs(messagepd,h_pdys);
	free(messagepd);
	fclose(h_pdys);
/*	printf("%s\n",messagepd);*/
	/*  BPZY and BPJY need qdqb  */	
	
	strcpy(temp_bkdh,PDSMDB.bkdh);
	trim(temp_bkdh);
	
	if( temp=='3' || temp=='5' )
	{
		tempstr[0]='\0';
		strcpy(tempstring,"PZ");
		strcat(tempstring,temp_bkdh);
		strcat(tempstring,".");
		strcat(tempstring,PDSMDB.sjbh);
	}
	else if( temp=='4' || temp=='6' )
	{
		tempstring[0]='\0';
		strcpy(tempstring,"PJ");
		strcat(tempstring,temp_bkdh);
		strcat(tempstring,".");
		strcat(tempstring,PDSMDB.sjbh);
		strcat(tempstring,ch);
	}

	if( temp=='3' )
	{
		strcpy(tempstr,"BPZ");
		YS_SINGAL[2]='1';
	}
	else if( temp=='5' )
	{
		strcpy(tempstr,"KPZ");
		YS_SINGAL[4]='1';
	}
	else if( temp=='4' )
	{
		strcpy(tempstr,"BPJ");
		YS_SINGAL[3]='1';
	}
	else if( temp=='6' )
	{
		strcpy(tempstr,"KPJ");
		YS_SINGAL[5]='1';
	}

	messagepdsj=(char *)malloc(MAX_YSSJ_LEN*sizeof(char));
	if( messagepdsj==NULL )
	{
		ProcessError(LOG_ERROR,"PCS_Convert_File: no space in memory when use ","CallConvertPDYS");
		return(-1);
	}
	messagepdsj[0]='\0';

	strcat(file_locat,tempstr);
	h_pdsj=fopen(file_locat,"a");
	if( h_pdsj == NULL )
	{
		ProcessError(LOG_ERROR,"PCS_Convert_File: cannot open ",file_locat);
		free(messagepdsj);
		return(-1);
	}
	fseek(h_pdsj,0,SEEK_END);

	retcode=ConvertPDYSSJ(tempstring,messagepdsj,key,sjbh);
	if( retcode!=0 )
	{
		free(messagepdsj);
		fclose(h_pdsj);
		ProcessError(LOG_ERROR,"PCS_Convert_File: convert pdsj error! ",END);
		return(-1);
	}
	fputs(messagepdsj,h_pdsj);
	free(messagepdsj);
	fclose(h_pdsj);
	UpdateJSRZ_cved(key,sjbh);
	return(0);
}

int CallConvertGH( long int key,char *sjbh )
{
	char tempstr[MID_LEN];
	char string[SHORT_LEN];
	int i;
	int tempnum;
	struct stGHDBRec GHDB;
	
/*	for( i=0;i<MAX_GH_LEN;i++ )
		GHDB.ghnr[i]='\0';
*/		
	/* The primary key of t_jsgh is sjbh and jsxh , so declare cursor cur_mulgh */
	/* to avoid select too many value into sqlerror */
	EXEC SQL WHENEVER SQLERROR DO sqlerror();
	EXEC SQL VAR GHDB.ghnr IS string;
	EXEC SQL  SELECT * INTO :GHDB.ghbh,:GHDB.ghxl,:GHDB.ghnr,:GHDB.sjbh,:GHDB.jsxh
		FROM t_jsgh WHERE jsxh=:key AND sjbh=:sjbh;
	
	if( ERROR!=0 )
	{
		ERROR=0;
		return(-1);
	}
	/* get gh filename */
	tempstr[0]='\0';
	strcpy(tempstr,YWJ_PATH);
	strcat(tempstr,"GH");
	trim(GHDB.sjbh);
	strcat(tempstr,GHDB.sjbh);
	strcat(tempstr,BsbhFromT);
	trim(GHDB.ghxl);
	strcat(tempstr,GHDB.ghxl);
	strcat(tempstr,".");
	trim(GHDB.ghbh);
	strcat(tempstr,GHDB.ghbh);
	
	h_gh=fopen(tempstr,"w");
	if( h_gh == NULL )
	{
		ProcessError(LOG_ERROR,"PCS_Convert_File: cannot open ",tempstr);
		return(-1);
	}
	
	fputs(GHDB.ghnr,h_gh);
	fclose(h_gh);
	UpdateJSRZ_cved(key,sjbh);
	return(0);
}

int CallConvertBKML( long int key,char *sjbh )
{
	char tempstr[MID_LEN],sys_bkml[MID_LEN];
	char filewithpath[MID_LEN],filename[MID_LEN];
	char string[SHORT_LEN];
	int i;
	int num_line,tmpbym;
	int tempnum;
	struct stBKMLDBRec BKMLDB;
	struct stBKMLDBRec_id stDBRecord_id;
	
	ERROR=0;
	EXEC SQL WHENEVER SQLERROR DO sqlerror();
	EXEC SQL DECLARE cur_bkml CURSOR FOR 
		SELECT * FROM t_jsbkhzmlnr WHERE jsxh=:key AND sjbh=:sjbh;
	
	/* get gh filename */
	filewithpath[0]='\0';
	strcpy(filewithpath,YWJ_PATH);
	strcat(filewithpath,"BKML");
	
	h_bkml=fopen(filewithpath,"a");
	if( h_bkml == NULL )
	{
		ProcessError(LOG_ERROR,"PCS_Convert_File: cannot open ",filewithpath);
		return(-1);
	}

	strcat(filewithpath,".");
	trim(sjbh);
	strcat(filewithpath,sjbh);

	fputs("XXXX3",h_bkml);
	trimpath(filewithpath,filename);
	fputs(filename,h_bkml);

	EXEC SQL SELECT count(*) INTO :num_line FROM t_jsbkhzmlnr WHERE jsxh=:key AND sjbh=:sjbh;
	messagebkml=(char *)malloc((MAX_BKML_LINE+1)*sizeof(char));
	EXEC SQL OPEN cur_bkml;
	for( i=0;i<num_line;i++ )
	{
		EXEC SQL FETCH cur_bkml INTO :BKMLDB.bkdh, :BKMLDB.bkmc :stDBRecord_id.bkmc_id,
                                     :BKMLDB.fbkjmc :stDBRecord_id.fbkj_id, :BKMLDB.cbrq :stDBRecord_id.cbrq_id,
                                     :BKMLDB.dj :stDBRecord_id.dj_id, :BKMLDB.yj :stDBRecord_id.yj_id,
                                     :BKMLDB.jj :stDBRecord_id.jj_id, :BKMLDB.bnj :stDBRecord_id.bnj_id,
                                     :BKMLDB.nj :stDBRecord_id.nj_id, :BKMLDB.hzddrq :stDBRecord_id.hzddjdrq_id,
                                     :BKMLDB.fxfw :stDBRecord_id.fxfw_id, :BKMLDB.kq :stDBRecord_id.kq_id,
                                     :BKMLDB.tykh :stDBRecord_id.tykh_id, :BKMLDB.jb :stDBRecord_id.jb_id,
                                     :BKMLDB.pc :stDBRecord_id.pc_id, :BKMLDB.kz :stDBRecord_id.kz_id,
                                     :BKMLDB.bym :stDBRecord_id.bym_id, :BKMLDB.xyf :stDBRecord_id.xyf_id,
                                     :BKMLDB.bbdyfl :stDBRecord_id.bbdyfl_id, :BKMLDB.wbdyfl :stDBRecord_id.wbdyfl_id,
                                     :BKMLDB.bblsfl :stDBRecord_id.bblsfl_id, :BKMLDB.wblsfl :stDBRecord_id.wblsfl_id,
                                     :BKMLDB.bz :stDBRecord_id.bz_id, :BKMLDB.key;

		trim(BKMLDB.bkdh);
		trim(BKMLDB.bkmc);
		trim(BKMLDB.fbkjmc);
		trim(BKMLDB.cbrq);
		
		sprintf(messagebkml,"%s%s%s%s%s%s%s%s",BKMLDB.bkdh,",",BKMLDB.bkmc,",",BKMLDB.fbkjmc,",",BKMLDB.cbrq,",");

		if( stDBRecord_id.dj_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.dj);
		strcat(messagebkml,",");

		if( stDBRecord_id.yj_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.yj);
		strcat(messagebkml,",");

		if( stDBRecord_id.jj_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.jj);
		strcat(messagebkml,",");

		if( stDBRecord_id.bnj_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.bnj);
		strcat(messagebkml,",");

/*		if( stDBRecord_id.nj_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.nj);
		strcat(messagebkml,",");
*/
		trim(BKMLDB.hzddrq);
		trim(BKMLDB.fxfw);
		trim(BKMLDB.kq);
		trim(BKMLDB.tykh);
		trim(BKMLDB.jb);
		trim(BKMLDB.bz);
		trim(BKMLDB.xyf);

		sprintf(messagebkml,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",messagebkml,BKMLDB.hzddrq,",",BKMLDB.fxfw,
			",",BKMLDB.kq,",",BKMLDB.tykh,",",BKMLDB.jb,",",BKMLDB.bz,",",BKMLDB.xyf,",");

		if( stDBRecord_id.pc_id == 0 )
			sprintf(messagebkml,"%s%d",messagebkml,BKMLDB.pc);
		strcat(messagebkml,",");

		if( stDBRecord_id.kz_id == 0 )
			sprintf(messagebkml,"%s%d",messagebkml,BKMLDB.kz);
		strcat(messagebkml,",");

		if( stDBRecord_id.bym_id == 0 )
		{
			sprintf(tempstr,"%d",BKMLDB.bym);
			tmpbym=strlen(tempstr);
			if( tmpbym>2 )
			{
				tempstr[tmpbym+1]='\0';
				tempstr[tmpbym]=tempstr[tmpbym-1];
				tempstr[tmpbym-1]=tempstr[tmpbym-2];
				tempstr[tmpbym-2]=',';
				sprintf(messagebkml,"%s%s",messagebkml,tempstr);
			}
			else sprintf(messagebkml,"%s%c%s",messagebkml,',',tempstr);
		}
		else strcat(messagebkml,",");
		strcat(messagebkml,",");

/*		if( stDBRecord_id.bbdyfl_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.bbdyfl);
		strcat(messagebkml,",");

		if( stDBRecord_id.wbdyfl_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.wbdyfl);
		strcat(messagebkml,",");

		if( stDBRecord_id.bblsfl_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.bblsfl);
		strcat(messagebkml,",");

		if( stDBRecord_id.wblsfl_id == 0 )
			sprintf(messagebkml,"%s%.2f",messagebkml,BKMLDB.wblsfl);
		strcat(messagebkml,",");
*/
		strcat(messagebkml,"\n");
		if( ERROR!=0 )
		{
			ERROR=0;
			free(messagebkml);
			EXEC SQL CLOSE cur_bkml;
			fclose(h_bkml);
			return(-1);
		}
		
		fputs(messagebkml,h_bkml);
	}
	fputs("XXXX0",h_bkml);