Alexandre Kühn
b0116e4523
closes odoo/odoo#105677 Signed-off-by: Alexandre Kühn (aku) <aku@odoo.com>
1971 lines
73 KiB
JavaScript
1971 lines
73 KiB
JavaScript
/** @odoo-module **/
|
|
|
|
import { attr, clear, insert, insertAndUnlink, link, many, one, Model, unlink } from "@mail/model";
|
|
import { cleanSearchTerm } from "@mail/utils/utils";
|
|
import * as mailUtils from "@mail/js/utils";
|
|
|
|
import { sprintf } from "@web/core/utils/strings";
|
|
import { url } from "@web/core/utils/urls";
|
|
|
|
import { str_to_datetime } from "web.time";
|
|
|
|
const getSuggestedRecipientInfoNextTemporaryId = (function () {
|
|
let tmpId = 0;
|
|
return () => {
|
|
tmpId += 1;
|
|
return tmpId;
|
|
};
|
|
})();
|
|
|
|
Model({
|
|
name: "Thread",
|
|
lifecycleHooks: {
|
|
_willDelete() {
|
|
if (this.isTemporary) {
|
|
for (const message of this.messages) {
|
|
message.delete();
|
|
}
|
|
}
|
|
},
|
|
},
|
|
modelMethods: {
|
|
/**
|
|
* @param {Object} data
|
|
* @return {Object}
|
|
*/
|
|
convertData(data) {
|
|
const data2 = {};
|
|
if ("authorizedGroupFullName" in data) {
|
|
data2.authorizedGroupFullName = data.authorizedGroupFullName;
|
|
}
|
|
if ("channel" in data) {
|
|
data2.channel = data.channel;
|
|
data2.model = "mail.channel";
|
|
}
|
|
if ("defaultDisplayMode" in data) {
|
|
data2.defaultDisplayMode = data.defaultDisplayMode;
|
|
}
|
|
if ("description" in data) {
|
|
data2.description = data.description;
|
|
}
|
|
if ("model" in data) {
|
|
data2.model = data.model;
|
|
}
|
|
if ("create_uid" in data) {
|
|
data2.creator = insert({ id: data.create_uid });
|
|
}
|
|
if ("group_based_subscription" in data) {
|
|
data2.group_based_subscription = data.group_based_subscription;
|
|
}
|
|
if ("id" in data) {
|
|
data2.id = data.id;
|
|
}
|
|
if ("invitedMembers" in data) {
|
|
data2.invitedMembers = data.invitedMembers;
|
|
}
|
|
if ("is_minimized" in data && "state" in data) {
|
|
data2.serverFoldState = data.is_minimized ? data.state : "closed";
|
|
}
|
|
if ("is_pinned" in data) {
|
|
data2.isServerPinned = data.is_pinned;
|
|
}
|
|
if ("last_interest_dt" in data && data.last_interest_dt) {
|
|
data2.lastInterestDateTime = str_to_datetime(data.last_interest_dt);
|
|
}
|
|
if ("last_message" in data && data.last_message) {
|
|
const messageData = this.messaging.models["Message"].convertData({
|
|
id: data.last_message.id,
|
|
model: data2.model,
|
|
res_id: data2.id,
|
|
});
|
|
data2.serverLastMessage = insert(messageData);
|
|
}
|
|
if ("last_message_id" in data && data.last_message_id) {
|
|
const messageData = this.messaging.models["Message"].convertData({
|
|
id: data.last_message_id,
|
|
model: data2.model,
|
|
res_id: data2.id,
|
|
});
|
|
data2.serverLastMessage = insert(messageData);
|
|
}
|
|
if ("message_needaction_counter" in data) {
|
|
data2.message_needaction_counter = data.message_needaction_counter;
|
|
}
|
|
if ("name" in data) {
|
|
data2.name = data.name;
|
|
}
|
|
if ("seen_message_id" in data) {
|
|
data2.rawLastSeenByCurrentPartnerMessageId = data.seen_message_id;
|
|
}
|
|
if ("uuid" in data) {
|
|
data2.uuid = data.uuid;
|
|
}
|
|
|
|
// relations
|
|
if ("rtc_inviting_session" in data) {
|
|
data2.rtcInvitingSession = insert(data.rtc_inviting_session);
|
|
}
|
|
if ("rtcSessions" in data) {
|
|
data2.rtcSessions = data.rtcSessions;
|
|
}
|
|
if ("seen_partners_info" in data) {
|
|
if (!data.seen_partners_info) {
|
|
data2.partnerSeenInfos = clear();
|
|
} else {
|
|
data2.partnerSeenInfos = data.seen_partners_info.map(
|
|
({ fetched_message_id, partner_id, seen_message_id }) => {
|
|
return {
|
|
lastFetchedMessage: fetched_message_id
|
|
? insert({ id: fetched_message_id })
|
|
: clear(),
|
|
lastSeenMessage: seen_message_id
|
|
? insert({ id: seen_message_id })
|
|
: clear(),
|
|
partner: { id: partner_id },
|
|
};
|
|
}
|
|
);
|
|
if (data.id || this.id) {
|
|
const messageIds = data.seen_partners_info.reduce(
|
|
(currentSet, { fetched_message_id, seen_message_id }) => {
|
|
if (fetched_message_id) {
|
|
currentSet.add(fetched_message_id);
|
|
}
|
|
if (seen_message_id) {
|
|
currentSet.add(seen_message_id);
|
|
}
|
|
return currentSet;
|
|
},
|
|
new Set()
|
|
);
|
|
if (messageIds.size > 0) {
|
|
data2.messageSeenIndicators = [...messageIds].map((messageId) => {
|
|
return {
|
|
message: { id: messageId },
|
|
};
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return data2;
|
|
},
|
|
/**
|
|
* Creates a new group chat with the provided partners.
|
|
*
|
|
* @param {Object} param0
|
|
* @param {number[]} param0.partners_to Ids of the partners to add as channel
|
|
* members.
|
|
* @param {boolean|string} param0.default_display_mode
|
|
* @returns {Thread} The newly created group chat.
|
|
*/
|
|
async createGroupChat({ default_display_mode, partners_to }) {
|
|
const channelData = await this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "create_group",
|
|
kwargs: {
|
|
default_display_mode,
|
|
partners_to,
|
|
},
|
|
});
|
|
return this.messaging.models["Thread"].insert(
|
|
this.messaging.models["Thread"].convertData(channelData)
|
|
);
|
|
},
|
|
/**
|
|
* Fetches threads matching the given composer search state to extend
|
|
* the JS knowledge and to update the suggestion list accordingly.
|
|
* More specifically only thread of model 'mail.channel' are fetched.
|
|
*
|
|
* @param {string} searchTerm
|
|
* @param {Object} [options={}]
|
|
* @param {Thread} [options.thread] prioritize and/or restrict
|
|
* result in the context of given thread
|
|
*/
|
|
async fetchSuggestions(searchTerm, { thread } = {}) {
|
|
const channelsData = await this.messaging.rpc(
|
|
{
|
|
model: "mail.channel",
|
|
method: "get_mention_suggestions",
|
|
kwargs: { search: searchTerm },
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
this.messaging.models["Thread"].insert(
|
|
channelsData.map((channelData) =>
|
|
this.messaging.models["Thread"].convertData(channelData)
|
|
)
|
|
);
|
|
},
|
|
/**
|
|
* Returns a sort function to determine the order of display of threads
|
|
* in the suggestion list.
|
|
*
|
|
* @param {string} searchTerm
|
|
* @param {Object} [options={}]
|
|
* @param {Thread} [options.thread] prioritize result in the
|
|
* context of given thread
|
|
* @returns {function}
|
|
*/
|
|
getSuggestionSortFunction(searchTerm, { thread } = {}) {
|
|
const cleanedSearchTerm = cleanSearchTerm(searchTerm);
|
|
return (a, b) => {
|
|
const isAPublicChannel =
|
|
a.model === "mail.channel" &&
|
|
a.channel.channel_type === "channel" &&
|
|
!a.authorizedGroupFullName;
|
|
const isBPublicChannel =
|
|
b.model === "mail.channel" &&
|
|
b.channel.channel_type === "channel" &&
|
|
!b.authorizedGroupFullName;
|
|
if (isAPublicChannel && !isBPublicChannel) {
|
|
return -1;
|
|
}
|
|
if (!isAPublicChannel && isBPublicChannel) {
|
|
return 1;
|
|
}
|
|
const isMemberOfA = a.channel && a.channel.memberOfCurrentUser;
|
|
const isMemberOfB = b.channel && b.channel.memberOfCurrentUser;
|
|
if (isMemberOfA && !isMemberOfB) {
|
|
return -1;
|
|
}
|
|
if (!isMemberOfA && isMemberOfB) {
|
|
return 1;
|
|
}
|
|
const cleanedAName = cleanSearchTerm(a.name || "");
|
|
const cleanedBName = cleanSearchTerm(b.name || "");
|
|
if (
|
|
cleanedAName.startsWith(cleanedSearchTerm) &&
|
|
!cleanedBName.startsWith(cleanedSearchTerm)
|
|
) {
|
|
return -1;
|
|
}
|
|
if (
|
|
!cleanedAName.startsWith(cleanedSearchTerm) &&
|
|
cleanedBName.startsWith(cleanedSearchTerm)
|
|
) {
|
|
return 1;
|
|
}
|
|
if (cleanedAName < cleanedBName) {
|
|
return -1;
|
|
}
|
|
if (cleanedAName > cleanedBName) {
|
|
return 1;
|
|
}
|
|
return a.id - b.id;
|
|
};
|
|
},
|
|
/**
|
|
* Load the previews of the specified threads. Basically, it fetches the
|
|
* last messages, since they are used to display inline content of them.
|
|
*
|
|
* @param {Thread[]} threads
|
|
*/
|
|
async loadPreviews(threads) {
|
|
const channelIds = threads.reduce((list, thread) => {
|
|
if (thread.model === "mail.channel") {
|
|
return list.concat(thread.id);
|
|
}
|
|
return list;
|
|
}, []);
|
|
if (channelIds.length === 0) {
|
|
return;
|
|
}
|
|
const channelPreviews = await this.messaging.rpc(
|
|
{
|
|
model: "mail.channel",
|
|
method: "channel_fetch_preview",
|
|
args: [channelIds],
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
this.messaging.models["Message"].insert(
|
|
channelPreviews
|
|
.filter((p) => p.last_message)
|
|
.map((channelPreview) =>
|
|
this.messaging.models["Message"].convertData(channelPreview.last_message)
|
|
)
|
|
);
|
|
},
|
|
/**
|
|
* Performs the `channel_fold` RPC on `mail.channel`.
|
|
*
|
|
* @param {number} channelId
|
|
* @param {string} state
|
|
*/
|
|
async performRpcChannelFold(channelId, state) {
|
|
return this.messaging.rpc(
|
|
{
|
|
model: "mail.channel",
|
|
method: "channel_fold",
|
|
args: [[channelId]],
|
|
kwargs: {
|
|
state,
|
|
},
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
},
|
|
/**
|
|
* Performs the `channel_info` RPC on `mail.channel`.
|
|
*
|
|
* @param {Object} param0
|
|
* @param {integer[]} param0.ids list of id of channels
|
|
* @returns {Thread[]}
|
|
*/
|
|
async performRpcChannelInfo({ ids }) {
|
|
const channelInfos = await this.messaging.rpc(
|
|
{
|
|
model: "mail.channel",
|
|
method: "channel_info",
|
|
args: [ids],
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
const channels = this.messaging.models["Thread"].insert(
|
|
channelInfos.map((channelInfo) =>
|
|
this.messaging.models["Thread"].convertData(channelInfo)
|
|
)
|
|
);
|
|
return channels;
|
|
},
|
|
/**
|
|
* Performs the `/mail/channel/set_last_seen_message` RPC.
|
|
*
|
|
* @param {Object} param0
|
|
* @param {integer} param0.id id of channel
|
|
* @param {integer[]} param0.lastMessageId
|
|
*/
|
|
async performRpcChannelSeen({ id, lastMessageId }) {
|
|
return this.messaging.rpc(
|
|
{
|
|
route: `/mail/channel/set_last_seen_message`,
|
|
params: {
|
|
channel_id: id,
|
|
last_message_id: lastMessageId,
|
|
},
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
},
|
|
/**
|
|
* Performs the `channel_pin` RPC on `mail.channel`.
|
|
*
|
|
* @param {Object} param0
|
|
* @param {number} param0.channelId
|
|
* @param {boolean} [param0.pinned=false]
|
|
*/
|
|
async performRpcChannelPin({ channelId, pinned = false }) {
|
|
return this.messaging.rpc(
|
|
{
|
|
model: "mail.channel",
|
|
method: "channel_pin",
|
|
args: [[channelId]],
|
|
kwargs: {
|
|
pinned,
|
|
},
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
},
|
|
/**
|
|
* Performs the `channel_create` RPC on `mail.channel`.
|
|
*
|
|
* @param {Object} param0
|
|
* @param {string} param0.name
|
|
* @param {integer} param0.group_id
|
|
* @returns {Thread} the created channel
|
|
*/
|
|
async performRpcCreateChannel({ name, group_id }) {
|
|
const data = await this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "channel_create",
|
|
args: [name, group_id],
|
|
});
|
|
return this.messaging.models["Thread"].insert(
|
|
this.messaging.models["Thread"].convertData(data)
|
|
);
|
|
},
|
|
/**
|
|
* Search for thread matching `searchTerm`.
|
|
*
|
|
* @param {Object} param0
|
|
* @param {integer} param0.limit
|
|
* @param {string} param0.searchTerm
|
|
*/
|
|
async searchChannelsToOpen({ limit, searchTerm }) {
|
|
const domain = [
|
|
["channel_type", "=", "channel"],
|
|
["name", "ilike", searchTerm],
|
|
];
|
|
const fields = ["channel_type", "name"];
|
|
const channelsData = await this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "search_read",
|
|
kwargs: {
|
|
domain,
|
|
fields,
|
|
limit,
|
|
},
|
|
});
|
|
return this.insert(
|
|
channelsData.map((channelData) =>
|
|
this.messaging.models["Thread"].convertData({
|
|
channel: {
|
|
channel_type: channelData.channel_type,
|
|
id: channelData.id,
|
|
},
|
|
id: channelData.id,
|
|
name: channelData.name,
|
|
})
|
|
)
|
|
);
|
|
},
|
|
/**
|
|
* Returns threads that match the given search term. More specially only
|
|
* threads of model 'mail.channel' are suggested, and if the context
|
|
* thread is a private channel, only itself is returned if it matches
|
|
* the search term.
|
|
*
|
|
* @param {string} searchTerm
|
|
* @param {Object} [options={}]
|
|
* @param {Thread} [options.thread] prioritize and/or restrict
|
|
* result in the context of given thread
|
|
* @returns {[mail.threads[], mail.threads[]]}
|
|
*/
|
|
searchSuggestions(searchTerm, { thread } = {}) {
|
|
let threads;
|
|
if (
|
|
thread &&
|
|
thread.model === "mail.channel" &&
|
|
(thread.channel.channel_type !== "channel" ||
|
|
(thread.channel.channel_type === "channel" && thread.authorizedGroupFullName))
|
|
) {
|
|
// Only return the current channel when in the context of a
|
|
// group restricted channel or group or chat. Indeed, the message with the mention
|
|
// would appear in the target channel, so this prevents from
|
|
// inadvertently leaking the private message into the mentioned
|
|
// channel.
|
|
threads = [thread];
|
|
} else {
|
|
threads = this.messaging.models["Thread"].all();
|
|
}
|
|
const cleanedSearchTerm = cleanSearchTerm(searchTerm);
|
|
return [
|
|
threads.filter(
|
|
(thread) =>
|
|
!thread.isTemporary &&
|
|
thread.channel &&
|
|
thread.channel.channel_type === "channel" &&
|
|
thread.displayName &&
|
|
cleanSearchTerm(thread.displayName).includes(cleanedSearchTerm)
|
|
),
|
|
];
|
|
},
|
|
},
|
|
recordMethods: {
|
|
/**
|
|
* Changes description of the thread to the given new description.
|
|
* Only makes sense for channels.
|
|
*
|
|
* @param {string} description
|
|
*/
|
|
async changeDescription(description) {
|
|
this.update({ description });
|
|
return this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "channel_change_description",
|
|
args: [[this.id]],
|
|
kwargs: { description },
|
|
});
|
|
},
|
|
/**
|
|
* Client-side ending of the call.
|
|
*/
|
|
endCall() {
|
|
if (this.rtc) {
|
|
this.rtc.reset();
|
|
this.messaging.soundEffects.channelLeave.play();
|
|
}
|
|
this.update({
|
|
rtc: clear(),
|
|
rtcInvitingSession: clear(),
|
|
});
|
|
},
|
|
/**
|
|
* Requests the given `requestList` data from the server.
|
|
*
|
|
* @param {string[]} requestList
|
|
*/
|
|
async fetchData(requestList) {
|
|
if (this.isTemporary) {
|
|
return;
|
|
}
|
|
const requestSet = new Set(requestList);
|
|
if (!this.hasActivities) {
|
|
requestSet.delete("activities");
|
|
}
|
|
if (requestSet.has("attachments")) {
|
|
this.update({ isLoadingAttachments: true });
|
|
}
|
|
if (requestSet.has("messages")) {
|
|
this.cache.loadNewMessages();
|
|
}
|
|
const {
|
|
activities: activitiesData,
|
|
attachments: attachmentsData,
|
|
followers: followersData,
|
|
hasWriteAccess,
|
|
mainAttachment,
|
|
hasReadAccess,
|
|
suggestedRecipients: suggestedRecipientsData,
|
|
} = await this.messaging.rpc(
|
|
{
|
|
route: "/mail/thread/data",
|
|
params: {
|
|
request_list: [...requestSet],
|
|
thread_id: this.id,
|
|
thread_model: this.model,
|
|
},
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
if (!this.exists()) {
|
|
return;
|
|
}
|
|
const values = { hasWriteAccess, mainAttachment, hasReadAccess };
|
|
if (activitiesData) {
|
|
Object.assign(values, {
|
|
activities: activitiesData.map((activityData) =>
|
|
this.messaging.models["Activity"].convertData(activityData)
|
|
),
|
|
});
|
|
}
|
|
if (attachmentsData) {
|
|
Object.assign(values, {
|
|
areAttachmentsLoaded: true,
|
|
isLoadingAttachments: false,
|
|
originThreadAttachments: attachmentsData,
|
|
});
|
|
}
|
|
if (followersData) {
|
|
Object.assign(values, {
|
|
followers: followersData.map((followerData) =>
|
|
this.messaging.models["Follower"].convertData(followerData)
|
|
),
|
|
});
|
|
}
|
|
if (suggestedRecipientsData) {
|
|
const recipientInfoList = suggestedRecipientsData.map((recipientInfoData) => {
|
|
const [partner_id, emailInfo, lang, reason] = recipientInfoData;
|
|
const [name, email] = emailInfo && mailUtils.parseEmail(emailInfo);
|
|
return {
|
|
email,
|
|
id: getSuggestedRecipientInfoNextTemporaryId(),
|
|
name,
|
|
lang,
|
|
partner: partner_id ? insert({ id: partner_id }) : clear(),
|
|
reason,
|
|
};
|
|
});
|
|
Object.assign(values, {
|
|
suggestedRecipientInfoList: recipientInfoList,
|
|
});
|
|
}
|
|
this.update(values);
|
|
this.messaging.messagingBus.trigger("o-thread-loaded-data", { thread: this });
|
|
},
|
|
/**
|
|
* Add current user to provided thread's followers.
|
|
*/
|
|
async follow() {
|
|
await this.messaging.rpc({
|
|
model: this.model,
|
|
method: "message_subscribe",
|
|
args: [[this.id]],
|
|
kwargs: {
|
|
partner_ids: [this.messaging.currentPartner.id],
|
|
},
|
|
});
|
|
if (!this.exists()) {
|
|
return;
|
|
}
|
|
this.fetchData(["followers", "suggestedRecipients"]);
|
|
},
|
|
/**
|
|
* Performs the rpc to leave the rtc call of the channel.
|
|
*/
|
|
async performRpcLeaveCall() {
|
|
await this.messaging.rpc(
|
|
{
|
|
route: "/mail/rtc/channel/leave_call",
|
|
params: { channel_id: this.id },
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
},
|
|
/**
|
|
* Leaves the current call if there is one, joins the call if the user was
|
|
* not yet in it.
|
|
*
|
|
* @param {Object} options
|
|
*/
|
|
async toggleCall(options) {
|
|
this.update({ hasPendingRtcRequest: true });
|
|
const isActiveCall = !!this.rtc;
|
|
if (this.messaging.rtc.channel) {
|
|
await this.messaging.rtc.channel.leaveCall();
|
|
}
|
|
if (isActiveCall) {
|
|
this.update({ hasPendingRtcRequest: false });
|
|
return;
|
|
}
|
|
await this._joinCall(options);
|
|
this.update({ hasPendingRtcRequest: false });
|
|
},
|
|
/**
|
|
* @param {Object} [param0]
|
|
* @param {boolean} [param0.startWithVideo] whether or not to start the call with the video
|
|
* @param {boolean} [param0.videoType] type of the video: 'user-video' or 'display'
|
|
*/
|
|
async _joinCall({ startWithVideo = false, videoType } = {}) {
|
|
if (this.model !== "mail.channel") {
|
|
return;
|
|
}
|
|
if (!this.messaging.device.hasRtcSupport) {
|
|
this.messaging.notify({
|
|
message: this.env._t("Your browser does not support webRTC."),
|
|
type: "warning",
|
|
});
|
|
return;
|
|
}
|
|
const { rtcSessions, iceServers, sessionId, invitedMembers } = await this.messaging.rpc(
|
|
{
|
|
route: "/mail/rtc/channel/join_call",
|
|
params: {
|
|
channel_id: this.id,
|
|
check_rtc_session_ids: this.rtcSessions.map((rtcSession) => rtcSession.id),
|
|
},
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
if (!this.exists()) {
|
|
return;
|
|
}
|
|
this.update({
|
|
rtc: this.messaging.rtc,
|
|
rtcInvitingSession: clear(),
|
|
rtcSessions,
|
|
invitedMembers,
|
|
});
|
|
await this.messaging.rtc.initSession({
|
|
currentSessionId: sessionId,
|
|
iceServers,
|
|
startWithAudio: true,
|
|
startWithVideo,
|
|
videoType,
|
|
});
|
|
if (!this.exists()) {
|
|
return;
|
|
}
|
|
this.messaging.soundEffects.channelJoin.play();
|
|
},
|
|
/**
|
|
* Notifies the server and does the cleanup of the current call.
|
|
*/
|
|
async leaveCall() {
|
|
await this.performRpcLeaveCall();
|
|
this.endCall();
|
|
},
|
|
/**
|
|
* @param {Array<Object>} rtcSessions server representation of the current rtc sessions of the channel
|
|
*/
|
|
updateRtcSessions(rtcSessions) {
|
|
const oldCount = this.rtcSessions.length;
|
|
this.update({ rtcSessions });
|
|
if (this.rtc) {
|
|
const newCount = this.rtcSessions.length;
|
|
if (newCount > oldCount) {
|
|
this.messaging.soundEffects.channelJoin.play();
|
|
}
|
|
if (newCount < oldCount) {
|
|
this.messaging.soundEffects.memberLeave.play();
|
|
}
|
|
}
|
|
this.rtc && this.rtc.filterCallees(this.rtcSessions);
|
|
if (this.rtc && !this.rtc.currentRtcSession) {
|
|
this.endCall();
|
|
}
|
|
},
|
|
/**
|
|
* Returns the name of the given persona in the context of this thread.
|
|
*
|
|
* @param {Persona} persona
|
|
* @returns {string}
|
|
*/
|
|
getMemberName(persona) {
|
|
return persona.name;
|
|
},
|
|
/**
|
|
* Joins this thread. Only makes sense on channels of type channel.
|
|
*/
|
|
async join() {
|
|
await this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "add_members",
|
|
args: [[this.id]],
|
|
kwargs: { partner_ids: [this.messaging.currentPartner.id] },
|
|
});
|
|
},
|
|
/**
|
|
* Leaves this thread. Only makes sense on channels of type channel.
|
|
*/
|
|
async leave() {
|
|
await this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "action_unfollow",
|
|
args: [[this.id]],
|
|
});
|
|
},
|
|
/**
|
|
* Mark the specified conversation as fetched.
|
|
*/
|
|
async markAsFetched() {
|
|
await this.messaging.rpc(
|
|
{
|
|
model: "mail.channel",
|
|
method: "channel_fetched",
|
|
args: [[this.id]],
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
},
|
|
/**
|
|
* Mark the specified conversation as read/seen.
|
|
*
|
|
* @param {Message} message the message to be considered as last seen.
|
|
*/
|
|
async markAsSeen(message) {
|
|
if (this.messaging.currentGuest) {
|
|
return;
|
|
}
|
|
if (this.model !== "mail.channel") {
|
|
return;
|
|
}
|
|
if (this.pendingSeenMessageId && message.id <= this.pendingSeenMessageId) {
|
|
return;
|
|
}
|
|
if (
|
|
this.lastSeenByCurrentPartnerMessageId &&
|
|
message.id <= this.lastSeenByCurrentPartnerMessageId
|
|
) {
|
|
return;
|
|
}
|
|
this.update({ pendingSeenMessageId: message.id });
|
|
return this.messaging.models["Thread"].performRpcChannelSeen({
|
|
id: this.id,
|
|
lastMessageId: message.id,
|
|
});
|
|
},
|
|
/**
|
|
* Marks as read all needaction messages with this thread as origin.
|
|
*/
|
|
async markNeedactionMessagesAsOriginThreadAsRead() {
|
|
await this.messaging.models["Message"].markAsRead(
|
|
this.needactionMessagesAsOriginThread
|
|
);
|
|
},
|
|
/**
|
|
* Notifies the server of new fold state. Useful for initial,
|
|
* cross-tab, and cross-device chat window state synchronization.
|
|
*
|
|
* @param {string} state
|
|
*/
|
|
async notifyFoldStateToServer(state) {
|
|
if (this.model !== "mail.channel") {
|
|
// Server sync of fold state is only supported for channels.
|
|
return;
|
|
}
|
|
return this.messaging.models["Thread"].performRpcChannelFold(this.id, state);
|
|
},
|
|
/**
|
|
* Notify server to leave the current channel. Useful for cross-tab
|
|
* and cross-device chat window state synchronization.
|
|
*
|
|
* Only makes sense if isPendingPinned is set to the desired value.
|
|
*/
|
|
async notifyPinStateToServer() {
|
|
if (this.channel.channel_type === "channel") {
|
|
await this.leave();
|
|
return;
|
|
}
|
|
await this.messaging.models["Thread"].performRpcChannelPin({
|
|
channelId: this.id,
|
|
pinned: this.isPendingPinned,
|
|
});
|
|
},
|
|
/**
|
|
* Opens this thread either as form view, in discuss app, or as a chat
|
|
* window. The thread will be opened in an "active" matter, which will
|
|
* interrupt current user flow.
|
|
*
|
|
* @param {Object} [param0]
|
|
* @param {boolean} [param0.expanded=false]
|
|
* @param {boolean} [param0.focus]
|
|
*/
|
|
async open({ expanded = false, focus } = {}) {
|
|
const discuss = this.messaging.discuss;
|
|
// check if thread must be opened in form view
|
|
if (!this.channel && !this.mailbox) {
|
|
if (expanded || discuss.discussView) {
|
|
// Close chat window because having the same thread opened
|
|
// both in chat window and as main document does not look
|
|
// good.
|
|
this.messaging.chatWindowManager.closeThread(this);
|
|
await this.messaging.openDocument({
|
|
id: this.id,
|
|
model: this.model,
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
// check if thread must be opened in discuss
|
|
if (
|
|
(!this.messaging.device.isSmall && (discuss.discussView || expanded)) ||
|
|
this.mailbox
|
|
) {
|
|
return discuss.openThread(this, {
|
|
focus: focus !== undefined ? focus : !this.messaging.device.isMobileDevice,
|
|
});
|
|
}
|
|
// thread must be opened in chat window
|
|
return this.messaging.chatWindowManager.openThread(this, {
|
|
makeActive: true,
|
|
});
|
|
},
|
|
/**
|
|
* Opens the most appropriate view that is a profile for this thread.
|
|
*/
|
|
async openProfile() {
|
|
return this.messaging.openDocument({
|
|
id: this.id,
|
|
model: this.model,
|
|
});
|
|
},
|
|
/**
|
|
* Pin this thread and notify server of the change.
|
|
*/
|
|
async pin() {
|
|
this.update({ isPendingPinned: true });
|
|
if (this.messaging.currentGuest) {
|
|
return;
|
|
}
|
|
await this.notifyPinStateToServer();
|
|
},
|
|
/**
|
|
* Refresh the typing status of the current partner.
|
|
*/
|
|
refreshCurrentPartnerIsTyping() {
|
|
this.update({
|
|
currentPartnerInactiveTypingTimer: {
|
|
doReset: this.currentPartnerInactiveTypingTimer ? true : undefined,
|
|
},
|
|
});
|
|
},
|
|
/**
|
|
* Called to refresh a registered other member that is typing something.
|
|
*
|
|
* @param {Member} member
|
|
*/
|
|
refreshOtherMemberTypingMember(member) {
|
|
this.messaging.models["OtherMemberLongTypingInThreadTimer"].insert({
|
|
member,
|
|
thread: this,
|
|
timer: {
|
|
doReset: true,
|
|
},
|
|
});
|
|
},
|
|
/**
|
|
* Called when current partner is inserting some input in composer.
|
|
* Useful to notify current partner is currently typing something in the
|
|
* composer of this thread to all other members.
|
|
*/
|
|
async registerCurrentPartnerIsTyping() {
|
|
// Handling of typing timers.
|
|
this.update({
|
|
currentPartnerInactiveTypingTimer: {},
|
|
currentPartnerLongTypingTimer: {},
|
|
});
|
|
// Manage typing member relation.
|
|
const memberOfCurrentUser = this.channel.memberOfCurrentUser;
|
|
const newOrderedTypingMembers = [
|
|
...this.orderedTypingMembers.filter((member) => member !== memberOfCurrentUser),
|
|
memberOfCurrentUser,
|
|
];
|
|
this.update({
|
|
isCurrentPartnerTyping: true,
|
|
orderedTypingMembers: newOrderedTypingMembers,
|
|
typingMembers: link(memberOfCurrentUser),
|
|
});
|
|
// Notify typing status to other members.
|
|
await this.throttleNotifyCurrentPartnerTypingStatus.do();
|
|
},
|
|
/**
|
|
* Called to register a new other member partner is typing something.
|
|
*
|
|
* @param {Member} member
|
|
*/
|
|
registerOtherMemberTypingMember(member) {
|
|
this.update({ otherMembersLongTypingTimers: insert({ member }) });
|
|
const newOrderedTypingMembers = [
|
|
...this.orderedTypingMembers.filter((currentMember) => currentMember !== member),
|
|
member,
|
|
];
|
|
this.update({
|
|
orderedTypingMembers: newOrderedTypingMembers,
|
|
typingMembers: link(member),
|
|
});
|
|
},
|
|
/**
|
|
* Renames this thread to the given new name.
|
|
* Only makes sense for channels.
|
|
*
|
|
* @param {string} name
|
|
*/
|
|
async rename(name) {
|
|
this.update({ name });
|
|
return this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "channel_rename",
|
|
args: [[this.id]],
|
|
kwargs: { name },
|
|
});
|
|
},
|
|
/**
|
|
* Sets the custom name of this thread for the current user to the given
|
|
* new name.
|
|
* Only makes sense for channels.
|
|
*
|
|
* @param {string} newName
|
|
*/
|
|
async setCustomName(newName) {
|
|
return this.messaging.rpc({
|
|
model: "mail.channel",
|
|
method: "channel_set_custom_name",
|
|
args: [this.id],
|
|
kwargs: { name: newName },
|
|
});
|
|
},
|
|
/**
|
|
* @param {Attachment} attachment
|
|
*/
|
|
async setMainAttachment(attachment) {
|
|
this.update({ mainAttachment: attachment });
|
|
await this.messaging.rpc({
|
|
model: "ir.attachment",
|
|
method: "register_as_main_attachment",
|
|
args: [[this.mainAttachment.id]],
|
|
});
|
|
},
|
|
/**
|
|
* Unfollow current partner from this thread.
|
|
*/
|
|
async unfollow() {
|
|
await this.followerOfCurrentPartner.remove();
|
|
},
|
|
/**
|
|
* Unpin this thread and notify server of the change.
|
|
*/
|
|
async unpin() {
|
|
this.update({ isPendingPinned: false });
|
|
if (this.messaging.currentGuest) {
|
|
return;
|
|
}
|
|
await this.notifyPinStateToServer();
|
|
},
|
|
/**
|
|
* Called when current partner has explicitly stopped inserting some
|
|
* input in composer. Useful to notify current partner has currently
|
|
* stopped typing something in the composer of this thread to all other
|
|
* members.
|
|
*
|
|
* @param {Object} [param0={}]
|
|
* @param {boolean} [param0.immediateNotify=false] if set, is typing
|
|
* status of current partner is immediately notified and doesn't
|
|
* consume throttling at all.
|
|
*/
|
|
unregisterCurrentPartnerIsTyping({ immediateNotify = false } = {}) {
|
|
// Handling of typing timers.
|
|
this.update({
|
|
currentPartnerInactiveTypingTimer: clear(),
|
|
currentPartnerLongTypingTimer: clear(),
|
|
});
|
|
// Manage typing member relation.
|
|
const memberOfCurrentUser = this.channel.memberOfCurrentUser;
|
|
const newOrderedTypingMembers = this.orderedTypingMembers.filter(
|
|
(member) => member !== memberOfCurrentUser
|
|
);
|
|
this.update({
|
|
isCurrentPartnerTyping: false,
|
|
orderedTypingMembers: newOrderedTypingMembers,
|
|
typingMembers: unlink(memberOfCurrentUser),
|
|
});
|
|
// Notify typing status to other members.
|
|
if (immediateNotify) {
|
|
this.throttleNotifyCurrentPartnerTypingStatus.clear();
|
|
}
|
|
this.throttleNotifyCurrentPartnerTypingStatus.do();
|
|
},
|
|
/**
|
|
* Called to unregister an other member partner that is no longer typing
|
|
* something.
|
|
*
|
|
* @param {Member} member
|
|
*/
|
|
unregisterOtherMemberTypingMember(member) {
|
|
this.update({ otherMembersLongTypingTimers: insertAndUnlink({ member }) });
|
|
const newOrderedTypingMembers = this.orderedTypingMembers.filter(
|
|
(currentMember) => currentMember !== member
|
|
);
|
|
this.update({
|
|
orderedTypingMembers: newOrderedTypingMembers,
|
|
typingMembers: unlink(member),
|
|
});
|
|
},
|
|
/**
|
|
* Unsubscribe current user from provided channel.
|
|
*/
|
|
unsubscribe() {
|
|
this.leaveCall();
|
|
this.messaging.chatWindowManager.closeThread(this);
|
|
this.unpin();
|
|
},
|
|
/**
|
|
* @private
|
|
*/
|
|
async _notifyCurrentPartnerTypingStatus() {
|
|
if (
|
|
this.forceNotifyNextCurrentPartnerTypingStatus ||
|
|
this.isCurrentPartnerTyping !== this.currentPartnerLastNotifiedIsTyping
|
|
) {
|
|
if (this.model === "mail.channel") {
|
|
await this.messaging.rpc(
|
|
{
|
|
route: "/mail/channel/notify_typing",
|
|
params: {
|
|
channel_id: this.id,
|
|
is_typing: this.isCurrentPartnerTyping,
|
|
},
|
|
},
|
|
{ shadow: true }
|
|
);
|
|
if (!this.exists()) {
|
|
return;
|
|
}
|
|
}
|
|
if (this.isCurrentPartnerTyping && this.currentPartnerLongTypingTimer) {
|
|
this.currentPartnerLongTypingTimer.update({ doReset: true });
|
|
}
|
|
}
|
|
this.update({
|
|
currentPartnerLastNotifiedIsTyping: this.isCurrentPartnerTyping,
|
|
forceNotifyNextCurrentPartnerTypingStatus: false,
|
|
});
|
|
},
|
|
/**
|
|
* @private
|
|
*/
|
|
_onChangeLastSeenByCurrentPartnerMessageId() {
|
|
this.messaging.messagingBus.trigger(
|
|
"o-thread-last-seen-by-current-partner-message-id-changed",
|
|
{
|
|
thread: this,
|
|
}
|
|
);
|
|
},
|
|
/**
|
|
* Handles change of pinned state coming from the server. Useful to
|
|
* clear pending state once server acknowledged the change.
|
|
*
|
|
* @private
|
|
* @see isPendingPinned
|
|
*/
|
|
_onIsServerPinnedChanged() {
|
|
if (this.isServerPinned === this.isPendingPinned) {
|
|
this.update({ isPendingPinned: clear() });
|
|
}
|
|
},
|
|
/**
|
|
* Handles change of fold state coming from the server. Useful to
|
|
* synchronize corresponding chat window.
|
|
*
|
|
* @private
|
|
*/
|
|
_onServerFoldStateChanged() {
|
|
if (!this.messaging.chatWindowManager) {
|
|
// avoid crash during destroy
|
|
return;
|
|
}
|
|
if (this.messaging.device.isSmall) {
|
|
return;
|
|
}
|
|
if (this.serverFoldState === "closed") {
|
|
this.messaging.chatWindowManager.closeThread(this, {
|
|
notifyServer: false,
|
|
});
|
|
} else {
|
|
this.messaging.chatWindowManager.openThread(this, {
|
|
isFolded: this.serverFoldState === "folded",
|
|
notifyServer: false,
|
|
});
|
|
}
|
|
},
|
|
/**
|
|
* Event handler for clicking thread in discuss app.
|
|
*/
|
|
async onClick() {
|
|
await this.open();
|
|
},
|
|
onCurrentPartnerInactiveTypingTimeout() {
|
|
this.unregisterCurrentPartnerIsTyping();
|
|
},
|
|
/**
|
|
* Called when current partner has been typing for a very long time.
|
|
* Immediately notify other members that he/she is still typing.
|
|
*/
|
|
async onCurrentPartnerLongTypingTimeout() {
|
|
this.update({
|
|
currentPartnerLongTypingTimer: clear(),
|
|
forceNotifyNextCurrentPartnerTypingStatus: true,
|
|
isCurrentPartnerTyping: true,
|
|
});
|
|
this.throttleNotifyCurrentPartnerTypingStatus.clear();
|
|
await this.throttleNotifyCurrentPartnerTypingStatus.do();
|
|
},
|
|
},
|
|
fields: {
|
|
accessRestrictedToGroupText: attr({
|
|
default: "",
|
|
compute() {
|
|
if (!this.authorizedGroupFullName) {
|
|
return clear();
|
|
}
|
|
return sprintf(this.env._t('Access restricted to group "%(groupFullName)s"'), {
|
|
groupFullName: this.authorizedGroupFullName,
|
|
});
|
|
},
|
|
}),
|
|
/**
|
|
* Determines the `mail.activity` that belong to `this`, assuming `this`
|
|
* has activities (@see hasActivities).
|
|
*/
|
|
activities: many("Activity", { inverse: "thread" }),
|
|
activity_state: attr({
|
|
compute() {
|
|
if (this.overdueActivities.length > 0) {
|
|
return "overdue";
|
|
}
|
|
if (this.todayActivities.length > 0) {
|
|
return "today";
|
|
}
|
|
if (this.futureActivities.length > 0) {
|
|
return "planned";
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
allAttachments: many("Attachment", {
|
|
inverse: "allThreads",
|
|
compute() {
|
|
return this.originThreadAttachments;
|
|
},
|
|
sort: [
|
|
["truthy-first", "isUploading"],
|
|
["greater-first", "id"],
|
|
],
|
|
}),
|
|
areAttachmentsLoaded: attr({ default: false }),
|
|
attachmentsInWebClientView: many("Attachment", {
|
|
inverse: "threadsAsAttachmentsInWebClientView",
|
|
readonly: true,
|
|
sort: [["greater-first", "id"]],
|
|
}),
|
|
authorizedGroupFullName: attr(),
|
|
cache: one("ThreadCache", {
|
|
default: {},
|
|
inverse: "thread",
|
|
readonly: true,
|
|
required: true,
|
|
}),
|
|
channel: one("Channel", { inverse: "thread", isCausal: true, readonly: true }),
|
|
/**
|
|
* States the chat window related to this thread (if any).
|
|
*/
|
|
chatWindow: one("ChatWindow", { inverse: "thread" }),
|
|
/**
|
|
* Determines the composer state of this thread.
|
|
*/
|
|
composer: one("Composer", {
|
|
inverse: "thread",
|
|
compute() {
|
|
if (this.mailbox) {
|
|
return clear();
|
|
}
|
|
return {};
|
|
},
|
|
}),
|
|
creator: one("User"),
|
|
/**
|
|
* Timer of current partner that was currently typing something, but
|
|
* there is no change on the input for 5 seconds. This is used
|
|
* in order to automatically notify other members that current
|
|
* partner has stopped typing something, due to making no changes
|
|
* on the composer for some time.
|
|
*/
|
|
currentPartnerInactiveTypingTimer: one("Timer", {
|
|
inverse: "threadAsCurrentPartnerInactiveTypingTimerOwner",
|
|
}),
|
|
/**
|
|
* Last 'is_typing' status of current partner that has been notified
|
|
* to other members. Useful to prevent spamming typing notifications
|
|
* to other members if it hasn't changed. An exception is the
|
|
* current partner long typing scenario where current partner has
|
|
* to re-send the same typing notification from time to time, so
|
|
* that other members do not assume he/she is no longer typing
|
|
* something from not receiving any typing notifications for a
|
|
* very long time.
|
|
*
|
|
* Supported values: true/false/undefined.
|
|
* undefined makes only sense initially and during current partner
|
|
* long typing timeout flow.
|
|
*/
|
|
currentPartnerLastNotifiedIsTyping: attr(),
|
|
/**
|
|
* Timer of current partner that is typing a very long text. When
|
|
* the other members do not receive any typing notification for a
|
|
* long time, they must assume that the related partner is no longer
|
|
* typing something (e.g. they have closed the browser tab).
|
|
* This is a timer to let other members know that current partner
|
|
* is still typing something, so that they should not assume he/she
|
|
* has stopped typing something.
|
|
*/
|
|
currentPartnerLongTypingTimer: one("Timer", {
|
|
inverse: "threadAsCurrentPartnerLongTypingTimerOwner",
|
|
}),
|
|
/**
|
|
* Determines the default display mode of this channel. Should contain
|
|
* either no value (to display the chat), or 'video_full_screen' to
|
|
* start a call in full screen.
|
|
*/
|
|
defaultDisplayMode: attr(),
|
|
/**
|
|
* States the description of this thread. Only applies to channels.
|
|
*/
|
|
description: attr(),
|
|
displayName: attr({
|
|
compute() {
|
|
if (this.channel) {
|
|
return this.channel.displayName;
|
|
}
|
|
if (this.mailbox) {
|
|
return this.mailbox.name;
|
|
}
|
|
return this.name;
|
|
},
|
|
}),
|
|
fetchMessagesParams: attr({
|
|
compute() {
|
|
if (this.model === "mail.channel") {
|
|
return { channel_id: this.id };
|
|
}
|
|
if (this.mailbox) {
|
|
return {};
|
|
}
|
|
return {
|
|
thread_id: this.id,
|
|
thread_model: this.model,
|
|
};
|
|
},
|
|
}),
|
|
fetchMessagesUrl: attr({
|
|
compute() {
|
|
if (this.model === "mail.channel") {
|
|
return `/mail/channel/messages`;
|
|
}
|
|
if (this.mailbox) {
|
|
return this.mailbox.fetchMessagesUrl;
|
|
}
|
|
return `/mail/thread/messages`;
|
|
},
|
|
}),
|
|
followerOfCurrentPartner: one("Follower", {
|
|
inverse: "followedThreadAsFollowerOfCurrentPartner",
|
|
}),
|
|
followersPartner: many("Partner", { related: "followers.partner" }),
|
|
followers: many("Follower", { inverse: "followedThread" }),
|
|
/**
|
|
* Determines whether the next request to notify current partner
|
|
* typing status should always result to making RPC, regardless of
|
|
* whether last notified current partner typing status is the same.
|
|
* Most of the time we do not want to notify if value hasn't
|
|
* changed, exception being the long typing scenario of current
|
|
* partner.
|
|
*/
|
|
forceNotifyNextCurrentPartnerTypingStatus: attr({ default: false }),
|
|
/**
|
|
* States the `Activity` that belongs to `this` and that are
|
|
* planned in the future (due later than today).
|
|
*/
|
|
futureActivities: many("Activity", {
|
|
compute() {
|
|
return this.activities.filter((activity) => activity.state === "planned");
|
|
},
|
|
}),
|
|
group_based_subscription: attr({ default: false }),
|
|
/**
|
|
* States whether the current user has read access for this thread.
|
|
*/
|
|
hasReadAccess: attr(),
|
|
/**
|
|
* States whether `this` has activities (`mail.activity.mixin` server side).
|
|
*/
|
|
hasActivities: attr({ default: false }),
|
|
/**
|
|
* Determines whether the RTC call feature should be displayed.
|
|
*/
|
|
hasCallFeature: attr({
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
return ["channel", "chat", "group"].includes(this.channel.channel_type);
|
|
},
|
|
}),
|
|
/**
|
|
* States whether this thread should has the invite feature. Only makes
|
|
* sense for channels.
|
|
*/
|
|
hasInviteFeature: attr({
|
|
compute() {
|
|
return this.model === "mail.channel";
|
|
},
|
|
}),
|
|
/**
|
|
* Determines whether it makes sense for this thread to have a member list.
|
|
*/
|
|
hasMemberListFeature: attr({
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
return ["channel", "group"].includes(this.channel.channel_type);
|
|
},
|
|
}),
|
|
/**
|
|
* States whether there is a server request for joining or leaving the RTC session.
|
|
* TODO Should maybe be on messaging (after messaging env rebase) to lock the rpc across all threads.
|
|
*/
|
|
hasPendingRtcRequest: attr({ default: false }),
|
|
/**
|
|
* Determine whether this thread has the seen indicators (V and VV)
|
|
* enabled or not.
|
|
*/
|
|
hasSeenIndicators: attr({
|
|
default: false,
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
return ["chat", "livechat"].includes(this.channel.channel_type);
|
|
},
|
|
}),
|
|
/**
|
|
* States whether current user has write access for the record. If yes, few other operations
|
|
* (like adding other followers to the thread) are enabled for the user.
|
|
*/
|
|
hasWriteAccess: attr({ default: false }),
|
|
id: attr({ identifying: true }),
|
|
invitationLink: attr({
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
if (
|
|
!this.uuid ||
|
|
!this.channel.channel_type ||
|
|
this.channel.channel_type === "chat"
|
|
) {
|
|
return clear();
|
|
}
|
|
return `${window.location.origin}/chat/${this.id}/${this.uuid}`;
|
|
},
|
|
}),
|
|
/**
|
|
* List of members that have been invited to the RTC call of this channel.
|
|
*/
|
|
invitedMembers: many("ChannelMember"),
|
|
/**
|
|
* Determines whether this description can be changed.
|
|
* Only makes sense for channels.
|
|
*/
|
|
isChannelDescriptionChangeable: attr({
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
return ["channel", "group"].includes(this.channel.channel_type);
|
|
},
|
|
}),
|
|
/**
|
|
* Determines whether this thread can be renamed.
|
|
* Only makes sense for channels.
|
|
*/
|
|
isChannelRenamable: attr({
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
return ["chat", "channel", "group"].includes(this.channel.channel_type);
|
|
},
|
|
}),
|
|
/**
|
|
* States whether this thread is a `mail.channel` qualified as chat.
|
|
*
|
|
* Useful to list chat channels, like in messaging menu with the filter
|
|
* 'chat'.
|
|
*/
|
|
isChatChannel: attr({
|
|
default: false,
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
return ["chat", "group"].includes(this.channel.channel_type);
|
|
},
|
|
}),
|
|
isCurrentPartnerFollowing: attr({
|
|
default: false,
|
|
compute() {
|
|
return this.followers.some(
|
|
(follower) =>
|
|
follower.partner && follower.partner === this.messaging.currentPartner
|
|
);
|
|
},
|
|
}),
|
|
isCurrentPartnerTyping: attr({ default: false }),
|
|
/**
|
|
* States whether this thread description is editable by the current user.
|
|
*/
|
|
isDescriptionEditableByCurrentUser: attr({
|
|
compute() {
|
|
return Boolean(
|
|
this.messaging &&
|
|
this.messaging.currentUser &&
|
|
this.messaging.currentUser.isInternalUser &&
|
|
this.isChannelDescriptionChangeable
|
|
);
|
|
},
|
|
}),
|
|
/**
|
|
* States whether `this` is currently loading attachments.
|
|
*/
|
|
isLoadingAttachments: attr({ default: false }),
|
|
/**
|
|
* Determine if there is a pending pin state change, which is a change
|
|
* of pin state requested by the client but not yet confirmed by the
|
|
* server.
|
|
*
|
|
* This field can be updated to immediately change the pin state on the
|
|
* interface and to notify the server of the new state.
|
|
*/
|
|
isPendingPinned: attr(),
|
|
/**
|
|
* Boolean that determines whether this thread is pinned
|
|
* in discuss and present in the messaging menu.
|
|
*/
|
|
isPinned: attr({
|
|
compute() {
|
|
return this.isPendingPinned !== undefined
|
|
? this.isPendingPinned
|
|
: this.isServerPinned;
|
|
},
|
|
}),
|
|
/**
|
|
* Determine the last pin state known by the server, which is the pin
|
|
* state displayed after initialization or when the last pending
|
|
* pin state change was confirmed by the server.
|
|
*
|
|
* This field should be considered read only in most situations. Only
|
|
* the code handling pin state change from the server should typically
|
|
* update it.
|
|
*/
|
|
isServerPinned: attr({ default: false }),
|
|
isTemporary: attr({ default: false }),
|
|
/**
|
|
* States the date and time of the last interesting event that happened
|
|
* in this channel for this partner. This includes: creating, joining,
|
|
* pinning, and new message posted. It is contained as a Date object.
|
|
*/
|
|
lastInterestDateTime: attr(),
|
|
lastCurrentPartnerMessageSeenByEveryone: one("Message", {
|
|
compute() {
|
|
const otherPartnerSeenInfos = this.partnerSeenInfos.filter(
|
|
(partnerSeenInfo) => partnerSeenInfo.partner !== this.messaging.currentPartner
|
|
);
|
|
if (otherPartnerSeenInfos.length === 0) {
|
|
return clear();
|
|
}
|
|
|
|
const otherPartnersLastSeenMessageIds = otherPartnerSeenInfos.map(
|
|
(partnerSeenInfo) =>
|
|
partnerSeenInfo.lastSeenMessage ? partnerSeenInfo.lastSeenMessage.id : 0
|
|
);
|
|
if (otherPartnersLastSeenMessageIds.length === 0) {
|
|
return clear();
|
|
}
|
|
const lastMessageSeenByAllId = Math.min(...otherPartnersLastSeenMessageIds);
|
|
const currentPartnerOrderedSeenMessages = this.orderedNonTransientMessages.filter(
|
|
(message) =>
|
|
message.author === this.messaging.currentPartner &&
|
|
message.id <= lastMessageSeenByAllId
|
|
);
|
|
|
|
if (
|
|
!currentPartnerOrderedSeenMessages ||
|
|
currentPartnerOrderedSeenMessages.length === 0
|
|
) {
|
|
return clear();
|
|
}
|
|
return currentPartnerOrderedSeenMessages.slice().pop();
|
|
},
|
|
}),
|
|
/**
|
|
* Last message of the thread, could be a transient one.
|
|
*/
|
|
lastMessage: one("Message", {
|
|
compute() {
|
|
const { length: l, [l - 1]: lastMessage } = this.orderedMessages;
|
|
if (lastMessage) {
|
|
return lastMessage;
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
/**
|
|
* States the last known needaction message having this thread as origin.
|
|
*/
|
|
lastNeedactionMessageAsOriginThread: one("Message", {
|
|
compute() {
|
|
const orderedNeedactionMessagesAsOriginThread = this.needactionMessagesAsOriginThread.sort(
|
|
(m1, m2) => (m1.id < m2.id ? -1 : 1)
|
|
);
|
|
const {
|
|
length: l,
|
|
[l - 1]: lastNeedactionMessageAsOriginThread,
|
|
} = orderedNeedactionMessagesAsOriginThread;
|
|
if (lastNeedactionMessageAsOriginThread) {
|
|
return lastNeedactionMessageAsOriginThread;
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
/**
|
|
* Last non-transient message.
|
|
*/
|
|
lastNonTransientMessage: one("Message", {
|
|
compute() {
|
|
const { length: l, [l - 1]: lastMessage } = this.orderedNonTransientMessages;
|
|
if (lastMessage) {
|
|
return lastMessage;
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
/**
|
|
* Last seen message id of the channel by current partner.
|
|
*
|
|
* Also, it needs to be kept as an id because it's considered like a "date" and could stay
|
|
* even if corresponding message is deleted. It is basically used to know which
|
|
* messages are before or after it.
|
|
*/
|
|
lastSeenByCurrentPartnerMessageId: attr({
|
|
default: 0,
|
|
/**
|
|
* Adjusts the last seen message received from the server to consider
|
|
* the following messages also as read if they are either transient
|
|
* messages or messages from the current partner.
|
|
*/
|
|
compute() {
|
|
const firstMessage = this.orderedMessages[0];
|
|
if (
|
|
firstMessage &&
|
|
this.rawLastSeenByCurrentPartnerMessageId &&
|
|
this.rawLastSeenByCurrentPartnerMessageId < firstMessage.id
|
|
) {
|
|
// no deduction can be made if there is a gap
|
|
return this.rawLastSeenByCurrentPartnerMessageId;
|
|
}
|
|
let lastSeenByCurrentPartnerMessageId = this.rawLastSeenByCurrentPartnerMessageId;
|
|
for (const message of this.orderedMessages) {
|
|
if (message.id <= this.rawLastSeenByCurrentPartnerMessageId) {
|
|
continue;
|
|
}
|
|
if (
|
|
(message.author &&
|
|
this.messaging.currentPartner &&
|
|
message.author === this.messaging.currentPartner) ||
|
|
(message.guestAuthor &&
|
|
this.messaging.currentGuest &&
|
|
message.guestAuthor === this.messaging.currentGuest) ||
|
|
message.isTransient
|
|
) {
|
|
lastSeenByCurrentPartnerMessageId = message.id;
|
|
continue;
|
|
}
|
|
return lastSeenByCurrentPartnerMessageId;
|
|
}
|
|
return lastSeenByCurrentPartnerMessageId;
|
|
},
|
|
}),
|
|
mailbox: one("Mailbox", { inverse: "thread" }),
|
|
mainAttachment: one("Attachment"),
|
|
/**
|
|
* Determines the last mentioned channels of the last composer related
|
|
* to this thread. Useful to sync the composer when re-creating it.
|
|
*/
|
|
mentionedChannelsBackup: many("Thread"),
|
|
/**
|
|
* Determines the last mentioned partners of the last composer related
|
|
* to this thread. Useful to sync the composer when re-creating it.
|
|
*/
|
|
mentionedPartnersBackup: many("Partner"),
|
|
/**
|
|
* Determines the message before which the "new message" separator must
|
|
* be positioned, if any.
|
|
*/
|
|
messageAfterNewMessageSeparator: one("Message", {
|
|
compute() {
|
|
if (!this.channel) {
|
|
return clear();
|
|
}
|
|
if (this.channel.localMessageUnreadCounter === 0) {
|
|
return clear();
|
|
}
|
|
const index = this.orderedMessages.findIndex(
|
|
(message) => message.id === this.lastSeenByCurrentPartnerMessageId
|
|
);
|
|
if (index === -1) {
|
|
return clear();
|
|
}
|
|
const message = this.orderedMessages[index + 1];
|
|
if (!message) {
|
|
return clear();
|
|
}
|
|
return message;
|
|
},
|
|
}),
|
|
message_needaction_counter: attr({ default: 0 }),
|
|
/**
|
|
* All messages that this thread is linked to.
|
|
* Note that this field is automatically computed by inverse
|
|
* computed field.
|
|
*/
|
|
messages: many("Message", { inverse: "threads", readonly: true }),
|
|
/**
|
|
* All messages that have been originally posted in this thread.
|
|
*/
|
|
messagesAsOriginThread: many("Message", { inverse: "originThread", isCausal: true }),
|
|
/**
|
|
* Contains the message fetched/seen indicators for all messages of this thread.
|
|
*/
|
|
messageSeenIndicators: many("MessageSeenIndicator", { inverse: "thread" }),
|
|
messagingAsAllCurrentClientThreads: one("Messaging", {
|
|
inverse: "allCurrentClientThreads",
|
|
compute() {
|
|
if (
|
|
!this.messaging ||
|
|
!this.channel ||
|
|
!this.channel.memberOfCurrentUser ||
|
|
!this.isServerPinned
|
|
) {
|
|
return clear();
|
|
}
|
|
return this.messaging;
|
|
},
|
|
}),
|
|
messagingAsRingingThread: one("Messaging", {
|
|
inverse: "ringingThreads",
|
|
compute() {
|
|
if (this.rtcInvitingSession) {
|
|
return this.messaging;
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
messagingMenuAsPinnedAndUnreadChannel: one("MessagingMenu", {
|
|
inverse: "pinnedAndUnreadChannels",
|
|
compute() {
|
|
if (!this.messaging || !this.messaging.messagingMenu) {
|
|
return clear();
|
|
}
|
|
if (this.channel && this.isPinned && this.channel.localMessageUnreadCounter > 0) {
|
|
return this.messaging.messagingMenu;
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
model: attr({ identifying: true }),
|
|
model_name: attr(),
|
|
moduleIcon: attr(),
|
|
name: attr(),
|
|
/**
|
|
* States all known needaction messages having this thread as origin.
|
|
*/
|
|
needactionMessagesAsOriginThread: many("Message", {
|
|
compute() {
|
|
return this.messagesAsOriginThread.filter((message) => message.isNeedaction);
|
|
},
|
|
}),
|
|
/**
|
|
* All messages ordered like they are displayed.
|
|
*/
|
|
orderedMessages: many("Message", {
|
|
compute() {
|
|
return this.messages.sort((m1, m2) => (m1.id < m2.id ? -1 : 1));
|
|
},
|
|
}),
|
|
/**
|
|
* All messages ordered like they are displayed. This field does not
|
|
* contain transient messages which are not "real" records.
|
|
*/
|
|
orderedNonTransientMessages: many("Message", {
|
|
compute() {
|
|
return this.orderedMessages.filter((m) => !m.isTransient);
|
|
},
|
|
}),
|
|
/**
|
|
* Ordered typing members on this thread, excluding the current partner.
|
|
*/
|
|
orderedOtherTypingMembers: many("ChannelMember", {
|
|
compute() {
|
|
return this.orderedTypingMembers.filter((member) => !member.isMemberOfCurrentUser);
|
|
},
|
|
}),
|
|
/**
|
|
* Ordered list of typing members.
|
|
*/
|
|
orderedTypingMembers: many("ChannelMember"),
|
|
originThreadAttachments: many("Attachment", { inverse: "originThread", isCausal: true }),
|
|
/**
|
|
* Registry of timers of partners currently typing in the thread,
|
|
* excluding current partner. This is useful in order to
|
|
* automatically unregister typing members when not receive any
|
|
* typing notification after a long time. Timers are internally
|
|
* indexed by partner records as key. The current partner is
|
|
* ignored in this registry of timers.
|
|
*
|
|
* @see registerOtherMemberTypingMember
|
|
* @see unregisterOtherMemberTypingMember
|
|
*/
|
|
otherMembersLongTypingTimers: many("OtherMemberLongTypingInThreadTimer", {
|
|
inverse: "thread",
|
|
}),
|
|
/**
|
|
* States the `Activity` that belongs to `this` and that are
|
|
* overdue (due earlier than today).
|
|
*/
|
|
overdueActivities: many("Activity", {
|
|
compute() {
|
|
return this.activities.filter((activity) => activity.state === "overdue");
|
|
},
|
|
}),
|
|
/**
|
|
* Contains the seen information for all members of the thread.
|
|
* FIXME This field should be readonly once task-2336946 is done.
|
|
*/
|
|
partnerSeenInfos: many("ThreadPartnerSeenInfo", { inverse: "thread" }),
|
|
/**
|
|
* Determine if there is a pending seen message change, which is a change
|
|
* of seen message requested by the client but not yet confirmed by the
|
|
* server.
|
|
*/
|
|
pendingSeenMessageId: attr(),
|
|
rawLastSeenByCurrentPartnerMessageId: attr({ default: 0 }),
|
|
/**
|
|
* If set, the current thread is the thread that hosts the current RTC call.
|
|
*/
|
|
rtc: one("Rtc", { inverse: "channel" }),
|
|
callInviteRequestPopup: one("CallInviteRequestPopup", {
|
|
inverse: "thread",
|
|
compute() {
|
|
if (this.rtcInvitingSession) {
|
|
return {};
|
|
}
|
|
return clear();
|
|
},
|
|
}),
|
|
/**
|
|
* The session that invited the current user, it is only set when the
|
|
* invitation is still pending.
|
|
*/
|
|
rtcInvitingSession: one("RtcSession", { inverse: "calledChannels" }),
|
|
rtcSessions: many("RtcSession", { inverse: "channel", isCausal: true }),
|
|
/**
|
|
* Determine the last fold state known by the server, which is the fold
|
|
* state displayed after initialization or when the last pending
|
|
* fold state change was confirmed by the server.
|
|
*
|
|
* This field should be considered read only in most situations. Only
|
|
* the code handling fold state change from the server should typically
|
|
* update it.
|
|
*/
|
|
serverFoldState: attr({ default: "closed" }),
|
|
/**
|
|
* Last message considered by the server.
|
|
*
|
|
* Useful to compute localMessageUnreadCounter field.
|
|
*
|
|
* @see localMessageUnreadCounter
|
|
*/
|
|
serverLastMessage: one("Message"),
|
|
suggestable: one("ComposerSuggestable", {
|
|
default: {},
|
|
inverse: "thread",
|
|
readonly: true,
|
|
required: true,
|
|
}),
|
|
/**
|
|
* Determines the `SuggestedRecipientInfo` concerning `this`.
|
|
*/
|
|
suggestedRecipientInfoList: many("SuggestedRecipientInfo", {
|
|
inverse: "thread",
|
|
isCausal: true,
|
|
}),
|
|
/**
|
|
* Determines the last content of the last composer related to this
|
|
* thread. Useful to sync the composer when re-creating it.
|
|
*/
|
|
textInputContentBackup: attr({ default: "" }),
|
|
/**
|
|
* Determines the last cursor end of the last composer related to this
|
|
* thread. Useful to sync the composer when re-creating it.
|
|
*/
|
|
textInputCursorEndBackup: attr({ default: 0 }),
|
|
/**
|
|
* Determines the last cursor start of the last composer related to this
|
|
* thread. Useful to sync the composer when re-creating it.
|
|
*/
|
|
textInputCursorStartBackup: attr({ default: 0 }),
|
|
/**
|
|
* Determines the last selection direction of the last composer related
|
|
* to this thread. Useful to sync the composer when re-creating it.
|
|
*/
|
|
textInputSelectionDirectionBackup: attr({ default: "none" }),
|
|
threadViews: many("ThreadView", { inverse: "thread" }),
|
|
/**
|
|
* Clearable and cancellable throttled version of the
|
|
* `_notifyCurrentPartnerTypingStatus` method.
|
|
* This is useful when the current partner posts a message and
|
|
* types something else afterwards: it must notify immediately that
|
|
* he/she is typing something, instead of waiting for the throttle
|
|
* internal timer.
|
|
*
|
|
* @see _notifyCurrentPartnerTypingStatus
|
|
*/
|
|
throttleNotifyCurrentPartnerTypingStatus: one("Throttle", {
|
|
inverse: "threadAsThrottleNotifyCurrentPartnerTypingStatus",
|
|
compute() {
|
|
return {
|
|
func: () => this._notifyCurrentPartnerTypingStatus(),
|
|
};
|
|
},
|
|
}),
|
|
/**
|
|
* States the `Activity` that belongs to `this` and that are due
|
|
* specifically today.
|
|
*/
|
|
todayActivities: many("Activity", {
|
|
compute() {
|
|
return this.activities.filter((activity) => activity.state === "today");
|
|
},
|
|
}),
|
|
threadNeedactionPreviewViews: many("ThreadNeedactionPreviewView", { inverse: "thread" }),
|
|
/**
|
|
* Members that are currently typing something in the composer of this
|
|
* thread, including current partner.
|
|
*/
|
|
typingMembers: many("ChannelMember"),
|
|
/**
|
|
* Text that represents the status on this thread about typing members.
|
|
*/
|
|
typingStatusText: attr({
|
|
default: "",
|
|
compute() {
|
|
if (this.orderedOtherTypingMembers.length === 0) {
|
|
return clear();
|
|
}
|
|
if (this.orderedOtherTypingMembers.length === 1) {
|
|
return sprintf(
|
|
this.env._t("%s is typing..."),
|
|
this.getMemberName(this.orderedOtherTypingMembers[0].persona)
|
|
);
|
|
}
|
|
if (this.orderedOtherTypingMembers.length === 2) {
|
|
return sprintf(
|
|
this.env._t("%s and %s are typing..."),
|
|
this.getMemberName(this.orderedOtherTypingMembers[0].persona),
|
|
this.getMemberName(this.orderedOtherTypingMembers[1].persona)
|
|
);
|
|
}
|
|
return sprintf(
|
|
this.env._t("%s, %s and more are typing..."),
|
|
this.getMemberName(this.orderedOtherTypingMembers[0].persona),
|
|
this.getMemberName(this.orderedOtherTypingMembers[1].persona)
|
|
);
|
|
},
|
|
}),
|
|
/**
|
|
* URL to access to the conversation.
|
|
*/
|
|
url: attr({
|
|
default: "",
|
|
/**
|
|
* Compute an url string that can be used inside a href attribute
|
|
*/
|
|
compute() {
|
|
const baseHref = url("/web");
|
|
if (this.model === "mail.channel") {
|
|
return `${baseHref}#action=mail.action_discuss&active_id=${this.model}_${this.id}`;
|
|
}
|
|
return `${baseHref}#model=${this.model}&id=${this.id}`;
|
|
},
|
|
}),
|
|
uuid: attr(),
|
|
/**
|
|
* The amount of videos broadcast in the current Rtc call
|
|
*/
|
|
videoCount: attr({
|
|
default: 0,
|
|
compute() {
|
|
return this.rtcSessions.filter((session) => session.videoStream).length;
|
|
},
|
|
}),
|
|
},
|
|
onChanges: [
|
|
{
|
|
dependencies: ["lastSeenByCurrentPartnerMessageId"],
|
|
methodName: "_onChangeLastSeenByCurrentPartnerMessageId",
|
|
},
|
|
{
|
|
dependencies: ["isServerPinned"],
|
|
methodName: "_onIsServerPinnedChanged",
|
|
},
|
|
{
|
|
dependencies: ["serverFoldState"],
|
|
methodName: "_onServerFoldStateChanged",
|
|
},
|
|
],
|
|
});
|