chat4app-client-angular 1.0.0 → 1.0.1

package/chat4app.service.spec.ts

@@ -0,0 +1,17 @@
+import { Chat4AppService } from "./chat4app.service";
+
+
+
+
+
+describe('Chat4AppService', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [Chat4AppService]
+    });
+  });
+
+  it('should be created', inject([Chat4AppService], (service: Chat4AppService) => {
+    expect(service).toBeTruthy();
+  }));
+});

package/chat4app.service.ts

@@ -0,0 +1,502 @@
+import { Injectable, OnDestroy } from '@angular/core';
+import { HttpClient, HttpHeaders  } from '@angular/common/http';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { environment } from '../../environments/environment';
+import * as Stomp from 'stompjs';
+import * as SockJS from 'sockjs-client';
+
+
+
+
+@Injectable()
+export class Chat4AppService  {
+  public chatUrl =  environment.serverChat4app + "/api/v1/";
+
+  sock: any;
+  stompClient: any;
+
+  constructor(
+    private http: HttpClient
+  ) { 
+
+  }
+
+  init(callback: any, chatCallback?: IChatCallback, token?: string) {
+      this.getTokenChat4app().subscribe((res: any)=>{
+        this.setTokenChat4app(res.token);
+
+        if (chatCallback && token){
+          this.connectWebsocket(chatCallback, token);
+        }
+        
+        callback(res.token);
+      })
+  }
+
+  getChatUrlDownload(messageFileId: string){
+    return this.chatUrl + "chatmessage/getFile?messageFileId=" + messageFileId;
+  }
+
+
+  getMessageChat(chatId: string,fromId: string,toId: string): Observable<Array<ChatMessage4App>> {
+    let url = this.chatUrl + "chatmessage/" + chatId + "/" + fromId + "/" + toId;
+
+    return this.http.get<Array<ChatMessage4App>>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+
+  }
+  getMessageChatByGrop(chatId: string,groupId: string, fromId: string): Observable<Array<ChatMessage4App>> {
+    let url = this.chatUrl + "chatmessage/byGroup/" + chatId + "/" + groupId + "/" + fromId;
+
+    return this.http.get<Array<ChatMessage4App>>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+
+  }
+
+
+  addMessageChat(chatMessage4App: ChatMessage4App): Observable<ChatMessage4App> {
+    let url = this.chatUrl + "chatmessage/" + chatMessage4App.chatId;
+
+    return this.http.post<ChatMessage4App>(url,chatMessage4App,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+
+  }
+  props(chatFilterRequest4App: Array< ChatFilterRequest4App>): Observable<ChatUserResponse4App> {
+    let url = this.chatUrl + "chatmessage/props" ;
+
+    return this.http.post<ChatUserResponse4App>(url,chatFilterRequest4App,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+
+  }
+
+  
+  removeUsersChat(chatId: string, chatUsersId?: string[], chatUsersExternalId?: string[]): Observable<ChatUser4App[]> {
+    let params = new Array();
+    if (chatUsersId && chatUsersId.length>0) {
+
+      chatUsersId.forEach(cui=>{
+        params.push("chatUserId=" + cui);
+      });
+    } else if (chatUsersExternalId && chatUsersExternalId.length > 0){
+      chatUsersExternalId.forEach(cuei=>{
+        params.push("chatUserExternalId=" + cuei);
+      })
+
+    }
+
+    let url = this.chatUrl + "chatuser/" + chatId + "?" + params.join("&");
+
+    return this.http.delete<ChatUser4App[]>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+  removeUserChat(chatId: string, chatUserId?: string, chatUserExternalId?: string): Observable<ChatUser4App> {
+    let param = "";
+    if (chatUserId) {
+      param = "chatUserId=" + chatUserId;
+    } else {
+      param = "chatUserExternalId=" + chatUserExternalId;
+    }
+
+    let url = this.chatUrl + "chatuser/" + chatId + "?" + param;
+
+    return this.http.delete<ChatUser4App>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+  updateUserChat(chatId: string, charUser4AppUpdate: ChatUser4App): Observable<ChatUser4App> {
+
+    let url = this.chatUrl + "chatuser/" + chatId ;
+
+    return this.http.put<ChatUser4App>(url, charUser4AppUpdate,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+
+  createUserChat(chatId: string, chatUser4App: ChatUser4App): Observable<ChatUser4App> {
+    let url = this.chatUrl + "chatuser/" + chatId;
+
+    return this.http.post<ChatUser4App>(url,chatUser4App,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+  createUsersChat(chatId: string, chatUser4App: ChatUser4App[]): Observable<ChatUser4App[]> {
+    let url = this.chatUrl + "chatuser/users/" + chatId;
+
+    return this.http.post<ChatUser4App[]>(url,chatUser4App,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+
+  createChat(chat4app: Chat4App): Observable<Chat4App> {
+    let url = this.chatUrl + "chat";
+
+    return this.http.post<Chat4App>(url,chat4app,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+  createUpdateChat(chat4app: Chat4App): Observable<Chat4App> {
+    let url = this.chatUrl + "chat";
+
+    return this.http.put<Chat4App>(url,chat4app,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+  
+  getLastMessageGroup(chatExternalId: string, groupId: string): Observable<ChatUserResponse4App> {
+
+    let url = this.chatUrl + "chatmessage/lastMessageGroup?chatExternalId=" + chatExternalId + "&groupId=" + groupId;
+
+    return this.http.get<ChatUserResponse4App>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+  getLastMessage(chatExternalId: string, chatUserExternalId: string): Observable<ChatUserResponse4App> {
+
+    let url = this.chatUrl + "chatmessage/lastMessage?chatExternalId=" + chatExternalId + "&chatUserExternalId=" + chatUserExternalId;
+
+    return this.http.get<ChatUserResponse4App>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+  countNotReadMessages(chatUserExternalId: string, chatExternalId?: string, groupId?: string): Observable<ChatUserResponse4App> {
+
+    let url = this.chatUrl + "chatmessage/countNotReadMessages?chatUserExternalId=" + chatUserExternalId ;
+
+    if (chatExternalId && chatExternalId.length>0) {
+      url += "&chatExternalId=" + chatExternalId;
+    }
+
+    if (groupId && groupId.length>0) {
+      url += "&groupId=" + groupId;
+    }
+
+    return this.http.get<ChatUserResponse4App>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+
+  getChatByExternalId(externalId: string): Observable<Chat4App> {
+
+    let url = this.chatUrl + "chat?externalId=" + externalId;
+
+    return this.http.get<Chat4App>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+  readMessage(chatMessageId: string, toId?: string): Observable<void> {
+
+    let url = this.chatUrl + "chatmessage/read/" + chatMessageId;
+
+    if (toId && toId.length> 0) {
+      url += "/" + toId;
+    }
+
+    return this.http.put<void>(url,null,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+  online(chatId: string, chatUserId: string): Observable<number> {
+
+    let url = this.chatUrl + "chatmessage/online/" + chatId + "/" + chatUserId ;
+
+    return this.http.get<number>(url,
+      { 
+        headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+      })
+  }
+
+
+  public sendFile(chatId: string, fromId: string, toId: string, fileToUpload: File): Observable<ChatMessageFile4App> {
+    const endpoint =  this.chatUrl + "chatmessage/sendFile/" + chatId + "/" + fromId + "/" + toId;
+    
+    const formData: FormData = new FormData();
+    formData.append('file', fileToUpload);
+
+    return this.http
+      .post<ChatMessageFile4App>(endpoint, formData,
+        { 
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+        });
+  }
+
+  public sendFileGroup(chatId: string, fromId: string, groupId: string, fileToUpload: File): Observable<ChatMessageFile4App> {
+    const endpoint =  this.chatUrl + "chatmessage/sendFileGroup/" + chatId + "/" + fromId + "/" + groupId;
+    
+    const formData: FormData = new FormData();
+    formData.append('file', fileToUpload);
+
+    return this.http
+      .post<ChatMessageFile4App>(endpoint, formData,
+        { 
+          headers: new HttpHeaders().set('Authorization', this.getBearerToken()) 
+        });
+  }
+
+
+  /* Token */
+  getBearerToken(): string {
+
+    let ret = "Bearer " + window.sessionStorage.getItem("chat4AppSessionToken");
+
+    return ret;
+  }
+
+  getTokenChat4app() {
+    return this.http.post("/rest/secured/chat-helper", null);
+  }
+
+  setTokenChat4app(chat4AppSessionToken: string) {
+
+
+    window.sessionStorage.setItem("chat4AppSessionToken", chat4AppSessionToken);
+  }
+
+
+  /* Connection */
+
+  onMessageFirebaseReceived(data: any, chatCallback: IChatCallback) {
+
+
+    //alert("onMessageReceived connectFirebase");
+
+    if (data.chatMessageId && data.type == "msg") {
+
+      let chat4appMessage = new Chat4AppMessageReceive();
+      chat4appMessage.data.chatId = data.chatId;
+      chat4appMessage.data.chatMessageId = data.chatMessageId;
+      chat4appMessage.data.externalId = data.externalId;
+      chat4appMessage.data.fromId = data.fromId;
+      chat4appMessage.data.toId = data.toId;
+      chat4appMessage.data.dateHour = data.dateHour;
+      chat4appMessage.data.type = data.type;
+      chat4appMessage.notification.body = data.body;
+
+      if (data.fileId && data.fileId.length > 0) {
+        chat4appMessage.data.fileId = data.fileId;
+        chat4appMessage.data.fileName = data.fileName;
+        chat4appMessage.data.fileSize = data.fileSize;
+        chat4appMessage.data.fileType =data.fileType;
+
+      }
+
+      let datTmp = new Map<string,string>();
+
+      for (let key in data) {
+        datTmp.set(key, data[key]);
+      }
+
+      chat4appMessage.data.all = datTmp;
+
+      chatCallback.onMessage(chat4appMessage);
+      
+    }
+
+  }
+
+  public connectWebsocket(chatCallback: IChatCallback, token: string) {
+    this.disconnect();
+
+    // let ichatcallback: Array<IChatCallback> = window["iChatCallback"] ;
+
+    // if (!ichatcallback) {
+    //   ichatcallback = new Array();
+      
+    // }
+    // ichatcallback.push(chatCallback);
+
+    // window["iChatCallback"] = ichatcallback;
+
+    let securityToken = this.getBearerToken();
+    
+    this.sock = new SockJS( environment.serverChat4app +  '/stomp/gkz-stomp-endpoint?token=' + securityToken);
+    this.stompClient = Stomp.over(this.sock);
+    this.stompClient.debug = function (msg: any) {
+      console.log(msg);
+    }
+
+    this.stompClient.connect({}, (frame: any) => {
+      console.log(frame);
+
+      this.stompClient.subscribe('/queue/' + token, (msg: any) => {
+        //console.log('mensagem', msg);
+        
+        if (msg.command == "MESSAGE" ) {
+
+          // console.log(msg)
+
+          let msgObj = JSON.parse(msg.body) ;
+
+          let datTmp = new Map<string,string>();
+
+          
+
+          for (let key in msgObj.data) {
+            datTmp.set(key, msgObj.data[key]);
+          }
+      
+          msgObj.data.all = datTmp;
+      
+
+          chatCallback.onMessage(msgObj);
+          //callback(msg.body);
+          // ichatcallback.forEach((iChat)=>{
+          //   iChat.onMessage(JSON.parse(msg.body) );
+          // });
+        }
+
+      });
+    },
+      (message: any) => {
+        // check message for disconnect
+        console.log("Disconnect");
+
+        setTimeout(() => {
+          this.connectWebsocket(chatCallback, token);
+        }, 500);
+
+      });
+
+  }
+
+  public disconnect() {
+    console.log("disconnect")
+    try {
+      if (this.stompClient) {
+        this.stompClient.disconnect();
+      }
+  
+    }catch (e) {
+      console.log(e);
+    }
+  }
+
+
+ 
+}
+
+export class Chat4App {
+  id: string;
+  configId: string;
+  externalId: string;
+  title: string;
+  status: ChatStatus4App;
+  users: Array<ChatUser4App>;
+
+}
+export class ChatUser4App {
+  id: string;
+  name: string;
+  clientToken: string;
+  picturePath: string;
+  email: string;
+  externalId: string;
+  status: ChatUserStatus4App;
+}
+export class ChatMessage4App {
+  id: string;
+  fromId: string;
+  toId: string;
+  chatId: string;
+  title: string;
+  body: string;
+  meta: Array<ChatMessageMeta4App>;
+  groupId: string;
+  read: Boolean;
+  dateHourIncluded: Date;
+  chatMessageFile: ChatMessageFile4App;
+}
+export class ChatMessageFile4App {
+  id: string;
+  name: string;
+  type: string;
+  size: number;
+  fullPath: string;
+}
+export class ChatMessageMeta4App {
+  name: string;
+  value: string;
+}
+export class Chat4AppMessageReceive {
+  data: Chat4AppMessageReceiveData = new Chat4AppMessageReceiveData();
+  notification: Chat4AppMessageReceiveNotification = new Chat4AppMessageReceiveNotification();
+  token: string;
+}
+export class Chat4AppMessageReceiveData {
+  toId: string;
+  chatId: string;
+  dateHour: string;
+  chatMessageId: string;
+  externalId: string;
+  type: string;
+  fromId: string;
+  fileId: string;
+  fileName: string;
+  fileSize: number;
+  fileType: string;
+  all: Map<string,string>;
+
+
+
+}
+export class Chat4AppMessageReceiveNotification {
+  body: string;
+}
+
+export class ChatUserResponse4App {
+  totalMessages: number;
+  chat: Chat4App;
+  chatMessage: ChatMessage4App;
+  chats: ChatUserResponse4App[];
+}
+export class ChatFilterRequest4App {
+  type: ChatFilterType;
+  chatExternalId: string;
+  chatUserExternalId: string;
+  groupId: string;
+}
+
+export enum ChatStatus4App{
+  CREATED = "CREATED", 
+  CLOSED = "CLOSED"
+
+}
+export enum ChatUserStatus4App{
+  REMOVED = "REMOVED"
+
+}
+export enum ChatFilterType {
+  COUNT_NOT_READ = 1,
+  LAST_MESSAGE = 2
+}
+export interface IChatCallback {
+  onMessage(msg: Chat4AppMessageReceive): void;
+}
+

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "chat4app-client-angular",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
-  "main": "index.js",
+  "main": "chat4app.service.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "net": "^1.0.2",
+    "sockjs-client": "^1.6.1",
+    "stompjs": "^2.3.3"
+  }
 }