Coverage for users/filtersets.py: 72%

1import django_filters 

2from django.db.models import Q 

3from django.utils.translation import gettext as _ 

4 

5from core.models import ObjectType 

6from extras.models import NotificationGroup 

7from netbox.filtersets import BaseFilterSet 

8from users.models import Group, ObjectPermission, Owner, OwnerGroup, Token, User 

9from utilities.filters import MultiValueContentTypeFilter 

10from utilities.filtersets import register_filterset 

11 

12__all__ = ( 

13 'GroupFilterSet', 

14 'ObjectPermissionFilterSet', 

15 'OwnerFilterSet', 

16 'OwnerGroupFilterSet', 

17 'TokenFilterSet', 

18 'UserFilterSet', 

19) 

20 

21 

22@register_filterset 

23class GroupFilterSet(BaseFilterSet): 

24 q = django_filters.CharFilter( 

25 method='search', 

26 label=_('Search'), 

27 ) 

28 user_id = django_filters.ModelMultipleChoiceFilter( 

29 field_name='user', 

30 queryset=User.objects.all(), 

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

32 ) 

33 owner_id = django_filters.ModelMultipleChoiceFilter( 

34 field_name='owner', 

35 queryset=Owner.objects.all(), 

36 label=_('Owner (ID)'), 

37 ) 

38 owner = django_filters.ModelMultipleChoiceFilter( 

39 field_name='owner__name', 

40 queryset=Owner.objects.all(), 

41 to_field_name='name', 

42 label=_('Owner (name)'), 

43 ) 

44 permission_id = django_filters.ModelMultipleChoiceFilter( 

45 field_name='object_permissions', 

46 queryset=ObjectPermission.objects.all(), 

47 label=_('Permission (ID)'), 

48 ) 

49 notification_group_id = django_filters.ModelMultipleChoiceFilter( 

50 field_name='notification_groups', 

51 queryset=NotificationGroup.objects.all(), 

52 label=_('Notification group (ID)'), 

53 ) 

54 

55 class Meta: 

56 model = Group 

57 fields = ('id', 'name', 'description') 

58 

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

60 if not value.strip(): 

61 return queryset 

62 return queryset.filter( 

63 Q(name__icontains=value) | 

64 Q(description__icontains=value) 

65 ) 

66 

67 

68@register_filterset 

69class UserFilterSet(BaseFilterSet): 

70 q = django_filters.CharFilter( 

71 method='search', 

72 label=_('Search'), 

73 ) 

74 group_id = django_filters.ModelMultipleChoiceFilter( 

75 field_name='groups', 

76 queryset=Group.objects.all(), 

77 label=_('Group'), 

78 ) 

79 group = django_filters.ModelMultipleChoiceFilter( 

80 field_name='groups__name', 

81 queryset=Group.objects.all(), 

82 to_field_name='name', 

83 label=_('Group (name)'), 

84 ) 

85 owner_id = django_filters.ModelMultipleChoiceFilter( 

86 field_name='owner', 

87 queryset=Owner.objects.all(), 

88 label=_('Owner (ID)'), 

89 ) 

90 owner = django_filters.ModelMultipleChoiceFilter( 

91 field_name='owner__name', 

92 queryset=Owner.objects.all(), 

93 to_field_name='name', 

94 label=_('Owner (name)'), 

95 ) 

96 permission_id = django_filters.ModelMultipleChoiceFilter( 

97 field_name='object_permissions', 

98 queryset=ObjectPermission.objects.all(), 

99 label=_('Permission (ID)'), 

100 ) 

101 notification_group_id = django_filters.ModelMultipleChoiceFilter( 

102 field_name='notification_groups', 

103 queryset=NotificationGroup.objects.all(), 

104 label=_('Notification group (ID)'), 

105 ) 

106 

107 class Meta: 

108 model = User 

109 fields = ( 

110 'id', 'username', 'first_name', 'last_name', 'email', 'date_joined', 'last_login', 'is_active', 

111 'is_superuser', 

112 ) 

113 

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

115 if not value.strip(): 

116 return queryset 

117 return queryset.filter( 

118 Q(username__icontains=value) | 

119 Q(first_name__icontains=value) | 

120 Q(last_name__icontains=value) | 

121 Q(email__icontains=value) 

122 ) 

123 

124 

125@register_filterset 

126class TokenFilterSet(BaseFilterSet): 

127 q = django_filters.CharFilter( 

128 method='search', 

129 label=_('Search'), 

130 ) 

131 user_id = django_filters.ModelMultipleChoiceFilter( 

132 field_name='user', 

133 queryset=User.objects.all(), 

134 distinct=False, 

135 label=_('User'), 

136 ) 

137 user = django_filters.ModelMultipleChoiceFilter( 

138 field_name='user__username', 

139 queryset=User.objects.all(), 

140 distinct=False, 

141 to_field_name='username', 

142 label=_('User (name)'), 

143 ) 

144 created = django_filters.DateTimeFilter() 

145 created__gte = django_filters.DateTimeFilter( 

146 field_name='created', 

147 lookup_expr='gte' 

148 ) 

149 created__lte = django_filters.DateTimeFilter( 

150 field_name='created', 

151 lookup_expr='lte' 

152 ) 

153 expires = django_filters.DateTimeFilter() 

154 expires__gte = django_filters.DateTimeFilter( 

155 field_name='expires', 

156 lookup_expr='gte' 

157 ) 

158 expires__lte = django_filters.DateTimeFilter( 

159 field_name='expires', 

160 lookup_expr='lte' 

161 ) 

162 last_used = django_filters.DateTimeFilter() 

163 last_used__gte = django_filters.DateTimeFilter( 

164 field_name='last_used', 

165 lookup_expr='gte' 

166 ) 

167 last_used__lte = django_filters.DateTimeFilter( 

168 field_name='last_used', 

169 lookup_expr='lte' 

170 ) 

171 

172 class Meta: 

173 model = Token 

174 fields = ( 

175 'id', 'version', 'key', 'pepper_id', 'enabled', 'write_enabled', 

176 'description', 'created', 'expires', 'last_used', 

177 ) 

178 

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

180 if not value.strip(): 

181 return queryset 

182 return queryset.filter( 

183 Q(key=value) | 

184 Q(user__username__icontains=value) | 

185 Q(description__icontains=value) 

186 ) 

187 

188 

189@register_filterset 

190class ObjectPermissionFilterSet(BaseFilterSet): 

191 q = django_filters.CharFilter( 

192 method='search', 

193 label=_('Search'), 

194 ) 

195 object_type_id = django_filters.ModelMultipleChoiceFilter( 

196 queryset=ObjectType.objects.all(), 

197 field_name='object_types' 

198 ) 

199 object_type = MultiValueContentTypeFilter( 

200 field_name='object_types' 

201 ) 

202 can_view = django_filters.BooleanFilter( 

203 method='_check_action' 

204 ) 

205 can_add = django_filters.BooleanFilter( 

206 method='_check_action' 

207 ) 

208 can_change = django_filters.BooleanFilter( 

209 method='_check_action' 

210 ) 

211 can_delete = django_filters.BooleanFilter( 

212 method='_check_action' 

213 ) 

214 user_id = django_filters.ModelMultipleChoiceFilter( 

215 field_name='users', 

216 queryset=User.objects.all(), 

217 label=_('User'), 

218 ) 

219 user = django_filters.ModelMultipleChoiceFilter( 

220 field_name='users__username', 

221 queryset=User.objects.all(), 

222 to_field_name='username', 

223 label=_('User (name)'), 

224 ) 

225 group_id = django_filters.ModelMultipleChoiceFilter( 

226 field_name='groups', 

227 queryset=Group.objects.all(), 

228 label=_('Group'), 

229 ) 

230 group = django_filters.ModelMultipleChoiceFilter( 

231 field_name='groups__name', 

232 queryset=Group.objects.all(), 

233 to_field_name='name', 

234 label=_('Group (name)'), 

235 ) 

236 

237 class Meta: 

238 model = ObjectPermission 

239 fields = ('id', 'name', 'enabled', 'object_types', 'description') 

240 

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

242 if not value.strip(): 

243 return queryset 

244 return queryset.filter( 

245 Q(name__icontains=value) | 

246 Q(description__icontains=value) 

247 ) 

248 

249 def _check_action(self, queryset, name, value): 

250 action = name.split('_')[1] 

251 if value: 

252 return queryset.filter(actions__contains=[action]) 

253 return queryset.exclude(actions__contains=[action]) 

254 

255 

256@register_filterset 

257class OwnerGroupFilterSet(BaseFilterSet): 

258 q = django_filters.CharFilter( 

259 method='search', 

260 label=_('Search'), 

261 ) 

262 

263 class Meta: 

264 model = OwnerGroup 

265 fields = ('id', 'name', 'description') 

266 

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

268 if not value.strip(): 

269 return queryset 

270 return queryset.filter( 

271 Q(name__icontains=value) | 

272 Q(description__icontains=value) 

273 ) 

274 

275 

276@register_filterset 

277class OwnerFilterSet(BaseFilterSet): 

278 q = django_filters.CharFilter( 

279 method='search', 

280 label=_('Search'), 

281 ) 

282 group_id = django_filters.ModelMultipleChoiceFilter( 

283 queryset=OwnerGroup.objects.all(), 

284 distinct=False, 

285 label=_('Group (ID)'), 

286 ) 

287 group = django_filters.ModelMultipleChoiceFilter( 

288 field_name='group__name', 

289 queryset=OwnerGroup.objects.all(), 

290 distinct=False, 

291 to_field_name='name', 

292 label=_('Group (name)'), 

293 ) 

294 user_group_id = django_filters.ModelMultipleChoiceFilter( 

295 field_name='user_groups', 

296 queryset=Group.objects.all(), 

297 label=_('User group (ID)'), 

298 ) 

299 user_group = django_filters.ModelMultipleChoiceFilter( 

300 field_name='user_groups__name', 

301 queryset=Group.objects.all(), 

302 to_field_name='name', 

303 label=_('User group (name)'), 

304 ) 

305 user_id = django_filters.ModelMultipleChoiceFilter( 

306 field_name='users', 

307 queryset=User.objects.all(), 

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

309 ) 

310 user = django_filters.ModelMultipleChoiceFilter( 

311 field_name='users__username', 

312 queryset=User.objects.all(), 

313 to_field_name='username', 

314 label=_('User (username)'), 

315 ) 

316 

317 class Meta: 

318 model = Owner 

319 fields = ('id', 'name', 'description') 

320 

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

322 if not value.strip(): 

323 return queryset 

324 return queryset.filter( 

325 Q(name__icontains=value) | 

326 Q(description__icontains=value) 

327 )