BlueGit

timfa bluegit

Files

bluegit / internal / store / flow.go

flow.go

feat: webhook-formulier per preset
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 934ba1ea History
flow.go 22.4 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "encoding/json"
7 "errors"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/names"
12)
13
14// Webhook is een uitgaande melding.
15type Webhook struct {
16 ID int64
17 ScopeKind string
18 ScopeID int64
19 Name string
20 Preset string
21 URLTemplate string
22 Headers map[string]string
23 BodyTemplate string
24 Events []string
25 BranchFilter string
26 Active bool
27 Method string
28}
29
30// CreateWebhook bewaart een webhook.
31func (s *Store) CreateWebhook(ctx context.Context, w Webhook) (int64, error) {
32 if w.Headers == nil {
33 w.Headers = map[string]string{}
34 }
35 if w.Preset == "" {
36 w.Preset = "generic"
37 }
38 if w.Method == "" {
39 w.Method = "POST"
40 }
41 res, err := s.db.ExecContext(ctx, `INSERT INTO webhooks (scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method, created_at)
42 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`,
43 w.ScopeKind, w.ScopeID, w.Name, w.Preset, w.URLTemplate, mustJSON(w.Headers), w.BodyTemplate, mustJSON(w.Events), w.BranchFilter, w.Method, now())
44 if err != nil {
45 return 0, err
46 }
47 return res.LastInsertId()
48}
49
50// ListWebhooks geeft de webhooks van een repository of groep.
51func (s *Store) ListWebhooks(ctx context.Context, scopeKind string, scopeID int64) ([]Webhook, error) {
52 rows, err := s.db.QueryContext(ctx, `SELECT id, scope_kind, scope_id, name, preset, url_template, headers_json, body_template, events_json, branch_filter, active, method FROM webhooks WHERE scope_kind = ? AND scope_id = ? ORDER BY id`, scopeKind, scopeID)
53 if err != nil {
54 return nil, err
55 }
56 defer rows.Close()
57 var out []Webhook
58 for rows.Next() {
59 w, err := scanWebhook(rows)
60 if err != nil {
61 return nil, err
62 }
63 out = append(out, w)
64 }
65 return out, rows.Err()
66}
67
68func scanWebhook(rows *sql.Rows) (Webhook, error) {
69 var w Webhook
70 var headers, events string
71 var active int
72 if err := rows.Scan(&w.ID, &w.ScopeKind, &w.ScopeID, &w.Name, &w.Preset, &w.URLTemplate, &headers, &w.BodyTemplate, &events, &w.BranchFilter, &active, &w.Method); err != nil {
73 return Webhook{}, err
74 }
75 w.Active = active == 1
76 _ = json.Unmarshal([]byte(headers), &w.Headers)
77 _ = json.Unmarshal([]byte(events), &w.Events)
78 if w.Headers == nil {
79 w.Headers = map[string]string{}
80 }
81 return w, nil
82}
83
84// DeleteWebhook verwijdert een webhook in dit scope.
85func (s *Store) DeleteWebhook(ctx context.Context, scopeKind string, scopeID, id int64) error {
86 res, err := s.db.ExecContext(ctx, `DELETE FROM webhooks WHERE id = ? AND scope_kind = ? AND scope_id = ?`, id, scopeKind, scopeID)
87 if err != nil {
88 return err
89 }
90 n, _ := res.RowsAffected()
91 if n == 0 {
92 return errNotFound
93 }
94 return nil
95}
96
97// AddDelivery bewaart het resultaat van een poging.
98func (s *Store) AddDelivery(ctx context.Context, webhookID int64, eventType string, status int, errText string) error {
99 _, err := s.db.ExecContext(ctx, `INSERT INTO webhook_deliveries (webhook_id, event_type, status_code, error, created_at) VALUES (?, ?, ?, ?, ?)`,
100 webhookID, eventType, status, trim(errText, 500), now())
101 return err
102}
103
104// Delivery is één poging.
105type Delivery struct {
106 EventType string
107 StatusCode int
108 Error string
109 CreatedAt time.Time
110}
111
112// RecentDeliveries geeft de laatste pogingen.
113func (s *Store) RecentDeliveries(ctx context.Context, webhookID int64) ([]Delivery, error) {
114 rows, err := s.db.QueryContext(ctx, `SELECT event_type, status_code, error, created_at FROM webhook_deliveries WHERE webhook_id = ? ORDER BY id DESC LIMIT 8`, webhookID)
115 if err != nil {
116 return nil, err
117 }
118 defer rows.Close()
119 var out []Delivery
120 for rows.Next() {
121 var d Delivery
122 var created string
123 if err := rows.Scan(&d.EventType, &d.StatusCode, &d.Error, &created); err != nil {
124 return nil, err
125 }
126 d.CreatedAt = parseTime(created)
127 out = append(out, d)
128 }
129 return out, rows.Err()
130}
131
132// MergeRequest is een basisverzoek om een branch samen te voegen.
133type MergeRequest struct {
134 ID int64
135 RepoID int64
136 Number int64
137 Title string
138 Description string
139 SourceBranch string
140 TargetBranch string
141 AuthorID int64
142 Author string
143 Status string
144 CreatedAt time.Time
145 UpdatedAt time.Time
146}
147
148// CreateMergeRequest nummert per repository.
149func (s *Store) CreateMergeRequest(ctx context.Context, repoID, authorID int64, title, description, source, target string) (MergeRequest, error) {
150 title = trim(title, 200)
151 if title == "" {
152 return MergeRequest{}, i18n.E("err.mrTitle")
153 }
154 tx, err := s.db.BeginTx(ctx, nil)
155 if err != nil {
156 return MergeRequest{}, err
157 }
158 defer func() { _ = tx.Rollback() }()
159 var n int64
160 if err := tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(number), 0) FROM merge_requests WHERE repo_id = ?`, repoID).Scan(&n); err != nil {
161 return MergeRequest{}, err
162 }
163 ts := now()
164 res, err := tx.ExecContext(ctx, `INSERT INTO merge_requests (repo_id, number, title, description, source_branch, target_branch, author_id, status, created_at, updated_at)
165 VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`, repoID, n+1, title, description, source, target, authorID, ts, ts)
166 if err != nil {
167 return MergeRequest{}, err
168 }
169 id, _ := res.LastInsertId()
170 if err := tx.Commit(); err != nil {
171 return MergeRequest{}, err
172 }
173 return s.MergeRequest(ctx, repoID, id)
174}
175
176// MergeRequest leest op interne id.
177func (s *Store) MergeRequest(ctx context.Context, repoID, id int64) (MergeRequest, error) {
178 row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.id = ?`, repoID, id)
179 return scanMR(row)
180}
181
182// MergeRequestByNumber leest !nummer.
183func (s *Store) MergeRequestByNumber(ctx context.Context, repoID, number int64) (MergeRequest, error) {
184 row := s.db.QueryRowContext(ctx, mrSelect+` WHERE m.repo_id = ? AND m.number = ?`, repoID, number)
185 return scanMR(row)
186}
187
188const mrSelect = `SELECT m.id, m.repo_id, m.number, m.title, m.description, m.source_branch, m.target_branch, m.author_id, u.username, m.status, m.created_at, m.updated_at
189FROM merge_requests m JOIN users u ON u.id = m.author_id`
190
191func scanMR(row *sql.Row) (MergeRequest, error) {
192 var m MergeRequest
193 var created, updated string
194 if err := row.Scan(&m.ID, &m.RepoID, &m.Number, &m.Title, &m.Description, &m.SourceBranch, &m.TargetBranch, &m.AuthorID, &m.Author, &m.Status, &created, &updated); err != nil {
195 if errors.Is(err, sql.ErrNoRows) {
196 return MergeRequest{}, errNotFound
197 }
198 return MergeRequest{}, err
199 }
200 m.CreatedAt = parseTime(created)
201 m.UpdatedAt = parseTime(updated)
202 return m, nil
203}
204
205// ListMergeRequests geeft verzoeken, open eerst.
206func (s *Store) ListMergeRequests(ctx context.Context, repoID int64) ([]MergeRequest, error) {
207 rows, err := s.db.QueryContext(ctx, mrSelect+` WHERE m.repo_id = ? ORDER BY CASE m.status WHEN 'open' THEN 0 ELSE 1 END, m.number DESC`, repoID)
208 if err != nil {
209 return nil, err
210 }
211 defer rows.Close()
212 var out []MergeRequest
213 for rows.Next() {
214 var m MergeRequest
215 var created, updated string
216 if err := rows.Scan(&m.ID, &m.RepoID, &m.Number, &m.Title, &m.Description, &m.SourceBranch, &m.TargetBranch, &m.AuthorID, &m.Author, &m.Status, &created, &updated); err != nil {
217 return nil, err
218 }
219 m.CreatedAt = parseTime(created)
220 m.UpdatedAt = parseTime(updated)
221 out = append(out, m)
222 }
223 return out, rows.Err()
224}
225
226// SetMergeRequestStatus zet open, merged of closed.
227func (s *Store) SetMergeRequestStatus(ctx context.Context, id int64, status string) error {
228 _, err := s.db.ExecContext(ctx, `UPDATE merge_requests SET status = ?, updated_at = ? WHERE id = ?`, status, now(), id)
229 return err
230}
231
232// NewJob is een job die nog de wachtrij in moet.
233type NewJob struct {
234 Name string
235 Stage string
236 Position int
237 Image string
238 Script string
239 Needs []string
240 NeedsSet bool
241 Variables map[string]string
242 ArtifactPaths []string
243 ArtifactExpire time.Duration
244 AllowFailure bool
245}
246
247// Pipeline is een draai van blue-ci-cd.yml.
248type Pipeline struct {
249 ID int64
250 RepoID int64
251 CommitSHA string
252 Ref string
253 Status string
254 CreatedAt time.Time
255}
256
257// Job is één container in een pipeline.
258type Job struct {
259 ID int64
260 PipelineID int64
261 RepoID int64
262 Name string
263 Stage string
264 Position int
265 Status string
266 Image string
267 Script string
268 Needs []string
269 NeedsSet bool
270 Variables map[string]string
271 ArtifactPaths []string
272 ArtifactExpire time.Duration
273 AllowFailure bool
274 Log string
275 CommitSHA string
276 Ref string
277}
278
279// RecordConfigFailure bewaart een pipeline die niet kon starten.
280func (s *Store) RecordConfigFailure(ctx context.Context, repoID int64, sha, ref, message string) error {
281 tx, err := s.db.BeginTx(ctx, nil)
282 if err != nil {
283 return err
284 }
285 defer func() { _ = tx.Rollback() }()
286 ts := now()
287 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, created_at, finished_at) VALUES (?, ?, ?, 'failed', ?, ?)`, repoID, sha, ref, ts, ts)
288 if err != nil {
289 return err
290 }
291 id, _ := res.LastInsertId()
292 _, err = tx.ExecContext(ctx, `INSERT INTO jobs (pipeline_id, repo_id, name, stage, position, status, image, script, needs_json, needs_set, variables_json, artifact_paths, artifact_expire_seconds, allow_failure, log, finished_at)
293 VALUES (?, ?, 'blue-ci-cd', 'test', 0, 'failed', 'alpine:3.20', 'exit 1', '[]', 0, '{}', '[]', 0, 0, ?, ?)`, id, repoID, message, ts)
294 if err != nil {
295 return err
296 }
297 return tx.Commit()
298}
299
300// CreatePipeline maakt een pipeline met jobs in de wachtrij.
301func (s *Store) CreatePipeline(ctx context.Context, repoID int64, sha, ref string, jobs []NewJob) (int64, error) {
302 tx, err := s.db.BeginTx(ctx, nil)
303 if err != nil {
304 return 0, err
305 }
306 defer func() { _ = tx.Rollback() }()
307 res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, created_at) VALUES (?, ?, ?, 'queued', ?)`, repoID, sha, ref, now())
308 if err != nil {
309 return 0, err
310 }
311 id, _ := res.LastInsertId()
312 for _, j := range jobs {
313 if j.Variables == nil {
314 j.Variables = map[string]string{}
315 }
316 if j.Needs == nil {
317 j.Needs = []string{}
318 }
319 if j.ArtifactPaths == nil {
320 j.ArtifactPaths = []string{}
321 }
322 _, err := tx.ExecContext(ctx, `INSERT INTO jobs (pipeline_id, repo_id, name, stage, position, status, image, script, needs_json, needs_set, variables_json, artifact_paths, artifact_expire_seconds, allow_failure, log)
323 VALUES (?, ?, ?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?, ?, ?, '')`,
324 id, repoID, j.Name, j.Stage, j.Position, j.Image, j.Script, mustJSON(j.Needs), boolInt(j.NeedsSet), mustJSON(j.Variables), mustJSON(j.ArtifactPaths), int(j.ArtifactExpire/time.Second), boolInt(j.AllowFailure))
325 if err != nil {
326 return 0, err
327 }
328 }
329 if err := tx.Commit(); err != nil {
330 return 0, err
331 }
332 return id, nil
333}
334
335// ListPipelines geeft de nieuwste pipelines.
336func (s *Store) ListPipelines(ctx context.Context, repoID int64) ([]Pipeline, error) {
337 rows, err := s.db.QueryContext(ctx, `SELECT id, repo_id, commit_sha, ref, status, created_at FROM pipelines WHERE repo_id = ? ORDER BY id DESC LIMIT 50`, repoID)
338 if err != nil {
339 return nil, err
340 }
341 defer rows.Close()
342 var out []Pipeline
343 for rows.Next() {
344 p, err := scanPipeline(rows)
345 if err != nil {
346 return nil, err
347 }
348 out = append(out, p)
349 }
350 return out, rows.Err()
351}
352
353func scanPipeline(rows *sql.Rows) (Pipeline, error) {
354 var p Pipeline
355 var created string
356 if err := rows.Scan(&p.ID, &p.RepoID, &p.CommitSHA, &p.Ref, &p.Status, &created); err != nil {
357 return Pipeline{}, err
358 }
359 p.CreatedAt = parseTime(created)
360 return p, nil
361}
362
363// PipelineByID leest één pipeline.
364func (s *Store) PipelineByID(ctx context.Context, repoID, id int64) (Pipeline, error) {
365 var p Pipeline
366 var created string
367 err := s.db.QueryRowContext(ctx, `SELECT id, repo_id, commit_sha, ref, status, created_at FROM pipelines WHERE repo_id = ? AND id = ?`, repoID, id).
368 Scan(&p.ID, &p.RepoID, &p.CommitSHA, &p.Ref, &p.Status, &created)
369 if errors.Is(err, sql.ErrNoRows) {
370 return Pipeline{}, errNotFound
371 }
372 if err != nil {
373 return Pipeline{}, err
374 }
375 p.CreatedAt = parseTime(created)
376 return p, nil
377}
378
379// JobsByPipeline geeft de jobs in bestandsvolgorde.
380func (s *Store) JobsByPipeline(ctx context.Context, pipelineID int64) ([]Job, error) {
381 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.repo_id, j.name, j.stage, j.position, j.status, j.image, j.script, j.needs_json, j.needs_set, j.variables_json, j.artifact_paths, j.artifact_expire_seconds, j.allow_failure, j.log, p.commit_sha, p.ref
382 FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id WHERE j.pipeline_id = ? ORDER BY j.position, j.id`, pipelineID)
383 if err != nil {
384 return nil, err
385 }
386 defer rows.Close()
387 var out []Job
388 for rows.Next() {
389 j, err := scanJob(rows)
390 if err != nil {
391 return nil, err
392 }
393 out = append(out, j)
394 }
395 return out, rows.Err()
396}
397
398func scanJob(rows *sql.Rows) (Job, error) {
399 var j Job
400 var needs, vars, paths string
401 var needsSet, allow, expire int
402 if err := rows.Scan(&j.ID, &j.PipelineID, &j.RepoID, &j.Name, &j.Stage, &j.Position, &j.Status, &j.Image, &j.Script, &needs, &needsSet, &vars, &paths, &expire, &allow, &j.Log, &j.CommitSHA, &j.Ref); err != nil {
403 return Job{}, err
404 }
405 j.NeedsSet = needsSet == 1
406 j.AllowFailure = allow == 1
407 j.ArtifactExpire = time.Duration(expire) * time.Second
408 _ = json.Unmarshal([]byte(needs), &j.Needs)
409 _ = json.Unmarshal([]byte(vars), &j.Variables)
410 _ = json.Unmarshal([]byte(paths), &j.ArtifactPaths)
411 return j, nil
412}
413
414// ActivePipelines zijn nog niet af.
415func (s *Store) ActivePipelines(ctx context.Context) ([]Pipeline, error) {
416 rows, err := s.db.QueryContext(ctx, `SELECT id, repo_id, commit_sha, ref, status, created_at FROM pipelines WHERE status IN ('queued', 'running') ORDER BY id`)
417 if err != nil {
418 return nil, err
419 }
420 defer rows.Close()
421 var out []Pipeline
422 for rows.Next() {
423 p, err := scanPipeline(rows)
424 if err != nil {
425 return nil, err
426 }
427 out = append(out, p)
428 }
429 return out, rows.Err()
430}
431
432// MarkJobRunning zet een wachtende job op running als hij dat nog is.
433func (s *Store) MarkJobRunning(ctx context.Context, id int64) (bool, error) {
434 res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'running', started_at = ? WHERE id = ? AND status = 'queued'`, now(), id)
435 if err != nil {
436 return false, err
437 }
438 n, _ := res.RowsAffected()
439 if n == 1 {
440 _, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running' WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
441 }
442 return n == 1, nil
443}
444
445// FinishJob schrijft het eindresultaat en het log.
446func (s *Store) FinishJob(ctx context.Context, id int64, status, logText string) error {
447 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = ?, log = ?, finished_at = ? WHERE id = ?`, status, logText, now(), id)
448 return err
449}
450
451// AppendJobLog voegt tekst toe terwijl de job loopt.
452func (s *Store) AppendJobLog(ctx context.Context, id int64, chunk string) error {
453 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET log = log || ? WHERE id = ?`, chunk, id)
454 return err
455}
456
457// RefreshPipelineStatus berekent de pipelinestatus uit de jobs.
458func (s *Store) RefreshPipelineStatus(ctx context.Context, pipelineID int64) (string, error) {
459 jobs, err := s.JobsByPipeline(ctx, pipelineID)
460 if err != nil {
461 return "", err
462 }
463 status := "success"
464 for _, j := range jobs {
465 switch j.Status {
466 case "failed":
467 if !j.AllowFailure {
468 status = "failed"
469 }
470 case "queued", "running":
471 if status != "failed" {
472 status = "running"
473 }
474 }
475 }
476 if status == "success" || status == "failed" {
477 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = ?, finished_at = ? WHERE id = ?`, status, now(), pipelineID)
478 } else {
479 _, err = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running' WHERE id = ?`, pipelineID)
480 }
481 return status, err
482}
483
484// SkipJob markeert een job die niet meer hoeft.
485func (s *Store) SkipJob(ctx context.Context, id int64, reason string) error {
486 _, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'skipped', log = ?, finished_at = ? WHERE id = ? AND status = 'queued'`, reason, now(), id)
487 return err
488}
489
490// CreateJobToken maakt het token waarmee een lopende job de API aanroept.
491func (s *Store) CreateJobToken(ctx context.Context, jobID int64) (string, error) {
492 plain, err := newToken("bgj_")
493 if err != nil {
494 return "", err
495 }
496 _, err = s.db.ExecContext(ctx, `INSERT INTO job_tokens (job_id, token_hash, created_at) VALUES (?, ?, ?)
497 ON CONFLICT(job_id) DO UPDATE SET token_hash = excluded.token_hash, created_at = excluded.created_at`,
498 jobID, hashToken(plain), now())
499 if err != nil {
500 return "", err
501 }
502 return plain, nil
503}
504
505// JobByToken zoekt een lopende job bij een job-token.
506func (s *Store) JobByToken(ctx context.Context, token string) (Job, error) {
507 if len(token) < 4 || token[:4] != "bgj_" {
508 return Job{}, errNotFound
509 }
510 var jobID int64
511 err := s.db.QueryRowContext(ctx, `SELECT job_id FROM job_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&jobID)
512 if errors.Is(err, sql.ErrNoRows) {
513 return Job{}, errNotFound
514 }
515 if err != nil {
516 return Job{}, err
517 }
518 rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.repo_id, j.name, j.stage, j.position, j.status, j.image, j.script, j.needs_json, j.needs_set, j.variables_json, j.artifact_paths, j.artifact_expire_seconds, j.allow_failure, j.log, p.commit_sha, p.ref
519 FROM jobs j JOIN pipelines p ON p.id = j.pipeline_id WHERE j.id = ?`, jobID)
520 if err != nil {
521 return Job{}, err
522 }
523 defer rows.Close()
524 if !rows.Next() {
525 return Job{}, errNotFound
526 }
527 return scanJob(rows)
528}
529
530// Artifact verwijst naar een bestand uit een job.
531type Artifact struct {
532 ID int64
533 JobID int64
534 Path string
535 StoragePath string
536 Size int64
537}
538
539// AddArtifact registreert een bewaard bestand.
540func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePath string, size int64, expires *time.Time) error {
541 var exp any
542 if expires != nil {
543 exp = expires.UTC().Format(time.RFC3339)
544 }
545 _, err := s.db.ExecContext(ctx, `INSERT INTO artifacts (job_id, path, storage_path, size, expires_at) VALUES (?, ?, ?, ?, ?)`,
546 jobID, relPath, storagePath, size, exp)
547 return err
548}
549
550// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
551func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
552 var storage string
553 err := s.db.QueryRowContext(ctx, `SELECT a.storage_path FROM artifacts a JOIN jobs j ON j.id = a.job_id
554 WHERE j.pipeline_id = ? AND j.name = ? AND a.path = ? AND j.status = 'success'`, pipelineID, jobName, relPath).Scan(&storage)
555 if errors.Is(err, sql.ErrNoRows) {
556 return "", errNotFound
557 }
558 return storage, err
559}
560
561// Release is een publicatie op een commit.
562type Release struct {
563 ID int64
564 RepoID int64
565 Tag string
566 CommitSHA string
567 Name string
568 Body string
569 CreatedAt time.Time
570 Assets []ReleaseAsset
571}
572
573// ReleaseAsset is een bestand bij een release.
574type ReleaseAsset struct {
575 Name string
576 StoragePath string
577 Size int64
578}
579
580// CreateRelease bewaart de release. De bestanden staan al op storagePath.
581func (s *Store) CreateRelease(ctx context.Context, repoID int64, tag, sha, name, body string, authorID, jobID int64, assets []ReleaseAsset) (int64, error) {
582 if err := names.ValidTag(tag); err != nil {
583 return 0, err
584 }
585 tx, err := s.db.BeginTx(ctx, nil)
586 if err != nil {
587 return 0, err
588 }
589 defer func() { _ = tx.Rollback() }()
590 var author, job any
591 if authorID != 0 {
592 author = authorID
593 }
594 if jobID != 0 {
595 job = jobID
596 }
597 res, err := tx.ExecContext(ctx, `INSERT INTO releases (repo_id, tag, commit_sha, name, body, author_id, job_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
598 repoID, tag, sha, name, body, author, job, now())
599 if err != nil {
600 if containsUnique(err) {
601 return 0, i18n.E("err.tagExists", tag)
602 }
603 return 0, err
604 }
605 id, _ := res.LastInsertId()
606 for _, a := range assets {
607 if _, err := tx.ExecContext(ctx, `INSERT INTO release_assets (release_id, name, storage_path, size) VALUES (?, ?, ?, ?)`, id, a.Name, a.StoragePath, a.Size); err != nil {
608 return 0, err
609 }
610 }
611 if err := tx.Commit(); err != nil {
612 return 0, err
613 }
614 return id, nil
615}
616
617// ListReleases geeft publicaties, nieuwste eerst.
618func (s *Store) ListReleases(ctx context.Context, repoID int64) ([]Release, error) {
619 rows, err := s.db.QueryContext(ctx, `SELECT id, repo_id, tag, commit_sha, name, body, created_at FROM releases WHERE repo_id = ? ORDER BY id DESC`, repoID)
620 if err != nil {
621 return nil, err
622 }
623 defer rows.Close()
624 var out []Release
625 for rows.Next() {
626 var r Release
627 var created string
628 if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created); err != nil {
629 return nil, err
630 }
631 r.CreatedAt = parseTime(created)
632 out = append(out, r)
633 }
634 if err := rows.Err(); err != nil {
635 return nil, err
636 }
637 for i := range out {
638 assets, err := s.releaseAssets(ctx, out[i].ID)
639 if err != nil {
640 return nil, err
641 }
642 out[i].Assets = assets
643 }
644 return out, nil
645}
646
647// ReleaseByTag leest één release.
648func (s *Store) ReleaseByTag(ctx context.Context, repoID int64, tag string) (Release, error) {
649 var r Release
650 var created string
651 err := s.db.QueryRowContext(ctx, `SELECT id, repo_id, tag, commit_sha, name, body, created_at FROM releases WHERE repo_id = ? AND tag = ?`, repoID, tag).
652 Scan(&r.ID, &r.RepoID, &r.Tag, &r.CommitSHA, &r.Name, &r.Body, &created)
653 if errors.Is(err, sql.ErrNoRows) {
654 return Release{}, errNotFound
655 }
656 if err != nil {
657 return Release{}, err
658 }
659 r.CreatedAt = parseTime(created)
660 r.Assets, err = s.releaseAssets(ctx, r.ID)
661 return r, err
662}
663
664func (s *Store) releaseAssets(ctx context.Context, id int64) ([]ReleaseAsset, error) {
665 rows, err := s.db.QueryContext(ctx, `SELECT name, storage_path, size FROM release_assets WHERE release_id = ? ORDER BY name`, id)
666 if err != nil {
667 return nil, err
668 }
669 defer rows.Close()
670 var out []ReleaseAsset
671 for rows.Next() {
672 var a ReleaseAsset
673 if err := rows.Scan(&a.Name, &a.StoragePath, &a.Size); err != nil {
674 return nil, err
675 }
676 out = append(out, a)
677 }
678 return out, rows.Err()
679}
680
681func trim(s string, n int) string {
682 s = string([]rune(s))
683 if len([]rune(s)) > n {
684 return string([]rune(s)[:n])
685 }
686 return s
687}
688
689func containsUnique(err error) bool {
690 return err != nil && (errors.Is(err, err) && (len(err.Error()) > 0 && (contains(err.Error(), "UNIQUE") || contains(err.Error(), "unique"))))
691}
692
693func contains(s, sub string) bool {
694 return len(s) >= len(sub) && (s == sub || len(sub) == 0 || (len(s) > 0 && (indexOf(s, sub) >= 0)))
695}
696
697func indexOf(s, sub string) int {
698 for i := 0; i+len(sub) <= len(s); i++ {
699 if s[i:i+len(sub)] == sub {
700 return i
701 }
702 }
703 return -1
704}