def to_plan(self) -> Plan:
plan_dict = self.plan
device_types = [PlanDeviceType(**i) for i in plan_dict["deviceTypes"]]
devices = [
PlanDevice(
device_name=i["device_name"],
device_type=i["device_type"],
id=convert(i["id"], ID),
) for i in plan_dict["devices"]
]
return Plan(
id=convert(plan_dict["id"], ID),
company_id=convert_or_none(plan_dict["company_id"], ID),
name=plan_dict["name"],
description=plan_dict["description"],
active=plan_dict["active"],
max_devices=plan_dict["max_devices"],
max_fps=plan_dict["max_fps"],
bgp_enabled=plan_dict["bgp_enabled"],
fast_retention=plan_dict["fast_retention"],
full_retention=plan_dict["full_retention"],
created_date=plan_dict["cdate"],
updated_date=plan_dict.get("edate"),
max_bigdata_fps=plan_dict["max_bigdata_fps"],
device_types=device_types,
devices=devices,
metadata=plan_dict["metadata"],
)
def to_all_interfaces(self) -> AllInterfaces:
return AllInterfaces(
device_id=convert(self.device_id, ID),
snmp_speed=convert(self.snmp_speed, int),
interface_description=self.interface_description,
initial_snmp_speed=convert_or_none(self.initial_snmp_speed, int),
)
def to_tag(self) -> Tag:
return Tag(
flow_tag=self.tag.flow_tag,
device_name=self.tag.device_name,
interface_name=self.tag.interface_name,
addr=self.tag.addr,
port=self.tag.port,
tcp_flags=self.tag.tcp_flags,
protocol=self.tag.protocol,
asn=self.tag.asn,
nexthop=self.tag.nexthop,
nexthop_asn=self.tag.nexthop_asn,
bgp_aspath=self.tag.bgp_aspath,
bgp_community=self.tag.bgp_community,
device_type=self.tag.device_type,
site=self.tag.site,
lasthop_as_name=self.tag.lasthop_as_name,
nexthop_as_name=self.tag.nexthop_as_name,
mac=self.tag.mac,
country=self.tag.country,
vlans=self.tag.vlans,
id=convert(self.tag.id, ID),
company_id=convert(self.tag.company_id, ID),
addr_count=self.tag.addr_count,
user_id=convert(self.tag.user, ID),
mac_count=self.tag.mac_count,
edited_by=self.tag.edited_by,
created_date=self.tag.created_date,
updated_date=self.tag.updated_date,
)
def to_populator(self) -> Populator:
return Populator(
dimension_id=convert(self.dimension_id, ID),
value=self.value,
direction=convert(self.direction.upper(), Populator.Direction),
device_name=self.device_name,
interface_name=self.interface_name,
addr=self.addr,
port=self.port,
tcp_flags=self.tcp_flags,
protocol=self.protocol,
asn=self.asn,
nexthop_asn=self.nexthop_asn,
nexthop=self.nexthop,
bgp_aspath=self.bgp_aspath,
bgp_community=self.bgp_community,
device_type=self.device_type,
site=self.site,
lasthop_as_name=self.lasthop_as_name,
nexthop_as_name=self.nexthop_as_name,
mac=self.mac,
country=self.country,
vlans=self.vlans,
id=convert(self.id, ID),
company_id=convert(self.company_id, ID),
user=self.user,
mac_count=self.mac_count,
addr_count=self.addr_count,
created_date=self.created_date,
updated_date=self.updated_date,
)
def to_site(self) -> Site:
return Site(
self.site.site_name,
self.site.lat,
self.site.lon,
convert(self.site.id, ID),
convert(self.site.company_id, ID),
)
def to_custom_dimension(self) -> CustomDimension:
return CustomDimension(
name=self.name,
display_name=self.display_name,
type=self.type,
populators=self.populators.to_populators(),
id=convert(self.id, ID),
company_id=convert(self.company_id, ID),
)
def to_tenant_user(self):
return TenantUser(
id=convert(self.id, ID),
tenant_id=convert(self.tenant_id, ID),
company_id=convert(self.company_id, ID),
user_email=self.user_email,
last_login=self.last_login,
user_name=self.user_name,
user_full_name=self.user_full_name,
)
def tenant_user_from_dict(dic: Dict[str, Any]) -> TenantUser:
return TenantUser(
id=convert(dic["id"], ID),
user_email=dic["user_email"],
tenant_id=convert(dic["tenant_id"], ID),
company_id=convert(dic["company_id"], ID),
last_login=dic.get("last_login"),
user_name=dic.get("user_name"),
user_full_name=dic.get("user_full_name"),
)
def to_device_label(self) -> DeviceLabel:
return DeviceLabel(
name=self.name,
color=self.color,
id=convert(self.id, ID),
user_id=convert(self.user_id, ID),
company_id=convert(self.company_id, ID),
devices=self.devices.to_device_items(),
created_date=self.created_date,
updated_date=self.updated_date,
)
def to_device_label(self) -> DeviceLabel:
return DeviceLabel(
id=convert(self.id, ID),
color=self.color,
name=self.name,
user_id=convert(self.user_id, ID),
company_id=convert(self.company_id, ID),
created_date=self.cdate,
updated_date=self.edate,
devices=None,
)
def to_alert(self) -> HistoricalAlert:
dic = deepcopy(self.__dict__)
dic.pop("ctime")
date_parse = lambda date: datetime.strptime(date,
"%Y-%m-%dT%H:%M:%S.000Z")
dic["creation_time"] = convert(self.ctime, date_parse)
date_parse = lambda date: datetime.strptime(date, "%Y-%m-%d %H:%M:%S")
dic["alarm_start_time"] = convert(self.alarm_start_time, date_parse)
return HistoricalAlert(**dic)
def to_saved_filter(self) -> SavedFilter:
filters_obj = self._to_filters(self.filters)
return SavedFilter(
company_id=convert(self.company_id, ID),
created_date=self.cdate,
updated_date=self.edate,
filter_description=self.filter_description,
filter_level=self.filter_level,
filter_name=self.filter_name,
filters=filters_obj,
id=convert(self.id, ID),
)
def to_custom_application(self) -> CustomApplication:
return CustomApplication(
name=self.name,
description=self.description,
ip_range=self.ip_range,
protocol=self.protocol,
port=self.port,
asn=self.asn,
id=convert(self.id, ID),
company_id=convert(self.company_id, ID),
user_id=convert(self.user_id, ID),
created_date=self.cdate,
updated_date=self.edate,
)
def to_applied_labels(self) -> AppliedLabels:
labels = [l.to_device_label() for l in self.labels]
return AppliedLabels(
id=convert(self.id, ID),
device_name=self.device_name,
labels=labels,
)
def to_device_item(self) -> DeviceItem:
return DeviceItem(
id=convert(self.id, ID),
device_name=self.device_name,
device_subtype=self.device_subtype,
device_type=self.device_type,
)
def test_convert_provided_invalid_data_format_raises_error() -> None:
# given
attr = "0x18" # cant convert 0x18 to int with base 10
convert_func = int
# when - then
with pytest.raises(DataFormatError):
_ = convert(attr, convert_func)
def to_user(self) -> User:
return User(
id=convert(self.id, ID),
username=self.username,
full_name=self.user_full_name,
email=self.user_email,
role=self.role,
email_service=bool(self.email_service),
email_product=bool(self.email_product),
last_login=self.last_login,
created_date=self.created_date,
updated_date=self.updated_date,
company_id=convert(self.company_id, ID),
api_token=self.user_api_token,
filters=dict(self.filters),
saved_filters=list(self.saved_filters),
)
def to_site(self) -> Site:
return Site(
site_name=self.site_name,
latitude=self.lat,
longitude=self.lon,
id=convert(self.id, ID),
company_id=convert_or_none(self.company_id, ID),
)
def to_tenant(self) -> Tenant:
users = [tenant_user_from_dict(i) for i in self.users]
return Tenant(
id=convert(self.id, ID),
users=users,
created_date=self.created_date,
updated_date=self.updated_date,
name=self.name,
description=self.description,
)
def test_convert_provided_valid_data_format_returns_value() -> None:
# given
attr = "128"
convert_func = int
# when
result = convert(attr, convert_func)
# then
assert result == 128
def to_alarm(self) -> Alarm:
dic = self.__dict__
try: # when alarm end is not specified, the alarm_end is set to "0000-00-00 00:00:00" then converted to None
dic["alarm_end"] = datetime.strptime(self.alarm_end,
"%Y-%m-%d %H:%M:%S")
except ValueError as err:
if dic["alarm_end"] == "0000-00-00 00:00:00":
dic["alarm_end"] = None
else:
raise DataFormatError(str(err))
date_parse = lambda date: datetime.strptime(date,
"%Y-%m-%dT%H:%M:%S.000Z")
dic["alarm_start"] = convert(self.alarm_start, date_parse)
return Alarm(**dic)
def from_dict(cls, dic: Dict[str, Any]):
required_fields = [
"id",
"snmp_id",
"snmp_speed",
"interface_description",
"company_id",
"device_id",
"cdate",
"edate",
]
validate_fields(class_name=cls.__name__, required_fields=required_fields, dic=dic)
# recreate GET/POST/PUT response payload: fill all available fields
# warning: snmp_speed comes back as str for GET, but as int for POST/PUT
# warning: initial_snmp_id comes back as empty string instead of null when not set
return cls(
# always returned fields
id=dic["id"],
snmp_id=dic["snmp_id"],
snmp_speed=convert(dic["snmp_speed"], int),
interface_description=dic["interface_description"],
company_id=dic["company_id"],
device_id=dic["device_id"],
cdate=dic["cdate"],
edate=dic["edate"],
# optional fields
snmp_alias=dic.get("snmp_alias"),
interface_ip=dic.get("interface_ip"),
interface_ip_netmask=dic.get("interface_ip_netmask"),
vrf_id=dic.get("vrf_id"),
vrf=convert_or_none(dic.get("vrf"), VRFAttributesPayload.from_dict),
secondary_ips=convert_list_or_none(dic.get("secondary_ips"), SecondaryIPPayload.from_dict),
initial_snmp_id=dic.get("initial_snmp_id") if dic.get("initial_snmp_id") != "" else None,
initial_snmp_alias=dic.get("initial_snmp_alias"),
initial_interface_description=dic.get("initial_interface_description"),
initial_snmp_speed=dic.get("initial_snmp_speed"),
provider=dic.get("provider"),
top_nexthop_asns=convert_list_or_none(dic.get("top_nexthop_asns"), TopNextHopASNPayload.from_dict),
)
def from_id_list(cls, ids: List[ID]):
labels = [LabelIDPayload(id=convert(label_id, int)) for label_id in ids]
return cls(labels=labels)
