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

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();
+    }
+
+}

package/src/services/EntityService.ts

@@ -4,11 +4,14 @@ import { Inject } from "@web-atoms/core/dist/di/Inject";
 import { App } from "@web-atoms/core/dist/App";
 import { IHttpRequest } from "@web-atoms/entity/dist/services/HttpSession";
 import BusyProgress from "./BusyProgress";
+import { QueryProcessor } from "@web-atoms/entity/dist/services/QueryProcessor";
 
 
 @DISingleton()
 export default class EntityService extends BaseEntityService {
 
+    public queryProcessor: QueryProcessor = "JavaScript";
+
     @Inject
     private app: App;
 

package/src/services/UserService.ts

@@ -0,0 +1,26 @@
+import DISingleton from "@web-atoms/core/dist/di/DISingleton";
+import { Inject } from "@web-atoms/core/dist/di/Inject";
+import EntityService from "./EntityService";
+import { ILoginSession, IUser, LoginSession, User } from "../model/model";
+import SocialMailApp from "../common/SocialMailApp";
+
+@DISingleton()
+export default class UserService {
+
+    @Inject
+    private entityService: EntityService;
+
+    private user: IUser;
+
+    public async getUser() {
+        this.user ??= (await this.entityService.query(LoginSession, "currentUser").firstOrDefault())?.user;
+        SocialMailApp.user = this.user;
+        return this.user;
+    }
+
+    public async login(session: ILoginSession) {
+        await this.entityService.save(session);
+        location.reload();
+    }
+
+}

package/src/style/GlobalStyle.ts

@@ -1,3 +1,12 @@
+
+import { UMD } from "@web-atoms/core/dist/core/types";
+
+import "@web-atoms/core/dist/core/AtomList";
+
+import "./OverrideAppStyle";
+
+export const ___UMD = UMD;
+
 import styled from "@web-atoms/core/dist/style/styled";
 import "@web-atoms/data-styles/data-styles";
 
@@ -27,8 +36,8 @@ addLinkTag("https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@6.4.0/css
 
 :root {
     --primary-color: #294D4A;
-    --accent-color: #9F33FF;
-    --accent2-color: #382C5285;
+    --accent-color: #ff6733;
+    --accent2-color: #ff673375;
     --lighter-accent-color: #e6e6fa60;
     --light-accent-color: #f2e5fa;
     --accent-text-color: white;

package/src/style/OverrideAppStyle.ts

@@ -0,0 +1,9 @@
+import styled from "@web-atoms/core/dist/style/styled";
+
+    styled.css `
+
+    div[data-desktop-app=desktop-app] {
+        width: 100%;
+    }
+
+`.withId("default-app-style").withOrder("medium").installGlobal();

package/src/web/AppIndex.tsx

@@ -10,10 +10,35 @@ import Command from "@web-atoms/core/dist/core/Command";
 import AppCommands from "./commands/AppCommands";
 
 import "../style/GlobalStyle";
+import UserService from "../services/UserService";
+import LoginPage from "../common/pages/user/LoginPage";
+import AppDrawer from "./drawer/AppDrawer";
 
 @Pack
 export default class AppIndex extends MobileDesktopApp {
+
+    @InjectProperty
+    private userService: UserService;
+
     async init() {
         AppCommands.install(this);
+
+        // check if we are logged in...
+        if (!await this.userService.getUser()) {
+            PageNavigator.openPage(LoginPage);
+            return;
+        }
+
+        this.drawerMenu = AppDrawer;
+    }
+}
+
+Route.encodeUrl = (url) => {
+    if (url.startsWith("#")) {
+        return url;
+    }
+    if (/\d+\./.test(location.hostname)) {
+        return "#!" + url;
     }
-}
+    return url;
+};