TypeScript bluebird.map函数代码示例

            .then((emailDataList: Array<EmailData>) => {

                const emailDataListWithTriggers: Array<EmailData> =
                    emailDataList.filter((emailData) => emailData.triggeredSendKey !== undefined);

                const triggers: Promise<Array<any>> = Promise.map(emailDataListWithTriggers, createTriggeredSend).map(sendTriggeredSend);
                const subscriptions: Promise<Array<any>> = Promise.map(emailDataList, createSubscription).map(subscribeEmailToList);

                return Promise.join(triggers, subscriptions)
                    .map((responses: Array<any>) => {
                        return responses.map((response: any) => {
                            if (!response.body.Results[0]) throw "No results";
                            return response.body.Results;
                        });
                    })
                    .map((allResponses: Array<Array<any>>) => {
                        allResponses.map((results: Array<any>) => {
                            results.map((result: any) => {
                                console.log(JSON.stringify(result));
                                if (result.StatusCode !== 'OK') {
                                    console.log("Failed! StatusCode: " + result.StatusCode + " StatusMessage: " + result.StatusMessage);
                                    throw result;
                                }
                                return result;
                            });
                        });
                    })
                    .then(() => putStatusToStream(makeSuccessPutRequest(emailDataList)))
                    .catch((error) => {
                        console.log(error);
                        putStatusToStream(makeFailurePutRequest(emailDataList, error))
                    })
                    .then(() => Promise.resolve(emailDataList));
            })

/**
 * Try to detect a single browser definition, which may dispatch multiple `checkOneBrowser` calls,
 * one for each binary. If Windows is detected, only one `checkOneBrowser` will be called, because
 * we don't use the `binary` field on Windows.
 */
function checkBrowser(browser: Browser): Promise<(boolean | FoundBrowser)[]> {
  if (Array.isArray(browser.binary) && os.platform() !== 'win32') {
    return Bluebird.map(browser.binary, (binary: string) => {
      return checkOneBrowser(extend({}, browser, { binary }))
    })
  }
  return Bluebird.map([browser], checkOneBrowser)
}

	return(built.then(() =>

		// Add mappings to any extra packages listed in command line options.

		Promise.map(options.mapPackages || [], (name: string) =>
			findPackage(name, path.resolve(basePath, 'package.json'), basePath, fixTbl, repoTbl)
		)

async function processActivityPubHttpBroadcast (job: kue.Job) {
  logger.info('Processing ActivityPub broadcast in job %d.', job.id)

  const payload = job.data as ActivitypubHttpBroadcastPayload

  const body = await computeBody(payload)
  const httpSignatureOptions = await buildSignedRequestOptions(payload)

  const options = {
    method: 'POST',
    uri: '',
    json: body,
    httpSignature: httpSignatureOptions,
    timeout: JOB_REQUEST_TIMEOUT
  }

  const badUrls: string[] = []
  const goodUrls: string[] = []

  await Bluebird.map(payload.uris, uri => {
    return doRequest(Object.assign({}, options, { uri }))
      .then(() => goodUrls.push(uri))
      .catch(() => badUrls.push(uri))
  }, { concurrency: BROADCAST_CONCURRENCY })

  return ActorFollowModel.updateActorFollowsScore(goodUrls, badUrls, undefined)
}

    .then(schedules => {
      return Promise.map(schedules, schedule => {
        return knex('users')
          .distinct('timezone')
          .select()
          .then(timezones => {
            return Promise.mapSeries(timezones, ({ timezone: tz }) => {
              const initialTz = tz
              const sign = Number(tz) >= 0 ? '+' : '-'
              tz = padDigits(Math.abs(Number(tz)), 2)
              const relTime = moment(`${schedule['date_time']}${sign}${tz}`, 'YYYY-MM-DD HH:mmZ').toDate()
              const adjustedTime = this.db.knex.date.format(schedule['ts'] ? schedule['ts'] : relTime)

              const whereClause = _.isNil(initialTz) ? 'where timezone IS NULL' : 'where timezone = :initialTz'

              const sql = `insert into broadcast_outbox ("userId", "scheduleId", "ts")
            select userId, :scheduleId, :adjustedTime
            from (
              select id as userId
              from users
              ${whereClause}
            ) as q1`

              return knex
                .raw(sql, {
                  scheduleId: schedule['id'],
                  adjustedTime,
                  initialTz
                })
                .then()
            })
          })
          .then(() => {
            return knex('broadcast_outbox')
              .where({ scheduleId: schedule['id'] })
              .select(knex.raw('count(*) as count'))
              .then()
              .get(0)
              .then(({ count }) => {
                return knex('broadcast_schedules')
                  .where({ id: schedule['id'] })
                  .update({
                    outboxed: knex.bool.true(),
                    total_count: count
                  })
                  .then(() => {
                    bp.logger.info('Scheduled broadcast #' + schedule['id'], '. [' + count + ' messages]')

                    if (schedule['filters'] && JSON.parse(schedule['filters']).length > 0) {
                      bp.logger.info(
                        `Filters found on broadcast #${schedule['id']}. Filters are applied at sending time.`
                      )
                    }

                    emitChanged()
                  })
              })
          })
      })
    })

  execute(project, kube) {
    logger.info("Running build!");

    // For now, until Kube supports running one-off jobs (with
    // containers with "privileged mode" turned on to allow nesting),
    // we need to reach out to an *existing* dockerd already running
    // in our cluster (or elsewhere) in order to build images.

    // Now, we have to strategically decide how and when to ship
    // images from the build location (which *may* be a node!) to all
    // of nodes that will run the kube job.  we don't want to be
    // piping bits through the user's laptop if ever avoidable.  If
    // it's a single nod deployment, it's easy, because the image will
    // be on that docker node used by that kubelet already.  Now, say
    // you have a simple environment consisting of two nodes, we have
    // to ship that image to the other node.  We still do not want to
    // ship through the user's laptop, because asymmetric home ISP
    // horrors.

    // now, the right answer might be to always deploy a Pod
    // containing Docker Index (using an image from the public Docker
    // Hub, to avoid chicken/egg issues) in the most basic mode (ie.,
    // a singleton with storage on a UNIX fs, which doesn't scale for
    // shit but is great for getting started and won't depend on Riak
    // CS), and shove the things through that.

    // TODO: this should be injected
    var builder = new DirectBuilder(project, project.env.getBuilderDockerHost(), project.env.getBuilderDockerPort());
    return Promise.map(project.images, function(image) {
        return builder.build(image);
    });
  }

function test4() {
	const unsorted: number[] = [];

	function compare(a: number, b: number) { return(a - b); }

	for(let num = 0; num < 100; ++num) {
		unsorted[num] = ~~(Math.random() * 50);
	}

	const correct = unsorted.slice(0).sort(compare);

	const queue = new TaskQueue(Promise, 1);
	const result: number[] = [];
	const start = new Date().getTime();

	return(
		Promise.map(
			unsorted,
			(item: number) => queue.add(
				() => {
					const delta = new Date().getTime() - start - item * 10;
					if(delta > 0 && delta < 20) result.push(item);
				},
				item * 10
			)
		).then(
			() => result.join(' ') == correct.join(' ') && ++testCount
		)
	);
}

 .map(regions, (region: any) => {
   const ec2Client = new aws.EC2({ region: region });
   return bluebird
     .map(filters, (filterSet: any) => {
       return ec2Client
         .describeImages({
           Filters: filterSet.Filters
         })
         .promise()
         .then((ami: any) => {
           const set: any = {};
           if (ami.Images[0]) {
             set[filterSet.Name] = ami.Images[0].ImageId
               ? ami.Images[0].ImageId
               : 'NOT_SUPPORTED';
           } else {
             set[filterSet.Name] = 'NOT_SUPPORTED';
           }
           return set;
         });
     })
     .then((results: any) => {
       results = results.reduce((prev: any, current: any) => {
         const key = Object.keys(current)[0];
         prev[key] = current[key];
         return prev;
       }, {});
       return { region: region, images: results };
     });
 })

	/**
	 * 协助列表
	 */
	public async assistanceList(ctx: any) {
		let args = ctx.request.query;
		debug(">>>>args:", args)
		let userAgent = ctx.req.headers['user-agent'];
		let referer = ctx.req.headers['referer'];
		let pageIndex = args.pageIndex ? (args.pageIndex - 1) * 5 : 0;
		let assistancies = await AssistanceModel.findAll({
			offset: pageIndex,
			limit: 5,
			order: [['created_at', 'desc']]
		});
		let total = await AssistanceModel.count();
		let assistanceInfos: AssistanceInfo[] = assistancies;
		await Bluebird.map(assistanceInfos, async (item, index) => {
			let userRecord = await item.getUserModel();
			debug(userRecord.user_name)
			item.user_name = (userRecord && userRecord.user_name) ? userRecord.user_name : "缺省";//发起协助的用户名（业务用户users）
			item.imageArr = item.images ? item.imageArr = item.images.split(",") : [];
			return item;
		})
		await ctx.render('assistance-list', {
			title: '申请协助',
			userAgent,
			referer,
			currentIndex: args.pageIndex || 1,
			total,
			assistanceInfos
		})
	};

let parser = parse({delimiter: ",", columns: true}, function(err, data){
    return Promise.map<BeaconRow, any>(data, function(b) {
        return new BeaconSlot({
            id: b.bid,
            lat: b.lat,
            long: b.lng,
            edge: b.edge,
            floor: b.floor,
            start_node: b.start,
            end_node: b.end,
            deployment_id: 6,
        }).save(null, {method: "insert"})
        .then(function(slot) {
            return new Beacon({
                id: b.bid,
                minor_id: b.minor,
                slot: slot.id,
                deployment_id: 6,
            }).save(null, {method: "insert"})
            .then(function(beacon) {
                return slot.save({beacon_id: beacon.id}, {method: "update"});
            });
        }).then(() => process.exit())
        .catch(err => {
            console.log(err);
            process.exit(1);
        });
    });
});