import org.takes.Response; //导入依赖的package包/类
@Override
public final Opt<Response> route(final RqFallback req) throws IOException {
    return new Opt.Single<>(
        new RsWithStatus(
            new RsHtml(
                new RsVelocity(
                    TkApp.class.getResource("error.html.vm"),
                    new RsVelocity.Pair(
                        "err",
                        new TextOf(req.throwable()).asString()
                    ),
                    new RsVelocity.Pair(
                        "rev",
                        Manifests.read("Rehttp-Revision")
                    )
                )
            ),
            HttpURLConnection.HTTP_INTERNAL_ERROR
        )
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(Request req) throws IOException {
    try {
        long number = Long.parseLong(((RqRegex) req).matcher().group("number"));
        Category category = base.categories().category(number);

        JsonReader reader = Json.createReader(req.body());
        JsonObject json = reader.readObject();
        String name = json.getString("name");
        Optional<Category> parent = Optional.of(json.getInt("parent_id", 0))
                .filter(id -> id > 0)
                .map(id -> base.categories().category(id));

        Category result = category.update(name, parent);
        return new RsJson(result);
    } catch (IOException e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(Request req) throws IOException {
    try {
        long number = Long.parseLong(((RqRegex) req).matcher().group("number"));
        Product product = base.products().product(number);

        JsonReader reader = Json.createReader(req.body());
        JsonObject json = reader.readObject();
        String name = json.getString("name");
        String desc = json.getString("desc");
        FastMoney price = FastMoney.of(new BigDecimal(json.getString("price")), "CZK");

        Product result = product.update(name, desc, price);
        return new RsJson(result);
    } catch (IOException e) {
        throw new IllegalStateException(e.getMessage(), e);
    }
}
 

import org.takes.Response; //导入依赖的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.Response; //导入依赖的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.Response; //导入依赖的package包/类
/**
 * Make fatal error page.
 * @param req Request
 * @return Response
 * @throws IOException If fails
 */
private static Response fatal(final RqFallback req) throws IOException {
    return new RsWithStatus(
        new RsHtml(
            new RsVelocity(
                TkApp.class.getResource("error.html.vm"),
                new RsVelocity.Pair(
                    "err",
                    new TextOf(req.throwable()).asString()
                ),
                new RsVelocity.Pair("rev", TkApp.REV)
            )
        ),
        HttpURLConnection.HTTP_INTERNAL_ERROR
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    return new RsPage(
        "/xsl/logs.xsl",
        request,
        () -> new StickyList<>(
            new XeAppend("menu", "logs"),
            new XeDirectives(
                new Directives().add("logs").append(
                    new Joined<>(
                        new Limited<Iterable<Directive>>(
                            Tv.TWENTY,
                            new RqUser(this.base, request).logs()
                        )
                    )
                )
            )
        )
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    return new RsPage(
        "/xsl/scripts.xsl",
        request,
        () -> new StickyList<>(
            new XeAppend("menu", "scripts"),
            new XeAppend("stripe_cents", "500"),
            new XeAppend(
                "stripe_key",
                Manifests.read("ThreeCopies-StripeKey")
            ),
            new XeDirectives(
                new Directives().add("scripts").append(
                    new Joined<>(
                        new RqUser(this.base, request).scripts()
                    )
                )
            )
        )
    );
}
 

import org.takes.Response; //导入依赖的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.Response; //导入依赖的package包/类
@Override
public Response act(final Request request) throws IOException {
    final User user = new RqUser(this.base, request);
    final RqHref href = new RqHref.Base(request);
    final Iterator<String> name = href.href().param("name").iterator();
    return new RsPage(
        "/xsl/script.xsl",
        request,
        () -> new StickyList<>(
            new XeAppend("menu", "scripts"),
            new XeWhen(
                name.hasNext(),
                () -> new XeDirectives(
                    user.script(name.next()).toXembly()
                )
            )
        )
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(final Request req) {
    return new RsPage(
        req, "mistakes",
        () -> new IterableOf<>(
            new XeAppend(
                "worst",
                new XeDirectives(
                    new Joined<>(
                        new Limited<>(
                            // @checkstyle MagicNumber (1 line)
                            20, new Mistakes().worst()
                        )
                    )
                )
            )
        )
    );
}
 

import org.takes.Response; //导入依赖的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.Response; //导入依赖的package包/类
@Override
public Response act(final Request req) {
    return new RsPage(
        req, "all",
        () -> new IterableOf<>(
            new XeAppend(
                "recent",
                new XeDirectives(
                    new Joined<>(
                        new Results().all()
                    )
                )
            )
        )
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Future<Func<String, Response>> apply(final String group,
    final String artifact) {
    final String target = String.format("%s:%s", group, artifact);
    this.queue.put(target, System.currentTimeMillis());
    // @checkstyle MagicNumber (1 line)
    if (this.times.size() > 1000) {
        this.times.clear();
    }
    return this.service.submit(
        new VerboseCallable<>(
            () -> {
                final Func<String, Response> func =
                    this.origin.apply(group, artifact);
                this.times.add(
                    System.currentTimeMillis() - this.queue.remove(target)
                );
                return func;
            },
            true, true
        )
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Test
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
public void pingsSimplePages() throws IOException {
    final String[] pages = {
        "/org/jpeek/web/layout.xsl",
        "/org/jpeek/web/index.xsl",
        "/jpeek.css",
        "/",
        "/mistakes",
        "/robots.txt",
    };
    final Take app = new TkApp(Files.createTempDirectory("x"));
    for (final String page : pages) {
        final Response response = app.act(new RqFake("GET", page));
        MatcherAssert.assertThat(
            new RsPrint(response).print(),
            response,
            new HmRsStatus(HttpURLConnection.HTTP_OK)
        );
    }
}
 

import org.takes.Response; //导入依赖的package包/类
@Test
public void rendersOneReport() throws Exception {
    final ExecutorService service = Executors.newSingleThreadExecutor();
    final BiFunc<String, String, Func<String, Response>> bifunc =
        new AsyncReports(
            new SolidBiFunc<>(
                (first, second) -> service.submit(
                    () -> input -> {
                        TimeUnit.DAYS.sleep(1L);
                        return new RsText("done!");
                    }
                )
            )
        );
    final Response response =
        bifunc.apply("org.jpeek", "jpeek").apply("index.html");
    MatcherAssert.assertThat(
        response,
        new HmRsStatus(HttpURLConnection.HTTP_OK)
    );
    MatcherAssert.assertThat(
        XhtmlMatchers.xhtml(new RsPrint(response).printBody()),
        XhtmlMatchers.hasXPath("//xhtml:body")
    );
    service.shutdownNow();
}
 

import org.takes.Response; //导入依赖的package包/类
/**
 * Make fatal error page.
 * @param req Request
 * @return Response
 * @throws IOException If fails
 */
private static Response fatal(final RqFallback req) throws IOException {
    return new RsWithStatus(
        new RsWithType(
            new RsVelocity(
                TkAppFallback.class.getResource("error.html.vm"),
                new RsVelocity.Pair(
                    "err",
                    ExceptionUtils.getStackTrace(req.throwable())
                ),
                new RsVelocity.Pair("rev", TkAppFallback.REV)
            ),
            "text/html"
        ),
        HttpURLConnection.HTTP_INTERNAL_ERROR
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final String name = new RqFormBase(req).param("name")
        .iterator().next().trim();
    try {
        new SafeUser(this.base.user(new RqUser(req).name())).add(name);
    } catch (final SafeUser.InvalidNameException ex) {
        throw TkAdd.forward(new RsFlash(ex));
    }
    return TkAdd.forward(
        new RsFlash(
            String.format(
                "domain \"%s\" added", name
            )
        )
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    return new RsPage(
        "/xsl/domains.xsl",
        req,
        new XeAppend(
            "domains",
            new XeTransform<>(
                this.base.user(new RqUser(req).name()).mine(),
                TkDomains::source
            )
        ),
        new XeLink("add", "/add"),
        new XeLink("invalidate", "/invalidate")
    );
}
 

import org.takes.Response; //导入依赖的package包/类
@Override
public Response act(final Request req) throws IOException {
    final Iterable<Event> events = this.base.user(new RqUser(req).urn())
        .events()
        .iterate();
    return new RsPage(
        "/xsl/events.xsl",
        req,
        new XeAppend(
            "events",
            new XeChain(
                new XeTransform<>(
                    Iterables.limit(events, Tv.TWENTY),
                    TkEvents::source
                )
            ),
            new XeDirectives(
                new Directives().attr("total", Iterables.size(events))
            )
        )
    );
}