303 lines
12 KiB
JavaScript
303 lines
12 KiB
JavaScript
import ModalFunctionality from 'discourse/mixins/modal-functionality';
|
|
import { emailValid } from 'discourse/lib/utilities';
|
|
import computed from 'ember-addons/ember-computed-decorators';
|
|
import Group from 'discourse/models/group';
|
|
import Invite from 'discourse/models/invite';
|
|
|
|
export default Ember.Controller.extend(ModalFunctionality, {
|
|
userInvitedShow: Ember.inject.controller('user-invited-show'),
|
|
|
|
// If this isn't defined, it will proxy to the user model on the preferences
|
|
// page which is wrong.
|
|
emailOrUsername: null,
|
|
hasCustomMessage: false,
|
|
customMessage: null,
|
|
inviteIcon: "envelope",
|
|
invitingExistingUserToTopic: false,
|
|
|
|
@computed('isMessage', 'invitingToTopic')
|
|
title(isMessage, invitingToTopic) {
|
|
if (isMessage) {
|
|
return 'topic.invite_private.title';
|
|
} else if (invitingToTopic) {
|
|
return 'topic.invite_reply.title';
|
|
} else {
|
|
return 'user.invited.create';
|
|
}
|
|
},
|
|
|
|
@computed
|
|
isAdmin() {
|
|
return this.currentUser.admin;
|
|
},
|
|
|
|
@computed('isAdmin', 'emailOrUsername', 'invitingToTopic', 'isPrivateTopic', 'model.groupNames', 'model.saving', 'model.details.can_invite_to')
|
|
disabled(isAdmin, emailOrUsername, invitingToTopic, isPrivateTopic, groupNames, saving, can_invite_to) {
|
|
if (saving) return true;
|
|
if (Ember.isEmpty(emailOrUsername)) return true;
|
|
const emailTrimmed = emailOrUsername.trim();
|
|
|
|
// when inviting to forum, email must be valid
|
|
if (!invitingToTopic && !emailValid(emailTrimmed)) return true;
|
|
// normal users (not admin) can't invite users to private topic via email
|
|
if (!isAdmin && isPrivateTopic && emailValid(emailTrimmed)) return true;
|
|
// when inviting to private topic via email, group name must be specified
|
|
if (isPrivateTopic && Ember.isEmpty(groupNames) && emailValid(emailTrimmed)) return true;
|
|
|
|
if (can_invite_to) return false;
|
|
return false;
|
|
},
|
|
|
|
@computed('isAdmin', 'emailOrUsername', 'model.saving', 'isPrivateTopic', 'model.groupNames', 'hasCustomMessage')
|
|
disabledCopyLink(isAdmin, emailOrUsername, saving, isPrivateTopic, groupNames, hasCustomMessage) {
|
|
if (hasCustomMessage) return true;
|
|
if (saving) return true;
|
|
if (Ember.isEmpty(emailOrUsername)) return true;
|
|
const email = emailOrUsername.trim();
|
|
// email must be valid
|
|
if (!emailValid(email)) return true;
|
|
// normal users (not admin) can't invite users to private topic via email
|
|
if (!isAdmin && isPrivateTopic && emailValid(email)) return true;
|
|
// when inviting to private topic via email, group name must be specified
|
|
if (isPrivateTopic && Ember.isEmpty(groupNames) && emailValid(email)) return true;
|
|
return false;
|
|
},
|
|
|
|
@computed('model.saving')
|
|
buttonTitle(saving) {
|
|
return saving ? 'topic.inviting' : 'topic.invite_reply.action';
|
|
},
|
|
|
|
// We are inviting to a topic if the model isn't the current user.
|
|
// The current user would mean we are inviting to the forum in general.
|
|
@computed('model')
|
|
invitingToTopic(model) {
|
|
return model !== this.currentUser;
|
|
},
|
|
|
|
@computed('model', 'model.details.can_invite_via_email')
|
|
canInviteViaEmail(model, can_invite_via_email) {
|
|
return (this.get('model') === this.currentUser) ?
|
|
true :
|
|
can_invite_via_email;
|
|
},
|
|
|
|
@computed('isMessage', 'canInviteViaEmail')
|
|
showCopyInviteButton(isMessage, canInviteViaEmail) {
|
|
return (canInviteViaEmail && !isMessage);
|
|
},
|
|
|
|
topicId: Ember.computed.alias('model.id'),
|
|
|
|
// Is Private Topic? (i.e. visible only to specific group members)
|
|
isPrivateTopic: Em.computed.and('invitingToTopic', 'model.category.read_restricted'),
|
|
|
|
// Is Private Message?
|
|
isMessage: Em.computed.equal('model.archetype', 'private_message'),
|
|
|
|
// Allow Existing Members? (username autocomplete)
|
|
allowExistingMembers: Ember.computed.alias('invitingToTopic'),
|
|
|
|
@computed("isAdmin", "model.group_users")
|
|
isGroupOwnerOrAdmin(isAdmin, groupUsers) {
|
|
return isAdmin || (groupUsers && groupUsers.some(groupUser => groupUser.owner));
|
|
},
|
|
|
|
// Show Groups? (add invited user to private group)
|
|
@computed('isGroupOwnerOrAdmin', 'emailOrUsername', 'isPrivateTopic', 'isMessage', 'invitingToTopic', 'canInviteViaEmail')
|
|
showGroups(isGroupOwnerOrAdmin, emailOrUsername, isPrivateTopic, isMessage, invitingToTopic, canInviteViaEmail) {
|
|
return isGroupOwnerOrAdmin &&
|
|
canInviteViaEmail &&
|
|
!isMessage &&
|
|
(emailValid(emailOrUsername) || isPrivateTopic || !invitingToTopic);
|
|
},
|
|
|
|
@computed('emailOrUsername')
|
|
showCustomMessage(emailOrUsername) {
|
|
return (this.get('model') === this.currentUser || emailValid(emailOrUsername));
|
|
},
|
|
|
|
// Instructional text for the modal.
|
|
@computed('isMessage', 'invitingToTopic', 'emailOrUsername', 'isPrivateTopic', 'isAdmin', 'canInviteViaEmail')
|
|
inviteInstructions(isMessage, invitingToTopic, emailOrUsername, isPrivateTopic, isAdmin, canInviteViaEmail) {
|
|
if (!canInviteViaEmail) {
|
|
// can't invite via email, only existing users
|
|
return I18n.t('topic.invite_reply.sso_enabled');
|
|
} else if (isMessage) {
|
|
// inviting to a message
|
|
return I18n.t('topic.invite_private.email_or_username');
|
|
} else if (invitingToTopic) {
|
|
// inviting to a private/public topic
|
|
if (isPrivateTopic && !isAdmin) {
|
|
// inviting to a private topic and is not admin
|
|
return I18n.t('topic.invite_reply.to_username');
|
|
} else {
|
|
// when inviting to a topic, display instructions based on provided entity
|
|
if (Ember.isEmpty(emailOrUsername)) {
|
|
return I18n.t('topic.invite_reply.to_topic_blank');
|
|
} else if (emailValid(emailOrUsername)) {
|
|
this.set("inviteIcon", "envelope");
|
|
return I18n.t('topic.invite_reply.to_topic_email');
|
|
} else {
|
|
this.set("inviteIcon", "hand-o-right");
|
|
return I18n.t('topic.invite_reply.to_topic_username');
|
|
}
|
|
}
|
|
} else {
|
|
// inviting to forum
|
|
return I18n.t('topic.invite_reply.to_forum');
|
|
}
|
|
},
|
|
|
|
@computed('isPrivateTopic')
|
|
showGroupsClass(isPrivateTopic) {
|
|
return isPrivateTopic ? 'required' : 'optional';
|
|
},
|
|
|
|
groupFinder(term) {
|
|
return Group.findAll({ term: term, ignore_automatic: true });
|
|
},
|
|
|
|
@computed('isMessage', 'emailOrUsername', 'invitingExistingUserToTopic')
|
|
successMessage(isMessage, emailOrUsername, invitingExistingUserToTopic) {
|
|
if (this.get('hasGroups')) {
|
|
return I18n.t('topic.invite_private.success_group');
|
|
} else if (isMessage) {
|
|
return I18n.t('topic.invite_private.success');
|
|
} else if (invitingExistingUserToTopic) {
|
|
return I18n.t('topic.invite_reply.success_existing_email', { emailOrUsername });
|
|
} else if (emailValid(emailOrUsername)) {
|
|
return I18n.t('topic.invite_reply.success_email', { emailOrUsername });
|
|
} else {
|
|
return I18n.t('topic.invite_reply.success_username');
|
|
}
|
|
},
|
|
|
|
@computed('isMessage')
|
|
errorMessage(isMessage) {
|
|
return isMessage ? I18n.t('topic.invite_private.error') : I18n.t('topic.invite_reply.error');
|
|
},
|
|
|
|
@computed('canInviteViaEmail')
|
|
placeholderKey(canInviteViaEmail) {
|
|
return (canInviteViaEmail) ?
|
|
'topic.invite_private.email_or_username_placeholder' :
|
|
'topic.invite_reply.username_placeholder';
|
|
},
|
|
|
|
@computed
|
|
customMessagePlaceholder() {
|
|
return I18n.t('invite.custom_message_placeholder');
|
|
},
|
|
|
|
// Reset the modal to allow a new user to be invited.
|
|
reset() {
|
|
this.set('emailOrUsername', null);
|
|
this.set('hasCustomMessage', false);
|
|
this.set('customMessage', null);
|
|
this.set('invitingExistingUserToTopic', false);
|
|
this.get('model').setProperties({
|
|
groupNames: null,
|
|
error: false,
|
|
saving: false,
|
|
finished: false,
|
|
inviteLink: null
|
|
});
|
|
},
|
|
|
|
actions: {
|
|
|
|
createInvite() {
|
|
const self = this;
|
|
if (this.get('disabled')) { return; }
|
|
|
|
const groupNames = this.get('model.groupNames'),
|
|
userInvitedController = this.get('userInvitedShow'),
|
|
model = this.get('model');
|
|
|
|
model.setProperties({ saving: true, error: false });
|
|
|
|
const onerror = function(e) {
|
|
if (e.jqXHR.responseJSON && e.jqXHR.responseJSON.errors) {
|
|
self.set("errorMessage", e.jqXHR.responseJSON.errors[0]);
|
|
} else {
|
|
self.set("errorMessage", self.get('isMessage') ? I18n.t('topic.invite_private.error') : I18n.t('topic.invite_reply.error'));
|
|
}
|
|
model.setProperties({ saving: false, error: true });
|
|
};
|
|
|
|
if (this.get('hasGroups')) {
|
|
return this.get('model').createGroupInvite(this.get('emailOrUsername').trim()).then((data) => {
|
|
model.setProperties({ saving: false, finished: true });
|
|
this.get('model.details.allowed_groups').pushObject(Ember.Object.create(data.group));
|
|
this.appEvents.trigger('post-stream:refresh');
|
|
|
|
}).catch(onerror);
|
|
|
|
} else {
|
|
|
|
return this.get('model').createInvite(this.get('emailOrUsername').trim(), groupNames, this.get('customMessage')).then(result => {
|
|
model.setProperties({ saving: false, finished: true });
|
|
if (!this.get('invitingToTopic')) {
|
|
Invite.findInvitedBy(this.currentUser, userInvitedController.get('filter')).then(invite_model => {
|
|
userInvitedController.set('model', invite_model);
|
|
userInvitedController.set('totalInvites', invite_model.invites.length);
|
|
});
|
|
} else if (this.get('isMessage') && result && result.user) {
|
|
this.get('model.details.allowed_users').pushObject(Ember.Object.create(result.user));
|
|
this.appEvents.trigger('post-stream:refresh');
|
|
} else if (this.get('invitingToTopic') && emailValid(this.get('emailOrUsername').trim()) && result && result.user) {
|
|
this.set('invitingExistingUserToTopic', true);
|
|
}
|
|
}).catch(onerror);
|
|
}
|
|
},
|
|
|
|
generateInvitelink() {
|
|
const self = this;
|
|
|
|
if (this.get('disabled')) { return; }
|
|
|
|
const groupNames = this.get('model.groupNames'),
|
|
userInvitedController = this.get('userInvitedShow'),
|
|
model = this.get('model');
|
|
|
|
var topicId = null;
|
|
if (this.get('invitingToTopic')) {
|
|
topicId = this.get('model.id');
|
|
}
|
|
|
|
model.setProperties({ saving: true, error: false });
|
|
|
|
return this.get('model').generateInviteLink(this.get('emailOrUsername').trim(), groupNames, topicId).then(result => {
|
|
model.setProperties({ saving: false, finished: true, inviteLink: result });
|
|
Invite.findInvitedBy(this.currentUser, userInvitedController.get('filter')).then(invite_model => {
|
|
userInvitedController.set('model', invite_model);
|
|
userInvitedController.set('totalInvites', invite_model.invites.length);
|
|
});
|
|
}).catch(function(e) {
|
|
if (e.jqXHR.responseJSON && e.jqXHR.responseJSON.errors) {
|
|
self.set("errorMessage", e.jqXHR.responseJSON.errors[0]);
|
|
} else {
|
|
self.set("errorMessage", self.get('isMessage') ? I18n.t('topic.invite_private.error') : I18n.t('topic.invite_reply.error'));
|
|
}
|
|
model.setProperties({ saving: false, error: true });
|
|
});
|
|
},
|
|
|
|
showCustomMessageBox() {
|
|
this.toggleProperty('hasCustomMessage');
|
|
if (this.get('hasCustomMessage')) {
|
|
if (this.get('model') === this.currentUser) {
|
|
this.set('customMessage', I18n.t('invite.custom_message_template_forum'));
|
|
} else {
|
|
this.set('customMessage', I18n.t('invite.custom_message_template_topic'));
|
|
}
|
|
} else {
|
|
this.set('customMessage', null);
|
|
}
|
|
}
|
|
}
|
|
|
|
});
|