import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Test
public void testAuthenticateSuccess() {
  String email = "[email protected]";
  String id = "user-id";
  UserInfo userInfo = new UserInfo(ImmutableList.<String>of(), email, id, "issuer");
  when(this.authenticator.authenticate(request, AUTH_INFO, SERVICE_NAME))
      .thenReturn(userInfo);
  this.attribute.set(ATTRIBUTE_PREFIX + ".method_info", INFO);
  this.attribute.set(ATTRIBUTE_PREFIX + ".service", SERVICE);

  User user = this.espAuthenticator.authenticate(request);
  assertEquals(email, user.getEmail());
  assertEquals(id, user.getId());

  verify(this.authenticator, only()).authenticate(request, AUTH_INFO, SERVICE_NAME);
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Authenticate the request and retrieve an {@code com.google.appengine.api.users.User}. Should
 * only run once per request.
 */
com.google.appengine.api.users.User authenticateAppEngineUser() throws ServiceException {
  if (!EnvUtil.isRunningOnAppEngine()) {
    return null;
  }
  attr.set(Attribute.REQUIRE_APPENGINE_USER, true);
  User user = authenticate();
  attr.set(Attribute.REQUIRE_APPENGINE_USER, false);
  if (user == null) {
    return null;
  }
  com.google.appengine.api.users.User appEngineUser =
      (com.google.appengine.api.users.User) attr.get(Attribute.AUTHENTICATED_APPENGINE_USER);
  if (appEngineUser != null) {
    return appEngineUser;
  } else {
    return user.getEmail() == null
        ? null : new com.google.appengine.api.users.User(user.getEmail(), "", user.getId());
  }
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Test
public void testUserInjectionThrowsExceptionIfRequired() throws Exception {
  @SuppressWarnings("unused")
  class TestUser {
    @SuppressWarnings("unused")
    public void getUser(User user) { }
  }
  ApiMethodConfig methodConfig = Mockito.mock(ApiMethodConfig.class);
  when(methodConfig.getAuthLevel()).thenReturn(AuthLevel.REQUIRED);
  methodConfig.setAuthLevel(AuthLevel.REQUIRED);
  try {
    Method method = TestUser.class.getDeclaredMethod("getUser", User.class);
    readParameters(
        "{}", EndpointMethod.create(method.getDeclaringClass(), method),
        methodConfig,
        null,
        null);
    fail("expected unauthorized method exception");
  } catch (UnauthorizedException ex) {
    // expected
  }
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Test
public void testAppEngineUserInjectionThrowsExceptionIfRequired() throws Exception {
  @SuppressWarnings("unused")
  class TestUser {
    @SuppressWarnings("unused")
    public void getUser(com.google.appengine.api.users.User user) { }
  }
  ApiMethodConfig methodConfig = Mockito.mock(ApiMethodConfig.class);
  when(methodConfig.getAuthLevel()).thenReturn(AuthLevel.REQUIRED);
  methodConfig.setAuthLevel(AuthLevel.REQUIRED);
  try {
    Method method = TestUser.class
        .getDeclaredMethod("getUser", com.google.appengine.api.users.User.class);
    readParameters(
        "{}",
        EndpointMethod.create(method.getDeclaringClass(), method),
        methodConfig,
        null,
        null);
    fail("expected unauthorized method exception");
  } catch (UnauthorizedException ex) {
    // expected
  }
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
private Object[] readParameters(final String input, EndpointMethod method,
    ApiMethodConfig methodConfig, final User user,
    final com.google.appengine.api.users.User appEngineUser)
    throws Exception {
  ParamReader reader = new ServletRequestParamReader(
      method, request, context, null, methodConfig) {
    @Override
    User getUser() {
      return user;
    }
    @Override
    com.google.appengine.api.users.User getAppEngineUser() {
      return appEngineUser;
    }
  };
  return readParameters(input, reader);
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Test
public void testAuthenticateOAuth2Fail() {
  authenticator = new GoogleAppEngineAuthenticator(oauthService, userService) {
    @Override
    com.google.appengine.api.users.User getOAuth2User(HttpServletRequest request,
        ApiMethodConfig config) {
      return null;
    }

    @Override
    boolean shouldTryCookieAuth(ApiMethodConfig config) {
      return false;
    }
  };
  assertNull(authenticator.authenticate(request));
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Test
public void testAuthenticateOAuth2CookieAuthBothFail() {
  authenticator = new GoogleAppEngineAuthenticator(oauthService, userService) {
    @Override
    com.google.appengine.api.users.User getOAuth2User(HttpServletRequest request,
        ApiMethodConfig config) {
      return null;
    }

    @Override
    boolean shouldTryCookieAuth(ApiMethodConfig config) {
      return true;
    }
  };
  when(userService.getCurrentUser()).thenReturn(null);
  assertNull(authenticator.authenticate(request));
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Test
public void testAuthenticateOAuth2FailCookieAuth() {
  authenticator = new GoogleAppEngineAuthenticator(oauthService, userService) {
    @Override
    com.google.appengine.api.users.User getOAuth2User(HttpServletRequest request,
        ApiMethodConfig config) {
      return null;
    }

    @Override
    boolean shouldTryCookieAuth(ApiMethodConfig config) {
      return true;
    }
  };
  when(userService.getCurrentUser()).thenReturn(APP_ENGINE_USER);
  assertEquals(USER, authenticator.authenticate(request));
  assertEquals(APP_ENGINE_USER, attr.get(Attribute.AUTHENTICATED_APPENGINE_USER));
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 * <p>
 * Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 * <p>
 * Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START google_id_token_auth]
@ApiMethod(
        httpMethod = ApiMethod.HttpMethod.GET,
        authenticators = {EspAuthenticator.class},
        audiences = {"YOUR_OAUTH_CLIENT_ID"},
        clientIds = {"YOUR_OAUTH_CLIENT_ID"}
)
public Email getUserEmail(User user) throws UnauthorizedException {
    if (user == null) {
        throw new UnauthorizedException("Invalid credentials");
    }

    Email response = new Email();
    response.setEmail(user.getEmail());
    return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
     * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
     * 401.
     * <p>
     * Note that name is not specified. This will default to "{class name}.{method name}". For
     * example, the default is "echo.getUserEmail".
     * <p>
     * Note that httpMethod is not required here. Without httpMethod, this will default to GET due
     * to the API method name. httpMethod is added here for example purposes.
     */
    // [START firebase_auth]
    @ApiMethod(
            path = "firebase_user",
            httpMethod = ApiMethod.HttpMethod.GET,
            authenticators = {EspAuthenticator.class},
            issuerAudiences = {
                    @ApiIssuerAudience(
                            name = "firebase",
//                            audiences = {"YOUR-PROJECT-ID"}
                            audiences = {"cryptonomica-server"}
                    )
            }
    )


    public Email getUserEmailFirebase(User user) throws UnauthorizedException {
        if (user == null) {
            throw new UnauthorizedException("Invalid credentials");
        }

        Email response = new Email();
        response.setEmail(user.getEmail());
        return response;
    }
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
@Override
public User authenticate(HttpServletRequest req) {
    OAuthService authService = OAuthServiceFactory.getOAuthService();
    com.google.appengine.api.users.User currentUser;

    try {
      currentUser = authService.getCurrentUser(Constants.EMAIL_SCOPE);
      // Check current user..
      if(currentUser != null) {
        String email = currentUser.getEmail();
        // Check domain..
        if(isValidDomain(email) || isWhiteList(email)) {
          return new User(currentUser.getUserId(), currentUser.getEmail());
        }
      }
      throw new RestrictedDomainException(i18n.t("Authorization error"));
    }
    catch(OAuthRequestException  e) {
      log.log(Level.WARNING, "Error when trying to authenticate. Message: " + e.getMessage(), e);
      return null;
    }
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 *
 * <p>Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 *
 * <p>Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START google_id_token_auth]
@ApiMethod(
    httpMethod = ApiMethod.HttpMethod.GET,
    authenticators = {EspAuthenticator.class},
    audiences = {"YOUR_OAUTH_CLIENT_ID"},
    clientIds = {"YOUR_OAUTH_CLIENT_ID"}
    )
public Email getUserEmail(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 *
 * <p>Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 *
 * <p>Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START firebase_auth]
@ApiMethod(
    path = "firebase_user",
    httpMethod = ApiMethod.HttpMethod.GET,
    authenticators = {EspAuthenticator.class},
    issuerAudiences = {@ApiIssuerAudience(name = "firebase", audiences = {"YOUR-PROJECT-ID"})}
    )
public Email getUserEmailFirebase(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 *
 * Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 *
 * Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START google_id_token_auth]
@ApiMethod(
    httpMethod = ApiMethod.HttpMethod.GET,
    authenticators = {EspAuthenticator.class},
    audiences = {"YOUR_OAUTH_CLIENT_ID"},
    clientIds = {"YOUR_OAUTH_CLIENT_ID"}
    )
public Email getUserEmail(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 *
 * Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 *
 * Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START firebase_auth]
@ApiMethod(
    path = "firebase_user",
    httpMethod = ApiMethod.HttpMethod.GET,
    authenticators = {EspAuthenticator.class},
    issuerAudiences = {@ApiIssuerAudience(name = "firebase", audiences = {"YOUR-PROJECT-ID"})}
    )
public Email getUserEmailFirebase(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 *
 * <p>Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 *
 * <p>Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START google_id_token_auth]
@ApiMethod(
    httpMethod = ApiMethod.HttpMethod.GET,
    authenticators = {EspAuthenticator.class},
    audiences = {"YOUR_OAUTH_CLIENT_ID"},
    clientIds = {"YOUR_OAUTH_CLIENT_ID"}
)
public Email getUserEmail(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Gets the authenticated user's email. If the user is not authenticated, this will return an HTTP
 * 401.
 *
 * <p>Note that name is not specified. This will default to "{class name}.{method name}". For
 * example, the default is "echo.getUserEmail".
 *
 * <p>Note that httpMethod is not required here. Without httpMethod, this will default to GET due
 * to the API method name. httpMethod is added here for example purposes.
 */
// [START firebase_auth]
@ApiMethod(
    path = "firebase_user",
    httpMethod = ApiMethod.HttpMethod.GET,
    authenticators = {EspAuthenticator.class},
    issuerAudiences = {
        @ApiIssuerAudience(
            name = "firebase",
            audiences = {"YOUR-PROJECT-ID"}
        )
    }
)
public Email getUserEmailFirebase(User user) throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  Email response = new Email();
  response.setEmail(user.getEmail());
  return response;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Reset reservations in datastore to match those in RTDB. Reservations in RTDB are used
 * as the source of truth, corresponding reservations in datastore are updated to match
 * those in RTDB. Reservations in RTDB that do not exist in datastore are added to datastore.
 * Reservations that exist in datastore and do not exist in RTDB are updated in datastore
 * with status DELETED.
 *
 * Use of this endpoint should be followed by a user data sync.
 *
 * @param user User making request (injected by Endpoints)
 */
@ApiMethod(name = "reset", path = "reset")
public void reset(User user)
    throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  // Add Sync Reservations worker to queue.
  Queue queue = QueueFactory.getQueue("SyncReservationsQueue");

  TaskOptions taskOptions = TaskOptions.Builder
      .withUrl("/queue/syncres")
      .method(Method.GET);
  queue.add(taskOptions);
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Batch update user data
 *
 * @param user Current user (injected by Endpoints)
 * @param userData UserData object with new values to save
 * @return Updated UserData object
 */
@SuppressWarnings("ResourceParameter")  // http://b.android.com/201031
@ApiMethod(name = "updateUser", path = "all", httpMethod = ApiMethod.HttpMethod.PUT)
public UserData updateUser(User user,  UserData userData) throws UnauthorizedException {
    UserData savedData = getUser(user);

    // Bookmarked sessions can be overwritten
    savedData.bookmarkedSessions = userData.bookmarkedSessions;
    // Reviewed sessions should be merged with old values
    for (String session : userData.reviewedSessions) {
        savedData.reviewedSessions.add(session);
    }
    // We don't allow clients to update reserved sessions, preserve old values

    save(savedData);
    return savedData;
}
 

import com.google.api.server.spi.auth.common.User; //导入依赖的package包/类
/**
 * Add a waitlisted session for the specified user. If the session is already in the user's feed,
 * it will be annotated with status=WAITLISTED.
 *
 * @param user         Service account making the request (injected by Endpoints)
 * @param userId       User ID of user that reserved a session.
 * @param sessionId    Session ID to mark as reserved.
 * @param timestampUTC The time (in millis, UTC) when the user performed this action. May be
 *                     different than the time this method is called if offline sync is
 *                     implemented. MUST BE ACCURATE - COMPENSATE FOR CLOCK DRIFT!
 * @return The list of reserved sessions for the user
 */
@ApiMethod(name = "addWaitlistedSession", path = "reservations/waitlist",
    httpMethod = ApiMethod.HttpMethod.PUT, clientIds = {Ids.SERVICE_ACCOUNT_CLIENT_ID})
public Map<String, ReservedSession> addWaitlistedSession (
    User user,
    @Named("userId") String userId,
    @Named("sessionId") String sessionId,
    @Named("timestampUTC") long timestampUTC)
    throws UnauthorizedException {
    UserData data = getUser(user, userId);
    ReservedSession s = new ReservedSession(sessionId, Status.WAITLISTED, timestampUTC);
    data.reservedSessions.put(sessionId, s);
    save(data);
    // notify user's clients of reservation change change
    new GCMPing().notifyUserSync(data.userId);
    return data.reservedSessions;
}