2017-09-22 20:52:06 +03:00
|
|
|
/*
|
|
|
|
Copyright 2017 New Vector Ltd
|
|
|
|
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
you may not use this file except in compliance with the License.
|
|
|
|
You may obtain a copy of the License at
|
|
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
See the License for the specific language governing permissions and
|
|
|
|
limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
import EventEmitter from 'events';
|
2017-10-23 18:04:26 +03:00
|
|
|
import { groupMemberFromApiObject, groupRoomFromApiObject } from '../groups';
|
2017-10-23 17:28:38 +03:00
|
|
|
import FlairStore from './FlairStore';
|
2017-11-28 14:54:05 +03:00
|
|
|
import MatrixClientPeg from '../MatrixClientPeg';
|
2017-09-22 20:52:06 +03:00
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
function parseMembersResponse(response) {
|
|
|
|
return response.chunk.map((apiMember) => groupMemberFromApiObject(apiMember));
|
|
|
|
}
|
|
|
|
|
|
|
|
function parseRoomsResponse(response) {
|
|
|
|
return response.chunk.map((apiRoom) => groupRoomFromApiObject(apiRoom));
|
|
|
|
}
|
|
|
|
|
2018-03-13 14:35:15 +03:00
|
|
|
// The number of ongoing group requests
|
|
|
|
let ongoingRequestCount = 0;
|
|
|
|
|
|
|
|
// This has arbitrarily been set to a small number to lower the priority
|
|
|
|
// of doing group-related requests because we care about other important
|
|
|
|
// requests like hitting /sync.
|
|
|
|
const LIMIT = 3; // Maximum number of ongoing group requests
|
|
|
|
|
|
|
|
// FIFO queue of functions to call in the backlog
|
|
|
|
const backlogQueue = [
|
|
|
|
// () => {...}
|
|
|
|
];
|
|
|
|
|
|
|
|
// Pull from the FIFO queue
|
|
|
|
function checkBacklog() {
|
|
|
|
const item = backlogQueue.shift();
|
|
|
|
if (typeof item === 'function') item();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Limit the maximum number of ongoing promises returned by fn to LIMIT and
|
|
|
|
// use a FIFO queue to handle the backlog.
|
|
|
|
function limitConcurrency(fn) {
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
const item = () => {
|
|
|
|
ongoingRequestCount++;
|
|
|
|
resolve();
|
|
|
|
};
|
|
|
|
if (ongoingRequestCount >= LIMIT) {
|
|
|
|
// Enqueue this request for later execution
|
|
|
|
backlogQueue.push(item);
|
|
|
|
} else {
|
|
|
|
item();
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.then(fn)
|
|
|
|
.then((result) => {
|
|
|
|
ongoingRequestCount--;
|
|
|
|
checkBacklog();
|
|
|
|
return result;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-09-22 20:52:06 +03:00
|
|
|
/**
|
2017-10-04 18:56:35 +03:00
|
|
|
* Stores the group summary for a room and provides an API to change it and
|
2017-10-04 19:01:44 +03:00
|
|
|
* other useful group APIs that may have an effect on the group summary.
|
2017-09-22 20:52:06 +03:00
|
|
|
*/
|
2017-10-04 18:56:35 +03:00
|
|
|
export default class GroupStore extends EventEmitter {
|
2017-10-31 19:13:13 +03:00
|
|
|
|
|
|
|
static STATE_KEY = {
|
|
|
|
GroupMembers: 'GroupMembers',
|
|
|
|
GroupInvitedMembers: 'GroupInvitedMembers',
|
|
|
|
Summary: 'Summary',
|
|
|
|
GroupRooms: 'GroupRooms',
|
|
|
|
};
|
|
|
|
|
2017-11-28 14:54:05 +03:00
|
|
|
constructor(groupId) {
|
2017-09-22 20:52:06 +03:00
|
|
|
super();
|
2017-11-06 13:18:10 +03:00
|
|
|
if (!groupId) {
|
|
|
|
throw new Error('GroupStore needs a valid groupId to be created');
|
|
|
|
}
|
2017-10-04 19:51:38 +03:00
|
|
|
this.groupId = groupId;
|
2018-01-17 19:59:13 +03:00
|
|
|
this._state = {};
|
|
|
|
this._state[GroupStore.STATE_KEY.Summary] = {};
|
|
|
|
this._state[GroupStore.STATE_KEY.GroupRooms] = [];
|
|
|
|
this._state[GroupStore.STATE_KEY.GroupMembers] = [];
|
|
|
|
this._state[GroupStore.STATE_KEY.GroupInvitedMembers] = [];
|
2017-10-31 14:42:09 +03:00
|
|
|
this._ready = {};
|
2017-10-27 13:36:32 +03:00
|
|
|
|
2018-01-17 20:01:42 +03:00
|
|
|
this._fetchResourcePromise = {};
|
2018-01-17 19:59:13 +03:00
|
|
|
this._resourceFetcher = {
|
|
|
|
[GroupStore.STATE_KEY.Summary]: () => {
|
2018-03-13 14:35:15 +03:00
|
|
|
return limitConcurrency(
|
|
|
|
() => MatrixClientPeg.get().getGroupSummary(this.groupId),
|
|
|
|
);
|
2018-01-17 19:59:13 +03:00
|
|
|
},
|
|
|
|
[GroupStore.STATE_KEY.GroupRooms]: () => {
|
2018-03-13 14:35:15 +03:00
|
|
|
return limitConcurrency(
|
|
|
|
() => MatrixClientPeg.get().getGroupRooms(this.groupId).then(parseRoomsResponse),
|
|
|
|
);
|
2018-01-17 19:59:13 +03:00
|
|
|
},
|
|
|
|
[GroupStore.STATE_KEY.GroupMembers]: () => {
|
2018-03-13 14:35:15 +03:00
|
|
|
return limitConcurrency(
|
|
|
|
() => MatrixClientPeg.get().getGroupUsers(this.groupId).then(parseMembersResponse),
|
|
|
|
);
|
2018-01-17 19:59:13 +03:00
|
|
|
},
|
|
|
|
[GroupStore.STATE_KEY.GroupInvitedMembers]: () => {
|
2018-03-13 14:35:15 +03:00
|
|
|
return limitConcurrency(
|
|
|
|
() => MatrixClientPeg.get().getGroupInvitedUsers(this.groupId).then(parseMembersResponse),
|
|
|
|
);
|
2018-01-17 19:59:13 +03:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2017-10-27 13:36:32 +03:00
|
|
|
this.on('error', (err) => {
|
|
|
|
console.error(`GroupStore for ${this.groupId} encountered error`, err);
|
|
|
|
});
|
2017-10-23 18:04:26 +03:00
|
|
|
}
|
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
_fetchResource(stateKey) {
|
2018-01-17 20:01:42 +03:00
|
|
|
// Ongoing request, ignore
|
|
|
|
if (this._fetchResourcePromise[stateKey]) return;
|
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
const clientPromise = this._resourceFetcher[stateKey]();
|
2018-01-17 20:01:42 +03:00
|
|
|
|
|
|
|
// Indicate ongoing request
|
|
|
|
this._fetchResourcePromise[stateKey] = clientPromise;
|
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
clientPromise.then((result) => {
|
|
|
|
this._state[stateKey] = result;
|
|
|
|
this._ready[stateKey] = true;
|
2017-10-23 18:04:26 +03:00
|
|
|
this._notifyListeners();
|
|
|
|
}).catch((err) => {
|
2017-10-27 13:37:45 +03:00
|
|
|
// Invited users not visible to non-members
|
2018-01-17 19:59:13 +03:00
|
|
|
if (stateKey === GroupStore.STATE_KEY.GroupInvitedMembers && err.httpStatus === 403) {
|
2017-10-27 13:37:45 +03:00
|
|
|
return;
|
|
|
|
}
|
2017-09-22 20:52:06 +03:00
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
console.error("Failed to get resource " + stateKey + ":" + err);
|
2017-09-22 20:52:06 +03:00
|
|
|
this.emit('error', err);
|
2018-01-17 20:01:42 +03:00
|
|
|
}).finally(() => {
|
|
|
|
// Indicate finished request, allow for future fetches
|
|
|
|
delete this._fetchResourcePromise[stateKey];
|
2017-09-22 20:52:06 +03:00
|
|
|
});
|
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
return clientPromise;
|
2017-10-05 16:30:04 +03:00
|
|
|
}
|
|
|
|
|
2017-09-22 20:52:06 +03:00
|
|
|
_notifyListeners() {
|
|
|
|
this.emit('update');
|
|
|
|
}
|
|
|
|
|
2018-01-02 21:12:08 +03:00
|
|
|
/**
|
|
|
|
* Register a listener to recieve updates from the store. This also
|
|
|
|
* immediately triggers an update to send the current state of the
|
|
|
|
* store (which could be the initial state).
|
|
|
|
*
|
2018-01-17 19:59:13 +03:00
|
|
|
* This also causes a fetch of all group data, which might cause
|
|
|
|
* 4 separate HTTP requests, but only said requests aren't already
|
|
|
|
* ongoing.
|
2018-01-02 21:12:08 +03:00
|
|
|
*
|
|
|
|
* @param {function} fn the function to call when the store updates.
|
|
|
|
* @return {Object} tok a registration "token" with a single
|
|
|
|
* property `unregister`, a function that can
|
|
|
|
* be called to unregister the listener such
|
|
|
|
* that it won't be called any more.
|
|
|
|
*/
|
2017-10-27 13:36:32 +03:00
|
|
|
registerListener(fn) {
|
|
|
|
this.on('update', fn);
|
2017-10-31 14:42:09 +03:00
|
|
|
// Call to set initial state (before fetching starts)
|
|
|
|
this.emit('update');
|
2018-01-17 19:59:13 +03:00
|
|
|
|
|
|
|
this._fetchResource(GroupStore.STATE_KEY.Summary);
|
|
|
|
this._fetchResource(GroupStore.STATE_KEY.GroupRooms);
|
|
|
|
this._fetchResource(GroupStore.STATE_KEY.GroupMembers);
|
|
|
|
this._fetchResource(GroupStore.STATE_KEY.GroupInvitedMembers);
|
2017-12-15 17:12:21 +03:00
|
|
|
|
2018-01-02 21:12:08 +03:00
|
|
|
// Similar to the Store of flux/utils, we return a "token" that
|
|
|
|
// can be used to unregister the listener.
|
2017-12-15 17:12:21 +03:00
|
|
|
return {
|
|
|
|
unregister: () => {
|
|
|
|
this.unregisterListener(fn);
|
|
|
|
},
|
|
|
|
};
|
2017-10-27 13:36:32 +03:00
|
|
|
}
|
|
|
|
|
2017-10-27 16:33:10 +03:00
|
|
|
unregisterListener(fn) {
|
|
|
|
this.removeListener('update', fn);
|
|
|
|
}
|
|
|
|
|
2017-10-31 14:42:09 +03:00
|
|
|
isStateReady(id) {
|
|
|
|
return this._ready[id];
|
|
|
|
}
|
|
|
|
|
2017-09-22 20:52:06 +03:00
|
|
|
getSummary() {
|
2018-01-17 19:59:13 +03:00
|
|
|
return this._state[GroupStore.STATE_KEY.Summary];
|
2017-09-22 20:52:06 +03:00
|
|
|
}
|
|
|
|
|
2017-10-05 16:30:04 +03:00
|
|
|
getGroupRooms() {
|
2018-01-17 19:59:13 +03:00
|
|
|
return this._state[GroupStore.STATE_KEY.GroupRooms];
|
2017-10-05 16:30:04 +03:00
|
|
|
}
|
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
getGroupMembers() {
|
|
|
|
return this._state[GroupStore.STATE_KEY.GroupMembers];
|
2017-10-23 18:04:26 +03:00
|
|
|
}
|
|
|
|
|
2018-01-17 19:59:13 +03:00
|
|
|
getGroupInvitedMembers() {
|
|
|
|
return this._state[GroupStore.STATE_KEY.GroupInvitedMembers];
|
2017-10-23 18:04:26 +03:00
|
|
|
}
|
|
|
|
|
2017-10-17 18:08:19 +03:00
|
|
|
getGroupPublicity() {
|
2018-01-17 19:59:13 +03:00
|
|
|
return this._state[GroupStore.STATE_KEY.Summary].user ?
|
|
|
|
this._state[GroupStore.STATE_KEY.Summary].user.is_publicised : null;
|
2017-10-17 18:08:19 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
isUserPrivileged() {
|
2018-01-17 19:59:13 +03:00
|
|
|
return this._state[GroupStore.STATE_KEY.Summary].user ?
|
|
|
|
this._state[GroupStore.STATE_KEY.Summary].user.is_privileged : null;
|
2017-10-17 18:08:19 +03:00
|
|
|
}
|
|
|
|
|
2017-11-02 16:25:55 +03:00
|
|
|
addRoomToGroup(roomId, isPublic) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-11-02 16:25:55 +03:00
|
|
|
.addRoomToGroup(this.groupId, roomId, isPublic)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupRooms));
|
2017-11-02 16:25:55 +03:00
|
|
|
}
|
|
|
|
|
2017-11-09 19:28:21 +03:00
|
|
|
updateGroupRoomVisibility(roomId, isPublic) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-11-09 19:28:21 +03:00
|
|
|
.updateGroupRoomVisibility(this.groupId, roomId, isPublic)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupRooms));
|
2017-10-05 16:30:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
removeRoomFromGroup(roomId) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-10-05 16:30:04 +03:00
|
|
|
.removeRoomFromGroup(this.groupId, roomId)
|
|
|
|
// Room might be in the summary, refresh just in case
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary))
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupRooms));
|
2017-10-04 18:56:35 +03:00
|
|
|
}
|
|
|
|
|
2017-10-23 18:04:26 +03:00
|
|
|
inviteUserToGroup(userId) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get().inviteUserToGroup(this.groupId, userId)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupInvitedMembers));
|
2017-10-23 18:04:26 +03:00
|
|
|
}
|
|
|
|
|
2017-11-07 21:51:41 +03:00
|
|
|
acceptGroupInvite() {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get().acceptGroupInvite(this.groupId)
|
2018-04-10 12:03:54 +03:00
|
|
|
// The user should now be able to access (personal) group settings
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary))
|
|
|
|
// The user might be able to see more rooms now
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupRooms))
|
|
|
|
// The user should now appear as a member
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupMembers))
|
|
|
|
// The user should now not appear as an invited member
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupInvitedMembers));
|
|
|
|
}
|
|
|
|
|
|
|
|
joinGroup() {
|
|
|
|
return MatrixClientPeg.get().joinGroup(this.groupId)
|
|
|
|
// The user should now be able to access (personal) group settings
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary))
|
2017-11-07 21:51:41 +03:00
|
|
|
// The user might be able to see more rooms now
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupRooms))
|
2017-11-08 14:52:52 +03:00
|
|
|
// The user should now appear as a member
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupMembers))
|
|
|
|
// The user should now not appear as an invited member
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupInvitedMembers));
|
2017-11-07 21:51:41 +03:00
|
|
|
}
|
|
|
|
|
2018-04-10 12:03:54 +03:00
|
|
|
leaveGroup() {
|
|
|
|
return MatrixClientPeg.get().leaveGroup(this.groupId)
|
|
|
|
// The user should now not be able to access group settings
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary))
|
|
|
|
// The user might only be able to see a subset of rooms now
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupRooms))
|
|
|
|
// The user should now not appear as a member
|
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.GroupMembers));
|
|
|
|
}
|
|
|
|
|
2017-09-22 20:52:06 +03:00
|
|
|
addRoomToGroupSummary(roomId, categoryId) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-10-04 19:51:38 +03:00
|
|
|
.addRoomToGroupSummary(this.groupId, roomId, categoryId)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary));
|
2017-09-22 20:52:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
addUserToGroupSummary(userId, roleId) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-10-04 19:51:38 +03:00
|
|
|
.addUserToGroupSummary(this.groupId, userId, roleId)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary));
|
2017-09-22 20:52:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
removeRoomFromGroupSummary(roomId) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-10-04 19:51:38 +03:00
|
|
|
.removeRoomFromGroupSummary(this.groupId, roomId)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary));
|
2017-09-22 20:52:06 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
removeUserFromGroupSummary(userId) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-10-04 19:51:38 +03:00
|
|
|
.removeUserFromGroupSummary(this.groupId, userId)
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary));
|
2017-09-22 20:52:06 +03:00
|
|
|
}
|
2017-09-26 16:46:57 +03:00
|
|
|
|
2017-09-26 16:58:49 +03:00
|
|
|
setGroupPublicity(isPublished) {
|
2017-11-28 14:54:05 +03:00
|
|
|
return MatrixClientPeg.get()
|
2017-10-04 19:51:38 +03:00
|
|
|
.setGroupPublicity(this.groupId, isPublished)
|
2017-11-28 14:54:05 +03:00
|
|
|
.then(() => { FlairStore.invalidatePublicisedGroups(MatrixClientPeg.get().credentials.userId); })
|
2018-01-17 19:59:13 +03:00
|
|
|
.then(this._fetchResource.bind(this, GroupStore.STATE_KEY.Summary));
|
2017-09-26 16:46:57 +03:00
|
|
|
}
|
2017-09-22 20:52:06 +03:00
|
|
|
}
|