refactor to Visible and ControlMessage types

pull/1542/head
Audric Ackermann 4 years ago
parent 13d21e94ca
commit 79193ee7be
No known key found for this signature in database
GPG Key ID: 999F434D76324AD4

@ -30,7 +30,7 @@
this.chatName = convo.get('name');
this.chatServer = convo.get('server');
this.channelId = convo.get('channelId');
this.isPublic = !!convo.cachedProps.isPublic;
this.isPublic = !!convo.isPublic();
this.convo = convo;
this.$el.focus();

@ -44,7 +44,7 @@ class InviteContactsDialogInner extends React.Component<Props, State> {
id: d.id,
authorPhoneNumber: d.id,
authorProfileName: name,
authorAvatarPath: d?.cachedProps?.avatarPath,
authorAvatarPath: d?.getAvatarPath(),
selected: false,
authorName: name,
checkmarked: false,

@ -53,7 +53,7 @@ export class UpdateGroupMembersDialog extends React.Component<Props, State> {
id: d.id,
authorPhoneNumber: d.id,
authorProfileName: name,
authorAvatarPath: d?.cachedProps?.avatarPath,
authorAvatarPath: d?.getAvatarPath(),
selected: false,
authorName: name, // different from ProfileName?
checkmarked: false,

@ -3,23 +3,14 @@ import _ from 'lodash';
import { ConversationType } from '../receiver/common';
import { getMessageQueue } from '../session';
import { ConversationController } from '../session/conversations';
import {
ChatMessage,
ChatMessageParams,
ExpirationTimerUpdateMessage,
GroupInvitationMessage,
OpenGroupMessage,
ReadReceiptMessage,
TypingMessage,
} from '../session/messages/outgoing';
import { ClosedGroupChatMessage } from '../session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
import { ClosedGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
import { OpenGroup, PubKey } from '../session/types';
import { ToastUtils, UserUtils } from '../session/utils';
import { BlockedNumberController } from '../util';
import { MessageController } from '../session/messages';
import { leaveClosedGroup } from '../session/group';
import { SignalService } from '../protobuf';
import { MessageCollection, MessageModel } from './message';
import { MessageModel } from './message';
import { MessageAttributesOptionals, MessageModelType } from './messageType';
import autoBind from 'auto-bind';
import {
@ -40,6 +31,15 @@ import {
ConversationType as ReduxConversationType,
LastMessageStatusType,
} from '../state/ducks/conversations';
import { OpenGroupMessage } from '../session/messages/outgoing';
import { ExpirationTimerUpdateMessage } from '../session/messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
import { TypingMessage } from '../session/messages/outgoing/controlMessage/TypingMessage';
import {
VisibleMessage,
VisibleMessageParams,
} from '../session/messages/outgoing/visibleMessage/VisibleMessage';
import { GroupInvitationMessage } from '../session/messages/outgoing/visibleMessage/GroupInvitationMessage';
import { ReadReceiptMessage } from '../session/messages/outgoing/controlMessage/receipt/ReadReceiptMessage';
export interface ConversationAttributes {
profileName?: string;
@ -633,7 +633,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
await getMessageQueue().sendToOpenGroup(openGroupMessage);
return;
}
const chatMessageParams: ChatMessageParams = {
const chatMessageParams: VisibleMessageParams = {
body: uploads.body,
identifier: id,
timestamp: sentAt,
@ -648,7 +648,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
if (this.isPrivate()) {
if (this.isMe()) {
chatMessageParams.syncTarget = this.id;
const chatMessageMe = new ChatMessage(chatMessageParams);
const chatMessageMe = new VisibleMessage(chatMessageParams);
await getMessageQueue().sendSyncMessage(chatMessageMe);
return;
@ -671,7 +671,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
);
return;
}
const chatMessagePrivate = new ChatMessage(chatMessageParams);
const chatMessagePrivate = new VisibleMessage(chatMessageParams);
await getMessageQueue().sendToPubKey(
destinationPubkey,
@ -681,14 +681,14 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
}
if (this.isMediumGroup()) {
const chatMessageMediumGroup = new ChatMessage(chatMessageParams);
const closedGroupChatMessage = new ClosedGroupChatMessage({
const chatMessageMediumGroup = new VisibleMessage(chatMessageParams);
const closedGroupVisibleMessage = new ClosedGroupVisibleMessage({
chatMessage: chatMessageMediumGroup,
groupId: destination,
});
// we need the return await so that errors are caught in the catch {}
await getMessageQueue().sendToGroup(closedGroupChatMessage);
await getMessageQueue().sendToGroup(closedGroupVisibleMessage);
return;
}

@ -7,12 +7,11 @@ import { getMessageQueue, Types, Utils } from '../../ts/session';
import { ConversationController } from '../../ts/session/conversations';
import { MessageController } from '../../ts/session/messages';
import {
ChatMessage,
DataMessage,
OpenGroupMessage,
} from '../../ts/session/messages/outgoing';
import { ClosedGroupChatMessage } from '../../ts/session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
import { EncryptionType, PubKey, RawMessage } from '../../ts/session/types';
import { ClosedGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
import { PubKey } from '../../ts/session/types';
import { ToastUtils, UserUtils } from '../../ts/session/utils';
import {
fillMessageAttributesWithDefaults,
@ -24,6 +23,7 @@ import autoBind from 'auto-bind';
import { saveMessage } from '../../ts/data/data';
import { ConversationModel } from './conversation';
import { actions as conversationActions } from '../state/ducks/conversations';
import { VisibleMessage } from '../session/messages/outgoing/visibleMessage/VisibleMessage';
export class MessageModel extends Backbone.Model<MessageAttributes> {
public propsForTimerNotification: any;
@ -889,7 +889,7 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
delete chatParams.lokiProfile;
}
const chatMessage = new ChatMessage(chatParams);
const chatMessage = new VisibleMessage(chatParams);
// Special-case the self-send case - we send only a sync message
if (conversation.isMe()) {
@ -912,13 +912,13 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
);
}
const closedGroupChatMessage = new ClosedGroupChatMessage({
const closedGroupVisibleMessage = new ClosedGroupVisibleMessage({
identifier: this.id,
chatMessage,
groupId: this.get('conversationId'),
});
return getMessageQueue().sendToGroup(closedGroupChatMessage);
return getMessageQueue().sendToGroup(closedGroupVisibleMessage);
} catch (e) {
await this.saveErrors(e);
return null;
@ -1033,7 +1033,7 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
if (!conversation) {
throw new Error('Cannot trigger syncMessage with unknown convo.');
}
const syncMessage = ChatMessage.buildSyncMessage(
const syncMessage = VisibleMessage.buildSyncMessage(
this.id,
dataMessage,
conversation.id,

@ -22,7 +22,7 @@ import {
import {
ClosedGroupNewMessage,
ClosedGroupNewMessageParams,
} from '../session/messages/outgoing/content/data/group/ClosedGroupNewMessage';
} from '../session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
import { ECKeyPair, HexKeyPair } from './keypairs';
import { UserUtils } from '../session/utils';
@ -30,7 +30,7 @@ import { ConversationModel } from '../models/conversation';
import _ from 'lodash';
import { forceSyncConfigurationNowIfNeeded } from '../session/utils/syncUtils';
import { MessageController } from '../session/messages';
import { ClosedGroupEncryptionPairReplyMessage } from '../session/messages/outgoing/content/data/group';
import { ClosedGroupEncryptionPairReplyMessage } from '../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';
import { queueAllCachedFromSource } from './receiver';
import { actions as conversationActions } from '../state/ducks/conversations';

@ -8,7 +8,6 @@ import { handleMessageJob } from './queuedJob';
import { downloadAttachment } from './attachments';
import _ from 'lodash';
import { StringUtils, UserUtils } from '../session/utils';
import { DeliveryReceiptMessage } from '../session/messages/outgoing';
import { getMessageQueue } from '../session';
import { ConversationController } from '../session/conversations';
import { handleClosedGroupControlMessage } from './closedGroups';
@ -16,6 +15,7 @@ import { MessageModel } from '../models/message';
import { MessageModelType } from '../models/messageType';
import { getMessageBySender } from '../../ts/data/data';
import { ConversationModel } from '../models/conversation';
import { DeliveryReceiptMessage } from '../session/messages/outgoing/controlMessage/receipt/DeliveryReceiptMessage';
export async function updateProfile(
conversation: ConversationModel,

@ -295,10 +295,10 @@ export async function handlePublicMessage(messageData: any) {
await updateProfile(conversation, profile, profileKey);
}
const isPublicChatMessage =
const isPublicVisibleMessage =
group && group.id && !!group.id.match(/^publicChat:/);
if (!isPublicChatMessage) {
if (!isPublicVisibleMessage) {
throw new Error(
'handlePublicMessage Should only be called with public message groups'
);

@ -18,21 +18,19 @@ import { generateCurve25519KeyPairWithoutPrefix } from '../crypto';
import { encryptUsingSessionProtocol } from '../crypto/MessageEncrypter';
import { ECKeyPair } from '../../receiver/keypairs';
import { UserUtils } from '../utils';
import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/content/data/group/ClosedGroupMemberLeftMessage';
import {
ClosedGroupAddedMembersMessage,
ClosedGroupEncryptionPairMessage,
ClosedGroupEncryptionPairRequestMessage,
ClosedGroupNameChangeMessage,
ClosedGroupNewMessage,
ClosedGroupRemovedMembersMessage,
} from '../messages/outgoing/content/data/group';
import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMemberLeftMessage';
import { ConversationModel } from '../../models/conversation';
import { MessageModel } from '../../models/message';
import { MessageModelType } from '../../models/messageType';
import { MessageController } from '../messages';
import { distributingClosedGroupEncryptionKeyPairs } from '../../receiver/closedGroups';
import { getMessageQueue } from '..';
import { ClosedGroupAddedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';
import { ClosedGroupEncryptionPairMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';
import { ClosedGroupEncryptionPairRequestMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairRequestMessage';
import { ClosedGroupNameChangeMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';
import { ClosedGroupNewMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
import { ClosedGroupRemovedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';
export interface GroupInfo {
id: string;

@ -1,5 +1,5 @@
import { Message } from '../Message';
import { SignalService } from '../../../../protobuf';
import { Message } from '.';
import { SignalService } from '../../../protobuf';
export abstract class ContentMessage extends Message {
public plainTextBuffer(): Uint8Array {

@ -1,6 +1,6 @@
import { ContentMessage } from '../ContentMessage';
import { SignalService } from '../../../../../protobuf';
import { TTL_DEFAULT } from '../../../../constants';
import { ContentMessage } from '.';
import { SignalService } from '../../../protobuf';
import { TTL_DEFAULT } from '../../constants';
export abstract class DataMessage extends ContentMessage {
public abstract dataProto(): SignalService.DataMessage;

@ -1,6 +1,10 @@
import { Message, MessageParams } from './Message';
import { AttachmentPointer, Preview, Quote } from './content';
import { OpenGroup } from '../../types/OpenGroup';
import {
AttachmentPointer,
Preview,
Quote,
} from './visibleMessage/VisibleMessage';
interface OpenGroupMessageParams extends MessageParams {
group: OpenGroup;

@ -1,51 +0,0 @@
import { SignalService } from '../../../../../../protobuf';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,
} from './ClosedGroupMessage';
import { fromHexToArray } from '../../../../../utils/String';
export interface ClosedGroupUpdateMessageParams
extends ClosedGroupMessageParams {
name: string;
members: Array<string>;
expireTimer: number;
}
export class ClosedGroupUpdateMessage extends ClosedGroupMessage {
private readonly name: string;
private readonly members: Array<string>;
constructor(params: ClosedGroupUpdateMessageParams) {
super({
timestamp: params.timestamp,
identifier: params.identifier,
groupId: params.groupId,
expireTimer: params.expireTimer,
});
this.name = params.name;
this.members = params.members;
// members can be empty. It means noone is in the group anymore and it happens when an admin leaves the group
if (!params.members) {
throw new Error('Members must be set');
}
if (!params.name || params.name.length === 0) {
throw new Error('Name must cannot be empty');
}
}
public dataProto(): SignalService.DataMessage {
const dataMessage = new SignalService.DataMessage();
dataMessage.closedGroupControlMessage = new SignalService.DataMessage.ClosedGroupControlMessage();
dataMessage.closedGroupControlMessage.type =
SignalService.DataMessage.ClosedGroupControlMessage.Type.UPDATE;
dataMessage.closedGroupControlMessage.name = this.name;
dataMessage.closedGroupControlMessage.members = this.members.map(
fromHexToArray
);
return dataMessage;
}
}

@ -1,8 +0,0 @@
export * from './ClosedGroupEncryptionPairMessage';
export * from './ClosedGroupEncryptionPairRequestMessage';
export * from './ClosedGroupEncryptionPairReplyMessage';
export * from './ClosedGroupNewMessage';
export * from './ClosedGroupAddedMembersMessage';
export * from './ClosedGroupNameChangeMessage';
export * from './ClosedGroupRemovedMembersMessage';
export * from './ClosedGroupUpdateMessage';

@ -1,9 +0,0 @@
export * from './DataMessage';
export * from './GroupInvitationMessage';
export * from './ChatMessage';
export * from './group/ClosedGroupMessage';
export * from './group/ClosedGroupChatMessage';
export * from './group/ClosedGroupEncryptionPairMessage';
export * from './group/ClosedGroupNewMessage';
export * from './group/ClosedGroupMessage';
export * from './ExpirationTimerUpdateMessage';

@ -1,4 +0,0 @@
export * from './ContentMessage';
export * from './TypingMessage';
export * from './data';
export * from './receipt';

@ -1,3 +0,0 @@
export * from './ReceiptMessage';
export * from './DeliveryReceiptMessage';
export * from './ReadReceiptMessage';

@ -1,12 +1,12 @@
// this is not a very good name, but a configuration message is a message sent to our other devices so sync our current public and closed groups
import { ContentMessage } from './ContentMessage';
import { SignalService } from '../../../../protobuf';
import { MessageParams } from '../Message';
import { Constants } from '../../..';
import { ECKeyPair } from '../../../../receiver/keypairs';
import { fromHexToArray } from '../../../utils/String';
import { PubKey } from '../../../types';
import { ContentMessage } from '..';
interface ConfigurationMessageParams extends MessageParams {
activeClosedGroups: Array<ConfigurationMessageClosedGroup>;

@ -1,25 +1,28 @@
import { SignalService } from '../../../../../protobuf';
import { MessageParams } from '../../Message';
import { StringUtils } from '../../../../utils';
import { DataMessage } from './DataMessage';
import { PubKey } from '../../../../types';
import { Constants } from '../../../..';
import { DataMessage } from '..';
import { Constants } from '../../..';
import { SignalService } from '../../../../protobuf';
import { PubKey } from '../../../types';
import { StringUtils } from '../../../utils';
import { MessageParams } from '../Message';
interface ExpirationTimerUpdateMessageParams extends MessageParams {
groupId?: string | PubKey;
syncTarget?: string | PubKey;
expireTimer: number | null;
}
export class ExpirationTimerUpdateMessage extends DataMessage {
public readonly groupId?: PubKey;
public readonly syncTarget?: PubKey;
public readonly expireTimer: number | null;
constructor(params: ExpirationTimerUpdateMessageParams) {
super({ timestamp: params.timestamp, identifier: params.identifier });
this.expireTimer = params.expireTimer;
const { groupId } = params;
const { groupId, syncTarget } = params;
this.groupId = groupId ? PubKey.cast(groupId) : undefined;
this.syncTarget = syncTarget ? PubKey.cast(syncTarget) : undefined;
}
public ttl(): number {
@ -46,6 +49,10 @@ export class ExpirationTimerUpdateMessage extends DataMessage {
data.group = groupMessage;
}
if (this.syncTarget) {
data.syncTarget = this.syncTarget.key;
}
if (this.expireTimer) {
data.expireTimer = this.expireTimer;
}

@ -1,7 +1,7 @@
import { ContentMessage } from './ContentMessage';
import { SignalService } from '../../../../protobuf';
import { MessageParams } from '../Message';
import { Constants } from '../../..';
import { ContentMessage } from '..';
interface TypingMessageParams extends MessageParams {
isTyping: boolean;

@ -1,7 +1,7 @@
import { fromHex } from 'bytebuffer';
import { Constants } from '../../../../..';
import { SignalService } from '../../../../../../protobuf';
import { fromHexToArray } from '../../../../../utils/String';
import { Constants } from '../../../..';
import { SignalService } from '../../../../../protobuf';
import { fromHexToArray } from '../../../../utils/String';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,

@ -1,6 +1,5 @@
import { Constants } from '../../../../..';
import { SignalService } from '../../../../../../protobuf';
import { fromHexToArray } from '../../../../../utils/String';
import { Constants } from '../../../..';
import { SignalService } from '../../../../../protobuf';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,

@ -1,5 +1,5 @@
import { SignalService } from '../../../../../../protobuf';
import { fromHexToArray } from '../../../../../utils/String';
import { SignalService } from '../../../../../protobuf';
import { fromHexToArray } from '../../../../utils/String';
import { ClosedGroupEncryptionPairMessage } from './ClosedGroupEncryptionPairMessage';
/**

@ -1,9 +1,12 @@
import { Constants } from '../../../../..';
import { SignalService } from '../../../../../../protobuf';
import { Constants } from '../../../..';
import { SignalService } from '../../../../../protobuf';
import { ClosedGroupMessage } from './ClosedGroupMessage';
export class ClosedGroupEncryptionPairRequestMessage extends ClosedGroupMessage {
public dataProto(): SignalService.DataMessage {
throw new Error(
'ClosedGroupEncryptionPairRequestMessage: This is unused for now '
);
const dataMessage = super.dataProto();
// tslint:disable: no-non-null-assertion

@ -1,20 +1,8 @@
import { Constants } from '../../../../..';
import { SignalService } from '../../../../../../protobuf';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,
} from './ClosedGroupMessage';
import { Constants } from '../../../..';
import { SignalService } from '../../../../../protobuf';
import { ClosedGroupMessage } from './ClosedGroupMessage';
export class ClosedGroupMemberLeftMessage extends ClosedGroupMessage {
constructor(params: ClosedGroupMessageParams) {
super({
timestamp: params.timestamp,
identifier: params.identifier,
groupId: params.groupId,
expireTimer: params.expireTimer,
});
}
public dataProto(): SignalService.DataMessage {
const dataMessage = super.dataProto();

@ -1,7 +1,7 @@
import { DataMessage } from '../DataMessage';
import { MessageParams } from '../../../Message';
import { SignalService } from '../../../../../../protobuf';
import { PubKey } from '../../../../../types/PubKey';
import { SignalService } from '../../../../../protobuf';
import { PubKey } from '../../../../types';
import { DataMessage } from '../../DataMessage';
import { MessageParams } from '../../Message';
export interface ClosedGroupMessageParams extends MessageParams {
groupId: string | PubKey;

@ -1,5 +1,5 @@
import { Constants } from '../../../../..';
import { SignalService } from '../../../../../../protobuf';
import { Constants } from '../../../..';
import { SignalService } from '../../../../../protobuf';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,

@ -1,10 +1,10 @@
import { SignalService } from '../../../../../../protobuf';
import { SignalService } from '../../../../../protobuf';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,
} from './ClosedGroupMessage';
import { fromHexToArray } from '../../../../../utils/String';
import { ECKeyPair } from '../../../../../../receiver/keypairs';
import { fromHexToArray } from '../../../../utils/String';
import { ECKeyPair } from '../../../../../receiver/keypairs';
export interface ClosedGroupNewMessageParams extends ClosedGroupMessageParams {
name: string;

@ -1,6 +1,6 @@
import { Constants } from '../../../../..';
import { SignalService } from '../../../../../../protobuf';
import { fromHexToArray } from '../../../../../utils/String';
import { Constants } from '../../../..';
import { SignalService } from '../../../../../protobuf';
import { fromHexToArray } from '../../../../utils/String';
import {
ClosedGroupMessage,
ClosedGroupMessageParams,

@ -1,7 +1,7 @@
import { ContentMessage } from '../ContentMessage';
import { SignalService } from '../../../../../protobuf';
import { MessageParams } from '../../Message';
import { Constants } from '../../../..';
import { ContentMessage } from '../..';
interface ReceiptMessageParams extends MessageParams {
timestamps: Array<number>;

@ -1,5 +1,7 @@
import { Message } from './Message';
import { OpenGroupMessage } from './OpenGroupMessage';
export * from './content/';
export * from './ContentMessage';
export * from './DataMessage';
export { Message, OpenGroupMessage };

@ -1,20 +1,20 @@
import { SignalService } from '../../../../../../protobuf';
import { ChatMessage } from '../ChatMessage';
import { ClosedGroupMessage } from './ClosedGroupMessage';
import { PubKey } from '../../../../../types';
import { Constants } from '../../../../..';
import { StringUtils } from '../../../../../utils';
interface ClosedGroupChatMessageParams {
import { Constants } from '../../..';
import { SignalService } from '../../../../protobuf';
import { PubKey } from '../../../types';
import { StringUtils } from '../../../utils';
import { VisibleMessage } from './VisibleMessage';
import { ClosedGroupMessage } from '../controlMessage/group/ClosedGroupMessage';
interface ClosedGroupVisibleMessageParams {
identifier?: string;
groupId: string | PubKey;
chatMessage: ChatMessage;
chatMessage: VisibleMessage;
}
export class ClosedGroupChatMessage extends ClosedGroupMessage {
private readonly chatMessage: ChatMessage;
export class ClosedGroupVisibleMessage extends ClosedGroupMessage {
private readonly chatMessage: VisibleMessage;
constructor(params: ClosedGroupChatMessageParams) {
constructor(params: ClosedGroupVisibleMessageParams) {
super({
timestamp: params.chatMessage.timestamp,
identifier: params.identifier ?? params.chatMessage.identifier,

@ -1,7 +1,7 @@
import { DataMessage } from './DataMessage';
import { SignalService } from '../../../../../protobuf';
import { MessageParams } from '../../Message';
import { Constants } from '../../../..';
import { DataMessage } from '..';
import { Constants } from '../../..';
import { SignalService } from '../../../../protobuf';
import { MessageParams } from '../Message';
interface GroupInvitationMessageParams extends MessageParams {
serverAddress: string;

@ -1,10 +1,11 @@
import { DataMessage } from './DataMessage';
import { SignalService } from '../../../../../protobuf';
import { MessageParams } from '../../Message';
import { LokiProfile } from '../../../../../types/Message';
import ByteBuffer from 'bytebuffer';
import { Constants } from '../../../..';
import { isNumber, toNumber } from 'lodash';
import { DataMessage } from '..';
import { Constants } from '../../..';
import { SignalService } from '../../../../protobuf';
import { LokiProfile } from '../../../../types/Message';
import { MessageParams } from '../Message';
export interface AttachmentPointer {
id?: number;
@ -40,7 +41,7 @@ export interface Quote {
attachments?: Array<QuotedAttachment>;
}
export interface ChatMessageParams extends MessageParams {
export interface VisibleMessageParams extends MessageParams {
attachments?: Array<AttachmentPointer>;
body?: string;
quote?: Quote;
@ -50,7 +51,7 @@ export interface ChatMessageParams extends MessageParams {
syncTarget?: string; // null means it is not a synced message
}
export class ChatMessage extends DataMessage {
export class VisibleMessage extends DataMessage {
public readonly expireTimer?: number;
private readonly attachments?: Array<AttachmentPointer>;
@ -65,7 +66,7 @@ export class ChatMessage extends DataMessage {
/// - Note: `null or undefined` if this isn't a sync message.
private readonly syncTarget?: string;
constructor(params: ChatMessageParams) {
constructor(params: VisibleMessageParams) {
super({ timestamp: params.timestamp, identifier: params.identifier });
this.attachments = params.attachments;
this.body = params.body;
@ -135,7 +136,7 @@ export class ChatMessage extends DataMessage {
const quote = (dataMessage.quote as Quote) || undefined;
const preview = (dataMessage.preview as Array<Preview>) || [];
return new ChatMessage({
return new VisibleMessage({
identifier,
timestamp,
attachments,
@ -232,7 +233,7 @@ export class ChatMessage extends DataMessage {
return dataMessage;
}
public isEqual(comparator: ChatMessage): boolean {
public isEqual(comparator: VisibleMessage): boolean {
return (
this.identifier === comparator.identifier &&
this.timestamp === comparator.timestamp

@ -1,34 +1,28 @@
import {
ClosedGroupChatMessage,
ClosedGroupNewMessage,
ContentMessage,
ExpirationTimerUpdateMessage,
OpenGroupMessage,
} from '../messages/outgoing';
import { PendingMessageCache } from './PendingMessageCache';
import { JobQueue, UserUtils } from '../utils';
import { PubKey, RawMessage } from '../types';
import { MessageSender } from '.';
import { ClosedGroupMessage } from '../messages/outgoing/content/data/group/ClosedGroupMessage';
import { ConfigurationMessage } from '../messages/outgoing/content/ConfigurationMessage';
import { ClosedGroupNameChangeMessage } from '../messages/outgoing/content/data/group/ClosedGroupNameChangeMessage';
import {
ClosedGroupAddedMembersMessage,
ClosedGroupEncryptionPairMessage,
ClosedGroupEncryptionPairRequestMessage,
ClosedGroupRemovedMembersMessage,
ClosedGroupUpdateMessage,
} from '../messages/outgoing/content/data/group';
import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/content/data/group/ClosedGroupMemberLeftMessage';
import { ClosedGroupMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMessage';
import { ConfigurationMessage } from '../messages/outgoing/controlMessage/ConfigurationMessage';
import { ClosedGroupNameChangeMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';
import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMemberLeftMessage';
import { MessageSentHandler } from './MessageSentHandler';
import { ContentMessage, OpenGroupMessage } from '../messages/outgoing';
import { ExpirationTimerUpdateMessage } from '../messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
import { ClosedGroupAddedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';
import { ClosedGroupEncryptionPairMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';
import { ClosedGroupEncryptionPairRequestMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairRequestMessage';
import { ClosedGroupNewMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
import { ClosedGroupRemovedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';
import { ClosedGroupVisibleMessage } from '../messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
type ClosedGroupMessageType =
| ClosedGroupChatMessage
| ClosedGroupVisibleMessage
| ClosedGroupAddedMembersMessage
| ClosedGroupRemovedMembersMessage
| ClosedGroupNameChangeMessage
| ClosedGroupMemberLeftMessage
| ClosedGroupUpdateMessage
| ExpirationTimerUpdateMessage
| ClosedGroupEncryptionPairMessage
| ClosedGroupEncryptionPairRequestMessage;

@ -1,13 +1,14 @@
import * as crypto from 'crypto';
import { Attachment } from '../../types/Attachment';
import { OpenGroup } from '../types';
import { LokiAppDotNetServerInterface } from '../../../js/modules/loki_app_dot_net_api';
import {
AttachmentPointer,
Preview,
Quote,
QuotedAttachment,
} from '../messages/outgoing';
import { LokiAppDotNetServerInterface } from '../../../js/modules/loki_app_dot_net_api';
} from '../messages/outgoing/visibleMessage/VisibleMessage';
interface UploadParams {
attachment: Attachment;

@ -1,14 +1,12 @@
import { RawMessage } from '../types/RawMessage';
import {
ContentMessage,
ExpirationTimerUpdateMessage,
} from '../messages/outgoing';
import { EncryptionType, PubKey } from '../types';
import { ClosedGroupMessage } from '../messages/outgoing/content/data/group/ClosedGroupMessage';
import { ClosedGroupNewMessage } from '../messages/outgoing/content/data/group/ClosedGroupNewMessage';
import { ClosedGroupMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMessage';
import { ClosedGroupNewMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
import _ from 'lodash';
import { ConversationModel } from '../../models/conversation';
import { ClosedGroupEncryptionPairReplyMessage } from '../messages/outgoing/content/data/group/ClosedGroupEncryptionPairReplyMessage';
import { ClosedGroupEncryptionPairReplyMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';
import { ContentMessage } from '../messages/outgoing';
import { ExpirationTimerUpdateMessage } from '../messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
function getEncryptionTypeFromMessageType(
message: ContentMessage

@ -13,7 +13,7 @@ import {
ConfigurationMessage,
ConfigurationMessageClosedGroup,
ConfigurationMessageContact,
} from '../messages/outgoing/content/ConfigurationMessage';
} from '../messages/outgoing/controlMessage/ConfigurationMessage';
import { ConversationModel } from '../../models/conversation';
import {
fromBase64ToArray,

@ -1,19 +1,19 @@
import { expect } from 'chai';
import {
AttachmentPointer,
ChatMessage,
Preview,
Quote,
} from '../../../../session/messages/outgoing';
import { SignalService } from '../../../../protobuf';
import { TextEncoder } from 'util';
import { toNumber } from 'lodash';
import { Constants } from '../../../../session';
import {
AttachmentPointer,
Preview,
Quote,
VisibleMessage,
} from '../../../../session/messages/outgoing/visibleMessage/VisibleMessage';
describe('ChatMessage', () => {
describe('VisibleMessage', () => {
it('can create empty message with just a timestamp', () => {
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
});
const plainText = message.plainTextBuffer();
@ -23,7 +23,7 @@ describe('ChatMessage', () => {
});
it('can create message with a body', () => {
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
body: 'body',
});
@ -33,7 +33,7 @@ describe('ChatMessage', () => {
});
it('can create message with a expire timer', () => {
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
expireTimer: 3600,
});
@ -50,7 +50,7 @@ describe('ChatMessage', () => {
avatarPointer: 'avatarPointer',
profileKey,
};
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
lokiProfile: lokiProfile,
});
@ -71,7 +71,7 @@ describe('ChatMessage', () => {
let quote: Quote;
quote = { id: 1234, author: 'author', text: 'text' };
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
quote,
});
@ -93,7 +93,7 @@ describe('ChatMessage', () => {
const previews = new Array<Preview>();
previews.push(preview);
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
preview: previews,
});
@ -115,7 +115,7 @@ describe('ChatMessage', () => {
const attachments = new Array<AttachmentPointer>();
attachments.push(attachment);
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
attachments: attachments,
});
@ -130,14 +130,14 @@ describe('ChatMessage', () => {
});
it('correct ttl', () => {
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
});
expect(message.ttl()).to.equal(Constants.TTL_DEFAULT.REGULAR_MESSAGE);
});
it('has an identifier', () => {
const message = new ChatMessage({
const message = new VisibleMessage({
timestamp: Date.now(),
});
expect(message.identifier).to.not.equal(null, 'identifier cannot be null');

@ -1,26 +1,24 @@
import { expect } from 'chai';
import {
ChatMessage,
ClosedGroupChatMessage,
} from '../../../../session/messages/outgoing';
import { SignalService } from '../../../../protobuf';
import { TestUtils } from '../../../test-utils';
import { StringUtils } from '../../../../session/utils';
import { PubKey } from '../../../../session/types';
import { Constants } from '../../../../session';
import { ClosedGroupVisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
import { VisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/VisibleMessage';
describe('ClosedGroupChatMessage', () => {
describe('ClosedGroupVisibleMessage', () => {
let groupId: PubKey;
beforeEach(() => {
groupId = TestUtils.generateFakePubKey();
});
it('can create empty message with timestamp, groupId and chatMessage', () => {
const chatMessage = new ChatMessage({
const chatMessage = new VisibleMessage({
timestamp: Date.now(),
body: 'body',
});
const message = new ClosedGroupChatMessage({
const message = new ClosedGroupVisibleMessage({
groupId,
chatMessage,
});
@ -50,10 +48,10 @@ describe('ClosedGroupChatMessage', () => {
});
it('correct ttl', () => {
const chatMessage = new ChatMessage({
const chatMessage = new VisibleMessage({
timestamp: Date.now(),
});
const message = new ClosedGroupChatMessage({
const message = new ClosedGroupVisibleMessage({
groupId,
chatMessage,
});
@ -61,10 +59,10 @@ describe('ClosedGroupChatMessage', () => {
});
it('has an identifier', () => {
const chatMessage = new ChatMessage({
const chatMessage = new VisibleMessage({
timestamp: Date.now(),
});
const message = new ClosedGroupChatMessage({
const message = new ClosedGroupVisibleMessage({
groupId,
chatMessage,
});
@ -76,12 +74,12 @@ describe('ClosedGroupChatMessage', () => {
});
it('should use the identifier passed into it over the one set in chatMessage', () => {
const chatMessage = new ChatMessage({
const chatMessage = new VisibleMessage({
timestamp: Date.now(),
body: 'body',
identifier: 'chatMessage',
});
const message = new ClosedGroupChatMessage({
const message = new ClosedGroupVisibleMessage({
groupId,
chatMessage,
identifier: 'closedGroupMessage',
@ -90,12 +88,12 @@ describe('ClosedGroupChatMessage', () => {
});
it('should use the identifier of the chatMessage if one is not specified on the closed group message', () => {
const chatMessage = new ChatMessage({
const chatMessage = new VisibleMessage({
timestamp: Date.now(),
body: 'body',
identifier: 'chatMessage',
});
const message = new ClosedGroupChatMessage({
const message = new ClosedGroupVisibleMessage({
groupId,
chatMessage,
});

@ -5,7 +5,7 @@ import {
ConfigurationMessage,
ConfigurationMessageClosedGroup,
ConfigurationMessageContact,
} from '../../../../session/messages/outgoing/content/ConfigurationMessage';
} from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';
import { TestUtils } from '../../../test-utils';
// tslint:disable-next-line: max-func-body-length

@ -1,9 +1,9 @@
import { expect } from 'chai';
import { beforeEach } from 'mocha';
import { GroupInvitationMessage } from '../../../../session/messages/outgoing';
import { SignalService } from '../../../../protobuf';
import { Constants } from '../../../../session';
import { GroupInvitationMessage } from '../../../../session/messages/outgoing/visibleMessage/GroupInvitationMessage';
describe('GroupInvitationMessage', () => {
let message: GroupInvitationMessage;

@ -1,11 +1,9 @@
import { expect } from 'chai';
import {
AttachmentPointer,
OpenGroupMessage,
} from '../../../../session/messages/outgoing';
import { OpenGroupMessage } from '../../../../session/messages/outgoing';
import * as MIME from '../../../../../ts/types/MIME';
import { OpenGroup } from '../../../../session/types';
import { AttachmentPointer } from '../../../../session/messages/outgoing/visibleMessage/VisibleMessage';
describe('OpenGroupMessage', () => {
const group = new OpenGroup({

@ -1,13 +1,11 @@
import { expect } from 'chai';
import { beforeEach } from 'mocha';
import {
DeliveryReceiptMessage,
ReadReceiptMessage,
} from '../../../../session/messages/outgoing';
import { SignalService } from '../../../../protobuf';
import { toNumber } from 'lodash';
import { Constants } from '../../../../session';
import { DeliveryReceiptMessage } from '../../../../session/messages/outgoing/controlMessage/receipt/DeliveryReceiptMessage';
import { ReadReceiptMessage } from '../../../../session/messages/outgoing/controlMessage/receipt/ReadReceiptMessage';
describe('ReceiptMessage', () => {
let readMessage: ReadReceiptMessage;

@ -1,12 +1,10 @@
import { expect } from 'chai';
import { TypingMessage } from '../../../../session/messages/outgoing';
import { SignalService } from '../../../../protobuf';
import Long from 'long';
import { toNumber } from 'lodash';
import { StringUtils } from '../../../../session/utils';
import { TestUtils } from '../../../test-utils';
import { Constants } from '../../../../session';
import { TypingMessage } from '../../../../session/messages/outgoing/controlMessage/TypingMessage';
describe('TypingMessage', () => {
it('has Action.STARTED if isTyping = true', () => {

@ -3,7 +3,7 @@
import { SignalService } from '../../../../protobuf';
import chai from 'chai';
import { ConfigurationMessage } from '../../../../session/messages/outgoing/content/ConfigurationMessage';
import { ConfigurationMessage } from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';
import { UserUtils } from '../../../../session/utils';
import { TestUtils } from '../../../test-utils';

@ -15,7 +15,7 @@ import {
import { PubKey, RawMessage } from '../../../../session/types';
import { MessageSender } from '../../../../session/sending';
import { PendingMessageCacheStub } from '../../../test-utils/stubs';
import { ClosedGroupMessage } from '../../../../session/messages/outgoing/content/data/group/ClosedGroupMessage';
import { ClosedGroupMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupMessage';
import chaiAsPromised from 'chai-as-promised';
import { MessageSentHandler } from '../../../../session/sending/MessageSentHandler';
@ -87,7 +87,7 @@ describe('MessageQueue', () => {
void pendingMessageCache
.add(
device,
TestUtils.generateChatMessage(),
TestUtils.generateVisibleMessage(),
waitForMessageSentEvent as any
)
.then(async () => {
@ -108,7 +108,10 @@ describe('MessageQueue', () => {
}
const device = TestUtils.generateFakePubKey();
await pendingMessageCache.add(device, TestUtils.generateChatMessage());
await pendingMessageCache.add(
device,
TestUtils.generateVisibleMessage()
);
const initialMessages = await pendingMessageCache.getForDevice(device);
expect(initialMessages).to.have.length(1);
@ -125,7 +128,7 @@ describe('MessageQueue', () => {
describe('events', () => {
it('should send a success event if message was sent', done => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const waitForMessageSentEvent = async () =>
new Promise<void>(resolve => {
resolve();
@ -149,7 +152,7 @@ describe('MessageQueue', () => {
sendStub.throws(new Error('failure'));
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
void pendingMessageCache
.add(device, message)
.then(() => messageQueueStub.processPending(device));
@ -180,7 +183,7 @@ describe('MessageQueue', () => {
const device = TestUtils.generateFakePubKey();
const stub = sandbox.stub(messageQueueStub as any, 'process').resolves();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
await messageQueueStub.sendToPubKey(device, message);
const args = stub.lastCall.args as [Array<PubKey>, ContentMessage];
@ -191,7 +194,7 @@ describe('MessageQueue', () => {
describe('sendToGroup', () => {
it('should throw an error if invalid non-group message was passed', async () => {
const chatMessage = TestUtils.generateChatMessage();
const chatMessage = TestUtils.generateVisibleMessage();
return expect(
messageQueueStub.sendToGroup(chatMessage as any)
).to.be.rejectedWith('Invalid group message passed in sendToGroup.');

@ -56,7 +56,7 @@ describe('PendingMessageCache', () => {
it('can add to cache', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
await pendingMessageCacheStub.add(device, message);
@ -74,12 +74,21 @@ describe('PendingMessageCache', () => {
it('can add multiple messages belonging to the same user', async () => {
const device = TestUtils.generateFakePubKey();
await pendingMessageCacheStub.add(device, TestUtils.generateChatMessage());
await pendingMessageCacheStub.add(
device,
TestUtils.generateVisibleMessage()
);
// We have to timeout here otherwise it's processed too fast and messages start having the same timestamp
await TestUtils.timeout(5);
await pendingMessageCacheStub.add(device, TestUtils.generateChatMessage());
await pendingMessageCacheStub.add(
device,
TestUtils.generateVisibleMessage()
);
await TestUtils.timeout(5);
await pendingMessageCacheStub.add(device, TestUtils.generateChatMessage());
await pendingMessageCacheStub.add(
device,
TestUtils.generateVisibleMessage()
);
// Verify that the message is in the cache
const finalCache = await pendingMessageCacheStub.getAllPending();
@ -89,7 +98,7 @@ describe('PendingMessageCache', () => {
it('can remove from cache', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
await pendingMessageCacheStub.add(device, message);
@ -108,14 +117,14 @@ describe('PendingMessageCache', () => {
it('should only remove messages with different timestamp and device', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
await pendingMessageCacheStub.add(device, message);
await TestUtils.timeout(5);
const one = await pendingMessageCacheStub.add(
device,
TestUtils.generateChatMessage(message.identifier)
TestUtils.generateVisibleMessage(message.identifier)
);
const two = await pendingMessageCacheStub.add(
TestUtils.generateFakePubKey(),
@ -139,15 +148,15 @@ describe('PendingMessageCache', () => {
const cacheItems = [
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
];
@ -171,11 +180,11 @@ describe('PendingMessageCache', () => {
const cacheItems = [
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
];
@ -198,7 +207,7 @@ describe('PendingMessageCache', () => {
it('can find nothing when empty', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
const foundMessage = pendingMessageCacheStub.find(rawMessage);
@ -207,7 +216,7 @@ describe('PendingMessageCache', () => {
it('can find message in cache', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
await pendingMessageCacheStub.add(device, message);
@ -224,15 +233,15 @@ describe('PendingMessageCache', () => {
const cacheItems = [
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
];
@ -254,15 +263,15 @@ describe('PendingMessageCache', () => {
const cacheItems = [
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
{
device: TestUtils.generateFakePubKey(),
message: TestUtils.generateChatMessage(),
message: TestUtils.generateVisibleMessage(),
},
];

@ -5,25 +5,21 @@ import * as sinon from 'sinon';
import { TestUtils } from '../../../test-utils';
import { MessageUtils, UserUtils } from '../../../../session/utils';
import { EncryptionType, PubKey } from '../../../../session/types';
import { ClosedGroupChatMessage } from '../../../../session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
import {
ClosedGroupEncryptionPairMessage,
ClosedGroupNewMessage,
} from '../../../../session/messages/outgoing';
import { SignalService } from '../../../../protobuf';
import {
ClosedGroupAddedMembersMessage,
ClosedGroupNameChangeMessage,
ClosedGroupRemovedMembersMessage,
} from '../../../../session/messages/outgoing/content/data/group';
import { ClosedGroupVisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
import { MockConversation } from '../../../test-utils/utils';
import { ConfigurationMessage } from '../../../../session/messages/outgoing/content/ConfigurationMessage';
import { ConfigurationMessage } from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';
import { ConversationModel } from '../../../../models/conversation';
import chaiAsPromised from 'chai-as-promised';
chai.use(chaiAsPromised as any);
import { ClosedGroupEncryptionPairReplyMessage } from '../../../../session/messages/outgoing/content/data/group/ClosedGroupEncryptionPairReplyMessage';
import { ClosedGroupEncryptionPairReplyMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';
import { SignalService } from '../../../../protobuf';
import { ClosedGroupAddedMembersMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';
import { ClosedGroupEncryptionPairMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';
import { ClosedGroupNameChangeMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';
import { ClosedGroupNewMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
import { ClosedGroupRemovedMembersMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';
const { expect } = chai;
@ -38,7 +34,7 @@ describe('Message Utils', () => {
describe('toRawMessage', () => {
it('can convert to raw message', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
@ -61,7 +57,7 @@ describe('Message Utils', () => {
it('should generate valid plainTextBuffer', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
@ -81,7 +77,7 @@ describe('Message Utils', () => {
it('should maintain pubkey', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
const derivedPubKey = PubKey.from(rawMessage.device);
@ -93,11 +89,11 @@ describe('Message Utils', () => {
);
});
it('should set encryption to ClosedGroup if a ClosedGroupChatMessage is passed in', async () => {
it('should set encryption to ClosedGroup if a ClosedGroupVisibleMessage is passed in', async () => {
const device = TestUtils.generateFakePubKey();
const groupId = TestUtils.generateFakePubKey();
const chatMessage = TestUtils.generateChatMessage();
const message = new ClosedGroupChatMessage({ chatMessage, groupId });
const chatMessage = TestUtils.generateVisibleMessage();
const message = new ClosedGroupVisibleMessage({ chatMessage, groupId });
const rawMessage = await MessageUtils.toRawMessage(device, message);
expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);
@ -105,7 +101,7 @@ describe('Message Utils', () => {
it('should set encryption to Fallback on other messages', async () => {
const device = TestUtils.generateFakePubKey();
const message = TestUtils.generateChatMessage();
const message = TestUtils.generateVisibleMessage();
const rawMessage = await MessageUtils.toRawMessage(device, message);
expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);

@ -1,15 +1,13 @@
import {
ChatMessage,
OpenGroupMessage,
} from '../../../session/messages/outgoing';
import { v4 as uuid } from 'uuid';
import { OpenGroup } from '../../../session/types';
import { generateFakePubKey, generateFakePubKeys } from './pubkey';
import { ClosedGroupChatMessage } from '../../../session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
import { ClosedGroupVisibleMessage } from '../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
import { ConversationAttributes } from '../../../models/conversation';
import { OpenGroupMessage } from '../../../session/messages/outgoing';
import { VisibleMessage } from '../../../session/messages/outgoing/visibleMessage/VisibleMessage';
export function generateChatMessage(identifier?: string): ChatMessage {
return new ChatMessage({
export function generateVisibleMessage(identifier?: string): VisibleMessage {
return new VisibleMessage({
body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
identifier: identifier ?? uuid(),
timestamp: Date.now(),
@ -40,11 +38,11 @@ export function generateOpenGroupMessage(): OpenGroupMessage {
export function generateClosedGroupMessage(
groupId?: string
): ClosedGroupChatMessage {
return new ClosedGroupChatMessage({
): ClosedGroupVisibleMessage {
return new ClosedGroupVisibleMessage({
identifier: uuid(),
groupId: groupId ?? generateFakePubKey().key,
chatMessage: generateChatMessage(),
chatMessage: generateVisibleMessage(),
});
}

Loading…
Cancel
Save