Coverage for core/filtersets.py: 77%

1import django_filters 

2from django.contrib.contenttypes.models import ContentType 

3from django.db.models import Q 

4from django.utils.translation import gettext as _ 

5 

6from netbox.filtersets import BaseFilterSet, ChangeLoggedModelFilterSet, PrimaryModelFilterSet 

7from netbox.utils import get_data_backend_choices 

8from users.models import User 

9from utilities.filters import MultiValueContentTypeFilter 

10from utilities.filtersets import register_filterset 

11 

12from .choices import * 

13from .models import * 

14 

15__all__ = ( 

16 'ConfigRevisionFilterSet', 

17 'DataFileFilterSet', 

18 'DataSourceFilterSet', 

19 'JobFilterSet', 

20 'ObjectChangeFilterSet', 

21 'ObjectTypeFilterSet', 

22) 

23 

24 

25@register_filterset 

26class DataSourceFilterSet(PrimaryModelFilterSet): 

27 type = django_filters.MultipleChoiceFilter( 

28 choices=get_data_backend_choices, 

29 distinct=False, 

30 null_value=None 

31 ) 

32 status = django_filters.MultipleChoiceFilter( 

33 choices=DataSourceStatusChoices, 

34 distinct=False, 

35 null_value=None 

36 ) 

37 sync_interval = django_filters.MultipleChoiceFilter( 

38 choices=JobIntervalChoices, 

39 distinct=False, 

40 null_value=None 

41 ) 

42 

43 class Meta: 

44 model = DataSource 

45 fields = ('id', 'name', 'enabled', 'description', 'source_url', 'last_synced') 

46 

47 def search(self, queryset, name, value): 

48 if not value.strip(): 

49 return queryset 

50 return queryset.filter( 

51 Q(name__icontains=value) | 

52 Q(description__icontains=value) | 

53 Q(comments__icontains=value) 

54 ) 

55 

56 

57@register_filterset 

58class DataFileFilterSet(ChangeLoggedModelFilterSet): 

59 q = django_filters.CharFilter( 

60 method='search' 

61 ) 

62 source_id = django_filters.ModelMultipleChoiceFilter( 

63 queryset=DataSource.objects.all(), 

64 distinct=False, 

65 label=_('Data source (ID)'), 

66 ) 

67 source = django_filters.ModelMultipleChoiceFilter( 

68 field_name='source__name', 

69 queryset=DataSource.objects.all(), 

70 distinct=False, 

71 to_field_name='name', 

72 label=_('Data source (name)'), 

73 ) 

74 

75 class Meta: 

76 model = DataFile 

77 fields = ('id', 'path', 'last_updated', 'size', 'hash') 

78 

79 def search(self, queryset, name, value): 

80 if not value.strip(): 

81 return queryset 

82 return queryset.filter( 

83 Q(path__icontains=value) 

84 ) 

85 

86 

87@register_filterset 

88class JobFilterSet(BaseFilterSet): 

89 q = django_filters.CharFilter( 

90 method='search', 

91 label=_('Search'), 

92 ) 

93 object_type_id = django_filters.ModelMultipleChoiceFilter( 

94 queryset=ObjectType.objects.with_feature('jobs'), 

95 distinct=False, 

96 field_name='object_type_id', 

97 ) 

98 object_type = MultiValueContentTypeFilter() 

99 created = django_filters.DateTimeFilter() 

100 created__before = django_filters.DateTimeFilter( 

101 field_name='created', 

102 lookup_expr='lte' 

103 ) 

104 created__after = django_filters.DateTimeFilter( 

105 field_name='created', 

106 lookup_expr='gte' 

107 ) 

108 scheduled = django_filters.DateTimeFilter() 

109 scheduled__before = django_filters.DateTimeFilter( 

110 field_name='scheduled', 

111 lookup_expr='lte' 

112 ) 

113 scheduled__after = django_filters.DateTimeFilter( 

114 field_name='scheduled', 

115 lookup_expr='gte' 

116 ) 

117 started = django_filters.DateTimeFilter() 

118 started__before = django_filters.DateTimeFilter( 

119 field_name='started', 

120 lookup_expr='lte' 

121 ) 

122 started__after = django_filters.DateTimeFilter( 

123 field_name='started', 

124 lookup_expr='gte' 

125 ) 

126 completed = django_filters.DateTimeFilter() 

127 completed__before = django_filters.DateTimeFilter( 

128 field_name='completed', 

129 lookup_expr='lte' 

130 ) 

131 completed__after = django_filters.DateTimeFilter( 

132 field_name='completed', 

133 lookup_expr='gte' 

134 ) 

135 execution_time = django_filters.DurationFilter( 

136 label=_('Execution time') 

137 ) 

138 execution_time__gte = django_filters.DurationFilter( 

139 field_name='execution_time', 

140 lookup_expr='gte', 

141 label=_('Execution time (minimum)') 

142 ) 

143 execution_time__lte = django_filters.DurationFilter( 

144 field_name='execution_time', 

145 lookup_expr='lte', 

146 label=_('Execution time (maximum)') 

147 ) 

148 status = django_filters.MultipleChoiceFilter( 

149 choices=JobStatusChoices, 

150 distinct=False, 

151 null_value=None 

152 ) 

153 notifications = django_filters.MultipleChoiceFilter( 

154 choices=JobNotificationChoices, 

155 distinct=False, 

156 null_value=None 

157 ) 

158 queue_name = django_filters.CharFilter() 

159 user_id = django_filters.ModelMultipleChoiceFilter( 

160 queryset=User.objects.all(), 

161 distinct=False, 

162 label=_('User (ID)'), 

163 ) 

164 user = django_filters.ModelMultipleChoiceFilter( 

165 field_name='user__username', 

166 queryset=User.objects.all(), 

167 distinct=False, 

168 to_field_name='username', 

169 label=_('User name'), 

170 ) 

171 

172 class Meta: 

173 model = Job 

174 fields = ( 

175 'id', 'object_type', 'object_type_id', 'object_id', 'name', 'interval', 'status', 'user', 'job_id', 

176 'queue_name', 'execution_time', 

177 ) 

178 

179 def search(self, queryset, name, value): 

180 if not value.strip(): 

181 return queryset 

182 return queryset.filter( 

183 Q(user__username__icontains=value) | 

184 Q(name__icontains=value) 

185 ) 

186 

187 

188@register_filterset 

189class ObjectTypeFilterSet(BaseFilterSet): 

190 q = django_filters.CharFilter( 

191 method='search', 

192 label=_('Search'), 

193 ) 

194 features = django_filters.CharFilter( 

195 method='filter_features' 

196 ) 

197 

198 class Meta: 

199 model = ObjectType 

200 fields = ('id', 'app_label', 'model', 'public') 

201 

202 def search(self, queryset, name, value): 

203 if not value.strip(): 203 ↛ 204line 203 didn't jump to line 204 because the condition on line 203 was never true

204 return queryset 

205 return queryset.filter( 

206 Q(app_label__icontains=value) | 

207 Q(model__icontains=value) 

208 ) 

209 

210 def filter_features(self, queryset, name, value): 

211 return queryset.filter(features__icontains=value) 

212 

213 

214@register_filterset 

215class ObjectChangeFilterSet(BaseFilterSet): 

216 q = django_filters.CharFilter( 

217 method='search', 

218 label=_('Search'), 

219 ) 

220 time = django_filters.DateTimeFromToRangeFilter() 

221 changed_object_type = MultiValueContentTypeFilter() 

222 changed_object_type_id = django_filters.ModelMultipleChoiceFilter( 

223 queryset=ContentType.objects.all(), 

224 distinct=False, 

225 ) 

226 related_object_type = MultiValueContentTypeFilter() 

227 user_id = django_filters.ModelMultipleChoiceFilter( 

228 queryset=User.objects.all(), 

229 distinct=False, 

230 label=_('User (ID)'), 

231 ) 

232 user = django_filters.ModelMultipleChoiceFilter( 

233 field_name='user__username', 

234 queryset=User.objects.all(), 

235 distinct=False, 

236 to_field_name='username', 

237 label=_('User name'), 

238 ) 

239 

240 class Meta: 

241 model = ObjectChange 

242 fields = ( 

243 'id', 'user', 'user_name', 'request_id', 'action', 'changed_object_type_id', 'changed_object_id', 

244 'related_object_type', 'related_object_id', 'object_repr', 

245 ) 

246 

247 def search(self, queryset, name, value): 

248 if not value.strip(): 

249 return queryset 

250 return queryset.filter( 

251 Q(user_name__icontains=value) | 

252 Q(object_repr__icontains=value) | 

253 Q(message__icontains=value) 

254 ) 

255 

256 

257@register_filterset 

258class ConfigRevisionFilterSet(BaseFilterSet): 

259 q = django_filters.CharFilter( 

260 method='search', 

261 label=_('Search'), 

262 ) 

263 

264 class Meta: 

265 model = ConfigRevision 

266 fields = ('id', 'created', 'comment') 

267 

268 def search(self, queryset, name, value): 

269 if not value.strip(): 

270 return queryset 

271 return queryset.filter( 

272 Q(comment__icontains=value) 

273 )