@hivegpt/hiveai-angular 0.0.380 → 0.0.382

package/esm2015/lib/components/bot-html-editor/bot-html-editor.component.js

@@ -0,0 +1,112 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { ChangeDetectorRef, Component, Input, } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+import { prod_environment, } from '../../../environments/environment';
+export class BotHtmlEditorComponent {
+    constructor(cdr, http) {
+        this.cdr = cdr;
+        this.http = http;
+        this.documentName = 'doc name';
+        this.quillConfig = {
+            toolbar: [
+                [{ header: '1' }, { header: '2' }, { font: [] }],
+                [{ list: 'ordered' }, { list: 'bullet' }],
+                ['bold', 'italic', 'underline'],
+                ['link'],
+                ['clean'],
+            ],
+        };
+    }
+    ngOnInit() {
+        this.environment = prod_environment;
+        setTimeout(() => {
+            if (this.isDocInEditMode) {
+                console.log('In Edit mode');
+                this.filldataInForm();
+            }
+            else {
+                console.log('In save mode');
+            }
+        }, 2500);
+    }
+    filldataInForm() {
+        var _a, _b;
+        if (this.documentContent) {
+            this.documentName = (_a = this.documentContent) === null || _a === void 0 ? void 0 : _a.name;
+            this.editorContent = (_b = this.documentContent) === null || _b === void 0 ? void 0 : _b.content;
+            this.cdr.detectChanges();
+        }
+    }
+    saveContent() {
+        if (!this.isDocInEditMode) {
+            this.saveContent_http().subscribe();
+        }
+        else {
+            this.saveContent_http().subscribe();
+        }
+    }
+    saveContent_http() {
+        console.log('API call function');
+        const url = `${this.environment.AGENTS_API}/ConversationDocuments?conversationId=${this.conversationId}&botId=${this.botId}`;
+        const headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            apiKey: 'WIz/qAm+EEmfOkFaUA/weA==',
+        });
+        let data = {
+            name: this.documentName,
+            content: this.editorContent,
+        };
+        return this.http.post(url, data, { headers }).pipe(switchMap((res) => {
+            if (res) {
+                //  alert('Saved Successfully');
+            }
+            this.cdr.markForCheck();
+            return of(res);
+        }), catchError((error) => {
+            console.error('Error fetching chatbot config: ', error);
+            return of(null);
+        }));
+    }
+    updateContent_http() {
+        console.log('API call function');
+        const url = `${this.environment.AGENTS_API}/ConversationDocuments/rename?conversationId=${this.conversationId}&botId=${this.botId}`;
+        const headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            apiKey: 'WIz/qAm+EEmfOkFaUA/weA==',
+        });
+        let data = {
+            name: this.documentName,
+            content: this.editorContent,
+        };
+        return this.http.put(url, data, { headers }).pipe(switchMap((res) => {
+            if (res) {
+                // alert('Updated Successfully');
+            }
+            this.cdr.markForCheck();
+            return of(res);
+        }), catchError((error) => {
+            console.error('Error fetching chatbot config: ', error);
+            return of(null);
+        }));
+    }
+}
+BotHtmlEditorComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'lib-bot-html-editor',
+                template: "<div style=\"padding: 12px\">\n  <div style=\"margin-top: 42px\" class=\"form-group\">\n    <input [(ngModel)]=\"documentName\" class=\"form-control\" type=\"text\" />\n    <button (click)=\"saveContent()\" class=\"save-btn\">Save</button>\n  </div>\n\n  <quill-editor\n    [(ngModel)]=\"editorContent\"\n    [modules]=\"quillConfig\"\n  ></quill-editor>\n</div>\n",
+                styles: [".save-btn{background-color:#f0f0f0;border:none;color:#333;margin-top:22px;position:absolute;right:16px;width:56px}"]
+            },] }
+];
+BotHtmlEditorComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: HttpClient }
+];
+BotHtmlEditorComponent.propDecorators = {
+    editorContent: [{ type: Input }],
+    isDocInEditMode: [{ type: Input }],
+    documentContent: [{ type: Input }],
+    conversationId: [{ type: Input }],
+    botId: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bot-html-editor.component.js","sourceRoot":"/mnt/50b3cdea-e297-435c-ad9c-0483c95c6d25/professional/HiveAI-Packages/Angular/projects/hivegpt/eventsgpt-angular/src/","sources":["lib/components/bot-html-editor/bot-html-editor.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  ViewChild,\n  ViewChildren,\n} from '@angular/core';\nimport { MatDrawer } from '@angular/material/sidenav';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\nimport { of, Subscription } from 'rxjs';\nimport { catchError, switchMap } from 'rxjs/operators';\nimport { formatNow, formatTimeStamps } from '../../utils/utils';\nimport {\n  dev_environment,\n  prod_environment,\n} from '../../../environments/environment';\nimport { ConversationService } from '../conversation.service';\nimport { Observable } from 'rxjs';\nimport { SocketService } from '../socket-service.service';\n\n@Component({\n  selector: 'lib-bot-html-editor',\n  templateUrl: './bot-html-editor.component.html',\n  styleUrls: ['./bot-html-editor.component.css'],\n})\nexport class BotHtmlEditorComponent implements OnInit {\n  @Input() editorContent: Observable<string>;\n  @Input() isDocInEditMode: any;\n  @Input() documentContent: any;\n  @Input() conversationId: any;\n  @Input() botId: any;\n\n  documentName: any = 'doc name';\n\n  environment: {\n    USERS_API;\n    BASE_URL;\n    AGENTS_API;\n  };\n\n  quillConfig = {\n    toolbar: [\n      [{ header: '1' }, { header: '2' }, { font: [] }],\n      [{ list: 'ordered' }, { list: 'bullet' }],\n      ['bold', 'italic', 'underline'],\n      ['link'],\n      ['clean'],\n    ],\n  };\n  constructor(private cdr: ChangeDetectorRef, private http: HttpClient) {}\n\n  ngOnInit(): void {\n    this.environment = prod_environment;\n\n    setTimeout(() => {\n      if (this.isDocInEditMode) {\n        console.log('In Edit mode');\n        this.filldataInForm();\n      } else {\n        console.log('In save mode');\n      }\n    }, 2500);\n  }\n\n  filldataInForm() {\n    if (this.documentContent) {\n      this.documentName = this.documentContent?.name;\n      this.editorContent = this.documentContent?.content;\n      this.cdr.detectChanges();\n    }\n  }\n\n  saveContent() {\n    if (!this.isDocInEditMode) {\n      this.saveContent_http().subscribe();\n    } else {\n      this.saveContent_http().subscribe();\n    }\n  }\n\n  saveContent_http() {\n    console.log('API call function');\n\n    const url = `${this.environment.AGENTS_API}/ConversationDocuments?conversationId=${this.conversationId}&botId=${this.botId}`;\n    const headers = new HttpHeaders({\n      'Content-Type': 'application/json',\n      apiKey: 'WIz/qAm+EEmfOkFaUA/weA==',\n    });\n\n    let data = {\n      name: this.documentName,\n      content: this.editorContent,\n    };\n\n    return this.http.post(url, data, { headers }).pipe(\n      switchMap((res: any) => {\n        if (res) {\n          //  alert('Saved Successfully');\n        }\n        this.cdr.markForCheck();\n\n        return of(res);\n      }),\n      catchError((error) => {\n        console.error('Error fetching chatbot config: ', error);\n\n        return of(null);\n      })\n    );\n  }\n\n  updateContent_http() {\n    console.log('API call function');\n\n    const url = `${this.environment.AGENTS_API}/ConversationDocuments/rename?conversationId=${this.conversationId}&botId=${this.botId}`;\n    const headers = new HttpHeaders({\n      'Content-Type': 'application/json',\n      apiKey: 'WIz/qAm+EEmfOkFaUA/weA==',\n    });\n\n    let data = {\n      name: this.documentName,\n      content: this.editorContent,\n    };\n\n    return this.http.put(url, data, { headers }).pipe(\n      switchMap((res: any) => {\n        if (res) {\n          // alert('Updated Successfully');\n        }\n        this.cdr.markForCheck();\n\n        return of(res);\n      }),\n      catchError((error) => {\n        console.error('Error fetching chatbot config: ', error);\n\n        return of(null);\n      })\n    );\n  }\n}\n"]}

package/esm2015/lib/components/bot.service.js

@@ -0,0 +1,50 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { HttpHeaders } from '@angular/common/http';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class BotsService {
+    constructor(http) {
+        this.http = http;
+        this.eventDescription = new Subject();
+        this.bot_api = 'https://agent-api.hivegpt.ai/';
+    }
+    fetchSpeechAuthorizationToken(botId, apiKey, domain) {
+        const headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'hive-bot-id': botId,
+            'domain-authority': domain
+        });
+        const apiUrl = `${this.bot_api}speech/issue_token`;
+        const url = `${apiUrl}`;
+        return this.http.get(url, { headers }).pipe(map((resp) => {
+            return resp.token;
+        }));
+    }
+    getWorkflowsByOrgId(orgId) {
+        const apiUrl = `${this.bot_api}workflows`;
+        const url = `${apiUrl}?org_id=${orgId}`;
+        return this.http.get(url).pipe(map((resp) => {
+            return resp;
+        }));
+    }
+    getWorkflowExecutionById(executionId) {
+        const apiUrl = `${this.bot_api}workflows/execution/${executionId}`;
+        return this.http.get(apiUrl).pipe(map((resp) => {
+            return resp;
+        }));
+    }
+}
+BotsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BotsService_Factory() { return new BotsService(i0.ɵɵinject(i1.HttpClient)); }, token: BotsService, providedIn: "root" });
+BotsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+BotsService.ctorParameters = () => [
+    { type: HttpClient }
+];
+//# sourceMappingURL=data:application/json;base64,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