summaryrefslogtreecommitdiff
path: root/lib/Ultramarine/Controller.pm6
blob: 5e18b48084929ae36979f8467b3b23423743757b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
use v6.d.PREVIEW;
use Cro::HTTP::Router;
use Cro::HTTP::Request;
use Cro::HTTP::Response;
use Cro::Transform;
use Cro;
 
class Ultramarine::Controller {
    has $.license is required;
    has $.authorisation is required;
    has $.collection is required;
 
    sub respond(*@body{
        response.status = 200;
        response.set-body(@body);
    }
 
    my class URLRewrite does Cro::Transform {
        method consumes() { Cro::HTTP::Request }
        method produces() { Cro::HTTP::Request }
 
        my token prefix { '/rest' }
        my token api-method { '/' \w+ }
        my token suffix { '.view' }
        my token query { '?' .* }
        my token api-url { ^ <prefix> <api-method> <suffix>? <query> $ }
 
        method transformer(Supply $requests --> Supply{
            supply whenever $requests -> $request {
                with $request {
                    if (.target ~~ /<api-url>/{
                        emit .clone(
                            original-target => .original-target // .target,
                            target => ($<api-url><prefix api-method query>).join,
                        );
                    }
                    else {
                        emit $_;
                    }
                }
            }
        }
    }
 
    method inner-routes() {
        return route {
            # this needs to be here, not in the Server because its 
            # short-circuited "unauthorised" response will be emited 
            # in an 'after' middleware, but the 
            # ResponseSerializerExtension is applied just before those 
            # middlewares, so our serialised won't be seen by the 
            # "unauthorised" response 
            before $!authorisation;
 
            post my $ping = -> 'ping' { respond [] }
            get $ping;
 
            post my $getLicense = -> 'getLicense' {
                my $expires = $.license.expires-at.DateTime.truncated-to('second');
                respond [
                    :status<ok>,
                    license => [
                                :valid($.license.is-valid.Str.lc),
                                :email($.license.email),
                                :licenseExpires($expires.yyyy-mm-dd ~ ':' ~ $expires.hh-mm-ss),
                            ],
                ],
            }
            get $getLicense;
 
            post my $getMusicFolders = -> 'getMusicFolders' {
                respond [
                    :status<ok>,
                    musicFolders => [
                        musicFolder => [ :id<0>:name<Music> ],
                    ]
                ],
            }
            get $getMusicFolders;
            # this is clearly not a Subsonic method 
            get -> 'dakkarList' {
                await $.collection.is-ready;
                respond [
                    :status<ok>,
                    songs => $.collection.all-songs,
                ];
            }
        }
    }
 
    method routes() {
        return Cro.compose(
            URLRewrite,
            route { include 'rest' => self.inner-routes() },
        );
    }
}