pcs_snd_cancel_p.pc

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

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*	File name		: Pcs_Snd_Cancel_P.pc				*				
*	Module ID		:						*
*	Module Name		:  						*
*	Purpose			: Get Cancel Data From DataBase And SEND TO MQ 	*
*	Author             	: Liu Yan Qiu ( DIMPT )				*
*	Date Created		: 1999,10,27					*
*	Version			: Version 1.0   				*
*	Environment		: Digital UNIX                  		*
*	Portability		: UNIX Platform                 		*
*	Warnings		:                               		*
*	References		:                               		*
*	Calling Syntax		:                               		*
*	Parameters		: None                          		*
*	Returns			: void                          		*
*	Calling Function	:                               		*
*	Called Functions	: When system startup           		*
*	Datastores and usages	:                             			*
*        	  (a) Input                      				*
* 	   	  (b) OutPut                              			*       
*	Report			: None                          		*
*	Screens			: None                        			*
*	Messages Files		: None                          		*
*	Change Log		:                               		*
*	Change No. 	Date	Author	Reason For Change 			*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  
*/

#include "/usr/bkfx/include/Pcs_Snd_Cancel_P/Pcs_Snd_Cancel_P.h"


void main()
{
  
    	signal(SIGTERM, Free_Mem);
    
	EXEC SQL INCLUDE SQLCA;

	ProcessError(LOG_NORMAL, "Pcs_Snd_Cancel_P.x  Is Begin!",END);

	while(1)
	{
		rtn_code = MQBKInit("CSGL");
    		if ( rtn_code < 0 )
      		{
       			ProcessError(LOG_ERROR,"Calling Funtion MQBKInit() Failed!",END);
			sleep(InitInterval);
     		}
		else
			break;
	}
	    
    	rtn_code = InitPCSSndCancel();
        if ( rtn_code < 0 )
        {
        	ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Calling Function \
        				InitPCSSndCancel() Failed!",END);
        }
    
    	rtn_code = PCSSndCancel();
        if ( rtn_code < 0 )
        {
        	ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Calling Function \
        				PCSSndCancel() Failed!",END);
       	}
               
} 


void Free_Mem()
{
	ProcessError(LOG_NORMAL, "Pcs_Snd_Cancel_P.x Is Terminated By User!",END);
 	if ( MsgQX != NULL ) free( MsgQX );
 	MQBKClear();
 	EXEC SQL RollBack RELEASE;
	exit(0);
}


int InitPCSSndCancel()
{
	
 
 	EXEC SQL BEGIN DECLARE SECTION;
      		VARCHAR  userid[20];
      		VARCHAR  password[20];
 	EXEC SQL END DECLARE SECTION; 

 
 	/*********************************
   	|   Get Process waiting interval |
   	**********************************/
 	
 	interval = GetTimeInterval("PCS_SND_CANCEL_P");
 	

 	/*****************************
  	| Connect to DataBase	     |
  	*****************************/
  
 	strcpy( userid.arr, "pcsdba" );
	userid.len = strlen( userid.arr );
	strcpy( password.arr, "dba" );
	password.len = strlen( password.arr );
	
	
 	EXEC SQL WHENEVER SQLERROR GOTO sqlerror;
 	EXEC SQL CONNECT :userid IDENTIFIED BY :password;


 	/****************************
  	|    Initialize MQ	    |
  	****************************/
 
 	return(1);
 
 	sqlerror:
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,   "DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
 	exit(-1);

}


int PCSSndCancel()
{
  	int	count_rz, count_hz, i;

       
        EXEC SQL WHENEVER SQLERROR GOTO sqlerror;
        
   while (1)
   {
	
   	EXEC SQL SELECT count(*) INTO :count_rz FROM T_FSRZ 
        		WHERE sjzt = '4';
	
	if ( count_rz == 0 )  sleep( interval); 
  	else
	{
           
 	       	EXEC SQL DECLARE cur_rz CURSOR For
           	      	SELECT fsxh FROM t_fsrz 
                	WHERE sjzt='4';
	       	EXEC SQL OPEN cur_rz;
       
             	for (i=1; i <= count_rz; i++)
               	{

                	EXEC SQL FETCH cur_rz INTO :fsxh ;
                  
                 	EXEC SQL SELECT count(*) INTO count_hz
                        		FROM t_hz
                          		WHERE FSXH = :fsxh;
                          		
               	 	itoa( fsxh, c_fsxh, LEN_FSXH+1);
                 	
                     	if ( count_hz == 1) 
                 	EXEC SQL SELECT sjbh INTO :jssjbh
                          		FROM t_hz  WHERE FSXH = :fsxh;
                       	else if ( count_hz > 1)
                       	{
                     		jssjbh[0] = '9';
                     		jssjbh[1] = '9';
                       	}
			
                 	jssjbh[2] = '\0';    
                 

                 	rtn_code = SetPCSSndCancel();
                 	if (rtn_code < 0)
                 	{
                  	  ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Calling Function \
                  	  			SetPCSSndCancel() Failed!",END);
                  	  continue;
                 	}
                 	
                        rtn_code = MQBKSend_Syn(strlen(MsgQX),MsgQX,0,"CANCEL");
			free( MsgQX );
			if (rtn_code <0)  
              		{
              			ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Sendding Cancel \
              						Message Error!",END);
				MQBKBack();
              			continue;
              		}
              		
              		rtn_code = MQBKCmit();
       			if ( rtn_code < 0 ) 
	       		{
				ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Commit Cancel \
						Message Error!",END);
				MQBKBack();
	       	      		continue;
       	      		}
       	      		
                        EXEC SQL UPDATE t_fsrz SET sjzt ='5', jssj =sysdate
         				WHERE FSXH =:fsxh;  
                        
        	}	/* end of for */
       		EXEC SQL COMMIT WORK ;
        	EXEC SQL CLOSE cur_rz;        
        	
         	sleep(interval);

          }	/* end of else */

    }	/* end of while */
       
 	return(1); 
       
	sqlerror:
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,"DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
	ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Running Function PCSSndCancel() \
				SQL Error!",END);
	if ( MsgQX != NULL ) free(MsgQX);
 	EXEC SQL RollBack;
	return(-1); 
}


int SetPCSSndCancel()
{

	EXEC SQL WHENEVER SQLERROR GOTO sqlerror;
	
	while(1)
	{

		if ( (MsgQX = (char *)malloc (LEN_MsgQX)) == NULL )
 		{
			ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Malloc Cancel Buffer \
 					Error!",END);
			sleep(InitInterval);
		}
		else
			break;

 	}
 	
 	memset(MsgQX, '\0', LEN_MsgQX);
 	
 	EXEC SQL SELECT bsbh into :fssjbh FROM t_bsbh;
        fssjbh[2] = '\0';
 	
 	strcpy( MsgQX, c_fsxh);
 	strcat( MsgQX, fssjbh);
 	strcat( MsgQX, jssjbh); 

	#ifdef DEBUG
		printf("fsxh, fssjbh, jssjbh is: %s, %s, %s \n",c_fsxh,fssjbh,jssjbh);
	#endif
 	return(1);
 	
 	sqlerror:
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,   "DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
 	ProcessError(LOG_ERROR,"Pcs_Snd_Cancel_P.x: Running Function SetPCSSndCancel() \
 				SQL Error!",END);
 	free( MsgQX );
 	EXEC SQL RollBack;
  	return(-1);
 
}


void itoa(long The_int_data, char* The_out_string, int j)
{
	char exch_str[12];
	char a;
	int i=0, n, the_mod;
	The_out_string[0]='\0';
	
	/* if the int varible is zero, then ...*/
	if (The_int_data==0)
	{
		exch_str[0]='0';
		exch_str[1]='\0';
		
		
		strcat( The_out_string, exch_str);
		for(n=1;n<j-1;n++)
		The_out_string[n]=' ';
		The_out_string[n]='\0';
		return;
	}
	
	
            while (1)
	        {
		
		the_mod = The_int_data%10;
		exch_str[i] = (char )(the_mod+48);
		exch_str[i+1] = '\0';
		i++;
		
		/* change the last digit to char */
		if((The_int_data = (The_int_data/10))<10) 
		     {
			exch_str[i] = (char)(The_int_data+48);
			exch_str[i+1] = '\0';
			goto over;
                        }
                   }
	
	/* overturn the order */
over:	for(n=0;n<=i;n++)
	The_out_string[n] = exch_str[i-n];
	for(n=i+1;n<j-1;n++)
	The_out_string[n]=' ';
	The_out_string[n]='\0';
}


/*Get the Time_Interval specified in the file and return it */
int GetTimeInterval(char* cType)
{
	FILE *hTimeInterval;
	char cLine[MAX_LINE_LEN+1], cCaption[100], cValue[21];
	int iInterval, i;
	char* pLine;
	
	 
	hTimeInterval = fopen( CONFIG_FILE_FOR_TIMEINTERVAL, "r" );
	if( hTimeInterval == NULL )
	{
		ProcessError(LOG_ERROR, "GetTimeInterval: this is %s message:Cannot open file: %s,The file may not exist!",END);
		return(DEFAULT_TIMEINTERVAL);  
	}
	
	while( myapi_ReadALine( cLine, hTimeInterval ) )
	{
		if( cLine[0] == '#' ) continue;
		if( cLine[0] == NULL ) continue;
		
		pLine = cLine;
		while( (*pLine == ' ') || (*pLine == '\t') ) pLine++;
		i=0;
		while( (*pLine != ' ') && (*pLine != '\t') && (*pLine != '\0') )
		{
			cCaption[i] = *pLine;
			i++;
			pLine++;
		}
		
		cCaption[i] = '\0';
		if( strcmp( cCaption, cType ) == 0 ) /*Match*/
		{
			while( (*pLine == ' ') || (*pLine == '\t') ) pLine++;
			if( *pLine == '\0' )
			{	fclose( hTimeInterval );
				return(DEFAULT_TIMEINTERVAL);
			}
			i=0;
			while( (*pLine != ' ') && (*pLine != '\t') && (*pLine != '\0') )
			{
				cValue[i] = *pLine;
				i++;
				pLine++;
			}
			cValue[i] = '\0';
			iInterval = atoi(cValue);
			
			if(iInterval <= 0) 		
			{
				fclose( hTimeInterval );
				return(DEFAULT_TIMEINTERVAL);
			}
			else
				fclose( hTimeInterval );
				return(iInterval);
		}
		else
			continue;
	}
	fclose( hTimeInterval );
	return(DEFAULT_TIMEINTERVAL);
}

/*Read a line to a string from a file, \n is excluded.
  return 1 if sucessful, 0 otherwise
  Do not close the file.*/
int myapi_ReadALine( char* cLine, FILE* hTable )
{
	char cChar;
	int i=0;
	cLine[0] = '\0';
	while( (cChar = fgetc( hTable )) != '\n' )
	{
		if( cChar == EOF ) return(0);
		cLine[i++] = cChar;
		
		
		if( i >= MAX_LINE_LEN ) i=0;
		cLine[i] = '\0';
	}
	return(1);
}

void ProcessError( char *LOG, char *sErrorMessage1, char *sErrorMessage2 )
{
	FILE* hErrorFile;
	char cDateTime[100],tempstr[100];
	int i,j,len,n;
	
	tempstr[0]='\0';
	len=strlen(sErrorMessage1);
	for(i=0;i<=len;i++)
	{
		if(sErrorMessage1[i]=='%')
		{			
			n=i;
			if(len!=i+1)
			{
				for(j=0;j<200&&sErrorMessage1[i+2]!='\0';j++,i++)
				tempstr[j]=sErrorMessage1[i+2];
				tempstr[j]='\0';
			}	
			break;
		}
		if(sErrorMessage1[i]=='\0')
		{
			n=i;
			tempstr[0] = '\0';
			break;
		}
			
	}
	
	
	sErrorMessage1[n]='\0';
	hErrorFile = fopen( ERROR_LOG_FILE, "a" );
	if( hErrorFile == NULL )
	{
		printf( "Critical! Cannot open ERROR_LOG_FILE for append or cannot create!\n");
		return;
	}
	fseek( hErrorFile, 0 ,SEEK_END );
	fputs( "\n",hErrorFile);
	fputs( LOG ,hErrorFile);
	printf("\n%s",LOG);
	fputs( sErrorMessage1,hErrorFile );
	printf("%s",sErrorMessage1);
	fputs( sErrorMessage2,hErrorFile );
	printf("%s",sErrorMessage2);
	fputs( tempstr,hErrorFile );
	printf("%s\n",tempstr);
	fputs( "\n",hErrorFile);
	fclose( hErrorFile );
	sprintf( cDateTime, "date >> %s\n", ERROR_LOG_FILE );
	system( cDateTime );
}