Coverage for dcim/api/serializers_/devicetype_components.py: 100%

1from django.contrib.contenttypes.models import ContentType 

2from rest_framework import serializers 

3 

4from dcim.choices import * 

5from dcim.constants import * 

6from dcim.models import ( 

7 ConsolePortTemplate, 

8 ConsoleServerPortTemplate, 

9 CoolingIntakeTemplate, 

10 CoolingOutflowTemplate, 

11 DeviceBayTemplate, 

12 FrontPortTemplate, 

13 InterfaceTemplate, 

14 InventoryItemTemplate, 

15 ModuleBayTemplate, 

16 ModuleBayType, 

17 PortTemplateMapping, 

18 PowerOutletTemplate, 

19 PowerPortTemplate, 

20 RearPortTemplate, 

21) 

22from netbox.api.fields import ChoiceField, ContentTypeField, SerializedPKRelatedField 

23from netbox.api.gfk_fields import GFKSerializerField 

24from netbox.api.serializers import ChangeLogMessageSerializer, ValidatedModelSerializer 

25from netbox.choices import DiameterUnitChoices, FlowRateUnitChoices 

26from wireless.choices import * 

27 

28from .base import PortSerializer 

29from .devicetypes import DeviceTypeSerializer, ModuleBayTypeSerializer, ModuleTypeSerializer 

30from .manufacturers import ManufacturerSerializer 

31from .nested import NestedInterfaceTemplateSerializer 

32from .roles import InventoryItemRoleSerializer 

33 

34__all__ = ( 

35 'ConsolePortTemplateSerializer', 

36 'ConsoleServerPortTemplateSerializer', 

37 'CoolingIntakeTemplateSerializer', 

38 'CoolingOutflowTemplateSerializer', 

39 'DeviceBayTemplateSerializer', 

40 'FrontPortTemplateSerializer', 

41 'InterfaceTemplateSerializer', 

42 'InventoryItemTemplateSerializer', 

43 'ModuleBayTemplateSerializer', 

44 'PowerOutletTemplateSerializer', 

45 'PowerPortTemplateSerializer', 

46 'RearPortTemplateSerializer', 

47) 

48 

49 

50class ComponentTemplateSerializer(ChangeLogMessageSerializer, ValidatedModelSerializer): 

51 pass 

52 

53 

54class ConsolePortTemplateSerializer(ComponentTemplateSerializer): 

55 device_type = DeviceTypeSerializer( 

56 nested=True, 

57 required=False, 

58 allow_null=True, 

59 default=None 

60 ) 

61 module_type = ModuleTypeSerializer( 

62 nested=True, 

63 required=False, 

64 allow_null=True, 

65 default=None 

66 ) 

67 type = ChoiceField( 

68 choices=ConsolePortTypeChoices, 

69 allow_blank=True, 

70 required=False 

71 ) 

72 

73 class Meta: 

74 model = ConsolePortTemplate 

75 fields = [ 

76 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 

77 'description', 'created', 'last_updated', 

78 ] 

79 brief_fields = ('id', 'url', 'display', 'name', 'description') 

80 

81 

82class ConsoleServerPortTemplateSerializer(ComponentTemplateSerializer): 

83 device_type = DeviceTypeSerializer( 

84 nested=True, 

85 required=False, 

86 allow_null=True, 

87 default=None 

88 ) 

89 module_type = ModuleTypeSerializer( 

90 nested=True, 

91 required=False, 

92 allow_null=True, 

93 default=None 

94 ) 

95 type = ChoiceField( 

96 choices=ConsolePortTypeChoices, 

97 allow_blank=True, 

98 required=False 

99 ) 

100 

101 class Meta: 

102 model = ConsoleServerPortTemplate 

103 fields = [ 

104 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 

105 'description', 'created', 'last_updated', 

106 ] 

107 brief_fields = ('id', 'url', 'display', 'name', 'description') 

108 

109 

110class PowerPortTemplateSerializer(ComponentTemplateSerializer): 

111 device_type = DeviceTypeSerializer( 

112 nested=True, 

113 required=False, 

114 allow_null=True, 

115 default=None 

116 ) 

117 module_type = ModuleTypeSerializer( 

118 nested=True, 

119 required=False, 

120 allow_null=True, 

121 default=None 

122 ) 

123 type = ChoiceField( 

124 choices=PowerPortTypeChoices, 

125 allow_blank=True, 

126 required=False, 

127 allow_null=True 

128 ) 

129 

130 class Meta: 

131 model = PowerPortTemplate 

132 fields = [ 

133 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 

134 'maximum_draw', 'allocated_draw', 'description', 'created', 'last_updated', 

135 ] 

136 brief_fields = ('id', 'url', 'display', 'name', 'description') 

137 

138 

139class PowerOutletTemplateSerializer(ComponentTemplateSerializer): 

140 device_type = DeviceTypeSerializer( 

141 nested=True, 

142 required=False, 

143 allow_null=True, 

144 default=None 

145 ) 

146 module_type = ModuleTypeSerializer( 

147 nested=True, 

148 required=False, 

149 allow_null=True, 

150 default=None 

151 ) 

152 type = ChoiceField( 

153 choices=PowerOutletTypeChoices, 

154 allow_blank=True, 

155 required=False, 

156 allow_null=True 

157 ) 

158 power_port = PowerPortTemplateSerializer( 

159 nested=True, 

160 required=False, 

161 allow_null=True 

162 ) 

163 feed_leg = ChoiceField( 

164 choices=PowerOutletFeedLegChoices, 

165 allow_blank=True, 

166 required=False, 

167 allow_null=True 

168 ) 

169 

170 class Meta: 

171 model = PowerOutletTemplate 

172 fields = [ 

173 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 

174 'color', 'power_port', 'feed_leg', 'description', 'created', 'last_updated', 

175 ] 

176 brief_fields = ('id', 'url', 'display', 'name', 'description') 

177 

178 

179class CoolingIntakeTemplateSerializer(ComponentTemplateSerializer): 

180 device_type = DeviceTypeSerializer( 

181 nested=True, 

182 required=False, 

183 allow_null=True, 

184 default=None 

185 ) 

186 module_type = ModuleTypeSerializer( 

187 nested=True, 

188 required=False, 

189 allow_null=True, 

190 default=None 

191 ) 

192 type = ChoiceField( 

193 choices=CoolingConnectorTypeChoices, 

194 allow_blank=True, 

195 required=False, 

196 allow_null=True 

197 ) 

198 diameter_unit = ChoiceField( 

199 choices=DiameterUnitChoices, 

200 allow_blank=True, 

201 required=False, 

202 allow_null=True 

203 ) 

204 max_flow_unit = ChoiceField( 

205 choices=FlowRateUnitChoices, 

206 allow_blank=True, 

207 required=False, 

208 allow_null=True 

209 ) 

210 

211 class Meta: 

212 model = CoolingIntakeTemplate 

213 fields = [ 

214 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 

215 'diameter', 'diameter_unit', 'max_flow', 'max_flow_unit', 'description', 

216 'created', 'last_updated', 

217 ] 

218 brief_fields = ('id', 'url', 'display', 'name', 'description') 

219 

220 

221class CoolingOutflowTemplateSerializer(ComponentTemplateSerializer): 

222 device_type = DeviceTypeSerializer( 

223 nested=True, 

224 required=False, 

225 allow_null=True, 

226 default=None 

227 ) 

228 module_type = ModuleTypeSerializer( 

229 nested=True, 

230 required=False, 

231 allow_null=True, 

232 default=None 

233 ) 

234 type = ChoiceField( 

235 choices=CoolingConnectorTypeChoices, 

236 allow_blank=True, 

237 required=False, 

238 allow_null=True 

239 ) 

240 diameter_unit = ChoiceField( 

241 choices=DiameterUnitChoices, 

242 allow_blank=True, 

243 required=False, 

244 allow_null=True 

245 ) 

246 cooling_intake = CoolingIntakeTemplateSerializer( 

247 nested=True, 

248 required=False, 

249 allow_null=True 

250 ) 

251 

252 class Meta: 

253 model = CoolingOutflowTemplate 

254 fields = [ 

255 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 

256 'diameter', 'diameter_unit', 'cooling_intake', 'description', 'created', 'last_updated', 

257 ] 

258 brief_fields = ('id', 'url', 'display', 'name', 'description') 

259 

260 

261class InterfaceTemplateSerializer(ComponentTemplateSerializer): 

262 device_type = DeviceTypeSerializer( 

263 nested=True, 

264 required=False, 

265 allow_null=True, 

266 default=None 

267 ) 

268 module_type = ModuleTypeSerializer( 

269 nested=True, 

270 required=False, 

271 allow_null=True, 

272 default=None 

273 ) 

274 type = ChoiceField(choices=InterfaceTypeChoices) 

275 parent = NestedInterfaceTemplateSerializer( 

276 required=False, 

277 allow_null=True 

278 ) 

279 bridge = NestedInterfaceTemplateSerializer( 

280 required=False, 

281 allow_null=True 

282 ) 

283 poe_mode = ChoiceField( 

284 choices=InterfacePoEModeChoices, 

285 required=False, 

286 allow_blank=True, 

287 allow_null=True 

288 ) 

289 poe_type = ChoiceField( 

290 choices=InterfacePoETypeChoices, 

291 required=False, 

292 allow_blank=True, 

293 allow_null=True 

294 ) 

295 rf_role = ChoiceField( 

296 choices=WirelessRoleChoices, 

297 required=False, 

298 allow_blank=True, 

299 allow_null=True 

300 ) 

301 

302 class Meta: 

303 model = InterfaceTemplate 

304 fields = [ 

305 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 'channels', 'channel_id', 

306 'enabled', 'mgmt_only', 'description', 'parent', 'bridge', 'poe_mode', 'poe_type', 'rf_role', 'created', 

307 'last_updated', 

308 ] 

309 brief_fields = ('id', 'url', 'display', 'name', 'description') 

310 

311 

312class RearPortTemplateMappingSerializer(serializers.ModelSerializer): 

313 position = serializers.IntegerField( 

314 source='rear_port_position' 

315 ) 

316 front_port = serializers.PrimaryKeyRelatedField( 

317 queryset=FrontPortTemplate.objects.all(), 

318 ) 

319 

320 class Meta: 

321 model = PortTemplateMapping 

322 fields = ('position', 'front_port', 'front_port_position') 

323 

324 

325class RearPortTemplateSerializer(ComponentTemplateSerializer, PortSerializer): 

326 device_type = DeviceTypeSerializer( 

327 required=False, 

328 nested=True, 

329 allow_null=True, 

330 default=None 

331 ) 

332 module_type = ModuleTypeSerializer( 

333 nested=True, 

334 required=False, 

335 allow_null=True, 

336 default=None 

337 ) 

338 type = ChoiceField(choices=PortTypeChoices) 

339 front_ports = RearPortTemplateMappingSerializer( 

340 source='mappings', 

341 many=True, 

342 required=False, 

343 ) 

344 

345 class Meta: 

346 model = RearPortTemplate 

347 fields = [ 

348 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 'color', 'positions', 

349 'front_ports', 'description', 'created', 'last_updated', 

350 ] 

351 brief_fields = ('id', 'url', 'display', 'name', 'description') 

352 

353 

354class FrontPortTemplateMappingSerializer(serializers.ModelSerializer): 

355 position = serializers.IntegerField( 

356 source='front_port_position' 

357 ) 

358 rear_port = serializers.PrimaryKeyRelatedField( 

359 queryset=RearPortTemplate.objects.all(), 

360 ) 

361 

362 class Meta: 

363 model = PortTemplateMapping 

364 fields = ('position', 'rear_port', 'rear_port_position') 

365 

366 

367class FrontPortTemplateSerializer(ComponentTemplateSerializer, PortSerializer): 

368 device_type = DeviceTypeSerializer( 

369 nested=True, 

370 required=False, 

371 allow_null=True, 

372 default=None 

373 ) 

374 module_type = ModuleTypeSerializer( 

375 nested=True, 

376 required=False, 

377 allow_null=True, 

378 default=None 

379 ) 

380 type = ChoiceField(choices=PortTypeChoices) 

381 rear_ports = FrontPortTemplateMappingSerializer( 

382 source='mappings', 

383 many=True, 

384 required=False, 

385 ) 

386 

387 class Meta: 

388 model = FrontPortTemplate 

389 fields = [ 

390 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'type', 'color', 'positions', 

391 'rear_ports', 'description', 'created', 'last_updated', 

392 ] 

393 brief_fields = ('id', 'url', 'display', 'name', 'description') 

394 

395 

396class ModuleBayTemplateSerializer(ComponentTemplateSerializer): 

397 device_type = DeviceTypeSerializer( 

398 nested=True, 

399 required=False, 

400 allow_null=True, 

401 default=None 

402 ) 

403 module_type = ModuleTypeSerializer( 

404 nested=True, 

405 required=False, 

406 allow_null=True, 

407 default=None 

408 ) 

409 module_bay_types = SerializedPKRelatedField( 

410 queryset=ModuleBayType.objects.all(), 

411 serializer=ModuleBayTypeSerializer, 

412 nested=True, 

413 required=False, 

414 many=True 

415 ) 

416 

417 class Meta: 

418 model = ModuleBayTemplate 

419 fields = [ 

420 'id', 'url', 'display', 'device_type', 'module_type', 'name', 'label', 'position', 'enabled', 'description', 

421 'module_bay_types', 'created', 'last_updated', 

422 ] 

423 brief_fields = ('id', 'url', 'display', 'name', 'enabled', 'description') 

424 

425 

426class DeviceBayTemplateSerializer(ComponentTemplateSerializer): 

427 device_type = DeviceTypeSerializer( 

428 nested=True 

429 ) 

430 

431 class Meta: 

432 model = DeviceBayTemplate 

433 fields = [ 

434 'id', 'url', 'display', 'device_type', 'name', 'label', 'enabled', 'description', 

435 'created', 'last_updated' 

436 ] 

437 brief_fields = ('id', 'url', 'display', 'name', 'enabled', 'description') 

438 

439 

440class InventoryItemTemplateSerializer(ComponentTemplateSerializer): 

441 device_type = DeviceTypeSerializer( 

442 nested=True 

443 ) 

444 parent = serializers.PrimaryKeyRelatedField( 

445 queryset=InventoryItemTemplate.objects.all(), 

446 allow_null=True, 

447 default=None 

448 ) 

449 role = InventoryItemRoleSerializer(nested=True, required=False, allow_null=True) 

450 manufacturer = ManufacturerSerializer( 

451 nested=True, 

452 required=False, 

453 allow_null=True, 

454 default=None 

455 ) 

456 component_type = ContentTypeField( 

457 queryset=ContentType.objects.filter(MODULAR_COMPONENT_TEMPLATE_MODELS), 

458 required=False, 

459 allow_null=True 

460 ) 

461 component = GFKSerializerField(read_only=True) 

462 _depth = serializers.IntegerField(source='level', read_only=True) 

463 

464 class Meta: 

465 model = InventoryItemTemplate 

466 fields = [ 

467 'id', 'url', 'display', 'device_type', 'parent', 'name', 'label', 'role', 'manufacturer', 

468 'part_id', 'description', 'component_type', 'component_id', 'component', 'created', 'last_updated', 

469 '_depth', 

470 ] 

471 brief_fields = ('id', 'url', 'display', 'name', 'description', '_depth')