import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public String ocket(final long time) throws IOException {
    final Iterator<Item> items = this.region.table("logs")
        .frame()
        .through(new QueryValve().withLimit(1))
        .where("group", this.group())
        .where(
            "start",
            new Condition()
                .withComparisonOperator(ComparisonOperator.EQ)
                .withAttributeValueList(
                    new AttributeValue().withN(Long.toString(time))
                )
        )
        .iterator();
    if (!items.hasNext()) {
        throw new RsForward(
            new RsFlash("Can't find log"),
            "/scripts"
        );
    }
    return items.next().get("ocket").getS();
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final String name = new RqHref.Smart(request).single("script");
    return new RsForward(
        String.format(
            "/log?name=%s",
            URLEncoder.encode(
                new RqUser(this.base, request).script(name).ocket(
                    Long.parseLong(
                        new RqHref.Smart(request).single("time")
                    )
                ),
                StandardCharsets.UTF_8.displayName()
            )
        )
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final User user = new RqUser(this.base, request);
    final RqFormSmart form = new RqFormSmart(new RqGreedy(request));
    final String name = form.single("script");
    final long cents = Long.parseLong(form.single("cents"));
    try {
        user.script(name).pay(
            cents, form.single("token"), form.single("email")
        );
    } catch (final IOException ex) {
        throw new RsForward(new RsFlash(ex));
    }
    return new RsForward(
        new RsFlash(
            String.format(
                "Script \"%s\" funded for $%.2f.",
                // @checkstyle MagicNumber (1 line)
                name, (double) cents / 100.0d
            )
        ),
        "/scripts"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的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.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final RqRegex req) throws IOException {
    final Matcher matcher = req.matcher();
    // @checkstyle MagicNumber (1 line)
    String path = matcher.group(3);
    if (path.isEmpty()) {
        throw new RsForward(
            String.format("%s/index.html", matcher.group(0))
        );
    }
    path = path.substring(1);
    return new IoCheckedFunc<>(
        new IoCheckedBiFunc<>(this.reports).apply(
            matcher.group(1),
            matcher.group(2)
        )
    ).apply(path);
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final String visibility = new RqForm.Smart(
        new RqForm.Base(req)
    ).single("visibility", "Private");
    new RqDoc(req, this.base).doc().attributes().show(
        "Public".equals(visibility)
    );
    return new RsForward(
        new RsFlash(
            String.format(
                "document visibility set to \"%s\"", visibility
            )
        )
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
/**
 * Get deck.
 * @return The deck
 * @throws IOException If fails
 */
@SuppressWarnings("PMD.PreserveStackTrace")
public Deck deck() throws IOException {
    final User user = new RqUser(this, this.base).get();
    final String name = new RqHeaders.Smart(
        new RqHeaders.Base(this)
    ).single("X-Thindeck-Deck");
    try {
        return user.decks().get(name);
    } catch (final IOException ex) {
        throw new RsForward(
            new RsText(ex.getLocalizedMessage()),
            HttpURLConnection.HTTP_NOT_FOUND
        );
    }
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
/**
 * Redirect to the bout.
 * @param deck Deck name
 * @param take Take
 * @return New take
 */
private static Take redirect(final String deck, final Take take) {
    return new Take() {
        @Override
        public Response act(final Request req) throws IOException {
            try {
                return take.act(req);
            } catch (final RsForward ex) {
                if (ex.code() == HttpURLConnection.HTTP_SEE_OTHER) {
                    throw new RsForward(
                        ex,
                        new RqHref.Smart(
                            new RqHref.Base(req)
                        ).home().path("d").path(deck)
                    );
                }
                throw ex;
            }
        }
    };
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final User user = new RqUser(this.base, request);
    final String name = new RqHref.Smart(request).single("name");
    user.script(name).flush();
    return new RsForward(
        new RsFlash(
            String.format("Script \"%s\" flushed, it will start now.", name)
        ),
        "/scripts"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final User user = new RqUser(this.base, request);
    final String name = new RqHref.Smart(request).single("name");
    user.script(name).delete();
    return new RsForward(
        new RsFlash(
            String.format("Script \"%s\" deleted.", name)
        ),
        "/scripts"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的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.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final User user = new RqUser(this.base, request);
    final String group = new RqHref.Smart(request).single("group");
    final long start = Long.parseLong(
        new RqHref.Smart(request).single("start")
    );
    user.delete(group, start);
    return new RsForward(
        new RsFlash(
            String.format("Log \"%[email protected]%d\" deleted.", group, start)
        ),
        "/logs"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final User user = new RqUser(this.base, request);
    final RqFormSmart form = new RqFormSmart(new RqGreedy(request));
    final String name = form.single("name");
    user.script(name).update(form.single("body"));
    return new RsForward(
        new RsFlash(
            String.format("Script \"%s\" updated/saved.", name)
        ),
        "/scripts"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final String url = new RqHref.Base(req).href()
        .param("url").iterator().next();
    final String path = String.format(
        "/?u=%s",
        URLEncoder.encode(
            url,
            "UTF-8"
        )
    );
    final AmazonCloudFront aws = AmazonCloudFrontClientBuilder.standard()
        .withCredentials(
            new AWSStaticCredentialsProvider(
                new BasicAWSCredentials(this.key, this.secret)
            )
        )
        .build();
    final CreateInvalidationResult result = aws.createInvalidation(
        new CreateInvalidationRequest(
            "E2QC66VZY6F0QA",
            new InvalidationBatch(
                new Paths().withItems(path).withQuantity(1),
                UUID.randomUUID().toString()
            )
        )
    );
    return new RsForward(
        new RsFlash(
            String.format(
                "URL \"%s\" was invalidated (ID=\"%s\", Status=\"%s\")",
                url,
                result.getInvalidation().getId(),
                result.getInvalidation().getStatus()
            )
        ),
        "/domains"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    this.base.user(new RqUser(req).urn()).pipes().add(
        new RqFormBase(req).param("json").iterator().next().trim()
    );
    return new RsForward(
        new RsFlash("pipe created"),
        "/pipes"
    );
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final User user = this.base.user(new RqUser(req).urn());
    final Event event = user.events().event(
        new RqHref.Base(req).href().param("title").iterator().next()
    );
    event.vote(-Tv.TEN);
    return new RsForward(new RsFlash("event down-voted"));
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final Pipe pipe = this.base.user(new RqUser(req).urn()).pipes().pipe(
        Long.parseLong(
            new RqHref.Base(req).href().param("id").iterator().next()
        )
    );
    final String msg = new XePrint(pipe.asXembly()).text(
        "pipe #{/pipe/id/text()} deleted"
    );
    pipe.delete();
    return new RsForward(new RsFlash(msg), "/pipes");
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final User user = this.base.user(new RqUser(req).urn());
    final Event event = user.events().event(
        new RqHref.Base(req).href().param("title").iterator().next()
    );
    final String msg = new XePrint(event.asXembly()).text(
        "event \"{/event/title/text()}\" deleted"
    );
    event.delete();
    return new RsForward(new RsFlash(msg));
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    if (new RqAuth(request).identity().equals(Identity.ANONYMOUS)) {
        throw new RsForward(
            new RsFlash("access denied", Level.WARNING),
            this.loc
        );
    }
    return this.origin.act(request);
}
 

import org.takes.facets.forward.RsForward; //导入依赖的package包/类
/**
 * PsBasic can handle connection with invalid credential.
 * @throws Exception If some problem inside
 */
@Test
public void handleConnectionWithInvalidCredential() throws Exception {
    RsForward forward = new RsForward();
    try {
        new PsBasic(
            "RealmB",
            new PsBasic.Empty()
        ).enter(
            new RqWithHeaders(
                new RqFake(
                    RqMethod.GET,
                    String.format(
                        "?invalid_code=%s",
                        RandomStringUtils.randomAlphanumeric(Tv.TEN)
                    )
                ),
                PsBasicTest.header("username", "wrong")
            )
        );
    } catch (final RsForward ex) {
        forward = ex;
    }
    MatcherAssert.assertThat(
        new RsPrint(forward).printHead(),
        Matchers.allOf(
            Matchers.containsString("HTTP/1.1 401 Unauthorized"),
            Matchers.containsString(
                "WWW-Authenticate: Basic ream=\"RealmB\""
            )
        )
    );
}