jitz-sharepoint-utilities 1.11.2 → 2.0.0

package/data/context/CommonRepository.ts

@@ -0,0 +1,287 @@
+import { ICommonRepository } from "../interfaces/ICommonRepository";
+import IJitzSPContext from "../interfaces/IJitzSPContext";
+import { IEmail } from "../interfaces/IModels";
+
+export default class CommonRepository implements ICommonRepository {
+  public context: IJitzSPContext;
+
+  constructor(context: IJitzSPContext) {
+    this.context = context;
+  }
+
+  public sendEmail(email: IEmail): Promise<boolean> {
+    email.properties.__metadata = {
+      type: "SP.Utilities.EmailProperties",
+    };
+    // console.log(JSON.stringify(email.properties));
+    var requestUrl = `${this.context.siteUrl}/_api/SP.Utilities.Utility.SendEmail`;
+    return this.context.client
+      .post(requestUrl, email, {
+        Accept: "application/json;odata=nometadata",
+        "Content-type": "application/json;odata=verbose",
+        "odata-version": "",
+      })
+      .then((response: any): Promise<boolean> => {
+        if (response.status >= 200 && response.status < 300) {
+          var json = response;
+          return json;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      });
+  }
+
+  public getData(
+    listName: string,
+    selectFields?: string,
+    expand?: string,
+    filters?: string,
+    orderBy?: string,
+    top?: number,
+    skipTokenUniqueField?: string,
+    skipTokenUniqueFieldValue?: string
+  ): Promise<any> {
+    let queryUrlGetAllItems: string =
+      `/_api/web/lists/GetByTitle('` + listName + `')/items`;
+
+    if (selectFields != null && selectFields != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=` + selectFields;
+    } else {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=*`;
+    }
+    if (expand != null && expand != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$expand=` + expand;
+    }
+    if (top != null && top != undefined && top > 0) {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$top=` + top;
+    }
+    if (filters != null && filters != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$filter=` + filters;
+    }
+    if (orderBy != null && orderBy != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$orderby=` + orderBy;
+    }
+    if (
+      skipTokenUniqueField != null &&
+      skipTokenUniqueField != undefined &&
+      skipTokenUniqueFieldValue != null &&
+      skipTokenUniqueFieldValue != undefined
+    ) {
+      if (skipTokenUniqueField == "Id" || skipTokenUniqueField == "id") {
+        skipTokenUniqueField = "ID";
+      }
+      queryUrlGetAllItems =
+        queryUrlGetAllItems +
+        `&$skiptoken=Paged=TRUE%26p_${skipTokenUniqueField}=${skipTokenUniqueFieldValue}`;
+    }
+
+    return this.context.client
+      .get(queryUrlGetAllItems)
+      .then((response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return response.data.d;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      })
+      .then((data: any) => {
+        return data;
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public get(url: string): Promise<any> {
+    return this.context.client
+      .get(url)
+      .then((response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return response.data.d;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      })
+      .then((data: any) => {
+        return data;
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public post(url: string, data: any, header?: any): Promise<any> {
+    return this.context.client
+      .post(url, data, header)
+      .then((response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return response.data;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      })
+      .then((data: any) => {
+        return data;
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public getFiles(
+    libraryName: string,
+    selectFields: string,
+    filter: string,
+    expandFields: string
+  ): Promise<any> {
+    let url: string = `/_api/web/lists/getbytitle('${libraryName}')/Items?$select=*,File/Name,File/ServerRelativeUrl`;
+    if (selectFields != undefined && selectFields.length > 0) {
+      url = `${url},${selectFields}`;
+    }
+    if (filter != undefined && filter.length > 0) {
+      url = `${url}&$filter=${filter}`;
+    }
+    url = `${url}&$expand=File`;
+    if (expandFields != undefined && expandFields.length > 0) {
+      url = `${url},${expandFields}`;
+    }
+    return this.context.client.get(url).then((response: any) => {
+      if (response.status >= 200 && response.status <= 300) {
+        var json = response.data.d.results;
+        return json;
+      } else {
+        return Promise.reject(new Error(JSON.stringify(response)));
+      }
+    });
+  }
+
+  public uploadFile(
+    libraryName: string,
+    fileName: string,
+    arrayBuffer: ArrayBuffer
+  ): Promise<any> {
+    return this.context.client
+      .postWithOutStringify(
+        `/_api/Web/Lists/getByTitle('${libraryName}')/RootFolder/Files/Add(url='${fileName}', overwrite=true)`,
+        arrayBuffer,
+        {
+          Accept: "application/json;odata=verbose",
+          "content-length": arrayBuffer.byteLength.toString(),
+        }
+      )
+      .then((response: any) => {
+        if (response.status >= 200 && response.status <= 300) {
+          var json = response.data.d;
+          return json;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      });
+  }
+
+  public getFileItem(libraryName: string, fileUrl: string): Promise<any> {
+    // `${this._webAbsoluteUrl}/_api/web/GetFileByServerRelativeUrl('${fileUrl}')/$value`
+    return this.context.client
+      .get(
+        `/_api/web/lists/getbytitle('${libraryName}')/Items?$filter=FileLeafRef eq '${fileUrl}'&$select=Id`
+      )
+      .then((response: any) => {
+        if (response.status >= 200 && response.status <= 300) {
+          var json = response.data.d;
+          return json;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      });
+  }
+
+  public async updateMetadata(listName: string, item: any): Promise<any> {
+    var item = await this.getEntityType(listName).then((entityType) => {
+      item.__metadata = {
+        //etag: "1",
+        type: entityType,
+      };
+      var requestUrl = `_api/web/lists/getbytitle('${listName}')/items(${item.Id})`;
+      return this.context.client
+        .post(requestUrl, item, {
+          Accept: "application/json;odata=nometadata",
+          "Content-type": "application/json;odata=verbose",
+          "odata-version": "",
+          "IF-MATCH": "*",
+          "X-HTTP-Method": "MERGE",
+        })
+        .then((response: any) => {
+          if (response.status >= 200 && response.status < 300) {
+            return item;
+          } else {
+            console.log(JSON.stringify(response));
+            return Promise.reject(new Error(JSON.stringify(response)));
+          }
+        });
+    });
+
+    let url: string = `/_api/web/lists/getbytitle('${listName}')/items(${item.Id})?$select=*,File/Name,File/ServerRelativeUrl&$expand=File`;
+    return this.context.client.get(url).then((response: any) => {
+      if (response.status >= 200 && response.status <= 300) {
+        var json = response.data.d;
+        return json;
+      } else {
+        return Promise.reject(new Error(JSON.stringify(response)));
+      }
+    });
+  }
+
+  public deleteFile(listName: string, id: number): Promise<boolean> {
+    var requestUrl = `_api/web/lists/getbytitle('${listName}')/items(${id})`;
+    return this.context.client
+      .post(
+        requestUrl,
+        {},
+        {
+          Accept: "application/json;odata=nometadata",
+          "Content-type": "application/json;odata=verbose",
+          "odata-version": "",
+          "IF-MATCH": "*",
+          "X-HTTP-Method": "DELETE",
+        }
+      )
+      .then((response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return true;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      });
+  }
+
+  private getEntityType(listName: string): Promise<string> {
+    return new Promise<string>(
+      (
+        resolve: (listItemEntityTypeName: string) => void,
+        reject: (error: any) => void
+      ): void => {
+        this.context.client
+          .get(
+            `_api/web/lists/getbytitle('${listName}')?$select=ListItemEntityTypeFullName`
+          )
+          .then(
+            (
+              response: any
+            ): Promise<{ ListItemEntityTypeFullName: string }> => {
+              return response;
+            },
+            (error: any): void => {
+              reject(error);
+            }
+          )
+          .then((response: any): void => {
+            var _listEntityType = response.data.d.ListItemEntityTypeFullName;
+            resolve(_listEntityType || "");
+          });
+      }
+    );
+  }
+}

package/data/context/JitzContext.ts

@@ -0,0 +1,33 @@
+import { WebPartContext } from "@microsoft/sp-webpart-base";
+import { MSGraphClientV3 } from "@microsoft/sp-http";
+import IJitzContext from "../interfaces/IJitzContext";
+import IJitzSPContext from "../interfaces/IJitzSPContext";
+import JitzSPContext from "./JitzSPContext";
+
+export default class JitzContext implements IJitzContext {
+  spContext: IJitzSPContext;
+  webpartContext: WebPartContext;
+  graphClient: MSGraphClientV3;
+  siteId: string;
+
+  constructor(webpartContext: WebPartContext) {
+    this.spContext = new JitzSPContext(
+      webpartContext.pageContext.site.absoluteUrl
+    );
+    this.webpartContext = webpartContext;
+    this.siteId = this.webpartContext.pageContext.site.id.toString();
+  }
+
+  public async init() {
+    await this.spContext.init();
+    await this.initGraphClient();
+  }
+
+  private async initGraphClient() {
+    await this.webpartContext.msGraphClientFactory
+      .getClient("3") // Init Microsoft Graph Client
+      .then((client: MSGraphClientV3) => {
+        this.graphClient = client;
+      });
+  }
+}

package/data/context/JitzSPContext.ts

@@ -0,0 +1,16 @@
+import IJitzSPContext from "../interfaces/IJitzSPContext";
+import IJitzSPHttpClient from "../interfaces/IJitzSPHttpClient";
+import JitzSPHttpClient from "./JitzSPHttpClient";
+
+export default class JitzSPContext implements IJitzSPContext {
+  public client: IJitzSPHttpClient;
+  public siteUrl: string;
+
+  constructor(siteUrl: string) {
+    this.siteUrl = siteUrl;
+    this.client = new JitzSPHttpClient(siteUrl);
+  }
+  public init = async () => {
+    await this.client.init();
+  };
+}

package/data/context/JitzSPHttpClient.ts

@@ -0,0 +1,133 @@
+import axios from "axios";
+import IJitzSPHttpClient from "../interfaces/IJitzSPHttpClient";
+
+export default class JitzSPHttpClient implements IJitzSPHttpClient {
+  public siteUrl: string;
+  public client: any;
+  public securityToken: string = "";
+  private header: any = {
+    Accept: "application/json;odata=verbose",
+    "Content-Type": "application/json;odata=verbose",
+  };
+
+  constructor(siteUrl: string = "") {
+    this.siteUrl = siteUrl;
+    this.securityToken = "";
+    this.client = axios.create({
+      baseURL: this.siteUrl,
+    });
+  }
+
+  public init = async () => {
+    await this.refreshSecurityValidation();
+  };
+
+  public get = (url: string, header?: any) => {
+    header = header || this.header;
+    header["X-RequestDigest"] = this.securityToken;
+    var authOptions = {
+      method: "GET",
+      url: url,
+      data: JSON.stringify({}),
+      headers: header,
+      json: true,
+    };
+
+    return this.client(authOptions);
+
+    // return this.getSecurityValidation().then((ctx: any) => {
+    //   this.securityToken = ctx.data.d.GetContextWebInformation.FormDigestValue;
+    //   header["X-RequestDigest"] = this.securityToken;
+    //   var authOptions = {
+    //     method: "GET",
+    //     url: url,
+    //     data: JSON.stringify({}),
+    //     headers: header,
+    //     json: true,
+    //   };
+
+    //   return this.client(authOptions);
+    // });
+  };
+
+  public post = (url: string, data: any, header?: any) => {
+    header = header || this.header;
+    header["X-RequestDigest"] = this.securityToken;
+    header["Accept"] = "application/json;odata=verbose";
+    header["Content-Type"] = "application/json;odata=verbose";
+    var authOptions = {
+      method: "POST",
+      url: url,
+      data: JSON.stringify(data),
+      headers: header,
+      json: true,
+    };
+
+    return this.client(authOptions);
+
+    // return this.getSecurityValidation().then((ctx: any) => {
+    //   this.securityToken = ctx.data.d.GetContextWebInformation.FormDigestValue;
+    //   header["X-RequestDigest"] = this.securityToken;
+    //   var authOptions = {
+    //     method: "POST",
+    //     url: url,
+    //     data: JSON.stringify(data),
+    //     headers: header,
+    //     json: true,
+    //   };
+
+    //   return this.client(authOptions);
+    // });
+  };
+
+  public postWithOutStringify = (url: string, data: any, header?: any) => {
+    header = header || this.header;
+    header["X-RequestDigest"] = this.securityToken;
+    var authOptions = {
+      method: "POST",
+      url: url,
+      data: data,
+      headers: header,
+      json: true,
+    };
+
+    return this.client(authOptions);
+  };
+
+  public getSecurityValidation = () => {
+    var authOptions = {
+      method: "POST",
+      url: "/_api/contextinfo",
+      data: JSON.stringify({}),
+      headers: {
+        Accept: "application/json;odata=verbose",
+        "Content-Type": "application/json;odata=verbose",
+      },
+      json: true,
+    };
+    return this.client(authOptions);
+  };
+
+  public refreshSecurityValidation = async () => {
+    var authOptions = {
+      method: "POST",
+      url: "/_api/contextinfo",
+      data: JSON.stringify({}),
+      headers: {
+        Accept: "application/json;odata=verbose",
+        "Content-Type": "application/json;odata=verbose",
+      },
+      json: true,
+    };
+
+    await this.client(authOptions).then((context: any) => {
+      this.securityToken =
+        context.data.d.GetContextWebInformation.FormDigestValue;
+      // console.log("Token:- "+this.securityToken);
+      var interval = setInterval(() => {
+        this.refreshSecurityValidation();
+        clearInterval(interval);
+      }, 600000); //300000
+    });
+  };
+}