@things-factory/gallery 0.0.0-stage → 10.1.223

package/server/service/gallery/gallery-rules.ts

@@ -0,0 +1,187 @@
+/*
+ * The gallery's rules that need no database (ADR-0165): what a post may hold, how tags are kept, who sees a post, which
+ * events are offered for a photo, and who hears of an event's first photo. Pure, so the tests read them directly.
+ */
+
+export const SPACES = ['COMPANY', 'PERSONAL']
+
+/** At most this many photos in one post, and at least one. */
+export const MAX_PHOTOS = 20
+export const MAX_CAPTION = 500
+export const MAX_TAGS = 10
+export const MAX_TAG = 30
+
+/** A tag as it is kept: no `#` in front, inner spaces as one, nothing around. */
+export function tagOf(raw: string): string {
+  return String(raw ?? '')
+    .trim()
+    .replace(/^#+/, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** The tags as they are kept - each once (the same word whatever its case), in the order given. */
+export function tagsOf(raw: string[] | null | undefined): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const one of raw ?? []) {
+    const tag = tagOf(one)
+    const key = tag.toLowerCase()
+    if (!tag || seen.has(key)) continue
+    seen.add(key)
+    out.push(tag)
+  }
+  return out
+}
+
+export type PostInput = {
+  space?: string | null
+  caption?: string | null
+  tags?: string[] | null
+  eventId?: string | null
+}
+
+/** Why the input cannot be kept, or nothing. */
+export function inputRefusal(input: PostInput): string | undefined {
+  if (input.space && !SPACES.includes(input.space)) return 'unknown-space'
+  if ((input.caption ?? '').length > MAX_CAPTION) return 'caption-too-long'
+  const tags = tagsOf(input.tags)
+  if (tags.length > MAX_TAGS) return 'too-many-tags'
+  if (tags.some(tag => tag.length > MAX_TAG)) return 'tag-too-long'
+  /* An event is the company's: a person's own gallery holds their days, not the company's events (decision 2). */
+  if (input.eventId && input.space === 'PERSONAL') return 'event-in-personal'
+  return undefined
+}
+
+/** Why a post would hold this many photos wrongly, or nothing. */
+export function photoCountRefusal(count: number): string | undefined {
+  if (count < 1) return 'no-photo'
+  if (count > MAX_PHOTOS) return 'too-many-photos'
+  return undefined
+}
+
+/** A photo is an image - the gallery takes nothing else. */
+export function isPhoto(mimetype?: string | null): boolean {
+  return /^image\//i.test(mimetype ?? '')
+}
+
+/** The tags with `from` renamed to `to` - a rename into a tag already there merges the two. */
+export function renamedTags(tags: string[] | null | undefined, from: string, to: string): string[] {
+  const source = tagOf(from).toLowerCase()
+  return tagsOf((tags ?? []).map(tag => (tagOf(tag).toLowerCase() === source ? to : tag)))
+}
+
+/** Whether a post holds the tag, whatever its case. */
+export function hasTag(tags: string[] | null | undefined, tag: string): boolean {
+  const key = tagOf(tag).toLowerCase()
+  return !!key && (tags ?? []).some(one => tagOf(one).toLowerCase() === key)
+}
+
+/** The tags of the domain with how many posts hold each, the most used first - narrowed to those that hold `text`. */
+export function tagCounts(
+  lists: (string[] | null | undefined)[],
+  text = '',
+  limit = 20
+): { tag: string; count: number }[] {
+  const counts = new Map<string, { tag: string; count: number }>()
+  for (const list of lists) {
+    for (const tag of tagsOf(list)) {
+      const key = tag.toLowerCase()
+      const one = counts.get(key)
+      if (one) one.count++
+      else counts.set(key, { tag, count: 1 })
+    }
+  }
+  const wanted = tagOf(text).toLowerCase()
+  return [...counts.values()]
+    .filter(one => !wanted || one.tag.toLowerCase().includes(wanted))
+    .sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag))
+    .slice(0, limit)
+}
+
+export type Viewer = { userId: string; moderator: boolean; activePeople: ReadonlySet<string> }
+export type SeenPost = { space: string; creatorId?: string | null; hiddenAt?: Date | string | null }
+
+/**
+ * Whether the viewer sees the post. Everyone of the domain sees every post (decision 2), except a hidden one - its
+ * owner and the moderators see that - and the own gallery of someone who left (decision 5).
+ */
+export function seesPost(post: SeenPost, viewer: Viewer): boolean {
+  const own = !!post.creatorId && post.creatorId === viewer.userId
+  if (post.hiddenAt && !own && !viewer.moderator) return false
+  if (post.space === 'PERSONAL' && !own && !viewer.activePeople.has(post.creatorId ?? '')) return false
+  return true
+}
+
+const DAY = 24 * 60 * 60 * 1000
+
+/** Whether a photo taken at `takenAt` is near the event - from a day before it starts to a day after it ends. */
+export function nearEvent(event: { startAt: Date | string; endAt: Date | string }, takenAt: Date | string): boolean {
+  const at = new Date(takenAt).getTime()
+  return new Date(event.startAt).getTime() - DAY <= at && at <= new Date(event.endAt).getTime() + DAY
+}
+
+/** The events offered for a photo: those near when it was taken first - the closest start first - then the newest. */
+export function orderChoices<T extends { id: string; startAt: Date | string; endAt: Date | string }>(
+  events: T[],
+  takenAt: Date | string
+): (T & { near: boolean })[] {
+  const at = new Date(takenAt).getTime()
+  const unique = [...new Map(events.map(one => [one.id, one])).values()]
+  return unique
+    .map(one => ({ ...one, near: nearEvent(one, takenAt) }))
+    .sort((a, b) =>
+      a.near !== b.near
+        ? Number(b.near) - Number(a.near)
+        : a.near
+          ? Math.abs(new Date(a.startAt).getTime() - at) - Math.abs(new Date(b.startAt).getTime() - at)
+          : new Date(b.startAt).getTime() - new Date(a.startAt).getTime()
+    )
+}
+
+/**
+ * Who hears that an event's first photo is up: the people named on it, or everyone of the domain when it names nobody
+ * (an event made from the gallery). Never the one who posted it.
+ */
+export function firstPhotoReceivers(attendeeIds: string[], memberIds: string[], posterId: string): string[] {
+  const base = attendeeIds.length ? attendeeIds : memberIds
+  return [...new Set(base)].filter(id => id && id !== posterId)
+}
+
+/** The page a notice opens - the gallery, narrowed to the event or the post. */
+export function galleryAddressOf(where: { eventId?: string | null; postId?: string | null }): string {
+  if (where.postId) return `gallery-page?post=${where.postId}`
+  if (where.eventId) return `gallery-page?event=${where.eventId}`
+  return 'gallery-page'
+}
+
+export type Say = (key: string, english: string, params?: Record<string, unknown>) => string
+
+/** The words of the notice that an event's first photo is up. */
+export function firstPhotoWords(event: { name: string }, poster: string, caption: string | null | undefined, say: Say) {
+  const subject = say('gallery.notice.first-photo-subject', 'Photos of {event} are up', { event: event.name })
+  const body = say('gallery.notice.first-photo-body', '{poster} posted the first photos of {event}.', {
+    poster,
+    event: event.name
+  })
+  return {
+    subject,
+    summary: body,
+    body: caption ? `${body}\n\n${caption}` : body,
+    action: say('gallery.notice.action', 'Open the gallery'),
+    note: say('gallery.notice.note', 'Open Gallery in the application to see them.')
+  }
+}
+
+/** The words of the notice that a moderator hid one's post. */
+export function hiddenWords(reason: string, say: Say) {
+  const subject = say('gallery.notice.hidden-subject', 'Your gallery post was hidden')
+  const body = say('gallery.notice.hidden-body', 'Reason: {reason}', { reason })
+  return {
+    subject,
+    summary: body,
+    body,
+    action: say('gallery.notice.action', 'Open the gallery'),
+    note: say('gallery.notice.note', 'Open Gallery in the application to see them.')
+  }
+}

package/server/service/gallery/gallery-service.ts

@@ -0,0 +1,254 @@
+/*
+ * What the gallery's doors do with the database (ADR-0165 decisions 2-7): who sees a post, its photos and event, which
+ * events a person may post to, opening an event's gallery, and the two notices.
+ */
+import { EntityManager, In } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { checkPermission, getDomainAssignees, User, UserStatus } from '@things-factory/auth-base'
+import { Attendee, Event } from '@things-factory/calendar'
+import { translatorFor } from '@things-factory/i18n-base/translator'
+import { noticeLinkOf, sendNoticeWhenCommitted, type Notice } from '@things-factory/notification'
+import { getRepository } from '@things-factory/shell'
+
+import { GalleryEvent, GalleryLike, GalleryPost } from './gallery'
+import {
+  firstPhotoReceivers,
+  firstPhotoWords,
+  galleryAddressOf,
+  hiddenWords,
+  seesPost,
+  type Say,
+  type Viewer
+} from './gallery-rules'
+
+/** The photos of a post hang on it under this `refType` (attachment-base). */
+export const GALLERY_REF_TYPE = 'Gallery Post'
+
+const isId = (id?: string | null) => !!id && /^[0-9a-f-]{36}$/i.test(id)
+
+async function holds(context: any, category: string, privilege: string, key: string): Promise<boolean> {
+  const state = context?.state ?? {}
+  const { domain, user, unsafeIP, prohibitedPrivileges } = state
+  if (!domain || !user) return false
+  /* Asked once per request - a list asks it for each row. */
+  state[key] ??= checkPermission(
+    { category, privilege, owner: true } as any,
+    user,
+    domain,
+    unsafeIP,
+    prohibitedPrivileges
+  ).then(Boolean)
+  return await state[key]
+}
+
+/** Whether the request moderates the gallery - the module's one task, `gallery.moderation`. */
+export const isModerator = (context: any) => holds(context, 'gallery', 'mutation', '__galleryModerator')
+
+/** Whether the request reads the domain's whole calendar. */
+const readsCalendar = (context: any) => holds(context, 'calendar', 'query', '__galleryCalendarReader')
+
+/** The request's person as a post's viewer - asked once per request. */
+export async function viewerOf(context: any): Promise<Viewer> {
+  const state = context.state
+  if (!state.__galleryViewer) {
+    const people = await getDomainAssignees(state.domain, state.tx)
+    state.__galleryViewer = {
+      userId: state.user.id,
+      moderator: await isModerator(context),
+      activePeople: new Set(people.map(one => one.id))
+    }
+  }
+  return state.__galleryViewer
+}
+
+/** The post as the request may see it, or nothing - one answer for "none" and "not for you". */
+export async function visiblePost(id: string, context: any, tx?: EntityManager): Promise<GalleryPost | undefined> {
+  const { domain, user } = context?.state ?? {}
+  if (!isId(id) || !domain || !user) return undefined
+  const post = await getRepository(GalleryPost, tx).findOne({ where: { id, domain: { id: domain.id } } as any })
+  if (!post) return undefined
+  return seesPost(post, await viewerOf(context)) ? post : undefined
+}
+
+/** The photos of each post, in the order they were added. */
+export async function photosOf(
+  postIds: string[],
+  domainId: string,
+  tx?: EntityManager
+): Promise<Map<string, Attachment[]>> {
+  const out = new Map<string, Attachment[]>()
+  if (!postIds.length) return out
+  const rows = await getRepository(Attachment, tx).find({
+    where: { domain: { id: domainId }, refType: GALLERY_REF_TYPE, refBy: In(postIds) } as any,
+    order: { createdAt: 'ASC' } as any
+  })
+  for (const one of rows) out.set(one.refBy!, [...(out.get(one.refBy!) ?? []), one])
+  return out
+}
+
+/** The name, time and place of each event. */
+export async function eventsOf(eventIds: string[], domainId: string, tx?: EntityManager): Promise<Map<string, Event>> {
+  const ids = [...new Set(eventIds.filter(isId))]
+  if (!ids.length) return new Map()
+  const rows = await getRepository(Event, tx).find({ where: { id: In(ids), domain: { id: domainId } } as any })
+  return new Map(rows.map(one => [one.id, one]))
+}
+
+/** Puts on each post what its fields answer from - who posted it, its photos, its event and whether the request's person likes it. */
+export async function decorate(posts: GalleryPost[], context: any): Promise<GalleryPost[]> {
+  const { domain, user, tx } = context.state
+  const ids = posts.map(one => one.id)
+  const photos = await photosOf(ids, domain.id, tx)
+  const events = await eventsOf(
+    posts.map(one => one.eventId!),
+    domain.id,
+    tx
+  )
+  const liked = ids.length
+    ? await getRepository(GalleryLike, tx).find({ where: { post: { id: In(ids) }, user: { id: user.id } } as any })
+    : []
+  const likedIds = new Set(liked.map(one => one.postId))
+  const creatorIds = [...new Set(posts.map(one => one.creatorId).filter(Boolean))]
+  const creators = new Map(
+    (creatorIds.length ? await getRepository(User, tx).find({ where: { id: In(creatorIds) } as any }) : []).map(one => [
+      one.id,
+      one
+    ])
+  )
+  for (const one of posts as any[]) {
+    one.__creator = creators.get(one.creatorId) ?? null
+    one.__photos = photos.get(one.id) ?? []
+    one.__event = one.eventId ? (events.get(one.eventId) ?? null) : null
+    one.__liked = likedIds.has(one.id)
+  }
+  return posts
+}
+
+/** Whether the event's gallery is open. */
+export async function isOpenEvent(eventId: string, domainId: string, tx?: EntityManager): Promise<boolean> {
+  return !!(await getRepository(GalleryEvent, tx).findOne({
+    where: { domain: { id: domainId }, event: { id: eventId } } as any
+  }))
+}
+
+/**
+ * Whether the request's person may post to the event: its gallery is open, or they see the event - they are named on
+ * it or responsible for it, or they read the whole calendar. An event they cannot see takes no photo (판정 1).
+ */
+export async function maySeeEvent(eventId: string, context: any, tx?: EntityManager): Promise<Event | undefined> {
+  const { domain, user } = context.state
+  if (!isId(eventId)) return undefined
+  const event = await getRepository(Event, tx).findOne({ where: { id: eventId, domain: { id: domain.id } } as any })
+  if (!event) return undefined
+  if (event.organizerId === user.id) return event
+  if (await isOpenEvent(eventId, domain.id, tx)) return event
+  if (
+    await getRepository(Attendee, tx).findOne({
+      where: { domain: { id: domain.id }, event: { id: eventId }, user: { id: user.id } } as any
+    })
+  )
+    return event
+  return (await readsCalendar(context)) ? event : undefined
+}
+
+/** The events the person may post to that overlap [from, to): their own, the open ones, and all when they read the calendar. */
+export async function eventsSeenBetween(context: any, from: Date, to: Date, tx?: EntityManager): Promise<Event[]> {
+  const { domain, user } = context.state
+  const qb = getRepository(Event, tx)
+    .createQueryBuilder('E')
+    .where('E.domain = :domain', { domain: domain.id })
+    .andWhere('E.startAt < :to AND E.endAt > :from', { from, to })
+  if (!(await readsCalendar(context))) {
+    const named = await getRepository(Attendee, tx).find({
+      where: { domain: { id: domain.id }, user: { id: user.id } } as any
+    })
+    const open = await getRepository(GalleryEvent, tx).find({ where: { domain: { id: domain.id } } as any })
+    const ids = [...new Set([...named.map(one => one.eventId), ...open.map(one => one.eventId)].filter(Boolean))]
+    qb.andWhere(ids.length ? '(E.organizer = :me OR E.id IN (:...ids))' : 'E.organizer = :me', { me: user.id, ids })
+  }
+  return await qb.orderBy('E.startAt', 'DESC').take(50).getMany()
+}
+
+/** Opens the event's gallery, once. */
+export async function openEvent(eventId: string, context: any, tx: EntityManager): Promise<void> {
+  const { domain, user } = context.state
+  if (await isOpenEvent(eventId, domain.id, tx)) return
+  await getRepository(GalleryEvent, tx).save({ domain, event: { id: eventId }, creator: user, updater: user } as any)
+}
+
+/** The sentences in `lng` from this module's translations, the English one where `lng` has none. */
+const sayIn =
+  (lng: string): Say =>
+  (key, english, params = {}) =>
+    translatorFor(lng)(key, {
+      ...params,
+      defaultValue: english.replace(/\{(\w+)\}/g, (_, name) => String(params[name] ?? ''))
+    })
+
+/** The people to tell, as notification takes them - only those who can sign in. */
+async function receiversOf(userIds: string[], tx?: EntityManager) {
+  if (!userIds.length) return []
+  const people = await getRepository(User, tx).find({ where: { id: In(userIds) } as any })
+  return people
+    .filter(one => one.status === UserStatus.ACTIVATED)
+    .map(one => ({ id: one.id, email: one.email, locale: (one as any).locale }))
+}
+
+function tell(context: any, notice: Omit<Notice, 'link'>): void {
+  sendNoticeWhenCommitted(context, { ...notice, link: noticeLinkOf(context, notice.address) } as Notice)
+}
+
+/**
+ * When the post is the event's first, tells the people named on the event - everyone of the domain when it names
+ * nobody - that its photos are up (decision 6). Once per event: a later post is not the first.
+ */
+export async function tellFirstPhoto(context: any, post: GalleryPost, eventId: string): Promise<void> {
+  const { domain, user, tx } = context.state
+  const others = await getRepository(GalleryPost, tx)
+    .createQueryBuilder('P')
+    .where('P.domain = :domain AND P.event = :event AND P.id != :id', {
+      domain: domain.id,
+      event: eventId,
+      id: post.id
+    })
+    .withDeleted()
+    .getCount()
+  if (others) return
+  const event = await getRepository(Event, tx).findOne({ where: { id: eventId } as any })
+  if (!event) return
+  const attendees = await getRepository(Attendee, tx).find({
+    where: { domain: { id: domain.id }, event: { id: eventId } } as any
+  })
+  const members = attendees.some(one => one.userId) ? [] : (await getDomainAssignees(domain, tx)).map(one => one.id)
+  const receivers = await receiversOf(
+    firstPhotoReceivers(attendees.map(one => one.userId!).filter(Boolean), members, user.id),
+    tx
+  )
+  if (!receivers.length) return
+  tell(context, {
+    type: 'gallery',
+    receivers,
+    words: lng => firstPhotoWords(event, user.name ?? '', post.caption, sayIn(lng)),
+    address: galleryAddressOf({ eventId }),
+    label: `gallery first-photo ${eventId}`,
+    /* Photos are no news for the inbox of another app - the app and push carry it, mail only where the domain turned it on. */
+    channels: { email: false }
+  })
+}
+
+/** Tells the owner that a moderator hid their post, and why (decision 5). */
+export async function tellHidden(context: any, post: GalleryPost, reason: string): Promise<void> {
+  if (!post.creatorId || post.creatorId === context.state.user.id) return
+  const receivers = await receiversOf([post.creatorId], context.state.tx)
+  if (!receivers.length) return
+  tell(context, {
+    type: 'gallery',
+    level: 'warn',
+    receivers,
+    words: lng => hiddenWords(reason, sayIn(lng)),
+    address: galleryAddressOf({ postId: post.id }),
+    label: `gallery hidden ${post.id}`,
+    channels: { email: false }
+  })
+}

package/server/service/gallery/gallery-types.ts

@@ -0,0 +1,151 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { GalleryPost, GallerySpace } from './gallery'
+
+@ObjectType({ description: 'One photo of a gallery post.' })
+export class GalleryPhoto {
+  @Field(type => ID, { description: 'The attachment id of the photo.' })
+  id: string
+
+  @Field({ nullable: true, description: 'The file name.' })
+  name?: string
+
+  @Field({ nullable: true, description: 'A small picture of it, usable as an image source.' })
+  thumbnail?: string
+
+  @Field({ description: 'Where the photo itself is read.' })
+  fullpath: string
+
+  @Field({ nullable: true, description: 'The image type.' })
+  mimetype?: string
+}
+
+/** What everyone of the domain sees of an event a post hangs on - name, time and place, never its people (ADR-0165 사용자 판정 1). */
+@ObjectType({ description: 'The name, time and place of a calendar event - what the gallery shows of it.' })
+export class GalleryEventFacts {
+  @Field(type => ID, { description: 'The calendar event id.' })
+  id: string
+
+  @Field({ description: 'The event name.' })
+  name: string
+
+  @Field({ description: 'When it starts.' })
+  startAt: Date
+
+  @Field({ description: 'When it ends.' })
+  endAt: Date
+
+  @Field({ nullable: true, description: 'Where it takes place.' })
+  location?: string
+}
+
+@ObjectType({ description: 'An event whose gallery is open, with how many posts it holds and the photo shown for it.' })
+export class GalleryEventCard extends GalleryEventFacts {
+  @Field(type => Int, { description: 'How many posts the viewer sees in it.' })
+  postCount: number
+
+  @Field(type => GalleryPhoto, {
+    nullable: true,
+    description: 'The photo shown for it - the first of its most liked post.'
+  })
+  cover?: GalleryPhoto
+}
+
+@ObjectType({ description: 'An event offered for a photo.' })
+export class GalleryEventChoice extends GalleryEventFacts {
+  @Field({ description: 'Whether it is near when the photo was taken.' })
+  near: boolean
+}
+
+@ObjectType({ description: 'A tag and how many posts hold it.' })
+export class GalleryTagCount {
+  @Field({ description: 'The tag, without the # mark.' })
+  tag: string
+
+  @Field(type => Int, { description: 'How many posts hold it.' })
+  count: number
+}
+
+@ObjectType({ description: 'A person, as the gallery names them.' })
+export class GalleryPerson {
+  @Field(type => ID, { description: 'User id.' })
+  id: string
+
+  @Field({ nullable: true, description: 'Their name.' })
+  name?: string
+}
+
+@ObjectType({ description: 'A page of gallery posts.' })
+export class GalleryPostList {
+  @Field(type => [GalleryPost], { description: 'The posts, newest first.' })
+  items: GalleryPost[]
+
+  @Field(type => Int, { description: 'How many posts the narrowing holds.' })
+  total: number
+}
+
+@ObjectType({ description: "What the gallery's menu entry says." })
+export class GallerySummary {
+  @Field(type => Int, { description: 'Posts by others since the person last opened the gallery.' })
+  fresh: number
+}
+
+@ObjectType({ description: 'A like as it stands after the change.' })
+export class GalleryLikeState {
+  @Field(type => ID, { description: 'Post id.' })
+  id: string
+
+  @Field(type => Int, { description: 'How many people like it.' })
+  likeCount: number
+
+  @Field({ description: 'Whether the person likes it.' })
+  liked: boolean
+}
+
+@InputType({ description: 'What a gallery post holds besides its photos.' })
+export class GalleryPostInput {
+  @Field(type => GallerySpace, { nullable: true, description: "The company's gallery (default) or the person's own." })
+  space?: GallerySpace
+
+  @Field({ nullable: true, description: 'A short caption, plain text.' })
+  caption?: string
+
+  @Field({ nullable: true, description: 'When the photos were taken; now when not given.' })
+  takenAt?: Date
+
+  @Field(type => [String], { nullable: true, description: 'The tags; a leading # is dropped.' })
+  tags?: string[]
+
+  @Field({ nullable: true, description: 'The calendar event the photos are of - only in the company gallery.' })
+  eventId?: string
+}
+
+@InputType({ description: 'How a list of gallery posts is narrowed.' })
+export class GalleryFilter {
+  @Field(type => GallerySpace, { nullable: true, description: 'Only this space.' })
+  space?: GallerySpace
+
+  @Field({ nullable: true, description: 'Only the posts of this event.' })
+  eventId?: string
+
+  @Field({ nullable: true, description: 'Only the posts holding this tag.' })
+  tag?: string
+
+  @Field({ nullable: true, description: "Only this person's posts." })
+  authorId?: string
+}
+
+@InputType({ description: 'An event made from the gallery.' })
+export class GalleryEventInput {
+  @Field({ description: 'The event name.' })
+  name: string
+
+  @Field({ description: 'When it starts.' })
+  startAt: Date
+
+  @Field({ description: 'When it ends.' })
+  endAt: Date
+
+  @Field({ nullable: true, description: 'Where it takes place.' })
+  location?: string
+}