TypeScript Boom.forbidden函数代码示例

  public requestIsValid(request: any): boolean {
    const license = this.adapter.getLicenseType();
    if (license === null) {
      throw Boom.badRequest('Missing license information');
    }
    if (!supportedLicenses.some(licenseType => licenseType === license)) {
      throw Boom.forbidden('License not supported');
    }
    if (this.adapter.licenseIsActive() === false) {
      throw Boom.forbidden('License not active');
    }

    return this.checkRequest(request);
  }

export function registerClusterCheckupRoutes(server: Legacy.Server) {
  const { callWithRequest } = server.plugins.elasticsearch.getCluster('admin');
  const isCloudEnabled = _.get(server.plugins, 'cloud.config.isCloudEnabled', false);

  server.route({
    path: '/api/upgrade_assistant/status',
    method: 'GET',
    options: {
      pre: [EsVersionPrecheck],
    },
    async handler(request) {
      try {
        return await getUpgradeAssistantStatus(callWithRequest, request, isCloudEnabled);
      } catch (e) {
        if (e.status === 403) {
          return Boom.forbidden(e.message);
        }

        return Boom.boomify(e, {
          statusCode: 500,
        });
      }
    },
  });
}

        handler: async function (req, res, next) {
            const payload: Requests.UpdatePassword = req.validatedBody;
            let user = await UserDb.get(req.user._id);

            // Ensure the user's current password is correct
            if (!compareSync(payload.old_password, user.hashed_password)) {
                return next(boom.forbidden(`Your current password is incorrect.`));
            }

            // Change the user's password
            user.hashed_password = hashSync(payload.new_password);

            try {
                const updateResult = await UserDb.put(user._id, user, user._rev);
                user._rev = updateResult.rev
            } catch (e) {
                inspect("Failed to update user's password.", e);

                return next(e);
            }

            await res.withSessionToken(user);

            return next();
        }

 private checkRequest(request: any): boolean {
   const authenticated = get(request, 'auth.isAuthenticated', null);
   if (authenticated === null) {
     throw Boom.forbidden('Missing authentication');
   }
   return authenticated;
 }

 return function forbidApiAccess(request: any) {
   const licenseCheckResults = xpackMainPlugin.info.feature(pluginId).getLicenseCheckResults();
   if (!licenseCheckResults.showSpaces) {
     return Boom.forbidden(licenseCheckResults.linksMessage);
   } else {
     return '';
   }
 };

export function wrapEsError(err: any) {
  const statusCode = err.statusCode;
  if (statusCode === 403) {
    return Boom.forbidden('Insufficient user permissions for managing Beats configuration');
  }

  return Boom.boomify(err, { statusCode: err.statusCode });
}

export const readOnlyMiddleware = async (resolve, root, args, context: Context, info) => {
  const operationType = get(info, 'operation.operation');
  if (!context.readOnly || (context.readOnly && operationType === 'query')) {
    return resolve(root, args, context, info);
  }

  // readOnly true, but operation is one of mutation or subscription
  throw Boom.forbidden('Only query allowed in readonly request', {code: ErrorCodes.MUTATION_IN_READONLY});
};

  return async ({ ctx }: { ctx: Context }) => {
    const authorization = ctx.get('authorization');
    if (!authorization) {
      throw Boom.forbidden('authorization header required', {code: ErrorCodes.AUTH_HEADER_MISSING});
    }

    const accessToken = authorization.replace('Bearer ', '');
    if (!accessToken) {
      throw Boom.forbidden('access token required', {code: ErrorCodes.ACCESSTOKEN_MISSING});
    }

    // check with authHandler
    const authContext = await authHandler(accessToken);

    return {
      ...authContext
    };
  };

  private async ensureAuthorizedGlobally(action: string, method: string, forbiddenMessage: string) {
    const checkPrivileges = this.authorization.checkPrivilegesWithRequest(this.request);
    const { username, hasAllRequested } = await checkPrivileges.globally(action);

    if (hasAllRequested) {
      this.auditLogger.spacesAuthorizationSuccess(username, method);
      return;
    } else {
      this.auditLogger.spacesAuthorizationFailure(username, method);
      throw Boom.forbidden(forbiddenMessage);
    }
  }

 function handleError(exportType: any, err: Error) {
   if (err instanceof esErrors['401']) {
     return boom.unauthorized(`Sorry, you aren't authenticated`);
   }
   if (err instanceof esErrors['403']) {
     return boom.forbidden(`Sorry, you are not authorized to create ${exportType} reports`);
   }
   if (err instanceof esErrors['404']) {
     return boom.boomify(err, { statusCode: 404 });
   }
   return err;
 }