@social-mail/social-mail-client 1.0.1 → 1.0.4

package/src/common/controls/buttons/IconButton.tsx

@@ -0,0 +1,60 @@
+import XNode from "@web-atoms/core/dist/core/XNode";
+import styled from "@web-atoms/core/dist/style/styled";
+import IElement from "@web-atoms/web-controls/dist/basic/IElement";
+
+    styled.css `
+    `.installGlobal("[data-layout=icon-button]");
+
+export interface IButtonOptions extends IElement {
+    text?: string;
+    icon?: string;
+}
+
+const createButton = ({
+    text: defaultText = void 0,
+    icon: defaultIcon = void 0,
+    layout: defaultLayout = ""
+}: IButtonOptions) =>
+    ({
+        text = defaultText,
+        icon = defaultIcon,
+        layout = defaultLayout || (icon ? "icon-button" : "button"),
+        ... a
+    }: IButtonOptions) => {
+    a["data-layout"] = layout;
+    if (text && icon) {
+        return <button { ... a}>
+            <i class={icon}/>
+            <span text={text}/>
+        </button>;
+    }
+    if (icon) {
+        return <button { ... a} class={icon}/>;
+    }
+    return <button { ... a} text={text}/>;
+};
+
+export const IconButton = createButton({});
+
+export const AddIconButton = createButton({ icon: "fas fa-plus", layout: "go-button" });
+export const AddIconTextButton = createButton({ text : "Add", icon: "fas fa-plus", layout: "go-icon-button" });
+
+export const ArchiveIconButton = createButton({ icon: "fas fa-trash-can", layout: "warning-button" });
+export const ArchiveIconTextButton = createButton({ text : "Archive", icon: "fas fa-trash-can", layout: "warning-icon-button" });
+
+
+export const DeleteIconButton = createButton({ icon: "fas fa-trash-can", layout: "reject-button" });
+export const DeleteIconTextButton = createButton({ text : "Delete", icon: "fas fa-trash-can", layout: "reject-icon-button" });
+
+export const EmailIconButton = createButton({ icon: "fas fa-envelope", layout: "go-button" });
+export const EmailIconTextButton = createButton({ text : "Email", icon: "fas fa-envelope", layout: "go-icon-button" });
+
+
+export const SaveIconButton = createButton({ icon: "fas fa-floppy-disk", layout: "accept-button" });
+export const SaveIconTextButton = createButton({ text : "Save", icon: "fas fa-floppy-disk", layout: "accept-icon-button" });
+
+export const EditIconButton = createButton({ icon: "fas fa-edit", layout: "button"});
+export const EditIconTextButton = createButton({ text : "Edit", icon: "fas fa-edit", layout: "icon-button"});
+
+export const UploadIconButton = createButton({ icon: "fas fa-upload", layout: "go-button" });
+export const UploadIconTextButton = createButton({ text : "Upload", icon: "fas fa-upload", layout: "go-icon-button" });

package/src/common/controls/form/RequiredFormField.tsx

@@ -0,0 +1,53 @@
+import Bind from "@web-atoms/core/dist/core/Bind";
+import XNode from "@web-atoms/core/dist/core/XNode";
+import { BindError } from "@web-atoms/web-controls/dist/basic/Form";
+import FormField from "@web-atoms/web-controls/dist/basic/FormField";
+import IElement from "@web-atoms/web-controls/dist/basic/IElement";
+import PasswordBox from "@web-atoms/web-controls/dist/basic/PasswordBox";
+
+export interface IRequiredFormField<T = any> extends IElement {
+    label: string;
+    placeholder?: string;
+    value: () => T;
+    message?: (v: string, label: string) => string;
+    isValid?: (v: string) => boolean;
+    required?: boolean;
+    valuePropertyName?: string;
+}
+
+export default function RequiredFormField<T = any> ({
+    label,
+    value,
+    required = true,
+    message,
+    isValid,
+    placeholder,
+    valuePropertyName = "value",
+    ... extra
+}: IRequiredFormField<T>, node: XNode) {
+    const a = (node.attributes ??= {});
+    a[valuePropertyName] = Bind.twoWaysImmediate(value);
+    if (placeholder) {
+        a.placeholder = placeholder;
+    }
+    for (const key in extra) {
+        if (Object.prototype.hasOwnProperty.call(extra, key)) {
+            const element = extra[key];
+            a[key] ??= element;
+        }
+    }
+    return <FormField
+        required={required}
+        label={label}
+        error={BindError({ value, message, isValid})}>
+            { node }
+    </FormField>;
+}
+
+export function TextFormField( a: IRequiredFormField) {
+    return <RequiredFormField { ... a}><input type="text"/></RequiredFormField>;
+}
+
+export function PasswordFormField(a: IRequiredFormField) {
+    return <RequiredFormField { ... a}><PasswordBox value={Bind.twoWaysImmediate(a.value)}/></RequiredFormField>;
+}

package/src/common/controls/repeater/InfiniteRepeater.tsx

@@ -0,0 +1,93 @@
+import Bind from "@web-atoms/core/dist/core/Bind";
+import { CancelToken } from "@web-atoms/core/dist/core/types";
+import XNode from "@web-atoms/core/dist/core/XNode";
+import { AtomControl } from "@web-atoms/core/dist/web/controls/AtomControl";
+import AtomRepeater from "@web-atoms/web-controls/dist/basic/AtomRepeater";
+
+const loadMoreSet = Symbol("loadMoreSet");
+
+export interface IAnyPagedItems {
+    items: any[];
+    total: number;
+}
+
+export interface IInfiniteRepeater extends AtomRepeater {
+    pagedItems: IAnyPagedItems;
+    [loadMoreSet]: CancelToken;
+    start: number;
+}
+
+const pagedItemsSetter = AtomControl.registerProperty("paged-items", "paged-items",
+(control: IInfiniteRepeater, element, value) => {
+    if (value && value.items) {
+        let cancelToken = control[loadMoreSet];
+        control.footerRenderer ??= () => <div data-click-event="load-more-items"><span text="Load more ... "/></div>;
+        control.headerRenderer ??= () => <div class="scroll-header" style-height="1px" style-width="100%"/>;
+        if (!cancelToken) {
+            control[loadMoreSet] = cancelToken = new CancelToken();
+            control.bindEvent(control.element, "loadMoreItems", (e: any) => {
+                const ce = new CustomEvent("moreItems", {
+                    detail: {
+                        pagedItems: control.pagedItems,
+                        cancelToken
+                    },
+                    bubbles: false
+                });
+                control.element.dispatchEvent(ce);
+            });
+        } else {
+            cancelToken.cancel();
+            control[loadMoreSet] = cancelToken = new CancelToken();
+        }
+        const items = control.items;
+        if (items && Array.isArray(items)) {
+            items.clear();
+            items.addAll(value.items);
+        } else {
+            control.items = value.items;
+        }
+
+        setTimeout(() => {
+            const ce = control.element?.firstElementChild as HTMLElement;
+            ce?.scrollIntoView();
+        }, 100);
+
+        control.footer = value.total && value.items && value.items.length < value.total;
+        (control as any).pagedItems = value;
+    }
+});
+
+export type RepeaterLoader = (start: number) => (control: AtomControl, element: HTMLElement, cancelToken: CancelToken) => any;
+
+const scrollToBottom = ({ target, detail: { type, index}}) => {
+    if (!(type === "add" && index === 0) && type !== "reset") {
+        return;
+    }
+    setTimeout(() => {
+        const e = target.firstElementChild as HTMLElement;
+        console.log(e);
+        e?.scrollIntoView(true);
+    }, 1);
+};
+
+export default class InfiniteRepeater {
+
+    public static pagedItems = (start: RepeaterLoader) => {
+        const setter = start(0);
+        const setters = pagedItemsSetter(Bind.oneWayAsync(setter)) as any;
+        setters["event-more-items"] = Bind.event(async (s: any, e) => {
+            const st = s.items?.length ?? 0;
+            if (!st) {
+                return;
+            }
+            const cancelToken = s[loadMoreSet];
+            const loader = start(st);
+            const results = await loader(s, e.target as any, cancelToken);
+            s.items.addAll(results.items);
+            s.footer = results.items.length > 0;
+        });
+        // setters["event-items-updated"] = scrollToBottom;
+        return setters;
+    };
+
+}

package/src/common/pages/mailboxes/MailboxEditorPage.tsx

@@ -0,0 +1,66 @@
+import { PopupWindowPage } from "@web-atoms/web-controls/dist/mobile-app/MobileApp";
+import { EmailAddress, IDomain, IMailbox, Mailbox } from "../../../model/model";
+import XNode from "@web-atoms/core/dist/core/XNode";
+import Form from "@web-atoms/web-controls/dist/basic/Form";
+import { TextFormField } from "../../controls/form/RequiredFormField";
+import FormField from "@web-atoms/web-controls/dist/basic/FormField";
+import ComboBox from "@web-atoms/web-controls/dist/basic/ComboBox";
+import MailboxService from "./services/MailboxService";
+import InjectProperty from "@web-atoms/core/dist/core/InjectProperty";
+import Bind from "@web-atoms/core/dist/core/Bind";
+
+export interface IMailboxEx extends IMailbox {
+    prefix?: string;
+}
+
+export default class MailboxEditorPage extends PopupWindowPage {
+
+    public parameters: { model: IMailboxEx };
+
+    private model: IMailboxEx;
+
+    private domain: IDomain = null;
+
+    @InjectProperty
+    private mailboxService: MailboxService;
+
+    async init() {
+
+        this.title = "Add Mailbox";
+
+        this.model = this.parameters?.model ?? Mailbox.create({
+            emailAddress: EmailAddress.create({
+                emailAddress: ""
+            })
+        });
+
+        this.model.prefix = "";
+
+        const domains = await this.mailboxService.domains();
+        this.domain = domains[0];
+
+        this.renderer = <div>
+            <Form data-submit-event="save-mailbox">
+                <TextFormField label="Email Prefix" value={() => this.model.prefix}/>
+                <FormField label="Domain">
+                    <ComboBox
+                        labelPath={(item: IDomain) => item?.name}
+                        valuePath={(item: IDomain) => item?.domainID}
+                        selectedItem={Bind.twoWaysImmediate(() => this.domain)}
+                        items={domains}
+                        />
+                </FormField>
+                <FormField label="Email Address">
+                    <span text={Bind.oneWay(() => `${this.model.prefix}@${this.domain.name}`)}/>
+                </FormField>
+                <div data-layout="command-row">
+                    <button
+                        data-layout="accept-button"
+                        text="Add"
+                        />
+                </div>
+            </Form>
+        </div>;
+
+    }
+}

package/src/common/pages/mailboxes/MailboxListPage.tsx

@@ -0,0 +1,48 @@
+import Bind from "@web-atoms/core/dist/core/Bind";
+import XNode from "@web-atoms/core/dist/core/XNode";
+import AtomRepeater from "@web-atoms/web-controls/dist/basic/AtomRepeater";
+import { ContentPage } from "@web-atoms/web-controls/dist/mobile-app/MobileApp";
+import InfiniteRepeater from "../../controls/repeater/InfiniteRepeater";
+import MailboxService from "./services/MailboxService";
+import InjectProperty from "@web-atoms/core/dist/core/InjectProperty";
+import { IMailbox } from "../../../model/model";
+import Action from "@web-atoms/core/dist/view-model/Action";
+import PageNavigator from "@web-atoms/web-controls/dist/PageNavigator";
+import MailboxEditorPage from "./MailboxEditorPage";
+
+export default class MailboxListPage extends ContentPage {
+
+    private search: string = "";
+
+    @InjectProperty
+    private mailboxService: MailboxService;
+
+    private mailboxes: IMailbox[] = [];
+
+    private version = 0;
+
+    async init() {
+        this.titleRenderer = () => <div data-layout="row">
+            <input value={Bind.twoWaysImmediate(() => this.search)}/>
+            <i class="fas fa-plus" data-click-event="add-mailbox"/>
+        </div>;
+
+        this.renderer = <div>
+            <AtomRepeater
+                items={this.mailboxes}
+                { ... InfiniteRepeater.pagedItems((start) =>
+                        (c, e, cancelToken) => this.mailboxService.list({ start, cancelToken, search: this.search, version: this.version }))}
+                itemRenderer={(item: IMailbox) => <tr>
+                    <td></td>
+                </tr>}
+                />
+        </div>;
+    }
+
+    @Action({ onEvent: "add-mailbox"})
+    async addMailbox() {
+        await PageNavigator.pushPageForResult(MailboxEditorPage);
+        this.version++;
+    }
+
+}

package/src/common/pages/mailboxes/services/MailboxService.ts

@@ -0,0 +1,34 @@
+import DITransient from "@web-atoms/core/dist/di/DITransient";
+import { Inject } from "@web-atoms/core/dist/di/Inject";
+import EntityService from "../../../../services/EntityService";
+import { Domain, Mailbox } from "../../../../model/model";
+import { Sql } from "../../../Sql";
+
+@DITransient()
+export default class MailboxService {
+
+    @Inject
+    private entityService: EntityService;
+
+    public domains() {
+        return this.entityService.query(Domain).toArray();
+    }
+
+    public list({ search = "", start = 0, size = 50, version = 0, cancelToken}) {
+        let q = this.entityService.query(Mailbox);
+        if (search) {
+            if (search.endsWith("@")) {
+                search = search + "%";
+                q = q.where({ search }, (p) => (x) => Sql.text.like(x.emailAddress.emailAddress, p.search));
+                // q = q.where({ search }, (p) => (x) => Sql.text.st x.emailAddress.emailAddress)
+            } else if(search.startsWith("@")) {
+                search = "%" + search;
+                q = q.where({ search }, (p) => (x) => Sql.text.like(x.emailAddress.emailAddress, p.search));
+            } else {
+                q = q.where({ search }, (p) => (x) => x.emailAddress.emailAddress === p.search);
+            }
+        }
+        return q.toPagedList({ start, size, cancelToken });
+    }
+
+}

package/src/common/pages/user/LoginPage.tsx

@@ -0,0 +1,51 @@
+import XNode from "@web-atoms/core/dist/core/XNode";
+import { ContentPage } from "@web-atoms/web-controls/dist/mobile-app/MobileApp";
+import Form from "@web-atoms/web-controls/dist/basic/Form";
+import FormField from "@web-atoms/web-controls/dist/basic/FormField";
+import { ILoginSession, LoginSession } from "../../../model/model";
+import Bind from "@web-atoms/core/dist/core/Bind";
+import PasswordBox from "@web-atoms/web-controls/dist/basic/PasswordBox";
+import Action from "@web-atoms/core/dist/view-model/Action";
+import InjectProperty from "@web-atoms/core/dist/core/InjectProperty";
+import UserService from "../../../services/UserService";
+
+export default class LoginPage extends ContentPage {
+
+    @InjectProperty
+    private userService: UserService;
+
+    private model: ILoginSession & { userName?: string, checkPassword?: string };
+
+    async init() {
+        this.model = LoginSession.create({});
+        this.model.userName = "";
+        this.model.checkPassword = "";
+        this.render(<div>
+            <div data-layout="center-all">
+                <Form data-submit-event="login">
+                    <FormField label="Username">
+                        <input value={Bind.twoWaysImmediate(() => this.model.userName)}/>
+                    </FormField>
+                    <FormField label="Username">
+                        <PasswordBox
+                            value={Bind.twoWaysImmediate(() => this.model.checkPassword)}
+                            />
+                    </FormField>
+                    <div>
+                        <button
+                            data-layout="accent-button"
+                            data-type="submit"
+                            text="Login"
+                            />
+                    </div>
+                </Form>
+            </div>
+        </div>);
+    }
+
+    @Action({ onEvent: "login" })
+    async login() {
+        await this.userService.login(this.model);
+    }
+
+}

package/src/model/model.ts

@@ -0,0 +1,234 @@
+import DateTime from "@web-atoms/date-time/dist/DateTime";
+import type IClrEntity from "@web-atoms/entity/dist/models/IClrEntity";
+import { ICollection, IGeometry, IModel, Model } from "@web-atoms/entity/dist/services/BaseEntityService";
+
+export interface IAppRole extends IClrEntity {
+	roleName?: string;
+	roles?: ICollection<IUserRole>;
+}
+
+export const AppRole: IModel<IAppRole> = new Model<IAppRole>("AppRole", { roleName: "" });
+
+export interface IAppFile extends IClrEntity {
+	appFileID?: number;
+	folder?: string;
+	fileName?: string;
+	fileSize?: number;
+	contentType?: string;
+	fileContentID?: number;
+	fileContent?: IFileContent;
+	attachments?: ICollection<IEmailAttachment>;
+}
+
+export const AppFile: IModel<IAppFile> = new Model<IAppFile>("AppFile", { folder: "",fileName: "",fileSize: 0,contentType: "",fileContentID: 0 });
+
+export interface IFileContent extends IClrEntity {
+	fileContentID?: number;
+	contentHash?: string;
+	cloudPath?: string | null;
+	contentType?: string;
+	contentSize?: number;
+	appFiles?: ICollection<IAppFile>;
+}
+
+export const FileContent: IModel<IFileContent> = new Model<IFileContent>("FileContent", { contentHash: "",contentType: "",contentSize: 0 });
+
+export interface IConfiguration extends IClrEntity {
+	name?: string;
+	configValue?: string;
+}
+
+export const Configuration: IModel<IConfiguration> = new Model<IConfiguration>("Configuration", { name: "",configValue: "" });
+
+export interface IDomain extends IClrEntity {
+	domainID?: number;
+	name?: string;
+	hostedDomain?: IHostedDomain;
+}
+
+export const Domain: IModel<IDomain> = new Model<IDomain>("Domain", { name: "" });
+
+export interface IHostedDomain extends IClrEntity {
+	domainID?: number;
+	enableReceive?: boolean;
+	enableSend?: boolean;
+	useRelay?: boolean;
+	aliasForName?: string | null;
+	domain?: IDomain;
+	aliasFor?: IHostedDomain;
+	aliases?: ICollection<IHostedDomain>;
+	mailboxes?: ICollection<IMailbox>;
+	domainUsers?: ICollection<IDomainUser>;
+	domainKeys?: ICollection<IDomainKey>;
+	relays?: ICollection<IDomainRelay>;
+}
+
+export const HostedDomain: IModel<IHostedDomain> = new Model<IHostedDomain>("HostedDomain", { domainID: 0,enableReceive: false,enableSend: false,useRelay: false });
+
+export interface IDomainUser extends IClrEntity {
+	domainUserID?: number;
+	domainID?: number;
+	userID?: number;
+	prefix?: string | null;
+	hostedDomain?: IHostedDomain;
+	user?: IUser;
+}
+
+export const DomainUser: IModel<IDomainUser> = new Model<IDomainUser>("DomainUser", { domainID: 0,userID: 0 });
+
+export interface IDomainRelay extends IClrEntity {
+	domainRelayID?: number;
+	domainID?: number;
+	type?: "smtp" | "ses";
+	host?: string;
+	username?: string;
+	password?: string;
+	priority?: number;
+	hostedDomain?: IHostedDomain;
+}
+
+export const DomainRelay: IModel<IDomainRelay> = new Model<IDomainRelay>("DomainRelay", { domainID: 0,type: "smtp",host: "",username: "",password: "",priority: 0 });
+
+export interface IDomainKey extends IClrEntity {
+	domainKeyID?: number;
+	name?: string;
+	publicKey?: string;
+	privateKey?: string;
+	domainID?: number;
+	domain?: IHostedDomain;
+}
+
+export const DomainKey: IModel<IDomainKey> = new Model<IDomainKey>("DomainKey", { name: "",publicKey: "",privateKey: "",domainID: 0 });
+
+export interface IEmail extends IClrEntity {
+	emailID?: number;
+	mailBoxID?: number;
+	subject?: string;
+	textBody?: string;
+	htmlBody?: string;
+	senderName?: string;
+	senderID?: number;
+	headerFrom?: string;
+	headerTo?: string;
+	headerCc?: string;
+	headerBcc?: string;
+	mdBody?: string;
+	dateReceived?: DateTime;
+	dateCreated?: DateTime;
+	dateSent?: DateTime | null;
+	status?: "queued" | "received" | "draft" | "scheduled" | "sent";
+	mailbox?: IMailbox;
+	senderEmail?: IEmailAddress;
+	tags?: ICollection<IEmailTag>;
+	recipients?: ICollection<IEmailRecipient>;
+	attachments?: ICollection<IEmailAttachment>;
+}
+
+export const Email: IModel<IEmail> = new Model<IEmail>("Email", { mailBoxID: 0,subject: "",textBody: "",htmlBody: "",senderName: "",senderID: 0,headerFrom: "",headerTo: "",headerCc: "",headerBcc: "",mdBody: "",dateReceived: new DateTime(),dateCreated: new DateTime(),status: "queued" });
+
+export interface IEmailRecipient extends IClrEntity {
+	emailRecipientID?: number;
+	emailID?: number;
+	email?: IEmail;
+}
+
+export const EmailRecipient: IModel<IEmailRecipient> = new Model<IEmailRecipient>("EmailRecipient", { emailID: 0 });
+
+export interface IEmailTag extends IClrEntity {
+	emailTagID?: number;
+	emailID?: number;
+	tagID?: number;
+	email?: IEmail;
+	tag?: ITag;
+}
+
+export const EmailTag: IModel<IEmailTag> = new Model<IEmailTag>("EmailTag", { emailID: 0,tagID: 0 });
+
+export interface IEmailAddress extends IClrEntity {
+	emailAddressID?: number;
+	emailAddress?: string;
+	mailbox?: IMailbox;
+	senders?: ICollection<IEmail>;
+}
+
+export const EmailAddress: IModel<IEmailAddress> = new Model<IEmailAddress>("EmailAddress", { emailAddress: "" });
+
+export interface IEmailAttachment extends IClrEntity {
+	emailAttachmentID?: number;
+	emailID?: number;
+	appFileID?: number;
+	fileName?: string;
+	contentType?: string;
+	contentDisposition?: string;
+	contentID?: string | null;
+	email?: IEmail;
+	appFile?: IAppFile;
+}
+
+export const EmailAttachment: IModel<IEmailAttachment> = new Model<IEmailAttachment>("EmailAttachment", { emailID: 0,appFileID: 0,fileName: "",contentType: "",contentDisposition: "" });
+
+export interface IMailbox extends IClrEntity {
+	mailboxID?: number;
+	domainID?: number;
+	storage?: number;
+	maxStorage?: number;
+	emailAddress?: IEmailAddress;
+	domain?: IHostedDomain;
+	emails?: ICollection<IEmail>;
+	userMailboxes?: ICollection<IUserMailbox>;
+}
+
+export const Mailbox: IModel<IMailbox> = new Model<IMailbox>("Mailbox", { mailboxID: 0,domainID: 0,storage: 0,maxStorage: 0 });
+
+export interface IUser extends IClrEntity {
+	userID?: number;
+	userName?: string;
+	displayName?: string;
+	passwordHash?: string;
+	passwordSalt?: string;
+	roles?: ICollection<IUserRole>;
+	sessions?: ICollection<ILoginSession>;
+	domainUsers?: ICollection<IDomainUser>;
+	userMailboxes?: ICollection<IUserMailbox>;
+}
+
+export const User: IModel<IUser> = new Model<IUser>("User", { userName: "",displayName: "",passwordHash: "",passwordSalt: "" });
+
+export interface IUserRole extends IClrEntity {
+	id?: number;
+	userID?: number;
+	roleName?: string;
+	user?: IUser;
+	role?: IAppRole;
+}
+
+export const UserRole: IModel<IUserRole> = new Model<IUserRole>("UserRole", { userID: 0,roleName: "" });
+
+export interface IUserMailbox extends IClrEntity {
+	userMailboxID?: number;
+	emailAddress?: string;
+	userID?: number;
+	mailbox?: IMailbox;
+	user?: IUser;
+}
+
+export const UserMailbox: IModel<IUserMailbox> = new Model<IUserMailbox>("UserMailbox", { emailAddress: "",userID: 0 });
+
+export interface ILoginSession extends IClrEntity {
+	sessionID?: number;
+	userID?: number;
+	start?: Date;
+	expiry?: Date;
+	invalid?: boolean;
+	user?: IUser;
+}
+
+export const LoginSession: IModel<ILoginSession> = new Model<ILoginSession>("LoginSession", { userID: 0,start: new Date(),expiry: new Date(),invalid: false });
+
+export interface ITag extends IClrEntity {
+	tagID?: number;
+	name?: string;
+	emailTags?: ICollection<IEmailTag>;
+}
+
+export const Tag: IModel<ITag> = new Model<ITag>("Tag", { name: "" });

package/src/services/BusyProgress.ts

@@ -20,13 +20,13 @@ const css = styled.css `
         width: 100%;
         height: 100%;
         overflow: hidden;
-        background-color: rgb(159, 51, 255, 0.25);
+        background-color: var(--accent2-color);
   
         & > .progress-bar-value {
             display: none;
             width: 100%;
             height: 100%;
-            background-color: rgb(159, 51, 255);
+            background-color: var(--accent-color);
             transform-origin: 0% 50%;
         }
     }

package/src/services/ConfigService.ts

@@ -0,0 +1,19 @@
+import DITransient from "@web-atoms/core/dist/di/DITransient";
+import { Inject } from "@web-atoms/core/dist/di/Inject";
+import EntityService from "./EntityService";
+import { Configuration } from "../model/model";
+
+@DITransient()
+export default class ConfigService {
+
+    @Inject
+    private entityService: EntityService;
+
+    async isConfigured() {
+        const configured = "configured";
+        const isConfigured = await this.entityService.query(Configuration)
+            .where({ configured }, (p) => (x) => x.name === p.configured)
+            .firstOrDefault();
+    }
+
+}