jitz-sharepoint-utilities 2.0.14 → 2.0.16

package/lib/controls/JitzPeoplePicker.d.ts

@@ -0,0 +1,49 @@
+import * as React from "react";
+import IJitzSPContext from "../data/interfaces/IJitzSPContext";
+import { IJitzPeoplePickerState, SharePointUserPersona } from "../common/IObjects";
+export interface IJitzPeoplePickerProps {
+    description: string;
+    context: IJitzSPContext;
+    hostSiteUrl?: string;
+    typePicker: string;
+    disabled: boolean;
+    principalTypeUser: boolean;
+    principalTypeSharePointGroup: boolean;
+    principalTypeSecurityGroup: boolean;
+    principalTypeDistributionList: boolean;
+    numberOfItems: number;
+    onChange?: (items: SharePointUserPersona[]) => void;
+    prePopulatedItems: string[];
+    errorMessage?: string;
+    errorCss?: string;
+    multiSelect: boolean;
+}
+export declare class JitzPeoplePicker extends React.Component<IJitzPeoplePickerProps, IJitzPeoplePickerState> {
+    private _peopleList;
+    private contextualMenuItems;
+    constructor(props: IJitzPeoplePickerProps);
+    getSelectedItems(): void;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: IJitzPeoplePickerProps, prevState: IJitzPeoplePickerState, prevContext: any): void;
+    componentWillReceiveProps(nextProps: IJitzPeoplePickerProps): void;
+    render(): React.ReactElement<IJitzPeoplePickerProps>;
+    private _onChange;
+    private prePopulate;
+    private _onFilterChanged;
+    /**
+     * @function
+     * Returns fake people results for the Mock mode
+     */
+    private searchPeopleFromMock;
+    /**
+     * @function
+     * Returns people results after a REST API call
+     */
+    private _searchPeople;
+    private _filterPersonasByText;
+    private _removeDuplicates;
+    private _listContainsPersona;
+    private _filterPromise;
+    private _convertResultsToPromise;
+    private _doesTextStartWith;
+}

package/lib/controls/JitzPeoplePicker.js

@@ -0,0 +1,311 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitzPeoplePicker = void 0;
+var React = require("react");
+var lodash = require("lodash");
+var UtilityService_1 = require("../services/UtilityService");
+var react_1 = require("@fluentui/react");
+var IObjects_1 = require("../common/IObjects");
+var suggestionProps = {
+    suggestionsHeaderText: "Suggested People",
+    noResultsFoundText: "No results found",
+    loadingText: "Loading",
+};
+var JitzPeoplePicker = /** @class */ (function (_super) {
+    __extends(JitzPeoplePicker, _super);
+    function JitzPeoplePicker(props) {
+        var _this = _super.call(this, props) || this;
+        _this.contextualMenuItems = [
+            {
+                key: "newItem",
+                icon: "circlePlus",
+                name: "New",
+            },
+            {
+                key: "upload",
+                icon: "upload",
+                name: "Upload",
+            },
+            {
+                key: "divider_1",
+                name: "-",
+            },
+            {
+                key: "rename",
+                name: "Rename",
+            },
+            {
+                key: "properties",
+                name: "Properties",
+            },
+            {
+                key: "disabled",
+                name: "Disabled item",
+                disabled: true,
+            },
+        ];
+        _this.prePopulate = function (nextPrePopulatedItems) {
+            var ensureUserUrl = "".concat(_this.props.context.siteUrl, "/_api/web/ensureUser");
+            if (nextPrePopulatedItems != undefined &&
+                nextPrePopulatedItems != null &&
+                nextPrePopulatedItems[0] != null) {
+                nextPrePopulatedItems.map(function (item) {
+                    // console.log(item);
+                    _this.props.context.client
+                        .post(ensureUserUrl, { logonName: item })
+                        .then(function (response) {
+                        var res = response.data.d;
+                        return res;
+                    })
+                        .then(function (res) {
+                        var pers = new IObjects_1.SharePointUserPersona(res);
+                        pers.imageUrl = UtilityService_1.default.getProfilePictureUrl(_this.props.hostSiteUrl || _this.props.context.siteUrl, pers.User.Email || "");
+                        // (this.props.hostSiteUrl || this.props.context.siteUrl) +
+                        // `/_layouts/15/userphoto.aspx?size=S&accountname=${pers.User.Email}`;
+                        var prepopulatedItems = _this.state.selectedItems;
+                        if (prepopulatedItems.filter(function (x) { return x.User.LoginName == pers.User.LoginName; }).length == 0) {
+                            prepopulatedItems.push(pers);
+                            _this.setState({
+                                selectedItems: _this.props.multiSelect
+                                    ? prepopulatedItems
+                                    : prepopulatedItems.length > 0
+                                        ? [prepopulatedItems[0]]
+                                        : prepopulatedItems,
+                            });
+                        }
+                        if (_this.props.onChange) {
+                            _this.props.onChange(prepopulatedItems);
+                        }
+                    });
+                });
+            }
+        };
+        _this._onFilterChanged = function (filterText, currentPersonas) {
+            if (filterText) {
+                if (filterText.length > 2) {
+                    return _this._searchPeople(filterText, _this._peopleList);
+                }
+            }
+            else {
+                return [];
+            }
+        };
+        _this._peopleList = [];
+        _this.state = {
+            currentPicker: 1,
+            disabled: false,
+            delayResults: false,
+            selectedItems: [],
+        };
+        return _this;
+    }
+    JitzPeoplePicker.prototype.getSelectedItems = function () { };
+    JitzPeoplePicker.prototype.componentDidMount = function () {
+        this.setState({ disabled: this.props.disabled });
+        this.prePopulate(this.props.prePopulatedItems);
+    };
+    JitzPeoplePicker.prototype.componentDidUpdate = function (prevProps, prevState, prevContext) {
+        //this.prePopulate();
+    };
+    JitzPeoplePicker.prototype.componentWillReceiveProps = function (nextProps) {
+        this.setState({ disabled: nextProps.disabled });
+        this.prePopulate(nextProps.prePopulatedItems);
+    };
+    JitzPeoplePicker.prototype.render = function () {
+        if (this.props.typePicker == "Normal") {
+            return (React.createElement(react_1.NormalPeoplePicker, { onChange: this._onChange.bind(this), disabled: this.state.disabled, onResolveSuggestions: this._onFilterChanged, getTextFromItem: function (persona) {
+                    return persona.primaryText || "";
+                }, pickerSuggestionsProps: suggestionProps, selectedItems: this.state.selectedItems, className: "ms-PeoplePicker " +
+                    (this.props.errorMessage != null &&
+                        this.props.errorMessage != undefined &&
+                        this.props.errorMessage.length > 0
+                        ? this.props.errorCss
+                        : ""), key: "normal" }));
+        }
+        else {
+            return (React.createElement(react_1.CompactPeoplePicker, { onChange: this._onChange.bind(this), onResolveSuggestions: this._onFilterChanged, disabled: this.state.disabled, getTextFromItem: function (persona) {
+                    return persona.primaryText || "";
+                }, pickerSuggestionsProps: suggestionProps, selectedItems: this.state.selectedItems, className: "ms-PeoplePicker" +
+                    (this.props.errorMessage != null &&
+                        this.props.errorMessage != undefined &&
+                        this.props.errorMessage.length > 0
+                        ? this.props.errorCss
+                        : ""), key: "normal" }));
+        }
+    };
+    JitzPeoplePicker.prototype._onChange = function (items) {
+        var _this = this;
+        this.setState({
+            selectedItems: (this.props.multiSelect
+                ? items
+                : items != undefined
+                    ? items.length > 0
+                        ? [items[0]]
+                        : items
+                    : []) || [],
+        });
+        if (items != undefined) {
+            items.map(function (p, v) {
+                // console.log(p);
+                var ensureUserUrl = "".concat(_this.props.context.siteUrl, "/_api/web/ensureUser");
+                _this.props.context.client
+                    .post(ensureUserUrl, { logonName: p.User.Key })
+                    .then(function (response) {
+                    var res = response.data.d;
+                    return res;
+                })
+                    .then(function (res) { });
+            });
+        }
+        if (this.props.onChange) {
+            this.props.onChange(items || []);
+        }
+    };
+    /**
+     * @function
+     * Returns fake people results for the Mock mode
+     */
+    JitzPeoplePicker.prototype.searchPeopleFromMock = function () {
+        return (this._peopleList = []);
+    };
+    /**
+     * @function
+     * Returns people results after a REST API call
+     */
+    JitzPeoplePicker.prototype._searchPeople = function (terms, results) {
+        var _this = this;
+        var userRequestUrl = "".concat(this.props.context.siteUrl, "/_api/SP.UI.ApplicationPages.ClientPeoplePickerWebServiceInterface.clientPeoplePickerSearchUser");
+        var principalType = 0;
+        if (this.props.principalTypeUser === true) {
+            principalType += 1;
+        }
+        if (this.props.principalTypeSharePointGroup === true) {
+            principalType += 8;
+        }
+        if (this.props.principalTypeSecurityGroup === true) {
+            principalType += 4;
+        }
+        if (this.props.principalTypeDistributionList === true) {
+            principalType += 2;
+        }
+        var userQueryParams = {
+            queryParams: {
+                AllowEmailAddresses: true,
+                AllowMultipleEntities: false,
+                AllUrlZones: false,
+                MaximumEntitySuggestions: this.props.numberOfItems,
+                PrincipalSource: 15,
+                // PrincipalType controls the type of entities that are returned in the results.
+                // Choices are All - 15, Distribution List - 2 , Security Groups - 4, SharePoint Groups - 8, User - 1.
+                // These values can be combined (example: 13 is security + SP groups + users)
+                PrincipalType: principalType,
+                QueryString: terms,
+            },
+        };
+        return new Promise(function (resolve, reject) {
+            return _this.props.context.client
+                .post(userRequestUrl, userQueryParams)
+                .then(function (response) {
+                return response.data.d;
+            })
+                .then(function (response) {
+                var userQueryResults = JSON.parse(response.ClientPeoplePickerSearchUser);
+                var persons = userQueryResults.map(function (p) { return new IObjects_1.SharePointUserPersona(p); });
+                persons.map(function (p, index) {
+                    persons[index].imageUrl = UtilityService_1.default.getProfilePictureUrl(_this.props.hostSiteUrl || _this.props.context.siteUrl, persons[index].User.Email ||
+                        persons[index].User.Key.substr(persons[index].User.Key.lastIndexOf("|") + 1));
+                    // (this.props.hostSiteUrl || this.props.context.siteUrl) +
+                    // `/_layouts/15/userphoto.aspx?size=S&accountname=${
+                    //   persons[index].User.Email ||
+                    //   persons[index].User.Key.substr(
+                    //     persons[index].User.Key.lastIndexOf("|") + 1
+                    //   )
+                    // }`;
+                });
+                return persons;
+            })
+                .then(function (persons) {
+                //const batch = this.props.spHttpClient.beginBatch();
+                var ensureUserUrl = "".concat(_this.props.context.siteUrl, "/_api/web/ensureUser");
+                var batchPromises = persons.map(function (p) {
+                    p.primaryText = p.User.DisplayText;
+                    p.secondaryText = p.User.EntityData.Title;
+                    var userQuery = { logonName: p.User.Key };
+                    return (_this.props.context.client
+                        .post(ensureUserUrl, userQuery)
+                        //  return this.props.spHttpClient.post(ensureUserUrl,
+                        //                                       SPHttpClient.configurations.v1,
+                        //                                       {body:JSON.stringify({logonName:  p.User.Key})})
+                        .then(function (response) {
+                        return response.data.d;
+                    })
+                        .then(function (json) { return json; }));
+                });
+                // var users = this.props.spHttpClient.execute().then(() => );
+                var users = Promise.all(batchPromises).then(function (values) {
+                    values.forEach(function (v) {
+                        var userPersona = lodash.find(persons, function (o) { return o.User.Key == v.LoginName; });
+                        if (userPersona && userPersona.User) {
+                            var user = userPersona.User;
+                            lodash.assign(user, v);
+                            userPersona.User = user;
+                        }
+                    });
+                    resolve(persons);
+                });
+            }, function (error) {
+                reject((_this._peopleList = []));
+            });
+        });
+    };
+    JitzPeoplePicker.prototype._filterPersonasByText = function (filterText) {
+        var _this = this;
+        return this._peopleList.filter(function (item) {
+            return _this._doesTextStartWith(item.primaryText, filterText);
+        });
+    };
+    JitzPeoplePicker.prototype._removeDuplicates = function (personas, possibleDupes) {
+        var _this = this;
+        return personas.filter(function (persona) { return !_this._listContainsPersona(persona, possibleDupes); });
+    };
+    JitzPeoplePicker.prototype._listContainsPersona = function (persona, personas) {
+        if (!personas || !personas.length || personas.length === 0) {
+            return false;
+        }
+        return (personas.filter(function (item) { return item.primaryText === persona.primaryText; })
+            .length > 0);
+    };
+    JitzPeoplePicker.prototype._filterPromise = function (personasToReturn) {
+        if (this.state.delayResults) {
+            return this._convertResultsToPromise(personasToReturn);
+        }
+        else {
+            return personasToReturn;
+        }
+    };
+    JitzPeoplePicker.prototype._convertResultsToPromise = function (results) {
+        return new Promise(function (resolve, reject) {
+            return setTimeout(function () { return resolve(results); }, 2000);
+        });
+    };
+    JitzPeoplePicker.prototype._doesTextStartWith = function (text, filterText) {
+        return text.toLowerCase().indexOf(filterText.toLowerCase()) === 0;
+    };
+    return JitzPeoplePicker;
+}(React.Component));
+exports.JitzPeoplePicker = JitzPeoplePicker;

package/lib/controls/JitzPersonInfo.d.ts

@@ -0,0 +1,32 @@
+import * as React from "react";
+import IJitzSPContext from "../data/interfaces/IJitzSPContext";
+import { PersonaSize } from "@fluentui/react";
+export interface IPersonInfoProps {
+    userId: number;
+    email?: string;
+    title?: string;
+    department?: string;
+    location?: string;
+    context?: IJitzSPContext;
+    siteUrl?: string;
+    imageUrl?: string;
+    size?: PersonaSize;
+    className?: string;
+    hidePersonaDetails?: boolean;
+}
+export interface IPersonInfoState {
+    user: {
+        email?: string;
+        title?: string;
+        department?: string;
+        location?: string;
+    };
+}
+export declare class JitzPersonInfo extends React.Component<IPersonInfoProps, IPersonInfoState> {
+    private _userInfo;
+    constructor(props: IPersonInfoProps, state: IPersonInfoState);
+    componentDidMount(): void;
+    componentWillReceiveProps(nextProps: IPersonInfoProps): void;
+    private loadUser;
+    render(): React.ReactElement<IPersonInfoProps>;
+}

package/lib/controls/JitzPersonInfo.js

@@ -0,0 +1,98 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitzPersonInfo = void 0;
+var React = require("react");
+var react_1 = require("@fluentui/react");
+var UserService_1 = require("../services/UserService");
+var UtilityService_1 = require("../services/UtilityService");
+var JitzPersonInfo = /** @class */ (function (_super) {
+    __extends(JitzPersonInfo, _super);
+    function JitzPersonInfo(props, state) {
+        var _this = _super.call(this, props) || this;
+        _this.loadUser = function (id) {
+            if (_this.props.context != undefined) {
+                _this._userInfo = new UserService_1.default(_this.props.context);
+                _this._userInfo.getUserById(id).then(function (userInfo) {
+                    _this.setState({
+                        user: {
+                            email: userInfo.Email,
+                            title: userInfo.Title,
+                            // department: userInfo.Department,
+                        },
+                    });
+                });
+            }
+        };
+        _this.state = {
+            user: {},
+        };
+        return _this;
+    }
+    JitzPersonInfo.prototype.componentDidMount = function () {
+        if (this.props.userId > 0 &&
+            this.props.email == undefined &&
+            this.props.title == undefined) {
+            this.loadUser(this.props.userId);
+        }
+    };
+    JitzPersonInfo.prototype.componentWillReceiveProps = function (nextProps) {
+        if (nextProps.userId > 0 &&
+            nextProps.email == undefined &&
+            nextProps.title == undefined) {
+            this.loadUser(nextProps.userId);
+        }
+    };
+    JitzPersonInfo.prototype.render = function () {
+        // const userDetails = this.state.user;
+        var userDetails = {
+            imageUrl: UtilityService_1.default.getProfilePictureUrl(this.props.siteUrl || this.props.context.siteUrl, this.props.email || this.state.user.email || ""),
+            // this.props.imageUrl ||
+            // (this.props.siteUrl || this.props.context!.siteUrl) +
+            //   `/_layouts/15/userphoto.aspx?size=${
+            //     this.props.size == PersonaSize.size48 ||
+            //     this.props.size == PersonaSize.size56 ||
+            //     this.props.size == PersonaSize.size72 ||
+            //     this.props.size == PersonaSize.size100 ||
+            //     this.props.size == PersonaSize.size120
+            //       ? "L"
+            //       : "M"
+            //   }&accountname=${this.props.email || this.state.user.email}`,
+            imageInitials: "",
+            primaryText: this.props.title || this.state.user.title,
+            secondaryText: this.props.department || this.state.user.department,
+            tertiaryText: "",
+            optionalText: "",
+        };
+        return (React.createElement(react_1.Persona, __assign({ title: this.props.hidePersonaDetails ? userDetails.primaryText : "" }, userDetails, { className: this.props.className, size: this.props.size || react_1.PersonaSize.size24, 
+            // presence={PersonaPresence.online} //TODO: Actual presence
+            hidePersonaDetails: this.props.hidePersonaDetails || false })));
+    };
+    return JitzPersonInfo;
+}(React.Component));
+exports.JitzPersonInfo = JitzPersonInfo;

package/lib/controls/JitzPersona.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { PersonaPresence, PersonaSize } from "@fluentui/react";
+export interface IJitzPersonaProps {
+    className?: string;
+    imageUrl?: string;
+    personaSize?: PersonaSize;
+    presence?: PersonaPresence;
+    showPersonalDetails?: boolean;
+    imageInitials?: string;
+    text?: string;
+    secondaryText?: string;
+    tertiaryText?: string;
+    optionalText?: string;
+}
+export interface IJitzPersonaState {
+}
+export declare class JitzPersona extends React.Component<IJitzPersonaProps, IJitzPersonaState> {
+    private _userInfo;
+    constructor(props: IJitzPersonaProps, state: IJitzPersonaState);
+    componentDidMount(): void;
+    componentWillReceiveProps(nextProps: IJitzPersonaProps): void;
+    render(): React.ReactElement<IJitzPersonaProps>;
+}

package/lib/controls/JitzPersona.js

@@ -0,0 +1,48 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitzPersona = void 0;
+var React = require("react");
+var react_1 = require("@fluentui/react");
+var JitzPersona = /** @class */ (function (_super) {
+    __extends(JitzPersona, _super);
+    function JitzPersona(props, state) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            user: {},
+        };
+        return _this;
+    }
+    JitzPersona.prototype.componentDidMount = function () { };
+    JitzPersona.prototype.componentWillReceiveProps = function (nextProps) { };
+    JitzPersona.prototype.render = function () {
+        return (React.createElement(react_1.Persona, __assign({ className: this.props.className || "" }, this.props, { text: this.props.text, hidePersonaDetails: !this.props.showPersonalDetails, size: this.props.personaSize || react_1.PersonaSize.size56, presence: this.props.presence || react_1.PersonaPresence.none, imageAlt: "" })));
+    };
+    return JitzPersona;
+}(React.Component));
+exports.JitzPersona = JitzPersona;

package/lib/data/context/CommonRepository.d.ts

@@ -0,0 +1,17 @@
+import { ICommonRepository } from "../interfaces/ICommonRepository";
+import IJitzSPContext from "../interfaces/IJitzSPContext";
+import { IEmail } from "../interfaces/IModels";
+export default class CommonRepository implements ICommonRepository {
+    context: IJitzSPContext;
+    constructor(context: IJitzSPContext);
+    sendEmail(email: IEmail): Promise<boolean>;
+    getData(listName: string, selectFields?: string, expand?: string, filters?: string, orderBy?: string, top?: number, skipTokenUniqueField?: string, skipTokenUniqueFieldValue?: string): Promise<any>;
+    get(url: string): Promise<any>;
+    post(url: string, data: any, header?: any): Promise<any>;
+    getFiles(libraryName: string, selectFields: string, filter: string, expandFields: string): Promise<any>;
+    uploadFile(libraryName: string, fileName: string, arrayBuffer: ArrayBuffer): Promise<any>;
+    getFileItem(libraryName: string, fileUrl: string): Promise<any>;
+    updateMetadata(listName: string, item: any): Promise<any>;
+    deleteFile(listName: string, id: number): Promise<boolean>;
+    private getEntityType;
+}