Subversion Repositories DevTools

//---------------------------------------------------------------------------

#include <vcl.h>
#include <FileCtrl.hpp>
#pragma hdrstop

#include "UdTransfer.h"
#include "UdTransferManager.h"

namespace
{
    const char * REG_BASE_KEY       =   "\\Software\\ERG\\TxnTestManager\\UD Transfer";
    const char * REG_DURATION_TYPE  =   "DurationType";
    const char * REG_DURATION       =   "Duration";
    const char * REG_FREQUENCY_TYPE =   "FrequencyType";
    const char * REG_FREQUENCY      =   "Frequency";
    const char * REG_RECURRING      =   "Recurring";
    const char * REG_RAMP_TEST_TYPE =   "RampTestType";
    const char * REG_RAMP_GRADIENT  =   "RampGradient";
    const char * REG_SOURCE_PATH    =   "SourcePath";
    const char * REG_DESTINATION    =   "Destination";

    const char * REG_RENAME         =   "RenameSentFiles";
    const char * REG_IGNORESENT     =   "IgnoreSentFiles";
    const char * REG_MAXDEVICES     =   "MaxDeviceSimulators";
    const char * REG_DEVICEID       =   "StartingDeviceId";
    const char * REG_DEVICETYPE     =   "DeviceType";
    const char * REG_CONNECTTIMEOUT =   "DeviceConnectTimeout";

    const char * SENT_STRING        =   "sent_";

    static int MAX_DEVICES = 400;

    static Variant vInteger(1);
    static Variant vDouble(double(1));
    static Variant vString(AnsiString("1"));
}

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "AdvDirectoryEdit"
#pragma link "AdvEdBtn"
#pragma link "AdvEdit"
#pragma link "AdvPageControl"
#pragma resource "*.dfm"
TUdTransferForm *UdTransferForm;
//---------------------------------------------------------------------------
__fastcall TUdTransferForm::TUdTransferForm(TComponent* Owner)
    : TForm(Owner), m_Registry(NULL), m_manager(NULL)
{
        m_Registry = new TRegistry;
        m_Registry->RootKey = HKEY_CURRENT_USER;
        if (! m_Registry->OpenKey(REG_BASE_KEY, true) )
        {
                m_Registry->CloseKey();
                delete m_Registry;
                m_Registry = NULL;
        }
}
//---------------------------------------------------------------------------

__fastcall TUdTransferForm::~TUdTransferForm()
{
    if( m_Registry != NULL ) m_Registry->CloseKey();
    delete m_Registry;
    m_Registry = NULL;
    m_manager = NULL;
}
//---------------------------------------------------------------------------

int __fastcall TUdTransferForm::ShowForm( UdTransferManager * manager )
{
    m_manager = manager;
    InitialiseValuesFromRegistry();

    return ShowModal();
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::InitialiseValuesFromRegistry()
{
    int duration = 0;
    int durationType = 1;
    int frequency = 0;
    int frequencyType = 1;
    int rampTestType = 0;
    double rampGradient = 1;
    bool recurringUpload = false;
    AnsiString sourcePath = "";
    AnsiString destination = "";
    bool renameSent = false;
    bool ignoreSent = false;
    int maxDevices = 100;
    int deviceId = 1;
    AnsiString deviceType = "SIM";
    int connectTimeOut = 5; 

    if( m_Registry != NULL )
    {
        try {
            // Previous transfer settings

            if( m_Registry->ValueExists(REG_RECURRING) )
            {
                recurringUpload = m_Registry->ReadBool(REG_RECURRING);
            }
            if( m_Registry->ValueExists(REG_DURATION_TYPE) &&
                m_Registry->ValueExists(REG_DURATION) )
            {
                duration        = m_Registry->ReadInteger(REG_DURATION);
                durationType    = m_Registry->ReadInteger(REG_DURATION_TYPE);
            }
            if( m_Registry->ValueExists(REG_FREQUENCY_TYPE) &&
                m_Registry->ValueExists(REG_FREQUENCY) )
            {
                frequency       = m_Registry->ReadInteger(REG_FREQUENCY);
                frequencyType   = m_Registry->ReadInteger(REG_FREQUENCY_TYPE);
            }
            if( m_Registry->ValueExists(REG_RAMP_TEST_TYPE) )
            {
                rampTestType    = m_Registry->ReadInteger(REG_RAMP_TEST_TYPE);
            }
            if( m_Registry->ValueExists(REG_SOURCE_PATH) )
            {
                sourcePath      = m_Registry->ReadString(REG_SOURCE_PATH);
            }
            if( m_Registry->ValueExists(REG_DESTINATION) )
            {
                destination     = m_Registry->ReadString(REG_DESTINATION);
            }
            if( m_Registry->ValueExists(REG_RAMP_GRADIENT) )
            {
                rampGradient    = m_Registry->ReadFloat(REG_RAMP_GRADIENT);
            }

            // General settings

            if( m_Registry->ValueExists(REG_RENAME) )
            {
                renameSent      = m_Registry->ReadBool(REG_RENAME);
            }
            if( m_Registry->ValueExists(REG_IGNORESENT) )
            {
                ignoreSent      = m_Registry->ReadBool(REG_IGNORESENT);
            }
            if( m_Registry->ValueExists(REG_MAXDEVICES) )
            {
                maxDevices      = m_Registry->ReadInteger(REG_MAXDEVICES);
            }
            if( m_Registry->ValueExists(REG_DEVICEID) )
            {
                deviceId        = m_Registry->ReadInteger(REG_DEVICEID);
            }
            if( m_Registry->ValueExists(REG_DEVICETYPE) )
            {
                deviceType      = m_Registry->ReadString(REG_DEVICETYPE);
            }
            if( m_Registry->ValueExists(REG_CONNECTTIMEOUT) )
            {
                connectTimeOut  = m_Registry->ReadInteger(REG_CONNECTTIMEOUT);
            }
        }
        catch( EReadError & e ) { } // Ignore
        catch( ERegistryException & e ) { }
    }

    // Set default or loaded values

    cbRecurring->Checked        = recurringUpload;
    edUploadDuration->Text      = IntToStr(duration);
    coDurationType->ItemIndex   = durationType;
    edUploadFrequency->Text     = IntToStr(frequency);
    coFrequencyType->ItemIndex  = frequencyType;
    coRampTestType->ItemIndex   = rampTestType;
    edGradient->Text            = FloatToStr(rampGradient);
    edSourcePath->Text          = sourcePath;
    edDestination->Text         = destination;

    dtScheduleDate->Date        = TDateTime::CurrentDate();
    dtScheduleTime->Time        = TDateTime::CurrentTime();

    cbRename->Checked           = renameSent;
    cbIgnoreSent->Checked       = ignoreSent;
    coMaxDevices->Text          = maxDevices;
    edStartingDeviceId->Text    = IntToHex( deviceId, 8 );    
    edDeviceType->Text          = deviceType.SubString(0, 6);
    edDeviceTimeout->Text       = IntToStr(connectTimeOut);

    coRampTestTypeChange( NULL );
    rbStartNowClick( NULL );
    SetDefaultBatchSize();
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::coRampTestTypeChange(TObject *Sender)
{
    bool rampEnabled = false;

    lblRatioDescription->Hide();
    lblGradient->Hide();
    edGradient->Hide();

    switch( coRampTestType->ItemIndex )
    {
    case RampTestByDemand:
        lblGradient->Show();
        edGradient->Show();
        rampEnabled = true;
        break;

    case RampTestByRatio:
        lblRatioDescription->Show();
        rampEnabled = true;
        break;
    };

    rbStartNow->Enabled     = rampEnabled;
    rbSchedule->Enabled     = rampEnabled;
    dtScheduleDate->Enabled = rampEnabled && rbSchedule->Checked;
    dtScheduleTime->Enabled = rampEnabled && rbSchedule->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::btnOkClick(TObject *Sender)
{
    if( ValidateInputs() )
    {
        // Store current values in the registry

        m_Registry->WriteBool(REG_RECURRING, cbRecurring->Checked);
        m_Registry->WriteInteger(REG_DURATION, edUploadDuration->Text.ToInt());
        m_Registry->WriteInteger(REG_DURATION_TYPE, coDurationType->ItemIndex);
        m_Registry->WriteInteger(REG_FREQUENCY, edUploadFrequency->Text.ToInt());
        m_Registry->WriteInteger(REG_FREQUENCY_TYPE, coFrequencyType->ItemIndex);
        m_Registry->WriteInteger(REG_RAMP_TEST_TYPE, coRampTestType->ItemIndex);
        m_Registry->WriteString(REG_SOURCE_PATH, edSourcePath->Text);
        m_Registry->WriteString(REG_DESTINATION, edDestination->Text);
        if( coRampTestType->ItemIndex == RampTestByDemand )
        {
            m_Registry->WriteFloat(REG_RAMP_GRADIENT, edGradient->Text.ToDouble());
        }

        // Store settings values. No need to validate the majority of these; if they are
        // invalid we will fall back to default values

        try {
            m_Registry->WriteBool(REG_RENAME, cbRename->Checked);
            m_Registry->WriteBool(REG_IGNORESENT, cbIgnoreSent->Checked);
            m_Registry->WriteInteger(REG_MAXDEVICES, coMaxDevices->Text.ToIntDef(100));
            m_Registry->WriteInteger(REG_DEVICEID, StrToInt(AnsiString("$" + edStartingDeviceId->Text)));
            m_Registry->WriteString(REG_DEVICETYPE, edDeviceType->Text);
            m_Registry->WriteInteger(REG_CONNECTTIMEOUT, edDeviceTimeout->Text.ToIntDef(5));
        }
        catch( EConvertError & e ) { }

        // Add the task to the manager

        UdTransferTask task;
        task.batchSize = edBatchSize->Text.ToInt();
        task.duration = edUploadDuration->Text.ToInt();
        task.frequency = edUploadFrequency->Text.ToInt();
        task.recurring = cbRecurring->Checked;
        task.sourcePath = edSourcePath->Text;
        task.destination = edDestination->Text;
        task.rampType = (RampTestType)coRampTestType->ItemIndex;
        task.gradient = 0;
        if( task.rampType == RampTestByDemand )
        {
            task.gradient = edGradient->Text.ToDouble();
        }
        
        switch( coDurationType->ItemIndex )
        {
        case 1: task.duration *= 60;        break;
        case 2: task.duration *= 60 * 60;   break;
        }
        switch( coFrequencyType->ItemIndex )
        {
        case 1: task.frequency *= 60;       break;
        case 2: task.frequency *= 60 * 60;  break;
        }

        TDateTime rampTime = TDateTime::CurrentDateTime();
        if( rbSchedule->Checked )
        {
            rampTime = dtScheduleDate->DateTime + dtScheduleTime->Time;
        }
        task.rampTime = rampTime;

        if( m_manager != NULL )
        {
            m_manager->AddNewTask( task );
        }

        ModalResult = mrOk;
    }
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::btnDefaultClick(TObject *Sender)
{
    SetDefaultBatchSize();
    cbRecurring->Checked = false;
    coRampTestType->ItemIndex = RampTestDisabled;
    edGradient->Text = "1.0";

    rbStartNowClick(NULL);
    coRampTestTypeChange(NULL);
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::SetDefaultBatchSize()
{
    // Get the number of .devud files in the source path and
    // set this as the default batch size.

    if( edSourcePath->Text.IsEmpty() )
    {
        edBatchSize->Text = "0";
        return;
    }

    int count = 0;
    TSearchRec sr;

    if( FindFirst( edSourcePath->Text + "\\*.devud", faReadOnly, sr ) == 0 )
    {
        do
        {
            if( (sr.Attr & faDirectory) == 0 )
            {
                if( !(cbIgnoreSent->Checked && (sr.Name.Pos(SENT_STRING) == 1)) )
                {
                    ++count;
                }
            }
        } while( FindNext(sr) == 0 );
        FindClose(sr);
    }

    edBatchSize->Text = IntToStr(count);
}
//---------------------------------------------------------------------------

bool __fastcall TUdTransferForm::ValidateInputs()
{
    // All required values must have entries

    bool valid = ValidateEditControl( edSourcePath, "Source Path", vString );
    if( valid ) valid = ValidateEditControl( edDestination, "Destination", vString );
    if( valid ) valid = ValidateEditControl( edBatchSize, "Batch Size", vInteger );
    if( valid ) valid = ValidateEditControl( edUploadDuration, "Upload Duration", vInteger );
    if( valid ) valid = ValidateEditControl( edUploadFrequency, "Upload Frequency", vInteger );
    if( coRampTestType->ItemIndex == RampTestByDemand )
    {
        if( valid ) valid = ValidateEditControl( edGradient, "Ramp Gradient", vDouble );
    }

    // Scheduled ramp time must be in the future

    if( valid && rbSchedule->Checked )
    {
        TDateTime time = dtScheduleDate->DateTime + dtScheduleTime->Time;
        if( time < TDateTime::CurrentDateTime() )
        {
            AnsiString error =
                "The scheduled ramp time has already past. Use 'Start Now!' if you wish to start the ramp test immediately.";
            MessageDlg(error, mtError, TMsgDlgButtons() << mbOK, 0);
            valid = false;
        }
    }

    // Source path must be valid and contain some files to transfer

    if( valid && !DirectoryExists(edSourcePath->Text) )
    {
        AnsiString error =
            "The source path '" + edSourcePath->Text + "' does not exist.";
        MessageDlg(error, mtError, TMsgDlgButtons() << mbOK, 0);
        valid = false;
        edSourcePath->SetFocus();
    }

    if( valid && (edBatchSize->Text.ToInt() <= 0) )
    {
        AnsiString error =
            "The specified source path does not contain any UD files to transfer, or the transfer batch\n";
        error += "size has been set to zero. Do you want to continue anyway?";

        if( MessageDlg(error, mtWarning, TMsgDlgButtons() << mbNo << mbYes, 0) == mrNo )
        {
            valid = false;
            edBatchSize->SetFocus();
        }
    }

    // Duration must be greater than zero for ramp up by ratio calculation

    if( (coRampTestType->ItemIndex == RampTestByRatio) &&
        (edUploadDuration->Text.ToInt() == 0) )
    {
        AnsiString error =
            "An upload duration must be specified for Ramp Up by Ratio tests.";
        MessageDlg(error, mtError, TMsgDlgButtons() << mbOK, 0);
        valid = false;
        edUploadDuration->SetFocus();
    }

    // User input max device simulators must be less than the absolute maximum

    if( coMaxDevices->Text.ToIntDef(100) > MAX_DEVICES )
    {
        AnsiString error =
            "The maximum defined device simulators exceeds the known safe value.\n";
        error += "Please select a value between 0 and " + IntToStr(MAX_DEVICES) + ".";
        MessageDlg(error, mtError, TMsgDlgButtons() << mbOK, 0 );

        PageControl->ActivePageIndex = 1;
        coMaxDevices->SetFocus();
        valid = false;
    }

    return valid;
}
//---------------------------------------------------------------------------

bool __fastcall TUdTransferForm::ValidateEditControl( TCustomEdit * ctrl, const AnsiString & name,
                                                      const Variant & dataType )
{
    AnsiString details = "";

    bool valid = !ctrl->Text.IsEmpty();
    if( valid  )
    {
        // Ensure the control has a value of the specified data type

        if( dataType.VType == varInteger )
        {
            try {
                ctrl->Text.ToInt();
            }
            catch( EConvertError & e )
            {
                details = e.Message;
                valid = false;
            }
        }
        else if( dataType.VType == varDouble )
        {
            try {
                ctrl->Text.ToDouble();
            }
            catch( EConvertError & e )
            {
                details = e.Message;
                valid = false;
            }
        }
    }

    if( !valid )
    {
        AnsiString error = "A valid entry has not been provided for " + name + ".";
        if( !details.IsEmpty() ) error += "\n" + details + ".";
        
        MessageDlg(error, mtError, TMsgDlgButtons() << mbOK, 0);

        PageControl->ActivePageIndex = 0;
        ctrl->SetFocus();
    }

    return valid;
}

//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::rbStartNowClick(TObject *Sender)
{
    rbStartNow->Checked = true;
    rbSchedule->Checked = false;

    dtScheduleDate->Enabled = false;
    dtScheduleTime->Enabled = false;
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::rbScheduleClick(TObject *Sender)
{
    rbSchedule->Checked = true;
    rbStartNow->Checked = false;

    dtScheduleDate->Enabled = true;
    dtScheduleTime->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::edSourcePathChange(TObject *Sender)
{
    SetDefaultBatchSize();
}
//---------------------------------------------------------------------------

void __fastcall TUdTransferForm::cbIgnoreSentClick(TObject *Sender)
{
    // Reload batch size and this may impact on it
    SetDefaultBatchSize();
}
//---------------------------------------------------------------------------