Add fields to Report entity

- Add clock dependency to Moderation\Factory\Report
- Change DateTime field to DateTimeImmutable to satisfy Clock return type
- Add category, status and resolution constants

.gitignore

@@ -19,7 +19,7 @@ robots.txt
 /doc/cache
 
 #ignore reports, should be generated with every build
-report/
+/report/
 
 #ignore config files from eclipse, we don't want IDE files in our repository
 .project

database.sql

@@ -1695,19 +1695,33 @@ CREATE TABLE IF NOT EXISTS `report` (
 	`uid` mediumint unsigned COMMENT 'Reporting user',
 	`reporter-id` int unsigned COMMENT 'Reporting contact',
 	`cid` int unsigned NOT NULL COMMENT 'Reported contact',
+	`gsid` int unsigned NOT NULL COMMENT 'Reported contact server',
 	`comment` text COMMENT 'Report',
-	`category` varchar(20) COMMENT 'Category of the report (spam, violation, other)',
+	`category-id` int unsigned NOT NULL DEFAULT 1 COMMENT 'Report category, one of Entity\Report::CATEGORY_*',
-	`rules` text COMMENT 'Violated rules',
 	`forward` boolean COMMENT 'Forward the report to the remote server',
-	`created` datetime NOT NULL DEFAULT '0001-01-01 00:00:00' COMMENT '',
+	`public-remarks` text COMMENT 'Remarks shared with the reporter',
-	`status` tinyint unsigned COMMENT 'Status of the report',
+	`private-remarks` text COMMENT 'Remarks shared with the moderation team',
+	`last-editor-uid` mediumint unsigned COMMENT 'Last editor user',
+	`assigned-uid` mediumint unsigned COMMENT 'Assigned moderator user',
+	`status` tinyint unsigned NOT NULL COMMENT 'Status of the report, one of Entity\Report::STATUS_*',
+	`resolution` tinyint unsigned COMMENT 'Resolution of the report, one of Entity\Report::RESOLUTION_*',
+	`created` datetime(6) NOT NULL DEFAULT '0001-01-01 00:00:00' COMMENT '',
+	`edited` datetime(6) COMMENT 'Last time the report has been edited',
 	 PRIMARY KEY(`id`),
 	 INDEX `uid` (`uid`),
 	 INDEX `cid` (`cid`),
 	 INDEX `reporter-id` (`reporter-id`),
+	 INDEX `gsid` (`gsid`),
+	 INDEX `assigned-uid` (`assigned-uid`),
+	 INDEX `status-resolution` (`status`,`resolution`),
+	 INDEX `created` (`created`),
+	 INDEX `edited` (`edited`),
 	FOREIGN KEY (`uid`) REFERENCES `user` (`uid`) ON UPDATE RESTRICT ON DELETE CASCADE,
 	FOREIGN KEY (`reporter-id`) REFERENCES `contact` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE,
-	FOREIGN KEY (`cid`) REFERENCES `contact` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE
+	FOREIGN KEY (`cid`) REFERENCES `contact` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE,
+	FOREIGN KEY (`gsid`) REFERENCES `gserver` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE,
+	FOREIGN KEY (`last-editor-uid`) REFERENCES `user` (`uid`) ON UPDATE RESTRICT ON DELETE CASCADE,
+	FOREIGN KEY (`assigned-uid`) REFERENCES `user` (`uid`) ON UPDATE RESTRICT ON DELETE CASCADE
 ) DEFAULT COLLATE utf8mb4_general_ci COMMENT='';
 
 --
@@ -1721,7 +1735,18 @@ CREATE TABLE IF NOT EXISTS `report-post` (
 	 INDEX `uri-id` (`uri-id`),
 	FOREIGN KEY (`rid`) REFERENCES `report` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE,
 	FOREIGN KEY (`uri-id`) REFERENCES `item-uri` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE
-) DEFAULT COLLATE utf8mb4_general_ci COMMENT='';
+) DEFAULT COLLATE utf8mb4_general_ci COMMENT='Individual posts attached to a moderation report';
+
+--
+-- TABLE report-rule
+--
+CREATE TABLE IF NOT EXISTS `report-rule` (
+	`rid` int unsigned NOT NULL COMMENT 'Report id',
+	`line-id` int unsigned NOT NULL COMMENT 'Terms of service rule line number, may become invalid after a TOS change.',
+	`text` text NOT NULL COMMENT 'Terms of service rule text recorded at the time of the report',
+	 PRIMARY KEY(`rid`,`line-id`),
+	FOREIGN KEY (`rid`) REFERENCES `report` (`id`) ON UPDATE RESTRICT ON DELETE CASCADE
+) DEFAULT COLLATE utf8mb4_general_ci COMMENT='Terms of service rule lines relevant to a moderation report';
 
 --
 -- TABLE search

doc/database.md

@@ -77,7 +77,8 @@ Database Tables
 | [push_subscriber](help/database/db_push_subscriber) | Used for OStatus: Contains feed subscribers |
 | [register](help/database/db_register) | registrations requiring admin approval |
 | [report](help/database/db_report) |  |
-| [report-post](help/database/db_report-post) |  |
+| [report-post](help/database/db_report-post) | Individual posts attached to a moderation report |
+| [report-rule](help/database/db_report-rule) | Terms of service rule lines relevant to a moderation report |
 | [search](help/database/db_search) |  |
 | [session](help/database/db_session) | web session storage |
 | [storage](help/database/db_storage) | Data stored by Database storage backend |

doc/database/db_report-post.md

@@ -1,7 +1,7 @@
 Table report-post
 ===========
 
-
+Individual posts attached to a moderation report
 
 Fields
 ------

doc/database/db_report-rule.md

@@ -0,0 +1,29 @@
+Table report-rule
+===========
+
+Terms of service rule lines relevant to a moderation report
+
+Fields
+------
+
+| Field   | Description                                                               | Type         | Null | Key | Default | Extra |
+| ------- | ------------------------------------------------------------------------- | ------------ | ---- | --- | ------- | ----- |
+| rid     | Report id                                                                 | int unsigned | NO   | PRI | NULL    |       |
+| line-id | Terms of service rule line number, may become invalid after a TOS change. | int unsigned | NO   | PRI | NULL    |       |
+| text    | Terms of service rule text recorded at the time of the report             | text         | NO   |     | NULL    |       |
+
+Indexes
+------------
+
+| Name    | Fields       |
+| ------- | ------------ |
+| PRIMARY | rid, line-id |
+
+Foreign Keys
+------------
+
+| Field | Target Table | Target Field |
+|-------|--------------|--------------|
+| rid | [report](help/database/db_report) | id |
+
+Return to [database documentation](help/database)

doc/database/db_report.md

@@ -6,28 +6,39 @@ Table report
 Fields
 ------
 
-| Field       | Description                                     | Type               | Null | Key | Default             | Extra          |
+| Field           | Description                                                  | Type               | Null | Key | Default             | Extra          |
-| ----------- | ----------------------------------------------- | ------------------ | ---- | --- | ------------------- | -------------- |
+| --------------- | ------------------------------------------------------------ | ------------------ | ---- | --- | ------------------- | -------------- |
-| id          | sequential ID                                   | int unsigned       | NO   | PRI | NULL                | auto_increment |
+| id              | sequential ID                                                | int unsigned       | NO   | PRI | NULL                | auto_increment |
-| uid         | Reporting user                                  | mediumint unsigned | YES  |     | NULL                |                |
+| uid             | Reporting user                                               | mediumint unsigned | YES  |     | NULL                |                |
-| reporter-id | Reporting contact                               | int unsigned       | YES  |     | NULL                |                |
+| reporter-id     | Reporting contact                                            | int unsigned       | YES  |     | NULL                |                |
-| cid         | Reported contact                                | int unsigned       | NO   |     | NULL                |                |
+| cid             | Reported contact                                             | int unsigned       | NO   |     | NULL                |                |
-| comment     | Report                                          | text               | YES  |     | NULL                |                |
+| gsid            | Reported contact server                                      | int unsigned       | NO   |     | NULL                |                |
-| category    | Category of the report (spam, violation, other) | varchar(20)        | YES  |     | NULL                |                |
+| comment         | Report                                                       | text               | YES  |     | NULL                |                |
-| rules       | Violated rules                                  | text               | YES  |     | NULL                |                |
+| category-id     | Report category, one of Entity\Report::CATEGORY_*            | int unsigned       | NO   |     | 1                   |                |
-| forward     | Forward the report to the remote server         | boolean            | YES  |     | NULL                |                |
+| forward         | Forward the report to the remote server                      | boolean            | YES  |     | NULL                |                |
-| created     |                                                 | datetime           | NO   |     | 0001-01-01 00:00:00 |                |
+| public-remarks  | Remarks shared with the reporter                             | text               | YES  |     | NULL                |                |
-| status      | Status of the report                            | tinyint unsigned   | YES  |     | NULL                |                |
+| private-remarks | Remarks shared with the moderation team                      | text               | YES  |     | NULL                |                |
+| last-editor-uid | Last editor user                                             | mediumint unsigned | YES  |     | NULL                |                |
+| assigned-uid    | Assigned moderator user                                      | mediumint unsigned | YES  |     | NULL                |                |
+| status          | Status of the report, one of Entity\Report::STATUS_*         | tinyint unsigned   | NO   |     | NULL                |                |
+| resolution      | Resolution of the report, one of Entity\Report::RESOLUTION_* | tinyint unsigned   | YES  |     | NULL                |                |
+| created         |                                                              | datetime(6)        | NO   |     | 0001-01-01 00:00:00 |                |
+| edited          | Last time the report has been edited                         | datetime(6)        | YES  |     | NULL                |                |
 
 Indexes
 ------------
 
-| Name        | Fields      |
+| Name              | Fields             |
-| ----------- | ----------- |
+| ----------------- | ------------------ |
-| PRIMARY     | id          |
+| PRIMARY           | id                 |
-| uid         | uid         |
+| uid               | uid                |
-| cid         | cid         |
+| cid               | cid                |
-| reporter-id | reporter-id |
+| reporter-id       | reporter-id        |
+| gsid              | gsid               |
+| assigned-uid      | assigned-uid       |
+| status-resolution | status, resolution |
+| created           | created            |
+| edited            | edited             |
 
 Foreign Keys
 ------------
@@ -37,5 +48,8 @@ Foreign Keys
 | uid | [user](help/database/db_user) | uid |
 | reporter-id | [contact](help/database/db_contact) | id |
 | cid | [contact](help/database/db_contact) | id |
+| gsid | [gserver](help/database/db_gserver) | id |
+| last-editor-uid | [user](help/database/db_user) | uid |
+| assigned-uid | [user](help/database/db_user) | uid |
 
 Return to [database documentation](help/database)

src/Moderation/Entity/Report.php

@@ -21,51 +21,126 @@
 
 namespace Friendica\Moderation\Entity;
 
+use Friendica\Moderation\Collection;
+
 /**
- * @property-read int            $id
+ * @property-read int                     $id
- * @property-read int            $reporterId
+ * @property-read int                     $reporterCid
- * @property-read int            $cid
+ * @property-read int                     $cid
- * @property-read string         $comment
+ * @property-read int                     $gsid
- * @property-read string|null    $category
+ * @property-read string                  $comment
- * @property-read bool           $forward
+ * @property-read string                  $publicRemarks
- * @property-read array          $postUriIds
+ * @property-read string                  $privateRemarks
- * @property-read int            $uid
+ * @property-read bool                    $forward
- * @property-read \DateTime|null $created
+ * @property-read int                     $category
+ * @property-read int                     $status
+ * @property-read int|null                $resolution
+ * @property-read int                     $reporterUid
+ * @property-read int|null                $lastEditorUid
+ * @property-read int|null                $assignedUid
+ * @property-read \DateTimeImmutable      $created
+ * @property-read \DateTimeImmutable|null $edited
+ * @property-read Collection\Report\Posts $posts
+ * @property-read Collection\Report\Rules $rules
  */
-class Report extends \Friendica\BaseEntity
+final class Report extends \Friendica\BaseEntity
 {
+	const CATEGORY_OTHER = 1;
+	const CATEGORY_SPAM = 2;
+	const CATEGORY_ILLEGAL = 4;
+	const CATEGORY_SAFETY = 8;
+	const CATEGORY_UNWANTED = 16;
+	const CATEGORY_VIOLATION = 32;
+
+	const CATEGORIES  = [
+		self::CATEGORY_OTHER,
+		self::CATEGORY_SPAM,
+		self::CATEGORY_ILLEGAL,
+		self::CATEGORY_SAFETY,
+		self::CATEGORY_UNWANTED,
+		self::CATEGORY_VIOLATION,
+	];
+
+	const STATUS_CLOSED = 0;
+	const STATUS_OPEN = 1;
+
+	const RESOLUTION_ACCEPTED = 0;
+	const RESOLUTION_REJECTED = 1;
+
 	/** @var int|null */
 	protected $id;
-	/** @var int ID of the contact making a moderation report*/
+	/** @var int ID of the contact making a moderation report */
-	protected $reporterId;
+	protected $reporterCid;
-	/** @var int ID of the contact being reported*/
+	/** @var int ID of the contact being reported */
 	protected $cid;
-	/** @var string Optional comment */
+	/** @var int ID of the gserver of the contact being reported */
+	protected $gsid;
+	/** @var string Reporter comment */
 	protected $comment;
-	/** @var string Optional category */
+	/** @var int One of CATEGORY_* */
 	protected $category;
-	/** @var string Violated rules */
+	/** @var int ID of the user making a moderation report, null in case of an incoming forwarded report */
-	protected $rules;
+	protected $reporterUid;
 	/** @var bool Whether this report should be forwarded to the remote server */
 	protected $forward;
-	/** @var \DateTime|null When the report was created */
+	/** @var \DateTimeImmutable When the report was created */
 	protected $created;
-	/** @var array Optional list of URI IDs of posts supporting the report*/
+	/** @var Collection\Report\Rules List of terms of service rule lines being possibly violated */
-	protected $postUriIds;
+	protected $rules;
-	/** @var int ID of the user making a moderation report*/
+	/** @var Collection\Report\Posts List of URI IDs of posts supporting the report */
-	protected $uid;
+	protected $posts;
+	/** @var string Remarks shared with the reporter */
+	protected $publicRemarks;
+	/** @var string Remarks shared with the moderation team */
+	protected $privateRemarks;
+	/** @var \DateTimeImmutable|null When the report was last edited */
+	protected $edited;
+	/** @var int One of STATUS_* */
+	protected $status;
+	/** @var int|null One of RESOLUTION_* if any */
+	protected $resolution;
+	/** @var int|null Assigned moderator user id if any */
+	protected $assignedUid;
+	/** @var int|null Last editor user ID if any */
+	protected $lastEditorUid;
 
-	public function __construct(int $reporterId, int $cid, \DateTime $created, string $comment = '', string $category = null, string $rules = '', bool $forward = false, array $postUriIds = [], int $uid = null, int $id = null)
+	public function __construct(
-	{
+		int $reporterCid,
-		$this->reporterId = $reporterId;
+		int $cid,
-		$this->cid        = $cid;
+		int $gsid,
-		$this->created    = $created;
+		\DateTimeImmutable $created,
-		$this->comment    = $comment;
+		int $category,
-		$this->category   = $category;
+		int $reporterUid = null,
-		$this->rules      = $rules;
+		string $comment = '',
-		$this->forward    = $forward;
+		bool $forward = false,
-		$this->postUriIds = $postUriIds;
+		Collection\Report\Posts $posts = null,
-		$this->uid        = $uid;
+		Collection\Report\Rules $rules = null,
-		$this->id         = $id;
+		string $publicRemarks = '',
+		string $privateRemarks = '',
+		\DateTimeImmutable $edited = null,
+		int $status = self::STATUS_OPEN,
+		int $resolution = null,
+		int $assignedUid = null,
+		int $lastEditorUid = null,
+		int $id = null
+	) {
+		$this->reporterCid    = $reporterCid;
+		$this->cid            = $cid;
+		$this->gsid           = $gsid;
+		$this->created        = $created;
+		$this->category       = $category;
+		$this->reporterUid    = $reporterUid;
+		$this->comment        = $comment;
+		$this->forward        = $forward;
+		$this->posts          = $posts ?? new Collection\Report\Posts();
+		$this->rules          = $rules ?? new Collection\Report\Rules();
+		$this->publicRemarks  = $publicRemarks;
+		$this->privateRemarks = $privateRemarks;
+		$this->edited         = $edited;
+		$this->status         = $status;
+		$this->resolution     = $resolution;
+		$this->assignedUid    = $assignedUid;
+		$this->lastEditorUid  = $lastEditorUid;
+		$this->id             = $id;
 	}
 }

src/Moderation/Factory/Report.php

@@ -22,28 +22,51 @@
 namespace Friendica\Moderation\Factory;
 
 use Friendica\Capabilities\ICanCreateFromTableRow;
+use Friendica\Core\System;
+use Friendica\Moderation\Collection;
 use Friendica\Moderation\Entity;
+use Psr\Clock\ClockInterface;
+use Psr\Log\LoggerInterface;
 
 class Report extends \Friendica\BaseFactory implements ICanCreateFromTableRow
 {
+	/** @var ClockInterface */
+	private $clock;
+
+	public function __construct(LoggerInterface $logger, ClockInterface $clock)
+	{
+		parent::__construct($logger);
+
+		$this->clock = $clock;
+	}
+
 	/**
-	 * @param array $row        `report` table row
+	 * @param array                        $row   `report` table row
-	 * @param array $postUriIds List of post URI ids from the `report-post` table
+	 * @param Collection\Report\Posts|null $posts List of posts attached to the report
+	 * @param Collection\Report\Rules|null $rules List of rules from the terms of service, see System::getRules()
 	 * @return Entity\Report
 	 * @throws \Exception
 	 */
-	public function createFromTableRow(array $row, array $postUriIds = []): Entity\Report
+	public function createFromTableRow(array $row, Collection\Report\Posts $posts = null, Collection\Report\Rules $rules = null): Entity\Report
 	{
 		return new Entity\Report(
 			$row['reporter-id'],
 			$row['cid'],
-			new \DateTime($row['created'] ?? 'now', new \DateTimeZone('UTC')),
+			$row['gsid'],
-			$row['comment'],
+			new \DateTimeImmutable($row['created'], new \DateTimeZone('UTC')),
-			$row['category'],
+			$row['category-id'],
-			$row['rules'],
-			$row['forward'],
-			$postUriIds,
 			$row['uid'],
+			$row['comment'],
+			$row['forward'],
+			$posts ?? new Collection\Report\Posts(),
+			$rules ?? new Collection\Report\Rules(),
+			$row['public-remarks'],
+			$row['private-remarks'],
+			$row['edited'] ? new \DateTimeImmutable($row['edited'], new \DateTimeZone('UTC')) : null,
+			$row['status'],
+			$row['resolution'],
+			$row['assigned-uid'],
+			$row['last-editor-uid'],
 			$row['id'],
 		);
 	}
@@ -51,29 +74,44 @@ class Report extends \Friendica\BaseFactory implements ICanCreateFromTableRow
 	/**
 	 * Creates a Report entity from a Mastodon API /reports request
 	 *
-	 * @see \Friendica\Module\Api\Mastodon\Reports::post()
+	 * @param array  $rules      Line-number indexed node rules array, see System::getRules(true)
-	 *
-	 * @param int    $uid
 	 * @param int    $reporterId
 	 * @param int    $cid
+	 * @param int    $gsid
 	 * @param string $comment
+	 * @param string $category
 	 * @param bool   $forward
 	 * @param array  $postUriIds
+	 * @param array  $ruleIds
+	 * @param ?int   $uid
 	 * @return Entity\Report
-	 * @throws \Exception
+	 * @see \Friendica\Module\Api\Mastodon\Reports::post()
 	 */
-	public function createFromReportsRequest(int $reporterId, int $cid, string $comment = '', string $category = null, string $rules = '', bool $forward = false, array $postUriIds = [], int $uid = null): Entity\Report
+	public function createFromReportsRequest(array $rules, int $reporterId, int $cid, int $gsid, string $comment = '', string $category = '', bool $forward = false, array $postUriIds = [], array $ruleIds = [], int $uid = null): Entity\Report
 	{
+		if (count($ruleIds)) {
+			$categoryId = Entity\Report::CATEGORY_VIOLATION;
+		} elseif ($category == 'spam') {
+			$categoryId = Entity\Report::CATEGORY_SPAM;
+		} else {
+			$categoryId = Entity\Report::CATEGORY_OTHER;
+		}
+
 		return new Entity\Report(
 			$reporterId,
 			$cid,
-			new \DateTime('now', new \DateTimeZone('UTC')),
+			$gsid,
-			$comment,
+			$this->clock->now(),
-			$category,
+			$categoryId,
-			$rules,
-			$forward,
-			$postUriIds,
 			$uid,
+			$comment,
+			$forward,
+			new Collection\Report\Posts(array_map(function ($uriId) {
+				return new Entity\Report\Post($uriId);
+			}, $postUriIds)),
+			new Collection\Report\Rules(array_map(function ($lineId) use ($rules) {
+				return new Entity\Report\Rule($lineId, $rules[$lineId] ?? '');
+			}, $ruleIds)),
 		);
 	}
 }

src/Moderation/Repository/Report.php

@@ -25,24 +25,30 @@ use Friendica\BaseEntity;
 use Friendica\Core\Logger;
 use Friendica\Database\Database;
 use Friendica\Model\Post;
+use Friendica\Moderation\Factory;
+use Friendica\Moderation\Collection;
 use Friendica\Network\HTTPException\NotFoundException;
 use Friendica\Util\DateTimeFormat;
 use Psr\Log\LoggerInterface;
 
-class Report extends \Friendica\BaseRepository
+final class Report extends \Friendica\BaseRepository
 {
 	protected static $table_name = 'report';
 
-	/**
+	/** @var Factory\Report */
-	 * @var \Friendica\Moderation\Factory\Report
-	 */
 	protected $factory;
+	/** @var Factory\Report\Post */
+	protected $postFactory;
+	/** @var Factory\Report\Rule */
+	protected $ruleFactory;
 
-	public function __construct(Database $database, LoggerInterface $logger, \Friendica\Moderation\Factory\Report $factory)
+	public function __construct(Database $database, LoggerInterface $logger, Factory\Report $factory, Factory\Report\Post $postFactory, Factory\Report\Rule $ruleFactory)
 	{
 		parent::__construct($database, $logger, $factory);
 
-		$this->factory = $factory;
+		$this->factory     = $factory;
+		$this->postFactory = $postFactory;
+		$this->ruleFactory = $postFactory;
 	}
 
 	public function selectOneById(int $lastInsertId): \Friendica\Moderation\Entity\Report
@@ -53,34 +59,43 @@ class Report extends \Friendica\BaseRepository
 	public function save(\Friendica\Moderation\Entity\Report $Report)
 	{
 		$fields = [
-			'uid'         => $Report->uid,
+			'reporter-id'     => $Report->reporterCid,
-			'reporter-id' => $Report->reporterId,
+			'uid'             => $Report->reporterUid,
-			'cid'         => $Report->cid,
+			'cid'             => $Report->cid,
-			'comment'     => $Report->comment,
+			'gsid'            => $Report->gsid,
-			'category'    => $Report->category,
+			'comment'         => $Report->comment,
-			'rules'       => $Report->rules,
+			'forward'         => $Report->forward,
-			'forward'     => $Report->forward,
+			'category-id'     => $Report->category,
+			'public-remarks'  => $Report->publicRemarks,
+			'private-remarks' => $Report->privateRemarks,
+			'last-editor-uid' => $Report->lastEditorUid,
+			'assigned-uid'    => $Report->assignedUid,
+			'status'          => $Report->status,
+			'resolution'      => $Report->resolution,
+			'created'         => $Report->created->format(DateTimeFormat::MYSQL),
+			'edited'          => $Report->edited ? $Report->edited->format(DateTimeFormat::MYSQL) : null,
 		];
 
-		$postUriIds = $Report->postUriIds;
-
 		if ($Report->id) {
 			$this->db->update(self::$table_name, $fields, ['id' => $Report->id]);
 		} else {
-			$fields['created'] = DateTimeFormat::utcNow();
 			$this->db->insert(self::$table_name, $fields, Database::INSERT_IGNORE);
 
-			$Report = $this->selectOneById($this->db->lastInsertId());
+			$newReportId = $this->db->lastInsertId();
-		}
 
-		$this->db->delete('report-post', ['rid' => $Report->id]);
+			foreach ($Report->posts as $post) {
-
+				if (Post::exists(['uri-id' => $post->uriId])) {
-		foreach ($postUriIds as $uriId) {
+					$this->db->insert('report-post', ['rid' => $newReportId, 'uri-id' => $post->uriId, 'status' => $post->status]);
-			if (Post::exists(['uri-id' => $uriId])) {
+				} else {
-				$this->db->insert('report-post', ['rid' => $Report->id, 'uri-id' => $uriId]);
+					Logger::notice('Post does not exist', ['uri-id' => $post->uriId, 'report' => $Report]);
-			} else {
+				}
-				Logger::notice('Post does not exist', ['uri-id' => $uriId, 'report' => $Report]);
 			}
+
+			foreach ($Report->rules as $rule) {
+				$this->db->insert('report-rule', ['rid' => $newReportId, 'line-id' => $rule->lineId, 'text' => $rule->text]);
+			}
+
+			$Report = $this->selectOneById($this->db->lastInsertId());
 		}
 
 		return $Report;
@@ -88,13 +103,14 @@ class Report extends \Friendica\BaseRepository
 
 	protected function _selectOne(array $condition, array $params = []): BaseEntity
 	{
-		$fields = $this->db->selectFirst(static::$table_name, [], $condition, $params);
+		$fields = $this->db->selectFirst(self::$table_name, [], $condition, $params);
 		if (!$this->db->isResult($fields)) {
 			throw new NotFoundException();
 		}
 
-		$postUriIds = array_column($this->db->selectToArray('report-post', ['uri-id'], ['rid' => $condition['id'] ?? 0]), 'uri-id');
+		$reportPosts = new Collection\Report\Posts(array_map([$this->postFactory, 'createFromTableRow'], $this->db->selectToArray('report-post', ['uri-id', 'status'], ['rid' => $condition['id'] ?? 0])));
+		$reportRules = new Collection\Report\Rules(array_map([$this->ruleFactory, 'createFromTableRow'], $this->db->selectToArray('report-rule', ['line-id', 'line-text'], ['rid' => $condition['id'] ?? 0])));
 
-		return $this->factory->createFromTableRow($fields, $postUriIds);
+		return $this->factory->createFromTableRow($fields, $reportPosts, $reportRules);
 	}
 }

src/Module/Api/Mastodon/Reports.php

@@ -62,21 +62,23 @@ class Reports extends BaseApi
 			'forward'    => false,   // If the account is remote, should the report be forwarded to the remote admin?
 		], $request);
 
-		$contact = Contact::getById($request['account_id'], ['id']);
+		$contact = Contact::getById($request['account_id'], ['id', 'gsid']);
 		if (empty($contact)) {
 			throw new HTTPException\NotFoundException('Account ' . $request['account_id'] . ' not found');
 		}
 
-		$violation = '';
+		$report = $this->reportFactory->createFromReportsRequest(
-		$rules     = System::getRules(true);
+			System::getRules(),
-
+			Contact::getPublicIdByUserId(self::getCurrentUserID()),
-		foreach ($request['rule_ids'] as $key) {
+			$contact['id'],
-			if (!empty($rules[$key])) {
+			$contact['gsid'],
-				$violation .= $rules[$key] . "\n";
+			$request['comment'],
-			}
+			$request['category'],
-		}
+			$request['forward'],
-
+			$request['status_ids'],
-		$report = $this->reportFactory->createFromReportsRequest(Contact::getPublicIdByUserId(self::getCurrentUserID()), $request['account_id'], $request['comment'], $request['category'], trim($violation), $request['forward'], $request['status_ids'], self::getCurrentUserID());
+			$request['rule_ids'],
+			self::getCurrentUserID()
+		);
 
 		$this->reportRepo->save($report);
 

src/Protocol/ActivityPub/Processor.php

@@ -42,6 +42,7 @@ use Friendica\Model\Mail;
 use Friendica\Model\Tag;
 use Friendica\Model\User;
 use Friendica\Model\Post;
+use Friendica\Moderation\Entity\Report;
 use Friendica\Protocol\Activity;
 use Friendica\Protocol\ActivityPub;
 use Friendica\Protocol\Delivery;
@@ -1893,8 +1894,8 @@ class Processor
 	 */
 	public static function ReportAccount(array $activity)
 	{
-		$account_id = Contact::getIdForURL($activity['object_id']);
+		$account = Contact::getByURL($activity['object_id'], null, ['id', 'gsid']);
-		if (empty($account_id)) {
+		if (empty($account)) {
 			Logger::info('Unknown account', ['activity' => $activity]);
 			Queue::remove($activity);
 			return;
@@ -1915,10 +1916,10 @@ class Processor
 			}
 		}
 
-		$report = DI::reportFactory()->createFromReportsRequest($reporter_id, $account_id, $activity['content'], null, '', false, $uri_ids);
+		$report = DI::reportFactory()->createFromReportsRequest(System::getRules(true), $reporter_id, $account['id'], $account['gsid'], $activity['content'], 'other', false, $uri_ids);
 		DI::report()->save($report);
 
-		Logger::info('Stored report', ['reporter' => $reporter_id, 'account_id' => $account_id, 'comment' => $activity['content'], 'object_ids' => $activity['object_ids']]);
+		Logger::info('Stored report', ['reporter' => $reporter_id, 'account' => $account, 'comment' => $activity['content'], 'object_ids' => $activity['object_ids']]);
 	}
 
 	/**

static/dbstructure.config.php

@@ -1691,22 +1691,33 @@ return [
 			"uid" => ["type" => "mediumint unsigned", "foreign" => ["user" => "uid"], "comment" => "Reporting user"],
 			"reporter-id" => ["type" => "int unsigned", "foreign" => ["contact" => "id"], "comment" => "Reporting contact"],
 			"cid" => ["type" => "int unsigned", "not null" => "1", "foreign" => ["contact" => "id"], "comment" => "Reported contact"],
+			"gsid" => ["type" => "int unsigned", "not null" => "1", "foreign" => ["gserver" => "id"], "comment" => "Reported contact server"],
 			"comment" => ["type" => "text", "comment" => "Report"],
-			"category" => ["type" => "varchar(20)", "comment" => "Category of the report (spam, violation, other)"],
+			"category-id" => ["type" => "int unsigned", "not null" => 1, "default" => \Friendica\Moderation\Entity\Report::CATEGORY_OTHER, "comment" => "Report category, one of Entity\Report::CATEGORY_*"],
-			"rules" => ["type" => "text", "comment" => "Violated rules"],
 			"forward" => ["type" => "boolean", "comment" => "Forward the report to the remote server"],
-			"created" => ["type" => "datetime", "not null" => "1", "default" => DBA::NULL_DATETIME, "comment" => ""],
+			"public-remarks" => ["type" => "text", "comment" => "Remarks shared with the reporter"],
-			"status" => ["type" => "tinyint unsigned", "comment" => "Status of the report"],
+			"private-remarks" => ["type" => "text", "comment" => "Remarks shared with the moderation team"],
+			"last-editor-uid" => ["type" => "mediumint unsigned", "foreign" => ["user" => "uid"], "comment" => "Last editor user"],
+			"assigned-uid" => ["type" => "mediumint unsigned", "foreign" => ["user" => "uid"], "comment" => "Assigned moderator user"],
+			"status" => ["type" => "tinyint unsigned", "not null" => "1", "comment" => "Status of the report, one of Entity\Report::STATUS_*"],
+			"resolution" => ["type" => "tinyint unsigned", "comment" => "Resolution of the report, one of Entity\Report::RESOLUTION_*"],
+			"created" => ["type" => "datetime(6)", "not null" => "1", "default" => DBA::NULL_DATETIME, "comment" => ""],
+			"edited" => ["type" => "datetime(6)", "comment" => "Last time the report has been edited"],
 		],
 		"indexes" => [
 			"PRIMARY" => ["id"],
 			"uid" => ["uid"],
 			"cid" => ["cid"],
 			"reporter-id" => ["reporter-id"],
+			"gsid" => ["gsid"],
+			"assigned-uid" => ["assigned-uid"],
+			"status-resolution" => ["status", "resolution"],
+			"created" => ["created"],
+			"edited" => ["edited"],
 		]
 	],
 	"report-post" => [
-		"comment" => "",
+		"comment" => "Individual posts attached to a moderation report",
 		"fields" => [
 			"rid" => ["type" => "int unsigned", "not null" => "1", "primary" => "1", "foreign" => ["report" => "id"], "comment" => "Report id"],
 			"uri-id" => ["type" => "int unsigned", "not null" => "1", "primary" => "1", "foreign" => ["item-uri" => "id"], "comment" => "Uri-id of the reported post"],
@@ -1717,6 +1728,17 @@ return [
 			"uri-id" => ["uri-id"],
 		]
 	],
+	"report-rule" => [
+		"comment" => "Terms of service rule lines relevant to a moderation report",
+		"fields" => [
+			"rid" => ["type" => "int unsigned", "not null" => "1", "primary" => "1", "foreign" => ["report" => "id"], "comment" => "Report id"],
+			"line-id" => ["type" => "int unsigned", "not null" => "1", "primary" => "1", "comment" => "Terms of service rule line number, may become invalid after a TOS change."],
+			"text" => ["type" => "text", "not null" => "1", "comment" => "Terms of service rule text recorded at the time of the report"],
+		],
+		"indexes" => [
+			"PRIMARY" => ["rid", "line-id"],
+		]
+	],
 	"search" => [
 		"comment" => "",
 		"fields" => [

tests/src/Moderation/Factory/ReportTest.php

@@ -21,144 +21,242 @@
 
 namespace Friendica\Test\src\Moderation\Factory;
 
+use Friendica\Moderation\Collection;
 use Friendica\Moderation\Factory;
 use Friendica\Moderation\Entity;
 use Friendica\Test\MockedTest;
+use Friendica\Util\Clock\FrozenClock;
+use Friendica\Util\DateTimeFormat;
+use Psr\Clock\ClockInterface;
 use Psr\Log\NullLogger;
 
 class ReportTest extends MockedTest
 {
 	public function dataCreateFromTableRow(): array
 	{
+		$clock = new FrozenClock();
+
+		// We need to strip the microseconds part to match database stored timestamps
+		$nowSeconds = $clock->now()->setTime(
+			$clock->now()->format('H'),
+			$clock->now()->format('i'),
+			$clock->now()->format('s')
+		);
+
 		return [
 			'default' => [
+				'clock' => $clock,
 				'row' => [
-					'id'          => 11,
+					'id'              => 11,
-					'uid'         => 12,
+					'reporter-id'     => 12,
-					'reporter-id' => 14,
+					'uid'             => null,
-					'cid'         => 13,
+					'cid'             => 13,
-					'comment'     => '',
+					'gsid'            => 14,
-					'category'    => null,
+					'comment'         => '',
-					'rules'       => '',
+					'forward'         => false,
-					'forward'     => false,
+					'category-id'     => Entity\Report::CATEGORY_SPAM,
-					'created'     => null
+					'public-remarks'  => '',
+					'private-remarks' => '',
+					'last-editor-uid' => null,
+					'assigned-uid'    => null,
+					'status'          => Entity\Report::STATUS_OPEN,
+					'resolution'      => null,
+					'created'         => $nowSeconds->format(DateTimeFormat::MYSQL),
+					'edited'          => null,
 				],
-				'postUriIds' => [],
+				'posts' => new Collection\Report\Posts(),
+				'rules' => new Collection\Report\Rules(),
 				'assertion'  => new Entity\Report(
-					14,
+					12,
 					13,
-					new \DateTime('now', new \DateTimeZone('UTC')),
+					14,
-					'',
+					$nowSeconds,
+					Entity\Report::CATEGORY_SPAM,
 					null,
 					'',
 					false,
-					[],
+					new Collection\Report\Posts(),
-					12,
+					new Collection\Report\Rules(),
-					11,
+					'',
+					'',
+					null,
+					Entity\Report::STATUS_OPEN,
+					null,
+					null,
+					null,
+					11
 				),
 			],
 			'full' => [
+				'clock' => $clock,
 				'row' => [
-					'id'          => 11,
+					'id'              => 11,
-					'uid'         => 12,
+					'reporter-id'     => 42,
-					'reporter-id' => 14,
+					'uid'             => 12,
-					'cid'         => 13,
+					'cid'             => 13,
-					'comment'     => 'Report',
+					'gsid'            => 14,
-					'category'    => 'violation',
+					'comment'         => 'Report',
-					'rules'       => 'Rules',
+					'forward'         => true,
-					'forward'     => true,
+					'category-id'     => Entity\Report::CATEGORY_VIOLATION,
-					'created'     => '2021-10-12 12:23:00'
+					'public-remarks'  => 'Public remarks',
+					'private-remarks' => 'Private remarks',
+					'last-editor-uid' => 15,
+					'assigned-uid'    => 16,
+					'status'          => Entity\Report::STATUS_CLOSED,
+					'resolution'      => Entity\Report::RESOLUTION_ACCEPTED,
+					'created'         => '2021-10-12 12:23:00',
+					'edited'          => '2021-12-10 21:08:00',
 				],
-				'postUriIds' => [89, 90],
+				'posts' => new Collection\Report\Posts([
+					new Entity\Report\Post(89),
+					new Entity\Report\Post(90),
+				]),
+				'rules' => new Collection\Report\Rules([
+					new Entity\Report\Rule(1, 'No hate speech'),
+					new Entity\Report\Rule(3, 'No commercial promotion'),
+				]),
 				'assertion'  => new Entity\Report(
-					14,
+					42,
 					13,
-					new \DateTime('2021-10-12 12:23:00', new \DateTimeZone('UTC')),
+					14,
-					'Report',
+					new \DateTimeImmutable('2021-10-12 12:23:00', new \DateTimeZone('UTC')),
-					'violation',
+					Entity\Report::CATEGORY_VIOLATION,
-					'Rules',
-					true,
-					[89, 90],
 					12,
+					'Report',
+					true,
+					new Collection\Report\Posts([
+						new Entity\Report\Post(89),
+						new Entity\Report\Post(90),
+					]),
+					new Collection\Report\Rules([
+						new Entity\Report\Rule(1, 'No hate speech'),
+						new Entity\Report\Rule(3, 'No commercial promotion'),
+					]),
+					'Public remarks',
+					'Private remarks',
+					new \DateTimeImmutable('2021-12-10 21:08:00', new \DateTimeZone('UTC')),
+					Entity\Report::STATUS_CLOSED,
+					Entity\Report::RESOLUTION_ACCEPTED,
+					16,
+					15,
 					11
 				),
 			],
 		];
 	}
 
-	public function assertReport(Entity\Report $assertion, Entity\Report $report)
-	{
-		self::assertEquals(
-			$assertion->id,
-			$report->id
-		);
-		self::assertEquals($assertion->uid, $report->uid);
-		self::assertEquals($assertion->reporterId, $report->reporterId);
-		self::assertEquals($assertion->cid, $report->cid);
-		self::assertEquals($assertion->comment, $report->comment);
-		self::assertEquals($assertion->category, $report->category);
-		self::assertEquals($assertion->rules, $report->rules);
-		self::assertEquals($assertion->forward, $report->forward);
-		// No way to test "now" at the moment
-		//self::assertEquals($assertion->created, $report->created);
-		self::assertEquals($assertion->postUriIds, $report->postUriIds);
-	}
-
 	/**
 	 * @dataProvider dataCreateFromTableRow
 	 */
-	public function testCreateFromTableRow(array $row, array $postUriIds, Entity\Report $assertion)
+	public function testCreateFromTableRow(ClockInterface $clock, array $row, Collection\Report\Posts $posts, Collection\Report\Rules $rules, Entity\Report $assertion)
 	{
-		$factory = new Factory\Report(new NullLogger());
+		$factory = new Factory\Report(new NullLogger(), $clock);
 
-		$this->assertReport($factory->createFromTableRow($row, $postUriIds), $assertion);
+		$this->assertEquals($factory->createFromTableRow($row, $posts, $rules), $assertion);
 	}
 
 	public function dataCreateFromReportsRequest(): array
 	{
+		$clock = new FrozenClock();
+
 		return [
 			'default' => [
-				'reporter-id' => 14,
+				'clock'      => $clock,
-				'cid'         => 13,
+				'rules'      => [],
-				'comment'     => '',
+				'reporterId' => 12,
-				'category'    => null,
+				'cid'        => 13,
-				'rules'       => '',
+				'gsid'       => 14,
-				'forward'     => false,
+				'comment'    => '',
-				'postUriIds'  => [],
+				'category'   => 'spam',
-				'uid'         => 12,
+				'forward'    => false,
-				'assertion'   => new Entity\Report(
+				'postUriIds' => [],
-					14,
+				'ruleIds'    => [],
-					13,
+				'uid'        => null,
-					new \DateTime('now', new \DateTimeZone('UTC')),
+				'assertion'  => new Entity\Report(
-					'',
-					null,
-					'',
-					false,
-					[],
 					12,
-					null
+					13,
+					14,
+					$clock->now(),
+					Entity\Report::CATEGORY_SPAM,
 				),
 			],
 			'full' => [
-				'reporter-id' => 14,
+				'clock'      => $clock,
-				'cid'         => 13,
+				'rules'      => ['', 'Rule 1', 'Rule 2', 'Rule 3'],
-				'comment'     => 'Report',
+				'reporterId' => 12,
-				'category'    => 'violation',
+				'cid'        => 13,
-				'rules'       => 'Rules',
+				'gsid'       => 14,
-				'forward'     => true,
+				'comment'    => 'Report',
-				'postUriIds'  => [89, 90],
+				'category'   => 'violation',
-				'uid'         => 12,
+				'forward'    => true,
-				'assertion'   => new Entity\Report(
+				'postUriIds' => [89, 90],
-					14,
+				'ruleIds'    => [1, 3],
-					13,
+				'uid'        => 42,
-					new \DateTime('now', new \DateTimeZone('UTC')),
+				'assertion'  => new Entity\Report(
-					'Report',
-					'violation',
-					'Rules',
-					true,
-					[89, 90],
 					12,
-					null
+					13,
+					14,
+					$clock->now(),
+					Entity\Report::CATEGORY_VIOLATION,
+					42,
+					'Report',
+					true,
+					new Collection\Report\Posts([
+						new Entity\Report\Post(89),
+						new Entity\Report\Post(90)
+					]),
+					new Collection\Report\Rules([
+						new Entity\Report\Rule(1, 'Rule 1'),
+						new Entity\Report\Rule(3, 'Rule 3'),
+					]),
+				),
+			],
+			'forced-violation' => [
+				'clock'      => $clock,
+				'rules'      => ['', 'Rule 1', 'Rule 2', 'Rule 3'],
+				'reporterId' => 12,
+				'cid'        => 13,
+				'gsid'       => 14,
+				'comment'    => 'Report',
+				'category'   => 'other',
+				'forward'    => false,
+				'postUriIds' => [],
+				'ruleIds'    => [2, 3],
+				'uid'        => null,
+				'assertion'  => new Entity\Report(
+					12,
+					13,
+					14,
+					$clock->now(),
+					Entity\Report::CATEGORY_VIOLATION,
+					null,
+					'Report',
+					false,
+					new Collection\Report\Posts(),
+					new Collection\Report\Rules([
+						new Entity\Report\Rule(2, 'Rule 2'),
+						new Entity\Report\Rule(3, 'Rule 3'),
+					]),
+				),
+			],
+			'unknown-category' => [
+				'clock'      => $clock,
+				'rules'      => ['', 'Rule 1', 'Rule 2', 'Rule 3'],
+				'reporterId' => 12,
+				'cid'        => 13,
+				'gsid'       => 14,
+				'comment'    => '',
+				'category'   => 'unknown',
+				'forward'    => false,
+				'postUriIds' => [],
+				'ruleIds'    => [],
+				'uid'        => null,
+				'assertion'  => new Entity\Report(
+					12,
+					13,
+					14,
+					$clock->now(),
+					Entity\Report::CATEGORY_OTHER,
 				),
 			],
 		];
@@ -167,10 +265,10 @@ class ReportTest extends MockedTest
 	/**
 	 * @dataProvider dataCreateFromReportsRequest
 	 */
-	public function testCreateFromReportsRequest(int $reporter, int $cid, string $comment, string $category = null, string $rules = '', bool $forward, array $postUriIds, int $uid, Entity\Report $assertion)
+	public function testCreateFromReportsRequest(ClockInterface $clock, array $rules, int $reporterId, int $cid, int $gsid, string $comment, string $category, bool $forward, array $postUriIds, array $ruleIds, int $uid = null, Entity\Report $assertion)
 	{
-		$factory = new Factory\Report(new NullLogger());
+		$factory = new Factory\Report(new NullLogger(), $clock);
 
-		$this->assertReport($factory->createFromReportsRequest($reporter, $cid, $comment, $category, $rules, $forward, $postUriIds, $uid), $assertion);
+		$this->assertEquals($factory->createFromReportsRequest($rules, $reporterId, $cid, $gsid, $comment, $category, $forward, $postUriIds, $ruleIds, $uid), $assertion);
 	}
 }