TypeScript v4.v4函數代碼示例

async function createVideoChannel (videoChannelInfo: VideoChannelCreate, account: AccountModel, t: Sequelize.Transaction) {
  const uuid = uuidv4()
  const url = getVideoChannelActivityPubUrl(uuid)
  // We use the name as uuid
  const actorInstance = buildActorInstance('Group', url, uuid, uuid)

  const actorInstanceCreated = await actorInstance.save({ transaction: t })

  const videoChannelData = {
    name: videoChannelInfo.displayName,
    description: videoChannelInfo.description,
    support: videoChannelInfo.support,
    accountId: account.id,
    actorId: actorInstanceCreated.id
  }

  const videoChannel = VideoChannelModel.build(videoChannelData)

  const options = { transaction: t }
  const videoChannelCreated = await videoChannel.save(options)

  // Do not forget to add Account/Actor information to the created video channel
  videoChannelCreated.Account = account
  videoChannelCreated.Actor = actorInstanceCreated

  // No need to seed this empty video channel to followers
  return videoChannelCreated
}

 router.put('/upload/', function (req, res) {
     let body = req.body;
     if (!body || !body.Filename || !body.Size) {
         return res.send({ Success: false, Error: 'No filename!' });
     }
     let fileid = uuidv4();
     pool.getConnection((err, conn) => {
         if (err) {
             console.log(err);
             return res.status(500).send({Error: 'Could not establish connection to database'});
         } else {
             let q = 'Insert into `filemetadata` (`FileID`, `Filename`, `Owner`, `Size`) VALUES (?, ?, ?, ?);';
             let args = [fileid, body.Filename, res.locals.user.ID, body.Size];
             conn.query(q, args, (qerr, result) => {
                 conn.release();
                 if (qerr) {
                     console.log('Error saving file metadata', qerr);
                     return res.status(500).send({ Error: 'Internal Server Error' });
                 }
                 console.log('Beginning upload of', body.Filename);
                 return res.send({ EndpointID: fileid });
             });
         }
     });
 });

async function updateMyAvatar (req: express.Request, res: express.Response, next: express.NextFunction) {
  const avatarPhysicalFile = req.files['avatarfile'][0]
  const user = res.locals.oauth.token.user
  const actor = user.Account.Actor

  const extension = extname(avatarPhysicalFile.filename)
  const avatarName = uuidv4() + extension
  const destination = join(CONFIG.STORAGE.AVATARS_DIR, avatarName)
  await processImage(avatarPhysicalFile, destination, AVATARS_SIZE)

  const avatar = await sequelizeTypescript.transaction(async t => {
    const updatedActor = await updateActorAvatarInstance(actor, avatarName, t)
    await updatedActor.save({ transaction: t })

    await sendUpdateActor(user.Account, t)

    return updatedActor.Avatar
  })

  return res
    .json({
      avatar: avatar.toFormattedJSON()
    })
    .end()
}

 return db.findOne({ email, password }).then((user) => {
   if (!user) {
     throw Error("Could not authorize");
   }
   user.token = uuidv4();
   return user.save();
 });

router.post("/edit_user", async ctx => {
  await authToken(ctx, true);
  const {
    uid,
    email,
    note,
    enabled,
    isAdmin,
    isEmailVerified,
    regenerate,
  } = ctx.request.body;
  if (!uid) {
    return raiseApiError(400, "請求格式錯誤");
  }
  const user = await getRepository(User).findOneById(uid);
  if (!user) {
    return raiseApiError(404, "用戶不存在");
  }
  user.email = email || user.email;
  user.note = note || user.note;
  user.enabled = enabled;
  user.isAdmin = isAdmin;
  user.isEmailVerified = isEmailVerified;
  if (regenerate) {
    user.setConnPassword();
    await user.allocConnPort();
    user.vmessUid = uuid();
  }
  await getRepository(User).save(user);
  await writeServerConfig();
  ctx.body = { message: "操作成功" };
});

export function mixin(mixinClass) {
  Object.defineProperty(mixinClass, 'name', {
    value: uuid(),
  });
  Injectable()(mixinClass);
  return mixinClass;
}

export function generateEmptyPokemon(pokemon?: Pokemon[]): Pokemon {
    let position: number = 0;
    if (pokemon && pokemon.length > 0) {
        try {
            position = parseInt(pokemon.sort(sortPokes)[pokemon.length - 1].position as any) + 1;
        } catch (e) {
            console.error('Attempted to generate position, but failed.', e);
        }
    }
    const genStatus = () => {
        if (pokemon && pokemon.filter(poke => poke.status === 'Team').length >= 6) return 'Boxed';
        return 'Team';
    };
    return {
        id: uuid(),
        position: position,
        species: '',
        nickname: '',
        status: genStatus(),
        gender: 'genderless',
        level: undefined,
        met: '',
        metLevel: undefined,
        nature: 'None',
        ability: '',
        types: [Types.Normal, Types.Normal],
        egg: false,
    };
}

export async function saveUser(req: Request, res: Response, next: NextFunction): Promise<any> {
  let body: User = snakeCase(req.body);
  body.id = uuid();
  
  return await Account
  .findOne({ where: {email: body.email} })
  .then(async account => validateAndCreateUser(body, account, res))
  .catch(err => next(err));
}

    // CONSTRUCTOR
    // --------------------------------------------------------------------------------------------
    constructor(name: string, tasks: boolean, notices: boolean) {
        this.id = uuid();
        this.name = name;
        this.startTs = Date.now();

        this.tasks = tasks ? [] : undefined;
        this.notices = notices ? [] : undefined;
        this.deferred = [];
    }

        source.sensors.reduce((acc, sensor) => {
          const id = uuid()
          ids.push(id)

          const sensorWithId = {
            ...sensor,
            visible: true,
            source: source.id,
            id
          }

          return { ...acc, [id]: sensorWithId }
        }, {})