jitz-sharepoint-utilities 1.11.3 → 2.0.1

package/data/context/Repository.ts

@@ -0,0 +1,395 @@
+import IJitzSPContext from "../interfaces/IJitzSPContext";
+import { IListItemsMetadata, IModel } from "../interfaces/IModels";
+import { IRepository } from "../interfaces/IRepository";
+
+export default class Repository<T extends IModel> implements IRepository<T> {
+  private _listEntityType?: string;
+  public context: IJitzSPContext;
+  public listName: string;
+
+  constructor(context: IJitzSPContext, listName: string) {
+    this.context = context;
+    this.listName = listName;
+  }
+
+  public getAll(
+    selectFields?: string,
+    expand?: string,
+    filters?: string,
+    orderBy?: string,
+    top?: number,
+    skip?: number,
+    skipTokenUniqueField?: string,
+    skipTokenUniqueFieldValue?: string
+  ): Promise<T[]> {
+    let queryUrlGetAllItems: string =
+      `${this.context.siteUrl}/_api/web/lists/GetByTitle('` +
+      this.listName +
+      `')/items`;
+
+    if (selectFields != null && selectFields != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=` + selectFields;
+    } else {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=*`;
+    }
+    if (orderBy != null && orderBy != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$orderby=` + orderBy;
+    }
+    if (skip != null && skip != undefined && skip > 0) {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$skip=` + skip;
+    }
+    if (top != null && top != undefined && top > 0) {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$top=` + top;
+    }
+    if (expand != null && expand != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$expand=` + expand;
+    }
+    if (filters != null && filters != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$filter=` + filters;
+    }
+    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) => {
+        // let items: T[] = [];
+        // if (data) {
+        //   for (let i = 0; i < data.length; i++) {
+        //     let item = data[i];
+        //     items.push(item);
+        //   }
+        // }
+        return data;
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public getAllFromUrl(url: string): Promise<T[]> {
+    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) => {
+        // let items: T[] = [];
+        // if (data) {
+        //   for (let i = 0; i < data.length; i++) {
+        //     let item = data[i];
+        //     items.push(item);
+        //   }
+        // }
+        return data;
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public async getAllRecursive(
+    selectFields?: string,
+    expand?: string,
+    filters?: string,
+    orderBy?: string,
+    top?: number,
+    maxRecursiveCount = 5
+  ): Promise<T[]> {
+    let items: T[] = [];
+    let queryUrlGetAllItems: string =
+      `${this.context.siteUrl}/_api/web/lists/GetByTitle('` +
+      this.listName +
+      `')/items`;
+
+    if (selectFields != null && selectFields != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=` + selectFields;
+    } else {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$select=*`;
+    }
+    if (expand != null && expand != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$expand=` + expand;
+    }
+    if (filters != null && filters != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$filter=` + filters;
+    }
+    if (orderBy != null && orderBy != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$orderby=` + orderBy;
+    }
+    if (top != null && top != undefined && top > 0) {
+      queryUrlGetAllItems = queryUrlGetAllItems + `&$top=` + top;
+    }
+
+    await this.context.client
+      .get(queryUrlGetAllItems)
+      .then(async (response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return await response.data.d;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      })
+      .then(async (data: any) => {
+        if (data.results) {
+          for (let i = 0; i < data.results.length; i++) {
+            let item = data.results[i];
+            items.push(item);
+          }
+        }
+        let returnItem: IListItemsMetadata<T> = {
+          __next: data.__next,
+          results: items,
+        };
+        if (returnItem.__next != undefined && returnItem.__next.length > 0) {
+          items = await this.recursiveFetch(
+            returnItem.__next,
+            2,
+            maxRecursiveCount,
+            returnItem.results
+          );
+        }
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+    return items;
+  }
+
+  private async recursiveFetch(
+    url: string,
+    recursiveCount: number = 1,
+    maxRecursiveCount: number = 5,
+    items: T[] = []
+  ): Promise<T[]> {
+    items = items || [];
+    await this.context.client
+      .get(url)
+      .then(async (response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return await response.data.d;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      })
+      .then(async (data: any) => {
+        if (data.results) {
+          for (let i = 0; i < data.results.length; i++) {
+            let item = data.results[i];
+            items.push(item);
+          }
+        }
+        let returnItem: IListItemsMetadata<T> = {
+          __next: data.__next,
+          results: items,
+        };
+
+        if (
+          returnItem.__next != undefined &&
+          returnItem.__next.length > 0 &&
+          recursiveCount < maxRecursiveCount
+        ) {
+          items = await this.recursiveFetch(
+            returnItem.__next,
+            recursiveCount + 1,
+            maxRecursiveCount,
+            returnItem.results
+          );
+        }
+      })
+      .catch((ex: any) => {
+        console.log("load Items > JitzSPHttpClient.get()...catch:", ex);
+        // throw ex; //Let it continue
+      });
+    return items;
+  }
+
+  public itemsCount(filters?: string) {
+    let queryUrlGetAllItems: string =
+      `${this.context.siteUrl}/_api/web/lists/GetByTitle('` +
+      this.listName +
+      `')/ItemCount`;
+
+    if (filters != null && filters != "") {
+      queryUrlGetAllItems = queryUrlGetAllItems + `?$filter=` + filters;
+    }
+
+    return this.context.client
+      .get(queryUrlGetAllItems)
+      .then((response: any) => {
+        if (response.status >= 200 && response.status < 300) {
+          return response.data.d.ItemCount;
+        } else {
+          return Promise.reject(new Error(JSON.stringify(response)));
+        }
+      })
+      .then((data: any) => {
+        return data;
+      })
+      .catch((ex: any) => {
+        console.log("loadEvents > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public async getItemById(
+    id: number,
+    selectFields?: string,
+    expand?: string
+  ): Promise<T> {
+    const queryUrl: string =
+      `${this.context.siteUrl}/_api/web/lists/getByTitle('` +
+      this.listName +
+      `')/items(` +
+      id +
+      `)` +
+      `?$select=*${selectFields != undefined ? `,${selectFields}` : ""}` +
+      `${expand != undefined ? `&$expand=${expand}` : ``}`;
+
+    return await this.context.client
+      .get(queryUrl)
+      .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("loadEvents > JitzSPHttpClient.get()...catch:", ex);
+        throw ex;
+      });
+  }
+
+  public createItem(item: T): Promise<T> {
+    return this.getEntityType().then((entityType) => {
+      item.__metadata = {
+        type: entityType,
+      };
+      var requestUrl = `${this.context.siteUrl}/_api/web/lists/getbytitle('${this.listName}')/items`;
+      return this.context.client
+        .post(requestUrl, item, {
+          Accept: "application/json;odata=nometadata",
+          "Content-type": "application/json;odata=verbose",
+          "odata-version": "",
+        })
+        .then((response: any): Promise<T> => {
+          if (response.status >= 200 && response.status < 300) {
+            var json = response.data.d;
+            return json;
+          } else {
+            return Promise.reject(new Error(JSON.stringify(response)));
+          }
+        });
+    });
+  }
+
+  public updateItem(item: T): Promise<T> {
+    return this.getEntityType().then((entityType) => {
+      item.__metadata = {
+        //etag: "1",
+        type: entityType,
+      };
+      var requestUrl = `${this.context.siteUrl}/_api/web/lists/getbytitle('${this.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)));
+          }
+        });
+    });
+  }
+
+  public deleteItem(id: number): Promise<boolean> {
+    var requestUrl = `${this.context.siteUrl}/_api/web/lists/getbytitle('${this.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(): Promise<string> {
+    return new Promise<string>(
+      (
+        resolve: (listItemEntityTypeName: string) => void,
+        reject: (error: any) => void
+      ): void => {
+        if (this._listEntityType) {
+          resolve(this._listEntityType);
+          return;
+        }
+
+        this.context.client
+          .get(
+            `${this.context.siteUrl}/_api/web/lists/getbytitle('${this.listName}')?$select=ListItemEntityTypeFullName`
+          )
+          .then(
+            (
+              response: any
+            ): Promise<{ ListItemEntityTypeFullName: string }> => {
+              return response;
+            },
+            (error: any): void => {
+              reject(error);
+            }
+          )
+          .then((response: any): void => {
+            this._listEntityType = response.data.d.ListItemEntityTypeFullName;
+            resolve(this._listEntityType || "");
+          });
+      }
+    );
+  }
+}

package/data/interfaces/ICommonRepository.ts

@@ -0,0 +1,7 @@
+import IJitzSPContext from "./IJitzSPContext";
+import { IEmail } from "./IModels";
+
+export interface ICommonRepository {
+  context: IJitzSPContext;
+  sendEmail(email: IEmail): Promise<boolean>;
+}

package/data/interfaces/IJitzContext.ts

@@ -0,0 +1,11 @@
+import { WebPartContext } from "@microsoft/sp-webpart-base";
+import IJitzSPContext from "./IJitzSPContext";
+import { MSGraphClientV3 } from "@microsoft/sp-http";
+
+export default interface IJitzContext {
+  spContext: IJitzSPContext;
+  webpartContext: WebPartContext;
+  graphClient: MSGraphClientV3;
+  siteId: string;
+  init: () => void;
+}

package/data/interfaces/IJitzSPContext.ts

@@ -0,0 +1,7 @@
+import IJitzSPHttpClient from "./IJitzSPHttpClient";
+
+export default interface IJitzSPContext {
+  client: IJitzSPHttpClient;
+  siteUrl: string;
+  init: () => void;
+}

package/data/interfaces/IJitzSPHttpClient.ts

@@ -0,0 +1,6 @@
+export default interface IJitzSPHttpClient {
+  init: () => void;
+  get: (url: string, header?: any) => any;
+  post: (url: string, data: any, header?: any) => any;
+  postWithOutStringify: (url: string, data: any, header?: any) => any;
+}

package/data/interfaces/IList.ts

@@ -0,0 +1,41 @@
+import { IModel } from "./IModels";
+import IJitzContext from "../interfaces/IJitzContext";
+import { IRepository } from "./IRepository";
+
+export interface IList<T extends IModel> {
+  context: IJitzContext;
+  listName: string;
+  repository: IRepository<T>;
+  getItems(
+    filter?: string,
+    orderby?: string,
+    top?: number,
+    skip?: number
+  ): Promise<T[]>;
+  loadMore(): Promise<T[]>;
+  getItemById(id: number): Promise<T>;
+  getItemsRecursive(
+    filters?: string,
+    orderby?: string,
+    top?: number,
+    maxRecursiveCount?: number
+  ): Promise<T[]>;
+  getItemsCount(filters?: string): Promise<number>;
+  create(item: T): Promise<T>;
+  update(item: T): Promise<T>;
+  delete(id: number): Promise<boolean>;
+  //New Ones
+  getItemsIndexed(
+    filterQuery?: string,
+    orderby?: string,
+    top?: number
+  ): Promise<T[]>;
+  loadMoreIndexed(): Promise<T[]>;
+  _nextPageLink?: string;
+  top: number;
+  indexLimit: number;
+  upperId: number;
+  lowerId: number;
+  filters?: string;
+  orderBy?: string;
+}

package/data/interfaces/IModels.ts

@@ -0,0 +1,33 @@
+export interface IModel {
+  Id?: number;
+  Title?: string;
+  AuthorId?: number;
+  Author?: IPersonOrGroup;
+  __metadata?: {};
+}
+
+export interface IListItemsMetadata<T> {
+  __next?: string;
+  results: T[];
+}
+
+export interface IEmail {
+  properties: {
+    From?: string;
+    To: { results: string[] };
+    Body: string;
+    Subject: string;
+    __metadata?: {};
+  };
+}
+
+export interface IPersonOrGroup {
+  Id: number;
+  Title: string;
+  EMail: string;
+  Email: string;
+  Name: string;
+  LoginName: string;
+  IsGroup: boolean;
+  Groups?: IPersonOrGroup[];
+}

package/data/interfaces/IRepository.ts

@@ -0,0 +1,31 @@
+import IJitzSPContext from "./IJitzSPContext";
+import { IModel } from "./IModels";
+
+export interface IRepository<T extends IModel> {
+  context: IJitzSPContext;
+  listName: string;
+  getAll(
+    selectFields?: string,
+    expand?: string,
+    filters?: string,
+    orderBy?: string,
+    top?: number,
+    skip?: number,
+    skipTokenUniqueField?: string,
+    skipTokenUniqueFieldValue?: string
+  ): Promise<T[]>;
+  getAllFromUrl(url: string): Promise<T[]>;
+  itemsCount(filters?: string): Promise<number>;
+  getItemById(id: number, selectFields?: string, expand?: string): Promise<T>;
+  createItem(item: T): Promise<T>;
+  updateItem(item: T): Promise<T>;
+  deleteItem(id: number): Promise<boolean>;
+  getAllRecursive(
+    selectFields?: string,
+    expand?: string,
+    filters?: string,
+    orderBy?: string,
+    top?: number,
+    maxRecursiveCount?: number
+  ): any;
+}

package/lib/common/IModels.d.ts

@@ -1,10 +1,18 @@
 export interface IModel {
-    Id: number;
+    Id?: number;
     Title?: string;
     AuthorId?: number;
     Author?: IPersonOrGroup;
+    Created?: string;
+    Modified?: string;
     __metadata?: {};
 }
+export interface IMultiUserFieldId {
+    results: number[];
+}
+export interface IMultiUserField {
+    results: IPersonOrGroup[];
+}
 export interface IListItemsMetadata<T> {
     __next: string;
     results: T[];

package/lib/common/IObjects.d.ts

@@ -0,0 +1,72 @@
+import { IPersona } from "@fluentui/react";
+export interface IJitzAlertNotificationProps {
+    hideMe: boolean;
+    isDraggable: boolean;
+    title: string;
+    message: string;
+    shouldRedirectOnClose: boolean;
+    onClose?: () => void;
+}
+export interface IJitzAlertNotificationState {
+}
+export interface IJitzPeoplePickerState {
+    currentPicker?: number | string;
+    delayResults?: boolean;
+    disabled: boolean;
+    selectedItems: any[];
+}
+export interface IPeopleSearchProps {
+    JobTitle: string;
+    PictureURL: string;
+    PreferredName: string;
+}
+export interface IUserEntityData {
+    IsAltSecIdPresent: string;
+    ObjectId: string;
+    Title: string;
+    Email: string;
+    MobilePhone: string;
+    OtherMails: string;
+    Department: string;
+}
+export interface IClientPeoplePickerSearchUser {
+    Key: string;
+    Description: string;
+    DisplayText: string;
+    EntityType: string;
+    Title: string;
+    ProviderDisplayName: string;
+    ProviderName: string;
+    IsResolved: boolean;
+    EntityData: IUserEntityData;
+    MultipleMatches: any[];
+}
+export interface IEnsureUser {
+    Email: string;
+    Id: number;
+    IsEmailAuthenticationGuestUser: boolean;
+    IsHiddenInUI: boolean;
+    IsShareByEmailGuestUser: boolean;
+    IsSiteAdmin: boolean;
+    LoginName: string;
+    PrincipalType: number;
+    Title: string;
+    UserId: {
+        NameId: string;
+        NameIdIssuer: string;
+    };
+}
+export interface IEnsurableSharePointUser extends IClientPeoplePickerSearchUser, IEnsureUser {
+    imageUrl?: string;
+}
+export declare class SharePointUserPersona implements IPersona {
+    private _user;
+    get User(): IEnsurableSharePointUser;
+    set User(user: IEnsurableSharePointUser);
+    constructor(user: IEnsurableSharePointUser);
+    primaryText: string;
+    secondaryText: string;
+    tertiaryText: string;
+    imageUrl: string;
+    imageShouldFadeIn: boolean;
+}

package/lib/common/IObjects.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharePointUserPersona = void 0;
+var SharePointUserPersona = /** @class */ (function () {
+    function SharePointUserPersona(user) {
+        this.User = user;
+    }
+    Object.defineProperty(SharePointUserPersona.prototype, "User", {
+        get: function () {
+            return this._user;
+        },
+        set: function (user) {
+            this._user = user;
+            this.primaryText = user.Title;
+            //this.secondaryText = user.EntityData.Title;
+            //this.tertiaryText = user.EntityData.Department;
+            this.imageShouldFadeIn = true;
+            // if (this.User.Key != undefined)
+            //   this.imageUrl = `/_layouts/15/userphoto.aspx?size=S&accountname=${this.User.Key.substr(
+            //     this.User.Key.lastIndexOf("|") + 1
+            //   )}`;
+            // else
+            //   this.imageUrl = `/_layouts/15/userphoto.aspx?size=S&accountname=${this.User.Email}`;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SharePointUserPersona;
+}());
+exports.SharePointUserPersona = SharePointUserPersona;