Lambda se întoarce cu 200 cu obiect gol, neintrăgând ca apelul să dea foc

voturi
25

Mă lovesc de api calendarul Google și am o configurare lambda într-o încercare de capturare. Am incercat sa adaug asteptarea la fiecare functie, am incercat sa mut revenirea la dupa if (err), dar asta imi ofera 500. Ceea ce trebuie sa fac este sa transmit datele matrice din functia api calendar Google la mesaj, astfel incat sa pot primi în fața mea din față. Iată lambda până acum. Orice ajutor ar fi foarte apreciat. Mulțumiri


const { google } = require(googleapis)
const { OAuth2 } = google.auth
const faunadb = require(faunadb) /* Import faunaDB sdk */

// Docs on event and context https://www.netlify.com/docs/functions/#the-handler-method
exports.handler = async (event, context) => {
  try {
    const OAuth2Client = new OAuth2(
      FDSAF,
      FDSAF
    )

    // Connect to the database
    const q = faunadb.query
    const client = new faunadb.Client({
      secret: FDSAFA,
    })

    let refreshToken

    await client
      .query(q.Get(q.Ref(q.Collection(AuthUrl), fdsa)))
      .then(ret => (refreshToken = ret.data.title.refresh_token))

    console.log(refreshToken)

    OAuth2Client.setCredentials({
      refresh_token: refreshToken,
    })

    // Create a new calender instance.
    const calendar = google.calendar({ version: v3, auth: OAuth2Client })



    let ok
    function listEvents(callback) {
      let array = []

      calendar.events.list(
        {
          calendarId: primary,
          // timeMin: new Date().toISOString(),
          maxResults: 100000,
          singleEvents: true,
          orderBy: startTime,
        },
        (err, res) => {
          if (err) return console.log(The API returned an error:  + err)

          var date = new Date()
          var firstDay = new Date(date.getFullYear(), date.getMonth(), 1)
          var lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0)

          //console.log(res.data.items)
          const events = res.data.items
          if (events.length) {
            //   console.log(Upcoming 10 events:)
            events.map((event, i) => {
              const start = new Date(event.start.dateTime || event.start.date)
              const end = new Date(event.end.dateTime || event.end.date)

              if (start >= firstDay && end <= lastDay) {
                console.log(start, end, event.summary)
                //ok = test
                array.push(start)
                callback(array)
              }

              //     const start = event.start.dateTime || event.start.date
              //     console.log(`${start} - ${event.summary}`)
            })
          } else {
            console.log(No upcoming events found.)
          }
        }
      )
    }

    let array

    listEvents(function (eventList) {
      array = eventList
    })



    return {
      statusCode: 200,
      body: JSON.stringify({ message: array }),
      // // more keys you can return:
      // headers: { headerName: headerValue, ... },
      // isBase64Encoded: true,
    }
  } catch (err) {
    return { statusCode: 500, body: err.toString() }
  }
}

Acesta este efectul pe care îl fac pentru front end și returnează un obiect gol

const IndexPage = () => {
  fetch(/functions/list-calendar)
    .then(response => response.json())
    .then(response => {
      console.log(response)
    })
Întrebat 17/05/2020 la 20:06
sursa de către utilizator
În alte limbi...                            


1 răspunsuri

voturi
0

Mie mi se pare că vă returnați răspunsul înainte ca apelul să fie executat. Dacă nu ești familiar async și await , ar trebui să citiți această documentație . Practic, trebuie să așteptați să apară apelul înainte de a vă întoarce, și puteți face acest lucru folosind funcții de apelare inversă, lanțuri întinse sau funcții asincine.

Am observat, de asemenea, în codul dvs. că sunati apelul de apel de fiecare dată când faceți o apăsare în tablou. Cred că este mai simplu să îți împingi toate articolele array și apoi apelare înapoi la matrice.

În loc să facă o apăsare pe hartă (care este confuză), aceasta va întoarce o nouă serie de event.start.dateTime și pentru că dacă (start >= firstDay && end <= lastDay) este fals, adaugă a null la tablou, deci .filter(x => Boolean(x)); le filtrează astfel încât să obții doar o serie de date.

let array = events.map((event, i) => {
    const start = new Date(event.start.dateTime || event.start.date)
    const end = new Date(event.end.dateTime || event.end.date)

    if (start >= firstDay && end <= lastDay) {
      return start;
    else
      return null;

      //     const start = event.start.dateTime || event.start.date
      //     console.log(`${start} - ${event.summary}`)
    })
    .filter(x => Boolean(x));

Versiune simplă

Puteți muta întoarcerea în apelul invers.

listEvents(function (eventList) {
  array = eventList;

  return {
    statusCode: 200,
    body: JSON.stringify({ message: array }),
    // // more keys you can return:
    // headers: { "headerName": "headerValue", ... },
    // isBase64Encoded: true,
  }
});

Versiunea Promise

Nodul meu este puțin ruginit, dar ai putea schimba metoda pentru a-ți întoarce o promisiune.

function listEvents(callback) {
  return new Promise((resolve, reject) => {


    calendar.events.list(
    {
      calendarId: "primary",
      // timeMin: new Date().toISOString(),
      maxResults: 100000,
      singleEvents: true,
      orderBy: "startTime",
    },
    (err, res) => {
      if (err) reject("The API returned an error: " + err));

      var date = new Date()
      var firstDay = new Date(date.getFullYear(), date.getMonth(), 1)
      var lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0)

      //console.log(res.data.items)
      const events = res.data.items
      if (events.length) {
        //   console.log("Upcoming 10 events:")
        let array = events.map((event, i) => {
          const start = new Date(event.start.dateTime || event.start.date)
          const end = new Date(event.end.dateTime || event.end.date)

          if (start >= firstDay && end <= lastDay) {
            return start;
          else
            return null;

          //     const start = event.start.dateTime || event.start.date
          //     console.log(`${start} - ${event.summary}`)
        }).filter(x => Boolean(x));

        resolve(array);
      } else {
        resolve([]);
      }
    })
  });
}

și apoi, din moment ce utilizați deja async,

let array = await listEvents();
Publicat 23/05/2020 la 15:33
sursa de către utilizator

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more