,
71 | @Inject(MAT_DIALOG_DATA) public data: any
72 | ) { }
73 |
74 | ngOnInit() {
75 | }
76 |
77 | cancel() {
78 | this.dialogRef.close();
79 | }
80 |
81 | /* download() {
82 | window.open(CoreUtils.resolveUrl(this.data.track.url), '_blank');
83 | }*/
84 |
85 | }
86 |
87 |
--------------------------------------------------------------------------------
/web/src/app/my-music/components/artists.component.ts:
--------------------------------------------------------------------------------
1 | import {ChangeDetectionStrategy, Component, Input, OnChanges, SimpleChanges} from '@angular/core';
2 | import {Album, Artist} from '@app/model';
3 | import {DomSanitizer} from '@angular/platform-browser';
4 |
5 | @Component({
6 | selector: 'app-my-music-artists',
7 | template: `
8 |
25 |
26 |
31 |
32 | `,
33 | styles: [`
34 | .controls {
35 | padding: 0 1rem;
36 | display: flex;
37 | flex-direction: row;
38 | align-items: center;
39 | flex-wrap: wrap;
40 | }
41 | .play-all {
42 | margin: 1rem 0
43 | }
44 | .play-all mat-icon {
45 | vertical-align: middle;
46 | margin-right: 0.2rem;
47 | }
48 | .filler {
49 | flex-grow: 1;
50 | }
51 | .search {
52 | min-width: 13rem;
53 | }
54 | `],
55 | changeDetection: ChangeDetectionStrategy.OnPush
56 | })
57 | export class ArtistsComponent implements OnChanges {
58 |
59 | @Input() artists: Artist[];
60 |
61 | displayedArtists: Artist[];
62 |
63 | _search = '';
64 | set search(value: string) {
65 | this._search = value;
66 | this.displayedArtists = this.filter(this.artists);
67 | }
68 | get search() {
69 | return this._search;
70 | }
71 |
72 | primaryFunc = (artist: Artist) => artist.name;
73 | secondaryFunc = (artist: Artist) => artist.songs + ' song' + (artist.songs > 1 ? 's' : '');
74 |
75 | constructor(private sanitizer: DomSanitizer) {}
76 |
77 | ngOnChanges(changes: SimpleChanges): void {
78 | if (changes.artists) {
79 | const artists = changes.artists.currentValue;
80 | this.displayedArtists = this.filter(artists);
81 | }
82 | }
83 |
84 | getAvatarStyle(artist: Artist) {
85 | return artist.avatarUrl ? this.sanitizer.bypassSecurityTrustStyle(`background-image: url("${artist.avatarUrl}")`) : '';
86 | }
87 |
88 | play(album: Artist | Album) {
89 | console.log(album);
90 | }
91 |
92 | filter(artists: Artist[]): Artist[] {
93 | const toStringAlbum = (artist: Artist) => `${artist.name}`;
94 | return artists.filter(artist => toStringAlbum(artist).toLowerCase().includes(this._search.toLowerCase().trim()));
95 | }
96 |
97 | }
98 |
--------------------------------------------------------------------------------
/web/src/app/settings/components/lyrics-options.component.ts:
--------------------------------------------------------------------------------
1 | import {ChangeDetectionStrategy, Component, EventEmitter, Input, Output} from '@angular/core';
2 | import {LyricsOptions} from '@app/model';
3 |
4 | @Component({
5 | selector: 'app-lyrics-options',
6 | template: `
7 |
8 |
9 | Find lyrics on the Web
10 |
11 |
12 |
13 |
15 | Search on lyrics.wikia.com
16 |
18 | open_in_new
19 |
20 |
21 |
22 |
23 |
25 | Use the lyrics.ovh service
26 |
28 | open_in_new
29 |
30 |
31 |
32 |
33 |
34 | Save found lyrics automatically
35 | info
36 |
37 |
38 | `,
39 | styles: [`
40 | mat-icon.small {
41 | margin-left: 0.25rem;
42 | font-size: 18px;
43 | height: 18px;
44 | width: 18px;
45 | position: relative;
46 | top: 4px
47 | }
48 | .sub {
49 | padding-left: 1.2rem;
50 | }
51 | `],
52 | changeDetection: ChangeDetectionStrategy.OnPush
53 | })
54 | export class LyricsOptionsComponent {
55 |
56 | @Input() lyricsOpts: LyricsOptions;
57 | @Output() linkClicked: EventEmitter = new EventEmitter();
58 | @Output() optionsChanged: EventEmitter = new EventEmitter();
59 |
60 | lyricsSaveTooltip = 'If you enable this option, every time lyrics are found they are saved on disk for future use.' +
61 | ' Otherwise they are saved on disk only if you edit them.';
62 |
63 | toggleService() {
64 | if (!this.lyricsOpts.services.wikia && !this.lyricsOpts.services.lyricsOvh) {
65 | this.lyricsOpts.useService = false;
66 | }
67 | this.save();
68 | }
69 |
70 | toggleUseService() {
71 | if (this.lyricsOpts.useService && !(this.lyricsOpts.services.wikia || this.lyricsOpts.services.lyricsOvh)) {
72 | this.lyricsOpts.services.wikia = true;
73 | this.lyricsOpts.services.lyricsOvh = true;
74 | }
75 | this.save();
76 | }
77 |
78 | save() {
79 | this.optionsChanged.emit(this.lyricsOpts);
80 | }
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/web/src/app/core/core.theme.scss:
--------------------------------------------------------------------------------
1 | @import '~@angular/material/theming';
2 |
3 | @mixin core-theme($theme) {
4 |
5 | $primary: map-get($theme, primary);
6 | $accent: map-get($theme, accent);
7 | $warn: map-get($theme, warn);
8 | $foreground: map-get($theme, foreground);
9 | $background: map-get($theme, background);
10 |
11 | *::-webkit-scrollbar {
12 | width: 6px;
13 | height: 6px;
14 | }
15 | *::-webkit-scrollbar-track {
16 | background-color: mat-color($background, app-bar);
17 | }
18 | *::-webkit-scrollbar-thumb {
19 | background-color: mat-color($foreground, disabled-button);
20 | }
21 | *::-webkit-scrollbar-button {
22 | display: none;
23 | }
24 |
25 | .app-loader {
26 | background-color: mat-color($background, background);
27 | color: mat-color($foreground, text);
28 | }
29 |
30 | .divider {
31 | border-bottom: 1px solid mat-color($foreground, divider);
32 | }
33 |
34 | .fake-scroll-y {
35 | border-right: 5.5px solid mat-color($background, app-bar);
36 | }
37 |
38 | .hover:hover {
39 | background-color: mat-color($background, hover);
40 | }
41 |
42 | .link {
43 | text-decoration: none;
44 | color: mat-color($foreground, text);
45 | }
46 |
47 | .accent {
48 | color: mat-color($accent);
49 | }
50 |
51 | .warn {
52 | color: mat-color($warn);
53 | }
54 |
55 | .secondary-text {
56 | color: mat-color($foreground, secondary-text);
57 | }
58 |
59 | .mat-list-item.accent .mat-line {
60 | color: mat-color($accent);
61 | }
62 |
63 | .mat-list-item.warn .mat-line {
64 | color: mat-color($warn);
65 | }
66 |
67 | .theme-chooser {
68 | background-color: mat-color($background, dialog);
69 | border: 1px solid mat-color($background, status-bar);
70 | button {
71 | border: 1px solid mat-color($foreground, divider);
72 | mat-icon {
73 | color: mat-color($warn);
74 | }
75 | }
76 | }
77 |
78 | .hover-background {
79 | background-color: mat-color($background, hover);
80 | }
81 |
82 | .outline-dashed {
83 | outline: 2px dashed mat-color($foreground, icon);
84 | }
85 |
86 | mat-toolbar {
87 | background-color: mat-color($background, status-bar) !important;
88 | box-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.3);
89 | }
90 |
91 | .side-menu {
92 | background-color: mat-color($background, app-bar);
93 | color: mat-color($foreground, text);
94 | box-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.3);
95 | mat-icon {
96 | padding: 5px;
97 | }
98 | }
99 |
100 | mat-nav-list, .side-menu {
101 | .active {
102 | color: mat-color($primary) !important;
103 | }
104 | }
105 |
106 | &.electron .electron-buttons {
107 | :hover {
108 | background-color: mat-color($background, hover);
109 | }
110 | .close:hover {
111 | background-color: mat-color($warn);
112 | }
113 | }
114 |
115 | &.main-wrapper {
116 | border: 1px solid mat-color($background, app-bar);
117 | }
118 |
119 | &.main-wrapper.electron.focused {
120 | border: 1px solid mat-color($primary);
121 | }
122 |
123 | .about {
124 | a {
125 | color: mat-color($foreground, text);
126 | }
127 | }
128 |
129 | }
130 |
--------------------------------------------------------------------------------
/src/main/scala/net/creasource/web/package.scala:
--------------------------------------------------------------------------------
1 | package net.creasource
2 |
3 | import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
4 | import akka.http.scaladsl.model._
5 | import akka.util.ByteString
6 | import spray.json._
7 |
8 | import scala.util.Try
9 |
10 | package object web {
11 |
12 | case class JsonMessage(method: String, id: Int, entity: JsValue)
13 |
14 | object JsonMessage extends JsonSupport {
15 | def unapply(arg: JsValue): Option[(String, Int, JsValue)] = {
16 | Try(arg.convertTo[JsonMessage]).toOption.map(m => (m.method, m.id, m.entity))
17 | }
18 | }
19 |
20 | trait JsonSupport extends SprayJsonSupport with DefaultJsonProtocol {
21 | implicit val jsonMessageFormat: RootJsonFormat[JsonMessage] = jsonFormat3(JsonMessage.apply)
22 | implicit val httpHeaderWriter: RootJsonWriter[HttpHeader] = (obj: HttpHeader) => {
23 | JsObject(
24 | "name" -> JsString(obj.name()),
25 | "value" -> JsString(obj.value())
26 | )
27 | }
28 | implicit val httpResponseFormat: RootJsonWriter[HttpResponse] = (obj: HttpResponse) => JsObject(
29 | "status" -> JsNumber(obj.status.intValue),
30 | "statusText" -> JsString(obj.status.reason),
31 | "entity" -> (obj.entity match {
32 | case HttpEntity.Strict(ct@ContentTypes.`application/json`, body) => JsonParser(body.decodeString(ct.charset.value))
33 | case HttpEntity.Strict(ct@ContentTypes.`text/plain(UTF-8)`, body) => JsString(body.decodeString(ct.charset.value))
34 | case _ => throw new UnsupportedOperationException("Only strict application/json and text/plain endpoints are supported.")
35 | })
36 | //"headers" -> JsArray(obj.headers.map(_.toJson).toVector)
37 | )
38 | implicit val httpRequestFormat: RootJsonReader[HttpRequest] = (json: JsValue) => {
39 | val (method, uri, headers, entity) = json match {
40 | case js: JsObject =>
41 | val method = js.fields.get("method") match {
42 | case Some(JsString("GET")) => HttpMethods.GET
43 | case Some(JsString("POST")) => HttpMethods.POST
44 | case Some(JsString("PUT")) => HttpMethods.PUT
45 | case Some(JsString("DELETE")) => HttpMethods.DELETE
46 | case Some(JsString("OPTIONS")) => HttpMethods.OPTIONS
47 | case Some(JsString("HEAD")) => HttpMethods.HEAD
48 | case Some(m) => throw new UnsupportedOperationException(s"Method $m is not supported.")
49 | case _ => throw new UnsupportedOperationException(s"No Method header found.")
50 | }
51 | val uri = js.fields.get("url") match {
52 | case Some(JsString(url)) => Uri(url)
53 | case _ => throw new UnsupportedOperationException(s"No string url parameter found.")
54 | }
55 | val entity = js.fields.get("entity") match {
56 | case None => HttpEntity.Empty
57 | case Some(value: JsValue) => HttpEntity.Strict(ContentTypes.`application/json`, ByteString(value.compactPrint))
58 | }
59 | (method, uri, Nil, entity)
60 | case _ => throw new UnsupportedOperationException("The body of an HttpRequest message must be a JsObject.")
61 | }
62 | HttpRequest(method = method, uri = uri, headers = headers, entity = entity)
63 | }
64 | }
65 |
66 | object JsonSupport extends JsonSupport
67 |
68 | }
69 |
--------------------------------------------------------------------------------
/web/src/app/library/library.utils.ts:
--------------------------------------------------------------------------------
1 | import {Album, Artist, Track} from '@app/model';
2 | import {CoreUtils} from '@app/core/core.utils';
3 |
4 | export class LibraryUtils {
5 |
6 | static fixTags(track: Track): Track {
7 | if (track.title === undefined || track.title === '') {
8 | const components = track.url.split('/');
9 | track.title = components[components.length - 1];
10 | // track.warn = true;
11 | }
12 | if (track.albumArtist === undefined || track.albumArtist === '') {
13 | track.albumArtist = track.artist || 'Unknown Album Artist';
14 | // track.warn = true;
15 | }
16 | if (track.artist === undefined || track.artist === '') {
17 | track.artist = 'Unknown Artist';
18 | // track.warn = true;
19 | }
20 | if (track.album === undefined || track.album === '') {
21 | track.album = 'Unknown Album';
22 | // track.warn = true;
23 | }
24 | if (track.coverUrl) {
25 | track.coverUrl = CoreUtils.resolveUrl(encodeURI(track.coverUrl));
26 | }
27 | return track;
28 | }
29 |
30 | static extractArtists(tracks: Track[]): Artist[] {
31 | const artists: Artist[] = [];
32 | tracks.forEach(track => {
33 | const artist = track.albumArtist;
34 | const artistIndex = artists.findIndex(a => a.name === artist);
35 | if (artistIndex === -1) {
36 | const newArtist: Artist = {name: artist, songs: 1};
37 | // if (track.warn) { newArtist.warn = true; }
38 | if (track.coverUrl) { newArtist.avatarUrl = track.coverUrl; }
39 | artists.push(newArtist);
40 | } else {
41 | // if (track.warn) { artists[artistIndex].warn = true; }
42 | if (track.coverUrl) { artists[artistIndex].avatarUrl = track.coverUrl; }
43 | artists[artistIndex].songs += 1;
44 | }
45 | });
46 | return artists;
47 | }
48 |
49 | static extractAlbums(tracks: Track[]): Album[] {
50 | const albums: Album[] = [];
51 | tracks.forEach(track => {
52 | const artist = track.albumArtist;
53 | const album = track.album;
54 | const albumIndex = albums.findIndex(a => a.title === album && a.artist === artist);
55 | if (albumIndex === -1) {
56 | const newAlbum: Album = {title: album, artist: artist, songs: 1};
57 | // if (track.warn) { newAlbum.warn = true; }
58 | if (track.coverUrl) { newAlbum.avatarUrl = track.coverUrl; }
59 | albums.push(newAlbum);
60 | } else {
61 | // if (track.warn) { albums[albumIndex].warn = true; }
62 | if (track.coverUrl) { albums[albumIndex].avatarUrl = track.coverUrl; }
63 | albums[albumIndex].songs += 1;
64 | }
65 | });
66 | return albums;
67 | }
68 |
69 | static shuffleArray(a: T[]): T[] {
70 | for (let i = a.length - 1; i > 0; i--) {
71 | const j = Math.floor(Math.random() * (i + 1));
72 | [a[i], a[j]] = [a[j], a[i]];
73 | }
74 | return a;
75 | }
76 |
77 | static uniq(a: T[]): T[] {
78 | return a.filter((v, i, s) => s.indexOf(v) === i);
79 | }
80 |
81 | static uniqBy(a: T[], p: (t: T) => any): T[] {
82 | const interMap = a.reduce(
83 | (map, item) => {
84 | const key = p(item);
85 | if (!map.has(key)) { map.set(key, item); }
86 | return map;
87 | },
88 | new Map()
89 | );
90 | return Array.from(interMap.values());
91 | }
92 |
93 | }
94 |
--------------------------------------------------------------------------------
/web/src/polyfills.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * This file includes polyfills needed by Angular and is loaded before the app.
3 | * You can add your own extra polyfills to this file.
4 | *
5 | * This file is divided into 2 sections:
6 | * 1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
7 | * 2. Application imports. Files imported after ZoneJS that should be loaded before your main
8 | * file.
9 | *
10 | * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
11 | * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
12 | * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
13 | *
14 | * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
15 | */
16 |
17 | /***************************************************************************************************
18 | * BROWSER POLYFILLS
19 | */
20 |
21 | /** IE9, IE10 and IE11 requires all of the following polyfills. **/
22 | // import 'core-js/es6/symbol';
23 | // import 'core-js/es6/object';
24 | // import 'core-js/es6/function';
25 | // import 'core-js/es6/parse-int';
26 | // import 'core-js/es6/parse-float';
27 | // import 'core-js/es6/number';
28 | // import 'core-js/es6/math';
29 | // import 'core-js/es6/string';
30 | // import 'core-js/es6/date';
31 | // import 'core-js/es6/array';
32 | // import 'core-js/es6/regexp';
33 | // import 'core-js/es6/map';
34 | // import 'core-js/es6/weak-map';
35 | // import 'core-js/es6/set';
36 |
37 | /** IE10 and IE11 requires the following for NgClass support on SVG elements */
38 | // import 'classlist.js'; // Run `npm install --save classlist.js`.
39 |
40 | /** IE10 and IE11 requires the following for the Reflect API. */
41 | // import 'core-js/es6/reflect';
42 |
43 |
44 | /** Evergreen browsers require these. **/
45 | // Used for reflect-metadata in JIT. If you use AOT (and only Angular decorators), you can remove.
46 | import 'core-js/es7/reflect';
47 |
48 |
49 | /**
50 | * Required to support Web Animations `@angular/platform-browser/animations`.
51 | * Needed for: All but Chrome, Firefox and Opera. http://caniuse.com/#feat=web-animation
52 | **/
53 | // import 'web-animations-js'; // Run `npm install --save web-animations-js`.
54 |
55 | /**
56 | * By default, zone.js will patch all possible macroTask and DomEvents
57 | * user can disable parts of macroTask/DomEvents patch by setting following flags
58 | */
59 |
60 | // (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
61 | // (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
62 | // (window as any).__zone_symbol__BLACK_LISTED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames
63 |
64 | /*
65 | * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js
66 | * with the following flag, it will bypass `zone.js` patch for IE/Edge
67 | */
68 | // (window as any).__Zone_enable_cross_context_check = true;
69 |
70 | /***************************************************************************************************
71 | * Zone JS is required by default for Angular itself.
72 | */
73 | import 'zone.js/dist/zone'; // Included with Angular CLI.
74 |
75 |
76 |
77 | /***************************************************************************************************
78 | * APPLICATION IMPORTS
79 | */
80 |
--------------------------------------------------------------------------------
/web/src/app/my-music/components/shared/box-list.component.ts:
--------------------------------------------------------------------------------
1 | import {ChangeDetectionStrategy, Component, EventEmitter, Input, Output} from '@angular/core';
2 | import {Album, Artist} from '@app/model';
3 | import {DomSanitizer} from '@angular/platform-browser';
4 |
5 | @Component({
6 | selector: 'app-box-list',
7 | template: `
8 |
21 | `,
22 | styles: [`
23 | .list {
24 | display: flex;
25 | flex-direction: row;
26 | flex-wrap: wrap;
27 | list-style: none;
28 | margin: 0;
29 | padding: 0 0.5rem 0.5rem 0.5rem;
30 | justify-content: space-evenly;
31 | }
32 | .item {
33 | width: 150px;
34 | margin: 0.5rem;
35 | display: flex;
36 | flex-direction: column;
37 | }
38 | .item:hover .cover {
39 | box-shadow: 0 5px 10px 2px rgba(0, 0, 0, 0.2);
40 | }
41 | .cover {
42 | box-sizing: border-box;
43 | width: 150px;
44 | height: 150px;
45 | background-size: cover;
46 | margin-bottom: 0.5rem;
47 | display: flex;
48 | align-items: center;
49 | justify-content: center;
50 | cursor: pointer;
51 | }
52 | .cover mat-icon {
53 | width: 60px;
54 | height: 60px;
55 | line-height: 60px;
56 | font-size: 60px;
57 | user-select: none;
58 | }
59 | .play-icon {
60 | color: white;
61 | text-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
62 | display: none;
63 | }
64 | .cover:hover .play-icon {
65 | display: unset;
66 | }
67 | .cover:hover .avatar-icon {
68 | display: none;
69 | }
70 | .primary {
71 | font-weight: 500;
72 | white-space: nowrap;
73 | max-width: 150px;
74 | overflow: hidden;
75 | text-overflow: ellipsis;
76 | }
77 | .secondary {
78 | font-weight: 300;
79 | font-size: 12px;
80 | }
81 | .center .primary, .center .secondary {
82 | text-align: center;
83 | }
84 | @media screen and (min-width: 599px){
85 | .item {
86 | margin: 1rem;
87 | }
88 | }
89 | `],
90 | changeDetection: ChangeDetectionStrategy.OnPush
91 | })
92 | export class BoxListComponent {
93 |
94 | @Input() center: boolean;
95 | @Input() list: (Artist[] | Album[]);
96 | @Input() primaryFunc: (item: Artist | Album) => string;
97 | @Input() secondaryFunc: (item: Artist | Album) => string;
98 |
99 | @Output() itemClicked = new EventEmitter();
100 |
101 | constructor(private sanitizer: DomSanitizer) {}
102 |
103 | getAvatarStyle(item: Artist | Album) {
104 | return item.avatarUrl ? this.sanitizer.bypassSecurityTrustStyle(`background-image: url("${item.avatarUrl}")`) : '';
105 | }
106 |
107 | }
108 |
--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 | "rulesDirectory": [
3 | "node_modules/codelyzer"
4 | ],
5 | "rules": {
6 | "arrow-return-shorthand": true,
7 | "callable-types": true,
8 | "class-name": true,
9 | "comment-format": [
10 | true,
11 | "check-space"
12 | ],
13 | "curly": true,
14 | "deprecation": {
15 | "severity": "warn"
16 | },
17 | "eofline": true,
18 | "forin": true,
19 | "import-blacklist": [
20 | true,
21 | "rxjs/Rx"
22 | ],
23 | "import-spacing": true,
24 | "indent": [
25 | true,
26 | "spaces"
27 | ],
28 | "interface-over-type-literal": true,
29 | "label-position": true,
30 | "max-line-length": [
31 | true,
32 | 140
33 | ],
34 | "member-access": false,
35 | "member-ordering": [
36 | true,
37 | {
38 | "order": [
39 | "static-field",
40 | "instance-field",
41 | "static-method",
42 | "instance-method"
43 | ]
44 | }
45 | ],
46 | "no-arg": true,
47 | "no-bitwise": true,
48 | "no-console": [
49 | true,
50 | "debug",
51 | "info",
52 | "time",
53 | "timeEnd",
54 | "trace"
55 | ],
56 | "no-construct": true,
57 | "no-debugger": true,
58 | "no-duplicate-super": true,
59 | "no-empty": false,
60 | "no-empty-interface": true,
61 | "no-eval": true,
62 | "no-inferrable-types": [
63 | true,
64 | "ignore-params"
65 | ],
66 | "no-misused-new": true,
67 | "no-non-null-assertion": true,
68 | "no-shadowed-variable": true,
69 | "no-string-literal": false,
70 | "no-string-throw": true,
71 | "no-switch-case-fall-through": true,
72 | "no-trailing-whitespace": true,
73 | "no-unnecessary-initializer": true,
74 | "no-unused-expression": true,
75 | "no-use-before-declare": true,
76 | "no-var-keyword": true,
77 | "object-literal-sort-keys": false,
78 | "one-line": [
79 | true,
80 | "check-open-brace",
81 | "check-catch",
82 | "check-else",
83 | "check-whitespace"
84 | ],
85 | "prefer-const": true,
86 | "quotemark": [
87 | true,
88 | "single"
89 | ],
90 | "radix": true,
91 | "semicolon": [
92 | true,
93 | "always"
94 | ],
95 | "triple-equals": [
96 | true,
97 | "allow-null-check"
98 | ],
99 | "typedef-whitespace": [
100 | true,
101 | {
102 | "call-signature": "nospace",
103 | "index-signature": "nospace",
104 | "parameter": "nospace",
105 | "property-declaration": "nospace",
106 | "variable-declaration": "nospace"
107 | }
108 | ],
109 | "unified-signatures": true,
110 | "variable-name": false,
111 | "whitespace": [
112 | true,
113 | "check-branch",
114 | "check-decl",
115 | "check-operator",
116 | "check-separator",
117 | "check-type"
118 | ],
119 | "no-output-on-prefix": true,
120 | "use-input-property-decorator": true,
121 | "use-output-property-decorator": true,
122 | "use-host-property-decorator": true,
123 | "no-input-rename": true,
124 | "no-output-rename": true,
125 | "use-life-cycle-interface": true,
126 | "use-pipe-transform-interface": true,
127 | "component-class-suffix": true,
128 | "directive-class-suffix": true
129 | }
130 | }
131 |
--------------------------------------------------------------------------------
/web/src/app/core/components/sidenav.component.ts:
--------------------------------------------------------------------------------
1 | import {ChangeDetectionStrategy, Component, EventEmitter, Output} from '@angular/core';
2 |
3 | @Component({
4 | selector: 'app-side-nav',
5 | template: `
6 |
7 | Navigation
8 |
9 |
13 | play_circle_outline
14 | Playing now
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
27 | album
28 | Playlists
29 |
30 |
31 |
35 | queue_music
36 | Library
37 |
38 |
42 | schedule
43 | Recently Played
44 |
45 |
49 | favorite_border
50 | Favorites
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
64 | settings
65 | Settings
66 |
67 |
71 | info
72 | About
73 |
74 |
75 | `,
76 | styles: [`
77 | a {
78 | text-decoration: none;
79 | }
80 | mat-icon {
81 | padding: 0 !important;
82 | }
83 | .mat-list-item {
84 | height: 48px !important;
85 | }
86 | .playing-icon {
87 | height: 18px;
88 | width: 18px;
89 | line-height: 18px;
90 | font-size: 18px;
91 | vertical-align: text-top;
92 | }
93 | @media screen and (min-width: 599px){
94 | mat-icon:not(.playing-icon) {
95 | display: none;
96 | }
97 | .mat-line {
98 | margin-left: -1rem !important;
99 | }
100 | }
101 | `],
102 | changeDetection: ChangeDetectionStrategy.OnPush
103 | })
104 | export class SidenavComponent {
105 |
106 | @Output() closeSidenav = new EventEmitter();
107 |
108 | }
109 |
--------------------------------------------------------------------------------
/web/src/app/library/reducers/artists.reducers.ts:
--------------------------------------------------------------------------------
1 | import {createEntityAdapter, EntityAdapter, EntityState} from '@ngrx/entity';
2 | import {Artist} from '@app/model';
3 | import {ArtistsActionsUnion, ArtistsActionTypes} from '@app/library/actions/artists.actions';
4 | import {TracksActionsUnion, TracksActionTypes} from '@app/library/actions/tracks.actions';
5 | import {LibraryUtils} from '@app/library/library.utils';
6 |
7 | /**
8 | * State
9 | */
10 | export interface State extends EntityState {
11 | selectedIds: (string | number)[];
12 | }
13 |
14 | export const adapter: EntityAdapter = createEntityAdapter({
15 | selectId: (artist: Artist) => artist.name,
16 | sortComparer: (a, b) => a.name.localeCompare(b.name),
17 | });
18 |
19 | export const initialState: State = adapter.getInitialState({
20 | selectedIds: []
21 | });
22 |
23 | /**
24 | * Reducer
25 | */
26 | export function reducer(
27 | state = initialState,
28 | action: ArtistsActionsUnion | TracksActionsUnion
29 | ): State {
30 | switch (action.type) {
31 |
32 | case ArtistsActionTypes.LoadArtists:
33 | return adapter.upsertMany(action.payload, state);
34 |
35 | case ArtistsActionTypes.DeselectAllArtists: {
36 | return {
37 | ...state,
38 | selectedIds: []
39 | };
40 | }
41 |
42 | case ArtistsActionTypes.DeselectArtist: {
43 | return {
44 | ...state,
45 | selectedIds: state.selectedIds.filter(id => id !== action.payload.name)
46 | };
47 | }
48 |
49 | case ArtistsActionTypes.SelectArtist: {
50 | if (state.selectedIds.indexOf(action.payload.name) === -1) {
51 | return {
52 | ...state,
53 | selectedIds: [...state.selectedIds, action.payload.name]
54 | };
55 | } else {
56 | return state;
57 | }
58 | }
59 |
60 | case ArtistsActionTypes.SelectArtists: {
61 | return {
62 | ...state,
63 | selectedIds: action.payload.map(a => a.name)
64 | };
65 | }
66 |
67 | case ArtistsActionTypes.SelectArtistsByIds: {
68 | return {
69 | ...state,
70 | selectedIds: action.payload
71 | };
72 | }
73 |
74 | case TracksActionTypes.ScanTracks:
75 | return adapter.removeAll({
76 | ...state,
77 | selectedIds: []
78 | });
79 |
80 | case TracksActionTypes.LoadTracksSuccess: {
81 | const artists = LibraryUtils.extractArtists(action.payload);
82 | return adapter.upsertMany(artists, state);
83 | }
84 |
85 | case TracksActionTypes.AddTracks: {
86 | const artists = LibraryUtils.extractArtists(action.payload);
87 | artists.map(artist => {
88 | const old = state.entities[artist.name];
89 | if (old) {
90 | artist.songs += old.songs;
91 | }
92 | return artist;
93 | });
94 | return adapter.upsertMany(artists, state);
95 | }
96 |
97 | case TracksActionTypes.RemoveTracks: {
98 | const artists = LibraryUtils.extractArtists(action.payload);
99 | const fn: (s: State, artist: Artist) => State = (s, artist) => {
100 | const old = s.entities[artist.name];
101 | if (old) {
102 | old.songs -= artist.songs;
103 | if (old.songs === 0) {
104 | return adapter.removeOne(old.name, s);
105 | } else {
106 | return adapter.upsertOne(old, s);
107 | }
108 | }
109 | };
110 | return artists.reduce(fn, state);
111 | }
112 |
113 | default: {
114 | return state;
115 | }
116 | }
117 | }
118 |
119 | /**
120 | * Selectors
121 | */
122 | export const getSelectedIds = (state: State) => state.selectedIds;
123 |
--------------------------------------------------------------------------------
/web/src/app/library/components/shared/controls.component.ts:
--------------------------------------------------------------------------------
1 | import {ChangeDetectionStrategy, Component, EventEmitter, Input, Output} from '@angular/core';
2 | import {MatMenu} from '@angular/material';
3 |
4 | @Component({
5 | selector: 'app-controls',
6 | template: `
7 |
38 | `,
39 | styles: [`
40 | .controls {
41 | overflow-y: hidden;
42 | position: absolute;
43 | top: 0;
44 | left: 0;
45 | right: 0;
46 | height: 60px;
47 | padding: 0 0.5rem 0 1rem;
48 | display: flex;
49 | flex-direction: row;
50 | align-items: center;
51 | box-sizing: border-box;
52 | }
53 | .controls-inner {
54 | flex-grow: 1;
55 | align-self: flex-end;
56 | display: flex;
57 | flex-direction: column;
58 | transition-property: transform;
59 | transition-timing-function: ease;
60 | transition-duration: 0.4s;
61 | overflow: hidden;
62 | }
63 | .controls-meta {
64 | height: 59px;
65 | display: flex;
66 | flex-direction: row;
67 | align-items: center;
68 | transition-property: transform;
69 | transition-timing-function: ease;
70 | transition-duration: 0.4s;
71 | }
72 | .controls-meta.showSearch {
73 | transform: translateY(59px);
74 | }
75 | .search {
76 | height: 59px;
77 | transition-property: transform;
78 | transition-timing-function: ease;
79 | transition-duration: 0.4s;
80 | }
81 | .search.showSearch {
82 | transform: translateY(59px);
83 | }
84 | .search-icon {
85 | vertical-align: bottom;
86 | }
87 | .back {
88 | margin-right: 1rem;
89 | position: relative;
90 | z-index: 1;
91 | }
92 | .searchButton {
93 | margin-left: 0.5rem;
94 | }
95 | `],
96 | changeDetection: ChangeDetectionStrategy.OnPush
97 | })
98 | export class ControlsComponent {
99 |
100 | @Input() backButton: boolean;
101 | @Input() search: string;
102 | @Input() searchPlaceholder: string;
103 | @Input() matMenu: MatMenu;
104 |
105 | @Output() searchChange = new EventEmitter();
106 | @Output() backClicked = new EventEmitter();
107 |
108 | showSearch = false;
109 |
110 | }
111 |
--------------------------------------------------------------------------------
/web/src/app/core/services/loader.service.ts:
--------------------------------------------------------------------------------
1 | import {Injectable} from '@angular/core';
2 | import {concat, EMPTY, Observable, Subject, throwError} from 'rxjs';
3 | import {catchError, delay, mergeMap, publishReplay, refCount, retryWhen, share, switchMap, take} from 'rxjs/operators';
4 | import {HttpSocketClientService, SocketMessage} from '@app/core/services/http-socket-client.service';
5 | import {MatSnackBar} from '@angular/material';
6 |
7 | @Injectable()
8 | export class LoaderService {
9 |
10 | private readonly loadings$: Observable;
11 | private loading = new Subject();
12 |
13 | hasErrors$: Observable;
14 | private hasErrors = new Subject();
15 |
16 | log$: Observable;
17 | private log = new Subject();
18 |
19 | initializing$: Observable;
20 | private initializing = new Subject();
21 |
22 | private socketObs$: Observable;
23 |
24 | constructor(
25 | private httpSocketClient: HttpSocketClientService,
26 | private snack: MatSnackBar
27 | ) {
28 | this.loadings$ = this.loading.asObservable().pipe(publishReplay(1), refCount());
29 | this.initializing$ = this.initializing.asObservable().pipe(publishReplay(1), refCount());
30 | // this.initializing$ = this.httpSocketClient.socketOpened$.pipe(map(opened => !opened), publishReplay(1), refCount())
31 | this.log$ = this.log.asObservable().pipe(publishReplay(1), refCount());
32 | this.hasErrors$ = this.hasErrors.asObservable().pipe(publishReplay(1), refCount());
33 | this.loadings$.subscribe();
34 | this.initializing$.subscribe();
35 | this.log$.subscribe();
36 | this.hasErrors$.subscribe();
37 | }
38 |
39 | /* errors => errors.pipe(
40 | switchMap(() => {
41 | if (window.navigator.onLine) {
42 | console.warn(`WebSocket failed. Retrying in 500ms.`);
43 | return timer(500);
44 | } else {
45 | return fromEvent(window, 'online').pipe(take(1));
46 | }
47 | }),
48 | ))*/
49 |
50 | getSharedSocket(): Observable {
51 | if (!this.socketObs$) {
52 | return this.socketObs$ =
53 | this.initializing$.pipe(
54 | switchMap(initializing => {
55 | if (initializing) {
56 | return EMPTY;
57 | } else {
58 | return this.httpSocketClient.getSocket().pipe(
59 | retryWhen(errors =>
60 | concat(errors.pipe(delay(500), take(6)), throwError('Connection to server lost!'))
61 | ),
62 | catchError((error, caught) =>
63 | this.snack.open(error, 'Retry')
64 | .afterDismissed()
65 | .pipe(mergeMap(() => caught))
66 | )
67 | );
68 | }
69 | }),
70 | share()
71 | );
72 | } else {
73 | return this.socketObs$;
74 | }
75 | }
76 |
77 | getLoading(): Observable {
78 | return this.loadings$;
79 | }
80 |
81 | load(value: number) {
82 | this.loading.next(value);
83 | }
84 |
85 | unload() {
86 | this.loading.next(0);
87 | }
88 |
89 | initialize() {
90 | this.initializing.next(true);
91 | this.hasErrors.next(false);
92 | this.log.next('Loading...');
93 | this.httpSocketClient.getSocket().pipe(
94 | retryWhen(
95 | errors => concat(errors.pipe(delay(500), take(20)), throwError('Connection to server failed!'))
96 | ),
97 | take(1)
98 | ).subscribe(
99 | () => {},
100 | error => {
101 | this.hasErrors.next(true);
102 | this.log.next(error);
103 | },
104 | () => this.initializing.next(false)
105 | );
106 | }
107 |
108 | }
109 |
--------------------------------------------------------------------------------
/web/src/app/library/reducers/albums.reducers.ts:
--------------------------------------------------------------------------------
1 | import {createEntityAdapter, EntityAdapter, EntityState} from '@ngrx/entity';
2 | import {Album} from '@app/model';
3 | import {AlbumsActionsUnion, AlbumsActionTypes} from '@app/library/actions/albums.actions';
4 | import {TracksActionsUnion, TracksActionTypes} from '@app/library/actions/tracks.actions';
5 | import {LibraryUtils} from '@app/library/library.utils';
6 |
7 | export const getAlbumId = (album: Album) => album.artist + '-' + album.title;
8 |
9 | /**
10 | * State
11 | */
12 | export interface State extends EntityState {
13 | selectedIds: (string | number)[];
14 | }
15 |
16 | export const adapter: EntityAdapter = createEntityAdapter({
17 | selectId: getAlbumId,
18 | sortComparer: (a, b) => a.title.localeCompare(b.title),
19 | });
20 |
21 | export const initialState: State = adapter.getInitialState({
22 | selectedIds: []
23 | });
24 |
25 | /**
26 | * Reducer
27 | */
28 | export function reducer(
29 | state = initialState,
30 | action: AlbumsActionsUnion | TracksActionsUnion
31 | ): State {
32 | switch (action.type) {
33 |
34 | case AlbumsActionTypes.LoadAlbums:
35 | return adapter.upsertMany(action.payload, state);
36 |
37 | case AlbumsActionTypes.DeselectAllAlbums: {
38 | return {
39 | ...state,
40 | selectedIds: []
41 | };
42 | }
43 |
44 | case AlbumsActionTypes.DeselectAlbum: {
45 | return {
46 | ...state,
47 | selectedIds: state.selectedIds.filter(id => id !== getAlbumId(action.payload))
48 | };
49 | }
50 |
51 | case AlbumsActionTypes.SelectAlbum: {
52 | if (state.selectedIds.indexOf(getAlbumId(action.payload)) === -1) {
53 | return {
54 | ...state,
55 | selectedIds: [...state.selectedIds, getAlbumId(action.payload)]
56 | };
57 | } else {
58 | return state;
59 | }
60 | }
61 |
62 | case AlbumsActionTypes.SelectAlbums: {
63 | return {
64 | ...state,
65 | selectedIds: action.payload.map(getAlbumId)
66 | };
67 | }
68 |
69 | case AlbumsActionTypes.SelectAlbumsByIds: {
70 | return {
71 | ...state,
72 | selectedIds: action.payload
73 | };
74 | }
75 |
76 | case TracksActionTypes.ScanTracks:
77 | return adapter.removeAll({
78 | ...state,
79 | selectedIds: []
80 | });
81 |
82 | case TracksActionTypes.LoadTracksSuccess: {
83 | const albums = LibraryUtils.extractAlbums(action.payload);
84 | return adapter.upsertMany(albums, state);
85 | }
86 |
87 | case TracksActionTypes.AddTracks: {
88 | const albums = LibraryUtils.extractAlbums(action.payload);
89 | albums.map(album => {
90 | const old = state.entities[getAlbumId(album)];
91 | if (old) {
92 | album.songs += old.songs;
93 | }
94 | return album;
95 | });
96 | return adapter.upsertMany(albums, state);
97 | }
98 |
99 | case TracksActionTypes.RemoveTracks: {
100 | const albums = LibraryUtils.extractAlbums(action.payload);
101 | const fn: (s: State, album: Album) => State = (s, album) => {
102 | const old = s.entities[getAlbumId(album)];
103 | if (old) {
104 | old.songs -= album.songs;
105 | if (old.songs === 0) {
106 | return adapter.removeOne(getAlbumId(old), s);
107 | } else {
108 | return adapter.upsertOne(old, s);
109 | }
110 | }
111 | };
112 | return albums.reduce(fn, state);
113 | }
114 |
115 | default: {
116 | return state;
117 | }
118 | }
119 | }
120 |
121 | /**
122 | * Selectors
123 | */
124 | export const getSelectedIds = (state: State) => state.selectedIds;
125 |
--------------------------------------------------------------------------------
/src/main/scala/net/creasource/io/WatchService.scala:
--------------------------------------------------------------------------------
1 | package net.creasource.io
2 |
3 | /**
4 | * This file is copy/pasted from https://github.com/nurkiewicz/learning-akka
5 | * It is released under the Apache 2 License (https://github.com/nurkiewicz/learning-akka/blob/master/license.txt)
6 | * Substantial modifications have been made, including changing the package name, and fixing the code for fast copy.
7 | */
8 |
9 | import java.io.UncheckedIOException
10 | import java.nio.file.StandardWatchEventKinds._
11 | import java.nio.file._
12 |
13 | import akka.Done
14 | import akka.actor.ActorRef
15 | import akka.event.LoggingAdapter
16 | import akka.stream.Materializer
17 | import akka.stream.scaladsl.{Sink, StreamConverters}
18 |
19 | import scala.collection.JavaConverters._
20 | import scala.concurrent.Future
21 |
22 | class WatchService(notifyActor: ActorRef, logger: LoggingAdapter)(implicit materializer: Materializer) extends Runnable {
23 |
24 | private val watchService = FileSystems.getDefault.newWatchService()
25 |
26 | private def register(path: Path): WatchKey = path.register(watchService, ENTRY_CREATE, ENTRY_DELETE)
27 |
28 | def watch(root: Path): Future[Done] = {
29 | logger.debug("Watching folder: " + root)
30 | register(root)
31 | StreamConverters
32 | .fromJavaStream(() => Files.walk(root))
33 | .recover {
34 | case _: UncheckedIOException => root
35 | }
36 | .runWith(Sink.foreach(path =>
37 | if (path.toFile.isDirectory && path != root) {
38 | logger.debug("Registering folder: " + path)
39 | register(path)
40 | }
41 | )
42 | )
43 | }
44 |
45 | def run() {
46 | try {
47 | logger.debug("Waiting for file system events...")
48 | while (!Thread.currentThread().isInterrupted) {
49 | val key = watchService.take()
50 | key.pollEvents().asScala foreach {
51 | event =>
52 | val relativePath = event.context().asInstanceOf[Path]
53 | val path = key.watchable().asInstanceOf[Path].resolve(relativePath)
54 | event.kind() match {
55 | case ENTRY_CREATE =>
56 | if (path.toFile.isDirectory) {
57 | StreamConverters
58 | .fromJavaStream(() => Files.walk(path))
59 | .runWith(Sink.foreach(path =>
60 | if (path.toFile.isDirectory) {
61 | logger.debug("Registering folder: " + path)
62 | register(path)
63 | } else {
64 | // Ugly hack to wait for the file to be unlocked
65 | while (path.toFile.exists() && !path.toFile.renameTo(path.toFile)) {
66 | Thread.sleep(100)
67 | }
68 | notifyActor ! FileSystemChange.Created(path)
69 | logger.debug("Entry created: " + path)
70 | }
71 | ))
72 | } else {
73 | // Ugly hack to wait for the file to be unlocked
74 | while (path.toFile.exists() && !path.toFile.renameTo(path.toFile)) {
75 | Thread.sleep(100)
76 | }
77 | notifyActor ! FileSystemChange.Created(path)
78 | logger.debug("Entry created: " + path)
79 | }
80 |
81 | case ENTRY_DELETE =>
82 | notifyActor ! FileSystemChange.Deleted(path)
83 | logger.debug("Entry deleted: " + path)
84 |
85 | case e =>
86 | logger.warning("Unknown event received: " + e.toString)
87 | }
88 | }
89 | key.reset()
90 | }
91 | } catch {
92 | case _: InterruptedException => logger.debug("Interrupted.")
93 | } finally {
94 | watchService.close()
95 | }
96 | }
97 | }
98 |
--------------------------------------------------------------------------------