- remove some awaits

- add try catch
- small refactoring

e2e/utilities/repo-client/apis/sites/sites-api.ts

@@ -30,144 +30,210 @@ import { Utils } from '../../../../utilities/utils';
 import { SitesApi as AdfSiteApi } from '@alfresco/js-api';
 
 export class SitesApi extends RepoApi {
-    sitesApi = new AdfSiteApi(this.alfrescoJsApi);
+  sitesApi = new AdfSiteApi(this.alfrescoJsApi);
 
-    constructor(username?, password?) {
-        super(username, password);
+  constructor(username?, password?) {
+    super(username, password);
+  }
+
+  async getSite(siteId: string) {
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.getSite(siteId);
+    } catch (error) {
+      console.log('--- sites api getSite catch error: ', error);
+      return null;
     }
+  }
 
-    async getSite(siteId: string) {
-        await this.apiAuth();
-        return await this.sitesApi.getSite(siteId);
+  async getSites() {
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.listSiteMembershipsForPerson(this.getUsername());
+    } catch (error) {
+      console.log('--- sites api getSites catch error: ', error);
+      return null;
     }
+  }
 
-    async getSites() {
-        await this.apiAuth();
-        return await this.sitesApi.listSiteMembershipsForPerson(this.getUsername());
+  async getDocLibId(siteId: string) {
+    try {
+      await this.apiAuth();
+      return (await this.sitesApi.listSiteContainers(siteId)).list.entries[0].entry.id;
+    } catch (error) {
+      console.log('--- sites api getDocLibId catch error: ', error);
+      return null;
     }
+  }
 
-    async getDocLibId(siteId: string) {
-        await this.apiAuth();
-        return (await this.sitesApi.listSiteContainers(siteId)).list.entries[0].entry.id;
+  async getVisibility(siteId: string) {
+    try {
+      const site = await this.getSite(siteId);
+      return site.entry.visibility;
+    } catch (error) {
+      console.log('--- sites api getVisibility catch error: ', error);
+      return null;
     }
+  }
 
-    async getVisibility(siteId: string) {
-        const site = await this.getSite(siteId);
-        return site.entry.visibility;
-    }
-
-    async getDescription(siteId: string) {
+  async getDescription(siteId: string) {
+    try {
       const site = await this.getSite(siteId);
       return site.entry.description;
+    } catch (error) {
+      console.log('--- sites api getDescription catch error: ', error);
+      return null;
     }
+  }
 
-    async getTitle(siteId: string) {
+  async getTitle(siteId: string) {
+    try {
       const site = await this.getSite(siteId);
       return site.entry.title;
+    } catch (error) {
+      console.log('--- sites api getTitle catch error: ', error);
+      return null;
     }
+  }
 
-    async createSite(title: string, visibility?: string, description?: string, siteId?: string): Promise<SiteEntry|null> {
-        const site = <SiteBody>{
-            title,
-            visibility: visibility || SITE_VISIBILITY.PUBLIC,
-            description: description,
-            id: siteId || title
-        };
+  async createSite(title: string, visibility?: string, description?: string, siteId?: string): Promise<SiteEntry|null> {
+    const site = <SiteBody>{
+        title,
+        visibility: visibility || SITE_VISIBILITY.PUBLIC,
+        description: description,
+        id: siteId || title
+    };
 
-        try {
-          await this.apiAuth();
-        return await this.sitesApi.createSite(site);
-        } catch (error) {
-          console.log('=== create site catch: ', error);
-          return null;
-        }
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.createSite(site);
+    } catch (error) {
+      console.log('--- sites api createSite catch error: ', error);
+      return null;
     }
+  }
 
-   async createSites(titles: string[], visibility?: string) {
-        return titles.reduce(async (previous: any, current: any) => {
-            await previous;
-            return await this.createSite(current, visibility);
-        }, Promise.resolve());
+  async createSites(titles: string[], visibility?: string) {
+    try {
+      return titles.reduce(async (previous: any, current: any) => {
+        await previous;
+        return await this.createSite(current, visibility);
+      }, Promise.resolve());
+    } catch (error) {
+      console.log('--- sites api createSites catch error: ', error);
     }
+  }
 
-    async deleteSite(siteId: string, permanent: boolean = true) {
-        await this.apiAuth();
-        return await this.sitesApi.deleteSite(siteId, { permanent });
+  async deleteSite(siteId: string, permanent: boolean = true) {
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.deleteSite(siteId, { permanent });
+    } catch (error) {
+      console.log('--- sites api deleteSite catch error: ', error);
     }
+  }
 
-    async deleteSites(siteIds: string[], permanent: boolean = true) {
-        return siteIds.reduce(async (previous, current) => {
-            await previous;
-            return await this.deleteSite(current, permanent);
-        }, Promise.resolve());
+  async deleteSites(siteIds: string[], permanent: boolean = true) {
+    try {
+      return siteIds.reduce(async (previous, current) => {
+        await previous;
+        return await this.deleteSite(current, permanent);
+      }, Promise.resolve());
+    } catch (error) {
+      console.log('--- sites api deleteSites catch error: ', error);
     }
+  }
 
-    async deleteAllUserSites(permanent: boolean = true) {
+  async deleteAllUserSites(permanent: boolean = true) {
+    try {
       const siteIds = (await this.getSites()).list.entries.map(entries => entries.entry.id);
 
       return await siteIds.reduce(async (previous, current) => {
         await previous;
         return await this.deleteSite(current, permanent);
       }, Promise.resolve());
+    } catch (error) {
+      console.log('--- sites api deleteAllUserSites catch error: ', error);
     }
+  }
 
-    async updateSiteMember(siteId: string, userId: string, role: string) {
-        const siteRole = <SiteMemberRoleBody>{
-            role: role
-        };
+  async updateSiteMember(siteId: string, userId: string, role: string) {
+    const siteRole = <SiteMemberRoleBody>{
+        role: role
+    };
 
-        await this.apiAuth();
-        return await this.sitesApi.updateSiteMembership(siteId, userId, siteRole);
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.updateSiteMembership(siteId, userId, siteRole);
+    } catch (error) {
+      console.log('--- sites api updateSiteMember catch error: ', error);
+      return null;
     }
+  }
 
-    async addSiteMember(siteId: string, userId: string, role: string) {
-        const memberBody = <SiteMemberBody>{
-            id: userId,
-            role: role
-        };
+  async addSiteMember(siteId: string, userId: string, role: string) {
+    const memberBody = <SiteMemberBody>{
+        id: userId,
+        role: role
+    };
 
-        await this.apiAuth();
-        return await this.sitesApi.createSiteMembership(siteId, memberBody);
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.createSiteMembership(siteId, memberBody);
+    } catch (error) {
+      console.log('--- sites api addSiteMember catch error: ', error);
+      return null;
     }
+  }
 
-    async deleteSiteMember(siteId: string, userId: string) {
-        await this.apiAuth();
-        return await this.sitesApi.deleteSiteMembership(siteId, userId);
+  async deleteSiteMember(siteId: string, userId: string) {
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.deleteSiteMembership(siteId, userId);
+    } catch (error) {
+      console.log('--- sites api deleteSiteMember catch error: ', error);
     }
+  }
 
-    async requestToJoin(siteId: string): Promise<SiteMembershipRequestEntry|null> {
-        const body = {
-          id: siteId
-        };
-        await this.apiAuth();
-        try {
-          return await this.sitesApi.createSiteMembershipRequestForPerson('-me-', body);
-        } catch (error) {
-          console.log('====== requestToJoin catch ', error);
-          return null;
-        };
-    }
+  async requestToJoin(siteId: string): Promise<SiteMembershipRequestEntry|null> {
+    const body = {
+      id: siteId
+    };
 
-    async hasMembershipRequest(siteId: string) {
+    try {
+      await this.apiAuth();
+      return await this.sitesApi.createSiteMembershipRequestForPerson('-me-', body);
+    } catch (error) {
+      console.log('--- sites api requestToJoin catch error: ', error);
+      return null;
+    };
+  }
+
+  async hasMembershipRequest(siteId: string) {
+    try {
       await this.apiAuth();
       const requests = (await this.sitesApi.getSiteMembershipRequests('-me-')).list.entries.map(e => e.entry.id);
       return requests.includes(siteId);
+    } catch (error) {
+      console.log('--- sites api hasMembershipRequest catch error: ', error);
+      return null;
     }
+  }
 
-    async waitForApi(data) {
-        try {
-          const sites = async () => {
-            const totalItems = (await this.getSites()).list.pagination.totalItems;
-            if ( totalItems !== data.expect ) {
-                return Promise.reject(totalItems);
-            } else {
-                return Promise.resolve(totalItems);
-            }
-        };
-
-        return await Utils.retryCall(sites);
-        } catch (error) {
-          console.log('-----> catch sites: ', error);
+  async waitForApi(data: { expect: number }) {
+    try {
+      const sites = async () => {
+        const totalItems = (await this.getSites()).list.pagination.totalItems;
+        if ( totalItems !== data.expect ) {
+            return Promise.reject(totalItems);
+        } else {
+            return Promise.resolve(totalItems);
         }
+      };
+
+      return await Utils.retryCall(sites);
+    } catch (error) {
+      console.log('sites api waitForApi catch error: ', error);
     }
+  }
 }