@zxncij2390/monorepo3 3.18.0

package/packages/sp/clientside-pages/web.ts

@@ -0,0 +1,93 @@
+import { _Web, IWeb } from "../webs/types.js";
+import {
+    IClientsidePageComponent,
+    CreateClientsidePage,
+    IClientsidePage,
+    ClientsidePageLayoutType,
+    ClientsidePageFromFile,
+    PromotedState,
+    IRepostPage,
+    ClientsideWebpart,
+} from "./types.js";
+import { SPCollection, SPInstance } from "../spqueryable.js";
+import { spPost } from "../operations.js";
+import { body } from "@pnp/queryable";
+import { extractWebUrl } from "@pnp/sp";
+
+
+declare module "../webs/types" {
+    interface _Web {
+        getClientsideWebParts(): Promise<IClientsidePageComponent[]>;
+        addClientsidePage(pageName: string, title?: string, libraryTitle?: string, promotedState?: PromotedState): Promise<IClientsidePage>;
+        loadClientsidePage(path: string): Promise<IClientsidePage>;
+        addRepostPage(details: IRepostPage): Promise<string>;
+        addFullPageApp(pageName: string, title: string, componentId: string, promotedState?: PromotedState): Promise<IClientsidePage>;
+    }
+    interface IWeb {
+
+        /**
+         * Gets the collection of available client side web parts for this web instance
+         */
+        getClientsideWebParts(): Promise<IClientsidePageComponent[]>;
+
+        /**
+         * Creates a new client side page
+         *
+         * @param pageName Name of the new page
+         * @param title Display title of the new page
+         */
+        addClientsidePage(pageName: string, title?: string, PageLayoutType?: ClientsidePageLayoutType, promotedState?: PromotedState): Promise<IClientsidePage>;
+
+        /**
+         * Loads a page from the provided server relative path to the file
+         *
+         * @param path Server relative path to the file (ex: "/sites/dev/sitepages/page.aspx")
+         */
+        loadClientsidePage(path: string): Promise<IClientsidePage>;
+
+        /**
+         * Adds a repost page
+         *
+         * @param details The request details to create the page
+         */
+        addRepostPage(details: IRepostPage): Promise<string>;
+
+        /**
+         * Creates a new single page app page and installs the indicated component
+         *
+         * @param componentId
+         */
+        addFullPageApp(pageName: string, title: string, componentId: string, promotedState?: PromotedState): Promise<IClientsidePage>;
+    }
+}
+
+_Web.prototype.getClientsideWebParts = function (this: _Web): Promise<IClientsidePageComponent[]> {
+    return SPCollection(this, "GetClientSideWebParts")();
+};
+
+_Web.prototype.addClientsidePage =
+    function (this: IWeb, pageName: string, title = pageName.replace(/\.[^/.]+$/, ""), layout?: ClientsidePageLayoutType, promotedState?: PromotedState): Promise<IClientsidePage> {
+        return CreateClientsidePage(this, pageName, title, layout, promotedState);
+    };
+
+_Web.prototype.loadClientsidePage = function (this: IWeb, path: string): Promise<IClientsidePage> {
+    return ClientsidePageFromFile(this.getFileByServerRelativePath(path));
+};
+
+_Web.prototype.addRepostPage = async function (this: IWeb, details: IRepostPage): Promise<string> {
+    const query = SPInstance([this, extractWebUrl(this.toUrl())], "_api/sitepages/pages/reposts");
+    const r: { AbsoluteUrl: string } = await spPost(query, body(details));
+    return r.AbsoluteUrl;
+};
+
+// eslint-disable-next-line max-len
+_Web.prototype.addFullPageApp = async function (this: IWeb, pageName: string, title = pageName.replace(/\.[^/.]+$/, ""), componentId: string, promotedState?: PromotedState): Promise<IClientsidePage> {
+
+    const parts = await this.getClientsideWebParts();
+    const test = new RegExp(`{?${componentId}}?`, "i");
+    const partDef = parts.find(p => test.test(p.Id));
+    const part = ClientsideWebpart.fromComponentDef(partDef);
+    const page = await this.addClientsidePage(pageName, title, "SingleWebPartAppPage", promotedState);
+    page.addSection().addColumn(12).addControl(part);
+    return page;
+};

package/packages/sp/column-defaults/folder.ts

@@ -0,0 +1,89 @@
+import { odataUrlFrom } from "../utils/odata-url-from.js";
+import { extractWebUrl } from "../utils/extract-web-url.js";
+import { IResourcePath } from "../utils/to-resource-path.js";
+import { Web } from "../webs/types.js";
+import "../lists/web.js";
+import { _Folder, Folder } from "../folders/types.js";
+import { IFieldDefault, IFieldDefaultProps } from "./types.js";
+
+declare module "../folders/types" {
+    interface _Folder {
+        getDefaultColumnValues(): Promise<IFieldDefault[]>;
+        setDefaultColumnValues(defaults: IFieldDefaultProps[], merge?: boolean): Promise<void>;
+        clearDefaultColumnValues(): Promise<void>;
+    }
+    interface IFolder {
+        /**
+         * Gets the default column value for a given list
+         */
+        getDefaultColumnValues(): Promise<IFieldDefault[]>;
+        /**
+         *
+         * Sets the default column values for this folder
+         *
+         * @param fieldDefaults The values to set including field name and appropriate value
+         * @param merge If true (default) existing values will be updated and new values added, otherwise all defaults are replaced for this folder
+         */
+        setDefaultColumnValues(defaults: IFieldDefaultProps[], merge?: boolean): Promise<void>;
+        /**
+         * Clears all defaults from this folder
+         */
+        clearDefaultColumnValues(): Promise<void>;
+    }
+}
+
+_Folder.prototype.getDefaultColumnValues = async function (this: _Folder): Promise<IFieldDefault[]> {
+
+    const folderProps = await Folder(this, "Properties").select("vti_x005f_listname")<{ vti_x005f_listname: string }>();
+    const { ServerRelativePath: serRelPath } = await this.select("ServerRelativePath")<{ ServerRelativePath: IResourcePath }>();
+
+    const web = Web([this, extractWebUrl(odataUrlFrom(folderProps))]);
+    const docLib = web.lists.getById(folderProps.vti_x005f_listname);
+
+    // and we return the defaults associated with this folder's server relative path only
+    // if you want all the defaults use list.getDefaultColumnValues()
+    return (await docLib.getDefaultColumnValues()).filter(v => v.path.toLowerCase() === serRelPath.DecodedUrl.toLowerCase());
+};
+
+_Folder.prototype.setDefaultColumnValues = async function (fieldDefaults: IFieldDefaultProps[], merge = true): Promise<void> {
+
+    // we start by figuring out where we are
+    const folderProps = await Folder(this, "Properties").select("vti_x005f_listname")<{ vti_x005f_listname: string }>();
+
+    // now we create a web, list and batch to get some info we need
+    const web = Web([this, extractWebUrl(odataUrlFrom(folderProps))]);
+    const docLib = web.lists.getById(folderProps.vti_x005f_listname);
+
+    // we need the proper folder path
+    const folderPath = (await this.select("ServerRelativePath")()).ServerRelativePath.DecodedUrl;
+
+    // at this point we should have all the defaults to update
+    // and we need to get all the defaults to update the entire doc
+    const existingDefaults = await docLib.getDefaultColumnValues();
+
+    // we filter all defaults to remove any associated with this folder if merge is false
+    const filteredExistingDefaults = merge ? existingDefaults : existingDefaults.filter(f => f.path !== folderPath);
+
+    // we update / add any new defaults from those passed to this method
+    fieldDefaults.forEach(d => {
+
+        const existing = filteredExistingDefaults.find(ed => ed.name === d.name && ed.path === folderPath);
+
+        if (existing) {
+            existing.value = d.value;
+        } else {
+            filteredExistingDefaults.push({
+                name: d.name,
+                path: folderPath,
+                value: d.value,
+            });
+        }
+    });
+
+    // after this operation filteredExistingDefaults should contain all the value we want to write to the file
+    await docLib.setDefaultColumnValues(filteredExistingDefaults);
+};
+
+_Folder.prototype.clearDefaultColumnValues = async function (this: _Folder): Promise<void> {
+    await this.setDefaultColumnValues([], false);
+};

package/packages/sp/column-defaults/index.ts

@@ -0,0 +1,8 @@
+import "./list.js";
+import "./folder.js";
+
+export {
+    IFieldDefault,
+    IFieldDefaultProps,
+    AllowedDefaultColumnValues,
+} from "./types.js";

package/packages/sp/column-defaults/list.ts

@@ -0,0 +1,219 @@
+import { addProp, body, TextParse } from "@pnp/queryable";
+import { _List, List } from "../lists/types.js";
+import { Folder } from "../folders/types.js";
+import { IFieldDefault } from "./types.js";
+import { IResourcePath } from "../utils/to-resource-path.js";
+import { combine, isArray } from "@pnp/core";
+import { spPost } from "../operations.js";
+import { SPCollection } from "../presets/all.js";
+import { encodePath } from "../utils/encode-path-str.js";
+
+declare module "../lists/types" {
+    interface _List {
+        getDefaultColumnValues(): Promise<IFieldDefault[]>;
+        setDefaultColumnValues(defaults: IFieldDefault[]): Promise<void>;
+    }
+    interface IList {
+        /**
+         * Gets the default column value for a given list
+         */
+        getDefaultColumnValues(): Promise<IFieldDefault[]>;
+
+        /**
+         * Replaces all the column defaults with the supplied values
+         *
+         * @param defaults
+         */
+        setDefaultColumnValues(defaults: IFieldDefault[]): Promise<void>;
+    }
+}
+
+addProp(_List, "rootFolder", Folder);
+
+_List.prototype.getDefaultColumnValues = async function (this: _List): Promise<IFieldDefault[]> {
+
+    const pathPart: { ServerRelativePath: IResourcePath } = await this.rootFolder.select("ServerRelativePath")();
+    const webUrl: { ParentWeb: { Url: string } } = await this.select("ParentWeb/Url").expand("ParentWeb")();
+    const path = combine("/", pathPart.ServerRelativePath.DecodedUrl, "Forms/client_LocationBasedDefaults.html");
+    const baseFilePath = combine(webUrl.ParentWeb.Url, `_api/web/getFileByServerRelativePath(decodedUrl='${encodePath(path)}')`);
+
+    let xml = "";
+
+    try {
+
+        // we are reading the contents of the file
+        xml = await <any>Folder([this, baseFilePath], "$value").using(TextParse())();
+
+    } catch (e) {
+
+        // if this call fails we assume it is because the file is 404
+        if (e && e.status && e.status === 404) {
+
+            // return an empty array
+            return [];
+        }
+
+        throw e;
+    }
+
+    // get all the tags from the xml
+    const matches = xml.match(/<a.*?<\/a>/ig);
+    const tags = matches === null ? [] : matches.map(t => t.trim());
+
+    // now we need to turn these tags of form into objects
+    // <a href="/sites/dev/My%20Title"><DefaultValue FieldName="TextField">Test</DefaultValue></a>
+
+    return tags.reduce((defVals, t) => {
+        const m = /<a href="(.*?)">/ig.exec(t);
+        // if things worked out captures are:
+        // 0: whole string
+        // 1: ENCODED server relative path
+
+        if (m.length < 1) {
+            // this indicates an error somewhere, but we have no way to meaningfully recover
+            // perhaps the way the tags are stored has changed on the server? Check that first.
+            this.log(`Could not parse default column value from '${t}'`, 2);
+            return null;
+        }
+
+        // return the parsed out values
+        const subMatches = t.match(/<DefaultValue.*?<\/DefaultValue>/ig);
+        const subTags = subMatches === null ? [] : subMatches.map(st => st.trim());
+
+        subTags.map(st => {
+            const sm = /<DefaultValue FieldName="(.*?)">(.*?)<\/DefaultValue>/ig.exec(st);
+            // if things worked out captures are:
+            // 0: whole string
+            // 1: Field internal name
+            // 2: Default value as string
+
+            if (sm.length < 1) {
+                this.log(`Could not parse default column value from '${st}'`, 2);
+            } else {
+                defVals.push({
+                    name: sm[1],
+                    path: decodeURIComponent(m[1]),
+                    value: sm[2],
+                });
+            }
+        });
+
+        return defVals;
+
+    }, []).filter(v => v !== null);
+};
+
+_List.prototype.setDefaultColumnValues = async function (this: _List, defaults: IFieldDefault[]): Promise<void> {
+
+    // we need the field types from the list to map the values
+    // eslint-disable-next-line max-len
+    const fieldDefs: { InternalName: string; TypeAsString: string }[] = await SPCollection(this, "fields").select("InternalName", "TypeAsString").filter("Hidden ne true")();
+
+    // group field defaults by path
+    const defaultsByPath = {};
+    for (let i = 0; i < defaults.length; i++) {
+        if (defaultsByPath[defaults[i].path] == null) {
+            defaultsByPath[defaults[i].path] = [defaults[i]];
+        } else {
+            defaultsByPath[defaults[i].path].push(defaults[i]);
+        }
+    }
+
+    const paths = Object.getOwnPropertyNames(defaultsByPath);
+    const pathDefaults: string[] = [];
+    // For each path, group field defaults
+    for (let j = 0; j < paths.length; j++) {
+        // map the values into the right format and produce our xml elements
+        const pathFields = defaultsByPath[paths[j]];
+        const tags: string[] = pathFields.map(fieldDefault => {
+
+            const index = fieldDefs.findIndex(fd => fd.InternalName === fieldDefault.name);
+
+            if (index < 0) {
+                throw Error(`Field '${fieldDefault.name}' does not exist in the list. Please check the internal field name. Failed to set defaults.`);
+            }
+
+            const fieldDef = fieldDefs[index];
+            let value = "";
+
+            switch (fieldDef.TypeAsString) {
+                case "Boolean":
+                case "Currency":
+                case "Text":
+                case "DateTime":
+                case "Number":
+                case "Choice":
+                case "User":
+                    if (isArray(fieldDefault.value)) {
+                        throw Error(`The type '${fieldDef.TypeAsString}' does not support multiple values.`);
+                    }
+                    value = `${fieldDefault.value}`;
+                    break;
+
+                case "MultiChoice":
+                    if (isArray(fieldDefault.value)) {
+                        value = fieldDefault.value.map(v => `${v}`).join(";");
+                    } else {
+                        value = `${fieldDefault.value}`;
+                    }
+                    break;
+
+                case "UserMulti":
+                    if (isArray(fieldDefault.value)) {
+                        value = fieldDefault.value.map(v => `${v}`).join(";#");
+                    } else {
+                        value = `${fieldDefault.value}`;
+                    }
+                    break;
+
+                case "Taxonomy":
+                case "TaxonomyFieldType":
+                    if (isArray(fieldDefault.value)) {
+                        throw Error(`The type '${fieldDef.TypeAsString}' does not support multiple values.`);
+                    } else {
+                        value = `${fieldDefault.value.wssId};#${(<any>fieldDefault.value).termName}|${(<any>fieldDefault.value).termId}`;
+                    }
+                    break;
+
+                case "TaxonomyMulti":
+                case "TaxonomyFieldTypeMulti":
+                    if (isArray(fieldDefault.value)) {
+                        value = fieldDefault.value.map(v => `${v.wssId};#${v.termName}|${v.termId}`).join(";#");
+                    } else {
+                        value = [fieldDefault.value].map(v => `${v.wssId};#${v.termName}|${v.termId}`).join(";#");
+                    }
+                    break;
+            }
+
+            return `<DefaultValue FieldName="${fieldDefault.name}">${value}</DefaultValue>`;
+        });
+        const href = pathFields[0].path.replace(/ /gi, "%20");
+        const pathDefault = `<a href="${href}">${tags.join("")}</a>`;
+        pathDefaults.push(pathDefault);
+    }
+
+    // builds update to defaults
+    const xml = `<MetadataDefaults>${pathDefaults.join("")}</MetadataDefaults>`;
+    const pathPart: { ServerRelativePath: IResourcePath } = await this.rootFolder.select("ServerRelativePath")();
+    const webUrl: { ParentWeb: { Url: string } } = await this.select("ParentWeb/Url").expand("ParentWeb")();
+    const path = combine("/", pathPart.ServerRelativePath.DecodedUrl, "Forms");
+    const baseFilePath = combine(webUrl.ParentWeb.Url, "_api/web", `getFolderByServerRelativePath(decodedUrl='${encodePath(path)}')`, "files");
+
+    await spPost(Folder([this, baseFilePath], "add(overwrite=true,url='client_LocationBasedDefaults.html')"), { body: xml });
+
+    // finally we need to ensure this list has the right event receiver added
+    const existingReceivers = await this.eventReceivers.filter("ReceiverName eq 'LocationBasedMetadataDefaultsReceiver ItemAdded'").select("ReceiverId")();
+
+    if (existingReceivers.length < 1) {
+        await spPost(List(this.eventReceivers, "add"), body({
+            eventReceiverCreationInformation: {
+                EventType: 10001,
+                ReceiverAssembly: "Microsoft.Office.DocumentManagement, Version=16.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c",
+                ReceiverClass: "Microsoft.Office.DocumentManagement.LocationBasedMetadataDefaultsReceiver",
+                ReceiverName: "LocationBasedMetadataDefaultsReceiver ItemAdded",
+                SequenceNumber: 1000,
+                Synchronization: 1,
+            },
+        }));
+    }
+};

package/packages/sp/column-defaults/types.ts

@@ -0,0 +1,19 @@
+export type AllowedDefaultColumnValues = number | string | boolean | { wssId: string; termName: string; termId: string };
+
+export interface IFieldDefaultProps {
+    /**
+     * Internal name of the field
+     */
+    name: string;
+    /**
+     * The value of the field to set
+     */
+    value: AllowedDefaultColumnValues | AllowedDefaultColumnValues[];
+}
+
+export interface IFieldDefault extends IFieldDefaultProps {
+    /**
+     * The unencoded server relative path for this default
+     */
+    path: string;
+}

package/packages/sp/comments/clientside-page.ts

@@ -0,0 +1,120 @@
+import { _ClientsidePage } from "../clientside-pages/types.js";
+import { ICommentInfo, IComment, ILikedByInformation } from "./types.js";
+import { IItemUpdateResult, Item } from "../items/index.js";
+import { spPost } from "../operations.js";
+import { SPQueryable } from "../spqueryable.js";
+
+declare module "../clientside-pages/types" {
+    interface _ClientsidePage {
+        addComment(info: string | ICommentInfo): Promise<IComment & ICommentInfo>;
+        getCommentById(id: string | number): Promise<IComment & ICommentInfo>;
+        clearComments(): Promise<boolean>;
+        getComments(): Promise<ICommentInfo[]>;
+        like(): Promise<void>;
+        unlike(): Promise<void>;
+        getLikedByInformation(): Promise<ILikedByInformation>;
+        enableComments(): Promise<IItemUpdateResult>;
+        disableComments(): Promise<IItemUpdateResult>;
+        setCommentsOn(on: boolean): Promise<IItemUpdateResult>;
+    }
+    interface IClientsidePage {
+        /**
+         * Adds a comment to this page
+         *
+         * @param info The comment information
+         */
+        addComment(info: string | Partial<ICommentInfo>): Promise<IComment & ICommentInfo>;
+        /**
+         *
+         * @param id gets a comment by id
+         */
+        getCommentById(id: string | number): Promise<IComment & ICommentInfo>;
+        /**
+         * Deletes all comments for this page
+         */
+        clearComments(): Promise<boolean>;
+        /**
+         * Gets all the comments for this page
+         */
+        getComments(): Promise<ICommentInfo[]>;
+        /**
+         * Like this page
+         */
+        like(): Promise<void>;
+        /**
+         * Unlike this page
+         */
+        unlike(): Promise<void>;
+        /**
+         * gets list of who likes the page, current user's status, a few other details
+         */
+        getLikedByInformation(): Promise<ILikedByInformation>;
+        /**
+         * Enables comments for this page
+         */
+        enableComments(): Promise<IItemUpdateResult>;
+        /**
+         * Disables comments for this page
+         */
+        disableComments(): Promise<IItemUpdateResult>;
+    }
+}
+
+_ClientsidePage.prototype.addComment = async function (this: _ClientsidePage, info: string | ICommentInfo): Promise<IComment & ICommentInfo> {
+
+    const item = await this.getItem();
+    return item.comments.add(info);
+};
+
+_ClientsidePage.prototype.getCommentById = async function (this: _ClientsidePage, id: string | number): Promise<IComment & ICommentInfo> {
+
+    const item = await this.getItem();
+    const data = await item.comments.getById(id)();
+    return Object.assign(item.comments.getById(id), data);
+};
+
+_ClientsidePage.prototype.clearComments = async function (this: _ClientsidePage): Promise<boolean> {
+
+    const item = await this.getItem();
+    return item.comments.clear();
+};
+
+_ClientsidePage.prototype.getComments = async function (this: _ClientsidePage): Promise<ICommentInfo[]> {
+
+    const item = await this.getItem();
+    return item.comments();
+};
+
+_ClientsidePage.prototype.like = async function (this: _ClientsidePage): Promise<void> {
+    const item = await this.getItem("ID");
+    return spPost<void>(SPQueryable(item, "like"));
+};
+
+_ClientsidePage.prototype.unlike = async function (this: _ClientsidePage): Promise<void> {
+    const item = await this.getItem("ID");
+    return spPost<void>(SPQueryable(item, "unlike"));
+};
+
+_ClientsidePage.prototype.getLikedByInformation = async function (this: _ClientsidePage): Promise<ILikedByInformation> {
+    const item = await this.getItem("ID");
+    return item.getLikedByInformation();
+};
+
+_ClientsidePage.prototype.enableComments = async function (this: _ClientsidePage): Promise<IItemUpdateResult> {
+    return this.setCommentsOn(true).then(r => {
+        this.commentsDisabled = false;
+        return r;
+    });
+};
+
+_ClientsidePage.prototype.disableComments = async function (this: _ClientsidePage): Promise<IItemUpdateResult> {
+    return this.setCommentsOn(false).then(r => {
+        this.commentsDisabled = true;
+        return r;
+    });
+};
+
+_ClientsidePage.prototype.setCommentsOn = async function (this: _ClientsidePage, on: boolean): Promise<IItemUpdateResult> {
+    const item = await this.getItem();
+    return Item(item, `SetCommentsDisabled(${!on})`).update({});
+};

package/packages/sp/comments/index.ts

@@ -0,0 +1,14 @@
+import "./item.js";
+
+export {
+    Comment,
+    Comments,
+    IComment,
+    ICommentAuthorData,
+    ICommentInfo,
+    IComments,
+    IReplies,
+    Replies,
+    ILikeData,
+    ILikedByInformation,
+} from "./types.js";

package/packages/sp/comments/item.ts

@@ -0,0 +1,77 @@
+import { addProp } from "@pnp/queryable";
+import { _Item, Item } from "../items/types.js";
+import { Comments, IComments, ILikeData, ILikedByInformation, RatingValues } from "./types.js";
+import { spPost } from "../operations.js";
+import { extractWebUrl } from "../utils/extract-web-url.js";
+import { combine } from "@pnp/core";
+import { SPQueryable } from "../spqueryable.js";
+
+declare module "../items/types" {
+    interface _Item {
+        readonly comments: IComments;
+        getLikedBy(): Promise<ILikeData[]>;
+        like(): Promise<void>;
+        unlike(): Promise<void>;
+        getLikedByInformation(): Promise<ILikedByInformation>;
+        rate(rating: RatingValues): Promise<number>;
+    }
+    interface IItem {
+        readonly comments: IComments;
+        /**
+         * Gets the collection of people who have liked this item
+         */
+        getLikedBy(): Promise<ILikeData[]>;
+        /**
+         * Likes this client-side page as the current user
+         */
+        like(): Promise<void>;
+        /**
+         * Unlikes this client-side page as the current user
+         */
+        unlike(): Promise<void>;
+        /**
+         * Unlikes this item as the current user
+         */
+        getLikedByInformation(): Promise<ILikedByInformation>;
+        /**
+         * Rates this item as the current user
+         * @param rating rating number between 1-5
+         * @returns rating number
+         */
+        rate(rating: RatingValues): Promise<number>;
+    }
+}
+
+addProp(_Item, "comments", Comments);
+
+_Item.prototype.getLikedBy = function (this: _Item): Promise<ILikeData[]> {
+    return spPost<ILikeData[]>(Item(this, "likedBy"));
+};
+
+_Item.prototype.like = async function (this: _Item) {
+    const itemInfo = await this.getParentInfos();
+    const baseUrl = extractWebUrl(this.toUrl());
+    const reputationUrl = "_api/Microsoft.Office.Server.ReputationModel.Reputation.SetLike(listID=@a1,itemID=@a2,like=@a3)";
+    const likeUrl = combine(baseUrl, reputationUrl) + `?@a1='{${itemInfo.ParentList.Id}}'&@a2='${itemInfo.Item.Id}'&@a3=true`;
+    return spPost(SPQueryable([this, likeUrl]));
+};
+
+_Item.prototype.unlike = async function (this: _Item) {
+    const itemInfo = await this.getParentInfos();
+    const baseUrl = extractWebUrl(this.toUrl());
+    const reputationUrl = "_api/Microsoft.Office.Server.ReputationModel.Reputation.SetLike(listID=@a1,itemID=@a2,like=@a3)";
+    const likeUrl = combine(baseUrl, reputationUrl) + `?@a1='{${itemInfo.ParentList.Id}}'&@a2='${itemInfo.Item.Id}'&@a3=false`;
+    return spPost(SPQueryable([this, likeUrl]));
+};
+
+_Item.prototype.getLikedByInformation = function (this: _Item): Promise<ILikedByInformation> {
+    return Item(this, "likedByInformation").expand("likedby")<ILikedByInformation>();
+};
+
+_Item.prototype.rate = async function (this: _Item, value: RatingValues): Promise<number> {
+    const itemInfo = await this.getParentInfos();
+    const baseUrl = extractWebUrl(this.toUrl());
+    const reputationUrl = "_api/Microsoft.Office.Server.ReputationModel.Reputation.SetRating(listID=@a1,itemID=@a2,rating=@a3)";
+    const rateUrl = combine(baseUrl, reputationUrl) + `?@a1='{${itemInfo.ParentList.Id}}'&@a2='${itemInfo.Item.Id}'&@a3=${value}`;
+    return spPost(SPQueryable([this, rateUrl]));
+};