add assets and presentation, add code

Author: Alberto Rizzi

README.md

@@ -1,20 +1,33 @@
-# Ecommerce Orchestration Microservice
+# e-Commerce Saga Orchestration Implementation
+Il presente progetto ha lo scopo di implementare un prototipo di flusso di un e-Commerce attraverso alcune tecnologie di Amazon AWS previste nel pattern della Saga Orchestration.
 
-Lorenzo Marcolli (mat. 08302A) <br />
-Alberto Rizzi (mart. 08303A)
+## Autori
+- Lorenzo Marcolli (mat. 08302A)
+- Alberto Rizzi (mart. 08303A)
 
 ## Diagram flow
-[Draw.io](https://drive.google.com/file/d/14FBuOeF2dJOKJoST7JyEinbuRB0JBPWc/view?usp=sharing)
+<div align="center">
+    <img src="assets/schema_high.jpg" width="95%" style="border-radius: 5px; padding: 10px; background-color: white"></img>
+</div>
 
-## Technologies
+[ 🔗 Draw.io](https://drive.google.com/file/d/14FBuOeF2dJOKJoST7JyEinbuRB0JBPWc/view?usp=sharing)
+
+## Relazione
+[ 🔗 Relazione](/assets/relazione.pdf)
+
+## Presentazione
 
-### Client
-- Next.js
-- Typescript
-- Tailwind.css
 
+## Tecnologie usate
 ### Cloud
 - AWS Lambda
 - AWS SQS
 - AWS Step Function
-- AWS API Gateway
+- AWS API Gateway
+- AWS DynamoDB
+
+### Client
+- Next.js
+- Typescript
+- Tailwind.css
+

assets/relazione.pdf

@@ -1,11 +1,43 @@
-import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
+import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
+import { DynamoDBClient, GetItemCommand, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
 
 const dynamoDBClient = new DynamoDBClient();
 
+
 export const handler = async (event, context, callback) => {
     let response;
     const basket = event.basket;
 
+    const orderId = event.orderId;
+
+    console.log(orderId)
+
+    try {
+        const lambda = new LambdaClient({ region: 'eu-central-1' });
+
+        const params = {
+            FunctionName: 'SendWebsocketMessage',
+            InvocationType: 'RequestResponse',
+            Payload: JSON.stringify({ orderId: orderId, messageObj: { status: "pending", message: "Controllo disponibilità prodotti" } }) // Input payload for the target Lambda function
+        };
+
+        const command = new InvokeCommand(params);
+        const data = await lambda.send(command);
+
+        console.log(data)
+
+        if (data.StatusCode === 200) {
+            console.log(data.Payload)
+        }
+        else {
+            throw new Error("Errore invio WS message")
+        }
+    }
+    catch (error) {
+        console.error('Error:', error);
+        throw error;
+    }
+
     try {
         const hasInvalidQuantity = await Promise.all(
             basket.map(async (product) => {
@@ -17,26 +49,19 @@ export const handler = async (event, context, callback) => {
                         'productId': { N: product.id.toString() }
                     }
                 };
-                
-                console.log(params)
 
-                const command = new GetItemCommand(params);
 
-                console.log(command);
 
+                const command = new GetItemCommand(params);
                 const data = await dynamoDBClient.send(command);
 
-                console.log(data);
-
                 // Check if the item exists
                 if (!data.Item) {
                     throw new Error(`Product with ID ${product.id} not found in the inventory.`);
                 }
 
                 const retrievedItem = data.Item;
 
-                console.log(retrievedItem);
-
                 const availability = parseInt(retrievedItem.quantity.N);
 
                 if (product.quantity > availability) {
@@ -46,22 +71,64 @@ export const handler = async (event, context, callback) => {
                 return false;
             })
         );
-        
+
         console.log(hasInvalidQuantity)
 
         if (hasInvalidQuantity.some(Boolean)) {
-            throw new Error("error_quantity");
-        } else {
+            try {
+                const updateItemParams = {
+                    TableName: 'Order',
+                    Key: {
+                        orderId: { S: orderId }
+                    },
+                    UpdateExpression: 'SET orderStatus = :statusString',
+                    ExpressionAttributeValues: {
+                        ':statusString': { S: 'cancelled' }
+                    }
+                };
+
+                const command = new UpdateItemCommand(updateItemParams);
+                const data = await dynamoDBClient.send(command);
+            }
+            catch (error) {
+                console.error('Error:', error);
+                throw error;
+            }
+            throw new Error("Quantità non disponibile");
+        }
+        else {
+            basket.map(async (product) => {
+                console.log(typeof product.id);
+
+                const updateItemParams = {
+                    TableName: 'Inventory',
+                    Key: {
+                        productId: { N: product.id.toString() }
+                    },
+                    UpdateExpression: 'SET quantity = quantity - :decreaseAmount',
+                    ExpressionAttributeValues: {
+                        ':decreaseAmount': { N: product.quantity.toString() }, // Specify the amount to decrease
+                        ':quantityitem': { N: '0' }
+                    },
+                    ConditionExpression: 'quantity > :quantityitem',
+                };
+
+                const command = new UpdateItemCommand(updateItemParams);
+                const data = await dynamoDBClient.send(command);
+            })
+
             response = {
                 statusCode: 200,
                 body: event,
             };
         }
 
         return response;
-    } catch (error) {
+    }
+    catch (error) {
         const myErrorObj = {
             message: error.message,
+            orderId: orderId,
             errorType: "InternalServerError",
             httpStatus: 500,
             requestId: context.awsRequestId,

assets/schema_high.jpg

@@ -0,0 +1,74 @@
+import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
+import { DynamoDBClient, GetItemCommand, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
+
+const dynamoDBClient = new DynamoDBClient();
+
+export const handler = async (event, context, callback) => {
+    const orderId = event.body.orderId
+
+    try {
+        const updateItemParams = {
+            TableName: 'Order',
+            Key: {
+                orderId: { S: orderId }
+            },
+            UpdateExpression: 'SET orderStatus = :statusString',
+            ExpressionAttributeValues: {
+                ':statusString': { S: 'completed' }
+            }
+        };
+
+        const command = new UpdateItemCommand(updateItemParams);
+        const data = await dynamoDBClient.send(command);
+    }
+    catch (error) {
+        console.error('Error:', error);
+
+        const myErrorObj = {
+            message: error.message,
+            orderId: orderId,
+            errorType: "InternalServerError",
+            httpStatus: 500,
+            requestId: context.awsRequestId,
+        };
+        callback(JSON.stringify(myErrorObj));
+    }
+
+
+
+    try {
+        const lambda = new LambdaClient({ region: 'eu-central-1' });
+
+        const params = {
+            FunctionName: 'SendWebsocketMessage',
+            InvocationType: 'RequestResponse',
+            Payload: JSON.stringify({ orderId: orderId, messageObj: { status: "completed", message: "Ordine avvenuto con successo" } }) // Input payload for the target Lambda function
+        };
+
+        const command = new InvokeCommand(params);
+        const data = await lambda.send(command);
+
+        if (data.StatusCode === 200) {
+            console.log(data.Payload)
+
+            const response = {
+                statusCode: 200,
+                body: JSON.stringify('Ordine avvenuto con successo!'),
+            };
+            return response;
+        }
+        else {
+            throw new Error("Errore invio WS message")
+        }
+    }
+    catch (error) {
+        const myErrorObj = {
+            message: error.message,
+            orderId: orderId,
+            errorType: "InternalServerError",
+            httpStatus: 500,
+            requestId: context.awsRequestId,
+        };
+        callback(JSON.stringify(myErrorObj));
+    }
+};

lambda/CheckInventory.js

@@ -0,0 +1,77 @@
+import { DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb";
+
+const client = new DynamoDBClient()
+
+
+function getItemValue(attribute) {
+    const dataType = Object.keys(attribute)[0];
+    const value = attribute[dataType];
+
+    switch (dataType) {
+        case "N":
+            return parseFloat(value);
+        case "S":
+            return value;
+        case "BOOL":
+            return value === "true";
+            // Handle other data types as needed
+        default:
+            return null;
+    }
+}
+
+
+export const handler = async (event) => {
+    try {
+
+        const scanCommand = new ScanCommand({ TableName: 'Inventory', ConsistentRead: true });
+        const scanResult = await client.send(scanCommand);
+
+        if (!scanResult.Items) {
+            return {
+                statusCode: 404,
+                body: JSON.stringify('no_items_found'),
+                headers: {
+                    "Access-Control-Allow-Headers": "Content-Type",
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "GET"
+                },
+            };
+        }
+
+        // create array of product
+        const items = scanResult.Items.map((item) => {
+            const formattedItem = {};
+            Object.keys(item).forEach((key) => {
+                formattedItem[key] = getItemValue(item[key]);
+            });
+            return formattedItem;
+        });
+
+        console.log(items)
+
+        return {
+            statusCode: 200,
+            error: false,
+            body: JSON.stringify(items),
+            headers: {
+                "Access-Control-Allow-Headers": "Content-Type",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET"
+            },
+        };
+    }
+    catch (error) {
+        console.log(error);
+        return {
+            statusCode: 500,
+            error: true,
+            body: JSON.stringify('no_items_found'),
+            headers: {
+                "Access-Control-Allow-Headers": "Content-Type",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET"
+            },
+        };
+    }
+};