File content as of revision 0:61364762ee0e:

#include "CloudFileReceiver.h"
#include "CloudDataHandler.h"
#include "mbed.h"
#include "global.h"
#include "cJSON.h"
#include <algorithm>
#include <string>
#include "stdio.h"

char CloudFileReceiverWriteBuf[MAX_FILE_SIZE];
char CloudFileReceiverReadBuf[MAX_FILE_SIZE];

bool StoreReceivedFile( std::string &payload_string )
{
    FILENAME_STRING filename;

    memset( filename, '\0', sizeof(FILENAME_STRING) );

    cJSON * root = cJSON_Parse(payload_string.c_str());
    int mType = cJSON_GetObjectItem(root,"mtype")->valueint;
//    printf("%s:%d: mtype=%d\r\n", __func__,__LINE__,mType);
    switch( mType ) {
        case SETPOINT_CONTROL_MTYPE:
        case MANUAL_CONTROL_MTYPE:
        case TIMER_CONTROL_MTYPE: {

            std::string control_json;
            ConfigMessage_t *mail  = ConfigHandlerMailBox.alloc();
            memset(mail, 0, sizeof(ConfigMessage_t));
            mail->action  = ACTION_CREATE;

            switch( mType ) {
                case SETPOINT_CONTROL_MTYPE: {
                    cJSON * spcontrol = cJSON_GetObjectItem(root,"spcontrol");
                    snprintf( filename, sizeof(FILENAME_STRING), "control_sp_%s.json", cJSON_GetObjectItem(spcontrol,"id")->valuestring );
                    control_json = cJSON_PrintUnformatted(spcontrol);
                    mail->control = CONTROL_SETPOINT;
                    break;
                }
                case MANUAL_CONTROL_MTYPE: {
                    cJSON * mncontrol = cJSON_GetObjectItem(root,"mncontrol");
                    snprintf( filename, sizeof(FILENAME_STRING), "control_mn_%s.json", cJSON_GetObjectItem(mncontrol,"id")->valuestring );
                    control_json = cJSON_PrintUnformatted(mncontrol);
                    mail->control = CONTROL_MANUAL;
                    break;
                }
                case TIMER_CONTROL_MTYPE: {
                    cJSON * tmcontrol = cJSON_GetObjectItem(root,"tmcontrol");
                    snprintf( filename, sizeof(FILENAME_STRING), "control_tm_%s.json", cJSON_GetObjectItem(tmcontrol,"id")->valuestring );
                    std::string control_str = cJSON_PrintUnformatted(tmcontrol);
                    mail->control = CONTROL_TIMER;
                    break;
                }
                default: {
                    printf("%s:%d: Unknown message type: %d\r\n",__func__,__LINE__,mType);
                    cJSON_Delete(root);
                    return false;
                }
            }

            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)control_json.c_str(), MAX_FILE_SIZE);
            if( status != true ) {
                printf("(%d)save file failed, status=%d\r\n", __LINE__, status);
                break;
            }

            strncpy(mail->controlFile, filename, sizeof(mail->controlFile)-1);
            ConfigHandlerMailBox.put(mail);

            printf("%s:%d: Control JSON: %s\r\n", __func__,__LINE__, control_json.c_str() );
            printf("%s:%d: Sending a create request for control %s type = %u\r\n", __func__,__LINE__, mail->controlFile, mail->control);
            break;
        }
        case INPUT_CONFIG_MTYPE:
        case VINPUT_CONFIG_MTYPE: {

            cJSON * input = cJSON_GetObjectItem(root,"input");
            if( mType == INPUT_CONFIG_MTYPE ) {
                snprintf( filename, sizeof(FILENAME_STRING), "input_%s%s", cJSON_GetObjectItem(input,"id")->valuestring, ".json" );
            } else {
                snprintf( filename, sizeof(FILENAME_STRING), "vinput_%s%s", cJSON_GetObjectItem(input,"id")->valuestring, ".json" );
            }
            std::string input_str = cJSON_PrintUnformatted(input);


            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)input_str.c_str(), MAX_FILE_SIZE);
            if( status != true ) {
                printf("(%d)save file failed, status=%d", __LINE__, status);
                break;
            }

            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
            mail->action = ACTION_READ_FILE;
            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
            ModbusMasterMailBox.put(mail);

            printf("%s:%d: INPUT JSON: %s\r\n", __func__,__LINE__, input_str.c_str() );
            printf("%s:%d: Sending New INPUT to ModbusMasterMailBox, filename=%s\r\n", __func__,__LINE__, filename);
            break;
        }
        case OUTPUT_CONFIG_MTYPE:
        case VOUTPUT_CONFIG_MTYPE: {

            cJSON * output = cJSON_GetObjectItem(root,"output");
            if( mType == OUTPUT_CONFIG_MTYPE ) {
                snprintf( filename, sizeof(FILENAME_STRING), "output_%s%s", cJSON_GetObjectItem(output,"id")->valuestring, ".json" );
            } else {
                snprintf( filename, sizeof(FILENAME_STRING), "voutput_%s%s", cJSON_GetObjectItem(output,"id")->valuestring, ".json" );
            }
            std::string output_str = cJSON_PrintUnformatted(output);

            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)output_str.c_str(), MAX_FILE_SIZE);
            if( status != true ) {
                printf("(%d)save file failed, status=%d\r\n", __LINE__, status);
                break;
            }

            // send a message to the modbus master
            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
            mail->action = ACTION_READ_FILE;
            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
            ModbusMasterMailBox.put(mail);

            // send a message to the output master
            OutputControlMsg_t *output_mail = OutputMasterMailBox.alloc();
            output_mail->action = ACTION_NEW;
            strncpy(output_mail->controlFile, filename, sizeof(output_mail->controlFile)-1);
            OutputMasterMailBox.put(output_mail);

            printf("%s:%d: OUTPUT JSON: %s\r\n", __func__,__LINE__, output_str.c_str() );
            printf("%s:%d: Sending New OUTPUT to ModbusMaster and OutputMaster, filename=%s\r\n", __func__,__LINE__, filename);

            break;
        }
        case HOLDING_CONFIG_MTYPE: {

            cJSON * holding = cJSON_GetObjectItem(root,"holding");
            snprintf( filename, sizeof(FILENAME_STRING), "hold_%s%s", cJSON_GetObjectItem(holding,"id")->valuestring, ".json" );
            std::string holding_str = cJSON_PrintUnformatted(holding);

            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)holding_str.c_str(), MAX_FILE_SIZE);
            if( status != true ) {
                printf("(%d)save file failed, status=%d", __LINE__, status);
                break;
            }

            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
            mail->action = ACTION_READ_FILE;
            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
            ModbusMasterMailBox.put(mail);

            printf("%s:%d: HOLDING JSON: %s\r\n", __func__,__LINE__, holding_str.c_str() );
            printf("%s:%d: Sending New HOLDING REGISTER to ModbusMasterMailBox, filename=%s\r\n", __func__,__LINE__, filename);
            break;
        }
        case DESTROY_SETPOINT_MTYPE: {

            cJSON * spcontrol = cJSON_GetObjectItem(root,"spcontrol");
            snprintf( filename, sizeof(FILENAME_STRING), "control_sp_%s.json", cJSON_GetObjectItem(spcontrol,"id")->valuestring );

            // send a message to the configuration handler to create the control
            ConfigMessage_t *msg  = ConfigHandlerMailBox.alloc();
            memset(msg, 0, sizeof(ConfigMessage_t));
            msg->action  = ACTION_DESTROY;
            msg->control = CONTROL_SETPOINT;
            strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);

            printf("%s:%d: Sending a destroy request for setpoint control %s type = %u\r\n", __func__,__LINE__, msg->controlFile, msg->control);

            ConfigHandlerMailBox.put(msg);
            break;
        }
        case DESTROY_MANUAL_MTYPE: {

            cJSON * mncontrol = cJSON_GetObjectItem(root,"mncontrol");
            snprintf( filename, sizeof(FILENAME_STRING), "control_mn_%s.json", cJSON_GetObjectItem(mncontrol,"id")->valuestring );

            // send a message to the configuration handler to create the control
            ConfigMessage_t *msg  = ConfigHandlerMailBox.alloc();
            memset(msg, 0, sizeof(ConfigMessage_t));
            msg->action  = ACTION_DESTROY;
            msg->control = CONTROL_MANUAL;
            strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);

            printf("%s:%d: Sending a destroy request for manual control %s type = %u\r\n", __func__,__LINE__, msg->controlFile, msg->control);

            ConfigHandlerMailBox.put(msg);
            break;
        }
        case DESTROY_TIMER_MTYPE: {

            cJSON * tmcontrol = cJSON_GetObjectItem(root,"tmcontrol");
            snprintf( filename, sizeof(FILENAME_STRING), "control_tm_%s.json", cJSON_GetObjectItem(tmcontrol,"id")->valuestring );

            ConfigMessage_t *msg  = ConfigHandlerMailBox.alloc();
            memset(msg, 0, sizeof(ConfigMessage_t));
            msg->action  = ACTION_DESTROY;
            msg->control = CONTROL_TIMER;
            strncpy(msg->controlFile, filename, sizeof(msg->controlFile)-1);

            printf("%s:%d: Sending a destroy request for timer control %s type = %u\r\n", __func__,__LINE__, msg->controlFile, msg->control);

            ConfigHandlerMailBox.put(msg);
            break;
        }
        case VIRTUAL_COMMAND_MTYPE: {

            cJSON * command = cJSON_GetObjectItem(root,"command");
            snprintf( filename, sizeof(FILENAME_STRING), "cmd_%s.json", cJSON_GetObjectItem(command,"id")->valuestring );
            std::string command_json = cJSON_PrintUnformatted(command);

            bool status = GLOBAL_mdot->saveUserFile(filename, (void *)command_json.c_str(), MAX_FILE_SIZE);
            if( status != true ) {
                printf("(%d)save file failed, status=%d\r\n", __LINE__, status);
                break;
            }

            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
            mail->action = ACTION_READ_FILE;
            strncpy( mail->msg, filename, (sizeof(mail->msg)-1));
            ModbusMasterMailBox.put(mail);

            printf("%s:%d: COMMAND: %s\r\n", __func__,__LINE__, command_json.c_str() );
            printf("%s:%d: Sending a create command requst to ModbusMaster %s type = %u\r\n", __func__,__LINE__, mail->msg, mail->control);

            break;
        }
        case BT_MODBUS_HOLD_COMMAND_MTYPE: {

            cJSON * mbcommand = cJSON_GetObjectItem(root,"mbcommand");
            std::string mbcommand_json = cJSON_PrintUnformatted(mbcommand);
            ModbusMasterReq_t *mail = ModbusMasterMailBox.alloc();
            mail->action = ACTION_EXEC_CMD;
            mail->replyThread = CLOUD_DATA_HANDLER;
            strncpy( mail->msg, mbcommand_json.c_str(), (sizeof(mail->msg)-1));
            ModbusMasterMailBox.put(mail);

            printf("%s:%d: MODBUS Command: %s\r\n", __func__,__LINE__, mbcommand_json.c_str());

            break;
        }
        default:
//            printf("%s:%d: DEFAULT\r\n", __func__,__LINE__);
            break;
    }
    cJSON_Delete(root);
    return true;
}

bool CloudDataHandler_RcvFile = false;
bool CloudFileReceiver( std::string *recv_string )
{
    bool status;
    CloudDataHandler_RcvFile = false;
    int sequence;
    std::string seq_str = recv_string->c_str();
    std::string remove_seq = "{\"seq\":";
    std::string::size_type i = seq_str.find(remove_seq);
    if (i != std::string::npos) {
        seq_str.erase(i, remove_seq.length());
        std::string remove_comma = ",";
        i = seq_str.find(remove_comma);
        if (i != std::string::npos) {
            seq_str.erase(i, (seq_str.length()-i));
            sequence = atoi(seq_str.c_str());
        }
    }
    std::string payload_string = recv_string->c_str();
    std::string extract_pay = "\"pay\":";
    i = payload_string.find(extract_pay);
    if (i != std::string::npos) {
        i = i + extract_pay.length();
        payload_string.erase(0, i);
        payload_string.erase((payload_string.length()-1), 1);
        if( sequence != -1 ) {
            payload_string = payload_string.substr(1, payload_string.size() - 2);
        }
    }

    printf("sequence=%d, payload_string:%s", sequence, payload_string.c_str() );

    CloudDataHandler_RcvFile = false;
    if( sequence == -1 ) {

        // sequence of -1 means string sent in 1 chunk.
//        printf("%s:%d: payload=%s\r\n",__func__,__LINE__, payload_string.c_str() );
        status = StoreReceivedFile( payload_string );

    } else if( sequence == 0 ) {

        memset(CloudFileReceiverWriteBuf,0,sizeof(CloudFileReceiverWriteBuf));
        snprintf(CloudFileReceiverWriteBuf, sizeof(CloudFileReceiverWriteBuf), "%s", payload_string.c_str() );

        printf("(%d)Writing String Length=%d, %s", __LINE__, MAX_FILE_SIZE, CloudFileReceiverWriteBuf );

        status = GLOBAL_mdot->saveUserFile("scratch.json", (void *)CloudFileReceiverWriteBuf, MAX_FILE_SIZE);
        if( status != true ) {
            printf("(%d)save file failed, status=%d", __LINE__, status);
        } else {
            CloudDataHandler_RcvFile = true;
            printf("(%d)UPDATED scratch.json FILE, status:%d, strlen=%d", __LINE__, status, strlen(CloudFileReceiverWriteBuf));
        }

    } else if( sequence == -2 ) {

        printf("(%d)READING BACK scratch.json FILE FOR LAST PACKET", __LINE__);

        // read the file back
        status = GLOBAL_mdot->readUserFile("scratch.json", (void *)CloudFileReceiverReadBuf, MAX_FILE_SIZE);
        if( status != true ) {
            printf("(%d)read file failed, status=%d", __LINE__, status);
            return false;
        }

        snprintf(CloudFileReceiverWriteBuf, sizeof(CloudFileReceiverWriteBuf), "%s%s", CloudFileReceiverReadBuf, payload_string.c_str() );
        printf("(%d)Final String Length=%d, %s", __LINE__, strlen(CloudFileReceiverWriteBuf), CloudFileReceiverWriteBuf );

        std::string final_json = CloudFileReceiverWriteBuf;
        printf("%s:%d: finished parse: %s\r\n", __func__,__LINE__,final_json.c_str() );

        status = StoreReceivedFile( final_json );
        if( status != true ) {
            printf("(%d)save file failed, status=%d", __LINE__, status);
        }

        status = GLOBAL_mdot->deleteUserFile("scratch.json");
        if( status != true ) {
            printf("(%d)delete file failed, status=%d", __LINE__, status);
        }

        printf("(%d)DELETED scratch.json FILE, status:%d", __LINE__, status );

    } else {

        printf("(%d)READING BACK scratch.json FILE", __LINE__);

        // read the file back
        status = GLOBAL_mdot->readUserFile("scratch.json", (void *)CloudFileReceiverReadBuf, MAX_FILE_SIZE);
        if( status != true ) {
            printf("(%d)read file failed, status=%d", __LINE__, status);
            return false;
        }

        snprintf(CloudFileReceiverWriteBuf, sizeof(CloudFileReceiverWriteBuf), "%s%s", CloudFileReceiverReadBuf, payload_string.c_str() );
        printf("(%d)Writing String Length=%d, %s", __LINE__, strlen(CloudFileReceiverWriteBuf), CloudFileReceiverWriteBuf );

        status = GLOBAL_mdot->saveUserFile("scratch.json", (void *)CloudFileReceiverWriteBuf, MAX_FILE_SIZE);
        if( status != true ) {
            printf("(%d)save file failed, status=%d", __LINE__, status);
        } else {
            CloudDataHandler_RcvFile = true;
            printf("(%d)UPDATED scratch.json FILE, status:%d, strlen=%d", __LINE__, status, strlen(CloudFileReceiverWriteBuf));
        }
    }
    return true;
}