resolves aspnetboilerplate/aspnetboilerplate#6627

Author: ismcagdas

angular/src/app-initializer.ts

@@ -6,6 +6,8 @@ import { filter as _filter, merge as _merge } from 'lodash-es';
 import { AppConsts } from '@shared/AppConsts';
 import { AppSessionService } from '@shared/session/app-session.service';
 import { environment } from './environments/environment';
+import { AccountServiceProxy, IsTenantAvailableInput, IsTenantAvailableOutput, TenantAvailabilityState } from '@shared/service-proxies/service-proxies';
+import { SubdomainTenantResolver } from '@shared/multi-tenancy/tenant-resolvers/subdomain-tenant-resolver';
 
 @Injectable({
   providedIn: 'root',
@@ -164,7 +166,40 @@ export class AppInitializer {
         AppConsts.remoteServiceBaseUrl = response.remoteServiceBaseUrl;
         AppConsts.localeMappings = response.localeMappings;
 
-        callback();
+        // Find tenant from subdomain
+        var tenancyName = this.resolveTenancyName(response.appBaseUrl);
+
+        if (tenancyName == null) {
+          callback();
+        } else {
+          this.ConfigureTenantIdCookie(tenancyName, callback);
+        }
       });
   }
+
+  private ConfigureTenantIdCookie(tenancyName: string, callback: () => void) {
+    let accountServiceProxy: AccountServiceProxy = this._injector.get(AccountServiceProxy);
+    let input = new IsTenantAvailableInput();
+    input.tenancyName = tenancyName;
+
+    accountServiceProxy.isTenantAvailable(input).subscribe((result: IsTenantAvailableOutput) => {
+      if (result.state === TenantAvailabilityState._1) { // Available
+        abp.multiTenancy.setTenantIdCookie(result.tenantId);
+      }
+
+      callback();
+    });
+  }
+
+  private resolveTenancyName(appBaseUrl): string | null {
+    var subdomainTenantResolver = new SubdomainTenantResolver();
+    var tenancyName = subdomainTenantResolver.resolve(appBaseUrl);
+    if (tenancyName) {
+      return tenancyName;
+    }
+
+    // add other tenancy resolvers here, ex: CookieTenantResolver, QueryStringTenantResolver etc...
+
+    return null;
+  }
 }

angular/src/shared/AppConsts.ts

@@ -1,5 +1,7 @@
 export class AppConsts {
 
+    static readonly tenancyNamePlaceHolderInUrl = '{TENANCY_NAME}';
+
     static remoteServiceBaseUrl: string;
     static appBaseUrl: string;
     static appBaseHref: string; // returns angular's base-href parameter value if used during the publish

angular/src/shared/helpers/FormattedStringValueExtracter.ts

@@ -0,0 +1,155 @@
+class ExtractionResult {
+    public IsMatch: boolean;
+    public Matches: any[];
+
+    constructor(isMatch: boolean) {
+        this.IsMatch = isMatch;
+        this.Matches = [];
+    }
+}
+
+enum FormatStringTokenType {
+    ConstantText,
+    DynamicValue,
+}
+
+class FormatStringToken {
+    public Text: string;
+
+    public Type: FormatStringTokenType;
+
+    constructor(text: string, type: FormatStringTokenType) {
+        this.Text = text;
+        this.Type = type;
+    }
+}
+
+class FormatStringTokenizer {
+    Tokenize(format: string, includeBracketsForDynamicValues: boolean = false): FormatStringToken[] {
+        const tokens: FormatStringToken[] = [];
+
+        let currentText = '';
+        let inDynamicValue = false;
+
+        for (let i = 0; i < format.length; i++) {
+            const c = format[i];
+            switch (c) {
+                case '{':
+                    if (inDynamicValue) {
+                        throw new Error(
+                            'Incorrect syntax at char ' +
+                            i +
+                            '! format string can not contain nested dynamic value expression!'
+                        );
+                    }
+
+                    inDynamicValue = true;
+
+                    if (currentText.length > 0) {
+                        tokens.push(new FormatStringToken(currentText, FormatStringTokenType.ConstantText));
+                        currentText = '';
+                    }
+
+                    break;
+                case '}':
+                    if (!inDynamicValue) {
+                        throw new Error(
+                            'Incorrect syntax at char ' +
+                            i +
+                            '! These is no opening brackets for the closing bracket }.'
+                        );
+                    }
+
+                    inDynamicValue = false;
+
+                    if (currentText.length <= 0) {
+                        throw new Error('Incorrect syntax at char ' + i + '! Brackets does not containt any chars.');
+                    }
+
+                    let dynamicValue = currentText;
+                    if (includeBracketsForDynamicValues) {
+                        dynamicValue = '{' + dynamicValue + '}';
+                    }
+
+                    tokens.push(new FormatStringToken(dynamicValue, FormatStringTokenType.DynamicValue));
+                    currentText = '';
+
+                    break;
+                default:
+                    currentText += c;
+                    break;
+            }
+        }
+
+        if (inDynamicValue) {
+            throw new Error('There is no closing } char for an opened { char.');
+        }
+
+        if (currentText.length > 0) {
+            tokens.push(new FormatStringToken(currentText, FormatStringTokenType.ConstantText));
+        }
+
+        return tokens;
+    }
+}
+
+export class FormattedStringValueExtracter {
+    Extract(str: string, format: string): ExtractionResult {
+        if (str === format) {
+            return new ExtractionResult(true);
+        }
+
+        const formatTokens = new FormatStringTokenizer().Tokenize(format);
+        if (!formatTokens) {
+            return new ExtractionResult(str === '');
+        }
+
+        const result = new ExtractionResult(true);
+
+        for (let i = 0; i < formatTokens.length; i++) {
+            const currentToken = formatTokens[i];
+            const previousToken = i > 0 ? formatTokens[i - 1] : null;
+
+            if (currentToken.Type === FormatStringTokenType.ConstantText) {
+                if (i === 0) {
+                    if (str.indexOf(currentToken.Text) !== 0) {
+                        result.IsMatch = false;
+                        return result;
+                    }
+
+                    str = str.substr(currentToken.Text.length, str.length - currentToken.Text.length);
+                } else {
+                    const matchIndex = str.indexOf(currentToken.Text);
+                    if (matchIndex < 0) {
+                        result.IsMatch = false;
+                        return result;
+                    }
+
+                    result.Matches.push({ name: previousToken?.Text, value: str.substr(0, matchIndex) });
+                    str = str.substring(0, matchIndex + currentToken.Text.length);
+                }
+            }
+        }
+
+        const lastToken = formatTokens[formatTokens.length - 1];
+        if (lastToken.Type === FormatStringTokenType.DynamicValue) {
+            result.Matches.push({ name: lastToken.Text, value: str });
+        }
+
+        return result;
+    }
+
+    IsMatch(str: string, format: string): string[] {
+        const result = new FormattedStringValueExtracter().Extract(str, format);
+        if (!result.IsMatch) {
+            return [];
+        }
+
+        const values: any[] = [];
+        for (let i = 0; i < result.Matches.length; i++) {
+            values.push(result.Matches[i].value);
+        }
+
+        return values;
+    }
+}

angular/src/shared/helpers/SubdomainTenancyNameFinder.ts

@@ -0,0 +1,25 @@
+import { AppConsts } from '@shared/AppConsts';
+import { FormattedStringValueExtracter } from '@shared/helpers/FormattedStringValueExtracter';
+
+export class SubdomainTenancyNameFinder {
+    urlHasTenancyNamePlaceholder(url: string): boolean {
+        return url.indexOf(AppConsts.tenancyNamePlaceHolderInUrl) >= 0;
+    }
+
+    getCurrentTenancyNameOrNull(rootAddress: string): string | null {
+        if (rootAddress.indexOf(AppConsts.tenancyNamePlaceHolderInUrl) < 0) {
+            // Web site does not support subdomain tenant name
+            return null;
+        }
+
+        const currentRootAddress = document.location.href;
+
+        const formattedStringValueExtracter = new FormattedStringValueExtracter();
+        const values: any[] = formattedStringValueExtracter.IsMatch(currentRootAddress, rootAddress);
+        if (!values.length) {
+            return null;
+        }
+
+        return values[0];
+    }
+}

angular/src/shared/multi-tenancy/tenant-resolvers/subdomain-tenant-resolver.ts

@@ -0,0 +1,10 @@
+import { SubdomainTenancyNameFinder } from '@shared/helpers/SubdomainTenancyNameFinder';
+
+export class SubdomainTenantResolver {
+
+    resolve(appBaseUrl): string {
+        const subdomainTenancyNameFinder = new SubdomainTenancyNameFinder();
+        return subdomainTenancyNameFinder.getCurrentTenancyNameOrNull(appBaseUrl);
+    }
+
+}