nextcloud-workflow-deck-automation/lib/Controller/WorkflowController.php

<?php

declare(strict_types=1);

namespace OCA\WorkflowDeckAutomation\Controller;

use OCA\WorkflowDeckAutomation\Db\Workflow;
use OCA\WorkflowDeckAutomation\Db\WorkflowMapper;
use OCA\WorkflowDeckAutomation\Service\DeckIntegrationService;
use OCA\WorkflowDeckAutomation\Service\DeckUnavailableException;
use OCP\AppFramework\Db\DoesNotExistException;
use OCP\AppFramework\Http;
use OCP\AppFramework\Http\Attribute\NoAdminRequired;
use OCP\AppFramework\Http\DataResponse;
use OCP\AppFramework\OCS\OCSBadRequestException;
use OCP\AppFramework\OCS\OCSNotFoundException;
use OCP\AppFramework\OCS\OCSPreconditionFailedException;
use OCP\AppFramework\OCSController;
use OCP\IRequest;
use OCP\IUserSession;

class WorkflowController extends OCSController {
	public function __construct(
		string $appName,
		IRequest $request,
		private WorkflowMapper $workflowMapper,
		private DeckIntegrationService $deckService,
		private IUserSession $userSession,
	) {
		parent::__construct($appName, $request);
	}

	private function currentUserId(): string {
		$user = $this->userSession->getUser();
		if ($user === null) {
			throw new OCSPreconditionFailedException('Not logged in');
		}
		return $user->getUID();
	}

	/**
	 * Every workflow on a board the user owns, no matter who created it: a
	 * workflow belongs to its board's owner, and follows the board when
	 * Deck transfers it.
	 */
	#[NoAdminRequired]
	public function index(): DataResponse {
		$workflows = $this->workflowMapper->findAllForBoards($this->ownedBoardIds());
		return new DataResponse(array_map(static fn (Workflow $w) => $w->jsonSerialize(), $workflows));
	}

	/**
	 * @param string[] $filterUserIds
	 * @param int[] $filterLabelIds
	 */
	#[NoAdminRequired]
	public function create(
		string $title,
		int $boardId,
		int $sourceStackId,
		int $targetStackId,
		array $filterUserIds = [],
		array $filterLabelIds = [],
		bool $notifyEmail = false,
		bool $enabled = true,
	): DataResponse {
		$this->validate($title, $boardId, $sourceStackId, $targetStackId);

		$workflow = new Workflow();
		$workflow->setUserId($this->currentUserId());
		$this->applyFields($workflow, $title, $boardId, $sourceStackId, $targetStackId, $filterUserIds, $filterLabelIds, $notifyEmail, $enabled);

		$workflow = $this->workflowMapper->insert($workflow);
		return new DataResponse($workflow->jsonSerialize(), Http::STATUS_CREATED);
	}

	/**
	 * @param string[] $filterUserIds
	 * @param int[] $filterLabelIds
	 */
	#[NoAdminRequired]
	public function update(
		int $id,
		string $title,
		int $boardId,
		int $sourceStackId,
		int $targetStackId,
		array $filterUserIds = [],
		array $filterLabelIds = [],
		bool $notifyEmail = false,
		bool $enabled = true,
	): DataResponse {
		$workflow = $this->findOwnWorkflow($id);
		$this->validate($title, $boardId, $sourceStackId, $targetStackId);

		// Kept in step with the board owner so the job runs as, and mails,
		// the right user; validate() made sure the editor owns the board.
		$workflow->setUserId($this->currentUserId());
		$this->applyFields($workflow, $title, $boardId, $sourceStackId, $targetStackId, $filterUserIds, $filterLabelIds, $notifyEmail, $enabled);
		$workflow = $this->workflowMapper->update($workflow);

		return new DataResponse($workflow->jsonSerialize());
	}

	#[NoAdminRequired]
	public function destroy(int $id): DataResponse {
		$workflow = $this->findOwnWorkflow($id);
		$this->workflowMapper->delete($workflow);
		return new DataResponse([]);
	}

	#[NoAdminRequired]
	public function boards(): DataResponse {
		$this->assertDeck();
		return new DataResponse($this->ownedBoards());
	}

	#[NoAdminRequired]
	public function stacks(int $boardId): DataResponse {
		$this->assertDeck();
		return new DataResponse($this->deckService->listStacks($boardId));
	}

	#[NoAdminRequired]
	public function labels(int $boardId): DataResponse {
		$this->assertDeck();
		return new DataResponse($this->deckService->listLabels($boardId));
	}

	#[NoAdminRequired]
	public function participants(int $boardId): DataResponse {
		$this->assertDeck();
		return new DataResponse($this->deckService->listParticipants($boardId));
	}

	private function findOwnWorkflow(int $id): Workflow {
		try {
			$workflow = $this->workflowMapper->findById($id);
		} catch (DoesNotExistException $e) {
			throw new OCSNotFoundException('Workflow not found');
		}

		if (!in_array($workflow->getBoardId(), $this->ownedBoardIds(), true)) {
			// Same answer as for a missing id: don't reveal other users' workflows.
			throw new OCSNotFoundException('Workflow not found');
		}
		return $workflow;
	}

	/**
	 * @return array<int, array{id: int, title: string, archived: bool}>
	 */
	private function ownedBoards(): array {
		$userId = $this->currentUserId();
		$this->assertDeck();
		try {
			return $this->deckService->listOwnedBoards($userId);
		} catch (DeckUnavailableException $e) {
			throw new OCSPreconditionFailedException('Could not load your Deck boards: ' . $e->getMessage());
		}
	}

	/**
	 * @return int[]
	 */
	private function ownedBoardIds(): array {
		return array_map(static fn (array $board) => $board['id'], $this->ownedBoards());
	}

	private function assertDeck(): void {
		$user = $this->userSession->getUser();
		if ($user === null) {
			throw new OCSPreconditionFailedException('Not logged in');
		}
		try {
			$this->deckService->assertDeckAvailable($user);
		} catch (DeckUnavailableException $e) {
			throw new OCSPreconditionFailedException('Deck is not available: ' . $e->getMessage());
		}
	}

	private function validate(string $title, int $boardId, int $sourceStackId, int $targetStackId): void {
		if (trim($title) === '') {
			throw new OCSBadRequestException('Title must not be empty');
		}
		if ($sourceStackId === $targetStackId) {
			throw new OCSBadRequestException('Source and target stack must differ');
		}

		// Reject references to boards or stacks that are gone (or were never
		// the user's) instead of storing a workflow that can only fail later.
		// assertDeck() ran first, so an empty list here means "not there",
		// not "Deck is unreachable".
		$this->assertDeck();

		// Only boards the user owns are listed, so this also enforces the
		// owner rule. Archived boards stay listed (their workflows must stay
		// visible) but are no target for a new or changed workflow.
		$board = null;
		foreach ($this->ownedBoards() as $candidate) {
			if ($candidate['id'] === $boardId) {
				$board = $candidate;
				break;
			}
		}
		if ($board === null || $board['archived']) {
			throw new OCSBadRequestException('The selected board does not exist, is archived or is not owned by you');
		}

		$stackIds = array_map(
			static fn (array $stack) => (int)$stack['id'],
			$this->deckService->listStacks($boardId),
		);
		if (!in_array($sourceStackId, $stackIds, true) || !in_array($targetStackId, $stackIds, true)) {
			throw new OCSBadRequestException('The selected stack does not exist on this board');
		}
	}

	/**
	 * @param string[] $filterUserIds
	 * @param int[] $filterLabelIds
	 */
	private function applyFields(
		Workflow $workflow,
		string $title,
		int $boardId,
		int $sourceStackId,
		int $targetStackId,
		array $filterUserIds,
		array $filterLabelIds,
		bool $notifyEmail,
		bool $enabled,
	): void {
		$workflow->setTitle($title);
		$workflow->setBoardId($boardId);
		$workflow->setSourceStackId($sourceStackId);
		$workflow->setTargetStackId($targetStackId);
		$workflow->setFilterUserIds($filterUserIds === [] ? null : json_encode(array_values($filterUserIds)));
		$workflow->setFilterLabelIds($filterLabelIds === [] ? null : json_encode(array_values($filterLabelIds)));
		$workflow->setNotifyEmail($notifyEmail);
		$workflow->setEnabled($enabled);
	}
}