Phoenix-Staged-Area/server_custom/config.ts

/* tslint:disable:no-console */
import path from 'path';
import { ConnectionOptions } from 'typeorm';
import { RedisSessionCachePlugin, DefaultLogger, LogLevel, TypeOrmLogger, SystemConfig, DefaultJobQueuePlugin, Injector, RequestContext, EmailSettingsService } from '@phoenix/core';
import { AssetServerPlugin } from '@phoenix/asset-server-plugin';
import { ADMIN_API_PATH, API_PORT, API_SSL_PORT, SHOP_API_PATH, SUPER_ADMIN_USER_IDENTIFIER } from '@phoenix/common';
import { EmailPlugin, FileBasedTemplateLoader, defaultEmailHandlers } from '@phoenix/email-plugin';
//import { BonnAPIPlugin } from '../plugins/bonn-api-plugin/bonn-api-plugin.module';
// import { DefaultJobQueuePlugin } from '@phoenix/system_service';

/**
 * Config settings used during development
 */
export const customConfig: SystemConfig = {
    apiOptions: {
        port: API_PORT,
        // sslPort: API_SSL_PORT,
        //sslCertPath: path.join(__dirname, '../secrets/certificate.crt'),
        //sslKeyPath: path.join(__dirname, '../secrets/certificate.key'),
        adminApiPath: ADMIN_API_PATH,
        shopApiPath: SHOP_API_PATH,
        cors: {
            origin: true,
            credentials: true,
        },
    },
    authOptions: {
        disableAuth: true,
        sessionSecret: 'some-secret',
        requireVerification: false,
        tokenMethod: "bearer",
        superadminCredentials: {
            identifier: SUPER_ADMIN_USER_IDENTIFIER,
            password: process.env.SUPER_ADMIN_USER_PASSWORD || 'superadmin'
        }
    },
    dbConnectionOptions: {
        // synchronize: true,
        // logging: true,
        logger: new TypeOrmLogger(),
        ...getDbConfig(),
        // logging: ["error"]
    },
    // paymentOptions: {
    //     // paymentMethodHandlers: [examplePaymentHandler],
    // },
    customFields: {
        Product: [
            {
                name: 'testo',
                type: 'string',
            }
        ],
        DocumentLineItem: [
        ],
        PostProductionDetail: [
        ],
    },
    searchableFields: {
        processResource: [
            "scanId"
        ]
    },
    logger: new DefaultLogger({ level: LogLevel.Debug }),
    //importExportOptions: {
    //    importProductAssetsDir: path.join(__dirname, 'import', 'product-assets'),
    //},
    defaults: {
        defaultTakeNumber: 100,
    },
    plugins: [
        RedisSessionCachePlugin.init({
            namespace: 'phx-session',
            redisOptions: {
                host: process.env.REDIS_HOST || 'redis',
                port: process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT) : 6379,
                db: process.env.REDIS_DB ? parseInt(process.env.REDIS_DB) : 0,
                password: process.env.REDIS_PASSWORD || 'admin'
            }
        }),
        AssetServerPlugin.init({
            route: 'remote-assets',
            assetUploadDir: path.join(__dirname, 'assets'),
            port: 5002,
            assetUrlPrefix: "\\remote-assets\\" //  to make it relative for client
        }),
        DefaultJobQueuePlugin.init({}),
        EmailPlugin.init({
            sendRealEmails: true,
            route: 'mailbox',
            handlers: [...defaultEmailHandlers],
            // Dynamic Email Templates
            templateLoader: new FileBasedTemplateLoader(path.join(__dirname, '..', '../email-plugin/templates')),
            globalTemplateVars: {
                verifyEmailAddressUrl: 'http://localhost:4201/verify',
                passwordResetUrl: 'http://localhost:4201/reset-password',
                changeEmailAddressUrl: 'http://localhost:4201/change-email-address',
            },
            transport: async (injector: Injector, ctx?: RequestContext) => {
                let res = await injector.get(EmailSettingsService).getFallbackEmailSettings(ctx);
                console.warn("SMTP Settings: ", res);
                return {
                    name: res.smtpName,
                    host: res.smtpHost,
                    port: res.smtpPort,
                    auth: {
                        user: res.smtpUser,
                        pass: res.smtpPass,
                    },
                    secure: res.smtpSecure,
                    type: 'smtp',
                    tls: {
                        rejectUnauthorized: res.smtpTls
                    },
                    ignoreTLS: true
                }
            },
        }),
        // DefaultStoragePlaceRankPlugin.init({})
        // new DefaultSearchPlugin(),
        // new ElasticsearchPlugin({
        //     host: 'http://192.168.99.100',
        //     port: 9200,
        // }),
        // DocusignPlugin.init({
        //     devMode:true,
        //     handlers: defaultDocusignHandlers,
        //     assetDownloadDir:  path.join(__dirname, 'docusign'),
        //     assetUploadDir:  path.join(__dirname, 'docusign'),
        //     port: API_PORT,
        //     route: "docusign"
        // }),
        // new AdminUiPlugin({
        //     port: 5001,
        // }),
    ],
    // ApolloEngineApiKey: "service:Logic-Bits-2900:5w1aCP5YUtF-1ErRG0KNQw"
};

function getDbConfig(): ConnectionOptions {
    const dbType = process.env.DB || 'postgres';
    const dbHost = process.env.DB_HOST || 'localhost';
    const dbPort = +process.env.DB_PORT || 5432;

    const connectionPoolMax = process.env.CONNECTION_POOL_MAX ?? 20;

    const dbUsername = process.env.DB_USERNAME || 'postgres';
    const password = process.env.DB_PASSWORD || 'admin';
    const database = process.env.DB_NAME || 'phoenix'

    if (password == "admin")
        console.warn("default postgres password is used!");

    if (process.env.DB_HOST)
        console.log(`using DB Host ${dbHost} from env`);

    console.log(`using Database ${database}`);
    console.log(`using User ${dbUsername}`);

    switch (dbType) {
        case 'postgres':
            console.log('Using postgres connection at ' + dbHost);
            return {
                synchronize: true,
                type: 'postgres',
                //host: '127.0.0.1',
                host: dbHost,
                port: dbPort,
                username: dbUsername,
                password: password,
                database: database,
                // logging: "all",
                extra: {
                    max: connectionPoolMax
                }
            };
        case 'sqlite':
            console.log('Using sqlite connection');
            return {
                type: 'sqlite',
                database: path.join(__dirname, 'phoenix.sqlite'),
            };
        case 'sqljs':
            console.log('Using sql.js connection');
            return {
                type: 'sqljs',
                autoSave: true,
                database: new Uint8Array([]),
                location: path.join(__dirname, 'phoenix.sqlite'),
            };
        case 'mysql':
        default:
            console.log('Using mysql connection');
            return {
                synchronize: true,
                type: 'mysql',
                host: '192.168.99.100',
                port: 3306,
                username: 'root',
                password: '',
                database: 'phoenix-dev',
            };
    }
}