Javascript 当wait'；s don'；我认不出来？

我试图在

var application=await SchedulerService（）上使用
await
。getIssues（issueId）

并返回错误：

SyntaxError:await仅在异步函数中有效

我从node.js开始。我能做些什么来修复它

---

我已经试过了

• 在第1行的初始函数

  const SchedulerService=wait function（）{

  之前添加异步

• 在第一次返回时添加async

  returnasync（）=>{

  第3行的

  return{

---

从“../../config/scheduler”导入schedulerConf；
从“../../config/auth”导入authConf；
从“../../config/application”导入applicationConf；
从“请求”导入请求；
从“节点计划”导入计划；
从“dateformat”导入dateformat；
设相互作用=0；
var servicecords=[]；
var发行记录=[]；
const SchedulerService=函数（）{
返回{
初始化：异步（）=>{
log（`****在${dateformat（new Date（），“dd/mm/yyyy HH:mm:ss”）}上启动调度程序）；
var j=schedule.scheduleJob（'*/1****'，function（）{
控制台。时间（'└─ 调度程序执行时间）；
如果（迭代===0）{
log（`Setting scheduler runtime to full time.`）；
}否则{
console.log（`------------------`）；
}
交互++；
log（`Job execution number:${interactions}.`）；
SchedulerService（）.execute（）
。然后（响应=>{
console.log(`└─ 作业${interactions}已成功执行。`）；
console.log(`└─ 执行日期${dateformat（new date（），“dd/mm/yyyy HH:mm:ss”）}`）；
控制台。时间结束（'└─ 调度程序执行时间）；
}).catch（错误=>{
console.log(`└─ 作业${interactions}在执行时返回错误。`）；
});
});
},
执行：异步（）=>{
返回SchedulerService（）.getRecords2Sync（）
.然后（（）=>{
SchedulerService（）.sync（）。然后（（）=>{
}).catch（错误=>{console.log（{error}）}）；
}).catch（错误=>{console.log（{error}）}）；
},
getRecords2Sync:async（）=>{
serviceRecords=[]；
变量选项={
网址：`http://localhost:${authConf.serverPort}/application`，
方法：“GET”，
标题：{
授权：`${authConf.secret}`
}
}              
返回新承诺（功能（解决、拒绝）{
请求（选项、功能（错误、恢复、正文）{
如果（！error&&res.statusCode==200）{
const srs=JSON.parse（body）；
常数响应=srs[‘响应’]；
for（设i=0；i{
发行记录=[]；
返回新承诺（函数（解析、拒绝）{
变量选项={
网址：`http://localhost:${authConf.serverPort}/application2/${issueId}`，
方法：“GET”，
标题：{
授权：`${authConf.secret}`
}
}            
请求（选项、功能（错误、恢复、正文）{
如果（！error&&res.statusCode==200）{
const issues=JSON.parse（body）；
const{issue}=issues.response；
const{id，status，custom_fields}=issue；
push（{id，status，custom_fields}）；
解决（发布记录）；
}否则{
拒绝（错误）；
}
});   
}); 
},
sync:async（）=>{
返回新承诺（功能（解决、拒绝）{
对于（设i=0；iimport schedulerConf from '../../config/scheduler';
import authConf from '../../config/auth';
import applicationConf from '../../config/application';
import request from 'request';
import schedule from 'node-schedule';
import dateformat from 'dateformat';

let interations = 0;
var serviceRecords = [];
var issueRecords = [];

const SchedulerService = function(){

    return {

        initialize: async () => {
            console.log(`***** Starting Scheduler on ${dateformat(new Date(), "dd/mm/yyyy HH:MM:ss")}`);
            var j = schedule.scheduleJob('*/1 * * * *', function(){
                console.time('└─ Scheduler execution time');
                if(interations === 0){
                    console.log(`Setting scheduler runtime to full time.`);
                }else{                    
                    console.log(`------------------------`);
                }
                interations++; 
                console.log(`Job execution number: ${interations}.`);

                SchedulerService().execute()
                .then(response => { 
                    console.log(`└─ Job ${interations} was successfully executed.`);
                    console.log(`└─ Execution date ${dateformat(new Date(), "dd/mm/yyyy HH:MM:ss")}`);
                    console.timeEnd('└─ Scheduler execution time');
                }).catch(error => { 
                    console.log(`└─ Job ${interations} returned error while executing.`);
                });

            });

        },

        execute: async () => {             

            return  SchedulerService().getRecords2Sync()            
                    .then(() => {
                        SchedulerService().sync().then(() => {
                        }).catch(error => {console.log({error})});
                    }).catch(error => {console.log({error})});

        },

        getRecords2Sync: async () => {
            serviceRecords = [];
            var options = {
                url: `http://localhost:${authConf.serverPort}/application`,
                method: 'GET',
                headers: {
                    authorization: `${authConf.secret}`
                }
            }              
            return new Promise(function (resolve, reject) {
                request(options, function (error, res, body) {
                    if (!error && res.statusCode == 200) {
                        const srs = JSON.parse(body);                        
                        const response = srs['response'];
                        for(let i =0;i < response.length;i++){
                            const { id, info } = response[i];
                            var status = "";
                            var issueId = "";
                            var statusClass = "";
                            for(let x = 0; x < info.length; x++){
                                if(info[x].key === "status"){
                                    status = info[x].value;
                                    statusClass = info[x].valueClass;
                                }
                                if(info[x].key === applicationConf.fields.issueId){
                                    issueId = info[x].value;
                                }
                            }
                            if(statusClass === 0){ 
                                if(issueId !== null && issueId !== ""){ 
                                    serviceRecords.push({id, status, issueId});
                                }
                            }
                        }
                        //console.log(serviceRecords);
                        resolve(serviceRecords);
                    } else {
                        //console.log(error);
                        reject(error);
                    }
                });
            });    
        },

        getIssues : async (issueId) => { 
            issueRecords = [];     
            return new Promise(function(resolve, reject) {                                 
                var options = {
                    url: `http://localhost:${authConf.serverPort}/application2/${issueId}`,
                    method: 'GET',
                    headers: {
                        authorization: `${authConf.secret}`
                    }
                }            
                request(options, function(error, res, body) {
                    if (!error && res.statusCode == 200) {

                        const issues = JSON.parse(body);                     
                        const { issue } = issues.response;
                        const { id, status, custom_fields  } = issue;

                        issueRecords.push({id, status, custom_fields});                                       
                        resolve(issueRecords);

                    } else {
                        reject(error);
                    }
                });   
            }); 
        },

        sync : async () => { 
            return new Promise(function(resolve, reject) {

                for (let i = 0; i < serviceRecords.length; i++) { 

                    const application_id = serviceRecords[i].id;        
                    const application_status = serviceRecords[i].status;        
                    const application_issueId = serviceRecords[i].issueId;

                    //console.log('issueRecords.length: ', issueRecords);
                    //console.log('issueRecords.length: ', issueRecords.length);

                    console.log(`********** application`);
                    console.log(`└─ id ${application_id}`);
                    console.log(`└─ status ${application_status}`);
                    console.log(`└─ issueId ${application_issueId}`);

                    var application2 = await SchedulerService().getIssues(application_issueId)
                                        .then(response => {
                                            resolve(() => {
                                                console.log(`i've found a record by issue_id ${application_issueId}`);
                                            });
                                        }).catch(error => {
                                            reject(error);
                                        });


                }
            }); 
        }

    }


}

export default new SchedulerService();

sync: async () => {

  // `map` over the serviceRecords and return a getIssues promise for each issueId
  const promises = serviceRecords.map(({ issueId }) => SchedulerService().getIssues(issueId));

  // Wait for all the promises to resolve
  const data = await Promise.all(promises);

  // Loop over the resolved promises and log the issueId
  data.forEach((issueId, issueRecords) => console.log(issueId));
}