a

src/index.js

@@ -5,38 +5,38 @@ const {
   addData,
   hydrateAndFilter,
   cozyClient
-} = require("cozy-konnector-libs");
-const rp = require("request-promise");
-const moment = require("moment");
-require("moment-timezone");
+} = require('cozy-konnector-libs')
+const rp = require('request-promise')
+const moment = require('moment')
+require('moment-timezone')
 
-moment.locale("fr"); // set the language
-moment.tz.setDefault("Europe/Paris"); // set the timezone
+moment.locale('fr') // set the language
+moment.tz.setDefault('Europe/Paris') // set the timezone
 
 const startDate = moment()
-  .startOf("year")
+  .startOf('year')
   // .subtract(3, 'year') TODO PUT TERNARY EXPRESSION FOR MANUAL LAUNCH
-  .subtract(1, "year")
-  .subtract(1, "day")
-  .format("MM/DD/YYYY");
-const endDate = moment().format("MM/DD/YYYY");
-const timeRange = ["day", "month", "year"];
+  .subtract(1, 'year')
+  .subtract(1, 'day')
+  .format('MM/DD/YYYY')
+const endDate = moment().format('MM/DD/YYYY')
+const timeRange = ['day', 'month', 'year']
 const rangeDate = {
   day: {
-    doctype: "com.grandlyon.egl.day",
-    keys: ["year", "month", "day"]
+    doctype: 'com.grandlyon.egl.day',
+    keys: ['year', 'month', 'day']
   },
   month: {
-    doctype: "com.grandlyon.egl.month",
-    keys: ["year", "month"]
+    doctype: 'com.grandlyon.egl.month',
+    keys: ['year', 'month']
   },
   year: {
-    doctype: "com.grandlyon.egl.year",
-    keys: ["year"]
+    doctype: 'com.grandlyon.egl.year',
+    keys: ['year']
   }
-};
+}
 
-module.exports = new BaseKonnector(start);
+module.exports = new BaseKonnector(start)
 
 // The start function is run by the BaseKonnector instance only when it got all the account
 // information (fields). When you run this connector yourself in "standalone" mode or "dev" mode,
@@ -45,82 +45,82 @@ async function start(fields, cozyParameters) {
   try {
     // resetting data for demo only
     // await resetData()
-    const baseUrl = cozyParameters.secret.eglBaseURL;
-    const apiAuthKey = cozyParameters.secret.eglAPIAuthKey;
-    log("info", "Authenticating ...");
+    const baseUrl = cozyParameters.secret.eglBaseURL
+    const apiAuthKey = cozyParameters.secret.eglAPIAuthKey
+    log('info', 'Authenticating ...')
     const response = await authenticate(
       fields.login,
       fields.password,
       baseUrl,
       apiAuthKey
-    );
-    log("info", "Successfully logged in");
+    )
+    log('info', 'Successfully logged in')
     Promise.all(
       timeRange.map(timeStep =>
         processData(timeStep, response, baseUrl, apiAuthKey)
       )
-    );
+    )
   } catch (error) {
-    throw new Error(error.message);
+    throw new Error(error.message)
   }
 }
 async function processData(timeStep, response, baseUrl, apiAuthKey) {
-  const doctype = rangeDate[timeStep].doctype;
-  log("info", "Getting data TIMESTEP : " + timeStep);
-  const loadProfile = await getData(response, baseUrl, apiAuthKey);
-  log("info", "Saving data to Cozy");
+  const doctype = rangeDate[timeStep].doctype
+  log('info', 'Getting data TIMESTEP : ' + timeStep)
+  const loadProfile = await getData(response, baseUrl, apiAuthKey)
+  log('info', 'Saving data to Cozy')
   if (doctype === rangeDate.day.doctype) {
-    log("info", "Saving daily data" + loadProfile);
-    await storeData(loadProfile, rangeDate.day.doctype, rangeDate.day.keys);
+    log('info', 'Saving daily data' + loadProfile)
+    await storeData(loadProfile, rangeDate.day.doctype, rangeDate.day.keys)
   } else if (doctype === rangeDate.month.doctype) {
-    await resetInProgressAggregatedData(rangeDate.month.doctype);
-    const monthlyData = processMonthlyAggregation(loadProfile, rangeDate.month);
-    log("info", "Saving monthly data" + monthlyData);
-    await storeData(monthlyData, rangeDate.month.doctype, rangeDate.month.keys);
+    await resetInProgressAggregatedData(rangeDate.month.doctype)
+    const monthlyData = processMonthlyAggregation(loadProfile, rangeDate.month)
+    log('info', 'Saving monthly data' + monthlyData)
+    await storeData(monthlyData, rangeDate.month.doctype, rangeDate.month.keys)
   } else if (doctype === rangeDate.year.doctype) {
-    await resetInProgressAggregatedData(rangeDate.year.doctype);
+    await resetInProgressAggregatedData(rangeDate.year.doctype)
     const yearlyData = processYearAggregation(
       loadProfile,
       rangeDate.year.doctype
-    );
-    log("info", "Saving yearly data" + yearlyData);
-    await storeData(yearlyData, rangeDate.year.doctype, rangeDate.year.keys);
+    )
+    log('info', 'Saving yearly data' + yearlyData)
+    await storeData(yearlyData, rangeDate.year.doctype, rangeDate.year.keys)
   } else {
-    throw new Error("Unkonw range type: " + doctype);
+    throw new Error('Unkonw range type: ' + doctype)
   }
 }
 
 async function authenticate(login, password, baseUrl, apiAuthKey) {
   const authRequest = {
-    method: "POST",
-    uri: baseUrl + "/connect.aspx",
+    method: 'POST',
+    uri: baseUrl + '/connect.aspx',
     headers: {
       AuthKey: apiAuthKey,
-      "Content-Type": "application/x-www-form-urlencoded"
+      'Content-Type': 'application/x-www-form-urlencoded'
     },
     form: {
       login: login,
       pass: password
     },
     json: true
-  };
-  const response = await rp(authRequest);
+  }
+  const response = await rp(authRequest)
   if (response.codeRetour === 100) {
-    return response;
+    return response
   } else {
-    throw new Error(errors.LOGIN_FAILED);
+    throw new Error(errors.LOGIN_FAILED)
   }
 }
 
 async function getData(response, baseUrl, apiAuthKey) {
-  log("debug", "Start date : " + startDate);
-  log("debug", "End date : " + endDate);
+  log('debug', 'Start date : ' + startDate)
+  log('debug', 'End date : ' + endDate)
   const dataRequest = {
-    method: "POST",
-    uri: baseUrl + "/getAllAgregatsByAbonnement.aspx",
+    method: 'POST',
+    uri: baseUrl + '/getAllAgregatsByAbonnement.aspx',
     headers: {
       AuthKey: apiAuthKey,
-      "Content-Type": "application/x-www-form-urlencoded"
+      'Content-Type': 'application/x-www-form-urlencoded'
     },
     form: {
       token: response.resultatRetour.token,
@@ -129,139 +129,139 @@ async function getData(response, baseUrl, apiAuthKey) {
       date_fin: endDate
     },
     json: true
-  };
+  }
   try {
-    const responseEgl = await rp(dataRequest);
+    const responseEgl = await rp(dataRequest)
     switch (responseEgl.codeRetour) {
       case 100:
-        return format(responseEgl);
+        return format(responseEgl)
       case -2:
-        throw new Error(errors.LOGIN_FAILED);
+        throw new Error(errors.LOGIN_FAILED)
       case -1:
-        throw new Error(errors.VENDOR_DOWN);
+        throw new Error(errors.VENDOR_DOWN)
       default:
-        throw new Error(errors.UNKNOWN_ERROR);
+        throw new Error(errors.UNKNOWN_ERROR)
     }
   } catch (error) {
-    throw new Error(errors.VENDOR_DOWN);
+    throw new Error(errors.VENDOR_DOWN)
   }
 }
 
 function format(response) {
   const data = response.resultatRetour
     .slice(1)
-    .filter(value => value.ValeurIndex);
-  const dataLen = data.length;
+    .filter(value => value.ValeurIndex)
+  const dataLen = data.length
   data.map((value, index) => {
-    const time = moment(value.DateReleve, moment.ISO_8601);
+    const time = moment(value.DateReleve, moment.ISO_8601)
     if (index + 1 < dataLen) {
       log(
-        "info",
-        "date -> " +
+        'info',
+        'date -> ' +
           value.DateReleve +
-          " SUBSTRACTING : " +
+          ' SUBSTRACTING : ' +
           value.ValeurIndex +
-          " - " +
+          ' - ' +
           response.resultatRetour[index].ValeurIndex +
-          "\n"
-      );
+          '\n'
+      )
       return {
         load: data[index + 1].ValeurIndex - value.ValeurIndex,
-        year: parseInt(time.format("YYYY")),
-        month: parseInt(time.format("M")),
-        day: parseInt(time.format("D")),
+        year: parseInt(time.format('YYYY')),
+        month: parseInt(time.format('M')),
+        day: parseInt(time.format('D')),
         hour: 0,
         minute: 0,
         type: value.TypeAgregat
-      };
+      }
     } else {
       return {
         load: null,
-        year: parseInt(time.format("YYYY")),
-        month: parseInt(time.format("M")),
-        day: parseInt(time.format("D")),
+        year: parseInt(time.format('YYYY')),
+        month: parseInt(time.format('M')),
+        day: parseInt(time.format('D')),
         hour: 0,
         minute: 0,
         type: value.TypeAgregat
-      };
+      }
     }
-  });
-  log("info", "DATALOAD LIST\n");
+  })
+  log('info', 'DATALOAD LIST\n')
   data.map(value => {
     log(
-      "info",
+      'info',
       value.month +
-        "-" +
+        '-' +
         value.day +
-        "-" +
+        '-' +
         value.year +
-        " : " +
+        ' : ' +
         value.load +
-        "\n"
-    );
-  });
-  return data;
+        '\n'
+    )
+  })
+  return data
 }
 
 function processYearAggregation(data, doctype) {
-  log("info", "Start aggregation for : " + doctype);
-  const grouped = data.reduce(reduceYearFunction, {});
-  return Object.values(grouped);
+  log('info', 'Start aggregation for : ' + doctype)
+  const grouped = data.reduce(reduceYearFunction, {})
+  return Object.values(grouped)
 }
 
 function processMonthlyAggregation(data, range) {
-  log("info", "Start aggregation for : " + range.doctype);
+  log('info', 'Start aggregation for : ' + range.doctype)
   // Filter by year
-  const tmpData = groupBy(data, "year");
-  const keys = Object.keys(tmpData);
-  var dataToStore = [];
+  const tmpData = groupBy(data, 'year')
+  const keys = Object.keys(tmpData)
+  var dataToStore = []
   // Monthly aggregation
   for (const index in keys) {
     // Get daily data of a year
-    var monthlyData = tmpData[keys[index]];
+    var monthlyData = tmpData[keys[index]]
     // Monthly aggregation
-    var aggregatedData = monthlyData.reduce(reduceMonthFunction, {});
+    var aggregatedData = monthlyData.reduce(reduceMonthFunction, {})
     // Store it
-    dataToStore = dataToStore.concat(Object.values(aggregatedData));
+    dataToStore = dataToStore.concat(Object.values(aggregatedData))
   }
-  return dataToStore;
+  return dataToStore
 }
 
 function groupBy(xs, key) {
   return xs.reduce(function(rv, x) {
-    (rv[x[key]] = rv[x[key]] || []).push(x);
-    return rv;
-  }, {});
+    ;(rv[x[key]] = rv[x[key]] || []).push(x)
+    return rv
+  }, {})
 }
 
 function reduceYearFunction(acc, x) {
-  var id = acc[x.year];
+  var id = acc[x.year]
   if (id) {
-    id.load += x.load;
+    id.load += x.load
   } else {
-    acc[x.year] = x;
+    acc[x.year] = x
   }
-  return acc;
+  return acc
 }
 
 function reduceMonthFunction(acc, x) {
-  var id = acc[x.month];
+  var id = acc[x.month]
   if (id) {
-    id.load += x.load;
+    id.load += x.load
   } else {
-    acc[x.month] = x;
+    acc[x.month] = x
   }
-  return acc;
+  return acc
 }
 
 async function storeData(data, doctype, keys) {
-  log("debug", "Store into " + doctype);
-  log("debug", keys, "Store into keys ");
+  log('debug', 'Store into ' + doctype)
+  log('debug', keys, 'Store into keys ')
   return hydrateAndFilter(data, doctype, {
     keys: keys
   }).then(filteredDocuments => {
-    addData(filteredDocuments, doctype);
-  });
+    addData(filteredDocuments, doctype)
+  })
 }
 
 /**
@@ -273,33 +273,33 @@ async function storeData(data, doctype, keys) {
  */
 async function resetInProgressAggregatedData(doctype) {
   // /!\ Warning: cannot use mongo queries because not supported for dev by cozy-konnectors-libs
-  log("debug", doctype, "Remove aggregated data for");
-  const result = await cozyClient.data.findAll(doctype);
+  log('debug', doctype, 'Remove aggregated data for')
+  const result = await cozyClient.data.findAll(doctype)
   if (result.error || result.length <= 0) {
     // eslint-disable-next-line no-console
-    console.warn("Error while fetching loads, doctype not found ");
+    console.warn('Error while fetching loads, doctype not found ')
   } else {
-    const currentDate = moment();
+    const currentDate = moment()
     // Filter data to remove
-    var filtered = [];
+    var filtered = []
     if (doctype === rangeDate.year.doctype) {
       // Yearly case
       filtered = result.filter(function(el) {
-        return el.year == currentDate.year();
-      });
+        return el.year == currentDate.year()
+      })
     } else {
       // Monthly case
       filtered = result.filter(function(el) {
         return (
           el.year == currentDate.year() &&
-          el.month == parseInt(moment().format("M"))
-        );
-      });
+          el.month == parseInt(moment().format('M'))
+        )
+      })
     }
     // Remove data
     for (const doc of filtered) {
-      log("debug", doc, "Removing this entry for " + doctype);
-      await cozyClient.data.delete(doctype, doc);
+      log('debug', doc, 'Removing this entry for ' + doctype)
+      await cozyClient.data.delete(doctype, doc)
     }
   }
 }