sync msgs

ts/session/messages/outgoing/content/sync/ContactSyncMessage.ts

@@ -0,0 +1,113 @@
+import { SignalService } from '../../../../../protobuf';
+import { MessageParams } from '../../Message';
+import { ContentMessage, SyncMessage } from '..';
+import { ConversationController, textsecure, libloki, Whisper } from '../../../../../window';
+import { PubKey } from '../../../../types';
+import * as Data from '../../../../../../js/modules/data';
+
+interface ContactSyncMessageParams extends MessageParams {
+
+}
+
+export class ContactSyncMessage extends SyncMessage {
+  private readonly sendTo: Array<PubKey>;
+  private readonly blocked: Array<PubKey>; // <--- convert to Array<string>
+  private readonly options: any;
+
+  
+  constructor(params: MessageParams) {
+    super(params);
+  }
+
+  public from(message: ContentMessage) {
+    const { timestamp, identifier } = message;
+
+    return new ContactSyncMessage({timestamp, identifier});
+  }
+
+  protected syncProto() {
+    const request = new SignalService.SyncMessage.Request();
+    request.type = SignalService.SyncMessage.Request.Type.CONTACTS;
+
+    const syncMessage = new SignalService.SyncMessage();
+    syncMessage.request = request;
+    
+    // const contacts = new SignalService.SyncMessage.Contacts();
+    // contacts.
+
+    SignalService.SyncMessage.Configuration
+    SignalService.SyncMessage.Contacts.create(
+
+    );
+    SignalService.SyncMessage.Groups
+    SignalService.SyncMessage.OpenGroupDetails
+    SignalService.SyncMessage.Read
+    
+    const conversations = await Data.getAllConversations({ ConversationCollection: Whisper.ConversationCollection });
+    const contacts = conversations.filter((conversation: any) => {
+      return (
+        !conversation.isMe() &&
+        conversation.isPrivate() &&
+        !conversation.isSecondaryDevice() &&
+        conversation.isFriend()
+      );
+    });
+
+    const syncMessage = await libloki.api.createContactSyncProtoMessage(contacts);
+
+
+    // const rawContacts = this.sendTo.map(async (device: PubKey) => {
+    //   const conversation = ConversationController.get(device.key);
+
+    //   const profile = conversation.getLokiProfile();
+    //   const name = profile
+    //     ? profile.displayName
+    //     : conversation.getProfileName();
+        
+    //   const status = await conversation.safeGetVerified();
+    //   const protoState = textsecure.storage.protocol.convertVerifiedStatusToProtoState(
+    //     status
+    //   );
+
+    //   const verified = new SignalService.Verified({
+    //     state: protoState,
+    //     destination: device.key,
+    //     identityKey: textsecure.StringView.hexToArrayBuffer(device.key),
+    //   });
+
+    //   return {
+    //     name,
+    //     verified,
+    //     number: device.key,
+    //     nickname: conversation.getNickname(),
+    //     blocked: conversation.isBlocked(),
+    //     expireTimer: conversation.get('expireTimer'),
+    //   };
+    // });
+
+
+    // // Convert raw contacts to an array of buffers
+    // const contactDetails = rawContacts
+    //   .filter(x => x.number !== textsecure.storage.user.getNumber())
+    //   .map(x => new textsecure.protobuf.ContactDetails(x))
+    //   .map(x => x.encode());
+    // // Serialise array of byteBuffers into 1 byteBuffer
+    // const byteBuffer = serialiseByteBuffers(contactDetails);
+    // const data = new Uint8Array(byteBuffer.toArrayBuffer());
+    // const contacts = new textsecure.protobuf.SyncMessage.Contacts({
+    //   data,
+    // });
+    // const syncMessage = new textsecure.protobuf.SyncMessage({
+    //   contacts,
+    // });
+    // return syncMessage;
+
+
+
+  protected dataProto() {
+    if dataMess
+  }
+}
+
+const contactSyncMessage = new ContactSyncMessage({timestamp: Date.now(), identifier: 'sdfgfdsgfdsgsfdgfdsg'});
+

ts/session/messages/outgoing/content/sync/SyncMessage.ts

@@ -1,18 +1,50 @@
 import { ContentMessage } from '../ContentMessage';
 import { SignalService } from '../../../../../protobuf';
+import { DataMessage, AttachmentPointer } from '../data';
+
+
+interface UnidentifiedDeliveryStatus {
+  destination?: string;
+  unidentified?: boolean;
+}
+
+interface Sent {
+  UnidentifiedDeliveryStatus: UnidentifiedDeliveryStatus;
+  desination?: string;
+  timestamp?: number;
+  message?: DataMessage;
+  expirationStartTimestamp?: number;
+  unidentifiedStatus: Array<UnidentifiedDeliveryStatus>;
+}
+
+interface Contact {
+  blob?: AttachmentPointer;
+  complete?: boolean;
+  data: any;
+}
+
+export interface SyncMessageParams {
+
+}
 
 export abstract class SyncMessage extends ContentMessage {
   public static canSync(message: ContentMessage): boolean {
-    // TODO: implement
-    return true;
+    return message instanceof SyncMessage;
   }
 
+  public abstract from(message: ContentMessage): SyncMessage;
+
   public ttl(): number {
     return this.getDefaultTTL();
   }
 
   protected contentProto(): SignalService.Content {
+    const dataMessage = new SignalService.DataMessage({
+
+    });
+
     return new SignalService.Content({
+      dataMessage,
       syncMessage: this.syncProto(),
     });
   }

ts/session/messages/outgoing/content/sync/index.ts

@@ -1,3 +1,4 @@
-import * as SyncMessage from './SyncMessage';
+import { SyncMessage } from './SyncMessage';
+import { ContactSyncMessage } from './ContactSyncMessage';
 
-export { SyncMessage };
+export { ContactSyncMessage, SyncMessage };

ts/session/sending/MessageQueue.ts

@@ -9,18 +9,17 @@ import {
   GroupMessageType,
 } from './MessageQueueInterface';
 import {
+  ClosedGroupMessage,
   ContentMessage,
   OpenGroupMessage,
-  SyncMessage,
   SessionResetMessage,
-  ClosedGroupMessage,
+  SyncMessage,
 } from '../messages/outgoing';
 import { PendingMessageCache } from './PendingMessageCache';
 import {
   JobQueue,
   TypedEventEmitter,
   toRawMessage,
-  toSyncMessage,
 } from '../utils';
 import { PubKey } from '../types';
 import { ConversationController } from '../../window';
@@ -57,7 +56,7 @@ export class MessageQueue implements MessageQueueInterface {
 
     if (message.canSync(message)) {
       // Sync to our devices
-      const syncMessage = toSyncMessage(message);
+      const syncMessage = SyncMessage.from(message);
       const ourDevices = await this.sendSyncMessage(syncMessage);
 
       // Remove our devices from currentDevices
@@ -97,7 +96,7 @@ export class MessageQueue implements MessageQueueInterface {
     message: ContentMessage
   ): Promise<Array<PubKey>> {
     // Sync with our devices
-    const syncMessage = toSyncMessage();
+    const syncMessage = SyncMessage.from(message);
     if (!syncMessage.canSync()) {
       return;
     }

ts/session/sending/PendingMessageCache.ts

@@ -3,7 +3,7 @@ import {
   getItemById,
   bulkAddItems,
 } from '../../../js/modules/data';
-import { RawMessage, BareRawMessage } from '../types/RawMessage';
+import { RawMessage, PartialRawMessage } from '../types/RawMessage';
 import { ContentMessage } from '../messages/outgoing';
 import { PubKey } from '../types';
 import * as MessageUtils from '../utils';
@@ -108,11 +108,11 @@ export class PendingMessageCache {
       return [];
     }
 
-    const barePending = JSON.parse(String(data.value)) as Array<BareRawMessage>;
+    const barePending = JSON.parse(String(data.value)) as Array<PartialRawMessage>;
 
     // Rebuild plainTextBuffer
     // tslint:disable-next-line: no-unnecessary-local-variable
-    const pending = barePending.map((message: BareRawMessage) => {
+    const pending = barePending.map((message: PartialRawMessage) => {
       const rebuiltMessage = { ...message };
 
       // From Array<number> to ArrayBuffer

ts/session/types/RawMessage.ts

@@ -11,7 +11,7 @@ export interface RawMessage {
   encryption: EncryptionType;
 }
 
-export interface BareRawMessage {
+export interface PartialRawMessage {
   identifier: string;
   plainTextBuffer: any;
   timestamp: number;

ts/session/utils/Messages.ts

@@ -21,9 +21,4 @@ export function toRawMessage(
   };
 
   return rawMessage;
-}
-
-export function toSyncMessage(message: ContentMessage):  {
-
-  return SyncMessage;
 }

ts/session/utils/SyncMessageUtils.ts

@@ -0,0 +1,11 @@
+import { RawMessage } from '../types/RawMessage';
+import { ContentMessage, SyncMessage } from '../messages/outgoing';
+import { EncryptionType, PubKey } from '../types';
+
+export function from(message: ContentMessage): SyncMessage | undefined {
+  return new SyncMessage({})
+}
+
+export function canSync(message: ContentMessage): boolean {
+  return Boolean(from(message));
+}

ts/window/index.ts

@@ -134,6 +134,7 @@ export const deleteAccount = window.deleteAccount;
 export const resetDatabase = window.resetDatabase;
 export const attemptConnection = window.attemptConnection;
 
+export const dcodeIO = window.dcodeIO;
 export const libloki = window.libloki;
 export const libsignal = window.libsignal;
 export const textsecure = window.textsecure;