DynamoDBに保存したIPアドレスをLambda関数で呼び出す

'use strict';

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();
const tableName = 'IPTable'; // DynamoDBのテーブル名
const http = require('http');

// --------------- Helpers that build all of the responses -----------------------

// ... (buildSpeechletResponse, buildResponse関数は変更なし)
function buildSpeechletResponse(title, output, repromptText, shouldEndSession) {
    return {
        outputSpeech: {
            type: 'PlainText',
            text: output,
        },
        card: {
            type: 'Simple',
            title: `SessionSpeechlet - ${title}`,
            content: `SessionSpeechlet - ${output}`,
        },
        reprompt: {
            outputSpeech: {
                type: 'PlainText',
                text: repromptText,
            },
        },
        shouldEndSession,
    };
}

function buildResponse(sessionAttributes, speechletResponse) {
    return {
        version: '1.0',
        sessionAttributes,
        response: speechletResponse,
    };
}

// --------------- Functions that control the skill's behavior -----------------------

// ... (getWelcomeResponse, handleSessionEndRequest, createLocationAttributes関数は変更なし)
function getWelcomeResponse(callback) {
    const sessionAttributes = {};
    const cardTitle = 'Welcome';
    const speechOutput = "二階の温度を教えてなどと問いかけると、それを答えます。";
    const repromptText = "私はこの部屋を見てるわよっ！何が知りたいのっ！　　　ってかっ";
    const shouldEndSession = false;

    callback(sessionAttributes,
        buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
}

function handleSessionEndRequest(callback) {
    const cardTitle = 'Session Ended';
    const speechOutput = 'Thank you for trying the Alexa Skills Kit sample. Have a nice day!';
    const shouldEndSession = true;

    callback({}, buildSpeechletResponse(cardTitle, speechOutput, null, shouldEndSession));
}

function createLocationAttributes(location) {
    return { location };
}


async function readTemperatureInSession(intent, session, callback) {
    const cardTitle = intent.name;
    const LocationSlot = intent.slots.Location;
    const MeasurementSlot = intent.slots.Measurement;
    let repromptText = '';
    let sessionAttributes = session.attributes || {};
    const shouldEndSession = false;
    let speechOutput = '';
    let body = '';
    const blynkport = '8080';
    let blynkAuthToken;
    let blynkPin;

    let location = LocationSlot.value || sessionAttributes.location || '二階';
    sessionAttributes.location = location;

    let ip;

    try {
        // DynamoDBからIPアドレスを取得
        const params = {
            TableName: tableName,
            Key: {
                id: 'globalIP' // パーティションキーは固定値
            }
        };
        const data = await dynamoDb.get(params).promise();
        const item = data.Item;

        if (!item || !item.ipAddress) {
            console.error('IPアドレスがDynamoDBに存在しません。');
            speechOutput = 'IPアドレスが取得できませんでした。';
            repromptText = 'もう一度お試しください。';
            callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
            return;
        }

        ip = item.ipAddress; // DynamoDBから取得したIPアドレス

    } catch (error) {
        console.error(`DynamoDBからIPアドレスを取得中にエラーが発生しました: ${error}`);
        speechOutput = 'IPアドレスの取得中にエラーが発生しました。';
        repromptText = 'もう一度お試しください。';
        callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
        return; // エラー発生時は処理を中断
    }


    switch (location) {
        case '二階':
            blynkAuthToken = '******wpbmLskRMBvSyi9Lw';
            break;
        case '仏間':
            blynkAuthToken = 'slWRpvQM++++++++BMKIRS7vi4ch2';
            break;
        case '屋根裏':
            blynkAuthToken = 'uwPwuHpaI=======CQ6R4268eEeI';
            break;
        default:
            speechOutput = '指定された場所が見つかりませんでした。';
            repromptText = '他の場所を指定してください。';
            callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
            return;
    }

    let measurement = MeasurementSlot.value || '温度';
    switch (measurement) {
        case '何度':
        case '気温':
        case '室温':
        case '温度':
            blynkPin = 'V0';
            break;
        case '湿気':
        case '湿度':
            blynkPin = 'V1';
            break;
        case '大気圧':
        case '気圧':
            blynkPin = 'V2';
            break;
        case '熱中度指数':
        case '熱中度':
        case '暑さ指数':
        case '暑さ度':
        case '暑さ':
            blynkPin = 'V4';
            break;
        default:
            speechOutput = '指定された測定項目が見つかりませんでした。';
            repromptText = '他の測定項目を指定してください。';
            callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
            return;
    }

    try {
        console.log(`Sending request to Blynk server with Auth Token: ${blynkAuthToken}, Pin: ${blynkPin}, IP: ${ip}`);

        const httpPromise = new Promise((resolve, reject) => {
            http.get({
                host: ip,
                path: `/${blynkAuthToken}/get/${blynkPin}`,
                port: blynkport,
            }, (response) => {
                response.on('data', (d) => {
                    body += d;
                });
                response.on('end', () => {
                    resolve('Done Sending');
                });
            }).on('error', (e) => {
                reject(e); // エラーをreject
                console.error(`Blynkサーバーへのリクエストエラー: ${e}`); // エラーログ
            });
        });

        await httpPromise;

        console.log(`Received response from Blynk server: ${body}`);

        let info;
        try {
            info = parseFloat(JSON.parse(body)); // パースを試みる
        } catch (parseError) {
            console.error(`JSONパースエラー: ${parseError}, body: ${body}`);
            info = NaN; // パースに失敗したらNaNを設定
        }

        if (isNaN(info)) {
            speechOutput = '温度の取得に失敗しました。';
            repromptText = 'もう一度お試しください。';
            callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
        } else {
            // ... (温度表示処理)
            speechOutput = location + 'の ' + measurement + 'は ';
            repromptText = speechOutput;
            switch (measurement) {
                default:
                case '何度':
                case '気温':
                case '室温':
                case '温度':
                    speechOutput += `${info.toFixed(1)}度 です。`;
                    repromptText += `${info.toFixed(1)}℃です。`;
                    break;
                case '湿気':
                case '湿度':
                    speechOutput += `${info.toFixed(1)}パーセント です。`;
                    repromptText += `${info.toFixed(1)}%です。`;
                    break;
                case '大気圧':
                case '気圧':
                    speechOutput += `${info.toFixed(0)}ヘクトパスカル です。`;
                    repromptText += `${info.toFixed(0)}hPaです。`;
                    break;
                case '熱中度指数':
                case '熱中度':
                case '暑さ指数':
                case '暑さ度':
                case '暑さ':
                    let annotation = '';
                    if (info >= 31) {
                        annotation = '危険！　ブラックです。';
                    } else if (info >= 28) {
                        annotation = '厳重警戒！　レッドです。';
                    } else if (info >= 25) {
                        annotation = '警戒！　オレンジです。';
                    } else if (info >= 21) {
                        annotation = '注意です。';
                    }
                    speechOutput += `${info.toFixed(0)}度 です。${annotation}`;
                    repromptText += `${info.toFixed(0)}℃です。${annotation}`;
                    break;
            }
            callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
        }

    } catch (error) {
        console.error(`温度取得処理全体のエラー: ${error}`);
        speechOutput = '温度の取得中にエラーが発生しました。';
        repromptText = 'もう一度お試しください。';
        callback(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession));
    }
}


// ... (onSessionStarted, onLaunch, onIntent, onSessionEnded関数は変更なし)
function onSessionStarted(sessionStartedRequest, session) {
    console.log(`onSessionStarted requestId=${sessionStartedRequest.requestId}, sessionId=${session.sessionId}`);
}

function onLaunch(launchRequest, session, callback) {
    console.log(`onLaunch requestId=${launchRequest.requestId}, sessionId=${session.sessionId}`);
    getWelcomeResponse((sessionAttributes, speechletResponse) => {
        callback(sessionAttributes, speechletResponse);
    });
}

function onIntent(intentRequest, session, callback) {
    console.log(`onIntent requestId=${intentRequest.requestId}, sessionId=${session.sessionId}`);
    const intent = intentRequest.intent;
    const intentName = intentRequest.intent.name;

    if (intentName === 'GetMeasurement') {
        readTemperatureInSession(intent, session, callback);
    } else if (intentName === 'AMAZON.HelpIntent') {
        getWelcomeResponse((sessionAttributes, speechletResponse) => {
            callback(sessionAttributes, speechletResponse);
        });
    } else if (intentName === 'AMAZON.StopIntent' || intentName === 'AMAZON.CancelIntent') {
        handleSessionEndRequest((sessionAttributes, speechletResponse) => {
            callback(sessionAttributes, speechletResponse);
        });
    } else {
        throw new Error('Invalid intent');
    }
}

function onSessionEnded(sessionEndedRequest, session) {
    console.log(`onSessionEnded requestId=${sessionEndedRequest.requestId}, sessionId=${session.sessionId}`);
    // callbackを呼び出す必要はありません。
    // context.succeed()も不要です。
}

exports.handler = (event, context) => {
    try {
        console.log('Event:', JSON.stringify(event));

        let globalIP;
        if (event.session && event.session.attributes && event.session.attributes.globalIP) {
            globalIP = event.session.attributes.globalIP;
            console.log(`Using globalIP from session attributes: ${globalIP}`);
            continueProcessing(event, context); // IPアドレス取得後に実行したい処理
        } else {
            console.log("globalIP not found in session attributes. Retrieving from DynamoDB or IP");
            // IPアドレスの取得処理 (DynamoDB or event.ip)
            if (event.ip) {
                globalIP = event.ip;
                event.session.attributes.globalIP = globalIP; // セッション属性に保存
                console.log(`IP from event: ${globalIP}`);
                continueProcessing(event, context); // IPアドレス取得後に実行したい処理
            } else {
                getIPAddressFromDynamoDB(event, context);
            }
        }

    } catch (e) {
        console.error(`Exception: ${e}`);
        context.fail(`Exception: ${e}`);
    }
};

function updateIPAddress(event, context) {
    const params = {
        TableName: tableName,
        Item: {
            id: 'globalIP',
            ipAddress: event.ip
        }
    };

    dynamoDb.put(params).promise()
        .then(() => {
            console.log(`Successfully updated IP address in DynamoDB: ${event.ip}`);
            event.session.attributes.globalIP = event.ip;
            console.log(`Updated globalIP to: ${event.ip}`);
            continueProcessing(event, context);
        })
        .catch(err => {
            console.error(`Error updating IP address in DynamoDB: ${err}`);
            context.fail(`Error updating IP address: ${err}`);
        });
}

function getIPAddressFromDynamoDB(event, context) {
    const params = {
        TableName: tableName,
        Key: {
            id: 'globalIP'
        }
    };

    dynamoDb.get(params).promise()
        .then(data => {
            if (data.Item) {
                const ipAddress = data.Item.ipAddress;
                event.session.attributes.globalIP = ipAddress;
                console.log(`Retrieved IP address from DynamoDB: ${ipAddress}`);
                continueProcessing(event, context);
            } else {
                console.error('IP address not found in DynamoDB.');
                context.fail('IP address not found.');
            }
        })
        .catch(err => {
            console.error(`Error retrieving IP address from DynamoDB: ${err}`);
            context.fail(`Error retrieving IP address: ${err}`);
        });
}

function continueProcessing(event, context) {
    if (event.session && event.session.new) {
        onSessionStarted({ requestId: event.request.requestId }, event.session);
    }
    if (event.request && event.request.type) {
        if (event.request.type === 'LaunchRequest') {
            onLaunch(event.request, event.session, (sessionAttributes, speechletResponse) => {
                context.succeed(buildResponse(sessionAttributes, speechletResponse));
                console.log('LaunchRequest succeeded');
            });
        } else if (event.request.type === 'IntentRequest') {
            onIntent(event.request, event.session, (sessionAttributes, speechletResponse) => {
                context.succeed(buildResponse(sessionAttributes, speechletResponse));
                console.log('IntentRequest succeeded');
            });
        } else if (event.request.type === 'SessionEndedRequest') {
            onSessionEnded(event.request, event.session);
            context.succeed();
            console.log('SessionEndedRequest succeeded');
        }
    } else {
        console.error('event.request が見つかりません。');
        context.fail('event.request が見つかりません。');
    }
}

// ... (onSessionStarted, onLaunch, onIntent, onSessionEnded, buildResponse, buildSpeechletResponseなどの関数は省略)