Added eventsearch extenstion

Author: eiksta

src/extensions/EventSearchExtensionProjections.ts

@@ -1,4 +1,11 @@
 // import { EventContext } from "matrix-js-sdk/src/models/event-context"; // eslint-disable-line
+// import { EventContext } from "matrix-js-sdk/src/models/event-context"; // eslint-disable-line
+// import { MatrixEvent } from "matrix-js-sdk/src/models/event"; // eslint-disable-line
+
+export interface SearchResultItem {
+    result: MatrixEventProjection;
+    context: EventContextProjection;
+}
 
 export enum DirectionProjection {
     Backward = "b",
@@ -46,6 +53,8 @@ export interface IPaginateOptsProjection {
 
 export interface  MatrixClientProjection {
      paginateEventTimeline(eventTimeline: EventTimelineProjection, opts: IPaginateOptsProjection): Promise<boolean>;
+    //  processRoomEventsSearch(searchResults, searchResponse);
+     processRoomEventsSearch<T extends ISearchResultsProjection>(searchResults: T, response: ISearchResponseProjection): T;
 }
 
 export interface RoomMemberProjection {
@@ -114,3 +123,133 @@ export interface EventContextProjection {
 
     getEvent(): MatrixEventProjection;
 }
+
+
+// export function convertRes(client: MatrixClientProjection, matches : SearchResultItem[]) : any
+// export function convertRes(client: MatrixClientProjection, room: RoomProjection, termObj:any, memberObj : any) : any
+// {
+//     const searchResults: ISearchResultsProjection = {
+//         results: [],
+//         highlights: [],
+//         count: 0,
+//     };
+
+//     const matches = findAllMatches(termObj, room, memberObj);
+
+//     // const converted : 
+
+//     // Process the matches to produce the equivalent result from a client.search() call
+//     // const searchResponse = getClientSearchResponse(searchResults, converted);
+
+//     // mimic the original code
+//     // const results = client.processRoomEventsSearch(searchResults, searchResponse);
+
+//     return matches;
+
+// }
+
+//  export function createResultObj(roomEvent : MatrixEvent, prevEvent: MatrixEvent) : EventContext {
+// // export function createResultObj(roomEvent : MatrixEventProjection, prevEvent: MatrixEventProjection) : EventContext {
+//     const evCtx = new EventContext(roomEvent);
+//     if (prevEvent !== null) {
+//         evCtx.addEvents([prevEvent], true);
+//     }
+
+//     return evCtx;
+// }
+
+// export function reverseEventContext(eventContext: EventContext): EventContextProjection {
+//     const contextTimeline = eventContext.getTimeline();
+//     const ourEventIndex = eventContext.getOurEventIndex();
+//     const ourEvent = eventContext.getEvent();
+//     const reversedContext = new EventContext(contextTimeline[ourEventIndex]);
+//     let afterOurEvent = false;
+
+//     for (let i = 0; i < contextTimeline.length; i++) {
+//         const event = contextTimeline[i];
+//         if (event.getId() === ourEvent.getId()) {
+//             afterOurEvent = true;
+//             continue;
+//         }
+//         if (afterOurEvent) {
+//             reversedContext.addEvents([event], true);
+//             this.ourEventIndex += [event].length;
+//         } else {
+//             this.timeline = this.timeline.concat(event);
+//             reversedContext.addEvents([event], false);
+//         }
+//     }
+
+//     const evnt : EventContextProjection[];
+//     evnt.timeline = reversedContext.getTimeline();
+
+//     return evnt;
+//     // return reversedContext;
+// }
+
+
+
+
+// // export function findAllMatches(termObj: SearchTerm, room: Room, matchingMembers: MemberObj): SearchResultItem[] {
+// export function findAllMatches(termObj: any, room: RoomProjection, matchingMembers: any): SearchResultItem[] {
+//         const matches: SearchResultItem[] = [];
+//     let searchHit: SearchResultItem | null = null;
+//     let prevEvent: MatrixEventProjection | null = null;
+//     let timeline: EventTimelineProjection | null = room.getLiveTimeline();
+
+//     const iterationCallback = (roomEvent: MatrixEventProjection): void => {
+//         if (searchHit !== null) {
+//             searchHit.context.addEvents([roomEvent], false);
+//         }
+//         searchHit = null;
+
+//         if (roomEvent.getType() === "m.room.message" && !roomEvent.isRedacted()) {
+//             if (eventMatchesSearchTerms(termObj, roomEvent, matchingMembers)) {
+//                 const evCtx = new EventContext(roomEvent);
+//                 if (prevEvent !== null) {
+//                     evCtx.addEvents([prevEvent], true);
+//                 }
+
+//                 const resObj: SearchResultItem = { result: roomEvent, context: evCtx };
+//                 matches.push(resObj);
+//                 searchHit = resObj;
+//             }
+
+//             prevEvent = roomEvent;
+//         }
+//     };
+
+//     // This code iterates over a timeline, retrieves events from the timeline, and invokes a callback function for each event in reverse order.
+//     while (timeline) {
+//         const events = timeline.getEvents();
+//         for (let i = events.length - 1; i >= 0; i--) {
+//             iterationCallback(events[i]);
+//         }
+//         timeline = timeline.getNeighbouringTimeline(DirectionProjection.Forward);
+//     }
+
+//     return matches;
+// }
+
+// // function getClientSearchResponse(searchResults: ISearchResults, matches: SearchResultItem[]): ISearchResponse {
+// //     const response: ISearchResponse = {
+// //         search_categories: {
+// //             room_events: {
+// //                 count: 0,
+// //                 highlights: [],
+// //                 results: [],
+// //             },
+// //         },
+// //     };
+
+// //     response.search_categories.room_events.count = matches.length;
+// //     for (let i = 0; i < matches.length; i++) {
+// //         const reversedContext = reverseEventContext(matches[i].context);
+
+// //         const sr = new SearchResult(0, reversedContext);
+// //         searchResults.results.push(sr);
+// //     }
+
+// //     return response;
+// // }
+

src/extensions/EventSearchExtensions.ts

@@ -1,4 +1,4 @@
-import { EventContextProjection, ISearchResultsProjection } from "./EventSearchExtensionProjections"
+import { EventContextProjection, ISearchResultsProjection, MatrixEventProjection } from "./EventSearchExtensionProjections"
 
 export interface MatrixClientProjection {
     getStateEvent(finalRoomId: string, eventType: string, stateKey: string):  Promise<Record<string, any>>;