import org.takes.facets.auth.Identity; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final Identity identity = new RqAuth(request).identity();
    if (identity.equals(Identity.ANONYMOUS)) {
        throw new RsForward(
            new RsFlash("You must be logged in to view logs.")
        );
    }
    final String login = identity.properties().get("login");
    final String name = new RqHref.Smart(request).single("name");
    if (!name.startsWith(String.format("%s_", login))) {
        throw new RsForward(
            new RsFlash(
                String.format(
                    "Permission denied: \"%s\".", name
                )
            )
        );
    }
    final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    this.bucket.ocket(name).read(baos);
    return new RsText(baos.toByteArray());
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
@Override
public Identity decode(final byte[] bytes) throws IOException {
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    try (InputStream gzip = new GZIPInputStream(
        new ByteArrayInputStream(bytes)
        )
    ) {
        while (true) {
            final int data = gzip.read();
            if (data < 0) {
                break;
            }
            out.write(data);
        }
    }
    return this.origin.decode(out.toByteArray());
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
@Override
public Identity decode(final byte[] bytes) throws IOException {
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    int idx = 0;
    while (idx < bytes.length) {
        if (bytes[idx] == '-') {
            ++idx;
            continue;
        }
        if (idx > bytes.length - 2) {
            throw new DecodingException("not enough data");
        }
        out.write(
            // @checkstyle MagicNumberCheck (1 line)
            (CcHex.decode(bytes[idx]) << 4) + CcHex.decode(bytes[idx + 1])
        );
        idx += 2;
    }
    return this.origin.decode(out.toByteArray());
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
@Override
public Identity decode(final byte[] bytes) throws IOException {
    final Map<String, String> map = new HashMap<>(0);
    try (DataInputStream stream = new DataInputStream(
        new ByteArrayInputStream(bytes)
        )
    ) {
        final String urn = stream.readUTF();
        while (stream.available() > 0) {
            map.put(stream.readUTF(), stream.readUTF());
        }
        return new Identity.Simple(urn, map);
    } catch (final IOException ex) {
        throw new DecodingException(ex);
    }
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * Get user name from Twitter, with the token provided.
 * @param tkn Twitter access token
 * @return The user found in Twitter
 * @throws IOException If fails
 */
private Identity identity(final String tkn) throws IOException {
    return parse(
        this.user
            .uri()
            .set(
                URI.create(
                    new Href(PsTwitter.VERIFY_URL)
                        .with(PsTwitter.ACCESS_TOKEN, tkn)
                        .toString()
                )
            )
            .back()
            .header("accept", "application/json")
            .fetch().as(RestResponse.class)
            .assertStatus(HttpURLConnection.HTTP_OK)
            .as(JsonResponse.class)
            .json()
            .readObject()
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * Get user name from Google, with the token provided.
 * @param token Google access token
 * @return The user found in Google
 * @throws IOException If fails
 */
private Identity fetch(final String token) throws IOException {
    // @checkstyle LineLength (1 line)
    final String uri = new Href(this.gapi).path("plus").path("v1")
        .path("people")
        .path("me")
        .with(PsGoogle.ACCESS_TOKEN, token)
        .toString();
    final JsonObject json = new JdkRequest(uri).fetch()
        .as(JsonResponse.class).json()
        .readObject();
    if (json.containsKey(PsGoogle.ERROR)) {
        throw new HttpException(
            HttpURLConnection.HTTP_BAD_REQUEST,
            String.format(
                "could not retrieve id from Google, possible cause: %s.",
                json.getJsonObject(PsGoogle.ERROR).get("message")
            )
        );
    }
    return PsGoogle.parse(json);
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * Make identity from JSON object.
 * @param json JSON received from Google
 * @return Identity found
 */
private static Identity parse(final JsonObject json) {
    final Map<String, String> props = new HashMap<>(json.size());
    final JsonObject image = json.getJsonObject("image");
    if (image == null) {
        props.put(PsGoogle.PICTURE, "#");
    } else {
        props.put(PsGoogle.PICTURE, image.getString("url", "#"));
    }
    if (json.containsKey(PsGoogle.DISPLAY_NAME)
        && json.get(PsGoogle.DISPLAY_NAME) != null) {
        props.put(PsGoogle.NAME, json.getString(PsGoogle.DISPLAY_NAME));
    } else {
        props.put(PsGoogle.NAME, "unknown");
    }
    return new Identity.Simple(
        String.format("urn:google:%s", json.getString("id")), props
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * FkAuthenticated can match by user status.
 * @throws IOException If some problem inside
 */
@Test
public void matchesIfAuthenticatedUser() throws IOException {
    MatcherAssert.assertThat(
        new FkAuthenticated(new TkEmpty()).route(
            new RqFake("GET", "/hel?a=1")
        ).has(),
        Matchers.is(false)
    );
    MatcherAssert.assertThat(
        new FkAuthenticated(new TkEmpty()).route(
            new RqWithHeader(
                new RqFake("PUT", "/hello"),
                TkAuth.class.getSimpleName(),
                new String(
                    new CcPlain().encode(new Identity.Simple("urn:test:1"))
                )
            )
        ).has(),
        Matchers.is(true)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcXor can encode and decode.
 * @throws IOException If some problem inside
 */
@Test
public void encodesAndDecodes() throws IOException {
    final String urn = "urn:domain:9";
    final Codec codec = new CcXor(
        new Codec() {
            @Override
            public byte[] encode(final Identity identity) {
                return identity.urn().getBytes();
            }
            @Override
            public Identity decode(final byte[] bytes) {
                return new Identity.Simple(new String(bytes));
            }
        },
        "secret"
    );
    MatcherAssert.assertThat(
        codec.decode(codec.encode(new Identity.Simple(urn))).urn(),
        Matchers.equalTo(urn)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcStrict can pass valid Identities.
 * @throws IOException If some problem inside
 */
@Test
public void passesValid() throws IOException {
    MatcherAssert.assertThat(
        new String(
            new CcStrict(new CcPlain()).encode(
                new Identity.Simple("urn:test:1")
            )
        ), Matchers.equalTo("urn%3Atest%3A1")
    );
    MatcherAssert.assertThat(
        new String(
            new CcStrict(new CcPlain()).encode(
                new Identity.Simple("urn:test-domain-org:valid:1")
            )
        ), Matchers.equalTo("urn%3Atest-domain-org%3Avalid%3A1")
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcCompact can encode and decode.
 * @throws IOException If some problem inside
 */
@Test
public void encodesAndDecodes() throws IOException {
    final String urn = "urn:test:3";
    final Identity identity = new Identity.Simple(
        urn,
        new ImmutableMap.Builder<String, String>()
            .put("name", "Jeff Lebowski")
            .build()
    );
    final byte[] bytes = new CcCompact().encode(identity);
    MatcherAssert.assertThat(
        new CcCompact().decode(bytes).urn(),
        Matchers.equalTo(urn)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcHex can decode invalid data.
 * @throws IOException If some problem inside
 */
@Test
public void decodesInvalidData() throws IOException {
    MatcherAssert.assertThat(
        new CcSafe(new CcCompact()).decode(
            " % tjw".getBytes()
        ),
        Matchers.equalTo(Identity.ANONYMOUS)
    );
    MatcherAssert.assertThat(
        new CcSafe(new CcCompact()).decode(
            "75726E253".getBytes()
        ),
        Matchers.equalTo(Identity.ANONYMOUS)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcBase64 can encode and decode.
 * @throws IOException If some problem inside
 */
@Test
public void encodesAndDecodes() throws IOException {
    final String urn = "urn:test:Hello World!";
    final Map<String, String> properties =
        ImmutableMap.of("userName", "user");
    final Codec codec = new CcBase64(new CcPlain());
    final Identity expected = codec.decode(
        codec.encode(new Identity.Simple(urn, properties))
    );
    MatcherAssert.assertThat(
        expected.urn(),
        Matchers.equalTo(urn)
    );
    MatcherAssert.assertThat(
        expected.properties(),
        Matchers.equalTo(properties)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcSalted can decode.
 * @throws IOException If some problem inside
 */
@Test
public void decodesInvalidData() throws IOException {
    MatcherAssert.assertThat(
        new CcSafe(new CcSalted(new CcPlain())).decode(
            " % tjw".getBytes()
        ),
        Matchers.equalTo(Identity.ANONYMOUS)
    );
    MatcherAssert.assertThat(
        new CcSafe(new CcSalted(new CcPlain())).decode(
            "75726E253".getBytes()
        ),
        Matchers.equalTo(Identity.ANONYMOUS)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * CcHex can decode.
 * @throws IOException If some problem inside
 */
@Test
public void decodesInvalidData() throws IOException {
    MatcherAssert.assertThat(
        new CcSafe(new CcHex(new CcPlain())).decode(
            " % tjw".getBytes()
        ),
        Matchers.equalTo(Identity.ANONYMOUS)
    );
    MatcherAssert.assertThat(
        new CcSafe(new CcHex(new CcPlain())).decode(
            "75-72-6E-253".getBytes()
        ),
        Matchers.equalTo(Identity.ANONYMOUS)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
@Override
public void exec(final URI home) throws IOException {
    final Identity identity = new PsLinkedin(
        new Href(String.format("%s/uas/oauth2/accessToken", home)),
        new Href(String.format("%s/v1/people", home)),
        this.lapp,
        this.lkey
    ).enter(new RqFake("GET", String.format("?code=%s", this.code)))
        .get();
    MatcherAssert.assertThat(
        identity.urn(),
        CoreMatchers.equalTo(
            String.format("urn:linkedin:%s", this.identifier)
        )
    );
    MatcherAssert.assertThat(
        identity.properties(),
        Matchers.allOf(
            Matchers.hasEntry(this.firstname, this.frodo),
            Matchers.hasEntry(this.lastname, this.baggins)
        )
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
@Override
public Opt<Identity> enter(final Request req) throws IOException {
    final Opt<Identity> user;
    if (TkAppAuth.TESTING) {
        final Iterator<String> login =
            new RqHref.Base(req).href().param("user").iterator();
        final String name;
        if (login.hasNext()) {
            name = login.next();
        } else {
            name = "tester";
        }
        user = new Opt.Single<Identity>(
            new Identity.Simple(
                String.format("urn:test:%s", name),
                new ArrayMap<String, String>().with("login", name)
            )
        );
    } else {
        user = new Opt.Empty<>();
    }
    return user;
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * Get user name (GitHub handle).
 * @return The user found
 * @throws IOException If fails
 */
private User user() throws IOException {
    final Identity identity = new RqAuth(this.request).identity();
    if (identity.equals(Identity.ANONYMOUS)) {
        throw new RsForward(
            new RsFlash("You must be logged in.")
        );
    }
    return this.base.user(
        identity.properties().get("login").toLowerCase(Locale.ENGLISH)
    );
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * Get user name (GitHub handle).
 * @return Name
 * @throws IOException If fails
 */
public String name() throws IOException {
    final Identity identity = new RqAuth(this).identity();
    final String urn = identity.urn();
    final Matcher mtr = RqUser.PTN.matcher(urn);
    if (!mtr.matches()) {
        throw new IllegalArgumentException(
            String.format("URN \"%s\" is not from GitHub", urn)
        );
    }
    return identity.properties().get("login");
}
 

import org.takes.facets.auth.Identity; //导入依赖的package包/类
/**
 * Get URN.
 * @return URN
 * @throws IOException If fails
 */
public String urn() throws IOException {
    final Identity identity = new RqAuth(this).identity();
    if (identity.equals(Identity.ANONYMOUS)) {
        throw new HttpException(
            HttpURLConnection.HTTP_FORBIDDEN,
            "you're not authorized"
        );
    }
    return identity.urn();
}