431 lines
12 KiB
JavaScript
431 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);
|
|
}
|
|
}
|
|
}
|
|
});
|