19065177774

Committed 04 Nov 2025 10:12AM UTC coverage: 75.865% (-0.08%) from 75.944%

Build # 19065177774

Build Type

push

github

Committed by

klinge

Commit Message

Temp reverting back to phpstan lvl 5

Run Details

1688 of 2225 relevant lines covered (75.87%)

3.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.12

/App/Models/SeglingRepository.php

<?php

declare(strict_types=1);

namespace App\Models;

use PDO;
use Psr\Log\LoggerInterface;

class SeglingRepository extends BaseModel
{
    public function __construct(PDO $db, LoggerInterface $logger)
    {
        parent::__construct($db, $logger);
    }

    /**
     * Retrieves all seglingar as Segling objects.
     *
     * @return array<int, Segling> Array of Segling objects
     */
    public function getAll(): array
    {
        $query = "SELECT * FROM Segling ORDER BY startdatum DESC";
        $stmt = $this->conn->prepare($query);
        $stmt->execute();
        $results = $stmt->fetchAll(PDO::FETCH_ASSOC);

        $seglingar = [];
        foreach ($results as $row) {
            $seglingar[] = $this->createSeglingFromData($row);
        }
        return $seglingar;
    }

    /**
     * Retrieves all seglingar with participants as Segling objects.
     *
     * @return array<int, Segling> Array of Segling objects with participants
     */
    public function getAllWithDeltagare(): array
    {
        $seglingar = $this->getAll();
        foreach ($seglingar as $segling) {
            $segling->deltagare = $this->findDeltagare($segling->id);
        }
        return $seglingar;
    }

    /**
     * Retrieves a segling by ID as Segling object.
     *
     * @param int $id Segling ID
     * @return Segling|null The Segling object or null if not found
     */
    public function getById(int $id): ?Segling
    {
        $query = "SELECT * FROM Segling WHERE id = ?";
        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(1, $id, PDO::PARAM_INT);
        $stmt->execute();
        $row = $stmt->fetch(PDO::FETCH_ASSOC);

        return $row ? $this->createSeglingFromData($row) : null;
    }

    /**
     * Retrieves a segling by ID with participants as Segling object.
     *
     * @param int $id Segling ID
     * @return Segling|null The Segling object with participants or null if not found
     */
    public function getByIdWithDeltagare(int $id): ?Segling
    {
        $segling = $this->getById($id);
        if ($segling) {
            $segling->deltagare = $this->findDeltagare($id);
        }
        return $segling;
    }

    /**
     * Creates a new segling.
     *
     * @param array<string, mixed> $data Segling data
     * @return int|null The new segling ID or null on failure
     */
    public function create(array $data): ?int
    {
        $query = 'INSERT INTO Segling (startdatum, slutdatum, skeppslag, kommentar) VALUES (:startdat, :slutdat, :skeppslag, :kommentar)';
        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(':startdat', $data['startdat'], PDO::PARAM_STR);
        $stmt->bindParam(':slutdat', $data['slutdat'], PDO::PARAM_STR);
        $stmt->bindParam(':skeppslag', $data['skeppslag'], PDO::PARAM_STR);
        $stmt->bindValue(':kommentar', $data['kommentar'] ?? null, PDO::PARAM_STR);

        if ($stmt->execute() && $stmt->rowCount() === 1) {
            return (int) $this->conn->lastInsertId();
        }
        return null;
    }

    /**
     * Updates an existing segling.
     *
     * @param int $id Segling ID
     * @param array<string, mixed> $data Segling data
     * @return bool Success status
     */
    public function update(int $id, array $data): bool
    {
        $query = "UPDATE Segling SET 
            startdatum = :startdatum, 
            slutdatum = :slutdatum, 
            skeppslag = :skeppslag, 
            kommentar = :kommentar
            WHERE id = :id";

        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(':startdatum', $data['startdat'], PDO::PARAM_STR);
        $stmt->bindParam(':slutdatum', $data['slutdat'], PDO::PARAM_STR);
        $stmt->bindParam(':skeppslag', $data['skeppslag'], PDO::PARAM_STR);
        $stmt->bindValue(':kommentar', $data['kommentar'] ?? null, PDO::PARAM_STR);
        $stmt->bindParam(':id', $id, PDO::PARAM_INT);

        return $stmt->execute() && $stmt->rowCount() === 1;
    }

    /**
     * Deletes a segling by ID.
     *
     * @param int $id Segling ID
     * @return bool Success status
     */
    public function delete(int $id): bool
    {
        $query = "DELETE FROM Segling WHERE id = ?";
        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(1, $id, PDO::PARAM_INT);
        return $stmt->execute() && $stmt->rowCount() === 1;
    }

    /**
     * Finds participants for a segling as raw data.
     *
     * @param int $seglingId Segling ID
     * @return array<int, array<string, mixed>> Array of participant data
     */
    public function findDeltagare(int $seglingId): array
    {
        $query = "SELECT smr.medlem_id, m.fornamn, m.efternamn, smr.roll_id, r.roll_namn
                    FROM Segling_Medlem_Roll smr
                    JOIN Medlem m ON smr.medlem_id = m.id
                    LEFT JOIN Roll r ON smr.roll_id = r.id
                    WHERE smr.segling_id = :id";
        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(':id', $seglingId, PDO::PARAM_INT);
        $stmt->execute();
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    /**
     * Finds participants for a segling as raw data.
     *
     * @deprecated Use findDeltagare() instead
     * @param int $seglingId Segling ID
     * @return array<int, array<string, mixed>> Array of participant data
     */
    public function getDeltagare(int $seglingId): array
    {
        return $this->findDeltagare($seglingId);
    }

    /**
     * Checks if a member is participating in a segling.
     *
     * @param int $seglingId Segling ID
     * @param int $memberId Member ID
     * @return bool True if member is participating
     */
    public function isMemberOnSegling(int $seglingId, int $memberId): bool
    {
        $query = "SELECT COUNT(*) FROM Segling_Medlem_Roll WHERE segling_id = :segling_id AND medlem_id = :medlem_id";
        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(':segling_id', $seglingId, PDO::PARAM_INT);
        $stmt->bindParam(':medlem_id', $memberId, PDO::PARAM_INT);
        $stmt->execute();
        return $stmt->fetchColumn() > 0;
    }

    /**
     * Adds a member to a segling with optional role.
     *
     * @param int $seglingId Segling ID
     * @param int $memberId Member ID
     * @param int|null $roleId Optional role ID
     * @return bool Success status
     */
    public function addMemberToSegling(int $seglingId, int $memberId, ?int $roleId = null): bool
    {
        if ($roleId && $roleId !== 999) {
            $query = "INSERT INTO Segling_Medlem_Roll (segling_id, medlem_id, roll_id) VALUES (:segling_id, :medlem_id, :roll_id)";
        } else {
            $query = "INSERT INTO Segling_Medlem_Roll (segling_id, medlem_id) VALUES (:segling_id, :medlem_id)";
        }

        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(':segling_id', $seglingId, PDO::PARAM_INT);
        $stmt->bindParam(':medlem_id', $memberId, PDO::PARAM_INT);
        if ($roleId && $roleId !== 999) {
            $stmt->bindParam(':roll_id', $roleId, PDO::PARAM_INT);
        }

        return $stmt->execute() && $stmt->rowCount() === 1;
    }

    /**
     * Removes a member from a segling.
     *
     * @param int $seglingId Segling ID
     * @param int $memberId Member ID
     * @return bool Success status
     */
    public function removeMemberFromSegling(int $seglingId, int $memberId): bool
    {
        $query = "DELETE FROM Segling_Medlem_Roll WHERE segling_id = :segling_id AND medlem_id = :medlem_id";
        $stmt = $this->conn->prepare($query);
        $stmt->bindParam(':segling_id', $seglingId, PDO::PARAM_INT);
        $stmt->bindParam(':medlem_id', $memberId, PDO::PARAM_INT);
        return $stmt->execute();
    }

    /**
     * Creates a Segling object from database row data.
     *
     * @param array<string, mixed> $row Database row data
     * @return Segling Populated Segling object
     */
    private function createSeglingFromData(array $row): Segling
    {
        return new Segling(
            id: (int) $row['id'],
            start_dat: $row['startdatum'],
            slut_dat: $row['slutdatum'],
            skeppslag: $row['skeppslag'],
            kommentar: $row['kommentar'],
            deltagare: [],
            created_at: $row['created_at'],
            updated_at: $row['updated_at']
        );
    }

    // Legacy methods for backward compatibility

    /**
     * @deprecated Use create() instead
     * @param array<string, mixed> $data Segling data
     * @return int|null The new segling ID or null on failure
     */
    public function createSegling(array $data): ?int
    {
        return $this->create($data);
    }

    /**
     * @deprecated Use update() instead
     * @param int $id Segling ID
     * @param array<string, mixed> $data Segling data
     * @return bool Success status
     */
    public function updateSegling(int $id, array $data): bool
    {
        return $this->update($id, $data);
    }

    /**
     * @deprecated Use delete() instead
     * @param int $id Segling ID
     * @return bool Success status
     */
    public function deleteSegling(int $id): bool
    {
        return $this->delete($id);
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace App\Models;
6
7	use PDO;
8	use Psr\Log\LoggerInterface;
9
10	class SeglingRepository extends BaseModel
11	{
12	public function __construct(PDO $db, LoggerInterface $logger)
13	{
14	parent::__construct($db, $logger);	16✔
15	}
16
17	/**
18	* Retrieves all seglingar as Segling objects.
19	*
20	* @return array<int, Segling> Array of Segling objects
21	*/
22	public function getAll(): array
23	{
24	$query = "SELECT * FROM Segling ORDER BY startdatum DESC";	1✔
25	$stmt = $this->conn->prepare($query);	1✔
26	$stmt->execute();	1✔
27	$results = $stmt->fetchAll(PDO::FETCH_ASSOC);	1✔
28
29	$seglingar = [];	1✔
30	foreach ($results as $row) {	1✔
31	$seglingar[] = $this->createSeglingFromData($row);	1✔
32	}
33	return $seglingar;	1✔
34	}
35
36	/**
37	* Retrieves all seglingar with participants as Segling objects.
38	*
39	* @return array<int, Segling> Array of Segling objects with participants
40	*/
41	public function getAllWithDeltagare(): array
42	{
43	$seglingar = $this->getAll();	×
44	foreach ($seglingar as $segling) {	×
45	$segling->deltagare = $this->findDeltagare($segling->id);	×
46	}
47	return $seglingar;	×
48	}
49
50	/**
51	* Retrieves a segling by ID as Segling object.
52	*
53	* @param int $id Segling ID
54	* @return Segling\|null The Segling object or null if not found
55	*/
56	public function getById(int $id): ?Segling
57	{
58	$query = "SELECT * FROM Segling WHERE id = ?";	3✔
59	$stmt = $this->conn->prepare($query);	3✔
60	$stmt->bindParam(1, $id, PDO::PARAM_INT);	3✔
61	$stmt->execute();	3✔
62	$row = $stmt->fetch(PDO::FETCH_ASSOC);	3✔
63
64	return $row ? $this->createSeglingFromData($row) : null;	3✔
65	}
66
67	/**
68	* Retrieves a segling by ID with participants as Segling object.
69	*
70	* @param int $id Segling ID
71	* @return Segling\|null The Segling object with participants or null if not found
72	*/
73	public function getByIdWithDeltagare(int $id): ?Segling
74	{
75	$segling = $this->getById($id);	1✔
76	if ($segling) {	1✔
77	$segling->deltagare = $this->findDeltagare($id);	1✔
78	}
79	return $segling;	1✔
80	}
81
82	/**
83	* Creates a new segling.
84	*
85	* @param array<string, mixed> $data Segling data
86	* @return int\|null The new segling ID or null on failure
87	*/
88	public function create(array $data): ?int
89	{
90	$query = 'INSERT INTO Segling (startdatum, slutdatum, skeppslag, kommentar) VALUES (:startdat, :slutdat, :skeppslag, :kommentar)';	3✔
91	$stmt = $this->conn->prepare($query);	3✔
92	$stmt->bindParam(':startdat', $data['startdat'], PDO::PARAM_STR);	3✔
93	$stmt->bindParam(':slutdat', $data['slutdat'], PDO::PARAM_STR);	3✔
94	$stmt->bindParam(':skeppslag', $data['skeppslag'], PDO::PARAM_STR);	3✔
95	$stmt->bindValue(':kommentar', $data['kommentar'] ?? null, PDO::PARAM_STR);	3✔
96
97	if ($stmt->execute() && $stmt->rowCount() === 1) {	3✔
98	return (int) $this->conn->lastInsertId();	2✔
99	}
100	return null;	1✔
101	}
102
103	/**
104	* Updates an existing segling.
105	*
106	* @param int $id Segling ID
107	* @param array<string, mixed> $data Segling data
108	* @return bool Success status
109	*/
110	public function update(int $id, array $data): bool
111	{
112	$query = "UPDATE Segling SET	3✔
113	startdatum = :startdatum,
114	slutdatum = :slutdatum,
115	skeppslag = :skeppslag,
116	kommentar = :kommentar
117	WHERE id = :id";	3✔
118
119	$stmt = $this->conn->prepare($query);	3✔
120	$stmt->bindParam(':startdatum', $data['startdat'], PDO::PARAM_STR);	3✔
121	$stmt->bindParam(':slutdatum', $data['slutdat'], PDO::PARAM_STR);	3✔
122	$stmt->bindParam(':skeppslag', $data['skeppslag'], PDO::PARAM_STR);	3✔
123	$stmt->bindValue(':kommentar', $data['kommentar'] ?? null, PDO::PARAM_STR);	3✔
124	$stmt->bindParam(':id', $id, PDO::PARAM_INT);	3✔
125
126	return $stmt->execute() && $stmt->rowCount() === 1;	3✔
127	}
128
129	/**
130	* Deletes a segling by ID.
131	*
132	* @param int $id Segling ID
133	* @return bool Success status
134	*/
135	public function delete(int $id): bool
136	{
137	$query = "DELETE FROM Segling WHERE id = ?";	3✔
138	$stmt = $this->conn->prepare($query);	3✔
139	$stmt->bindParam(1, $id, PDO::PARAM_INT);	3✔
140	return $stmt->execute() && $stmt->rowCount() === 1;	3✔
141	}
142
143	/**
144	* Finds participants for a segling as raw data.
145	*
146	* @param int $seglingId Segling ID
147	* @return array<int, array<string, mixed>> Array of participant data
148	*/
149	public function findDeltagare(int $seglingId): array
150	{
151	$query = "SELECT smr.medlem_id, m.fornamn, m.efternamn, smr.roll_id, r.roll_namn	2✔
152	FROM Segling_Medlem_Roll smr
153	JOIN Medlem m ON smr.medlem_id = m.id
154	LEFT JOIN Roll r ON smr.roll_id = r.id
155	WHERE smr.segling_id = :id";	2✔
156	$stmt = $this->conn->prepare($query);	2✔
157	$stmt->bindParam(':id', $seglingId, PDO::PARAM_INT);	2✔
158	$stmt->execute();	2✔
159	return $stmt->fetchAll(PDO::FETCH_ASSOC);	2✔
160	}
161
162	/**
163	* Finds participants for a segling as raw data.
164	*
165	* @deprecated Use findDeltagare() instead
166	* @param int $seglingId Segling ID
167	* @return array<int, array<string, mixed>> Array of participant data
168	*/
169	public function getDeltagare(int $seglingId): array
170	{
171	return $this->findDeltagare($seglingId);	×
172	}
173
174	/**
175	* Checks if a member is participating in a segling.
176	*
177	* @param int $seglingId Segling ID
178	* @param int $memberId Member ID
179	* @return bool True if member is participating
180	*/
181	public function isMemberOnSegling(int $seglingId, int $memberId): bool
182	{
183	$query = "SELECT COUNT(*) FROM Segling_Medlem_Roll WHERE segling_id = :segling_id AND medlem_id = :medlem_id";	1✔
184	$stmt = $this->conn->prepare($query);	1✔
185	$stmt->bindParam(':segling_id', $seglingId, PDO::PARAM_INT);	1✔
186	$stmt->bindParam(':medlem_id', $memberId, PDO::PARAM_INT);	1✔
187	$stmt->execute();	1✔
188	return $stmt->fetchColumn() > 0;	1✔
189	}
190
191	/**
192	* Adds a member to a segling with optional role.
193	*
194	* @param int $seglingId Segling ID
195	* @param int $memberId Member ID
196	* @param int\|null $roleId Optional role ID
197	* @return bool Success status
198	*/
199	public function addMemberToSegling(int $seglingId, int $memberId, ?int $roleId = null): bool
200	{
201	if ($roleId && $roleId !== 999) {	2✔
202	$query = "INSERT INTO Segling_Medlem_Roll (segling_id, medlem_id, roll_id) VALUES (:segling_id, :medlem_id, :roll_id)";	1✔
203	} else {
204	$query = "INSERT INTO Segling_Medlem_Roll (segling_id, medlem_id) VALUES (:segling_id, :medlem_id)";	1✔
205	}
206
207	$stmt = $this->conn->prepare($query);	2✔
208	$stmt->bindParam(':segling_id', $seglingId, PDO::PARAM_INT);	2✔
209	$stmt->bindParam(':medlem_id', $memberId, PDO::PARAM_INT);	2✔
210	if ($roleId && $roleId !== 999) {	2✔
211	$stmt->bindParam(':roll_id', $roleId, PDO::PARAM_INT);	1✔
212	}
213
214	return $stmt->execute() && $stmt->rowCount() === 1;	2✔
215	}
216
217	/**
218	* Removes a member from a segling.
219	*
220	* @param int $seglingId Segling ID
221	* @param int $memberId Member ID
222	* @return bool Success status
223	*/
224	public function removeMemberFromSegling(int $seglingId, int $memberId): bool
225	{
226	$query = "DELETE FROM Segling_Medlem_Roll WHERE segling_id = :segling_id AND medlem_id = :medlem_id";	1✔
227	$stmt = $this->conn->prepare($query);	1✔
228	$stmt->bindParam(':segling_id', $seglingId, PDO::PARAM_INT);	1✔
229	$stmt->bindParam(':medlem_id', $memberId, PDO::PARAM_INT);	1✔
230	return $stmt->execute();	1✔
231	}
232
233	/**
234	* Creates a Segling object from database row data.
235	*
236	* @param array<string, mixed> $row Database row data
237	* @return Segling Populated Segling object
238	*/
239	private function createSeglingFromData(array $row): Segling
240	{
241	return new Segling(	3✔
242	id: (int) $row['id'],	3✔
243	start_dat: $row['startdatum'],	3✔
244	slut_dat: $row['slutdatum'],	3✔
245	skeppslag: $row['skeppslag'],	3✔
246	kommentar: $row['kommentar'],	3✔
247	deltagare: [],	3✔
248	created_at: $row['created_at'],	3✔
249	updated_at: $row['updated_at']	3✔
250	);	3✔
251	}
252
253	// Legacy methods for backward compatibility
254
255	/**
256	* @deprecated Use create() instead
257	* @param array<string, mixed> $data Segling data
258	* @return int\|null The new segling ID or null on failure
259	*/
260	public function createSegling(array $data): ?int
261	{
262	return $this->create($data);	1✔
263	}
264
265	/**
266	* @deprecated Use update() instead
267	* @param int $id Segling ID
268	* @param array<string, mixed> $data Segling data
269	* @return bool Success status
270	*/
271	public function updateSegling(int $id, array $data): bool
272	{
273	return $this->update($id, $data);	1✔
274	}
275
276	/**
277	* @deprecated Use delete() instead
278	* @param int $id Segling ID
279	* @return bool Success status
280	*/
281	public function deleteSegling(int $id): bool
282	{
283	return $this->delete($id);	1✔
284	}
285	}

klinge / sl-webapp / 19065177774

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous