Appointment calendar

backend/loaders/express.js

@@ -9,7 +9,8 @@ const {
   baseRoute, registerRoute, userRoute, forgotPasswordRoute, usersRoute, clientsRoute,
   characteristicRoute, questionRoute, dynamicFormRoute, genericRoute, advancedSearchRoute, serviceProviderRoute,needRoute,
   needSatisfierRoute, outcomeRoute, internalTypeRoute, serviceProvisionRoute, programProvisionRoute,
-  matchingRoute, partnerNetworkApiRoute, partnerNetworkPublicRoute, partnerOrganizationRoute
+  matchingRoute, partnerNetworkApiRoute, partnerNetworkPublicRoute, partnerOrganizationRoute,
+  calendarRoute
 } = require('../routes');
 const {authMiddleware, errorHandler} = require('../services/middleware');
 
@@ -62,6 +63,7 @@ app.use('/api', programProvisionRoute);
 app.use('/api', matchingRoute);
 app.use('/api', partnerNetworkApiRoute);
 app.use('/api', partnerOrganizationRoute);
+app.use('/api', calendarRoute)
 
 // Authentication not required
 app.use('/public', partnerNetworkPublicRoute);

backend/models/appointment.js

@@ -11,7 +11,11 @@ const GDBAppointmentModel = createGraphDBModel({
   person: {type: GDBPersonModel, internalKey: ':hasPerson'},
   user: {type: GDBUserAccountModel, internalKey: ':withUser'},
   characteristicOccurrences : {type: [GDBCOModel], internalKey: ':hasCharacteristicOccurrence'},
-  address: {type: GDBAddressModel, internalKey: 'ic:hasAddress'}
+  address: {type: GDBAddressModel, internalKey: 'ic:hasAddress'},
+
+  startDate: {type: Date, internalKey: ':hasStartDate'},
+  endDate: {type: Date, internalKey: ':hasEndDate'},
+  appointmentName: {type: String, internalKey: ':hasName'},
 }, {
   rdfTypes: [':Appointment'], name: 'appointment'
 });

backend/models/userAccount.js

@@ -34,7 +34,9 @@ const GDBUserAccountModel = createGraphDBModel({
   status: {type: String, internalKey: ':hasAccountStatus'},
 
   // Exact 3 questions, the answer should be case-insensitive.
-  securityQuestions: {type: [GDBSecurityQuestion], internalKey: ':hasSecurityQuestion', onDelete: DeleteType.CASCADE}
+  securityQuestions: {type: [GDBSecurityQuestion], internalKey: ':hasSecurityQuestion', onDelete: DeleteType.CASCADE},
+
+  googleRefreshToken: {type: String, internalKey: ':hasGoogleRefreshToken'},
 
 }, {
   rdfTypes: [':UserAccount'], name: 'userAccount'

backend/package.json

@@ -13,13 +13,16 @@
   },
   "author": "",
   "dependencies": {
+    "@google-cloud/local-auth": "^3.0.1",
     "chevrotain": "^11.0.3",
     "cookie-parser": "^1.4.6",
     "cookie-session": "^2.0.0",
     "cors": "^2.8.5",
     "dotenv": "^16.0.1",
     "express": "^4.18.1",
     "form-data": "^4.0.0",
+    "google-auth-library": "^9.7.0",
+    "googleapis": "^134.0.0",
     "graphdb": "^2.0.0",
     "graphdb-utils": "git+https://github.com/csse-uoft/graphdb-utils.git",
     "jsonwebtoken": "^8.5.1",

backend/routes/calendar.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const {fetchAppointment} = require("../services/calendar");
+const {fetchGoogleAppointments, storeGoogleAppointments, GoogleLogin, updateGoogleLogin} = require("../services/calendar/googleCalendar");
+const router = express.Router();
+
+router.post('/calendar', fetchAppointment);
+
+router.post('/calendar_google_login', updateGoogleLogin)
+
+router.post('/calendar_google', fetchGoogleAppointments);
+
+router.put('/calendar_google', storeGoogleAppointments);
+
+module.exports = router;

backend/routes/index.js

@@ -20,4 +20,6 @@ module.exports = {
   partnerNetworkApiRoute: require('./partnerNetworkApi'),
   partnerNetworkPublicRoute: require('./partnerNetworkPublic'),
   partnerOrganizationRoute: require('./partnerOrganization'),
+  calendarRoute: require('./calendar'),
+
 }

backend/services/calendar/googleCalendar.js

@@ -0,0 +1,109 @@
+const {google} = require('googleapis');
+const {updateUserAccount} = require("../userAccount/user");
+const {findUserAccountById} = require("../userAccount/user");
+
+require('dotenv').config();
+GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID;
+GOOGLE_CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET;
+
+const oAuth2Client = new google.auth.OAuth2(
+  GOOGLE_CLIENT_ID,
+  GOOGLE_CLIENT_SECRET,
+  "http://localhost:3000"
+);
+
+async function updateGoogleLogin(req, res, next){
+  const { codeResponse, userId } = req.body;
+  const currentUser = await findUserAccountById(userId); // This is a function from userAccount/user.js that finds a user by ID
+
+  const code = req.body.code;
+  const {tokens} = await oAuth2Client.getToken(code);
+  oAuth2Client.setCredentials({refresh_token: tokens.refresh_token});
+  const email = currentUser.primaryEmail;
+  await updateUserAccount(email, {googleRefreshToken: tokens.refresh_token});
+
+}
+
+async function fetchGoogleAppointments(req, res, next) {
+  const { userId } = req.body;
+  try {
+    const currentUser = await findUserAccountById(userId); // Finds a user by ID
+    // Check if currentUser has a googleRefreshToken
+    if (currentUser.googleRefreshToken) {
+      console.log("Found refresh token");
+      oAuth2Client.setCredentials({refresh_token: currentUser.googleRefreshToken});
+    }
+
+    const calendar = google.calendar({version: 'v3', auth: oAuth2Client});
+    const response = await calendar.events.list({
+      calendarId: 'primary',
+      maxResults: 2500,
+      singleEvents: true,
+      orderBy: 'startTime',
+    });
+
+    const events = response.data.items;
+    const data = events.map(event => {
+      const start = Date.parse(event.start.dateTime || event.start.date);
+      const end = Date.parse(event.end.dateTime || event.end.date);
+      return {startDate: start, endDate: end, appointmentName: event.summary};
+    });
+
+    return res.status(200).json({success: true, data});
+  } catch (error) {
+    if (error.response && error.response.data && error.response.data.error === 'invalid_grant') {
+      console.error("Refresh token is invalid or expired.");
+      return res.status(401).json({success: false, message: "Authentication failed. Please log in again."});
+    }
+    console.error("An error occurred:", error.message);
+    return res.status(500).json({success: false, message: "An internal error occurred."});
+  }
+}
+
+async function storeGoogleAppointments(req, res, next) {
+  const { userId } = req.body;
+  try {
+    const currentUser = await findUserAccountById(userId); // Finds a user by ID
+    // Check if currentUser has a googleRefreshToken
+    if (currentUser.googleRefreshToken) {
+      oAuth2Client.setCredentials({refresh_token: currentUser.googleRefreshToken});
+    }
+
+    const calendar = google.calendar({version: 'v3', auth: oAuth2Client});
+
+    let startDate = new Date(req.body.start);
+    let endDate = new Date(req.body.end);
+
+    // Add an event to the calendar
+    const event = {
+      summary: req.body.name,
+      description: 'This is a test of the Google Calendar API',
+      start: {
+        dateTime: startDate,
+        timeZone: 'America/Los_Angeles',
+      },
+      end: {
+        dateTime: endDate,
+        timeZone: 'America/Los_Angeles',
+      },
+    };
+
+    await calendar.events.insert({
+      calendarId: 'primary',
+      requestBody: event,
+    });
+
+    return res.status(200).json({success: true});
+  } catch (error) {
+    if (error.response && error.response.data && error.response.data.error === 'invalid_grant') {
+      console.error("Refresh token is invalid or expired.");
+      return res.status(401).json({success: false, message: "Authentication failed. Please log in again."});
+    }
+    console.error("An error occurred:", error.message);
+    return res.status(500).json({success: false, message: "An internal error occurred."});
+  }
+}
+
+
+
+module.exports = {fetchGoogleAppointments, storeGoogleAppointments, updateGoogleLogin};

backend/services/calendar/index.js

@@ -0,0 +1,96 @@
+const {GDBAppointmentModel} = require("../../models/appointment");
+const {GDBServiceProviderModel} = require("../../models");
+const {extractAllIndexes} = require("../../helpers/stringProcess");
+const {graphdb} = require("../../config");
+const {GDBCharacteristicModel} = require("../../models/ClientFunctionalities/characteristic");
+const {GDBCOModel} = require("../../models/ClientFunctionalities/characteristicOccurrence");
+
+async function fetchAppointment(req, res, next) {
+
+  const fts_appointments = await fts_appointment_for_calendar(req.body);
+  if (fts_appointments.length === 0) {
+    return res.status(200).json({data: [], success: true});
+  }
+
+  let array = [...new Set([...fts_appointments])];
+
+  if (array.length !== 0) {
+    let data_array = [];
+    for (let i = 0; i < array.length; i++) {
+      data_array.push(await GDBAppointmentModel.find({_uri: array[i]},
+        {populates: ['characteristicOccurrences.occurrenceOf']}));
+
+      // Obtain the values from the characteristicOccurrences
+      // Iterate through the characteristicOccurrences
+      // for (let j = 0; j < data_array[i][0].characteristicOccurrences.length; j++) {
+      //   let occurrence = data_array[i][0].characteristicOccurrences[j];
+      //   if (occurrence.occurrenceOf) {
+      //     // Check if the occurrence is the start date of the appointment
+      //     if (occurrence.occurrenceOf.description === "Start date of a service Occurrence") {
+      //       // Get the date
+      //       data_array[i][0].set("start", occurrence.dataDateValue);
+      //       // data_array[i][0].set("end", new Date());
+      //     }
+      //     if (occurrence.occurrenceOf.description === "End date of a service Occurrence") {
+      //       // Get the date
+      //       data_array[i][0].set("end", occurrence.dataDateValue);
+      //     }
+      //     // Obtain the title of the appointment
+      //     if (occurrence.occurrenceOf.description === "Appointment Name") {
+      //       data_array[i][0].set("title", occurrence.dataStringValue);
+      //     }
+      //   }
+      // }
+    }
+    data = data_array.flat();
+  }
+
+  return res.status(200).json({data, success: true});
+}
+
+async function fts_appointment_for_calendar(params) {
+  // Assume all passed in date are in the format of "2024-02-22T00:00:00Z"
+  const {user_id, startDate, endDate} = params;
+
+  // let date_query;
+  // if (!startDate || !endDate) {
+  //   date_query = ``;
+  // } else {
+  //   date_query = `FILTER (?date >= xsd:dateTime("${startDate}") && ?date < xsd:dateTime("${endDate}")).`;
+  // }
+
+  // The id of the user should be an integer like 1, 2, 3, etc.
+  let person_query;
+  if (!user_id) {
+    person_query = ``;
+  } else {
+    person_query = `?object1 snmi:hasPerson snmi:person_${user_id}.`;
+  }
+
+  const sparqlQuery =
+    `
+PREFIX  xsd:  <http://www.w3.org/2001/XMLSchema#>
+PREFIX  snmi: <http://snmi#>
+PREFIX  rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+SELECT DISTINCT  ?object1
+WHERE
+  { ?object1  rdf:type  snmi:Appointment
+    { 
+        ${person_query}
+    }
+  }
+      `;
+
+  console.log("Query: ", sparqlQuery);
+
+  let query = graphdb.addr + "/repositories/snmi?query="  + encodeURIComponent(sparqlQuery);
+
+  const response = await fetch(query);
+  const text = await response.text();
+  return extractAllIndexes(text);
+
+}
+
+
+module.exports = {fetchAppointment};

backend/services/userAccount/user.js

@@ -36,7 +36,7 @@ async function updateUserAccount(email, updatedData) {
 
   const {
     securityQuestions, status, givenName, familyName, countryCode,
-    areaCode, phoneNumber, altEmail
+    areaCode, phoneNumber, altEmail, googleRefreshToken
   } = updatedData
   if (securityQuestions) {
     const answer1 = await Hashing.hashPassword(securityQuestions[3]);
@@ -94,6 +94,10 @@ async function updateUserAccount(email, updatedData) {
     userAccount.secondaryEmail = altEmail;
   }
 
+  if (googleRefreshToken) {
+    userAccount.googleRefreshToken = googleRefreshToken;
+  }
+
   await userAccount.save();
   console.log(userAccount)
   return userAccount;