@social-mail/social-mail-client 1.2.64 → 1.2.66

package/src/model/model.ts

@@ -27,9 +27,9 @@ export interface IAppFile extends IClrEntity {
 	readonly dateCreated?: DateTime;
 	dateUpdated?: DateTime | null;
 	versions?: number | null;
+	sourceUrl?: string;
 	url?: string;
 	downloadUrl?: string;
-	tempKeys?: string[];
 	fileContent?: IFileContent;
 	creator?: IUser;
 	parent?: IAppFile;
@@ -282,11 +282,12 @@ export interface IEmail extends IClrEntity {
 	readonly received?: boolean;
 	headers?: string | null;
 	headerMessageID?: string | null;
+	externalEmailID?: string | null;
 	mdBody?: string | null;
 	dateReceived?: DateTime;
 	dateCreated?: DateTime;
 	dateSent?: DateTime | null;
-	status?: "queued" | "received" | "draft" | "pending-approval" | "scheduled" | "sent" | "sent-failed";
+	status?: "queued" | "received" | "draft" | "published" | "pending-approval" | "scheduled" | "sent" | "sent-failed";
 	forwardCount?: number;
 	replyCount?: number;
 	viewCount?: number;
@@ -316,7 +317,7 @@ export interface IEmail extends IClrEntity {
 	subscriberActivities?: ICollection<ISubscriberActivity>;
 }
 
-export const EmailStatusArray = [{"label":"queued","value":"queued"},{"label":"received","value":"received"},{"label":"draft","value":"draft"},{"label":"pending-approval","value":"pending-approval"},{"label":"scheduled","value":"scheduled"},{"label":"sent","value":"sent"},{"label":"sent-failed","value":"sent-failed"}];
+export const EmailStatusArray = [{"label":"queued","value":"queued"},{"label":"received","value":"received"},{"label":"draft","value":"draft"},{"label":"published","value":"published"},{"label":"pending-approval","value":"pending-approval"},{"label":"scheduled","value":"scheduled"},{"label":"sent","value":"sent"},{"label":"sent-failed","value":"sent-failed"}];
 
 export const Email: IModel<IEmail> = new Model<IEmail>("Email", ["emailID"], { senderName: "",received: false,dateReceived: new DefaultFactory(() => new DateTime()),dateCreated: new DefaultFactory(() => new DateTime()),status: "queued",forwardCount: 0,replyCount: 0,viewCount: 0,originalFileSize: 0 });
 
@@ -413,7 +414,10 @@ export interface IMailbox extends IClrEntity {
 	dateUpdated?: DateTime;
 	isChannel?: boolean;
 	isPrivateChannel?: boolean;
+	requireApproval?: boolean;
 	subscriberCount?: number;
+	datePublished?: DateTime | null;
+	dateEngaged?: DateTime | null;
 	username?: string;
 	name?: string;
 	emailAddress?: IEmailAddress;
@@ -425,12 +429,13 @@ export interface IMailbox extends IClrEntity {
 	mailboxContacts?: ICollection<IMailboxContact>;
 	threadEmails?: ICollection<IMailboxContactEmail>;
 	syncTargets?: ICollection<IMailboxSyncTarget>;
+	channelConfig?: IChannelConfig;
 	subscriberActivities?: ICollection<ISubscriberActivity>;
 	userPins?: ICollection<IUserPin>;
 	userMailboxes?: ICollection<IUserMailbox>;
 }
 
-export const Mailbox: IModel<IMailbox> = new Model<IMailbox>("Mailbox", ["mailboxID"], { storage: 0,maxStorage: 0,indexAttachments: false,indexImageAttachments: false,dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),isChannel: false,isPrivateChannel: false,subscriberCount: 0 });
+export const Mailbox: IModel<IMailbox> = new Model<IMailbox>("Mailbox", ["mailboxID"], { storage: 0,maxStorage: 0,indexAttachments: false,indexImageAttachments: false,dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),isChannel: false,isPrivateChannel: false,requireApproval: false,subscriberCount: 0 });
 
 export interface IMailboxEmail extends IClrEntity {
 	mailboxID?: number;
@@ -455,6 +460,7 @@ export interface IMailboxContact extends IClrEntity {
 	canContribute?: boolean;
 	priority?: number;
 	blocked?: boolean;
+	mute?: boolean;
 	status?: "invited" | "added" | "active" | "unsubscribed" | "blocked";
 	emailAddressText?: string;
 	name?: string;
@@ -466,7 +472,7 @@ export interface IMailboxContact extends IClrEntity {
 
 export const MailboxContactStatusArray = [{"label":"invited","value":"invited"},{"label":"added","value":"added"},{"label":"active","value":"active"},{"label":"unsubscribed","value":"unsubscribed"},{"label":"blocked","value":"blocked"}];
 
-export const MailboxContact: IModel<IMailboxContact> = new Model<IMailboxContact>("MailboxContact", ["mailboxID","emailAddressID"], { dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),unread: 0,total: 0,isOwner: false,canContribute: false,priority: 0,blocked: false,status: "invited" });
+export const MailboxContact: IModel<IMailboxContact> = new Model<IMailboxContact>("MailboxContact", ["mailboxID","emailAddressID"], { dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),unread: 0,total: 0,isOwner: false,canContribute: false,priority: 0,blocked: false,mute: false,status: "invited" });
 
 export interface IMailboxContactEmail extends IClrEntity {
 	mailboxID?: number;
@@ -521,6 +527,19 @@ export const MailboxSyncTargetLastSyncStatusArray = [{"label":"none","value":"no
 
 export const MailboxSyncTarget: IModel<IMailboxSyncTarget> = new Model<IMailboxSyncTarget>("MailboxSyncTarget", ["syncTargetID"], { direction: "in",protocol: "imap",username: "",host: "",port: 0,isSecure: false,syncAllFolders: false,syncJunkMails: false,intervalSeconds: 0,active: false });
 
+export interface IChannelConfig extends IClrEntity {
+	mailboxID?: number;
+	inviteContent?: string | null;
+	welcomeContent?: string | null;
+	sendInviteOnEngagement?: boolean;
+	memberOnlyEngagement?: boolean;
+	notSafeForWork?: boolean;
+	postFooter?: string | null;
+	mailbox?: IMailbox;
+}
+
+export const ChannelConfig: IModel<IChannelConfig> = new Model<IChannelConfig>("ChannelConfig", ["mailboxID"], { sendInviteOnEngagement: false,memberOnlyEngagement: false,notSafeForWork: false });
+
 export interface ISubscriberActivity extends IClrEntity {
 	readonly activityID?: number;
 	mailboxID?: number;
@@ -585,6 +604,7 @@ export interface IUser extends IClrEntity {
 	userMailboxes?: ICollection<IUserMailbox>;
 	authFactors?: ICollection<IUserAuthFactor>;
 	publishedWebSiteVersions?: ICollection<IWebSiteFolderVersion>;
+	licenses?: ICollection<IAppLicense>;
 }
 
 export const UserStatusArray = [{"label":"active","value":"active"},{"label":"blocked","value":"blocked"},{"label":"locked","value":"locked"},{"label":"change-password","value":"change-password"},{"label":"external","value":"external"}];
@@ -718,3 +738,115 @@ export interface ITag extends IClrEntity {
 }
 
 export const Tag: IModel<ITag> = new Model<ITag>("Tag", ["tagID"], { name: "",isSystemTag: false });
+
+export interface IProduct extends IClrEntity {
+	productID?: string;
+	name?: string;
+	description?: string | null;
+	prices?: ICollection<IProductPrice>;
+}
+
+export const Product: IModel<IProduct> = new Model<IProduct>("Product", ["productID"], { name: "" });
+
+export interface IProductPrice extends IClrEntity {
+	priceID?: string;
+	productID?: string;
+	quantity?: number;
+	amount?: number;
+	isActive?: boolean;
+	currency?: string;
+	product?: IProduct;
+	licenses?: ICollection<IAppLicense>;
+}
+
+export const ProductPrice: IModel<IProductPrice> = new Model<IProductPrice>("ProductPrice", ["priceID"], { quantity: 0,amount: 0,isActive: false,currency: "" });
+
+export interface IAppLicense extends IClrEntity {
+	readonly licenseID?: number;
+	customerID?: number;
+	priceID?: string;
+	dateCreated?: DateTime;
+	dateExpiry?: DateTime;
+	dateUpdated?: DateTime;
+	maxCores?: number;
+	licenseCode?: string;
+	customer?: IUser;
+	price?: IProductPrice;
+}
+
+export const AppLicense: IModel<IAppLicense> = new Model<IAppLicense>("AppLicense", ["licenseID","priceID"], { dateCreated: new DefaultFactory(() => new DateTime()),dateExpiry: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),maxCores: 0,licenseCode: "" });
+
+export interface IVirtualServer extends IClrEntity {
+	readonly serverID?: number;
+	serverName?: string;
+	ownerEmailAddress?: string | null;
+	ownerPhoneNumber?: string | null;
+	active?: boolean;
+	bucketName?: string | null;
+	database?: string | null;
+	host?: string;
+	forwardHost?: string | null;
+	forwardPublicKey?: string | null;
+	environmentVariables?: string | null;
+	maxStorageGB?: number;
+	dnsZones?: ICollection<IDnsZone>;
+}
+
+export const VirtualServer: IModel<IVirtualServer> = new Model<IVirtualServer>("VirtualServer", ["serverID"], { serverName: "",active: false,host: "",maxStorageGB: 0 });
+
+export interface IDnsZone extends IClrEntity {
+	readonly zoneID?: number;
+	serverID?: number;
+	zone?: string;
+	keySigningKeyID?: number;
+	zoneSigningKeyID?: number;
+	dateCreated?: DateTime;
+	dateUpdated?: DateTime;
+	signed?: string | null;
+	unsigned?: string | null;
+	virtualServer?: IVirtualServer;
+	ksk?: IDnsSigningKey;
+	zsk?: IDnsSigningKey;
+	records?: ICollection<IDnsZoneRecord>;
+}
+
+export const DnsZone: IModel<IDnsZone> = new Model<IDnsZone>("DnsZone", ["zoneID"], { zone: "",dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()) });
+
+export interface IDnsZoneRecord extends IClrEntity {
+	readonly recordID?: number;
+	zoneID?: number;
+	disabled?: boolean;
+	name?: string;
+	type?: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "PTR" | "SRV" | "CAA" | "NS" | "SOA";
+	isAlias?: boolean;
+	value?: string;
+	ttl?: number;
+	dateCreated?: DateTime;
+	dateUpdated?: DateTime;
+	notes?: string | null;
+	signature?: string | null;
+	expiryDate?: DateTime | null;
+	readonly fqdn?: string | null;
+	hosted?: boolean;
+	zone?: IDnsZone;
+}
+
+export const DnsZoneRecordTypeArray = [{"label":"A","value":"A"},{"label":"AAAA","value":"AAAA"},{"label":"CNAME","value":"CNAME"},{"label":"MX","value":"MX"},{"label":"TXT","value":"TXT"},{"label":"PTR","value":"PTR"},{"label":"SRV","value":"SRV"},{"label":"CAA","value":"CAA"},{"label":"NS","value":"NS"},{"label":"SOA","value":"SOA"}];
+
+export const DnsZoneRecord: IModel<IDnsZoneRecord> = new Model<IDnsZoneRecord>("DnsZoneRecord", ["recordID"], { disabled: false,name: "",type: "A",isAlias: false,value: "",ttl: 0,dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),hosted: false });
+
+export interface IDnsSigningKey extends IClrEntity {
+	readonly keyID?: number;
+	publicKey?: string;
+	digestAlgorithm?: number;
+	signingAlgorithm?: number;
+	digest?: string;
+	flags?: number;
+	dateCreated?: DateTime;
+	expiryDate?: DateTime;
+	fileName?: string;
+	kskZones?: ICollection<IDnsZone>;
+	zskZones?: ICollection<IDnsZone>;
+}
+
+export const DnsSigningKey: IModel<IDnsSigningKey> = new Model<IDnsSigningKey>("DnsSigningKey", ["keyID"], { publicKey: "",digestAlgorithm: 0,signingAlgorithm: 0,digest: "",flags: 0,dateCreated: new DefaultFactory(() => new DateTime()),expiryDate: new DefaultFactory(() => new DateTime()),fileName: "" });

package/src/public/channel/BlogService.ts

@@ -15,6 +15,16 @@ export default class BlogService {
     @Inject
     downloader: EmailContentDownloader;
 
+    async getEmail({
+        emailID,
+        channelID
+    }) {
+        const q = this.entityService.query(Email, "channelEmails", channelID)
+            .where({ emailID }, (p) => (x) => x.emailID === p.emailID)
+            .include((x) => [x.children]);
+        return q.firstOrDefault();
+    }
+
     async getEmails({
         channelID = 0,
         search = "",
@@ -43,12 +53,14 @@ export default class BlogService {
     }
 
     async getChannel(channelID?, emailAddress?: any) {
-        let q = this.entityService.query(Mailbox, "channels", emailAddress);
+        let q = this.entityService.query(Mailbox, "channels", emailAddress)
+            .where((x) => x.datePublished !== null);
         if (channelID) {
             q = q.where({ channelID}, (p) => (x) => x.mailboxID === p.channelID);
         }
-        const c = await this.entityService.query(Mailbox, "channels", emailAddress)
+        const c = await q
             .include((x) => x.emailAddress)
+            .orderByDescending((x) => x.datePublished)
             .firstOrDefault();
         return c;
     }

package/src/public/channel/ChannelMessage.tsx

@@ -1,10 +1,16 @@
 import InjectProperty from "@web-atoms/core/dist/core/InjectProperty";
 import { AtomControl } from "@web-atoms/core/dist/web/controls/AtomControl";
 import BlogService from "./BlogService";
+import XNode from "@web-atoms/core/dist/core/XNode";
+import { DateFormats } from "../../common/date/DateFormats";
+import { renderMail } from "../../web/page/mails/service/ConversationService";
 
 const url = (window as any).pageUrl as URL;
 
-const {1: channelID = 1, 2: emailID = 1 } = /^\/channels\/(\d+)\/(\d+)\//.exec(url.pathname) ?? {} as any;
+let {1: channelID = 1, 2: emailID = 82 } = /^\/channels\/([^\/]+)\/([^\/]+)\//.exec(url.pathname) ?? {} as any;
+
+channelID = parseInt(channelID, 36);
+emailID = parseInt(emailID, 36);
 
 export default class ChannelMessage extends AtomControl {
 
@@ -13,6 +19,18 @@ export default class ChannelMessage extends AtomControl {
 
     async init() {
         const { items: [ email ]} = await this.blogService.getEmails({ channelID,  start: 0, size: 1, cancelToken: null});
+
+        this.renderer = <section data-element="blog-item">
+            <h4 data-element="title">
+                <label text={email.subject}/>
+            </h4>
+            <h6 data-element="date" text={DateFormats.relative.short(email.dateSent)}/>
+            <h6 text={email.senderName}/>
+            <section
+                data-element="content">
+                <section { ... renderMail({ email })}/>
+            </section>
+        </section>;
     }
 
 }

package/src/public/channel/ChannelMessageList.tsx

@@ -10,6 +10,7 @@ import { IMailbox, IEmail } from "../../model/model";
 import { renderMail } from "../../web/page/mails/service/ConversationService";
 import BlogService from "./BlogService";
 import { channelViewStyle } from "./channelViewStyle";
+import { UrlService } from "./UrlService";
 
 export default class ChannelView extends AtomControl {
 
@@ -29,12 +30,15 @@ export default class ChannelView extends AtomControl {
 
     async init() {
 
-        const { channelID, emailAddress } = (window as any).socialMail ?? {};
+        let { channelID, emailAddress } = (window as any).socialMail ?? {};
 
         this.element.setAttribute("data-blog-list", "blog-list");
 
         this.channel = await this.blogService.getChannel(emailAddress, channelID);
 
+        channelID = this.channel.mailboxID;
+        emailAddress = this.channel.emailAddress.emailAddress;
+
         this.renderer = <div data-layout="flex-center">
             <span text="..."/>
         </div>;
@@ -68,7 +72,7 @@ export default class ChannelView extends AtomControl {
                     itemRenderer={(email: IEmail) => {
                         return <section data-element="blog-item">
                             <h4 data-element="title">
-                                <a href={`/channels/${this.channel.mailboxID}/${email.emailID}/${email.subject?.trim() ?? ""}`} text={email.subject}></a>
+                                <a href={UrlService.toBlogUrl(channelID, email.emailID, email.subject)} text={email.subject}></a>
                             </h4>
                             <h6 data-element="date" text={DateFormats.relative.short(email.dateSent)}/>
                             <h6 text={email.senderName}/>

package/src/public/channel/UrlService.ts

@@ -0,0 +1,12 @@
+export const UrlService = {
+
+    toBlogUrl: (channelID: number, emailID: number, subject: string ) => {
+        subject ||= "";
+        if(subject.length > 400) {
+            subject = subject.substring(0, 400);
+        }
+        subject = subject.replace(/[^\p{L}\p{N}]+/ug, "-");
+        subject = encodeURIComponent(subject).replace(/\%20/g, "-");
+        return `/channels/${Number(channelID).toString(36)}/${Number(emailID).toString(36)}/${subject}`;
+    }
+};

package/src/web/drawer/AppDrawer.tsx

@@ -89,7 +89,7 @@ export default class AppDrawer extends Drawer {
                         commandLink={null}
                         />
                     { ... channels.map((mb) => <MenuItem
-                        commandLink={AppCommands.openMailbox.displayRoute({ id: mb.mailboxID })}
+                        commandLink={AppCommands.openChannel.displayRoute({ id: mb.mailboxID })}
                         label={mb.emailAddress.name}
                         description={mb.emailAddress.emailAddress}
                         title={mb.emailAddress.emailAddress}

package/src/web/page/channels/detail/ChannelDetailPage.tsx

@@ -1,7 +1,76 @@
 import { ContentPage } from "@web-atoms/web-controls/dist/mobile-app/MobileApp";
-import { IMailbox } from "../../../../model/model";
+import { IEmail, IMailbox } from "../../../../model/model";
 import InjectProperty from "@web-atoms/core/dist/core/InjectProperty";
 import MailboxService from "../../../../common/pages/mailboxes/services/MailboxService";
+import XNode from "@web-atoms/core/dist/core/XNode";
+import AppCommands from "../../../commands/AppCommands";
+import AtomRepeater from "@web-atoms/web-controls/dist/basic/AtomRepeater";
+import ChannelService from "../services/ChannelService";
+import InfiniteRepeater from "../../../../common/controls/repeater/InfiniteRepeater";
+import Bind from "@web-atoms/core/dist/core/Bind";
+import LimitedText from "@web-atoms/web-controls/dist/basic/LimitedText";
+import { renderMail } from "../../mails/service/ConversationService";
+import { DateFormats } from "../../../../common/date/DateFormats";
+import styled from "@web-atoms/core/dist/style/styled";
+
+const css = styled.css `
+
+    & [data-blog-list=blog-list] {
+
+
+        display: flex;
+        flex-direction: column;
+        gap: 10px;
+
+        & > * {
+            border: solid 1px lightgray;
+            border-radius: 5px;
+            display: inline-grid;
+            grid-template-columns: 5px 1fr auto auto 5px;
+            grid-template-rows: 5px auto auto 1fr auto 5px;
+
+            & > [data-element=bg] {
+                grid-row: 1 / span 3;
+                grid-column: 1/ span 5;
+                background-color: lightgrey;
+                z-index: -1;
+            }
+
+            & > h4, & > h6 {
+                margin-block-start: 0;
+                margin-block-end: 0;
+            }
+
+            & > [data-element=actions] {
+                grid-row: 2;
+                grid-column: 4;
+            }
+
+            & > [data-element=title] {
+                grid-row: 3;
+                grid-column: 2 / span 2;
+            }
+
+            & > [data-element=date] {
+                grid-row: 2;
+                grid-column: 3;
+            }
+
+            & > [data-element=author] {
+                grid-row: 2;
+                grid-column: 2;
+            }
+
+            & > [data-element=content] {
+                grid-row: 4;
+                grid-column: 2 / span 4;
+            }
+        }
+
+    }
+
+`.installLocal();
+
 
 export default class ChannelDetailPage extends ContentPage {
 
@@ -9,12 +78,55 @@ export default class ChannelDetailPage extends ContentPage {
 
     public mailbox: IMailbox;
 
+    public search = "";
+
     @InjectProperty
     private mailboxService: MailboxService;
 
+    @InjectProperty
+    private channelService: ChannelService;
+
     async init() {
+
         this.mailbox = await this.mailboxService.get(this.parameters.id);
         this.title = `${this.mailbox.emailAddress.name || this.mailbox.name} (${this.mailbox.emailAddress.emailAddress})`;
+
+        this.headerRenderer = () => <div data-layout="header-row">
+            <input type="search" value={Bind.twoWaysImmediate(() => this.search)}/>
+            <a
+                data-click-event="route"
+                href={AppCommands.openSubscribers.displayRoute({ id: this.parameters.id})}>Subscribers</a>
+        </div>;
+
+        this.renderer = <section class={css}>
+            <AtomRepeater
+                data-blog-list="blog-list"
+                { ... InfiniteRepeater.pagedItems((start) =>
+                        (c, e, cancelToken) =>
+                            this.channelService.getMails({
+                                channelID: this.parameters.id,
+                                search: this.search,
+                                cancelToken
+                            })
+                    )}
+                itemRenderer={(email: IEmail) => <section data-element="blog-item">
+                <div data-element="bg"/>
+                <h4 data-element="title"
+                    text={email.subject}/>
+                <h6 data-element="date" text={DateFormats.relative.short(email.dateSent)}/>
+                <h6 data-element="author" text={email.senderName}/>
+                <i
+                    data-element="actions"
+                    class="fa-light fa-square-ellipsis-vertical"/>
+                <section
+                    data-element="content">
+                    <LimitedText height={200}>
+                        <section { ... renderMail({ email })}/>
+                    </LimitedText>
+                </section>
+            </section>}
+                />
+        </section>;
     }
 
 }

package/src/web/page/channels/services/ChannelService.ts

@@ -1,7 +1,7 @@
 import DITransient from "@web-atoms/core/dist/di/DITransient";
 import { Inject } from "@web-atoms/core/dist/di/Inject";
 import EntityService from "../../../../services/EntityService";
-import { IMailboxContact, Mailbox, MailboxContact } from "../../../../model/model";
+import { Email, IMailboxContact, Mailbox, MailboxContact } from "../../../../model/model";
 import { Sql } from "../../../../common/Sql";
 
 @DITransient({})
@@ -10,6 +10,37 @@ export default class ChannelService {
     @Inject
     private entityService: EntityService;
 
+    public async getMails({
+        channelID,
+        published = true,
+        start = 0,
+        size = 100,
+        search = "",
+        cancelToken
+    }) {
+        let q = this.entityService.query(Email);
+
+        if (channelID) {
+            q = q.where({ channelID}, (p) => (x) => x.mailboxes.some((m) => m.mailboxID === p.channelID));
+        }
+
+        if (published) {
+            q = q.where((x) => x.status === "published");
+        } else {
+            q = q.where((x) => x.status !== "published");
+        }
+
+        if (search) {
+            if (!/\%/.test(search)) {
+                search = search + "%";
+            }
+            q = q.where({ search }, (p) => (x) => Sql.text.like(x.subject, p.search));
+        }
+
+        return q.orderByDescending((x) => x.emailID)
+            .toPagedList({ start, size, cancelToken });
+    }
+
     public async getMailbox(id: number) {
         return this.entityService.query(Mailbox)
             .include((x) => x.emailAddress)

package/src/web/page/mails/ConversationPage.tsx

@@ -288,6 +288,11 @@ export default class ConversationPage extends ContentPage {
         void InlinePopupControl.showPopup(ce.target as HTMLElement, <div
             data-click-event="none"
             data-click-animate="none">
+                { thread.email?.status === "published" &&
+                    <MenuItem
+                        icon="fas fa-delete"
+                        data-click-event="un-publish-mail"/>
+                }
                 <MenuItem
                     eventClick={() => PageNavigator.pushPage(MailDetailPage, thread.email)}
                     icon="fas fa-eye"

package/src/web/page/mails/service/MailService.ts

@@ -52,8 +52,9 @@ export default class MailService {
     }
 
     async send(email: IEmail) {
-        if (email.textBody) {
-            email.subject ||= email.textBody.substring(0, 80);
+        const { textBody } = email;
+        if (textBody) {
+            email.subject ||= textBody.split("\n")[0].substring(0, 80);
         }
         for (const iterator of email.recipients) {
             if (iterator.emailAddressText) {