{
public function recentCommands(DiscordGuild $guild) {
- $this->authorize('manage', $guild);
- return $guild->bot_commands()->limit(10)->get();
+ $this->authorize('view', $guild);
+ return $guild->bot_commands()->with('user')->limit(10)->get();
}
public function sendMessage(Request $request, DiscordGuild $guild) {
]);
$channel = DiscordChannel::findOrFail($validatedData['channel']);
$this->authorize('manage', $channel->guild);
- $cmd = DiscordBotCommand::sendMessage($channel, $validatedData['text']);
+ $cmd = DiscordBotCommand::sendMessage($channel, $validatedData['text'], $request->user());
return $cmd->toJson();
}
$validatedData = $request->validate([
'phrase' => 'string|nullable',
]);
+ $user_id = $request->user()->id;
$guilds = DiscordGuild::query();
if (!$request->user()->can('viewAny', DiscordGuild::class)) {
- $guilds = $guilds->where('owner', '=', $request->user()->id);
+ $guilds->where(function ($query) use ($user_id) {
+ $query->where('owner', '=', $user_id);
+ $query->orWhereHas('crew', function ($builder) use ($user_id) {
+ $builder->where('user_id', '=', $user_id);
+ });
+ });
}
if (!empty($validatedData['phrase'])) {
- $guilds = $guilds->where('name', 'LIKE', '%'.$validatedData['phrase'].'%');
+ $guilds->where('name', 'LIKE', '%'.$validatedData['phrase'].'%');
}
- $guilds = $guilds->limit(5);
+ $guilds->limit(5);
return $guilds->get()->toJson();
}
return $guild->toJson();
}
+ public function manageCrew(Request $request, $guild_id) {
+ $guild = DiscordGuild::where('guild_id', '=', $guild_id)->firstOrFail();
+ $this->authorize('administer', $guild);
+
+ $validatedData = $request->validate([
+ 'add_user' => 'numeric|exists:App\Models\User,id',
+ 'modify_user' => 'numeric|exists:App\Models\User,id',
+ 'remove_user' => 'numeric|exists:App\Models\User,id',
+ 'role' => 'string|in:admin,manager,member',
+ ]);
+
+ if (isset($validatedData['add_user'])) {
+ $guild->crew()->create([
+ 'user_id' => $validatedData['add_user'],
+ ]);
+ }
+ if (isset($validatedData['modify_user'], $validatedData['role'])) {
+ $crew = $guild->crew()->where('user_id', '=', $validatedData['modify_user'])->firstOrFail();
+ $crew->role = $validatedData['role'];
+ $crew->save();
+ }
+ if (isset($validatedData['remove_user'])) {
+ $crew = $guild->crew()->where('user_id', '=', $validatedData['remove_user'])->firstOrFail();
+ $crew->delete();
+ }
+
+ return $guild->fresh()->toJson();
+ }
+
public function subscriptions(Request $request, $guild_id) {
$guild = DiscordGuild::with([
'event_subscriptions',
'user_subscriptions',
'user_subscriptions.user',
])->where('guild_id', '=', $guild_id)->firstOrFail();
- $this->authorize('manage', $guild);
+ $this->authorize('view', $guild);
return $guild->toJson();
}
$guild->user_subscriptions()->create(['user_id' => $validatedData['add_user']]);
}
if (isset($validatedData['remove_event'])) {
- $guild->event_subscriptions()->where('event_id', '=', $validatedData['remove_event'])->delete();
+ $sub = $guild->event_subscriptions()->where('event_id', '=', $validatedData['remove_event'])->firstOrFail();
+ $sub->delete();
}
if (isset($validatedData['remove_user'])) {
- $guild->user_subscriptions()->where('user_id', '=', $validatedData['remove_user'])->delete();
+ $sub = $guild->user_subscriptions()->where('user_id', '=', $validatedData['remove_user'])->firstOrFail();
+ $sub->delete();
}
$guild->load([
'event_subscriptions',
$users->whereNotIn('id', $validatedData['exclude_ids']);
}
if (!empty($validatedData['phrase'])) {
- $users->where('username', 'LIKE', '%'.$validatedData['phrase'].'%')
- ->orWhere('nickname', 'LIKE', '%'.$validatedData['phrase'].'%');
+ $users->where(function ($query) use ($validatedData) {
+ $query->where('username', 'LIKE', '%'.$validatedData['phrase'].'%');
+ $query->orWhere('nickname', 'LIKE', '%'.$validatedData['phrase'].'%');
+ });
}
$users = $users->limit(5);
return $users->get()->toJson();
return $channels;
}
+ public function broadcastWith($event) {
+ $this->load(['user']);
+ }
+
public static function episodeEvent(DiscordGuild $guild, Episode $episode): DiscordBotCommand {
$cmd = new DiscordBotCommand();
$cmd->discord_guild()->associate($guild);
return $this->hasMany(DiscordChannel::class)->orderBy('position');
}
+ public function crew() {
+ return $this->hasMany(DiscordGuildCrew::class);
+ }
+
public function event_subscriptions() {
return $this->hasMany(DiscordGuildEventSubscription::class);
}
'guild_id',
];
+ protected $with = [
+ 'crew',
+ 'crew.user',
+ ];
+
}
--- /dev/null
+<?php
+
+namespace App\Models;
+
+use Illuminate\Broadcasting\PrivateChannel;
+use Illuminate\Database\Eloquent\BroadcastsEvents;
+use Illuminate\Database\Eloquent\Model;
+
+class DiscordGuildCrew extends Model {
+
+ use BroadcastsEvents;
+
+ public function broadcastOn(string $event): array {
+ $channels = [];
+ if ($this->discord_guild_id) {
+ $channels[] = new PrivateChannel('DiscordGuild.'.$this->discord_guild_id);
+ }
+ return $channels;
+ }
+
+ public function guild() {
+ return $this->belongsTo(DiscordGuild::class);
+ }
+
+ public function user() {
+ return $this->belongsTo(User::class);
+ }
+
+ protected $casts = [
+ 'user_id' => 'string',
+ ];
+
+ protected $fillable = [
+ 'discord_guild_id',
+ 'user_id',
+ ];
+
+ protected $with = [
+ 'user',
+ ];
+
+}
'event_id',
];
+ protected $with = [
+ 'event',
+ ];
+
}
return $this->belongsTo(User::class);
}
+ protected $casts = [
+ 'user_id' => 'string',
+ ];
+
protected $fillable = [
'discord_guild_id',
'user_id',
];
- protected $casts = [
- 'user_id' => 'string',
+ protected $with = [
+ 'user',
];
}
* @param \App\Models\User $user
* @return \Illuminate\Auth\Access\Response|bool
*/
- public function viewAny(User $user)
- {
- return $user->isAdmin();
+ public function viewAny(User $user): bool {
+ return false;
}
/**
* @param \App\Models\DiscordGuild $discordGuild
* @return \Illuminate\Auth\Access\Response|bool
*/
- public function view(User $user, DiscordGuild $discordGuild)
- {
- return $user->isAdmin() || $discordGuild->owner == $user->id;
+ public function view(User $user, DiscordGuild $discordGuild): bool {
+ if ($discordGuild->owner == $user->id) {
+ return true;
+ }
+ foreach ($discordGuild->crew as $crew) {
+ if ($crew->user_id == $user->id) {
+ return true;
+ }
+ }
+ return false;
}
/**
* @param \App\Models\DiscordGuild $discordGuild
* @return \Illuminate\Auth\Access\Response|bool
*/
+ public function administer(User $user, DiscordGuild $discordGuild)
+ {
+ if ($discordGuild->owner == $user->id) {
+ return true;
+ }
+ foreach ($discordGuild->crew as $crew) {
+ if ($crew->user_id == $user->id && $crew->role == 'admin') {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Determine whether the user can perform management tasks for the guild.
+ *
+ * @param \App\Models\User $user
+ * @param \App\Models\DiscordGuild $discordGuild
+ * @return \Illuminate\Auth\Access\Response|bool
+ */
public function manage(User $user, DiscordGuild $discordGuild)
{
- return $user->isAdmin() || $discordGuild->owner == $user->id;
+ if ($discordGuild->owner == $user->id) {
+ return true;
+ }
+ foreach ($discordGuild->crew as $crew) {
+ if ($crew->user_id == $user->id && in_array($crew->role, ['admin', 'manager'])) {
+ return true;
+ }
+ }
+ return false;
}
}
--- /dev/null
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+ /**
+ * Run the migrations.
+ */
+ public function up(): void {
+ Schema::create('discord_guild_crews', function (Blueprint $table) {
+ $table->id();
+ $table->foreignId('discord_guild_id')->constrained();
+ $table->foreignId('user_id')->constrained();
+ $table->string('role')->default('member');
+ $table->timestamps();
+ $table->unique(['discord_guild_id', 'user_id'], 'guild_user_unique');
+ });
+ }
+
+ /**
+ * Reverse the migrations.
+ */
+ public function down(): void {
+ Schema::dropIfExists('discord_guild_crews');
+ }
+};
const { t } = useTranslation();
+ const patchGuild = React.useCallback((incoming) => {
+ if (incoming instanceof Function) {
+ setGuild(incoming);
+ } else {
+ setGuild((existing) => ({ ...existing, ...incoming }));
+ }
+ }, []);
+
return <>
<Row>
<Form.Group as={Col} md={6}>
: null}
{guild ?
<ErrorBoundary>
- <GuildControls guild={guild} />
+ <GuildControls guild={guild} patchGuild={patchGuild} />
</ErrorBoundary>
: null}
</>;
import EventSelect from '../common/EventSelect';
import Icon from '../common/Icon';
+import { mayManageGuild } from '../../helpers/permissions';
+import { useUser } from '../../hooks/user';
-const EventSubscriptions = ({ addEvent, removeEvent, subs }) => {
+const EventSubscriptions = ({ addEvent, guild, removeEvent, subs }) => {
const { t } = useTranslation();
+ const { user } = useUser();
+
+ const mayManage = React.useMemo(() => mayManageGuild(user, guild), [guild, user]);
return <div>
- <Form.Group controlId="esubs.addEvent">
- <Form.Label>{t('discordBot.addEvent')}</Form.Label>
- <Form.Control
- as={EventSelect}
- excludeIds={subs.map(s => s.event_id)}
- onChange={e => addEvent(e.target.value)}
- value=""
- />
- </Form.Group>
+ {mayManage ?
+ <Form.Group controlId="esubs.addEvent">
+ <Form.Label>{t('discordBot.addEvent')}</Form.Label>
+ <Form.Control
+ as={EventSelect}
+ excludeIds={subs.map(s => s.event_id)}
+ onChange={e => addEvent(e.target.value)}
+ value=""
+ />
+ </Form.Group>
+ : null}
{subs.map((esub) => (
<div className="d-flex align-items-center justify-content-between my-2" key={esub.id}>
<div>{esub.event.title}</div>
- <div className="button-bar">
- <Button
- onClick={() => removeEvent(esub.event_id)}
- size="sm"
- title={t('button.remove')}
- variant="outline-danger"
- >
- <Icon.DELETE title="" />
- </Button>
- </div>
+ {mayManage ?
+ <div className="button-bar">
+ <Button
+ onClick={() => removeEvent(esub.event_id)}
+ size="sm"
+ title={t('button.remove')}
+ variant="outline-danger"
+ >
+ <Icon.DELETE title="" />
+ </Button>
+ </div>
+ : null}
</div>
))}
</div>;
EventSubscriptions.propTypes = {
addEvent: PropTypes.func,
+ guild: PropTypes.shape({
+ }),
removeEvent: PropTypes.func,
subs: PropTypes.arrayOf(PropTypes.shape({
})),
import toastr from 'toastr';
import EventSubscriptions from './EventSubscriptions';
+import GuildCrew from './GuildCrew';
import GuildProtocol from './GuildProtocol';
import UserSubscriptions from './UserSubscriptions';
import ErrorBoundary from '../common/ErrorBoundary';
import { compareTitle } from '../../helpers/Event';
import { compareUsername } from '../../helpers/User';
-const GuildControls = ({ guild }) => {
+const GuildControls = ({ guild, patchGuild }) => {
const [protocol, setProtocol] = React.useState([]);
- const [subscriptions, setSubscriptions] = React.useState({});
const { t } = useTranslation();
+ const addCrew = React.useCallback(async (user_id) => {
+ try {
+ const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/crew`, {
+ add_user: user_id,
+ });
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.crewAddError', { error }));
+ }
+ }, [guild.guild_id, patchGuild, t]);
+
+ const changeCrewRole = React.useCallback(async (user_id, role) => {
+ try {
+ const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/crew`, {
+ modify_user: user_id,
+ role,
+ });
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.crewChangeError', { error }));
+ }
+ }, [guild.guild_id, patchGuild, t]);
+
+ const removeCrew = React.useCallback(async (user_id) => {
+ try {
+ const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/crew`, {
+ remove_user: user_id,
+ });
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.crewRemoveError', { error }));
+ }
+ }, [guild.guild_id, patchGuild, t]);
+
const addEventSub = React.useCallback(async (event_id) => {
try {
const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/subscriptions`, {
add_event: event_id,
});
- setSubscriptions(response.data);
- } catch (e) {
- toastr.error(t('discordBot.eventSubError'));
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.eventSubError', { error }));
}
- }, [guild.guild_id, t]);
+ }, [guild.guild_id, patchGuild, t]);
const removeEventSub = React.useCallback(async (event_id) => {
try {
const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/subscriptions`, {
remove_event: event_id,
});
- setSubscriptions(response.data);
- } catch (e) {
- toastr.error(t('discordBot.eventUnsubError'));
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.eventUnsubError', { error }));
}
- }, [guild.guild_id, t]);
+ }, [guild.guild_id, patchGuild, t]);
const addUserSub = React.useCallback(async (user_id) => {
const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/subscriptions`, {
add_user: user_id,
});
- setSubscriptions(response.data);
- } catch (e) {
- toastr.error(t('discordBot.userSubError'));
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.userSubError', { error }));
}
- }, [guild.guild_id, t]);
+ }, [guild.guild_id, patchGuild, t]);
const removeUserSub = React.useCallback(async (user_id) => {
try {
const response = await axios.post(`/api/discord-guilds/${guild.guild_id}/subscriptions`, {
remove_user: user_id,
});
- setSubscriptions(response.data);
- } catch (e) {
- toastr.error(t('discordBot.userUnsubError'));
+ patchGuild(response.data);
+ } catch (error) {
+ toastr.error(t('discordBot.userUnsubError', { error }));
}
- }, [guild.guild_id, t]);
+ }, [guild.guild_id, patchGuild, t]);
React.useEffect(() => {
const ctrl = new AbortController();
response.data.user_subscriptions.sort((a, b) => {
return compareUsername(a.user, b.user);
});
- setSubscriptions(response.data);
+ patchGuild(response.data);
});
window.Echo.private(`DiscordGuild.${guild.id}`)
.listen('.DiscordBotCommandCreated', e => {
})
.listen('.DiscordBotCommandUpdated', e => {
if (e.model) {
- setProtocol(protocol => protocol.map(p => p.id === e.model.id ? { ...p, ...e.mode } : p));
+ setProtocol(protocol => protocol.map(p => p.id === e.model.id ? { ...p, ...e.model } : p));
+ }
+ })
+ .listen('.DiscordGuildCrewCreated', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, crew: [...g.crew || [], e.model] }));
+ }
+ })
+ .listen('.DiscordGuildCrewUpdated', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, crew: (g.crew || []).map(c => c.id === e.model.id ? { ...c, ...e.model } : c) }));
+ }
+ })
+ .listen('.DiscordGuildCrewDeleted', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, crew: (g.crew || []).filter(c => c.id !== e.model.id) }));
+ }
+ })
+ .listen('.DiscordGuildEventSubscriptionCreated', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, event_subscriptions: [...g.event_subscriptions || [], e.model] }));
+ }
+ })
+ .listen('.DiscordGuildEventSubscriptionUpdated', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, event_subscriptions: (g.event_subscriptions || []).map(c => c.id === e.model.id ? { ...c, ...e.model } : c) }));
+ }
+ })
+ .listen('.DiscordGuildEventSubscriptionDeleted', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, event_subscriptions: (g.event_subscriptions || []).filter(c => c.id !== e.model.id) }));
+ }
+ })
+ .listen('.DiscordGuildUserSubscriptionCreated', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, user_subscriptions: [...g.user_subscriptions || [], e.model] }));
+ }
+ })
+ .listen('.DiscordGuildUserSubscriptionUpdated', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, user_subscriptions: (g.user_subscriptions || []).map(c => c.id === e.model.id ? { ...c, ...e.model } : c) }));
+ }
+ })
+ .listen('.DiscordGuildUserSubscriptionDeleted', e => {
+ if (e.model) {
+ patchGuild(g => ({ ...g, user_subscriptions: (g.user_subscriptions || []).filter(c => c.id !== e.model.id) }));
}
});
return () => {
ctrl.abort();
window.Echo.leave(`DiscordGuild.${guild.id}`);
};
- }, [guild.id]);
+ }, [guild.id, patchGuild]);
return <>
<section className="mt-5">
<h2>{t('discordBot.guildControls')}</h2>
+ <Row className="mb-3">
+ <Col md={6}>
+ <h3>{t('discordBot.guildCrew')}</h3>
+ <GuildCrew
+ addCrew={addCrew}
+ changeCrewRole={changeCrewRole}
+ guild={guild}
+ removeCrew={removeCrew}
+ />
+ </Col>
+ <Col md={6}>
+ <h4>{t('discordBot.roleDescriptions.heading')}</h4>
+ <dl>
+ {['admin', 'manager', 'member'].map((role) => (
+ <React.Fragment key={role}>
+ <dt>{t(`discordBot.roles.${role}`)}</dt>
+ <dd className="ms-3">{t(`discordBot.roleDescriptions.${role}`)}</dd>
+ </React.Fragment>
+ ))}
+ </dl>
+ </Col>
+ </Row>
<Row>
<Col md={6}>
<h3>{t('discordBot.eventSubscriptions')}</h3>
+ <p style={{ minHeight: '3.5em' }}>{t('discordBot.eventSubscriptionDescription')}</p>
<ErrorBoundary>
<EventSubscriptions
addEvent={addEventSub}
+ guild={guild}
removeEvent={removeEventSub}
- subs={subscriptions.event_subscriptions || []}
+ subs={guild.event_subscriptions || []}
/>
</ErrorBoundary>
</Col>
<Col md={6}>
<h3>{t('discordBot.userSubscriptions')}</h3>
+ <p style={{ minHeight: '3.5em' }}>{t('discordBot.userSubscriptionDescription')}</p>
<ErrorBoundary>
<UserSubscriptions
addUser={addUserSub}
+ guild={guild}
removeUser={removeUserSub}
- subs={subscriptions.user_subscriptions || []}
+ subs={guild.user_subscriptions || []}
/>
</ErrorBoundary>
</Col>
</section>
<section className="mt-5">
<h3>{t('discordBot.guildProtocol')}</h3>
- <GuildProtocol protocol={protocol} />
+ <ErrorBoundary>
+ <GuildProtocol protocol={protocol} />
+ </ErrorBoundary>
</section>
</>;
};
GuildControls.propTypes = {
guild: PropTypes.shape({
+ event_subscriptions: PropTypes.arrayOf(PropTypes.shape({
+ })),
id: PropTypes.number,
guild_id: PropTypes.string,
+ user_subscriptions: PropTypes.arrayOf(PropTypes.shape({
+ })),
}),
+ patchGuild: PropTypes.func,
};
export default GuildControls;
--- /dev/null
+import PropTypes from 'prop-types';
+import React from 'react';
+import { Button, Form } from 'react-bootstrap';
+import { useTranslation } from 'react-i18next';
+
+import UserSelect from '../common/UserSelect';
+import Icon from '../common/Icon';
+import UserBox from '../users/Box';
+import { mayAdminGuild } from '../../helpers/permissions';
+import { useUser } from '../../hooks/user';
+
+const GuildCrew = ({ addCrew, changeCrewRole, guild, removeCrew }) => {
+ const { t } = useTranslation();
+ const { user } = useUser();
+
+ const mayAdmin = React.useMemo(() => mayAdminGuild(user, guild), [guild, user]);
+
+ return <div>
+ {mayAdmin ?
+ <Form.Group controlId="crew.addCrew">
+ <Form.Label>{t('discordBot.addCrew')}</Form.Label>
+ <Form.Control
+ as={UserSelect}
+ excludeIds={guild.crew.map(c => c.user_id)}
+ onChange={e => addCrew(e.target.value)}
+ value=""
+ />
+ </Form.Group>
+ : null}
+ {guild.crew.map((crew) => (
+ <div className="d-flex align-items-center justify-content-between my-2" key={crew.id}>
+ <UserBox user={crew.user} />
+ {mayAdmin ?
+ <div className="button-bar d-flex align-items-center">
+ <Form.Select
+ onChange={(e) => changeCrewRole(crew.user_id, e.target.value)}
+ value={crew.role}
+ >
+ {['admin', 'manager', 'member'].map((role =>
+ <option key={role} value={role}>{t(`discordBot.roles.${role}`)}</option>
+ ))}
+ </Form.Select>
+ <Button
+ onClick={() => removeCrew(crew.user_id)}
+ size="sm"
+ title={t('button.remove')}
+ variant="outline-danger"
+ >
+ <Icon.DELETE title="" />
+ </Button>
+ </div>
+ :
+ <span>{t(`discordBot.roles.${crew.role}`)}</span>
+ }
+ </div>
+ ))}
+ </div>;
+};
+
+GuildCrew.propTypes = {
+ addCrew: PropTypes.func,
+ changeCrewRole: PropTypes.func,
+ guild: PropTypes.shape({
+ crew: PropTypes.arrayOf(PropTypes.shape({
+ })),
+ }),
+ removeCrew: PropTypes.func,
+};
+
+export default GuildCrew;
import React from 'react';
import { useTranslation } from 'react-i18next';
+import { getUserName } from '../../helpers/User';
+
const GuildProtocol = ({ protocol }) => {
const { t } = useTranslation();
</div>
<div className="d-flex justify-content-between">
<span className="text-muted">
- {t('discordBot.commandTime', { time: new Date(entry.created_at) })}
+ {entry.user
+ ? t('discordBot.commandTimeUser', { time: new Date(entry.created_at), user: getUserName(entry.user) })
+ : t('discordBot.commandTime', { time: new Date(entry.created_at) })
+ }
</span>
<span className="text-muted">
{entry.executed_at
import UserSelect from '../common/UserSelect';
import Icon from '../common/Icon';
import UserBox from '../users/Box';
+import { mayManageGuild } from '../../helpers/permissions';
+import { useUser } from '../../hooks/user';
-const UserSubscriptions = ({ addUser, removeUser, subs }) => {
+const UserSubscriptions = ({ addUser, guild, removeUser, subs }) => {
const { t } = useTranslation();
+ const { user } = useUser();
+
+ const mayManage = React.useMemo(() => mayManageGuild(user, guild), [guild, user]);
return <div>
- <Form.Group controlId="usubs.addUser">
- <Form.Label>{t('discordBot.addUser')}</Form.Label>
- <Form.Control
- as={UserSelect}
- excludeIds={subs.map(s => s.user_id)}
- onChange={e => addUser(e.target.value)}
- value=""
- />
- </Form.Group>
+ {mayManage ?
+ <Form.Group controlId="usubs.addUser">
+ <Form.Label>{t('discordBot.addUser')}</Form.Label>
+ <Form.Control
+ as={UserSelect}
+ excludeIds={subs.map(s => s.user_id)}
+ onChange={e => addUser(e.target.value)}
+ value=""
+ />
+ </Form.Group>
+ : null}
{subs.map((usub) => (
<div className="d-flex align-items-center justify-content-between my-2" key={usub.id}>
<UserBox user={usub.user} />
- <div className="button-bar">
- <Button
- onClick={() => removeUser(usub.user_id)}
- size="sm"
- title={t('button.remove')}
- variant="outline-danger"
- >
- <Icon.DELETE title="" />
- </Button>
- </div>
+ {mayManage ?
+ <div className="button-bar">
+ <Button
+ onClick={() => removeUser(usub.user_id)}
+ size="sm"
+ title={t('button.remove')}
+ variant="outline-danger"
+ >
+ <Icon.DELETE title="" />
+ </Button>
+ </div>
+ : null}
</div>
))}
</div>;
UserSubscriptions.propTypes = {
addUser: PropTypes.func,
+ guild: PropTypes.shape({
+ }),
removeUser: PropTypes.func,
subs: PropTypes.arrayOf(PropTypes.shape({
})),
export const mayEditContent = user =>
user && hasGlobalRole(user, 'content');
+// Discord Guilds
+
+const isGuildOwner = (user, guild) => user && guild && user.id === guild.owner;
+
+const isGuildAdmin = (user, guild) => user && guild?.crew?.find(c => c.role === 'admin' && c.user_id === user.id);
+const isGuildManager = (user, guild) => user && guild?.crew?.find(c => c.role == 'manager' && c.user_id === user.id);
+const isGuildMember = (user, guild) => user && guild?.crew?.find(c => c.user_id === user.id);
+
+export const mayViewGuild = (user, guild) => isGuildOwner(user, guild) || isGuildMember(user, guild);
+
+export const mayManageGuild = (user, guild) => isGuildOwner(user, guild) || isGuildAdmin(user, guild) || isGuildManager(user, guild);
+
+export const mayAdminGuild = (user, guild) => isGuildOwner(user, guild) || isGuildAdmin(user, guild);
+
// Episodes
export const isCommentator = (user, episode) => {
},
},
discordBot: {
+ addCrew: 'User hinzufügen',
addEvent: 'Event abonnieren',
addUser: 'User abonnieren',
channel: 'Kanal',
channelControls: 'Kanal-Steuerung',
+ commandPending: 'Steht aus',
commandStatus: {
done: 'Abgeschlossen',
exception: 'Fehler',
pending: 'Ausstehend',
},
commandTime: '{{ time, L HH:mm:ss }}',
+ commandTimeUser: '{{ time, L HH:mm:ss }} von {{ user }}',
commandType: {
'episode-event': 'Episoden-Event Synchronisation',
message: 'Nachricht',
result: 'Ergebnis',
},
controls: 'Steuerung',
- eventSubError: 'Fehler bim Abonnieren',
- eventSubscriptions: 'Event Subscriptions',
+ crewAddError: 'Fehler bein Hinzufügen',
+ crewChangeError: 'Fehler beim Speichern',
+ crewRemoveError: 'Fehler beim Entfernen',
+ description: 'Dieser Bot kann automatisch Discord Events für abonnierte Veranstaltungen und Benutzer erstellen. Er ist auch in der Lage, Diskussions-Kanäle für Async Turnieren zu verwalten.',
+ eventSubError: 'Fehler beim Abonnieren',
+ eventSubscriptionDescription: 'Episoden abonnierter Veranstaltungen werden als Event in Discord angelegt.',
+ eventSubscriptions: 'Abonnierte Veranstaltungen',
eventUnsubError: 'Fehler beim Kündigen',
guild: 'Server',
guildControls: 'Server-Steuerung',
+ guildCrew: 'Crew',
guildProtocol: 'Command Protokoll',
heading: 'Discord Bot',
invite: 'Bot einladen',
message: 'Nachricht',
messageError: 'Fehler beim Senden',
messageSuccess: 'Nachricht in Warteschlange',
+ roles: {
+ admin: 'Admin',
+ manager: 'Manager',
+ member: 'Mitglied',
+ },
+ roleDescriptions: {
+ admin: 'Darf effektiv alles. Der Server-Owner (User mit der Krone im Discord) ist immer Admin.',
+ heading: 'Beschreibung der Rollen',
+ manager: 'Manager können alles außer die Userliste und Rollen bearbeiten.',
+ member: 'Kann diese Seite einsehen, aber nix anfassen.',
+ },
selectGuild: 'Bitte Server wählen',
sendMessage: 'Nachricht senden',
userSubError: 'Fehler beim Abonnieren',
- userSubscriptions: 'User Subscriptions',
+ userSubscriptionDescription: 'Episoden mit Beteiligung als Runner abonnierter Benutzer werden als Event in Discord angelegt.',
+ userSubscriptions: 'Abonnierte Benutzer',
userUnsubError: 'Fehler beim Kündigen',
},
episodes: {
},
},
discordBot: {
+ addCrew: 'Add user',
addEvent: 'Subscribe to event',
addUser: 'Subscribe to user',
channel: 'Channel',
channelControls: 'Channel controls',
+ commandPending: 'Pending execution',
commandStatus: {
done: 'Done',
exception: 'Error',
pending: 'Pending',
},
commandTime: '{{ time, L HH:mm:ss }}',
+ commandTimeUser: '{{ time, L HH:mm:ss }} by {{ user }}',
commandType: {
'episode-event': 'Episode event synchronization',
message: 'Message',
result: 'Result',
},
controls: 'Controls',
+ crewAddError: 'Error adding user',
+ crewChangeError: 'Error modifying user',
+ crewRemoveError: 'Error removing user',
+ description: 'This bot can automatically create scheduled events on your discord for events and users your discord is subscribed to. It also manages creation and access for async tournament discussion channels.',
eventSubError: 'Error subscribing',
+ eventSubscriptionDescription: 'Episodes of subscribed events will be posted as discord scheduled events.',
eventSubscriptions: 'Event subscriptions',
eventUnsubError: 'Error unsubscribing',
guild: 'Server',
guildControls: 'Server controls',
+ guildCrew: 'Crew',
guildProtocol: 'Command protocol',
heading: 'Discord Bot',
invite: 'Invite bot',
message: 'Message',
messageError: 'Error sending message',
messageSuccess: 'Message queued',
+ roles: {
+ admin: 'Admin',
+ manager: 'Manager',
+ member: 'Member',
+ },
+ roleDescriptions: {
+ admin: 'Effectively in total control. Server owners (user with the crown in discord) is always an admin.',
+ heading: 'Role descriptions',
+ manager: 'Managers may do pretty much everything except for administering users and roles.',
+ member: 'May see this page, but not do anything with it.',
+ },
selectGuild: 'Please select server',
sendMessage: 'Send message',
userSubError: 'Error subscribing',
+ userSubscriptionDescription: 'Episodes where subscribed users are participating as runners will be posted as discord scheduled events.',
userSubscriptions: 'User subscriptions',
userUnsubError: 'Error unsubscribing',
},
return <Container>
<h1>{t('discordBot.heading')}</h1>
+ <p>{t('discordBot.description')}</p>
<Helmet>
<title>{t('discordBot.heading')}</title>
+ <meta name="description" content={t('discordBot.description')} />
</Helmet>
<p>
<span className="button-bar">
Route::get('discord-guilds', 'App\Http\Controllers\DiscordGuildController@search');
Route::get('discord-guilds/{guild_id}', 'App\Http\Controllers\DiscordGuildController@single');
Route::get('discord-guilds/{guild_id}/channels', 'App\Http\Controllers\DiscordChannelController@search');
+Route::post('discord-guilds/{guild_id}/crew', 'App\Http\Controllers\DiscordGuildController@manageCrew');
Route::get('discord-guilds/{guild_id}/subscriptions', 'App\Http\Controllers\DiscordGuildController@subscriptions');
Route::post('discord-guilds/{guild_id}/subscriptions', 'App\Http\Controllers\DiscordGuildController@manageSubscriptions');
Broadcast::channel('DiscordGuild.{id}', function ($user, $id) {
$guild = DiscordGuild::findOrFail($id);
- return $user->can('manage', $guild);
+ return $user->can('view', $guild);
});
Broadcast::channel('Protocol.{id}', function ($user, $id) {
projects / alttp.git / commitdiff