Update

backend/api.js

@@ -35,6 +35,10 @@ app.get('/api/items', (req, res) => {
 });
 
 // POST - Register an account
+
+// (req, res) => { ... } is a callback which usually indicates that the
+// execution of the code contained between brackets will continue
+// asynchronously.
 app.post('/api/register', (req, res) => {
   const userData = req.body;
   
@@ -43,8 +47,8 @@ app.post('/api/register', (req, res) => {
     return res.status(400).json("Invalid request");
   }
 
-  // The callback denoted by the arrow function is executed asynchronously
-  // from the rest of the code outside of the hash() function
+  // The callback denoted by the arrow function is executed
+  // when hash() has finished its execution.
   bcrypt.hash(userData.password, 10, (err, hashedPassword) => {
     
     if (err) {
@@ -95,6 +99,55 @@ app.post('/api/register', (req, res) => {
   });
 });
 
+app.post('/api/registerv2', (req, res) => {
+  const userData = req.body;
+  
+  // Ensure that the required fields are present before proceeding
+  if (!userData.display_name || !userData.email || !userData.password) {
+    return res.status(400).json("Invalid request");
+  }
+
+  bcrypt.hash(userData.password, 10)
+    .then( hashedPassword => {
+      // Generate activation link token
+      const activationLink = crypto.randomBytes(16).toString('hex');
+          // Acquire a connection from the pool
+          pool.connect()
+          .then(async (client) => {
+            // SQL query with placeholders for parameters
+            const insertQuery = `
+            INSERT INTO "User" (display_name, date_of_birth, place_of_living, is_looking_for_job, email, password)
+            VALUES ($1, $2, $3, $4, $5, $6)
+            RETURNING *`; // Return the inserted row
+      
+          try {
+              try {
+                const result = await client.query(insertQuery, [
+                  userData.display_name,
+                  userData.date_of_birth,
+                  userData.place_of_living,
+                  userData.is_looking_for_job,
+                  userData.email,
+                  hashedPassword
+                ]);
+                // Respond with the inserted user data
+                res.status(200).json(result.rows[0]);
+              } catch (error) {
+                console.error('Error inserting data:', error);
+                res.status(500).json("Internal server error");
+              }
+            } finally {
+              // Release the connection back to the pool
+              client.release();
+            }
+        })
+        .catch((error) => {
+          console.error('Error acquiring a connection from the pool:', error);
+          res.status(500).json("Internal server error");
+        });
+    });
+});
+
 // Start the server
 app.listen(port, () => {
   console.log(`Blink API server is running on port ${port}`);

backend/tutorials/callbacks.js

@@ -0,0 +1,44 @@
+// https://javascript.info/callbacks
+
+ function execute_action(param, callback){
+
+    if(param == "something"){
+        console.log("Executing action: " + param);
+        callback(null, Date.now());
+    }
+    else{
+        // We can call callback with one argument even if
+        // the signature states two parameters
+        callback(new Error("Invalid parameter"))
+    }
+}
+
+function entryPoint(){
+    /* ===== Begin Simple callback ===== */
+
+    execute_action("something", function (error, time_of_completion){
+        if(error){
+            console.log("Something happened");
+        }
+        else{
+            console.log("Time of completion: " + new Date(time_of_completion).toDateString());
+        }
+    });
+    console.log("I started here!");
+    /*
+    Ciò è utile se ad esempio execute_action fa operazioni lente (ad esempio 
+    scrittura su database, connessioni HTTP ecc..) ma abbiamo bisogno
+    del suo valore di ritorno per continuare una determinata operazione
+    (in questo caso la data di completamento dell'esecuzione), 
+    senza però bloccare le altre operazioni che non hanno bisogno di tale
+    valore, in questo caso console.log("I started here!");
+
+    Questo però è solo un esempio in quanto le istruzioni verranno
+    eseguite in maniera sincrona (non concorrenti), ma che ci permette di
+    comprendere le basi di questo meccanismo.
+    */
+    
+    /* ===== End Simple Callback ===== */
+}
+
+entryPoint();

backend/tutorials/delay.js

@@ -0,0 +1,12 @@
+/*
+    The built-in function setTimeout uses callbacks. Create a promise-based alternative.
+    The function delay(ms) should return a promise. That promise should resolve after ms milliseconds, so that we can add .then to it, like this:
+*/
+
+function delay(ms){
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+
+delay(1000).then(() => console.log("Hello world!"));

backend/tutorials/promises.js

@@ -0,0 +1,46 @@
+// https://javascript.info/promise-basics
+
+/*
+    The function passed to Promise is called "executor". When Promise gets
+    created, the executor gets executed.
+    When the Promise ends, it should either call the "resolve" or "reject"
+    callbacks:
+    resolve(value) — if the job is finished successfully, with result value.
+    reject(error) — if an error has occurred, error is the error object.
+*/
+let promise = new Promise(function(resolve, reject) {
+    setTimeout(() => resolve("done"), 500);
+  });
+
+/*
+    The first argument of .then is a function that runs when the promise is resolved and receives the result.
+    The second argument of .then is a function that runs when the promise is rejected and receives the error.
+*/
+promise.then(
+    result => console.log("The operation was successful. It returned " + result),
+    error => console.log("The operation was not successful: " + error)
+);
+
+/*
+    Or we can pass only one argument if we're interested only in a positive result
+*/
+promise.then(
+    result => console.log("The operation was successful. It returned " + result)
+);
+
+/*
+    Or we can pass only one argument to the method "catch" if we're interested
+    in negative results only.
+
+    promise.catch internally just calls promise.then(null, f)
+*/
+promise.catch(
+    error => console.log(error)
+);
+
+/*
+    finally gets always called
+*/
+promise.finally(
+    () => console.log("The execution has terminated. Bye")
+);