Subversion Repositories svn1-original

/*************************************************************************
*           Copyright (C) 1995 Embedded Solutions
*                       All rights reserved
*
* file:     src\dcheck.c
*
* purpose:  This module contains routines used to test the consitency
*           of the time data.
*
*           It will test data for one or more legs generating displays of
*           inconsitent data. The system will then allow the operator to
*           correct the data or to disqualify the team.
*
* functions
*       data_check              - Start the data consistency testing
*       correct_times           - Allow the operator to modify data
*
* programmer: David Purdie
*
* revision  date        by      reason
*   00.0    27/01/95    DDP     Tidies up the program and formatted the file
*
**************************************************************************/

#include    "consts.h"
#include    "structs.h"
#include    "proto.h"


/* Internal definition */

//int         leg_end = 0;                         /* Legs to test */
//const char       *ck_err_mess[] = {
//    "No error",
//    "Invalid start time",
//    "Invalid end time",
//    "End before start",
//    "Team data not entered"
//};

/*========================================================================
 *
 *  Start the data consistency testing
 *
 *  Purpose:
 *      This function is called to start the data consistency testing
 *
 *  Parameters:
 *      None
 *
 *  Returns:
 *      Nothing
 *
 *========================================================================*/

//void data_check(void)
//{
//    int         tm;
//    int         list;                       /* Option to use */
//    int         i;                          /* List counter */
//    int         count_bad;                  /* Counter of bad teams */

//    cur( 0, 5 );
//    printf( "Leg times data consistency testing" );
//    while( TRUE )
//    {
//        if ( last_loaded_leg > 0 && last_loaded_leg <= config.num_legs )
//            leg_end = last_loaded_leg;
//        else
//            leg_end = config.num_legs;

//        d_field( 0, 6, "Enter leg to test :", D_NUMBER, 1,
//                 ( char * ) &leg_end, TRUE, M_UPDATE );
//        if( abort_flag )
//            return;
//        if( leg_end > 0 && leg_end <= config.num_legs )
//            break;                               /* Got what I need */
//        beep();
//    }

//    last_loaded_leg = leg_end;
//    for ( ; ; )
//    {
//        printf( "\n(L)ist, (E)xamine or (Q)uit teams with bad times :" );
//        list = 0;
//        count_bad = 0;
//        i = 0;
//        switch ( getfnc( "LEQ" ) )
//        {
//        case 'Q' :
//        case 0:
//            return;                                  /* Abort exit */

//        case 'L':
//            list++;
//            printf( "List" );
//            break;

//        case 'E':
//            printf( "Examine" );
//        }

//        /*
//         * Start the testing
//         * Read each team into memory and start the testing
//         */
//        printf( "\nScanning all team records\n" );

//        for( tm = config.min_team; tm <= config.max_team; tm++ )
//        {
//            abort_flag = FALSE;
//            if( valid_field( tm ) )
//            {
//                ( void ) g_record( tm, &team_buf );
//                if( team_buf.flags.disqualified == FALSE
//                    && test_times( &team_buf, leg_end ) )
//                {
//                    count_bad++;
//                    if( !list )
//                    {
//                        if( correct_times( tm, list ) )
//                        {
//                            tm--;
//                            count_bad--;
//                        }
//                        else if( abort_flag )
//                            break;;
//                    }
//                    else
//                    {
//                        printf( "%4d ", tm );
//                        if( ++i > 10 )
//                        {
//                            printf( "\n" );
//                            i = 0;
//                        }
//                        flush_out();
//                    }
//                }
//            }
//        }
//        if( count_bad )
//            printf( "\n%d teams with inconsistent data", count_bad );
//        else
//            printf( "\nAll team data correct" );
//        beep();
//    }
//}

/*========================================================================
 *
 *  Allow the operator to modify data
 *
 *  Purpose:
 *      This function is called to Allow the operator to modify data
 *
 *  Parameters:
 *      tm      Team to process
 *      list    Mode: TRUE : Just list data
 *                    FALSE: Modify data
 *
 *  Returns:
 *      This routine will return TRUE if the data was modified 
 *
 *========================================================================*/

//bool correct_times( int tm, int list )
//{
//    int         mods_done = FALSE;

//    list = list;                                 /* Keep lint quiet for now */
//    printf( "Team %4d,Leg %d: %s ", tm, check_error.leg,
//            ck_err_mess[check_error.type] );
//    printf( " Ign/Disq/NoEquest/Exam :" );
//    switch ( getfnc( "IDNE" ) )
//    {
//    case 0:
//    case 'I':
//        mods_done = FALSE;
//        break;
//    case 'D':
//        team_buf.flags.disqualified = TRUE;
//        printf( "Disqualified" );
//        mods_done = TRUE;
//        break;
//    case 'N':
//        team_buf.flags.disqualified = TRUE;
//        team_buf.flags.non_equestrian = TRUE;
//        printf( "No Equestrian" );
//        mods_done = TRUE;
//        break;

//    case 'E':
//        clearscreen();
//        if( check_error.type == 4 )
//            d_display( M_TEAM );
//        else
//            d_display( M_LEGS );
//        mods_done = TRUE;
//        break;
//    }
//    put_team_record( tm, &team_buf );
//    printf( "\n" );
//    return ( mods_done );
//}

/********************************* EOF ***********************************/