Browse Source

Admin/Organizer/Pending

tags/v0.9.1
akimmig 4 years ago
parent
commit
79c909f87d
7 changed files with 137 additions and 13 deletions
  1. +14
    -6
      server/schema.gql
  2. +14
    -1
      server/src/client.ts
  3. +3
    -0
      server/src/organizer/models/Organizer.ts
  4. +50
    -2
      server/src/organizer/resolver/organizer.ts
  5. +3
    -3
      server/src/person/resolver/person.mutation.ts
  6. +1
    -1
      server/src/person/resolver/person.query.ts
  7. +52
    -0
      server/src/person/resolver/person.ts

+ 14
- 6
server/schema.gql View File

familyName: String! familyName: String!
email: EmailAddress! email: EmailAddress!
token: String token: String
_adminOf: [UUID!]
adminOf: [Organizer!]
_organizerOf: [UUID!]
organizerOf: [Organizer!]
} }


"""UUID""" """UUID"""
""" """
scalar EmailAddress scalar EmailAddress


type Apparatus {
_id: UUID!
name: String!
logo: String
}

type Organizer { type Organizer {
_id: UUID! _id: UUID!
name: String! name: String!
logo: String logo: String
_admins: [UUID!] _admins: [UUID!]
_organizers: [UUID!] _organizers: [UUID!]
_pending: [UUID!]
admins: [Person!]
organizers: [Person!]
pending: [Person!]
}

type Apparatus {
_id: UUID!
name: String!
logo: String
} }


type Timeslot { type Timeslot {

+ 14
- 1
server/src/client.ts View File

private token: string = null; private token: string = null;


private master: boolean = false; private master: boolean = false;
private adminOf: UUID[] = [];
private organizerOf: UUID[] = [];


constructor(id?: UUID, ip?: string) { constructor(id?: UUID, ip?: string) {
this.id = id; this.id = id;


this.master = entry.master; this.master = entry.master;


this.adminOf = (await db.fetch('organizer', { _admins: userid })).map(e => e._id);
this.organizerOf = (await db.fetch('organizer', { _organizers: userid })).map(e => e._id);

return; return;
} }


return JSON.parse(Base64.decode(this.token?.split('.')?.[1] || '')); return JSON.parse(Base64.decode(this.token?.split('.')?.[1] || ''));
} }


public isSelf(id: string | UUID): boolean {
public isSelf(id: UUID): boolean {
return this.getUser()?._id === id; return this.getUser()?._id === id;
} }


public isMaster(): boolean { public isMaster(): boolean {
return this.master; return this.master;
} }

public isAdmin(id: UUID): boolean {
return this.adminOf.indexOf(id) !== -1;
}

public isOrganizer(id: UUID): boolean {
return this.isAdmin(id) || this.organizerOf.indexOf(id) !== -1;
}
} }

+ 3
- 0
server/src/organizer/models/Organizer.ts View File



@Field(() => [UUID], { nullable: true }) @Field(() => [UUID], { nullable: true })
_organizers?: UUID[] _organizers?: UUID[]

@Field(() => [UUID], { nullable: true })
_pending?: UUID[]
} }

+ 50
- 2
server/src/organizer/resolver/organizer.ts View File

import { Organizer } from '../models/Organizer'; import { Organizer } from '../models/Organizer';
import { Client } from '../../client'; import { Client } from '../../client';
import { UUID } from '../../global/scalars/UUID'; import { UUID } from '../../global/scalars/UUID';
import {Person} from '../../person/models/Person'
import {PersonService} from '../../person/person.service'


@Resolver(() => Organizer) @Resolver(() => Organizer)
export class OrganizerResolver { export class OrganizerResolver {
@Context('client') client: Client, @Context('client') client: Client,
@Parent() parent: Organizer @Parent() parent: Organizer
): Promise<UUID[]> { ): Promise<UUID[]> {
if (!client.isMaster()) return null;
if (!client.isMaster() && !client.isOrganizer(parent._id)) return null;


return parent._admins; return parent._admins;
} }


@ResolveField(() => [Person], { nullable: true })
async admins(
@Context('client') client: Client,
@Parent() parent: Organizer
): Promise<Person[]> {
if (!client.isMaster() && !client.isOrganizer(parent._id)) return null;

const personService = new PersonService();

return Promise.all((parent._admins || []).map(e => personService.findOneById(e)));
}

@ResolveField(() => [UUID], { nullable: true }) @ResolveField(() => [UUID], { nullable: true })
async _organizers( async _organizers(
@Context('client') client: Client, @Context('client') client: Client,
@Parent() parent: Organizer @Parent() parent: Organizer
): Promise<UUID[]> { ): Promise<UUID[]> {
if (!client.isMaster()) return null;
if (!client.isMaster() && !client.isOrganizer(parent._id)) return null;


return parent._organizers; return parent._organizers;
} }

@ResolveField(() => [Person], { nullable: true })
async organizers(
@Context('client') client: Client,
@Parent() parent: Organizer
): Promise<Person[]> {
if (!client.isMaster() && !client.isOrganizer(parent._id)) return null;

const personService = new PersonService();

return Promise.all((parent._organizers || []).map(e => personService.findOneById(e)));
}

@ResolveField(() => [UUID], { nullable: true })
async _pending(
@Context('client') client: Client,
@Parent() parent: Organizer
): Promise<UUID[]> {
if (!client.isMaster() && !client.isAdmin(parent._id)) return null;

return parent._pending;
}

@ResolveField(() => [Person], { nullable: true })
async pending(
@Context('client') client: Client,
@Parent() parent: Organizer
): Promise<Person[]> {
if (!client.isMaster() && !client.isAdmin(parent._id)) return null;

const personService = new PersonService();

return Promise.all((parent._pending || []).map(e => personService.findOneById(e)));
}
} }

+ 3
- 3
server/src/person/resolver/person.mutation.ts View File

organizerService.update(client, o._id, {$set: {_admins: [ tmp._id ] }}, {}); organizerService.update(client, o._id, {$set: {_admins: [ tmp._id ] }}, {});
} else if (o._admins.length === 0) { } else if (o._admins.length === 0) {
organizerService.update(client, o._id, {$push: {_admins: tmp._id }}, {}); organizerService.update(client, o._id, {$push: {_admins: tmp._id }}, {});
} else if (!o._organizers) {
organizerService.update(client, o._id, {$set: {_organizers: [ tmp._id ] }}, {});
} else if (!o._pending) {
organizerService.update(client, o._id, {$set: {_pending: [ tmp._id ] }}, {});
} else { } else {
organizerService.update(client, o._id, {$push: {_organizers: tmp._id }}, {});
organizerService.update(client, o._id, {$push: {_pending: tmp._id }}, {});
} }


// TODO: Mail verschicken // TODO: Mail verschicken

+ 1
- 1
server/src/person/resolver/person.query.ts View File

@Context('client') client: Client, @Context('client') client: Client,
@Args('id') id: UUID, @Args('id') id: UUID,
): Promise<Person> { ): Promise<Person> {
if (!client.isMaster()) return null;
if (!client.isMaster() && !client.isSelf(id)) return null;


return await this.service.findOneById(id) as Person; return await this.service.findOneById(id) as Person;
} }

+ 52
- 0
server/src/person/resolver/person.ts View File

import { Client } from '../../client'; import { Client } from '../../client';
import { UUID } from '../../global/scalars/UUID'; import { UUID } from '../../global/scalars/UUID';
import {EmailAddress} from '../../global/scalars/EmailAddress' import {EmailAddress} from '../../global/scalars/EmailAddress'
import {OrganizerService} from '../../organizer/organizer.service'
import {Organizer} from '../../organizer/models/Organizer'


@Resolver(() => Person) @Resolver(() => Person)
export class PersonResolver { export class PersonResolver {
if (!client.isMaster() && !client.isSelf(parent._id)) return null; if (!client.isMaster() && !client.isSelf(parent._id)) return null;
return parent.email; return parent.email;
} }

@ResolveField(() => [UUID], { nullable: true })
async _adminOf(
@Context('client') client: Client,
@Parent() parent: Person
): Promise<UUID[]> {
if (!client.isMaster() && !client.isSelf(parent._id)) return null;

const organizerService = new OrganizerService();

const o = await organizerService.find({ _admins: client.getUser()._id });
return o.map(e => e._id);
}

@ResolveField(() => [Organizer], { nullable: true })
async adminOf(
@Context('client') client: Client,
@Parent() parent: Person
): Promise<Organizer[]> {
if (!client.isMaster() && !client.isSelf(parent._id)) return null;

const organizerService = new OrganizerService();

return organizerService.find({ _admins: client.getUser()._id });
}

@ResolveField(() => [UUID], { nullable: true })
async _organizerOf(
@Context('client') client: Client,
@Parent() parent: Person
): Promise<UUID[]> {
if (!client.isMaster() && !client.isSelf(parent._id)) return null;

const organizerService = new OrganizerService();

const o = await organizerService.find({ $or: [{_organizers: client.getUser()._id}] });
return o.map(e => e._id);
}

@ResolveField(() => [Organizer], { nullable: true })
async organizerOf(
@Context('client') client: Client,
@Parent() parent: Person
): Promise<Organizer[]> {
if (!client.isMaster() && !client.isSelf(parent._id)) return null;

const organizerService = new OrganizerService();

return await organizerService.find({ $or: [{_organizers: client.getUser()._id}] });
}
} }

Loading…
Cancel
Save