Coverage for src/paperap/models/workflow/queryset.py: 54%

46 statements  

« prev     ^ index     » next       coverage.py v7.6.12, created at 2025-03-20 13:17 -0400

1""" 

2---------------------------------------------------------------------------- 

3 

4 METADATA: 

5 

6 File: queryset.py 

7 Project: paperap 

8 Created: 2025-03-04 

9 Version: 0.0.5 

10 Author: Jess Mann 

11 Email: jess@jmann.me 

12 Copyright (c) 2025 Jess Mann 

13 

14---------------------------------------------------------------------------- 

15 

16 LAST MODIFIED: 

17 

18 2025-03-04 By Jess Mann 

19 

20""" 

21 

22from __future__ import annotations 

23 

24import logging 

25from typing import TYPE_CHECKING, Any, Self 

26 

27from paperap.models.abstract.queryset import BaseQuerySet, StandardQuerySet 

28 

29if TYPE_CHECKING: 

30 from paperap.models.workflow.model import Workflow, WorkflowAction, WorkflowTrigger 

31 

32logger = logging.getLogger(__name__) 

33 

34 

35class WorkflowQuerySet(StandardQuerySet["Workflow"]): 

36 """ 

37 A lazy-loaded, chainable query interface for Paperless NGX resources. 

38 

39 BaseQuerySet provides pagination, filtering, and caching functionality similar to Django's BaseQuerySet. 

40 It's designed to be lazy - only fetching data when it's actually needed. 

41 """ 

42 

43 def name(self, value: str, *, exact: bool = True, case_insensitive: bool = True) -> Self: 

44 """ 

45 Filter workflows by name. 

46 

47 Args: 

48 value: The workflow name to filter by 

49 exact: If True, match the exact name, otherwise use contains 

50 case_insensitive: If True, ignore case when matching 

51 

52 Returns: 

53 Filtered WorkflowQuerySet 

54 

55 """ 

56 return self.filter_field_by_str("name", value, exact=exact, case_insensitive=case_insensitive) 

57 

58 def order(self, value: int) -> Self: 

59 """ 

60 Filter workflows by order. 

61 

62 Args: 

63 value: The order value to filter by 

64 

65 Returns: 

66 Filtered WorkflowQuerySet 

67 

68 """ 

69 return self.filter(order=value) 

70 

71 def enabled(self, value: bool = True) -> Self: 

72 """ 

73 Filter workflows by enabled status. 

74 

75 Args: 

76 value: If True, get enabled workflows, otherwise disabled 

77 

78 Returns: 

79 Filtered WorkflowQuerySet 

80 

81 """ 

82 return self.filter(enabled=value) 

83 

84 

85class WorkflowActionQuerySet(StandardQuerySet["WorkflowAction"]): 

86 """ 

87 A lazy-loaded, chainable query interface for Paperless NGX resources. 

88 

89 BaseQuerySet provides pagination, filtering, and caching functionality similar to Django's BaseQuerySet. 

90 It's designed to be lazy - only fetching data when it's actually needed. 

91 """ 

92 

93 def type(self, value: str, *, exact: bool = True, case_insensitive: bool = True) -> Self: 

94 """ 

95 Filter workflow actions by type. 

96 

97 Args: 

98 value: The action type to filter by 

99 exact: If True, match the exact type, otherwise use contains 

100 case_insensitive: If True, ignore case when matching 

101 

102 Returns: 

103 Filtered WorkflowActionQuerySet 

104 

105 """ 

106 return self.filter_field_by_str("type", value, exact=exact, case_insensitive=case_insensitive) 

107 

108 def assign_title(self, value: str, *, exact: bool = True, case_insensitive: bool = True) -> Self: 

109 """ 

110 Filter workflow actions by assigned title. 

111 

112 Args: 

113 value: The title to filter by 

114 exact: If True, match the exact title, otherwise use contains 

115 case_insensitive: If True, ignore case when matching 

116 

117 Returns: 

118 Filtered WorkflowActionQuerySet 

119 

120 """ 

121 return self.filter_field_by_str("assign_title", value, exact=exact, case_insensitive=case_insensitive) 

122 

123 def assign_tags(self, value: int | list[int]) -> Self: 

124 """ 

125 Filter workflow actions by assigned tags. 

126 

127 Args: 

128 value: The tag ID or list of tag IDs to filter by 

129 

130 Returns: 

131 Filtered WorkflowActionQuerySet 

132 

133 """ 

134 if isinstance(value, int): 

135 return self.filter(assign_tags__contains=value) 

136 return self.filter(assign_tags__overlap=value) 

137 

138 def assign_correspondent(self, value: int) -> Self: 

139 """ 

140 Filter workflow actions by assigned correspondent. 

141 

142 Args: 

143 value: The correspondent ID to filter by 

144 

145 Returns: 

146 Filtered WorkflowActionQuerySet 

147 

148 """ 

149 return self.filter(assign_correspondent=value) 

150 

151 def assign_document_type(self, value: int) -> Self: 

152 """ 

153 Filter workflow actions by assigned document type. 

154 

155 Args: 

156 value: The document type ID to filter by 

157 

158 Returns: 

159 Filtered WorkflowActionQuerySet 

160 

161 """ 

162 return self.filter(assign_document_type=value) 

163 

164 def assign_storage_path(self, value: int) -> Self: 

165 """ 

166 Filter workflow actions by assigned storage path. 

167 

168 Args: 

169 value: The storage path ID to filter by 

170 

171 Returns: 

172 Filtered WorkflowActionQuerySet 

173 

174 """ 

175 return self.filter(assign_storage_path=value) 

176 

177 def assign_owner(self, value: int) -> Self: 

178 """ 

179 Filter workflow actions by assigned owner. 

180 

181 Args: 

182 value: The owner ID to filter by 

183 

184 Returns: 

185 Filtered WorkflowActionQuerySet 

186 

187 """ 

188 return self.filter(assign_owner=value) 

189 

190 

191class WorkflowTriggerQuerySet(StandardQuerySet["WorkflowTrigger"]): 

192 """ 

193 A lazy-loaded, chainable query interface for Paperless NGX resources. 

194 

195 BaseQuerySet provides pagination, filtering, and caching functionality similar to Django's BaseQuerySet. 

196 It's designed to be lazy - only fetching data when it's actually needed. 

197 """ 

198 

199 def type(self, value: int) -> Self: 

200 """ 

201 Filter workflow triggers by type. 

202 

203 Args: 

204 value: The trigger type to filter by 

205 

206 Returns: 

207 Filtered WorkflowTriggerQuerySet 

208 

209 """ 

210 return self.filter(type=value) 

211 

212 def filter_path(self, value: str, *, exact: bool = True, case_insensitive: bool = True) -> Self: 

213 """ 

214 Filter workflow triggers by path filter. 

215 

216 Args: 

217 value: The path filter to match 

218 exact: If True, match the exact path, otherwise use contains 

219 case_insensitive: If True, ignore case when matching 

220 

221 Returns: 

222 Filtered WorkflowTriggerQuerySet 

223 

224 """ 

225 return self.filter_field_by_str("filter_path", value, exact=exact, case_insensitive=case_insensitive) 

226 

227 def filter_filename(self, value: str, *, exact: bool = True, case_insensitive: bool = True) -> Self: 

228 """ 

229 Filter workflow triggers by filename filter. 

230 

231 Args: 

232 value: The filename filter to match 

233 exact: If True, match the exact filename, otherwise use contains 

234 case_insensitive: If True, ignore case when matching 

235 

236 Returns: 

237 Filtered WorkflowTriggerQuerySet 

238 

239 """ 

240 return self.filter_field_by_str("filter_filename", value, exact=exact, case_insensitive=case_insensitive) 

241 

242 def filter_mailrule(self, value: str, *, exact: bool = True, case_insensitive: bool = True) -> Self: 

243 """ 

244 Filter workflow triggers by mail rule filter. 

245 

246 Args: 

247 value: The mail rule filter to match 

248 exact: If True, match the exact mail rule, otherwise use contains 

249 case_insensitive: If True, ignore case when matching 

250 

251 Returns: 

252 Filtered WorkflowTriggerQuerySet 

253 

254 """ 

255 return self.filter_field_by_str("filter_mailrule", value, exact=exact, case_insensitive=case_insensitive) 

256 

257 def has_tags(self, value: int | list[int]) -> Self: 

258 """ 

259 Filter workflow triggers by tags filter. 

260 

261 Args: 

262 value: The tag ID or list of tag IDs to filter by 

263 

264 Returns: 

265 Filtered WorkflowTriggerQuerySet 

266 

267 """ 

268 if isinstance(value, int): 

269 return self.filter(filter_has_tags__contains=value) 

270 return self.filter(filter_has_tags__overlap=value) 

271 

272 def has_correspondent(self, value: int) -> Self: 

273 """ 

274 Filter workflow triggers by correspondent filter. 

275 

276 Args: 

277 value: The correspondent ID to filter by 

278 

279 Returns: 

280 Filtered WorkflowTriggerQuerySet 

281 

282 """ 

283 return self.filter(filter_has_correspondent=value) 

284 

285 def has_document_type(self, value: int) -> Self: 

286 """ 

287 Filter workflow triggers by document type filter. 

288 

289 Args: 

290 value: The document type ID to filter by 

291 

292 Returns: 

293 Filtered WorkflowTriggerQuerySet 

294 

295 """ 

296 return self.filter(filter_has_document_type=value)