schdb.c

国家ASIC工程中心使用的嵌入式操作系统

#include "scheme.h"
#include "schfunc.h"
#include "schdb.h"

/***********************************************************************************************/
STATUS TransCreateScheme(  U32 *id, SCHEME_STRU *scheme_stru, U8 reserved )
{
	U8			i;
	U8			*add_data, *data;
	FIELDLIST	fieldlist[SCHEME_FIELD_NUM];
	U16			datalen;
	U32			tmp_id;
	DBLACB			*schemelacb;		//定义一个数据库控制块的变量
	schemelacb =  LinkDataBase( SCHEME_DATA_BASE );	//链接约会提醒数据库

	fieldlist[0].fieldvalue = scheme_stru->time;
	fieldlist[1].fieldvalue = scheme_stru->name;
	fieldlist[2].fieldvalue = scheme_stru->alarm_type;
	fieldlist[3].fieldvalue = scheme_stru->type;
	fieldlist[4].fieldvalue = scheme_stru->alarm_mode;
	fieldlist[5].fieldvalue = scheme_stru->content;
	fieldlist[6].fieldvalue = scheme_stru->alarm_repeat_num;
	datalen = (WORD)( SCHEME_FIELD_NUM * sizeof(WORD) );
	for( i = 0; i < SCHEME_FIELD_NUM; i++ )
	{
		if( fieldlist[i].fieldvalue == NULL )
		{
			fieldlist[i].headoffset = 0;
		}else{
			fieldlist[i].headoffset = datalen;
			datalen += (U16)( strlen( fieldlist[i].fieldvalue ) + 1 );
		}
	}
	
	add_data = (BYTE *)SysLmalloc(datalen);
	if( add_data == NULL )
		return SCHEME_ERROR;
	data = add_data;

	for( i = 0; i < SCHEME_FIELD_NUM; i++ )	//填充偏移值
	{
		memcpy( data, &fieldlist[i].headoffset, sizeof(WORD) );
		data += sizeof(WORD);
	}

	for( i = 0; i < SCHEME_FIELD_NUM; i++ )	//填充字段值
	{
		if( fieldlist[i].headoffset != 0 )
		{
			memcpy( data, fieldlist[i].fieldvalue , ( strlen( fieldlist[i].fieldvalue ) + 1 ) );
			data += ( strlen( fieldlist[i].fieldvalue ) + 1 );
		}
	}

	tmp_id = LocalAddRecord( schemelacb, add_data, datalen );
	DetachDataBase( schemelacb );
	Lfree( add_data );
	if( tmp_id == DB_ERROR )
		return SCHEME_ERROR;

	*id = tmp_id;
	return	SCHEME_OK;
}

/***********************************************************************************************/
STATUS TransModifyScheme( U16 select_no, SCHEME_STRU *scheme_stru, U8 reserved )
{
	U8			i;
	U8			*modify_data, *data;
	FIELDLIST	fieldlist[SCHEME_FIELD_NUM];
	U16			datalen;
	DBLACB			*schemelacb;		//定义一个数据库控制块的变量
	schemelacb =  LinkDataBase( SCHEME_DATA_BASE );	//链接约会提醒数据库

	fieldlist[0].fieldvalue = scheme_stru->time;
	fieldlist[1].fieldvalue = scheme_stru->name;
	fieldlist[2].fieldvalue = scheme_stru->alarm_type;
	fieldlist[3].fieldvalue = scheme_stru->type;
	fieldlist[4].fieldvalue = scheme_stru->alarm_mode;
	fieldlist[5].fieldvalue = scheme_stru->content;
	fieldlist[6].fieldvalue = scheme_stru->alarm_repeat_num;
	datalen = (WORD)( SCHEME_FIELD_NUM * sizeof(WORD) );
	for( i = 0; i < SCHEME_FIELD_NUM; i++ )
	{
		if( fieldlist[i].fieldvalue == NULL )
		{
			fieldlist[i].headoffset = 0;
		}else{
			fieldlist[i].headoffset = datalen;
			datalen += (U16)( strlen( fieldlist[i].fieldvalue ) + 1 );
		}
	}
	
	modify_data = (BYTE *)SysLmalloc(datalen);
	if( modify_data == NULL )
		return SCHEME_ERROR;
	data = modify_data;

	for( i = 0; i < SCHEME_FIELD_NUM; i++ )	//填充偏移值
	{
		memcpy( data, &fieldlist[i].headoffset, sizeof(WORD) );
		data += sizeof(WORD);
	}

	for( i = 0; i < SCHEME_FIELD_NUM; i++ )	//填充字段值
	{
		if( fieldlist[i].headoffset != 0 )
		{
			memcpy( data, fieldlist[i].fieldvalue , ( strlen( fieldlist[i].fieldvalue ) + 1 ) );
			data += ( strlen( fieldlist[i].fieldvalue ) + 1 );
		}
	}
	
	if( LocalModifyRecord( schemelacb, global_scheme_list->head[select_no].index, modify_data, datalen ) == DB_ERROR )
	{
		DetachDataBase( schemelacb );
		Lfree( modify_data );
		return SCHEME_ERROR;
	}

	DetachDataBase( schemelacb );
	Lfree( modify_data );
	return	SCHEME_OK;
}

/***********************************************************************************************/
STATUS	TransDelScheme( U16 select_no, U8 reserved )
{
	U16		i;
	DBLACB			*schemelacb;		//定义一个数据库控制块的变量
	schemelacb =  LinkDataBase( SCHEME_DATA_BASE );	//链接约会提醒数据库

	if( LocalDelRecord( schemelacb, global_scheme_list->head[select_no].index ) == DB_ERROR )
		return SCHEME_ERROR;
	Lfree( global_scheme_list->head[select_no].data );

	for( i = select_no; i < (U16)( global_scheme_list->num - 1 ); i++ )
	{
		global_scheme_list->head[i].index = global_scheme_list->head[i+1].index; 
		global_scheme_list->head[i].data = global_scheme_list->head[i+1].data; 
		global_scheme_list->head[i].datalen = global_scheme_list->head[i+1].datalen; 
	}
	global_scheme_list->num--;

	DetachDataBase( schemelacb );
	return	SCHEME_OK;
}

/***********************************************************************************************/
SCHEME_STRU* TransReadScheme( U16 select_no, U8 reserved )
//SCHEME_STRU* TransReadScheme( U16 select_no, BYTE **record )
{
	SCHEME_STRU		*scheme_stru;
	DBRECORDHEAD	*head_info;
	U8				*data;
#ifdef SIM_ON_PC
	U16				*field_head;
#else
	U16				field_head;
#endif
	U8				i = 0;
	
	if( ( scheme_stru = (SCHEME_STRU *)Lmalloc(sizeof(SCHEME_STRU)) ) == NULL )
		return	NULL;

	head_info = (DBRECORDHEAD *)( global_scheme_list->head[select_no].data );
//	data = (BYTE *)(&head_info->data);

//	head_info = (DBRECORDHEAD *)(*record);
	data = (BYTE *)(&head_info->data);

#ifdef SIM_ON_PC
	field_head = (WORD *)data;
	scheme_stru->time =  data + field_head[SCHEME_TIME];
	scheme_stru->name = data + field_head[SCHEME_NAME];
	scheme_stru->alarm_type = data + field_head[SCHEME_ALARM_TYPE];
	scheme_stru->type = data + field_head[SCHEME_TYPE];
	scheme_stru->alarm_mode = data + field_head[SCHEME_ALARM_MODE];
	scheme_stru->content = data + field_head[SCHEME_CONTENT];
	scheme_stru->alarm_repeat_num = data + field_head[SCHEME_REPEAT_NUM];
#else
	ByteReversal( &field_head, data+(SCHEME_TIME)*sizeof(WORD) );
	scheme_stru->time = data + field_head;
	ByteReversal( &field_head, data+(SCHEME_NAME)*sizeof(WORD) );
	scheme_stru->name = data + field_head;
	ByteReversal( &field_head, data+(SCHEME_ALARM_TYPE)*sizeof(WORD) );
	scheme_stru->alarm_type = data + field_head;
	ByteReversal( &field_head, data+(SCHEME_TYPE)*sizeof(WORD) );
	scheme_stru->type = data + field_head;
	ByteReversal( &field_head, data+(SCHEME_ALARM_MODE)*sizeof(WORD) );
	scheme_stru->alarm_mode = data + field_head;
	ByteReversal( &field_head, data+(SCHEME_CONTENT)*sizeof(WORD) );
	scheme_stru->content = data + field_head;
	ByteReversal( &field_head, data+(SCHEME_REPEAT_NUM)*sizeof(WORD) );
	scheme_stru->alarm_repeat_num = data + field_head;
#endif

	return	scheme_stru;
}

/***********************************************************************************************/
LOCALSEARCHLIST* TransSearchScheme( SCHEME_SEARCH_STRU *scheme_search_stru, U8 reserved )
{
	LOCALSEARCHLIST		*temp_searchlist, *searchlist;
	RECORDDATA			*next_record_data, *next_record_head, *temp_record_data;
	DBRECORDHEAD		*head_info;
	U8					*data, *field_value;
	U16					*field_head;
	U16					i, count;
	DBLACB				*schemelacb;		//定义一个数据库控制块的变量
	
	schemelacb = LinkDataBase( SCHEME_DATA_BASE );	//链接约会提醒数据库

	temp_searchlist = LocalFindRecord( schemelacb, scheme_search_stru->field, scheme_search_stru->keystring, scheme_search_stru->mode );

	switch( *(scheme_search_stru->type) )
	{
		case SCHEME_MATURITY:		// 到期
		case SCHEME_NO_MATURITY:	// 未到期
			temp_record_data = (RECORDDATA *)Lmalloc( sizeof(RECORDDATA) );	//暂存交换变量	
			if( temp_record_data == NULL )
			{
				DelOldSearchList( temp_searchlist );
				DetachDataBase( schemelacb );
				return	NULL;
			}

			next_record_head = next_record_data = temp_searchlist->head;
			for( count = 0, i = 0; i< temp_searchlist->num; i++ )	
			{
				head_info = (DBRECORDHEAD *)(next_record_data->data);
				data = (BYTE *)(&head_info->data);
				field_head = (WORD *)data;
				field_value =  data + field_head[SCHEME_TYPE];
				
				if( *field_value == *(scheme_search_stru->type) )
				{

					temp_record_data->index = next_record_head->index; 
					temp_record_data->data = next_record_head->data;
					temp_record_data->datalen = next_record_head->datalen;

					next_record_head->index = next_record_data->index;
					next_record_head->data = next_record_data->data;
					next_record_head->datalen = next_record_data->datalen;

					next_record_data->index = temp_record_data->index;
					next_record_data->data = temp_record_data->data;
					next_record_data->datalen = temp_record_data->datalen;

					next_record_head++;
					count++;
				}
				next_record_data++;
			}
			Lfree( temp_record_data );
			
			searchlist = (LOCALSEARCHLIST *)Lmalloc( sizeof(LOCALSEARCHLIST) );
			if( searchlist == NULL )
			{
				DelOldSearchList( temp_searchlist );
				DetachDataBase( schemelacb );
				return	NULL;
			}
			if( count != 0 )
			{
				searchlist->head = (RECORDDATA *)Lmalloc( sizeof(RECORDDATA) * count );
				if( searchlist->head == NULL )
				{
					DelOldSearchList( temp_searchlist );
					DetachDataBase( schemelacb );
					return	NULL;
				}
				memcpy( searchlist->head, temp_searchlist->head, ( sizeof(RECORDDATA) * count ) );
				searchlist->num = count;
//				DelOldSearchList( temp_searchlist );
			}else{
				searchlist->head = NULL;
				searchlist->num = 0;
			}
			Lfree( temp_searchlist );
			break;
		case SCHEME_ALL:			// 全部
			searchlist = temp_searchlist;
			break;
	}
	
	DetachDataBase( schemelacb );
	return	searchlist;
}


/***********************************************************************************************/
//把整型值的时间转换成字符串型的时间	
void TimetoChar( TIME_STRU *time, TIME_STRU *conversion_time )
{
/*
	conversion_time->year = (U32)( time->year/1000 + 0x30 ) | ( ( ( time->year%1000 )/100 + 0x30 ) << 8 )
		                    | ( ( ( ( time->year%1000 )%100 )/10 + 0x30 ) << 16 )
		                    | ( ( ( ( time->year%1000 )%100 )%10 + 0x30 ) << 24 );
	conversion_time->month = (U16)( time->month/10 + 0x30 ) | ( ( time->month%10 + 0x30 ) << 8 );
	conversion_time->day = (U16)( time->day/10 + 0x30 ) | ( ( time->day%10 + 0x30 ) << 8 );
	conversion_time->hour = (U16)( time->hour /10 + 0x30 ) | ( ( time->hour%10 + 0x30 ) << 8 );
	conversion_time->minute = (U16)( time->minute/10 + 0x30 ) | ( ( time->minute%10 + 0x30 ) << 8 );
	conversion_time->second = (U16)( time->second/10 + 0x30 ) | ( ( time->second%10 + 0x30 ) << 8 );
*/
	sprintf( (void *)&conversion_time->year, "%04.4d", time->year );
	sprintf( (void *)&conversion_time->month, "%02.2d", time->month );
	sprintf( (void *)&conversion_time->day, "%02.2d", time->day );
	sprintf( (void *)&conversion_time->hour, "%02.2d", time->hour );
	sprintf( (void *)&conversion_time->minute, "%02.2d", time->minute );
	sprintf( (void *)&conversion_time->second, "%02.2d", time->second );
}

/***********************************************************************************************/
//把字符串型的时间转换成整型值的时间	
void TimetoInt( TIME_STRU *time, TIME_STRU *conversion_time )
{
#ifdef SIM_ON_PC	
	conversion_time->year = (DWORD)( ( ( time->year & 0x0f )*1000 ) + ( (time->year >> 8 ) & 0x0f )*100
							+ ( ( time->year >> 16 ) & 0x0f )*10 + ( ( time->year >> 24 ) & 0x0f ) );
	conversion_time->month = (WORD)( ( ( time->month & 0x0f )*10 ) + ( (time->month >> 8 ) & 0x0f ) );
	conversion_time->day = (WORD)( ( ( time->day & 0x0f )*10 ) + ( (time->day >> 8 ) & 0x0f ) );
	conversion_time->hour = (WORD)( ( ( time->hour & 0x0f )*10 ) + ( (time->hour >> 8 ) & 0x0f ) );
	conversion_time->minute = (WORD)( ( ( time->minute & 0x0f )*10 ) + ( (time->minute >> 8 ) & 0x0f ) );
	conversion_time->second = (WORD)( ( ( time->second & 0x0f )*10 ) + ( (time->second >> 8 ) & 0x0f ) );
#else
	conversion_time->year = ( ( ( time->year & 0x0f ) ) + ( (time->year >> 8 ) & 0x0f )*10
							+ ( ( time->year >> 16 ) & 0x0f )*100 + ( ( time->year >> 24 ) & 0x0f )*1000 );
	conversion_time->month = (WORD)( ( ( time->month & 0x0f )*10 ) + ( (time->month >> 8 ) & 0x0f ) );
	conversion_time->day = (WORD)( ( ( time->day & 0x0f ) ) + ( (time->day >> 8 ) & 0x0f )*10 );
	conversion_time->hour = (WORD)( ( ( time->hour & 0x0f ) ) + ( (time->hour >> 8 ) & 0x0f )*10 );
	conversion_time->minute = (WORD)( ( ( time->minute & 0x0f ) ) + ( (time->minute >> 8 ) & 0x0f )*10  );
	conversion_time->second = (WORD)( ( ( time->second & 0x0f ) ) + ( (time->second >> 8 ) & 0x0f )*10 );
#endif

}

/***********************************************************************************************/
//读取当天的提醒列表
TIME_STRU  ReadCurSchemeList( void )
{
	ASIX_DATE			date;
	TIME_STRU			time, conversion_time;
	static char			keystring[KEYSTRING_LEN] = {0}, type[SCHEME_TYPE] = {0};
	SCHEME_SEARCH_STRU	scheme_search_stru;

	//读取当天的提醒列表:
	GetDate( &date );
	time.year = (U32)date.year;
	time.month = date.month;
	time.day = date.day;
	time.hour = time.minute = time.second = 0;
	TimetoChar( &time, &conversion_time );

	//获得关键字
	memcpy( keystring, SCHEME_DAY_RANGE, 2 );
	strcat( keystring, (char *)(&conversion_time) );	
	keystring[15] = '\0';
	scheme_search_stru.keystring = keystring;
	scheme_search_stru.field = SCHEME_TIME;
	scheme_search_stru.mode = PRECISE_FULL_MATCH;	
	type[0] = SCHEME_NO_MATURITY ;	//当天未到期的提醒
	scheme_search_stru.type = type;
	global_scheme_list = TransSearchScheme( &scheme_search_stru, 0 );	//读出当天的提醒记录
	return time;
}

/***********************************************************************************************/
STATUS DynAlarm( DWORD index, U16 timer_type )
{
	MSG			Msg;
	
	memset( (void *)&Msg, 0x0, sizeof(MSG) );
	
	Msg.messageType = ASIX_MESSAGE;
	Msg.message = WM_ALARM;
	Msg.lparam = index;
	Msg.data = NULL;			
	Msg.wparam = timer_type;	

	if( SendMessage( APPTALMSERVER_ID, &Msg ) != SYS_OK )
		return SCHEME_ERROR;
	return	SCHEME_OK;
}