mirror of
https://github.com/wekan/wekan.git
synced 2026-02-20 23:14:07 +01:00
2f6e34c5f5
- Convert all ReactiveCacheServer methods to async - findOne() → findOneAsync() - find().fetch() → find().fetchAsync() - Meteor.user() → Meteor.userAsync() - Convert ReactiveCache facade methods to async - Server path uses await for async operations - Client path returns sync Minimongo result (wrapped in Promise) This prepares the codebase for Meteor 3.0 where MongoDB operations are async.
1661 lines
56 KiB
JavaScript
1661 lines
56 KiB
JavaScript
import { DataCache } from '@wekanteam/meteor-reactive-cache';
|
|
import Settings from '../models/settings';
|
|
|
|
// Server isn't reactive, so search for the data always.
|
|
// All methods are async for Meteor 3.0 compatibility.
|
|
ReactiveCacheServer = {
|
|
async getBoard(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Boards.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getBoards(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Boards.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getList(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Lists.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getLists(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Lists.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getSwimlane(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Swimlanes.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getSwimlanes(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Swimlanes.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getChecklist(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Checklists.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getChecklists(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Checklists.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getChecklistItem(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await ChecklistItems.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getChecklistItems(selector = {}, options = {}, getQuery = false) {
|
|
let ret = ChecklistItems.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getCard(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Cards.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getCards(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Cards.find(selector, options, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getCardComment(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await CardComments.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getCardComments(selector = {}, options = {}, getQuery = false) {
|
|
let ret = CardComments.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getCardCommentReaction(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await CardCommentReactions.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getCardCommentReactions(selector = {}, options = {}, getQuery = false) {
|
|
let ret = CardCommentReactions.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getCustomField(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await CustomFields.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getCustomFields(selector = {}, options = {}, getQuery = false) {
|
|
let ret = CustomFields.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getAttachment(idOrFirstObjectSelector = {}, options = {}) {
|
|
// Try new structure first
|
|
let ret = await Attachments.findOneAsync(idOrFirstObjectSelector, options);
|
|
if (!ret && typeof idOrFirstObjectSelector === 'string') {
|
|
// Fall back to old structure for single attachment lookup
|
|
ret = await Attachments.getAttachmentWithBackwardCompatibility(
|
|
idOrFirstObjectSelector,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
async getAttachments(selector = {}, options = {}, getQuery = false) {
|
|
// Try new structure first
|
|
let ret = Attachments.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
// If no results and we have a cardId selector, try old structure
|
|
if (ret.length === 0 && selector['meta.cardId']) {
|
|
ret = await Attachments.getAttachmentsWithBackwardCompatibility(selector);
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
async getAvatar(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Avatars.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getAvatars(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Avatars.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getUser(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Users.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getUsers(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Users.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getOrg(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Org.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getOrgs(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Org.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getTeam(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Team.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getTeams(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Team.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getActivity(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Activities.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getActivities(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Activities.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getRule(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Rules.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getRules(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Rules.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getAction(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Actions.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getActions(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Actions.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getTrigger(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Triggers.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getTriggers(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Triggers.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getImpersonatedUser(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await ImpersonatedUsers.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getImpersonatedUsers(selector = {}, options = {}, getQuery = false) {
|
|
let ret = ImpersonatedUsers.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getIntegration(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Integrations.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getIntegrations(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Integrations.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getSessionData(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await SessionData.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getSessionDatas(selector = {}, options = {}, getQuery = false) {
|
|
let ret = SessionData.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getInvitationCode(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await InvitationCodes.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getInvitationCodes(selector = {}, options = {}, getQuery = false) {
|
|
let ret = InvitationCodes.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
async getCurrentSetting() {
|
|
const ret = await Settings.findOneAsync();
|
|
return ret;
|
|
},
|
|
async getCurrentUser() {
|
|
const ret = await Meteor.userAsync();
|
|
return ret;
|
|
},
|
|
async getTranslation(idOrFirstObjectSelector = {}, options = {}) {
|
|
const ret = await Translation.findOneAsync(idOrFirstObjectSelector, options);
|
|
return ret;
|
|
},
|
|
async getTranslations(selector = {}, options = {}, getQuery = false) {
|
|
let ret = Translation.find(selector, options);
|
|
if (getQuery !== true) {
|
|
ret = await ret.fetchAsync();
|
|
}
|
|
return ret;
|
|
},
|
|
};
|
|
|
|
// only the Client is reactive
|
|
// saving the result has a big advantage if the query is big and often searched for the same data again and again
|
|
// if the data is changed in the client, the data is saved to the server and depending code is reactive called again
|
|
ReactiveCacheClient = {
|
|
getBoard(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__board) {
|
|
this.__board = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Boards.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__board.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getBoards(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__boards) {
|
|
this.__boards = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Boards.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__boards.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getList(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__list) {
|
|
this.__list = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Lists.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__list.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getLists(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__lists) {
|
|
this.__lists = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Lists.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__lists.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getSwimlane(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__swimlane) {
|
|
this.__swimlane = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Swimlanes.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__swimlane.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getSwimlanes(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__swimlanes) {
|
|
this.__swimlanes = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Swimlanes.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__swimlanes.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getChecklist(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__checklist) {
|
|
this.__checklist = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Checklists.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__checklist.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getChecklists(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__checklists) {
|
|
this.__checklists = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Checklists.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__checklists.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getChecklistItem(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__checklistItem) {
|
|
this.__checklistItem = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = ChecklistItems.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__checklistItem.get(
|
|
EJSON.stringify(idOrFirstObjectSelect),
|
|
);
|
|
return ret;
|
|
},
|
|
getChecklistItems(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__checklistItems) {
|
|
this.__checklistItems = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = ChecklistItems.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__checklistItems.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getCard(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__card) {
|
|
this.__card = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Cards.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__card.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getCards(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__cards) {
|
|
this.__cards = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Cards.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__cards.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getCardComment(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__cardComment) {
|
|
this.__cardComment = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = CardComments.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__cardComment.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getCardComments(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__cardComments) {
|
|
this.__cardComments = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = CardComments.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__cardComments.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getCardCommentReaction(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__cardCommentReaction) {
|
|
this.__cardCommentReaction = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = CardCommentReactions.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__cardCommentReaction.get(
|
|
EJSON.stringify(idOrFirstObjectSelect),
|
|
);
|
|
return ret;
|
|
},
|
|
getCardCommentReactions(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__cardCommentReactions) {
|
|
this.__cardCommentReactions = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = CardCommentReactions.find(
|
|
__select.selector,
|
|
__select.options,
|
|
);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__cardCommentReactions.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getCustomField(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__customField) {
|
|
this.__customField = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = CustomFields.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__customField.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getCustomFields(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__customFields) {
|
|
this.__customFields = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = CustomFields.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__customFields.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getAttachment(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__attachment) {
|
|
this.__attachment = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
// Try new structure first
|
|
let _ret = Attachments.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
if (!_ret && typeof __select.idOrFirstObjectSelector === 'string') {
|
|
// Fall back to old structure for single attachment lookup
|
|
_ret = Attachments.getAttachmentWithBackwardCompatibility(
|
|
__select.idOrFirstObjectSelector,
|
|
);
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__attachment.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getAttachments(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__attachments) {
|
|
this.__attachments = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
// Try new structure first
|
|
let _ret = Attachments.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
// If no results and we have a cardId selector, try old structure
|
|
if (_ret.length === 0 && __select.selector['meta.cardId']) {
|
|
_ret = Attachments.getAttachmentsWithBackwardCompatibility(
|
|
__select.selector,
|
|
);
|
|
}
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__attachments.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getAvatar(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__avatar) {
|
|
this.__avatar = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Avatars.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__avatar.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getAvatars(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__avatars) {
|
|
this.__avatars = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Avatars.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__avatars.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getUser(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__user) {
|
|
this.__user = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Users.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__user.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getUsers(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__users) {
|
|
this.__users = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Users.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__users.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getOrg(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__org) {
|
|
this.__org = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Org.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__org.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getOrgs(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__orgs) {
|
|
this.__orgs = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Org.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__orgs.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getTeam(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__team) {
|
|
this.__team = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Team.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__team.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getTeams(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__teams) {
|
|
this.__teams = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Team.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__teams.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getActivity(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__activity) {
|
|
this.__activity = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Activities.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__activity.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getActivities(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__activities) {
|
|
this.__activities = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Activities.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__activities.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getRule(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__rule) {
|
|
this.__rule = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Rules.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__rule.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getRules(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__rules) {
|
|
this.__rules = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Rules.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__rules.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getAction(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__action) {
|
|
this.__action = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Actions.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__action.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getActions(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__actions) {
|
|
this.__actions = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Actions.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__actions.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getTrigger(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__trigger) {
|
|
this.__trigger = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Triggers.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__trigger.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getTriggers(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__triggers) {
|
|
this.__triggers = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Triggers.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__triggers.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getImpersonatedUser(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__impersonatedUser) {
|
|
this.__impersonatedUser = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = ImpersonatedUsers.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__impersonatedUser.get(
|
|
EJSON.stringify(idOrFirstObjectSelect),
|
|
);
|
|
return ret;
|
|
},
|
|
getImpersonatedUsers(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__impersonatedUsers) {
|
|
this.__impersonatedUsers = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = ImpersonatedUsers.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__impersonatedUsers.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getIntegration(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__integration) {
|
|
this.__integration = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Integrations.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__integration.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getIntegrations(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__integrations) {
|
|
this.__integrations = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Integrations.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__integrations.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getInvitationCode(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__invitationCode) {
|
|
this.__invitationCode = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = InvitationCodes.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__invitationCode.get(
|
|
EJSON.stringify(idOrFirstObjectSelect),
|
|
);
|
|
return ret;
|
|
},
|
|
getInvitationCodes(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__invitationCodes) {
|
|
this.__invitationCodes = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = InvitationCodes.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__invitationCodes.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
getCurrentSetting() {
|
|
if (!this.__currentSetting || !this.__currentSetting.get()) {
|
|
this.__currentSetting = new DataCache(() => {
|
|
const _ret = Settings.findOne();
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__currentSetting.get();
|
|
return ret;
|
|
},
|
|
getCurrentUser() {
|
|
if (!this.__currentUser || !this.__currentUser.get()) {
|
|
this.__currentUser = new DataCache(() => {
|
|
const _ret = Meteor.user();
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__currentUser.get();
|
|
return ret;
|
|
},
|
|
getTranslation(idOrFirstObjectSelector = {}, options = {}) {
|
|
const idOrFirstObjectSelect = { idOrFirstObjectSelector, options };
|
|
if (!this.__translation) {
|
|
this.__translation = new DataCache((_idOrFirstObjectSelect) => {
|
|
const __select = EJSON.parse(_idOrFirstObjectSelect);
|
|
const _ret = Translation.findOne(
|
|
__select.idOrFirstObjectSelector,
|
|
__select.options,
|
|
);
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__translation.get(EJSON.stringify(idOrFirstObjectSelect));
|
|
return ret;
|
|
},
|
|
getTranslations(selector = {}, options = {}, getQuery = false) {
|
|
const select = { selector, options, getQuery };
|
|
if (!this.__translations) {
|
|
this.__translations = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
let _ret = Translation.find(__select.selector, __select.options);
|
|
if (__select.getQuery !== true) {
|
|
_ret = _ret.fetch();
|
|
}
|
|
return _ret;
|
|
});
|
|
}
|
|
const ret = this.__translations.get(EJSON.stringify(select));
|
|
return ret;
|
|
},
|
|
};
|
|
|
|
// global Reactive Cache class to avoid big overhead while searching for the same data often again
|
|
// This class calls 2 implementation, for server and client code
|
|
//
|
|
// having this class here has several advantages:
|
|
// - The Programmer hasn't to care about in which context he call's this class
|
|
// - having all queries together in 1 class to make it possible to see which queries in Wekan happens, e.g. with console.log
|
|
//
|
|
// All methods are async for Meteor 3.0 compatibility.
|
|
// Server path uses async MongoDB operations; Client path uses sync Minimongo (wrapped in Promise).
|
|
ReactiveCache = {
|
|
async getBoard(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getBoard(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getBoard(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getBoards(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getBoards(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getBoards(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getList(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getList(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getList(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getLists(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getLists(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getLists(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getSwimlane(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getSwimlane(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getSwimlane(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getSwimlanes(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getSwimlanes(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getSwimlanes(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getChecklist(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getChecklist(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getChecklist(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getChecklists(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getChecklists(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getChecklists(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getChecklistItem(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getChecklistItem(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getChecklistItem(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getChecklistItems(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getChecklistItems(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getChecklistItems(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getCard(idOrFirstObjectSelector = {}, options = {}, noCache = false) {
|
|
if (Meteor.isServer || noCache === true) {
|
|
return await ReactiveCacheServer.getCard(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getCard(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getCards(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCards(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getCards(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getCardComment(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCardComment(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getCardComment(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getCardComments(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCardComments(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getCardComments(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getCardCommentReaction(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCardCommentReaction(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getCardCommentReaction(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getCardCommentReactions(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCardCommentReactions(
|
|
selector,
|
|
options,
|
|
getQuery,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getCardCommentReactions(
|
|
selector,
|
|
options,
|
|
getQuery,
|
|
);
|
|
}
|
|
},
|
|
async getCustomField(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCustomField(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getCustomField(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getCustomFields(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCustomFields(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getCustomFields(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getAttachment(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getAttachment(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getAttachment(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getAttachments(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getAttachments(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getAttachments(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getAvatar(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getAvatar(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getAvatar(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getAvatars(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getAvatars(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getAvatars(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getUser(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getUser(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getUser(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getUsers(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getUsers(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getUsers(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getOrg(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getOrg(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getOrg(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getOrgs(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getOrgs(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getOrgs(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getTeam(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getTeam(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getTeam(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getTeams(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getTeams(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getTeams(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getActivity(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getActivity(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getActivity(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getActivities(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getActivities(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getActivities(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getRule(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getRule(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getRule(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getRules(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getRules(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getRules(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getAction(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getAction(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getAction(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getActions(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getActions(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getActions(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getTrigger(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getTrigger(idOrFirstObjectSelector, options);
|
|
} else {
|
|
return ReactiveCacheClient.getTrigger(idOrFirstObjectSelector, options);
|
|
}
|
|
},
|
|
async getTriggers(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getTriggers(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getTriggers(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getImpersonatedUser(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getImpersonatedUser(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getImpersonatedUser(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getImpersonatedUsers(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getImpersonatedUsers(
|
|
selector,
|
|
options,
|
|
getQuery,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getImpersonatedUsers(
|
|
selector,
|
|
options,
|
|
getQuery,
|
|
);
|
|
}
|
|
},
|
|
async getIntegration(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getIntegration(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getIntegration(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getIntegrations(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getIntegrations(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getIntegrations(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getSessionData(idOrFirstObjectSelector = {}, options = {}) {
|
|
// no reactive cache, otherwise global search will not work anymore
|
|
return await ReactiveCacheServer.getSessionData(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
},
|
|
async getSessionDatas(selector = {}, options = {}, getQuery = false) {
|
|
// no reactive cache, otherwise global search will not work anymore
|
|
return await ReactiveCacheServer.getSessionDatas(selector, options, getQuery);
|
|
},
|
|
async getInvitationCode(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getInvitationCode(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getInvitationCode(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getInvitationCodes(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getInvitationCodes(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getInvitationCodes(selector, options, getQuery);
|
|
}
|
|
},
|
|
async getCurrentSetting() {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCurrentSetting();
|
|
} else {
|
|
return ReactiveCacheClient.getCurrentSetting();
|
|
}
|
|
},
|
|
async getCurrentUser() {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getCurrentUser();
|
|
} else {
|
|
return ReactiveCacheClient.getCurrentUser();
|
|
}
|
|
},
|
|
async getTranslation(idOrFirstObjectSelector = {}, options = {}) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getTranslation(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
} else {
|
|
return ReactiveCacheClient.getTranslation(
|
|
idOrFirstObjectSelector,
|
|
options,
|
|
);
|
|
}
|
|
},
|
|
async getTranslations(selector = {}, options = {}, getQuery = false) {
|
|
if (Meteor.isServer) {
|
|
return await ReactiveCacheServer.getTranslations(selector, options, getQuery);
|
|
} else {
|
|
return ReactiveCacheClient.getTranslations(selector, options, getQuery);
|
|
}
|
|
},
|
|
};
|
|
|
|
// Server isn't reactive, so search for the data always.
|
|
ReactiveMiniMongoIndexServer = {
|
|
getSubTasksWithParentId(parentId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (parentId) {
|
|
ret = ReactiveCache.getCards({ parentId, ...addSelect }, options);
|
|
}
|
|
return ret;
|
|
},
|
|
getChecklistsWithCardId(cardId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (cardId) {
|
|
ret = ReactiveCache.getChecklists({ cardId, ...addSelect }, options);
|
|
}
|
|
return ret;
|
|
},
|
|
getChecklistItemsWithChecklistId(checklistId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (checklistId) {
|
|
ret = ReactiveCache.getChecklistItems(
|
|
{ checklistId, ...addSelect },
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
getCardCommentsWithCardId(cardId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (cardId) {
|
|
ret = ReactiveCache.getCardComments({ cardId, ...addSelect }, options);
|
|
}
|
|
return ret;
|
|
},
|
|
getActivityWithId(activityId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (activityId) {
|
|
ret = ReactiveCache.getActivities(
|
|
{ _id: activityId, ...addSelect },
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
};
|
|
|
|
// Client side little MiniMongo DB "Index"
|
|
ReactiveMiniMongoIndexClient = {
|
|
getSubTasksWithParentId(parentId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (parentId) {
|
|
const select = { addSelect, options };
|
|
if (!this.__subTasksWithId) {
|
|
this.__subTasksWithId = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
const _subTasks = ReactiveCache.getCards(
|
|
{ parentId: { $exists: true }, ...__select.addSelect },
|
|
__select.options,
|
|
);
|
|
const _ret = _.groupBy(_subTasks, 'parentId');
|
|
return _ret;
|
|
});
|
|
}
|
|
ret = this.__subTasksWithId.get(EJSON.stringify(select));
|
|
if (ret) {
|
|
ret = ret[parentId] || [];
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
getChecklistsWithCardId(cardId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (cardId) {
|
|
const select = { addSelect, options };
|
|
if (!this.__checklistsWithId) {
|
|
this.__checklistsWithId = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
const _checklists = ReactiveCache.getChecklists(
|
|
{ cardId: { $exists: true }, ...__select.addSelect },
|
|
__select.options,
|
|
);
|
|
const _ret = _.groupBy(_checklists, 'cardId');
|
|
return _ret;
|
|
});
|
|
}
|
|
ret = this.__checklistsWithId.get(EJSON.stringify(select));
|
|
if (ret) {
|
|
ret = ret[cardId] || [];
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
getChecklistItemsWithChecklistId(checklistId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (checklistId) {
|
|
const select = { addSelect, options };
|
|
if (!this.__checklistItemsWithId) {
|
|
this.__checklistItemsWithId = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
const _checklistItems = ReactiveCache.getChecklistItems(
|
|
{ checklistId: { $exists: true }, ...__select.addSelect },
|
|
__select.options,
|
|
);
|
|
const _ret = _.groupBy(_checklistItems, 'checklistId');
|
|
return _ret;
|
|
});
|
|
}
|
|
ret = this.__checklistItemsWithId.get(EJSON.stringify(select));
|
|
if (ret) {
|
|
if (Meteor.isServer) {
|
|
ret[checklistId] = ReactiveCache.getChecklistItems(
|
|
{ checklistId: checklistId, ...addSelect },
|
|
options,
|
|
);
|
|
}
|
|
ret = ret[checklistId] || [];
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
getCardCommentsWithCardId(cardId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (cardId) {
|
|
const select = { addSelect, options };
|
|
if (!this.__cardCommentsWithId) {
|
|
this.__cardCommentsWithId = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
const _cardComments = ReactiveCache.getCardComments(
|
|
{ cardId: { $exists: true }, ...__select.addSelect },
|
|
__select.options,
|
|
);
|
|
const _ret = _.groupBy(_cardComments, 'cardId');
|
|
return _ret;
|
|
});
|
|
}
|
|
ret = this.__cardCommentsWithId.get(EJSON.stringify(select));
|
|
if (ret) {
|
|
ret = ret[cardId] || [];
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
getActivityWithId(activityId, addSelect = {}, options = {}) {
|
|
let ret = [];
|
|
if (activityId) {
|
|
const select = { addSelect, options };
|
|
if (!this.__activityWithId) {
|
|
this.__activityWithId = new DataCache((_select) => {
|
|
const __select = EJSON.parse(_select);
|
|
const _activities = ReactiveCache.getActivities(
|
|
{ _id: { $exists: true }, ...__select.addSelect },
|
|
__select.options,
|
|
);
|
|
const _ret = _.indexBy(_activities, '_id');
|
|
return _ret;
|
|
});
|
|
}
|
|
ret = this.__activityWithId.get(EJSON.stringify(select));
|
|
if (ret) {
|
|
ret = ret[activityId];
|
|
}
|
|
}
|
|
return ret;
|
|
},
|
|
};
|
|
|
|
// global Reactive MiniMongo Index Cache class to avoid big overhead while searching for the same data often again
|
|
// This class calls 2 implementation, for server and client code
|
|
//
|
|
// having this class here has several advantages:
|
|
// - The Programmer hasn't to care about in which context he call's this class
|
|
// - having all queries together in 1 class to make it possible to see which queries in Wekan happens, e.g. with console.log
|
|
ReactiveMiniMongoIndex = {
|
|
getSubTasksWithParentId(parentId, addSelect = {}, options = {}) {
|
|
let ret;
|
|
if (Meteor.isServer) {
|
|
ret = ReactiveMiniMongoIndexServer.getSubTasksWithParentId(
|
|
parentId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
} else {
|
|
ret = ReactiveMiniMongoIndexClient.getSubTasksWithParentId(
|
|
parentId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
getChecklistsWithCardId(cardId, addSelect = {}, options = {}) {
|
|
let ret;
|
|
if (Meteor.isServer) {
|
|
ret = ReactiveMiniMongoIndexServer.getChecklistsWithCardId(
|
|
cardId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
} else {
|
|
ret = ReactiveMiniMongoIndexClient.getChecklistsWithCardId(
|
|
cardId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
getChecklistItemsWithChecklistId(checklistId, addSelect = {}, options = {}) {
|
|
let ret;
|
|
if (Meteor.isServer) {
|
|
ret = ReactiveMiniMongoIndexServer.getChecklistItemsWithChecklistId(
|
|
checklistId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
} else {
|
|
ret = ReactiveMiniMongoIndexClient.getChecklistItemsWithChecklistId(
|
|
checklistId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
getCardCommentsWithCardId(cardId, addSelect = {}, options = {}) {
|
|
let ret;
|
|
if (Meteor.isServer) {
|
|
ret = ReactiveMiniMongoIndexServer.getCardCommentsWithCardId(
|
|
cardId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
} else {
|
|
ret = ReactiveMiniMongoIndexClient.getCardCommentsWithCardId(
|
|
cardId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
getActivityWithId(activityId, addSelect = {}, options = {}) {
|
|
let ret;
|
|
if (Meteor.isServer) {
|
|
ret = ReactiveMiniMongoIndexServer.getActivityWithId(
|
|
activityId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
} else {
|
|
ret = ReactiveMiniMongoIndexClient.getActivityWithId(
|
|
activityId,
|
|
addSelect,
|
|
options,
|
|
);
|
|
}
|
|
return ret;
|
|
},
|
|
};
|
|
|
|
export { ReactiveCache, ReactiveMiniMongoIndex };
|