Java F类代码示例

import play.libs.F; //导入依赖的package包/类
public F.Promise<SimpleResult> call(Context ctx) {
    try {
        final String key = configuration.key();
        final Integer duration = configuration.duration();
        SimpleResult result = (SimpleResult) Cache.get(key);
        F.Promise<SimpleResult> promise;
        if(result == null) {
            promise = delegate.call(ctx);
            promise.onRedeem(new F.Callback<SimpleResult>() {
                @Override
                public void invoke(SimpleResult simpleResult) throws Throwable {
                    Cache.set(key, simpleResult, duration);
                }
            });
        } else {
            promise = F.Promise.pure(result);
        }
        return promise;
    } catch(RuntimeException e) {
        throw e;
    } catch(Throwable t) {
        throw new RuntimeException(t);
    }
}
 

import play.libs.F; //导入依赖的package包/类
public F.Promise<SimpleResult> call(Context ctx) {
    try {
        Authenticator authenticator = configuration.value().newInstance();
        String username = authenticator.getUsername(ctx);
        if(username == null) {
            Result unauthorized = authenticator.onUnauthorized(ctx);
            if (unauthorized instanceof AsyncResult) {
                return ((AsyncResult) unauthorized).getPromise();
            } else {
                return F.Promise.pure((SimpleResult) unauthorized);
            }
        } else {
            try {
                ctx.request().setUsername(username);
                return delegate.call(ctx);
            } finally {
                ctx.request().setUsername(null);
            }
        }
    } catch(RuntimeException e) {
        throw e;
    } catch(Throwable t) {
        throw new RuntimeException(t);
    }
}
 

import play.libs.F; //导入依赖的package包/类
@Test
public void errorsAsJson() {
    running(fakeApplication(), new Runnable() {
        @Override
        public void run() {
            Lang lang = new Lang(new play.api.i18n.Lang("en", ""));
            
            Map<String, List<ValidationError>> errors = new HashMap<String, List<ValidationError>>();
            List<ValidationError> error = new ArrayList<ValidationError>();
            error.add(new ValidationError("foo", RequiredValidator.message, new ArrayList<Object>()));
            errors.put("foo", error);
            
            DynamicForm form = new DynamicForm(new HashMap<String, String>(), errors, F.None());
            
            JsonNode jsonErrors = form.errorsAsJson(lang);
            assertThat(jsonErrors.findPath("foo").iterator().next().asText()).isEqualTo(play.i18n.Messages.get(lang, RequiredValidator.message));
        }
    });
}
 

import play.libs.F; //导入依赖的package包/类
public static F.Promise<Result> paymentTodayPresent() {
    JsonNode key = keystoreConnector.getKey(session("uuid")).get(timeout);
    Form<CalculatorPaymentToday> form = form(CalculatorPaymentToday.class);

    if(Optional.ofNullable(key).isPresent()) {
        JsonNode amountsDue = key.get("data").get("calculator-amounts-due-form");
        JsonNode paymentToday = key.get("data").get("calculator-payment-today-form");

        if (Optional.ofNullable(amountsDue).isPresent()) {

            if (Optional.ofNullable(paymentToday).isPresent())
                return F.Promise.promise(() -> ok(payment_today_form.render(Form.form(CalculatorPaymentToday.class)
                            .fill(fromJson(paymentToday, CalculatorPaymentToday.class)))));
            else
                return F.Promise.promise(() -> ok(payment_today_form.render(form)));
        } else return F.Promise.promise(() -> redirect(routes.CalculatorController.amountsDuePresent()));
    } else return F.Promise.promise(() -> redirect(routes.CalculatorController.amountsDuePresent()));
}
 

import play.libs.F; //导入依赖的package包/类
public static F.Promise<Result> resultsSubmit() {
    final Integer monthsToShow;
    String formMonths = form().bindFromRequest().get("months_to_show");
    if (formMonths != null) {
        monthsToShow = Ints.tryParse(formMonths);
    } else {
        monthsToShow = 3;
    }

    List<PaymentSchedule> schedules = getPaymentSchedules(monthsToShow);

    final PaymentSchedule scheduleToShow;

    if (Optional.ofNullable(monthsToShow).isPresent()) {
        scheduleToShow = schedules.stream().filter(s -> s.getInstalments().size() == monthsToShow).findFirst().orElse(schedules.stream().findFirst().get());
    } else {
        scheduleToShow = schedules.stream().findFirst().get();
    }
    List<Integer> availableOptions = schedules.stream().map(s -> s.getInstalments().size()).collect(Collectors.toList());
    return F.Promise.promise(() -> ok(results.render(scheduleToShow, availableOptions)));
}
 

import play.libs.F; //导入依赖的package包/类
public static F.Promise<Result> debtTypePresent() {
    JsonNode key = keystoreConnector.getKey(session("uuid")).get(SsttpFrontendConfig.timeout);
    Form<EligibilityDebtType> form = Form.form(EligibilityDebtType.class);

    if(Optional.ofNullable(key).isPresent()) {
        if(Optional.ofNullable(key.get("data").get("service-start")).isPresent()) {

            JsonNode debtType = key.get("data").get("eligibility-debt-type-form");

            if(Optional.ofNullable(debtType).isPresent()) {
                return F.Promise.promise(() -> ok(debt_type.render(Form.form(EligibilityDebtType.class)
                            .fill(fromJson(debtType, EligibilityDebtType.class)))));
            } else return F.Promise.promise(() -> ok(debt_type.render(form)));
        } else
            return F.Promise.promise(() -> redirect(routes.SelfServiceTimeToPayController.serviceStart()));
    } else return F.Promise.promise(() -> ok(debt_type.render(form)));
}
 

import play.libs.F; //导入依赖的package包/类
public static F.Promise<Result> debtTypeSubmit() {
    Form<EligibilityDebtType> form = Form.form(EligibilityDebtType.class).bindFromRequest();

    if(form.hasErrors()) {
        return F.Promise.promise(() -> ok(debt_type.render(form)));
    } else {
        EligibilityDebtType debtTypeAnswer = form.get();
        Logger.debug(toJson(debtTypeAnswer).toString());
        String uuid = session("uuid");

        if(Optional.ofNullable(uuid).isPresent())
            keystoreConnector.putKey(toJson(debtTypeAnswer), uuid, "eligibility-debt-type-form");

        if(debtTypeAnswer.isOtherTaxDebt()) {
            return F.Promise.promise(() -> redirect(routes.SelfServiceTimeToPayController.ttpCallUs()));
        } else {
            return F.Promise.promise(() -> redirect(routes.EligibilityController.existingTtpPresent()));
        }
    }
}
 

import play.libs.F; //导入依赖的package包/类
public static F.Promise<Result> existingTtpPresent() {
    JsonNode key = keystoreConnector.getKey(session("uuid")).get(SsttpFrontendConfig.timeout);
    Form<EligibilityExistingTTP> form = Form.form(EligibilityExistingTTP.class);

    if(Optional.ofNullable(key).isPresent()) {
        JsonNode debtType = key.get("data").get("eligibility-debt-type-form");
        JsonNode existingTtp = key.get("data").get("eligibility-existing-ttp-form");
        if(Optional.ofNullable(debtType).isPresent()) {
            if(Optional.ofNullable(existingTtp).isPresent())
                return F.Promise.promise(() ->
                        ok(existing_ttp.render(Form.form(EligibilityExistingTTP.class).fill(fromJson(existingTtp, EligibilityExistingTTP.class)))));
            else return F.Promise.promise(() -> ok(existing_ttp.render(form)));
        } else
            return F.Promise.promise(() -> redirect(routes.EligibilityController.present()));
    } else return F.Promise.promise(() -> ok(existing_ttp.render(form)));

}
 

import play.libs.F; //导入依赖的package包/类
public static F.Promise<Result> existingTtpSubmit() {
    Form<EligibilityExistingTTP> form = Form.form(EligibilityExistingTTP.class).bindFromRequest();

    if (form.hasErrors()) {
        return F.Promise.promise(() -> ok(existing_ttp.render(form)));
    } else {
        EligibilityExistingTTP existingTtpAnswer = form.get();
        String uuid = session("uuid");
        if(Optional.ofNullable(uuid).isPresent())
            keystoreConnector.putKey(toJson(existingTtpAnswer), uuid, "eligibility-existing-ttp-form");
        if(existingTtpAnswer.getExistingTTP()) {
            return F.Promise.promise(() -> redirect(routes.SelfServiceTimeToPayController.ttpCallUs()));
        } else {
            return F.Promise.promise(() -> redirect(routes.CalculatorController.present()));
        }
    }
}
 

import play.libs.F; //导入依赖的package包/类
public F.Promise<List<PaymentSchedule>> sendUserInput(CalculatorInput calcInput) {

        String calculatorUrl = String.format("%s/%s", baseUrl, "paymentschedule");

        Logger.debug(toJson(calcInput).toString());

        F.Promise<WSResponse> result = WS.url(calculatorUrl).post(toJson(calcInput));

        return result.map(r -> {
            if (r.getStatus() != 200) {
                return new ArrayList<PaymentSchedule>();
            } else {
                return Arrays.asList(fromJson(r.asJson(), PaymentSchedule[].class));
            }
        });
    }
 

import play.libs.F; //导入依赖的package包/类
@Test
public void displayAmountsDue() {
    running(fakeApplication(new SsttpFrontendGlobal()), () -> {
        CalculatorController calculatorController = new CalculatorController();
        calculatorController.keystoreConnector = mock(KeystoreConnector.class);

        when(calculatorController.keystoreConnector.getKey("1")).thenReturn(F.Promise.promise(() -> (tree)));

        Result result = callAction(routes.ref.CalculatorController.amountsDuePresent(),
                fakeRequest()
                        .withHeader("referer", "/self-service-time-to-pay")
                        .withSession("uuid", uuid).withSession("timestamp", timestamp));

        String body = Helpers.contentAsString(result);

        assertThat(status(result), is(Http.Status.OK));
        assertThat(body, containsString(Messages.get("ssttp.calculator.form.amounts_due.title")));
    });
}
 

import play.libs.F; //导入依赖的package包/类
@Test
public void displayPaymentTodayPresent() {
    running(fakeApplication(new SsttpFrontendGlobal()), () -> {
        CalculatorController calculatorController = new CalculatorController();
        calculatorController.keystoreConnector = mock(KeystoreConnector.class);

        when(calculatorController.keystoreConnector.getKey("1")).thenReturn(F.Promise.promise(() -> (tree)));

        Result result = callAction(routes.ref.CalculatorController.paymentTodayPresent(),
                fakeRequest()
                        .withHeader("referer", "/self-service-time-to-pay")
                        .withSession("uuid", uuid).withSession("timestamp", timestamp));

        String body = Helpers.contentAsString(result);

        assertThat(status(result), is(Http.Status.OK));
        assertThat(body, containsString(Messages.get("ssttp.calculator.form.payment_today.title")));
    });
}
 

import play.libs.F; //导入依赖的package包/类
@Test
public void submitPaymentTodayNoErrors() {
    running(fakeApplication(new SsttpFrontendGlobal()), () -> {
        Map<String, String> formData = Maps.newHashMap();
        formData.put("amount", "345");
        CalculatorController calculatorController = new CalculatorController();
        calculatorController.keystoreConnector = mock(KeystoreConnector.class);
        calculatorController.connector = mock(SelfAssessmentConnector.class);

        when(calculatorController.keystoreConnector.getKey("1")).thenReturn(F.Promise.promise(() -> (tree)));
        when(calculatorController.connector.sendUserInput(any(CalculatorInput.class)))
                .thenReturn(F.Promise.promise(() -> (
                        Arrays.asList(fromJson(calculatorResponseTree, PaymentSchedule[].class)))));

        Result result = callAction(routes.ref.CalculatorController.paymentTodaySubmit(),
                fakeRequest()
                        .withSession("uuid", uuid).withSession("timestamp", timestamp)
                        .withFormUrlEncodedBody(formData));

        String body = Helpers.contentAsString(result);

        // should display payment summary page
        assertThat(status(result), is(Http.Status.OK));
        assertThat(body, containsString(Messages.get("ssttp.calculator.results.title")));
    });
}
 

import play.libs.F; //导入依赖的package包/类
@Test
public void presentDebtTypePage() {
    running(fakeApplication(new SsttpFrontendGlobal()), () -> {
        Map<String, String> formData = Maps.newHashMap();
        EligibilityController eligibility = new EligibilityController();
        eligibility.keystoreConnector = mock(KeystoreConnector.class);

        when(eligibility.keystoreConnector.getKey("1")).thenReturn(F.Promise.promise(() -> (tree)));

        Result result = callAction(routes.ref.EligibilityController.debtTypePresent(),
                fakeRequest()
                        .withSession("uuid", uuid).withSession("timestamp", timestamp)
                        .withFormUrlEncodedBody(formData));
        String body = Helpers.contentAsString(result);

        assertThat(status(result), is(Http.Status.OK));
        assertThat(body, containsString(Messages.get("ssttp.eligibility.form.debt_type.title")));

    });
}
 

import play.libs.F; //导入依赖的package包/类
@Test
public void presentExistingTtpPage() {
    running(fakeApplication(new SsttpFrontendGlobal()), () -> {
        Map<String, String> formData = Maps.newHashMap();

        EligibilityDebtType form = new EligibilityDebtType(true, false);
        EligibilityController eligibilityController = new EligibilityController();
        eligibilityController.keystoreConnector = mock(KeystoreConnector.class);

        when(eligibilityController.keystoreConnector.getKey("1")).thenReturn(F.Promise.promise(() -> (tree)));

        Result result = callAction(routes.ref.EligibilityController.existingTtpPresent(),
                    fakeRequest()
                            .withSession("uuid", uuid).withSession("timestamp", timestamp)
                            .withFormUrlEncodedBody(formData).withSession("uuid", uuid));
        String body = Helpers.contentAsString(result);

        assertThat(status(result), is(Http.Status.OK));
        assertThat(body, containsString(Messages.get("ssttp.eligibility.form.existing_ttp.title")));
    });
}