1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120
121. 121
122. 122
123. 123
124. 124
125. 125
126. 126
127. 127
128. 128
129. 129
130. 130
131. 131
132. 132
133. 133

// Copyright 2022 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT

package forgefed

import (
	"reflect"
	"time"
	"unsafe"

	ap "github.com/go-ap/activitypub"
	"github.com/valyala/fastjson"
)

const (
	TicketType ap.ActivityVocabularyType = "Ticket"
)

type Ticket struct {
	ap.Object
	// Dependants Collection of Tickets which depend on this ticket
	Dependants ap.ItemCollection `jsonld:"dependants,omitempty"`
	// Dependencies Collection of Tickets on which this ticket depends
	Dependencies ap.ItemCollection `jsonld:"dependencies,omitempty"`
	// IsResolved Whether the work on this ticket is done
	IsResolved bool `jsonld:"isResolved,omitempty"`
	// ResolvedBy If the work on this ticket is done, who marked the ticket as resolved, or which activity did so
	ResolvedBy ap.Item `jsonld:"resolvedBy,omitempty"`
	// Resolved When the ticket has been marked as resolved
	Resolved time.Time `jsonld:"resolved,omitempty"`
	// Origin The head branch if this ticket is a pull request
	Origin ap.Item `jsonld:"origin,omitempty"`
	// Target The base branch if this ticket is a pull request
	Target ap.Item `jsonld:"target,omitempty"`
}

// TicketNew initializes a Ticket type Object
func TicketNew() *Ticket {
	a := ap.ObjectNew(TicketType)
	o := Ticket{Object: *a}
	return &o
}

func (t Ticket) MarshalJSON() ([]byte, error) {
	b, err := t.Object.MarshalJSON()
	if len(b) == 0 || err != nil {
		return nil, err
	}

	b = b[:len(b)-1]
	if t.Dependants != nil {
		ap.JSONWriteItemCollectionJSONProp(&b, "dependants", t.Dependants)
	}
	if t.Dependencies != nil {
		ap.JSONWriteItemCollectionJSONProp(&b, "dependencies", t.Dependencies)
	}
	ap.JSONWriteBoolJSONProp(&b, "isResolved", t.IsResolved)
	if t.ResolvedBy != nil {
		ap.JSONWriteItemJSONProp(&b, "resolvedBy", t.ResolvedBy)
	}
	if !t.Resolved.IsZero() {
		ap.JSONWriteTimeJSONProp(&b, "resolved", t.Resolved)
	}
	if t.Origin != nil {
		ap.JSONWriteItemJSONProp(&b, "origin", t.Origin)
	}
	if t.Target != nil {
		ap.JSONWriteItemJSONProp(&b, "target", t.Target)
	}
	ap.JSONWrite(&b, '}')
	return b, nil
}

func JSONLoadTicket(val *fastjson.Value, t *Ticket) error {
	if err := ap.OnObject(&t.Object, func(o *ap.Object) error {
		return ap.JSONLoadObject(val, o)
	}); err != nil {
		return err
	}

	t.Dependants = ap.JSONGetItems(val, "dependants")
	t.Dependencies = ap.JSONGetItems(val, "dependencies")
	t.IsResolved = ap.JSONGetBoolean(val, "isResolved")
	t.ResolvedBy = ap.JSONGetItem(val, "resolvedBy")
	t.Resolved = ap.JSONGetTime(val, "resolved")
	t.Origin = ap.JSONGetItem(val, "origin")
	t.Target = ap.JSONGetItem(val, "target")
	return nil
}

func (t *Ticket) UnmarshalJSON(data []byte) error {
	p := fastjson.Parser{}
	val, err := p.ParseBytes(data)
	if err != nil {
		return err
	}
	return JSONLoadTicket(val, t)
}

// ToTicket tries to convert the it Item to a Ticket object.
func ToTicket(it ap.Item) (*Ticket, error) {
	switch i := it.(type) {
	case *Ticket:
		return i, nil
	case Ticket:
		return &i, nil
	case *ap.Object:
		return (*Ticket)(unsafe.Pointer(i)), nil
	case ap.Object:
		return (*Ticket)(unsafe.Pointer(&i)), nil
	default:
		// NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes
		typ := reflect.TypeOf(new(Ticket))
		if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Ticket); ok {
			return i, nil
		}
	}
	return nil, ap.ErrorInvalidType[ap.Object](it)
}

type withTicketFn func(*Ticket) error

// OnTicket calls function fn on it Item if it can be asserted to type *Ticket
func OnTicket(it ap.Item, fn withTicketFn) error {
	if it == nil {
		return nil
	}
	ob, err := ToTicket(it)
	if err != nil {
		return err
	}
	return fn(ob)
}