add search douban subject

douban/Douban.ts

@@ -6,14 +6,6 @@ interface DoubanPluginSettings {
     searchHeaders?:string
 }
 
-export interface DoubanExtract {
-	id: string,
-	type: string;
-	title: string;
-	desc: string;
-	url: string;
-}
-
 
 export const doubanHeadrs = {
     "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",

douban/DoubanExtractHandler.ts

@@ -0,0 +1,28 @@
+import DoubanPlugin from "main";
+import { App } from "obsidian";
+import DoubanMovieLoadHandler from "./handler/DoubanMovieLoadHandler";
+import DoubanSubjectLoadHandler from "./handler/DoubanSubjectLoadHandler";
+import DoubanSubject from "./model/DoubanSubject";
+
+export class DoubanEtractHandler {
+
+    private _app:App;
+    private _doubanPlugin:DoubanPlugin;
+    private _doubanSubjectHandlers:DoubanSubjectLoadHandler<DoubanSubject>[];
+
+    public DoubanEtractHandler(app:App, doubanPlugin:DoubanPlugin) {
+        this._app = app;
+        this._doubanPlugin = doubanPlugin;
+        this._doubanSubjectHandlers = [new DoubanMovieLoadHandler(), ]
+    }
+
+    public getSubjectTextById(searchExtract:DoubanSubject):string | undefined{
+        if(!searchExtract) {
+            return;
+        }
+
+
+    }
+
+}
+

douban/handler/DoubanAbstractLoadHandler.ts

@@ -0,0 +1,24 @@
+import { DoubanPluginSettings } from "douban/Douban";
+import DoubanSubject from "douban/model/DoubanSubject";
+import DoubanSubjectLoadHandler from "./DoubanSubjectLoadHandler";
+
+export default abstract class DoubanAbstractLoadHandler<T extends DoubanSubject> implements DoubanSubjectLoadHandler<T> {
+    
+    
+    doubanSettings:DoubanPluginSettings;
+
+    DoubanAbstractLoadHandler(doubanSettings:DoubanPluginSettings) {
+        this.doubanSettings = doubanSettings;
+    }
+    
+    abstract getSubject(url:string): T;
+    abstract getTextResult(url:string): string;
+    abstract getType(): string; 
+    
+
+
+    support(extract: DoubanSubject): boolean {
+        return extract && (this.getType() == extract.type);
+    }
+    
+}

douban/handler/DoubanMovieLoadHandler.ts

@@ -0,0 +1,67 @@
+import DoubanMovieSubject from "douban/model/DoubanMoveSubject";
+import { get, readStream } from "tiny-network";
+import { log } from "utils/logutil";
+import DoubanAbstractLoadHandler from "./DoubanAbstractLoadHandler";
+import cheerio, { CheerioAPI } from 'cheerio';
+
+
+export default class DoubanMovieLoadHandler extends DoubanAbstractLoadHandler<DoubanMovieSubject> {
+    
+    
+    
+    getSubject(url:string): DoubanMovieSubject {
+        return this.fetchFromDouban(url);
+    }
+    getTextResult(url:string): string {
+        throw new Error("Method not implemented.");
+    }
+    getType(): string {
+        throw new Error("Method not implemented.");
+    }
+ 
+    fetchFromDouban(url:string):DoubanMovieSubject {
+        const reuslt = await this.fetchFromDoubanWeb(url);
+        return reuslt;
+    }
+
+    fetchFromDoubanWeb(url:string):Promise<DoubanMovieSubject> {
+        return Promise
+            .resolve()
+            .then(() => get(url, JSON.parse(this.doubanSettings.searchHeaders)))
+            .then(readStream)
+            .then(log.info)
+            .then(cheerio.load)
+            .then(this.parseMovieSubjectFromHtml);
+    }
+
+    parseMovieSubjectFromHtml(responseHtml:CheerioAPI):DoubanMovieSubject {
+        return responseHtml('.result')
+        .get()
+        .map((i:any) => {
+            const item = responseHtml(i);
+            var idPattern = /(\d){5,10}/g;
+            var urlPattern = /(https%3A%2F%2F)\S+(\d){5,10}/g;
+            var linkValue = item.find("div.content > div > h3 > a").text();
+            var ececResult = idPattern.exec(linkValue);
+            var urlResult = urlPattern.exec(linkValue);
+            var cast = item.find(".subject-cast").text();
+            const result:DoubanMovieSubject = {
+                id: ececResult?ececResult[0]:'',
+                title: item.find("div.content > div > h3 > a").text(),
+                score: item.find(".rating_nums").text(),
+                // duration: item.attr('data-duration'),
+                // region: item.attr('data-region'),
+                // director: item.attr('data-director'),
+                // actors: item.attr('data-actors'),
+                // poster: item.find('.poster img').attr('src'),
+                cast: cast,
+                type: item.find("div.content > div > h3 > span").text(),
+                desc: item.find("div.content > p").text(),
+                url: urlResult?decodeURIComponent(urlResult[0]):'https://www.douban.com',
+            };
+            return result;
+        })[0];
+    }
+
+
+}

douban/handler/DoubanOtherLoadHandler.ts

@@ -0,0 +1,17 @@
+import DoubanSubject from "douban/model/DoubanSubject";
+import DoubanAbstractLoadHandler from "./DoubanAbstractLoadHandler";
+
+export default class DoubanOtherLoadHandler extends DoubanAbstractLoadHandler<DoubanSubject> {
+    getSubject(): DoubanSubject {
+        throw new Error("Method not implemented.");
+    }
+    getTextResult(): string {
+        throw new Error("Method not implemented.");
+    }
+    getType(): string {
+        return undefined;
+    }
+
+
+
+}

douban/handler/DoubanSubjectLoadHandler.ts

@@ -0,0 +1,13 @@
+import DoubanSubject from "douban/model/DoubanSubject";
+
+export default interface DoubanSubjectLoadHandler<T extends DoubanSubject> {
+
+    getType():string;
+
+    support(extract:DoubanSubject):boolean;
+
+    getSubject(url:string):T;
+
+    getTextResult(url:string):string;
+
+}

douban/model/DoubanMoveSubject.ts

@@ -0,0 +1,6 @@
+import DoubanSubject from "./DoubanSubject";
+
+export default class DoubanMovieSubject extends DoubanSubject  {
+	cast:string;
+	score:string;
+}

douban/model/DoubanSearchResultSubject.ts

@@ -0,0 +1,6 @@
+import DoubanSubject from "./DoubanSubject";
+
+export default class DoubanSearchResultSubject extends DoubanSubject {
+    score:string;
+    cast:string;
+} 

douban/model/DoubanSubject.ts

@@ -0,0 +1,7 @@
+export default class DoubanExtract {
+	id: string;
+	type: string;
+	title: string;
+	desc: string;
+	url: string;
+}

douban/search/DoubanSearchFuzzySuggestModal.ts

@@ -18,6 +18,21 @@ class DoubanFuzzySuggester extends FuzzySuggestModal<DoubanSearchResultExtract>
         this.app = app;
         this.plugin = plugin;
         this.setPlaceholder("Choose an item...");
+
+        // this.inputEl.addEventListener("keydown", (event) => {
+        //     if (event.key === "Enter") {
+        //         log.info("enter")
+        //       this.reloadSearch();
+        //     }
+        //   })
+
+    }
+
+    async reloadSearch() {
+        if(this.inputEl.value) {
+            log.info("reload search")
+            this.doubanSearchResultExtract = await this.plugin.getDoubanSearchList(this.inputEl.value);
+        }
     }
 
     getItems(): DoubanSearchResultExtract[] {
@@ -25,12 +40,12 @@ class DoubanFuzzySuggester extends FuzzySuggestModal<DoubanSearchResultExtract>
     }
 
     getItemText(item: DoubanSearchResultExtract): string {
-        let text:string = item.type + ":" + item.title + " [score]:" + item.score + ",[cast]:" + item.cast;
+        let text:string = item.type + "/"  + item.score + "/" + item.title + "/" + item.cast;
         return text;
     }
 
     onChooseItem(item: DoubanSearchResultExtract, evt: MouseEvent | KeyboardEvent): void {
-        log.warn("choose item  " + item.title + " id " + item.id);
+        this.plugin.geDoubanMovieTextForSearchTerm
     }
 
     public showSearchList(doubanSearchResultExtractList:DoubanSearchResultExtract[]) {

douban/search/DoubanSearchModal.ts

@@ -0,0 +1,69 @@
+import { App, Editor, Modal, TextComponent } from "obsidian";
+import { log } from "utils/logutil";
+import  DoubanPlugin  from "../../main";
+
+export class DoubanSearchModal extends Modal {
+	searchTerm: string;
+	plugin: DoubanPlugin;
+	editor: Editor;
+  
+	constructor(app: App, plugin: DoubanPlugin, editor: Editor) {
+	  super(app);
+	  this.plugin = plugin;
+	  this.editor = editor;
+	}
+  
+	onOpen() {
+	  let { contentEl } = this;
+
+	  contentEl.createEl("h2", { text: "Enter Search Term:" });
+  
+	  const inputs = contentEl.createDiv("inputs");
+	  const searchInput = new TextComponent(inputs).onChange((searchTerm) => {
+		this.searchTerm = searchTerm;
+	  });
+	  searchInput.inputEl.focus();
+	  searchInput.inputEl.addEventListener("keydown", (event) => {
+		if (event.key === "Enter") {
+		  this.search();
+		}
+	  });
+	  
+
+
+	  const controls = contentEl.createDiv("controls");
+	  const searchButton = controls.createEl("button", {
+		text: "Search",
+		cls: "mod-cta",
+		attr: {
+		  autofocus: true,
+		},
+	  });
+	  searchButton.addEventListener("click", this.close.bind(this));
+	  const cancelButton = controls.createEl("button", { text: "Cancel" });
+	  cancelButton.addEventListener("click", this.close.bind(this));
+	}
+	async search() {
+		log.info("start search :" + this.searchTerm);
+		let { contentEl } = this;
+		contentEl.empty();
+		if (this.searchTerm) {
+			this.close();
+			await this.plugin.search(this.searchTerm);
+			// await this.plugin.pasteIntoEditor(this.editor, null);
+
+		}
+	}
+
+
+  
+	async onClose() {
+	  let { contentEl } = this;
+  
+	  contentEl.empty();
+	  if (this.searchTerm) {
+		// await this.plugin.pasteIntoEditor(this.editor, this.searchTerm);
+	  }
+	}
+
+  }

douban/search/Search.ts

@@ -2,11 +2,12 @@ import cheerio from 'cheerio';
 import { doubanHeadrs, DoubanPluginSettings } from 'douban/Douban';
 import { get, readStream } from 'tiny-network';
 import { ensureStatusCode } from 'douban/ResponseHandle';
-import { DoubanSearchResultExtract, SearchParserHandler } from './SearchParser';
 import { log } from 'utils/logutil';
+import DoubanSearchResultSubject from 'douban/model/DoubanSearchResultSubject';
+import SearchParserHandler from './SearchParser';
 
-class Searcher {
+export default class Searcher {
-  static search(searchItem:string, doubanSettings:DoubanPluginSettings):Promise<DoubanSearchResultExtract[]> {
+  static search(searchItem:string, doubanSettings:DoubanPluginSettings):Promise<DoubanSearchResultSubject[]> {
     // getData();
     // getData2();
     // return Promise.resolve();
@@ -20,5 +21,3 @@ class Searcher {
         .then(SearchParserHandler.parseSearch);
   };
 }
-
-export {Searcher}

douban/search/SearchParser.ts

@@ -1,15 +1,8 @@
 import { CheerioAPI } from "cheerio";
-import { DoubanExtract } from "douban/Douban";
+import DoubanSearchResultSubject from "douban/model/DoubanSearchResultSubject";
-import { type } from "os";
 
-interface DoubanSearchResultExtract extends DoubanExtract{
+export default class SearchParserHandler {
-	cast: string;
+    static parseSearch(dataHtml:CheerioAPI):DoubanSearchResultSubject[]  {
-	score: string;
-}
-
-
-class SearchParserHandler {
-    static parseSearch(dataHtml:CheerioAPI):DoubanSearchResultExtract[]  {
         return dataHtml('.result')
             .get()
             .map((i:any) => {
@@ -20,7 +13,7 @@ class SearchParserHandler {
                 var ececResult = idPattern.exec(linkValue);
                 var urlResult = urlPattern.exec(linkValue);
                 var cast = item.find(".subject-cast").text();
-                const result:DoubanSearchResultExtract = {
+                const result:DoubanSearchResultSubject = {
                     id: ececResult?ececResult[0]:'',
                     title: item.find("div.content > div > h3 > a").text(),
                     score: item.find(".rating_nums").text(),
@@ -37,7 +30,4 @@ class SearchParserHandler {
                 return result;
             })
     };
-}
+}
-
-export {SearchParserHandler}
-export type {DoubanSearchResultExtract}

main.ts

@@ -1,4 +1,5 @@
-import { DoubanSearchModal } from "douban/DoubanSearchModal";
+import { DoubanEtractHandler } from "douban/DoubanExtractHandler";
+import { DoubanSearchModal } from "douban/search/DoubanSearchModal";
 import { DoubanSettingTab } from "douban/DoubanSettingTab";
 import { DoubanFuzzySuggester } from "douban/search/DoubanSearchFuzzySuggestModal";
 import { Editor, Notice, Plugin} from "obsidian";
@@ -10,6 +11,7 @@ import { DoubanSearchResultExtract } from "./douban/search/SearchParser";
 export default class DoubanPlugin extends Plugin {
 	public settings: DoubanPluginSettings;
 	public fuzzySuggester: DoubanFuzzySuggester;
+	public doubanEtractHandler: DoubanEtractHandler;
 
 
 	formatExtractText(extract: DoubanExtract): string {
@@ -29,22 +31,6 @@ export default class DoubanPlugin extends Plugin {
 		log.error(`Could not automatically resolve disambiguation.`);
 	}
   
-  
-	parseSearchList(extract: DoubanSearchResultExtract[]):DoubanSearchResultExtract[] {
-		// return extract.map(result => {
-		// 	return {
-		// 	id: result.id,
-		// 	type: result.type,
-		// 	title: result.title,
-		// 	desc: result.desc,
-		// 	url: result.url,
-		// 	score: result.score,
-		// 	cast: result.cast
-		// 	}
-		// })
-		return extract;
-	}
-  
 	async getDoubanSearchList(title: string): Promise<DoubanSearchResultExtract[] | undefined> {
 		return Searcher.search(title, this.settings);
 	  }
@@ -56,10 +42,15 @@ export default class DoubanPlugin extends Plugin {
 	  return null;
 	}
   
+	getAndPasteIntoEditor(extract: DoubanExtract) {
+		if (!extract) {
+		  this.handleNotFound("Not Found Subject");
+		  return;
+		}
 
+	}
 
 	async pasteIntoEditor(editor: Editor, extract: DoubanExtract) {
-
 	  if (!extract) {
 		this.handleNotFound("Not Found Subject");
 		return;
@@ -71,11 +62,10 @@ export default class DoubanPlugin extends Plugin {
 	async search(searchTerm:string) {
 		log.info("plugin search :" + searchTerm);
 		const resultListPromise = this.getDoubanSearchList(searchTerm);
-		resultListPromise.then(log.info);
 		const resultList = await resultListPromise;
-		const result = this.parseSearchList(resultList);
+		// const result = this.parseSearchList(resultList);
-		log.info("plugin search result:" + JSON.stringify(result));
+		log.info("plugin search result:" + JSON.stringify(resultList));
-		this.fuzzySuggester.showSearchList(result);
+		this.fuzzySuggester.showSearchList(resultList);
 	}
 
 	async getDoubanMovieTextForActiveFile(editor: Editor) {
@@ -113,6 +103,7 @@ export default class DoubanPlugin extends Plugin {
   
 	  this.addSettingTab(new DoubanSettingTab(this.app, this));
 	  this.fuzzySuggester = new DoubanFuzzySuggester(this.app, this);
+	  this.doubanEtractHandler = new DoubanEtractHandler(this.app, this);
 	}
   
 	async loadSettings() {