();
28 | for (String str in accept_header.split(",")){
29 | List arr = str.trim().replaceAll("-", "_").split(";");
30 |
31 | //Parse the locale
32 | Locale locale = null;
33 | List l = arr[0].split("_");
34 | switch(l.length){
35 | case 2: locale = new Locale(l[0], l[1]); break;
36 | case 3: locale = new Locale(l[0], l[1], variant: l[2]); break;
37 | default: locale = new Locale(l[0], ""); break;
38 | }
39 |
40 | //Parse the q-value
41 | // not been used
42 | /*double q = 1.0;
43 | for (String s in arr){
44 | s = s.trim();
45 | if (s.startsWith("q=")){
46 | q = double.parse(s.substring(2).trim());
47 | break;
48 | }
49 | }*/
50 |
51 | locales.add(locale);
52 | }
53 | return locales.isNotEmpty? locales[0] : null;
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/lib/i18n/cookie_locale_resolver.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | /**
4 | * {@link LocaleResolver} implementation that uses a cookie sent back to the user
5 | * in case of a custom setting, with a fallback to the specified default locale
6 | * or the request's accept-header locale.
7 | *
8 | * This is particularly useful for stateless applications without user sessions.
9 | */
10 | class CookieLocaleResolver extends AbstractLocaleResolver {
11 |
12 | /**
13 | * The default cookie name used if none is explicitly set.
14 | */
15 | final String DEFAULT_COOKIE_NAME = "FORCE.LOCALE";
16 |
17 | Locale defaultLocale;
18 |
19 | CookieHolderManager cookieManager = new CookieHolderManager();
20 |
21 | CookieLocaleResolver() {
22 | cookieManager.cookieName = DEFAULT_COOKIE_NAME;
23 | }
24 |
25 | /**
26 | * Set a fixed Locale that this resolver will return if no cookie found.
27 | */
28 | void setDefaultLocale(Locale defaultLocale) {
29 | this.defaultLocale = defaultLocale;
30 | }
31 |
32 | /**
33 | * Return the fixed Locale that this resolver will return if no cookie found,
34 | * if any.
35 | */
36 | Locale getDefaultLocale() {
37 | return this.defaultLocale;
38 | }
39 |
40 |
41 | Locale resolveLocale(ForceRequest request) {
42 | // Retrieve and parse cookie value.
43 | Cookie cookie = cookieManager.getCookie(request.request);
44 | if (cookie != null) {
45 | // ... todo for see implementation
46 | Locale locale = Locale.parseString(cookie.value); //StringUtils.parseLocaleString(cookie.value); How will I parse the cookie to a locale
47 |
48 | if (locale != null) {
49 | return locale;
50 | }
51 | }
52 |
53 | return determineDefaultLocale(request);
54 | }
55 |
56 | void setLocale(ForceRequest request, Locale locale) {
57 | if (locale != null) {
58 | cookieManager.addCookie(request.request.response, locale.toString());
59 | } else {
60 | // Set request attribute to fallback locale and remove cookie.
61 | cookieManager.removeCookie(request.request.response);
62 | }
63 | }
64 |
65 | /**
66 | * Determine the default locale for the given request,
67 | * Called if no locale cookie has been found.
68 | *
69 | * The default implementation returns the specified default locale,
70 | * if any, else falls back to the request's accept-header locale.
71 | * @param request the request to resolve the locale for
72 | * @return the default locale
73 | */
74 | Locale determineDefaultLocale(ForceRequest request) {
75 | Locale defaultLocale = getDefaultLocale();
76 | if (defaultLocale == null) {
77 | defaultLocale = Locale.defaultLocale;
78 | }
79 | return defaultLocale;
80 | }
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/lib/i18n/default_locale_resolver.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | abstract class AbstractLocaleResolver implements LocaleResolver {
4 |
5 | Locale _defaultLocale;
6 |
7 |
8 | /**
9 | * Set a default Locale that this resolver will return if no other locale found.
10 | */
11 | void setDefaultLocale(Locale defaultLocale) {
12 | this._defaultLocale = defaultLocale;
13 | }
14 |
15 | /**
16 | * Return the default Locale that this resolver is supposed to fall back to, if any.
17 | */
18 | Locale getDefaultLocale() {
19 | return this._defaultLocale;
20 | }
21 |
22 | }
--------------------------------------------------------------------------------
/lib/i18n/fixed_locale_resolver.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | /**
4 | * Always returns a default locale, implementation of a locale resolver
5 | */
6 | class FixedLocaleResolver extends AbstractLocaleResolver {
7 |
8 | /**
9 | * Create a FixedLocaleResolver that exposes the given locale.
10 | * @param locale the locale to expose
11 | */
12 | FixedLocaleResolver(Locale locale) {
13 | setDefaultLocale(locale);
14 | }
15 |
16 | Locale resolveLocale(ForceRequest request) {
17 | Locale locale = getDefaultLocale();
18 | if (locale == null) {
19 | locale = Locale.defaultLocale;
20 | }
21 | return locale;
22 | }
23 |
24 | void setLocale(ForceRequest request, Locale locale) {
25 | throw new UnsupportedError(
26 | "Cannot change fixed locale - use a different locale resolution strategy");
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/lib/i18n/locale_resolver.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | /**
4 | * Astract class for web-based locale resolution strategies that allows for
5 | * both locale resolution via the request and locale modification via
6 | * request and response.
7 | *
8 | * This interface allows for implementations based on request, session,
9 | * cookies, etc. The default implementation is AcceptHeaderLocaleResolver,
10 | * simply using the request's locale provided by the respective HTTP header.
11 | *
12 | */
13 | abstract class LocaleResolver {
14 |
15 | /**
16 | * Resolve the current locale via the given request.
17 | * Should return a default locale as fallback in any case.
18 | * @param request the request to resolve the locale for
19 | * @return the current locale (never null)
20 | */
21 | Locale resolveLocale(ForceRequest request);
22 |
23 | /**
24 | * Set the current locale to the given one.
25 | * @param request the request to be used for locale modification
26 | * @param locale the new locale, or null to clear the locale
27 | * @throws UnsupportedOperationException if the LocaleResolver implementation
28 | * does not support dynamic changing of the theme
29 | */
30 | void setLocale(ForceRequest request, Locale locale);
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/lib/manager/cookie_holder_manager.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class CookieHolderManager {
4 |
5 | static final Logger logger = new Logger('CookieManager');
6 |
7 | /**
8 | * Default path that cookies will be visible to: "/", i.e. the entire server.
9 | */
10 | static final String DEFAULT_COOKIE_PATH = "/";
11 |
12 | String cookiePath = DEFAULT_COOKIE_PATH;
13 |
14 | int cookieMaxAge;
15 | bool cookieSecure;
16 | String cookieName;
17 | String cookieDomain;
18 |
19 |
20 | /**
21 | * Add a cookie with the given value to the response,
22 | * using the cookie descriptor settings of this generator.
23 | *
24 | * Delegates to createCookie for cookie creation.
25 | * @param response the HTTP response to add the cookie to
26 | * @param cookieValue the value of the cookie to add
27 | */
28 | void addCookie(HttpResponse response, String cookieValue) {
29 | Cookie cookie = createCookie(cookieValue);
30 | int maxAge = cookieMaxAge;
31 | if (maxAge != null) {
32 | cookie.maxAge = maxAge;
33 | }
34 | if (cookieSecure) {
35 | cookie.secure = true;
36 | }
37 | response.cookies.add(cookie);
38 | logger.log(Level.INFO, "Added cookie with name [${cookieName}] and value [${cookieValue}]");
39 | }
40 |
41 | /**
42 | * Remove the cookie that this generator describes from the response.
43 | * Will generate a cookie with empty value and max age 0.
44 | *
45 | * Delegates to createCookie for cookie creation.
46 | * @param response the HTTP response to remove the cookie from
47 | */
48 | void removeCookie(HttpResponse response) {
49 | Cookie cookie = createCookie("");
50 | cookie.maxAge = 0;
51 | response.cookies.add(cookie);
52 | logger.log(Level.INFO, "Removed cookie with name [${cookieName}]");
53 | }
54 |
55 | /**
56 | * Create a cookie with the given value, using the cookie descriptor
57 | * settings of this manager (except for "cookieMaxAge").
58 | *
59 | * @param cookieValue the value of the cookie to crate
60 | * @return the cookie
61 | */
62 | Cookie createCookie(String cookieValue) {
63 | Cookie cookie = new Cookie(cookieName, cookieValue);
64 | if (cookieDomain != null) {
65 | cookie.domain = cookieDomain;
66 | }
67 | cookie.path = cookiePath;
68 | return cookie;
69 | }
70 |
71 | /**
72 | * Getting the cookie according to the request and the cookie name.
73 | *
74 | * @param request the HTTP request to retrieve the cookie from
75 | * @return the cookie
76 | */
77 | Cookie getCookie(HttpRequest request) {
78 | List cookies = request.cookies;
79 |
80 | if (cookies != null) {
81 | for (Cookie cookie in cookies) {
82 | if (cookieName == cookie.name) {
83 | return cookie;
84 | }
85 | }
86 | }
87 | return null;
88 | }
89 | }
--------------------------------------------------------------------------------
/lib/render/mustache_render.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class MustacheRender extends ForceViewRender {
4 | Delimiter delimiter = new Delimiter('{{', '}}');
5 |
6 | MustacheRender(ServingAssistent servingAssistent, [views = "../views/", clientFiles = "../build/web/", clientServe = true]) : super(servingAssistent, views, clientFiles, clientServe);
7 |
8 | String _render_impl(String template, model) {
9 | var output = render(_reviewTemplate(template), model, delimiter: delimiter);
10 | return _transform(output);
11 | }
12 |
13 | String _reviewTemplate(String result) {
14 | result = result.replaceAll("${delimiter.opening}&", "${delimiter.opening}&");
15 | return result;
16 | }
17 |
18 | String _transform(String result) {
19 | result = result.replaceAll("src=\"", "src=\"/");
20 | result = result.replaceAll("src=\"/http:/", "src=\"http:/");
21 | result = result.replaceAll("src=\"/../", "src=\"../");
22 | result = result.replaceAll("src='", "src='/");
23 | result = result.replaceAll("src='/http:/", "src='http:/");
24 | result = result.replaceAll("src='/../", "src='../");
25 | result = result.replaceAll("src='//", "src='/");
26 | result = result.replaceAll("src=\"//", "src=\"/");
27 | return result;
28 | }
29 | }
30 |
31 |
--------------------------------------------------------------------------------
/lib/render/view_render.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | abstract class ForceViewRender {
4 | final Logger log = new Logger('ForceViewRender');
5 | String views;
6 | String clientFiles;
7 | bool clientServe;
8 |
9 | ServingAssistent servingAssistent;
10 |
11 | ForceViewRender(this.servingAssistent, [this.views, this.clientFiles, this.clientServe]) {
12 | // Check so that we have a server side views directory exists
13 | views = Platform.script.resolve(views).toFilePath();
14 |
15 | _exists(views);
16 |
17 | // If we should serve client files, check that pub build has been run
18 | // or use the pub serve tric
19 | if(clientServe == true) {
20 | clientFiles = Platform.script.resolve(clientFiles).toFilePath();
21 |
22 | _exists(clientFiles);
23 | }
24 | }
25 |
26 | void _exists(dir) {
27 | try {
28 | if (!new Directory(dir).existsSync()) {
29 | log.severe("The '$dir' directory was not found.");
30 | }
31 | } on FileSystemException {
32 | log.severe("The '$dir' directory was not found.");
33 | }
34 | }
35 |
36 | Future render(String view, model) async {
37 | var viewUri = new Uri.file(views).resolve("$view.html");
38 | var file = new File(viewUri.toFilePath());
39 | var result = "";
40 |
41 | if (file.existsSync()) {
42 | result = await _readFile(file, model);
43 | } else {
44 | if (servingAssistent!=null) {
45 | try {
46 | Stream> inputStream = await servingAssistent.read(clientFiles, "$view.html");
47 | var template = await inputStream.transform(UTF8.decoder).first;
48 | result = _render_impl(template, model);
49 | } catch(e) {
50 | log.severe("The '$view' can't be resolved.");
51 | }
52 | } else {
53 | viewUri = new Uri.file(clientFiles).resolve("$view.html");
54 | file = new File(viewUri.toFilePath());
55 | if (file.existsSync()) {
56 | result = await _readFile(file, model);
57 | }
58 | }
59 | }
60 |
61 | return result;
62 | }
63 |
64 | Future _readFile(File file, model) async {
65 | var data = await file.readAsBytes();
66 | var template = new String.fromCharCodes(data);
67 | return _render_impl(template, model);
68 | }
69 |
70 | String _render_impl(String template, model);
71 | }
--------------------------------------------------------------------------------
/lib/security/no_security_strategy.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class NoSecurityStrategy extends SecurityStrategy {
4 |
5 | bool checkAuthorization(HttpRequest obj, List roles, data) => true;
6 |
7 | Uri getRedirectUri(HttpRequest req) {
8 | return Uri.parse("/");
9 | }
10 | }
--------------------------------------------------------------------------------
/lib/security/security_context_holder.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class SecurityContextHolder {
4 |
5 | SecurityStrategy strategy;
6 |
7 | SecurityContextHolder(this.strategy);
8 |
9 | bool checkAuthorization(HttpRequest req, List roles, {data: null}) {
10 | return this.strategy.checkAuthorization(req, roles, data);
11 | }
12 |
13 | Uri redirectUri(HttpRequest req) => this.strategy.getRedirectUri(req);
14 | }
--------------------------------------------------------------------------------
/lib/security/security_strategy.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | abstract class SecurityStrategy {
4 |
5 | bool checkAuthorization(T req, List roles, data);
6 |
7 | Uri getRedirectUri(HttpRequest req);
8 |
9 | }
--------------------------------------------------------------------------------
/lib/server/force_request.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class ForceRequest implements HttpInputMessage, HttpOutputMessage {
4 |
5 | HttpRequest request;
6 | Map path_variables;
7 | Completer _asyncCallCompleter;
8 | Locale locale;
9 |
10 | ForceRequest._();
11 |
12 | ForceRequest(this.request) {
13 | path_variables = new Map();
14 | _asyncCallCompleter = new Completer();
15 | }
16 |
17 | List header(String name) => request.headers[name.toLowerCase()];
18 |
19 | bool accepts(String type) =>
20 | request.headers['accept'].where((name) => name.split(',').indexOf(type) ).length > 0;
21 |
22 | bool isMime(String type) =>
23 | request.headers['content-type'].where((value) => value == type).isNotEmpty;
24 |
25 | bool get isForwarded => request.headers['x-forwarded-host'] != null;
26 |
27 | List get cookies => request.cookies.map((Cookie cookie) {
28 | cookie.name = Uri.decodeQueryComponent(cookie.name);
29 | cookie.value = Uri.decodeQueryComponent(cookie.value);
30 | return cookie;
31 | });
32 |
33 | void statusCode(int statusCode) {
34 | request.response.statusCode = statusCode;
35 | }
36 |
37 | // HTTPInputMessage
38 | Stream getBody() {
39 | return this.request.transform(const AsciiDecoder());
40 | }
41 |
42 | IOSink getOutputBody() {
43 | return request.response;
44 | }
45 |
46 | HttpHeadersWrapper getResponseHeaders() {
47 | return new HttpHeadersWrapper(this.request.response.headers);
48 | }
49 |
50 | HttpHeadersWrapper getRequestHeaders() {
51 | return new HttpHeadersWrapper(this.request.headers);
52 | }
53 |
54 | // All about getting post data
55 | Future getPostData({ bool usejson: true }) {
56 | Completer completer = new Completer();
57 | this.request.listen((List buffer) {
58 | // Return the data back to the client.
59 | String dataOnAString = new String.fromCharCodes(buffer);
60 |
61 | var package = usejson ? JSON.decode(dataOnAString) : dataOnAString;
62 | completer.complete(package);
63 | });
64 | return completer.future;
65 | }
66 |
67 | Future> getPostRawData() {
68 | Completer c = new Completer();
69 | this.getBody().listen((content) {
70 | c.complete(content);
71 | });
72 | return c.future;
73 | }
74 |
75 | Future> getPostParams({ Encoding enc: UTF8 }) {
76 | Completer c = new Completer();
77 | this.getBody().listen((content) {
78 | final postParams = new Map.fromIterable(
79 | content.split("&").map((kvs) => kvs.split("=")),
80 | key: (kv) => Uri.decodeQueryComponent(kv[0], encoding: enc),
81 | value: (kv) => Uri.decodeQueryComponent(kv[1], encoding: enc)
82 | );
83 | c.complete(postParams);
84 | });
85 | return c.future;
86 | }
87 |
88 | void async(value) {
89 | _asyncCallCompleter.complete(value);
90 | }
91 |
92 | Future get asyncFuture => _asyncCallCompleter.future;
93 |
94 | }
95 |
--------------------------------------------------------------------------------
/lib/server/handler_interceptor.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class HandlerInterceptor {
4 |
5 | bool preHandle(ForceRequest req, Model model, Object handler) => true;
6 |
7 | void postHandle(ForceRequest req, Model model, Object handler) {}
8 |
9 | void afterCompletion(ForceRequest req, Model model, Object handler) {}
10 |
11 | }
--------------------------------------------------------------------------------
/lib/server/http_request_streamer.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class HttpRequestStreamer {
4 |
5 | StreamController _controller;
6 |
7 | HttpRequestStreamer() {
8 | this._controller = new StreamController();
9 | }
10 |
11 | void add(HttpRequest request) {
12 | this._controller.add(request);
13 | }
14 |
15 | Stream get stream => _controller.stream;
16 | }
--------------------------------------------------------------------------------
/lib/server/interceptors_collection.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class InterceptorsCollection {
4 |
5 | List interceptors = new List();
6 |
7 | void add(HandlerInterceptor interceptor) {
8 | this.interceptors.add(interceptor);
9 | }
10 |
11 | void addAll(List interceptors) {
12 | this.interceptors.addAll(interceptors);
13 | }
14 |
15 | void preHandle(ForceRequest req, Model model, Object handler) {
16 | for (HandlerInterceptor interceptor in interceptors) {
17 | if (!interceptor.preHandle(req, model, handler)) {
18 | break;
19 | }
20 | }
21 | }
22 |
23 | void postHandle(ForceRequest req, Model model, Object handler) {
24 | for (HandlerInterceptor interceptor in interceptors) {
25 | interceptor.postHandle(req, model, handler);
26 | }
27 | }
28 |
29 | void afterCompletion(ForceRequest req, Model model, Object handler) {
30 | for (HandlerInterceptor interceptor in interceptors) {
31 | interceptor.afterCompletion(req, model, handler);
32 | }
33 | }
34 |
35 | }
--------------------------------------------------------------------------------
/lib/server/model.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class Model {
4 |
5 | final Logger log = new Logger('Model');
6 |
7 | var dynamic;
8 | // Changed from Map into generic,
9 | // You can add other types of object without limitation
10 | Map values = new Map();
11 |
12 | void addAttributeObject(dynamic) {
13 | this.dynamic = dynamic;
14 | }
15 |
16 | void addAttribute(String key, var value) {
17 | values[key] = value;
18 | }
19 |
20 | bool containsAttribute(String key) {
21 | return values.containsKey(key);
22 | }
23 |
24 | getData() {
25 | if (dynamic!=null) {
26 | if (values.isNotEmpty) {
27 | List dataList = new List();
28 | dataList.add(dynamic);
29 | dataList.add(values);
30 | return dataList;
31 | }
32 | return dynamic;
33 | } else {
34 | return values;
35 | }
36 | }
37 | }
--------------------------------------------------------------------------------
/lib/server/mvc_typedefs.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | typedef WebSocketHandler(WebSocket ws, HttpRequest req);
4 | typedef dynamic ControllerHandler(ForceRequest req, Model model);
5 | typedef ResponseHook(HttpResponse res);
--------------------------------------------------------------------------------
/lib/server/path_analyzer.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class PathAnalyzer {
4 |
5 | String _path;
6 | String route = "";
7 | String expression = "([^/]+?)";
8 |
9 | List variables;
10 |
11 | PathAnalyzer(this._path) {
12 | analyze();
13 | }
14 |
15 | void analyze() {
16 | variables = new List();
17 |
18 | bool capture = false;
19 | String variable = "";
20 | var chars_raw = this._path.split("");
21 | for (var ch in chars_raw) {
22 | if (ch == "{") {
23 | capture = true;
24 | variable = "";
25 | } else if (ch == "}") {
26 | capture = false;
27 | variables.add(variable);
28 | route = "$route$expression";
29 | } else if (capture) {
30 | variable = "$variable$ch";
31 | } else {
32 | route = "$route$ch";
33 | }
34 | }
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/lib/server/registry.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class ForceRegistry {
4 |
5 | WebApplication webApplication;
6 | File _basePath;
7 | HttpMessageRegulator messageRegulator = new HttpMessageRegulator();
8 |
9 | ForceRegistry(this.webApplication) {
10 | _basePath = new File(Platform.script.toFilePath());
11 |
12 | ApplicationContext.bootstrap();
13 |
14 | ApplicationContext.setBean("HttpMessageRegulator", messageRegulator);
15 | }
16 |
17 | void loadValues(String path) {
18 | var valuesUri = new Uri.file(_basePath.path).resolve(path);
19 | var file = new File(valuesUri.toFilePath());
20 | var yaml = file.readAsStringSync();
21 |
22 | ApplicationContext.registerMessage(path, yaml);
23 | }
24 |
25 | void scanning() {
26 | // scan for controllers
27 | var classes = ApplicationContext.addComponents(new Scanner<_Controller>().scan());
28 |
29 | // scan for restcontrollers
30 | var rest_classes = ApplicationContext.addComponents(new Scanner<_RestController>().scan());
31 |
32 | // scan for controllerAdvicers classes
33 | var advisers = ApplicationContext.addComponents(new Scanner<_ControllerAdvice>().scan());
34 |
35 | List> adviserModels = new List>();
36 | List> adviserExc = new List>();
37 | for (var obj in advisers) {
38 | adviserModels.addAll(new MetaDataHelper().from(obj));
39 | adviserExc.addAll(new MetaDataHelper().from(obj));
40 | }
41 |
42 | /* now register all the controller classes */
43 | for (var obj in classes) {
44 | this._register(obj, adviserModels, adviserExc);
45 | }
46 |
47 | /* now register all the controller classes */
48 | for (var obj in rest_classes) {
49 | this._register(obj, adviserModels, adviserExc, isRest: true);
50 | }
51 |
52 | // Search for interceptors
53 | ClassSearcher searcher = new ClassSearcher();
54 | List interceptorList = searcher.scan();
55 |
56 | webApplication.interceptors.addAll(interceptorList);
57 | }
58 |
59 | void register(Object obj) {
60 | _register(obj, new List>(), new List>());
61 | }
62 |
63 | void _register(Object obj, List> adviserModels, List> adviserExc, {bool isRest: false}) {
64 | List> mirrorValues = new MetaDataHelper().from(obj);
65 | List> mirrorModels = new MetaDataHelper().from(obj);
66 | mirrorModels.addAll(adviserModels);
67 |
68 | var _ref; //Variable to check null values
69 |
70 | // first look if the controller has a @Authentication annotation
71 | var roles = (_ref = new AnnotationScanner<_Authentication>().instanceFrom(obj))== null ? null : _ref.roles;
72 | // then look at PreAuthorizeRoles, when they are defined // then look at PreAuthorizeRoles, when they are defined
73 | roles = (_ref = new AnnotationScanner().instanceFrom(obj))== null ? roles : _ref.roles;
74 |
75 | String startPath = (_ref = new AnnotationScanner().instanceFrom(obj)) != null ? _ref.value : "";
76 |
77 | for (MetaDataValue mv in mirrorValues) {
78 | // execute all ! ! !
79 | PathAnalyzer pathAnalyzer = new PathAnalyzer(mv.object.value);
80 |
81 | UrlPattern urlPattern = new UrlPattern("${startPath}${pathAnalyzer.route}");
82 | this.webApplication.use(urlPattern, (ForceRequest req, Model model) {
83 | try {
84 | // prepare model
85 | model = _prepareModel(model, mirrorModels);
86 |
87 | // Has ResponseStatus in metaData?
88 | bool hasResponseBody = _hasResponseBody(mv.getOtherMetadata(), req) || isRest;
89 |
90 | // search for path variables
91 | for (var i = 0; pathAnalyzer.variables.length > i; i++) {
92 | var variableName = pathAnalyzer.variables[i],
93 | value = urlPattern.parse(req.request.uri.path)[i];
94 | req.path_variables[variableName] = value;
95 | }
96 |
97 | List positionalArguments = _calculate_positionalArguments(mv, model, req);
98 | Object obj = _executeFunction(mv, positionalArguments);
99 |
100 | if (hasResponseBody) {
101 | // model.getData().clear();
102 | // model.addAttributeObject(obj);
103 | messageRegulator.loopOverMessageConverters(req, obj);
104 | return new ResponseDone();
105 | } else {
106 | return obj;
107 | }
108 |
109 | } catch (e, stackTrace) {
110 | // Look for exceptionHandlers in this case
111 | print(stackTrace);
112 | List> mirrorExceptions = new MetaDataHelper().from(obj);
113 | mirrorExceptions.addAll(adviserExc);
114 |
115 | return _errorHandling(mirrorExceptions, model, req, e);
116 | }
117 | }, method: mv.object.method, roles: roles);
118 | }
119 | }
120 |
121 | Model _prepareModel(Model model, List> mirrorModels) {
122 | for (MetaDataValue mvModel in mirrorModels) {
123 |
124 | InstanceMirror res = mvModel.invoke([]);
125 |
126 | if (res != null && res.hasReflectee) {
127 | model.addAttribute(mvModel.object.value, res.reflectee);
128 | }
129 | }
130 | return model;
131 | }
132 |
133 | bool _hasResponseBody(List otherMetaData, req) {
134 | bool hasResponseBody = false;
135 |
136 | for (var metaData in otherMetaData) {
137 | if (metaData is ResponseStatus) {
138 | ResponseStatus responseStatus = metaData;
139 | // set response status
140 | req.statusCode(responseStatus.value);
141 | }
142 | if (metaData is _ResponseBody) {
143 | hasResponseBody = true;
144 | }
145 | }
146 | return hasResponseBody;
147 | }
148 |
149 | _errorHandling(List> mirrorExceptions, Model model, ForceRequest req, e) {
150 | if (mirrorExceptions.length == 0) {
151 | throw e;
152 | } else {
153 | MetaDataValue mdvException = null;
154 |
155 | for (MetaDataValue mdv in mirrorExceptions) {
156 | if (mdv.object.type !=null && e.runtimeType == mdv.object.type) {
157 | mdvException = mdv;
158 | }
159 | if (mdvException == null && mdv.object.type==null) {
160 | mdvException = mdv;
161 | }
162 | }
163 |
164 | if (mdvException!=null) {
165 | List positionalArguments = _calculate_positionalArguments(mdvException, model, req, e);
166 | return _executeFunction(mdvException, positionalArguments);
167 | } else {
168 | throw e;
169 | }
170 | }
171 | }
172 |
173 | _executeFunction(MetaDataValue mdv, List positionalArguments) {
174 | InstanceMirror res = mdv.invoke(positionalArguments);
175 | return res.reflectee;
176 | }
177 |
178 | List _calculate_positionalArguments(MetaDataValue mv, Model model, ForceRequest req, [ex_er]) {
179 | List positionalArguments = [];
180 | for (ParameterMirror pm in mv.parameters) {
181 | String name = (MirrorSystem.getName(pm.simpleName));
182 |
183 | if (pm.type is Model || name == 'model') {
184 | positionalArguments.add(model);
185 | } else if (pm.type is ForceRequest || name == 'req') {
186 | positionalArguments.add(req);
187 | } else if (pm.type is HttpSession || name == 'session') {
188 | positionalArguments.add(req.request.session);
189 | } else if (pm.type is HttpHeaders || name == 'headers') {
190 | positionalArguments.add(req.request.headers);
191 | } else if (pm.type is Exception || name == 'exception') {
192 | positionalArguments.add(ex_er);
193 | } else if (pm.type is Error || name == 'error') {
194 | positionalArguments.add(ex_er);
195 | } else if (pm.type is Locale || name == 'locale') {
196 | positionalArguments.add(req.locale);
197 | } else {
198 | if (req.path_variables[name] != null) {
199 | positionalArguments.add(req.path_variables[name]);
200 | } else {
201 | for (InstanceMirror im in pm.metadata) {
202 | if (im.reflectee is PathVariable) {
203 | PathVariable pathVariable = im.reflectee;
204 | if (req.path_variables[pathVariable.value] != null) {
205 | positionalArguments.add(req.path_variables[pathVariable.value]);
206 | }
207 | }
208 | if (im.reflectee is RequestParam) {
209 | RequestParam rp = im.reflectee;
210 | String qvalue = (rp.value == "" ? name : rp.value);
211 | if (req.request.uri.queryParameters[qvalue] != null) {
212 | positionalArguments.add(req.request.uri.queryParameters[qvalue]);
213 | } else {
214 | if (rp.required) {
215 | throw new RequiredError("${qvalue} not found on the queryParameters");
216 | } else {
217 | positionalArguments.add(rp.defaultValue);
218 | }
219 | }
220 | }
221 | }
222 | }
223 | }
224 | }
225 | if (positionalArguments.isEmpty && mv.parameters.length == 2) {
226 | positionalArguments = [req, model];
227 | }
228 | return positionalArguments;
229 | }
230 | }
231 |
232 | /**
233 | * When a request parameter is been required this will be thrown.
234 | */
235 | class RequiredError extends Error {
236 | final String message;
237 | RequiredError(this.message);
238 | String toString() => "Required: $message";
239 | }
240 |
241 | /**
242 | * When a response is already done by a responseBody or RestController.
243 | */
244 | class ResponseDone {}
245 |
--------------------------------------------------------------------------------
/lib/server/request_method.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class RequestMethod {
4 | static const GET = 'GET';
5 | static const POST = 'POST';
6 | static const DELETE = 'DELETE';
7 | static const PUT = 'PUT';
8 | static const HEAD = 'HEAD';
9 | static const OPTIONS = 'OPTIONS';
10 | static const TRACE = 'TRACE';
11 | }
--------------------------------------------------------------------------------
/lib/server/response_hooks.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | response_hook_cors(HttpResponse response) {
4 | response
5 | ..headers.add("Access-Control-Allow-Origin", "*, ")
6 | ..headers.add("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
7 | ..headers.add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
8 | }
--------------------------------------------------------------------------------
/lib/server/serving_assistent.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class ServingAssistent {
4 | final Uri pubServeUrl; // They read that from the Environment variable
5 | final client = new HttpClient();
6 | final http_server.VirtualDirectory vd;
7 |
8 | ServingAssistent(this.pubServeUrl, this.vd);
9 |
10 | Future proxyToPub(HttpRequest request, String path) {
11 | const RESPONSE_HEADERS = const [
12 | HttpHeaders.CONTENT_LENGTH,
13 | HttpHeaders.CONTENT_TYPE ];
14 |
15 | var uri = pubServeUrl.resolve(path);
16 | return client.openUrl(request.method, uri)
17 | .then((proxyRequest) {
18 | proxyRequest.headers.removeAll(HttpHeaders.ACCEPT_ENCODING);
19 | return proxyRequest.close();
20 | })
21 | .then((proxyResponse) {
22 | proxyResponse.headers.forEach((name, values) {
23 | if (RESPONSE_HEADERS.contains(name)) {
24 | request.response.headers.set(name, values);
25 | }
26 | });
27 | request.response.statusCode = proxyResponse.statusCode;
28 | request.response.reasonPhrase = proxyResponse.reasonPhrase;
29 | return proxyResponse.pipe(request.response);
30 | })
31 | .catchError((e) {
32 | print("Unable to connect to 'pub serve' for '${request.uri}': $e");
33 | var error = new AssistentError(
34 | "Unable to connect to 'pub serve' for '${request.uri}': $e");
35 | return new Future.error(error);
36 | });
37 | }
38 |
39 | Future serveFromFile(HttpRequest request, String path) {
40 | // Check if the request path is pointing to a static resource.
41 | Uri fileUri = Platform.script.resolve(path);
42 | File file = new File(fileUri.toFilePath());
43 | return file.exists().then((exists) {
44 | if (exists) {
45 | return vd.serveFile(file, request);
46 | } else {
47 | // look outside the build folder!
48 | path = path.replaceFirst("/build", "");
49 | fileUri = Platform.script.resolve(path);
50 | file = new File(fileUri.toFilePath());
51 | if (file.existsSync()) {
52 | return vd.serveFile(file, request);
53 | } else {
54 | print("Unable to serve for file at this path '${request.uri}'");
55 | var error = new AssistentError("Unable to serve form file to 'pub serve' for '${request.uri}'");
56 | return new Future.error(error);
57 | }
58 | }
59 | });
60 | }
61 |
62 | Future>> readFromPub(String path) {
63 | var uri = pubServeUrl.resolve(path);
64 | return client.openUrl('GET', uri)
65 | .then((request) => request.close())
66 | .then((response) {
67 | if (response.statusCode == HttpStatus.OK) {
68 | return response;
69 | } else {
70 | var error = new AssistentError(
71 | "Failed to fetch asset '$path' from pub: "
72 | "${response.statusCode}.");
73 | return new Future.error(error);
74 | }
75 | })
76 | .catchError((error) {
77 | if (error is! AssistentError) {
78 | error = new AssistentError(
79 | "Failed to fetch asset '$path' from pub: '${path}': $error");
80 | }
81 | return new Future.error(error);
82 | });
83 | }
84 |
85 | Future serve(HttpRequest request, String root, String path) {
86 | if (pubServeUrl != null) {
87 | // path = normalize(path);
88 |
89 | return proxyToPub(request, path);
90 | } else {
91 | return serveFromFile(request, "${root}${path}");
92 | }
93 | }
94 |
95 | Future just_serve(HttpRequest request, String root, String path) {
96 | if (pubServeUrl != null) {
97 | // path = normalize(path);
98 |
99 | return proxyToPub(request, path);
100 | } else {
101 | return serveFromFile(request, "${root}${path}");
102 | }
103 | }
104 |
105 | Future>> readFromFile(String root, String path) {
106 | path = normalize(path);
107 | return FileSystemEntity.isFile(root + path).then((exists) {
108 | if (exists) {
109 | return new File(root + path).openRead();
110 | } else {
111 | var error = new AssistentError("Asset '$path' not found");
112 | return new Future.error(error);
113 | }
114 | });
115 | }
116 |
117 | Future>> read(String root, String path) {
118 | if (pubServeUrl != null) {
119 | return readFromPub(path);
120 | } else {
121 | return readFromFile(root, path);
122 | }
123 | }
124 |
125 | }
126 |
127 | class AssistentError extends Error {
128 | final message;
129 |
130 | /** The [message] describes the erroneous argument. */
131 | AssistentError([this.message]);
132 |
133 | String toString() {
134 | if (message != null) {
135 | return "Illegal argument(s): $message";
136 | }
137 | return "Illegal argument(s)";
138 | }
139 | }
--------------------------------------------------------------------------------
/lib/server/serving_files.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class ServingFiles {
4 | final Logger log = new Logger('ServingFiles');
5 |
6 | Router router;
7 |
8 | var virDir;
9 |
10 | List staticFileTypes = ["dart", "js", "css", "png", "gif", "jpeg", "jpg", "webp", "html", "map"];
11 |
12 | void _serveClient(staticFiles, clientFiles, clientServe) {
13 | if(clientServe == true) {
14 | // Set up default handler. This will serve files from our 'build' directory.
15 | Uri clientFilesAbsoluteUri = Platform.script.resolve(clientFiles);
16 | virDir = new http_server.VirtualDirectory(clientFilesAbsoluteUri.toFilePath());
17 |
18 | servingAssistent = new ServingAssistent(_pubServeUrl(), virDir);
19 |
20 | // Disable jail-root, as packages are local sym-links.
21 | virDir..jailRoot = false
22 | ..allowDirectoryListing = true;
23 |
24 | // Add an error page handler.
25 | virDir.errorPageHandler = (HttpRequest request) {
26 | _notFoundHandling(request);
27 | };
28 |
29 | // Serve everything not routed elsewhere through the virtual directory.
30 | virDir.serve(router.defaultStream);
31 |
32 | // Start serving static files
33 | _serveStaticFiles(staticFiles);
34 |
35 | // Start serving transformable files
36 | _serveTransformableFiles(clientFiles);
37 | } else {
38 | log.info("You are serving the clientside files your self! Force is not serving clientside files!");
39 | }
40 | }
41 |
42 | void _notFoundHandling(HttpRequest request) {
43 | log.warning("Resource not found ${request.uri.path}");
44 | request.response.statusCode = HttpStatus.NOT_FOUND;
45 | }
46 |
47 | void serveFile(HttpRequest request, String root, String fileName) {
48 | if (servingAssistent==null) {
49 | log.warning("servingAssistent is not defined!");
50 | } else {
51 | servingAssistent.just_serve(request, root, fileName).catchError((e) {
52 | log.warning(e);
53 | _notFoundHandling(request);
54 | });
55 | }
56 | }
57 |
58 | void _serveTransformableFiles(clientFiles) {
59 | for (var fileType in staticFileTypes) {
60 | String parts = '([/|.|\\-|\\w|\\W|\\s])*\\.(?:${fileType})';
61 | var pattern = new UrlPattern(parts);
62 |
63 | this._serveWithPatterns(clientFiles, pattern);
64 | }
65 | }
66 |
67 |
68 | void _serveWithPatterns(clientFiles, UrlPattern pattern) {
69 | router.serve(pattern).listen((request) {
70 | var path = request.uri.path;
71 | serveFile(request, clientFiles, path);
72 | });
73 | }
74 |
75 | void _serveStaticFiles(clientFiles) {
76 | var pattern = new UrlPattern('/static/([/|.|\\-|\\w|\\s])*');
77 |
78 | router.serve(pattern).listen((request) {
79 | String path = request.uri.path;
80 | path = path.replaceAll('/static/', '');
81 |
82 | if (servingAssistent!=null) {
83 | servingAssistent.serveFromFile(request, "${clientFiles}${path}").catchError((e) {
84 | print(e);
85 | _notFoundHandling(request);
86 | });
87 | }
88 | });
89 | }
90 |
91 | Uri _pubServeUrl() {
92 | var env = Platform.environment;
93 | String pubServeUrlString = env['DART_PUB_SERVE'];
94 |
95 | Uri pubServeUrl = pubServeUrlString != null
96 | ? Uri.parse(pubServeUrlString)
97 | : null;
98 | return pubServeUrl;
99 | }
100 |
101 | void set servingAssistent(ServingAssistent servingAssistent)
102 | => ApplicationContext.setBean("ServingAssistent", servingAssistent);
103 |
104 | ServingAssistent get servingAssistent
105 | => ApplicationContext.getBeanByType(ServingAssistent);
106 | }
107 |
108 |
--------------------------------------------------------------------------------
/lib/server/simple_web_server.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class SimpleWebServer {
4 | final Logger log = new Logger('SimpleServer');
5 |
6 | Router router;
7 |
8 | var host;
9 | var port;
10 | var wsPath;
11 | var staticFiles;
12 | var clientFiles;
13 | var clientServe;
14 | var virDir;
15 | var bind_address = InternetAddress.ANY_IP_V6;
16 |
17 | Completer _completer = new Completer.sync();
18 |
19 | SimpleWebServer(this.host,
20 | this.port,
21 | this.wsPath,
22 | this.staticFiles,
23 | this.clientFiles,
24 | this.clientServe) {
25 | init();
26 | }
27 |
28 | void init() {
29 | if (host != null) {
30 | this.bind_address = host;
31 | }
32 |
33 | if(clientServe == true) {
34 | String clientFilesPath = Platform.script.resolve(clientFiles).toFilePath();
35 |
36 | _exists(clientFilesPath);
37 | }
38 | }
39 |
40 | void _exists(dir) {
41 | try {
42 | if (!new Directory(dir).existsSync()) {
43 | log.severe("The '$dir' directory was not found.");
44 | }
45 | } on FileSystemException {
46 | log.severe("The '$dir' directory was not found.");
47 | }
48 | }
49 |
50 | /**
51 | * This method helps to start your webserver.
52 | *
53 | * You can add a [WebSocketHandler].
54 | */
55 |
56 | Future start({WebSocketHandler handleWs: null, FallbackStart fallback}) {
57 | HttpServer.bind(bind_address, port).then((server) {
58 | _onStartComplete(server, handleWs);
59 | }).catchError((e) {
60 | if (fallback==null) {
61 | var error = _errorOnStart(e);
62 | return new Future.error(error);
63 | } else {
64 | fallback(this, handleWs);
65 | }
66 | });
67 |
68 | return _completer.future;
69 | }
70 |
71 | /**
72 | * This method helps to start your webserver in a secure way.
73 | *
74 | * You can add a [WebSocketHandler], [SecurityContext], requestClientCertificate, backlog
75 | *
76 | * The optional argument [backlog] can be used to specify the listen
77 | * backlog for the underlying OS listen setup. If [backlog] has the
78 | * value of [:0:] (the default) a reasonable value will be chosen by
79 | * the system.
80 | *
81 | * The certificate chain and the private key are set in the [context] SecurityContext object
82 | * that is passed to bindSecure.
83 | *
84 | */
85 |
86 | Future startSecure({WebSocketHandler handleWs: null, SecurityContext context, bool requestClientCertificate: false,
87 | int backlog: 0}) {
88 | HttpServer.bindSecure(bind_address, port, context,
89 | requestClientCertificate: requestClientCertificate,
90 | backlog: backlog).then((server) {
91 | _onStartComplete(server, handleWs);
92 | }).catchError((e) {
93 | var error = _errorOnStart(e);
94 | return new Future.error(error);
95 | });
96 |
97 | return _completer.future;
98 | }
99 |
100 | void _onStartComplete(Stream incoming, [WebSocketHandler handleWs]) {
101 | _onStart(incoming, handleWs);
102 | _completer.complete(const []);
103 | }
104 |
105 | Error _errorOnStart(e) {
106 | log.warning("Could not startup the web server ... $e");
107 | log.warning("Is your port already in use?");
108 | return new WebApplicationStartError("Unable to start with '${host}' - '${port}': $e");
109 | }
110 |
111 | Stream serve(String name) {
112 | return router.serve(name);
113 | }
114 |
115 | void setupConsoleLog([Level level = Level.INFO]) {
116 | Logger.root.level = level;
117 | Logger.root.onRecord.listen((LogRecord rec) {
118 | if (rec.level >= Level.SEVERE) {
119 | var stack = rec.stackTrace != null ? rec.stackTrace : "";
120 | print('${rec.level.name}: ${rec.time}: ${rec.message} - ${rec.error} $stack');
121 | } else {
122 | print('${rec.level.name}: ${rec.time}: ${rec.message}');
123 | }
124 | });
125 | }
126 |
127 | _onStart(Stream incoming, [WebSocketHandler handleWs]) {}
128 | }
129 |
130 | class WebApplicationStartError extends Error {
131 | final message;
132 |
133 | /** The [message] describes the erroneous argument. */
134 | WebApplicationStartError([this.message]);
135 |
136 | String toString() {
137 | if (message != null) {
138 | return "WebApplication start error: $message";
139 | }
140 | return "WebApplication start error";
141 | }
142 | }
143 |
144 | /*
145 | * This is been used in the restartFallback
146 | */
147 | typedef FallbackStart(SimpleWebServer sws, WebSocketHandler wsHandler);
148 |
149 | var randomPortFallback = (SimpleWebServer sws, WebSocketHandler wsHandler) {
150 | var rng = new Random();
151 | var newPortNumber = rng.nextInt(8888) + 1000;
152 |
153 | sws.port = newPortNumber;
154 | sws.start(handleWs: wsHandler);
155 | };
156 |
--------------------------------------------------------------------------------
/lib/server/web_application.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class WebApplication extends SimpleWebServer with ServingFiles {
4 | final Logger log = new Logger('WebApplication');
5 |
6 | bool cors=false;
7 | Router router;
8 | String views;
9 | ForceRegistry registry;
10 |
11 | InterceptorsCollection interceptors = new InterceptorsCollection();
12 |
13 | List responseHooks = new List();
14 | HttpRequestStreamer requestStreamer;
15 | Map _staticResources = new Map();
16 |
17 | ControllerHandler _notFound;
18 |
19 | WebApplication({host: "127.0.0.1",
20 | port: 8080,
21 | wsPath: '/ws',
22 | staticFiles: '../static/',
23 | clientFiles: '../build/web/',
24 | clientServe: true,
25 | this.views: "../views/",
26 | startPage,
27 | cors:true}) :
28 | super(host, port, wsPath, staticFiles,
29 | clientFiles, clientServe) {
30 | if (startPage!=null) { static("/", startPage); };
31 | if(cors==true){ this.responseHooks.add(response_hook_cors); }
32 |
33 | securityContext = new SecurityContextHolder(new NoSecurityStrategy());
34 | localeResolver = new AcceptHeaderLocaleResolver();
35 | exceptionResolver = new SimpleExceptionResolver();
36 |
37 | registry = new ForceRegistry(this);
38 | }
39 |
40 | void _scanning() {
41 | this.registry.scanning();
42 | }
43 |
44 | void use(Pattern url, ControllerHandler controllerHandler,
45 | {method: RequestMethod.GET, List roles}) {
46 | _completer.future.whenComplete(() {
47 | this.router.serve(url, method: method).listen((HttpRequest req) {
48 | if (checkSecurity(req, roles)) {
49 | _resolveRequest(req, controllerHandler);
50 | } else {
51 |
52 | Uri location = securityContext.redirectUri(req);
53 | req.response.redirect(location, status: HttpStatus.MOVED_PERMANENTLY);
54 | }
55 | });
56 | });
57 | }
58 |
59 | void static(Pattern url, String name,
60 | {method: RequestMethod.GET, List roles}) {
61 | bool containsAlreadyStatic = _staticResources.containsKey(url);
62 | _staticResources[url] = name;
63 |
64 | _completer.future.whenComplete(() {
65 | if (!containsAlreadyStatic) {
66 | this.router.serve(url, method: method).listen((HttpRequest req) {
67 | if (checkSecurity(req, roles)) {
68 | _resolveStatic(req, _staticResources[url]);
69 | } else {
70 | SecurityContextHolder sch = ApplicationContext.getBeanByType(SecurityContextHolder);
71 | Uri location = sch.redirectUri(req);
72 | req.response.redirect(location, status: HttpStatus.MOVED_PERMANENTLY);
73 | }
74 | });
75 | }
76 | });
77 | }
78 |
79 | void notFound(ControllerHandler controllerHandler) {
80 | this._notFound = controllerHandler;
81 | }
82 |
83 | void _notFoundHandling(HttpRequest request) {
84 | super._notFoundHandling(request);
85 | if (_notFound!=null) {
86 | _resolveRequest(request, _notFound);
87 | } else {
88 | request.response.close();
89 | }
90 | }
91 |
92 | bool checkSecurity(HttpRequest req, List roles) {
93 | if (roles != null) {
94 | SecurityContextHolder securityContext = ApplicationContext.getBeanByType(SecurityContextHolder);
95 | return securityContext.checkAuthorization(req, roles);
96 | } else {
97 | return true;
98 | }
99 | }
100 |
101 | void _resolveStatic(HttpRequest req, String name) {
102 | if (servingAssistent==null) {
103 | log.warning("servingAssistent is not defined!");
104 | } else {
105 | servingAssistent.just_serve(req, clientFiles, name).catchError((e) {
106 | print(e);
107 | _notFoundHandling(req);
108 | });
109 | }
110 | }
111 |
112 | void _resolveRequest(HttpRequest req, ControllerHandler controllerHandler) {
113 | Model model = new Model();
114 | ForceRequest forceRequest = new ForceRequest(req);
115 |
116 | // check locale
117 | if (localeResolver != null) forceRequest.locale = localeResolver.resolveLocale(forceRequest);
118 |
119 | var result;
120 |
121 | try {
122 | interceptors.preHandle(forceRequest, model, this);
123 | result = controllerHandler(forceRequest, model);
124 | interceptors.postHandle(forceRequest, model, this);
125 | } catch (e) {
126 | // do proper exception handling
127 | if (e is Exception) {
128 | result = exceptionResolver.resolveException(forceRequest, model, e);
129 | } else if (e is Error) {
130 | result = exceptionResolver.resolveError(forceRequest, model, e);
131 | }
132 | }
133 | if (result != null) {
134 | // template rendering
135 | if (result is String) {
136 | _resolveView(result, req, model);
137 | } else if (result is Future) {
138 | Future future = result;
139 | future.then((e) {
140 | if (e is String) {
141 | _resolveView(e, req, model);
142 | } else if (e is! HttpResponse) {
143 | model.addAttributeObject(e);
144 | _send_json(model.getData(), req);
145 | }
146 | });
147 | } else if (result is ResponseDone) {
148 | req.response.close();
149 | } else if (result is! HttpResponse) {
150 | model.addAttributeObject(result);
151 | _send_json(model.getData(), req);
152 | }
153 | } else {
154 | _send_json(model.getData(), req);
155 | }
156 | interceptors.afterCompletion(forceRequest, model, this);
157 | }
158 |
159 | void _send_json(rawData, HttpRequest req) {
160 | String data = JSON.encode(rawData);
161 | _send_response(req.response, new ContentType("application", "json", charset: "utf-8"), data);
162 | }
163 |
164 | void _resolveView(String view, HttpRequest req, Model model) {
165 | if (view.startsWith("redirect:")) {
166 | Uri location = Uri.parse(view.substring(9));
167 | req.response.redirect(location, status: HttpStatus.MOVED_TEMPORARILY);
168 | } else {
169 | _send_template(req, model, view);
170 | }
171 | }
172 |
173 | void register(Object obj) {
174 | this.registry.register(obj);
175 | }
176 |
177 | void _send_template(HttpRequest req, Model model, String view) {
178 | this.viewRender.render(view, model.getData()).then((String result) {
179 | _send_response(req.response, new ContentType("text", "html", charset: "utf-8"), result);
180 | });
181 | }
182 |
183 | void _send_response(HttpResponse response, ContentType contentType, String result) {
184 | responseHooks.forEach((ResponseHook responseHook) {
185 | responseHook(response);
186 | });
187 | response
188 | ..headers.contentType = contentType
189 | ..write(result)
190 | ..close();
191 | }
192 |
193 | /**
194 | * This requestHandler can be used to hook into the system without having to start a server.
195 | * You need to use this method for example with Google App Engine runtime.
196 | *
197 | * @param request is the current HttpRequest that needs to be handled by the system.
198 | * @param optional parameter to handle webSockets
199 | */
200 | void requestHandler(HttpRequest request, [WebSocketHandler handleWs]) {
201 | if (requestStreamer==null) {
202 | // initialize all
203 | requestStreamer = new HttpRequestStreamer();
204 | _onStartComplete(requestStreamer.stream, handleWs);
205 | }
206 | this.requestStreamer.add(request);
207 | }
208 |
209 | void _onStart(Stream incoming, [WebSocketHandler handleWs]) {
210 | log.info("Web server is running on "
211 | "'http://${Platform.localHostname}:$port/'");
212 | _scanning();
213 | router = new Router(incoming);
214 |
215 | // The client will connect using a WebSocket. Upgrade requests to '/ws' and
216 | // forward them to 'handleWebSocket'.
217 | if (handleWs != null) {
218 | Stream stream = router.serve(this.wsPath);
219 | stream.listen((HttpRequest req) {
220 | // stream.transform(new WebSocketTransformer())
221 | // .listen(handleWs);
222 | if(WebSocketTransformer.isUpgradeRequest(req)) {
223 | WebSocketTransformer.upgrade(req).then((WebSocket ws) {
224 | handleWs(ws, req);
225 | });
226 | }
227 | });
228 | }
229 |
230 | // Serve dart and static files (if not explicitly disabled by clientServe)
231 | _serveClient(staticFiles, clientFiles, clientServe);
232 | if (viewRender == null) {
233 | viewRender = new MustacheRender(servingAssistent, views, clientFiles, clientServe);
234 | }
235 | }
236 |
237 | // For Backwards compatibility
238 | void set strategy(SecurityStrategy strategy) {
239 | securityContext.strategy = strategy;
240 | }
241 |
242 | void set securityContext(SecurityContextHolder sch)
243 | => ApplicationContext.setBean("securityContextHolder", sch);
244 |
245 | SecurityContextHolder get securityContext
246 | => ApplicationContext.getBeanByType(SecurityContextHolder);
247 |
248 | void set exceptionResolver(HandlerExceptionResolver handlerExceptionResolver)
249 | => ApplicationContext.setBean("exceptionResolver", handlerExceptionResolver);
250 |
251 | HandlerExceptionResolver get exceptionResolver
252 | => ApplicationContext.getBeanByType(HandlerExceptionResolver);
253 |
254 | void set localeResolver(LocaleResolver localeResolver)
255 | => ApplicationContext.setBean("localeResolver", localeResolver);
256 |
257 | LocaleResolver get localeResolver
258 | => ApplicationContext.getBeanByType(LocaleResolver);
259 |
260 | void set viewRender(ForceViewRender viewRender)
261 | => ApplicationContext.setBean("viewRender", viewRender);
262 |
263 | ForceViewRender get viewRender
264 | => ApplicationContext.getBeanByType(ForceViewRender);
265 |
266 | void loadValues(String path) => this.registry.loadValues(path);
267 | }
268 |
--------------------------------------------------------------------------------
/lib/test.dart:
--------------------------------------------------------------------------------
1 | library dart_force_mvc_unittest_lib;
2 |
3 | import 'package:mock/mock.dart';
4 | import 'package:forcemvc/force_mvc.dart';
5 | import 'dart:io';
6 | import 'dart:async';
7 | import 'dart:convert';
8 |
9 | class MockHttpRequest extends Mock implements HttpRequest {}
10 |
11 | class MockForceRequest implements ForceRequest {
12 |
13 | var postData;
14 | Map postParams = new Map();
15 | List mockCookies = new List();
16 |
17 | HttpRequest request;
18 | Map path_variables;
19 | Completer _asyncCallCompleter;
20 | Locale locale;
21 |
22 | MockForceRequest({this.postData: "test"}) {
23 | path_variables = new Map();
24 | _asyncCallCompleter = new Completer();
25 | request = new MockHttpRequest();
26 | }
27 |
28 | List header(String name) => new List();
29 |
30 | bool accepts(String type) => true;
31 |
32 | bool isMime(String type) => true;
33 |
34 | bool get isForwarded => false;
35 |
36 | List get cookies => mockCookies;
37 |
38 | void statusCode(int statusCode) {}
39 |
40 | // HTTPInputMessage
41 | Stream getBody() {
42 | return this.request.transform(const AsciiDecoder());
43 | }
44 |
45 | IOSink getOutputBody() {
46 | return request.response;
47 | }
48 |
49 | HttpHeadersWrapper getResponseHeaders() {
50 | return new HttpHeadersWrapper(this.request.response.headers);
51 | }
52 |
53 | HttpHeadersWrapper getRequestHeaders() {
54 | return new HttpHeadersWrapper(this.request.headers);
55 | }
56 |
57 | Future getPostData({ bool usejson: true }) {
58 | Completer completer = new Completer();
59 | completer.complete(postData);
60 |
61 | return completer.future;
62 | }
63 |
64 | Future> getPostRawData() {
65 | Completer c = new Completer();
66 | c.complete(postParams);
67 | return c.future;
68 | }
69 |
70 | Future> getPostParams({ Encoding enc: UTF8 }) {
71 | Completer c = new Completer();
72 | c.complete(postParams);
73 | return c.future;
74 | }
75 |
76 | void async(value) {
77 | this._asyncCallCompleter.complete(value);
78 | }
79 |
80 | Future get asyncFuture => _asyncCallCompleter.future;
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/lib/utils/mime_type_utils.dart:
--------------------------------------------------------------------------------
1 | part of dart_force_mvc_lib;
2 |
3 | class MimeTypeUtils {
4 |
5 | /**
6 | * Parse the given String into a single [MimeType].
7 | * @param mimeType the string to parse
8 | * @return the mime type
9 | */
10 | static MimeType parseMimeType(String mimeType) {
11 | if (mimeType.length == 0) {
12 | throw new InvalidMimeTypeError(mimeType, "'mimeType' must not be empty");
13 | }
14 | List parts = mimeType.split(";");
15 | String fullType = parts[0].trim();
16 |
17 | if (MimeType.WILDCARD_TYPE == fullType) {
18 | fullType = "*/*";
19 | }
20 | int subIndex = fullType.indexOf('/');
21 | if (subIndex == -1) {
22 | throw new InvalidMimeTypeError(mimeType, "does not contain '/'");
23 | }
24 | if (subIndex == fullType.length - 1) {
25 | throw new InvalidMimeTypeError(mimeType, "does not contain subtype after '/'");
26 | }
27 | String type = fullType.substring(0, subIndex);
28 | String subtype = fullType.substring(subIndex + 1, fullType.length);
29 | if (MimeType.WILDCARD_TYPE == type && !(MimeType.WILDCARD_TYPE == subtype)) {
30 | throw new InvalidMimeTypeError(mimeType, "wildcard type is legal only in '*/*' (all mime types)");
31 | }
32 |
33 | Map parameters = null;
34 | if (parts.length > 1) {
35 | parameters = new LinkedHashMap();
36 | for (int i = 1; i < parts.length; i++) {
37 | String parameter = parts[i];
38 | int eqIndex = parameter.indexOf('=');
39 | if (eqIndex != -1) {
40 | String attribute = parameter.substring(0, eqIndex);
41 | String value = parameter.substring(eqIndex + 1, parameter.length);
42 | parameters[attribute] = value;
43 | }
44 | }
45 | }
46 | return new MimeType(type, subtype: subtype, parameters: parameters);
47 | }
48 |
49 | /**
50 | * Return a string representation of the given list of MimeType objects.
51 | * @param mimeTypes the string to parse
52 | * @return the list of mime types
53 | * @throws IllegalArgumentException if the String cannot be parsed
54 | */
55 | static String toStringify(Iterable mimeTypes) {
56 | String builder = "";
57 | bool hasNext = true;
58 | for (Iterator iterator = mimeTypes.iterator; hasNext;) {
59 | MimeType mimeType = iterator.current;
60 | builder = "$builder${mimeType.toString()}";
61 | hasNext = iterator.moveNext();
62 | if (hasNext) {
63 | builder = "$builder, ";
64 | }
65 | }
66 | return builder;
67 | }
68 |
69 | }
70 |
--------------------------------------------------------------------------------
/pubspec.yaml:
--------------------------------------------------------------------------------
1 | name: forcemvc
2 | version: 0.8.5
3 | author: Joris Hermans
4 | description: A serverside web mvc framework with templates
5 | homepage: https://github.com/ForceUniverse/dart-forcemvc
6 | dependencies:
7 | http_server: '>=0.9.0 <0.10.0'
8 | logging: '>=0.11.0 <0.12.0'
9 | route: '>=0.4.0 <0.5.0'
10 | mustache4dart: '>=1.0.0 <1.1.0'
11 | wired: '>=0.4.5 <0.4.6'
12 | locale: '>=0.1.1+2 <0.1.2'
13 | jsonify: '>=0.0.1 <0.0.2'
14 | dev_dependencies:
15 | test: '>=0.12.1 <0.13.0'
16 | mock: '>=0.11.0 <0.11.1'
17 | environment:
18 | sdk: '>=1.9.0 <2.0.0'
19 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 |  [](https://drone.io/github.com/ForceUniverse/dart-forcemvc/latest)
2 |
3 | ### Dart Force MVC ###
4 |
5 | 
6 |
7 | Serverside MVC based implementation for Dart. Easy to setup and part of the dart force framework!
8 |
9 | #### Introduction ####
10 |
11 | Dart ForceMVC is a dartlang webframework, with a lot of similarities to java spring mvc
12 |
13 | First of all you need to setup a webserver:
14 |
15 | ```dart
16 | library x;
17 | import 'package:wired/wired.dart';
18 | import 'package:forcemvc/force_mvc.dart';
19 |
20 | part 'controllers/x_controller.dart';
21 |
22 | main() {
23 | WebApplication app = new WebApplication(startPage: "start.html");
24 |
25 | app.start();
26 | }
27 | ```
28 |
29 | And then ofcource we need to create our controller.
30 |
31 | ```dart
32 | part of x;
33 |
34 | @Controller
35 | class XController {
36 |
37 | @RequestMapping(value: "/home", method: RequestMethod.GET)
38 | String home(Locale locale, Model model) {
39 | model.addAttribute("someprop", "value" );
40 |
41 | return "home";
42 | }
43 |
44 | }
45 | ```
46 |
47 | In the web folder of your application you can create a home.html file. That will be your view.
48 |
49 | #### Walkthrough ####
50 |
51 | Use a Web Application Server with dart very easily, create controllers with annotations ... similar to java spring mvc.
52 |
53 | First you will setup a new web application.
54 |
55 | WebApplication app = new WebApplication(wsPath: wsPath, port: port, host: host, buildPath: buildPath);
56 |
57 | Then you use the 'use' method to handle http requests.
58 |
59 | app.use(url, (ForceRequest req, Model model) { /* logic */ }, method: "GET");
60 |
61 | You can also use the annotation RequestMapping in a dart object
62 |
63 | @RequestMapping(value: "/someurl", method: "GET")
64 | void index(ForceRequest req, Model model)
65 |
66 | You can also use the annotation @ModelAttribute to add an object to all the scopes in the methods.
67 | An @ModelAttribute on a method argument indicates the argument should be retrieved from the model. If not present in the model, the argument should be instantiated first and then added to the model. Once present in the model, the argument's fields should be populated from all request parameters that have matching names.
68 |
69 | @ModelAttribute("someValue")
70 | String someName() {
71 | return mv.getValue();
72 | }
73 |
74 | Then you register that object on the WebApplication object.
75 |
76 | app.register(someObjectWithRequestMappingAnnotations)
77 |
78 | Or you can annotate a class with @Controller and then it will be registered automatically in the force WebApplication.
79 |
80 | @Controller
81 | class SomeObject {
82 |
83 | }
84 |
85 | #### Starting your web application ####
86 |
87 | You can do this as follow!
88 |
89 | app.start();
90 |
91 | It is also possible to start a web application with SSL possibilities.
92 |
93 | app.startSecure();
94 |
95 | #### ForceRequest ####
96 |
97 | ForceRequest is an extension for HttpRequest
98 |
99 | forceRequest.postData().then((data) => print(data));
100 |
101 | #### Interceptors ####
102 |
103 | You can define inteceptors as follow, the framework will pick up all the HandlerInterceptor classes or implementations.
104 |
105 | class RandomInterceptor implements HandlerInterceptor {
106 |
107 | bool preHandle(ForceRequest req, Model model, Object handler) { return true; }
108 | void postHandle(ForceRequest req, Model model, Object handler) {}
109 | void afterCompletion(ForceRequest req, Model model, Object handler) {}
110 |
111 | }
112 |
113 | #### Path variables ####
114 |
115 | You can now use path variables in force mvc.
116 |
117 | @RequestMapping(value: "/var/{var1}/other/{var2}/", method: "GET")
118 | void pathvariable(ForceRequest req, Model model, String var1, String var2)
119 |
120 | This is an alternative way how you can access path variables.
121 |
122 | req.path_variables['var1']
123 |
124 | You can also use the annotation @PathVariable("name") to match the pathvariable, like below:
125 |
126 | @RequestMapping(value: "/var/{var1}/", method: "GET")
127 | String multivariable(req, Model model, @PathVariable("var1") variable) {}
128 |
129 | #### Redirect ####
130 |
131 | You can instead of returning a view name, performing a redirect as follow:
132 |
133 | @RequestMapping(value: "/redirect/")
134 | String redirect(req, Model model) {
135 | redirect++;
136 | return "redirect:/viewable/";
137 | }
138 |
139 | #### Asynchronous Controller ####
140 |
141 | In the controller you can have asynchronous methods to handle for example POST methods much easier.
142 |
143 | On the ForceRequest object you have a method .async and his value is the return value that matters for the req.
144 |
145 | When a method is asynchrounous you must return req.asyncFuture.
146 |
147 | This is an example how you can use it.
148 |
149 | @RequestMapping(value: "/post/", method: "POST")
150 | Future countMethod(req, Model model) {
151 | req.getPostParams().then((map) {
152 | model.addAttribute("email", map["email"]);
153 |
154 | req.async(null);
155 | });
156 | model.addAttribute("status", "ok");
157 |
158 | return req.asyncFuture;
159 | }
160 |
161 | #### Authentication ####
162 |
163 | You can now add the annotation @Authentication to a controller class.
164 | This will make it necessary to for a user to authenticate before accessing these resources.
165 |
166 | An authentication in force is following a strategy.
167 | You can set a strategy by extending the class SecurityStrategy.
168 |
169 | class SessionStrategy extends SecurityStrategy {
170 |
171 | bool checkAuthorization(HttpRequest req, {data: null}) {
172 | HttpSession session = req.session;
173 | return (session["user"]!=null);
174 | }
175 |
176 | Uri getRedirectUri(HttpRequest req) {
177 | var referer = req.uri.toString();
178 | return Uri.parse("/login/?referer=$referer");
179 | }
180 | }
181 |
182 | And then add this strategy to the web application.
183 |
184 | app.strategy = new SessionStrategy();
185 |
186 | ##### Roles #####
187 |
188 | You can also define authorize roles. This can be done as follow.
189 |
190 | @Controller
191 | @PreAuthorizeRoles(const ["ADMIN"])
192 | class AdminController {
193 |
194 | }
195 |
196 | ##### ExceptionHandler #####
197 |
198 | This helps in defining methods that will be executed when an error or exception occured.
199 |
200 | @ExceptionHandler()
201 | String error_catch(req, Model model) {
202 | ...
203 | }
204 |
205 | You can also specify a type, only when an error or exception happend of that Type, that method will be executed.
206 |
207 | @ExceptionHandler(type: DoorLockedError)
208 | String doorLockedError(req, Model model) {
209 | model.addAttribute("explanation", "This is a specific error!");
210 | return "error";
211 | }
212 |
213 | #### Logging ####
214 |
215 | You can easily boostrap logging.
216 |
217 | app.setupConsoleLog();
218 |
219 | #### Wired ####
220 |
221 | Wired is a dependency injection package.
222 | You can use @Autowired and @bean and more in forcemvc find info [here](https://github.com/ForceUniverse/dart-force_it)
223 |
224 | #### LocaleResolver ####
225 |
226 | In ForceMVC you have a locale resolver to handle locale.
227 | The implementation that is been used by default is the AcceptHeaderLocale Resolver, this resolver looks at the request header accept-language.
228 |
229 | You can choose for a fixed locale resolver implementation or a cookie locale resolver or just implement your own handling if need.
230 |
231 | #### View / Templating ####
232 |
233 | In forcemvc you can define view templates. ForceMvc will look into the viewfolder and in the client 'build' folder for a .html file with the viewname that you provide the system in the controller.
234 |
235 | @RequestMapping(value: "/hello/")
236 | String redirect(req, Model model) {
237 | // do something
238 | model.addAttribute("text", "greetings");
239 | return "hello";
240 | }
241 |
242 | So in the example about we are returning a string with the value 'hello'. So the system will search in the view & build folder for a hello.html file.
243 |
244 | The default implementation in ForceMVC for templating is mustache.
245 |
246 | In the html file {{text}} will be replaced by greetings.
247 |
248 | More info about creating your own viewrender implementation [here](https://github.com/ForceUniverse/dart-forcemvc/wiki/Create-your-own-viewrender)
249 |
250 | #### Development trick ####
251 |
252 | Following the next steps will make it easier for you to develop, this allows you to adapt clientside files and immidiatly see results with doing a pub build.
253 |
254 | pub serve web --hostname 0.0.0.0 --port 7777 &&
255 | export DART_PUB_SERVE="http://localhost:7777" &&
256 | pub run bin/server.dart
257 |
258 | #### GAE ####
259 |
260 | You can now easily run your Force apps on a Google App Engine infrastructure by the following code! The rest is the same as a normal dart force app.
261 |
262 | WebApplication app = new WebApplication();
263 |
264 | runAppEngine(app.requestHandler).then((_) {
265 | // Server running. and you can do all the stuff you want!
266 | });
267 |
268 | You don't need to start WebApplication anymore, the start of the server will be done by AppEngine!
269 |
270 | More info about [GAE overall](https://www.dartlang.org/cloud/)
271 |
272 | #### Rest API's ####
273 |
274 | If you want to learn more about how to build Rest api's with ForceMVC go [here](https://github.com/ForceUniverse/dart-forcemvc/tree/master/example/server/controllers/rest)
275 |
276 | #### Example ####
277 |
278 | You can find a simple example with a page counter implementation [here](https://github.com/jorishermans/dart-forcemvc-example) - [live demo](http://forcemvc.herokuapp.com/)
279 |
280 | Or visit Github issue mover [here](https://github.com/google/github-issue-mover)
281 |
282 | #### Youtube ####
283 |
284 | You can watch a simple youtube video to get you started, have an idea between the transformation of java spring mvc and force mvc [here](https://www.youtube.com/watch?v=AcwnoiYEv8I)
285 |
286 | #### TODO ####
287 |
288 | - get more annotations and options for sending the response back
289 | - writing tests
290 |
291 | ### Notes to Contributors ###
292 |
293 | #### Fork Dart Force MVC ####
294 |
295 | If you'd like to contribute back to the core, you can [fork this repository](https://help.github.com/articles/fork-a-repo) and send us a pull request, when it is ready.
296 |
297 | If you are new to Git or GitHub, please read [this guide](https://help.github.com/) first.
298 |
299 | #### Dart Force ####
300 |
301 | Realtime web framework for dart that uses force MVC & wired [source code](https://github.com/ForceUniverse/dart-force)
302 |
303 | #### Twitter ####
304 |
305 | Follow us on twitter https://twitter.com/usethedartforce
306 |
307 | #### Google+ ####
308 |
309 | Follow us on [google+](https://plus.google.com/111406188246677273707)
310 |
311 | #### Join our discussion group ####
312 |
313 | [Google group](https://groups.google.com/forum/#!forum/dart-force)
314 |
--------------------------------------------------------------------------------
/resources/dart_force_logo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ForceUniverse/dart-forcemvc/f1199f185783c0caca699ed0b6f18113feb7d256/resources/dart_force_logo.jpg
--------------------------------------------------------------------------------
/test/locale_resolver_test.dart:
--------------------------------------------------------------------------------
1 | import 'package:test/test.dart';
2 | import 'package:forcemvc/force_mvc.dart';
3 |
4 | main() {
5 | // First tests!
6 | var accept_header_string = "en-ca,en;q=0.8,en-us;q=0.6,de-de;q=0.4,de;q=0.2";
7 |
8 | test("test locale resolving", () {
9 | AcceptHeaderLocaleResolver lr = new AcceptHeaderLocaleResolver();
10 |
11 | Locale locale = lr.resolveLocaleWithHeader(accept_header_string);
12 |
13 | expect("en_CA", locale.toString());
14 | });
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/test/locale_test.dart:
--------------------------------------------------------------------------------
1 | import 'package:test/test.dart';
2 | import 'package:forcemvc/force_mvc.dart';
3 |
4 | main() {
5 | // First tests!
6 | var locale = Locale.ENGLISH;
7 |
8 | test('test basic locale', () {
9 | expect(locale.toString(), "en");
10 | });
11 |
12 | // "en", "de_DE", "_GB", "en_US_WIN", "fr__MAC"
13 | test('test locale parsing en', () {
14 | Locale locale = Locale.parseString("en");
15 | expect(locale.getLanguage(), "en");
16 | });
17 |
18 | test('test locale parsing de_DE', () {
19 | Locale locale = Locale.parseString("de_DE");
20 | expect(locale.getLanguage(), "de");
21 | expect(locale.getCountry(), "DE");
22 | });
23 |
24 | test('test locale parsing _GB', () {
25 | Locale locale = Locale.parseString("_GB");
26 | expect(locale.getLanguage(), "");
27 | expect(locale.getCountry(), "GB");
28 | });
29 |
30 | test('test locale parsing en_US_WIN', () {
31 | Locale locale = Locale.parseString("en_US_WIN");
32 | expect(locale.getLanguage(), "en");
33 | expect(locale.getCountry(), "US");
34 | expect(locale.getVariant(), "WIN");
35 | });
36 |
37 | test('test locale parsing fr__MAC', () {
38 | Locale locale = Locale.parseString("fr__MAC");
39 | expect(locale.getLanguage(), "fr");
40 | expect(locale.getCountry(), "");
41 | expect(locale.getVariant(), "MAC");
42 | });
43 |
44 | }
--------------------------------------------------------------------------------
/test/path_test.dart:
--------------------------------------------------------------------------------
1 | import 'package:test/test.dart';
2 | import 'package:forcemvc/force_mvc.dart';
3 | import 'package:route/server.dart' show UrlPattern, Router;
4 |
5 | main() {
6 | // First tests!
7 | var path = "/some/{var1}/path/{var2}";
8 | PathAnalyzer pathAnalyzer = new PathAnalyzer(path);
9 |
10 | var expression = pathAnalyzer.expression;
11 |
12 | test('test the path analyzer', () {
13 | expect(pathAnalyzer.variables.length, 2);
14 | expect(pathAnalyzer.variables.last, "var2");
15 | expect(pathAnalyzer.route, "/some/$expression/path/$expression");
16 | });
17 |
18 | UrlPattern urlPattern = getMeUrlPattern("/some/{var1}");
19 | test('test the urlpattern of path analyzer route', () {
20 | expect(urlPattern.matches("/some/blablabla"), true);
21 | });
22 |
23 | UrlPattern urlPattern2 = getMeUrlPattern("/entities/entity/{id}");
24 | test('test special characters in the testing group', () {
25 | expect(urlPattern2.matches("/entities/entity/188575e0-d700-11e5-d18b-f130bc592bc4"), true);
26 | });
27 | }
28 |
29 | UrlPattern getMeUrlPattern(path) {
30 | PathAnalyzer path_analyzer = new PathAnalyzer(path);
31 | var route = path_analyzer.route;
32 | //var regex = r"/some/(\w+)";
33 | UrlPattern urlPattern = new UrlPattern(route);
34 | return urlPattern;
35 | }
36 |
--------------------------------------------------------------------------------
Force mvc examples