@social-mail/social-mail-client 1.2.210 → 1.2.211

package/src/model/model.ts

@@ -28,15 +28,14 @@ export interface IAppFile extends IClrEntity {
 	dateUpdated?: DateTime | null;
 	versions?: number | null;
 	sourceUrl?: string;
-	url?: string;
 	sourceEmailLogID?: number;
+	url?: string;
 	downloadUrl?: string;
 	fileContent?: IFileContent;
 	creator?: IUser;
 	parent?: IAppFile;
 	children?: ICollection<IAppFile>;
 	email?: IEmail;
-	originalEmails?: ICollection<IEmail>;
 	fileVersions?: ICollection<IAppFileVersion>;
 	folderVersions?: ICollection<IAppFileVersion>;
 	accessList?: ICollection<IAppFileAccess>;
@@ -53,6 +52,17 @@ export const AppFileContentDispositionArray = [{"label":"attachment","value":"at
 
 export const AppFile: IModel<IAppFile> = new Model<IAppFile>("AppFile", ["appFileID"], { isFolder: false,name: "",fileSize: 0,contentType: "",isDeleted: false,isShared: false,dateCreated: new DefaultFactory(() => new DateTime()) });
 
+export interface IAccessToken extends IClrEntity {
+	readonly tokenID?: number;
+	userID?: number;
+	dateCreated?: DateTime;
+	expiryDate?: DateTime;
+	displaySecret?: Object;
+	user?: IUser;
+}
+
+export const AccessToken: IModel<IAccessToken> = new Model<IAccessToken>("AccessToken", ["tokenID"], { dateCreated: new DefaultFactory(() => new DateTime()),expiryDate: new DefaultFactory(() => new DateTime()) });
+
 export interface IAppFileVersion extends IClrEntity {
 	readonly versionID?: number;
 	fileID?: number;
@@ -107,19 +117,20 @@ export interface IFileContent extends IClrEntity {
 	contentSize?: number;
 	compression?: string | null;
 	textDocumentID?: number | null;
+	deleted?: boolean;
 	textDocument?: ITextDocument;
 	appFiles?: ICollection<IAppFile>;
 	versions?: ICollection<IAppFileVersion>;
 }
 
-export const FileContent: IModel<IFileContent> = new Model<IFileContent>("FileContent", ["fileContentID"], { contentHash: "",contentType: "",contentSize: 0 });
+export const FileContent: IModel<IFileContent> = new Model<IFileContent>("FileContent", ["fileContentID"], { contentHash: "",contentType: "",contentSize: 0,deleted: false });
 
 export interface IConfiguration extends IClrEntity {
 	name?: string;
-	configValue?: string;
+	configValue?: string | null;
 }
 
-export const Configuration: IModel<IConfiguration> = new Model<IConfiguration>("Configuration", ["name"], { configValue: "" });
+export const Configuration: IModel<IConfiguration> = new Model<IConfiguration>("Configuration", ["name"], {  });
 
 export interface IContact extends IClrEntity {
 	readonly contactID?: number;
@@ -132,7 +143,7 @@ export interface IContact extends IClrEntity {
 	synchronization?: string | null;
 	dateCreated?: DateTime;
 	dateUpdated?: DateTime;
-	previewID?: number;
+	previewID?: number | null;
 	user?: IUser;
 	mailbox?: IMailbox;
 	domain?: IHostedDomain;
@@ -292,9 +303,10 @@ export interface IEmail extends IClrEntity {
 	forwardCount?: number;
 	replyCount?: number;
 	viewCount?: number;
-	originalFileID?: number | null;
-	originalFileSize?: number;
 	mimeFileID?: number | null;
+	htmlBodyID?: number | null;
+	emailSize?: number;
+	originalFileSize?: number;
 	workflowID?: string | null;
 	parentID?: number | null;
 	forwardedID?: number | null;
@@ -302,14 +314,15 @@ export interface IEmail extends IClrEntity {
 	tags?: string | null;
 	senderEmail?: IEmailAddress;
 	senderUser?: IUser;
-	originalFile?: IAppFile;
+	mimeFile?: IEmailLog;
+	logs?: ICollection<IEmailLog>;
+	htmlBodyFile?: IEmailLog;
 	parent?: IEmail;
 	children?: ICollection<IEmail>;
 	forwarded?: IEmail;
 	forwards?: ICollection<IEmail>;
 	attachments?: ICollection<IAppFile>;
 	engagements?: ICollection<IEmailEngagement>;
-	logs?: ICollection<IEmailLog>;
 	recipients?: ICollection<IEmailRecipient>;
 	emailTags?: ICollection<IEmailTag>;
 	mailboxes?: ICollection<IMailboxEmail>;
@@ -320,7 +333,7 @@ export interface IEmail extends IClrEntity {
 
 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"},{"label":"deleted","value":"deleted"}];
 
-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 });
+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,emailSize: 0,originalFileSize: 0 });
 
 export interface IEmailEngagement extends IClrEntity {
 	emailID?: number;
@@ -329,30 +342,33 @@ export interface IEmailEngagement extends IClrEntity {
 	email?: IEmail;
 }
 
-export const EmailEngagement: IModel<IEmailEngagement> = new Model<IEmailEngagement>("EmailEngagement", ["emailID"], { engagement: "",count: 0 });
+export const EmailEngagement: IModel<IEmailEngagement> = new Model<IEmailEngagement>("EmailEngagement", ["emailID","engagement"], { count: 0 });
 
 export interface IEmailLog extends IClrEntity {
 	readonly logID?: number;
 	emailID?: number;
 	fileName?: string;
+	fileSize?: number;
 	compression?: string;
 	dateCreated?: DateTime;
 	cloudPath?: string;
 	url?: string;
 	email?: IEmail;
+	mimeFileEmails?: ICollection<IEmail>;
+	htmlBodyFileEmails?: ICollection<IEmail>;
 }
 
-export const EmailLog: IModel<IEmailLog> = new Model<IEmailLog>("EmailLog", ["logID"], { fileName: "",compression: "",dateCreated: new DefaultFactory(() => new DateTime()),cloudPath: "" });
+export const EmailLog: IModel<IEmailLog> = new Model<IEmailLog>("EmailLog", ["logID"], { fileName: "",fileSize: 0,compression: "",dateCreated: new DefaultFactory(() => new DateTime()),cloudPath: "" });
 
 export interface IEmailRecipient extends IClrEntity {
 	emailID?: number;
 	emailAddressID?: number;
 	type?: "from" | "to" | "cc" | "bcc" | "viewer" | "editor";
 	name?: string | null;
-	replyTo?: string | null;
 	dateSent?: DateTime | null;
 	error?: string | null;
 	status?: string | null;
+	replyTo?: string | null;
 	emailAddressText?: string;
 	email?: IEmail;
 	emailAddress?: IEmailAddress;
@@ -520,9 +536,9 @@ export interface IMailboxSyncTarget extends IClrEntity {
 	lastSync?: DateTime | null;
 	lastSyncStatus?: "none" | "success" | "failed" | null;
 	lastSyncError?: string | null;
-	syncLog?: string;
 	/** Set this property to change password */
 	newPassword?: string;
+	syncLog?: string;
 	mailbox?: IMailbox;
 }
 
@@ -586,6 +602,101 @@ export interface ISearchWordIndex extends IClrEntity {
 
 export const SearchWordIndex: IModel<ISearchWordIndex> = new Model<ISearchWordIndex>("SearchWordIndex", ["wordID","fileContentID"], { rank: 0 });
 
+export interface IStore extends IClrEntity {
+	readonly storeID?: number;
+	name?: string;
+	storeUsers?: ICollection<IStoreUser>;
+	storeItems?: ICollection<IStoreItem>;
+	storeOrders?: ICollection<IStoreOrder>;
+	storeWebsites?: ICollection<IWebSiteStore>;
+}
+
+export const Store: IModel<IStore> = new Model<IStore>("Store", ["storeID"], { name: "" });
+
+export interface IStoreUser extends IClrEntity {
+	storeID?: number;
+	userID?: number;
+	store?: IStore;
+	user?: IUser;
+}
+
+export const StoreUser: IModel<IStoreUser> = new Model<IStoreUser>("StoreUser", ["storeID","userID"], {  });
+
+export interface IStoreItem extends IClrEntity {
+	readonly storeItemID?: number;
+	storeID?: number;
+	name?: string;
+	description?: string | null;
+	taxName?: string | null;
+	taxID?: string | null;
+	itemType?: string;
+	store?: IStore;
+	storeItemPrices?: ICollection<IStoreItemPrice>;
+	storeItemTags?: ICollection<IStoreItemTag>;
+}
+
+export const StoreItem: IModel<IStoreItem> = new Model<IStoreItem>("StoreItem", ["storeItemID"], { name: "",itemType: "" });
+
+export interface IStoreItemPrice extends IClrEntity {
+	readonly priceID?: number;
+	storeItemID?: number;
+	startDate?: DateTime;
+	endDate?: DateTime;
+	currency?: string;
+	amount?: number;
+	storeItem?: IStoreItem;
+	storeOrderItems?: ICollection<IStoreOrderItem>;
+}
+
+export const StoreItemPrice: IModel<IStoreItemPrice> = new Model<IStoreItemPrice>("StoreItemPrice", ["priceID"], { startDate: new DefaultFactory(() => new DateTime()),endDate: new DefaultFactory(() => new DateTime()),currency: "",amount: 0 });
+
+export interface IStoreOrder extends IClrEntity {
+	readonly orderID?: number;
+	storeID?: number;
+	customerID?: number | null;
+	externalCustomerID?: string | null;
+	customerTaxID?: string | null;
+	emailAddressID?: number | null;
+	orderNumber?: string;
+	dateCreated?: DateTime;
+	dateUpdated?: DateTime;
+	startDate?: DateTime | null;
+	endDate?: DateTime | null;
+	status?: "new" | "pending" | "paid" | "delivered" | "deleted";
+	store?: IStore;
+	customer?: IUser;
+	storeOrderItems?: ICollection<IStoreOrderItem>;
+}
+
+export const StoreOrderStatusArray = [{"label":"new","value":"new"},{"label":"pending","value":"pending"},{"label":"paid","value":"paid"},{"label":"delivered","value":"delivered"},{"label":"deleted","value":"deleted"}];
+
+export const StoreOrder: IModel<IStoreOrder> = new Model<IStoreOrder>("StoreOrder", ["orderID"], { orderNumber: "",dateCreated: new DefaultFactory(() => new DateTime()),dateUpdated: new DefaultFactory(() => new DateTime()),status: "new" });
+
+export interface IStoreOrderItem extends IClrEntity {
+	readonly orderItemID?: number;
+	orderID?: number;
+	storeItemPriceID?: number;
+	sourceOrderItemID?: number | null;
+	quantity?: number;
+	amount?: number;
+	storeOrder?: IStoreOrder;
+	storeItemPrice?: IStoreItemPrice;
+	source?: IStoreOrderItem;
+	relatedOrderItems?: ICollection<IStoreOrderItem>;
+}
+
+export const StoreOrderItem: IModel<IStoreOrderItem> = new Model<IStoreOrderItem>("StoreOrderItem", ["orderItemID"], { quantity: 0,amount: 0 });
+
+export interface IStoreItemTag extends IClrEntity {
+	storeItemID?: number;
+	tagID?: number;
+	tagValue?: string | null;
+	storeItem?: IStoreItem;
+	tag?: ITag;
+}
+
+export const StoreItemTag: IModel<IStoreItemTag> = new Model<IStoreItemTag>("StoreItemTag", ["storeItemID","tagID"], {  });
+
 export interface IUser extends IClrEntity {
 	readonly userID?: number;
 	userName?: string;
@@ -594,16 +705,23 @@ export interface IUser extends IClrEntity {
 	isExternal?: boolean;
 	readonly multiFactor?: boolean;
 	dateUpdated?: DateTime;
+	readonly storage?: number;
+	maxStorage?: number;
 	/** Save this to change password */
 	changePassword?: { oldPassword?: string;newPassword?: string;forceChangePasswordOnLogin?: boolean };
 	createFolder?: boolean;
+	createWebSite?: boolean;
+	autoEnableMF?: boolean;
 	createdFiles?: ICollection<IAppFile>;
 	sentEmails?: ICollection<IEmail>;
+	accessTokens?: ICollection<IAccessToken>;
 	versions?: ICollection<IAppFileVersion>;
 	sessions?: ICollection<ILoginSession>;
 	fileAccessList?: ICollection<IAppFileAccess>;
 	contacts?: ICollection<IContact>;
 	domainUsers?: ICollection<IDomainUser>;
+	stores?: ICollection<IStoreUser>;
+	storeOrders?: ICollection<IStoreOrder>;
 	pins?: ICollection<IUserPin>;
 	userPushSubscriptions?: ICollection<IUserPushSubscription>;
 	roles?: ICollection<IUserRole>;
@@ -614,7 +732,7 @@ export interface IUser extends IClrEntity {
 
 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"}];
 
-export const User: IModel<IUser> = new Model<IUser>("User", ["userID"], { userName: "",displayName: "",status: "active",isExternal: false,multiFactor: false,dateUpdated: new DefaultFactory(() => new DateTime()) });
+export const User: IModel<IUser> = new Model<IUser>("User", ["userID"], { userName: "",displayName: "",status: "active",isExternal: false,multiFactor: false,dateUpdated: new DefaultFactory(() => new DateTime()),storage: 0,maxStorage: 0 });
 
 export interface IUserPin extends IClrEntity {
 	readonly pinID?: number;
@@ -660,7 +778,7 @@ export const UserMailbox: IModel<IUserMailbox> = new Model<IUserMailbox>("UserMa
 export interface IUserAuthFactor extends IClrEntity {
 	readonly authFactorID?: number;
 	userID?: number;
-	method?: "totp" | "hotp" | "fido2" | "one-time";
+	method?: "totp" | "hotp" | "fido2" | "one-time" | "otp";
 	hint?: string | null;
 	verified?: boolean;
 	dateUpdated?: DateTime;
@@ -670,7 +788,7 @@ export interface IUserAuthFactor extends IClrEntity {
 	user?: IUser;
 }
 
-export const UserAuthFactorMethodArray = [{"label":"totp","value":"totp"},{"label":"hotp","value":"hotp"},{"label":"fido2","value":"fido2"},{"label":"one-time","value":"one-time"}];
+export const UserAuthFactorMethodArray = [{"label":"totp","value":"totp"},{"label":"hotp","value":"hotp"},{"label":"fido2","value":"fido2"},{"label":"one-time","value":"one-time"},{"label":"otp","value":"otp"}];
 
 export const UserAuthFactor: IModel<IUserAuthFactor> = new Model<IUserAuthFactor>("UserAuthFactor", ["authFactorID"], { method: "totp",verified: false,dateUpdated: new DefaultFactory(() => new DateTime()) });
 
@@ -678,15 +796,17 @@ export interface IWebSiteFolder extends IClrEntity {
 	folderID?: number;
 	currentVersionID?: number | null;
 	isStatic?: boolean;
-	isModified?: boolean;
 	isTemplate?: boolean;
+	isModified?: boolean;
+	sourceWebSiteID?: number | null;
 	folder?: IAppFile;
 	hosts?: ICollection<IWebSiteFolderHost>;
 	versions?: ICollection<IWebSiteFolderVersion>;
 	channels?: ICollection<IWebSiteChannel>;
+	websiteStores?: ICollection<IWebSiteStore>;
 }
 
-export const WebSiteFolder: IModel<IWebSiteFolder> = new Model<IWebSiteFolder>("WebSiteFolder", ["folderID"], { isStatic: false,isModified: false });
+export const WebSiteFolder: IModel<IWebSiteFolder> = new Model<IWebSiteFolder>("WebSiteFolder", ["folderID"], { isStatic: false,isTemplate: false,isModified: false });
 
 export interface IWebSiteFolderHost extends IClrEntity {
 	host?: string;
@@ -721,6 +841,15 @@ export interface IWebSiteChannel extends IClrEntity {
 
 export const WebSiteChannel: IModel<IWebSiteChannel> = new Model<IWebSiteChannel>("WebSiteChannel", ["folderID","channelID"], {  });
 
+export interface IWebSiteStore extends IClrEntity {
+	folderID?: number;
+	storeID?: number;
+	website?: IWebSiteFolder;
+	store?: IStore;
+}
+
+export const WebSiteStore: IModel<IWebSiteStore> = new Model<IWebSiteStore>("WebSiteStore", ["folderID","storeID"], {  });
+
 export interface ILoginSession extends IClrEntity {
 	readonly sessionID?: number;
 	userID?: number;
@@ -731,6 +860,7 @@ export interface ILoginSession extends IClrEntity {
 	deviceTokenType?: string | null;
 	userName?: string;
 	checkPassword?: string;
+	passwordIsAccessToken?: boolean;
 	newPassword?: string;
 	/** Multi Factor Auth Token */
 	timeToken?: string;
@@ -762,6 +892,7 @@ export interface ITag extends IClrEntity {
 	fileTags?: ICollection<IAppFileTag>;
 	emailTags?: ICollection<IEmailTag>;
 	mailboxContactTags?: ICollection<IMailboxContactTag>;
+	storeItemTags?: ICollection<IStoreItemTag>;
 }
 
 export const Tag: IModel<ITag> = new Model<ITag>("Tag", ["tagID"], { name: "",isSystemTag: false });

package/src/services/files/LocalFileService.tsx

@@ -186,7 +186,10 @@ export default class LocalFileService extends TaskManager {
         }
 
         if (file.size > 4 * 1024 * 1024) {
-            extra.folder = folder;
+            if (folder) {
+                extra ??= {};
+                extra.folder = folder;
+            }
             return await this.uploadFileParts(file, extra, ct, progress);
         }
 

package/src/services/store/StoreItemService.ts

@@ -0,0 +1,49 @@
+import DISingleton from "@web-atoms/core/dist/di/DISingleton";
+import { Inject } from "@web-atoms/core/dist/di/Inject";
+import EntityService from "../EntityService";
+import { IStoreItem, StoreItem } from "../../model/model";
+import { Sql } from "../../common/Sql";
+
+@DISingleton()
+export default class StoreItemService {
+
+    @Inject
+    entityService: EntityService;
+
+    get(id: any) {
+        return this.entityService.query(StoreItem)
+            .where({ id }, (p) => (x) => x.storeItemID === p.id)
+            .include((x) => [x.storeItemPrices, x.storeItemTags])
+            .firstOrDefault();
+    }
+
+    async list({
+        start = 0,
+        size = 100,
+        search = "",
+        storeID = void 0,
+        cancelToken
+    }) {
+        let q = this.entityService.query(StoreItem)
+            .where({ storeID }, (p) => (x) => x.storeID === p.storeID);
+        if (search) {
+            search = search + "%";
+            q = q.where({ search }, (p) => (x) => Sql.text.iLike(x.name, p.search)
+                || Sql.text.iLike(x.description, p.search));
+        }
+        return q.orderByDescending((x) => x.storeItemID)
+            .toPagedList({
+                start,
+                size,
+                cancelToken
+            });
+    }
+
+    async save(storeItem: IStoreItem) {
+        await this.entityService.save(storeItem, (x) =>
+            x.include((x) => x.storeItemPrices)
+            .include((x) => x.storeItemTags));
+        return storeItem;
+    }
+
+}

package/src/services/store/StoreOrderService.ts

@@ -0,0 +1,57 @@
+import DISingleton from "@web-atoms/core/dist/di/DISingleton";
+import { Inject } from "@web-atoms/core/dist/di/Inject";
+import EntityService from "../EntityService";
+import { IStoreOrder, StoreOrder } from "../../model/model";
+import { Sql } from "../../common/Sql";
+
+@DISingleton()
+export default class StoreOrderService {
+
+    @Inject
+    entityService: EntityService;
+
+    get(orderID) {
+        return this.entityService.query(StoreOrder)
+            .where({ orderID }, (p) => (x) => x.orderID === p.orderID)
+            .include((x) => [
+                x.storeOrderItems.forEach((oi) => [oi.storeItemPrice.storeItem.store]),
+                x.customer
+            ])
+            .firstOrDefault();
+    }
+
+    async list({
+        storeID = void 0,
+        start = 0,
+        size = 100,
+        search = "",
+        cancelToken = void 0
+    }) {
+        let q = this.entityService.query(StoreOrder)
+            .where({ storeID }, (p) => (x) => x.storeID === p.storeID);
+
+        if (search) {
+            search = search + "%";
+            q = q.where({ search }, (p) => (x) => Sql.text.iLike(x.customer.displayName, p.search)
+                || x.storeOrderItems.some((oi) => Sql.text.iLike(oi.storeItemPrice.storeItem.name, p.search))
+            );
+        }
+
+        return q
+            .orderByDescending((x) => x.orderID)
+            .toPagedList({
+                start,
+                size,
+                cancelToken
+            });
+    }
+
+    async save(order: IStoreOrder) {
+        await this.entityService.save(order, (c) => c
+            .include((x) => x.storeOrderItems )
+            .thenInclude((x) => x.relatedOrderItems)
+        );
+        return order;
+    }
+
+}

package/src/services/store/StoreService.ts

@@ -0,0 +1,49 @@
+import DISingleton from "@web-atoms/core/dist/di/DISingleton";
+import { Inject } from "@web-atoms/core/dist/di/Inject";
+import EntityService from "../EntityService";
+import { IStore, Store } from "../../model/model";
+import { Sql } from "../../common/Sql";
+
+@DISingleton()
+export default class StoreService {
+
+    @Inject
+    private entityService: EntityService;
+
+    async get(storeID) {
+        return this.entityService.query(Store)
+            .where({ storeID }, (p) => (x) => x.storeID === p.storeID)
+            .include((x) => [x.storeUsers, x.storeWebsites.forEach((w) => w.website.folder)])
+            .firstOrDefault();
+    }
+
+    async top() {
+        const { items } = await this.stores({ size: 3, cancelToken: null });
+        return items;
+    }
+
+    async stores({
+        search = "",
+        start = 0,
+        size = 100,
+        cancelToken
+    }) {
+        let q = this.entityService.query(Store);
+        if (search) {
+            search = search + "%";
+            q = q.where({ search }, (p) => (x) => Sql.text.like(x.name, p.search));
+        }
+        return q
+            .orderByDescending((x) => x.storeID)
+            .toPagedList({
+                start,
+                size,
+                cancelToken
+            });
+    }
+
+    async save(store: IStore) {
+        await this.entityService.save(store, (x) => x);
+    }
+
+}

package/src/web/drawer/AppDrawer.tsx

@@ -13,6 +13,7 @@ import { toFileSize } from "../../common/NumberFormats";
 import Action from "@web-atoms/core/dist/view-model/Action";
 import CommonCommands from "../../common/commands/CommonCommands";
 import LoginService from "../../services/LoginService";
+import StoreService from "../../services/store/StoreService";
 
 const css = styled.css `
     min-width: 300px;
@@ -49,7 +50,7 @@ export default class AppDrawer extends Drawer {
 
         this.user = SocialMailApp.user;
 
-        const { mailboxes, channels, drives, websites } = await this.getItems();
+        const { mailboxes, channels, drives, websites, stores } = await this.getItems();
 
         this.renderer = <div>
             <div
@@ -128,6 +129,17 @@ export default class AppDrawer extends Drawer {
                         commandLink={AppCommands.openWebSiteList.displayRoute({})}
                     />
                 </ExpanderMenu> }
+                {stores.length && <ExpanderMenu isExpanded={false}>
+                    <MenuItem
+                        icon="fas fa-dollar"
+                        label="Stores"
+                        commandLink={null}
+                        />
+                    { ... stores.map((s) => <MenuItem
+                        label={s.name}
+                        commandLink={AppCommands.editStore.displayRoute({ id: s.storeID})}
+                        />)}
+                </ExpanderMenu>}
                 { mailboxes.length && <MenuItem
                     icon="fas fa-money-check-pen"
                     label="Templates"
@@ -174,13 +186,15 @@ export default class AppDrawer extends Drawer {
     async getItems() {
         const ms = this.resolve(MailboxService);
         const fs = this.resolve(CloudFileService);
-        const [mailboxes, channels, drives, websites] = await Promise.all([
+        const ss = this.resolve(StoreService);
+        const [mailboxes, channels, drives, websites, stores] = await Promise.all([
             ms.top(),
             ms.top({ isChannel: true }),
             fs.top(),
-            fs.top(true)
+            fs.top(true),
+            ss.top()
         ]);
-        return { mailboxes, channels, drives, websites };
+        return { mailboxes, channels, drives, websites, stores };
     }
 
     @Action({ onEvent: "user-logout"})

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

@@ -156,7 +156,7 @@ export default class ChannelDetailPage extends ContentPage {
                     label="Details"
                     />
                 <MenuItem
-                    href={ apiPath(`/api/files/download/${email.originalFileID}`)}
+                    href={ apiPath(`/api/emails/logs//${email.mimeFileID}/${email.emailID}.eml`)}
                     icon="fas fa-download"
                     label="Download"
                     />

package/src/web/page/files/service/CloudFileService.ts

@@ -50,6 +50,7 @@ export default class CloudFileService {
         size = 50,
         search = "",
         version = 1,
+        contentType = void 0 as string,
         cancelToken
     }) {
         const userID = SocialMailApp.user.userID;
@@ -58,6 +59,9 @@ export default class CloudFileService {
         if (search) {
             q = q.where({ search }, (p) => (x) => Sql.text.includes(x.creator.userName, p.search));
         }
+        if (contentType) {
+            q = q.where({ contentType }, (p) => (x) => x.contentType === p.contentType);
+        }
         return q.include((x) => x.creator)
             .orderByDescending({userID} , (p) => (x) => x.userPins.some((s) => p.userID === s.userID))
             .thenByDescending((x) => x.fileSize)

package/src/web/page/mails/service/ConversationService.tsx

@@ -164,7 +164,7 @@ export default class ConversationService {
             q = q.where({ search }, (p) => (x) =>
                 Sql.text.iLike(x.email.subject, p.search)
                 || Sql.text.iLike(x.email.textBody, p.search)
-                || Sql.text.iLike(x.email.originalFile.fileContent.textDocument.searchable, p.search)
+                || x.email.attachments.some((a) => Sql.text.iLike(a.fileContent.textDocument.searchable, p.search))
             );
         }
         const emails = await q

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

@@ -56,14 +56,8 @@ export default class MailService {
     }
 
     async raw(email: IEmail) {
-        const { mimeFileID, originalFileID } = email;
-
-        if (mimeFileID) {
-            return FetchBuilder.get( apiPath(`/api/emails/logs/${mimeFileID}/${email.emailID}.eml`)).responseAsText();
-        }
-
-        const file = await this.entityService.query(AppFile).where({ originalFileID }, (p) => (x) => x.appFileID === p.originalFileID).firstOrDefault();
-        return FetchBuilder.get(file.url).responseAsText();
+        const { mimeFileID } = email;
+        return FetchBuilder.get( apiPath(`/api/emails/logs/${mimeFileID}/${email.emailID}.eml`)).responseAsText();
     }
 
     async send(email: IEmail) {