def edit_optical_path(request, handle_id):
# Get needed data from node
nh, path = helpers.get_nh_node(handle_id)
relations = path.get_relations()
depends_on = path.get_dependencies()
dependency_categories = 'odf,optical-link,optical-multiplex-section,optical-node,router,switch,optical-path'
if request.POST:
form = forms.EditOpticalPathForm(request.POST)
if form.is_valid():
# Generic node update
helpers.form_update_node(request.user, path.handle_id, form)
# Optical Path node updates
if form.cleaned_data['relationship_provider']:
owner_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, path, owner_nh.handle_id)
if form.cleaned_data['relationship_depends_on']:
depends_on_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_depends_on'])
helpers.set_depends_on(request.user, path, depends_on_nh.handle_id)
if 'saveanddone' in request.POST:
return redirect(nh.get_absolute_url())
else:
return redirect('%sedit' % nh.get_absolute_url())
else:
form = forms.EditOpticalPathForm(path.data)
return render(request, 'noclook/edit/edit_optical_path.html',
{'node_handle': nh, 'form': form, 'node': path, 'relations': relations,
'depends_on': depends_on, 'dependency_categories': dependency_categories})
def edit_cable(request, handle_id):
# Get needed data from node
nh, cable = helpers.get_nh_node(handle_id)
connections = cable.get_connected_equipment()
relations = cable.get_relations()
if request.POST:
form = forms.EditCableForm(request.POST)
if form.is_valid():
# Generic node update
helpers.form_update_node(request.user, cable.handle_id, form)
if form.cleaned_data['relationship_end_a']:
end_a_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_end_a'])
helpers.set_connected_to(request.user, cable, end_a_nh.handle_id)
if form.cleaned_data['relationship_end_b']:
end_b_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_end_b'])
helpers.set_connected_to(request.user, cable, end_b_nh.handle_id)
if form.cleaned_data['relationship_provider']:
owner_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, cable, owner_nh.handle_id)
if 'saveanddone' in request.POST:
return redirect(nh.get_absolute_url())
else:
return redirect('%sedit' % nh.get_absolute_url())
else:
form = forms.EditCableForm(cable.data)
return render(request, 'noclook/edit/edit_cable.html',
{'node_handle': nh, 'form': form, 'node': cable, 'connections': connections,
'relations': relations})
def edit_optical_link(request, handle_id):
# Get needed data from node
nh, link = helpers.get_nh_node(handle_id)
relations = link.get_relations()
depends_on = link.get_dependencies()
if request.POST:
form = forms.EditOpticalLinkForm(request.POST)
if form.is_valid():
if 'type' in form.cleaned_data:
form.cleaned_data['type'] = form.cleaned_data['type'].name
# Generic node update
helpers.form_update_node(request.user, link.handle_id, form)
# Optical Link node updates
if form.cleaned_data['relationship_provider']:
owner_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, link, owner_nh.handle_id)
if form.cleaned_data['relationship_end_a']:
depends_on_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_end_a'])
helpers.set_depends_on(request.user, link, depends_on_nh.handle_id)
if form.cleaned_data['relationship_end_b']:
depends_on_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_end_b'])
helpers.set_depends_on(request.user, link, depends_on_nh.handle_id)
if 'saveanddone' in request.POST:
return redirect(nh.get_absolute_url())
else:
return redirect('%sedit' % nh.get_absolute_url())
else:
form = forms.EditOpticalLinkForm(link.data)
return render(request, 'noclook/edit/edit_optical_link.html',
{'node_handle': nh, 'form': form, 'node': link, 'relations': relations,
'depends_on': depends_on})
def new_switch(request, **kwargs):
if request.POST:
form = forms.NewSwitchForm(request.POST)
if form.is_valid():
try:
nh = helpers.form_to_unique_node_handle(
request, form, 'switch', 'Physical')
except UniqueNodeError:
form = forms.NewSwitchForm(request.POST)
form.add_error('name',
'A Switch with that name already exists.')
return render(request, 'noclook/create/create_switch.html',
{'form': form})
helpers.form_update_node(request.user, nh.handle_id, form)
node = nh.get_node()
if form.cleaned_data['relationship_provider']:
provider_nh = NodeHandle.objects.get(
pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, node, provider_nh.handle_id)
if form.cleaned_data['switch_type']:
switch_type = SwitchType.objects.get(
pk=form.cleaned_data['switch_type'])
helpers.dict_update_node(request.user, nh.handle_id,
{"model": switch_type.name})
if switch_type.ports:
for port in switch_type.ports.split(","):
helpers.create_port(node, port.strip(), request.user)
return redirect(nh.get_absolute_url())
else:
name = kwargs.get('name', None)
initial = {'name': name}
form = forms.NewSwitchForm(initial=initial)
return render(request, 'noclook/create/create_switch.html', {'form': form})
def new_optical_multiplex_section(request, **kwargs):
if request.POST:
form = forms.NewOpticalMultiplexSectionForm(request.POST)
if form.is_valid():
try:
nh = helpers.form_to_unique_node_handle(
request, form, 'optical-multiplex-section', 'Logical')
except UniqueNodeError:
form = forms.NewOpticalMultiplexSectionForm(request.POST)
form.add_error(
'name',
'An Optical Multiplex Section with that name already exists.'
)
return render(
request,
'noclook/create/create_optical_multiplex_section.html',
{'form': form})
helpers.form_update_node(request.user, nh.handle_id, form)
if form.cleaned_data['relationship_provider']:
node = nh.get_node()
provider_nh = NodeHandle.objects.get(
pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, node, provider_nh.handle_id)
return redirect(nh.get_absolute_url())
else:
form = forms.NewOpticalMultiplexSectionForm()
return render(request,
'noclook/create/create_optical_multiplex_section.html',
{'form': form})
def new_cable(request, **kwargs):
cable_types = u', '.join([
u'"{}"'.format(val) for val in Dropdown.get('cable_types').as_values()
])
if request.POST:
form = forms.NewCableForm(request.POST)
if form.is_valid():
try:
nh = helpers.form_to_unique_node_handle(
request, form, 'cable', 'Physical')
except UniqueNodeError:
form = forms.NewCableForm(request.POST)
form.add_error('name',
'A Cable with that name already exists.')
return render(request, 'noclook/create/create_cable.html',
{'form': form})
helpers.form_update_node(request.user, nh.handle_id, form)
if form.cleaned_data['relationship_provider']:
node = nh.get_node()
provider_nh = NodeHandle.objects.get(
pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, node, provider_nh.handle_id)
return redirect(nh.get_absolute_url())
else:
name = kwargs.get('name', None)
initial = {'name': name}
form = forms.NewCableForm(initial=initial)
csv_form = forms.CsvForm(['name, cable_type, description'], request.POST
or None)
return render(request, 'noclook/create/create_cable.html', {
'form': form,
'csv_form': csv_form,
'cable_types': cable_types
})
def create_optical_path(self, name=None):
# create object
if not name:
name = '{}-{}'.format(
self.fake.ean8(), self.escape_quotes(self.fake.license_plate()))
optical_path = self.get_or_create_node(
name, 'Optical Path', META_TYPES[1])
# add context
self.add_network_context(optical_path)
# check if there's any provider or if we should create one
provider_type = NetworkFakeDataGenerator.get_nodetype('Provider')
providers = NodeHandle.objects.filter(node_type=provider_type)
max_providers = self.max_cable_providers
provider = None
if not providers or len(providers) < max_providers:
provider = self.create_provider()
else:
provider = random.choice(list(providers))
# add data
framing_types = self.get_dropdown_keys('optical_path_framing')
capaticy_types = self.get_dropdown_keys('optical_path_capacity')
operational_states = self.get_dropdown_keys('operational_states')
data = {
'description': self.fake.paragraph(),
'framing': random.choice(framing_types),
'capacity': random.choice(capaticy_types),
'operational_state': random.choice(operational_states),
'relationship_provider' : provider.handle_id,
}
for key, value in data.items():
value = self.escape_quotes(value)
optical_path.get_node().add_property(key, value)
helpers.set_provider(self.user,
optical_path.get_node(), provider.handle_id)
# add random dependencies
num_ports = random.randint(0, 3)
for i in range(0, num_ports):
dep_type = random.choice(list(self.optical_path_dependency_types.keys()))
dep_f = self.optical_path_dependency_types[dep_type]
dependency = dep_f()
rel_maker = PhysicalLogicalDataRelationMaker()
rel_maker.add_dependency(self.user, optical_path, dependency)
return optical_path
def create_optical_link(self, name=None):
# create object
if not name:
name = '{}-{}'.format(
self.fake.ean8(), self.escape_quotes(self.fake.license_plate()))
optical_link = self.get_or_create_node(
name, 'Optical Link', META_TYPES[1])
# add context
self.add_network_context(optical_link)
# check if there's any provider or if we should create one
provider_type = NetworkFakeDataGenerator.get_nodetype('Provider')
providers = NodeHandle.objects.filter(node_type=provider_type)
max_providers = self.max_cable_providers
provider = None
if not providers or len(providers) < max_providers:
provider = self.create_provider()
else:
provider = random.choice(list(providers))
# add data
link_types = self.get_dropdown_keys('optical_link_types')
interface_types = self.get_dropdown_keys('optical_link_interface_type')
operational_states = self.get_dropdown_keys('operational_states')
data = {
'description': self.fake.paragraph(),
'link_type': random.choice(link_types),
'interface_type': random.choice(interface_types),
'operational_state': random.choice(operational_states),
'relationship_provider' : provider.handle_id,
}
for key, value in data.items():
value = self.escape_quotes(value)
optical_link.get_node().add_property(key, value)
helpers.set_provider(self.user,
optical_link.get_node(), provider.handle_id)
# add random ports
num_ports = random.randint(1, 3)
for i in range(0, num_ports):
port = self.create_port()
rel_maker = PhysicalLogicalDataRelationMaker()
rel_maker.add_dependency(self.user, optical_link, port)
return optical_link
def edit_service(request, handle_id):
# Get needed data from node
nh, service = helpers.get_nh_node(handle_id)
relations = service.get_relations()
depends_on = service.get_dependencies()
dependency_categories = ['host',
'firewall',
'odf',
'optical-node',
'optical-path',
'optical-filter',
'router',
'service',
'switch',
'external-equipment']
user_categories = ['customer', 'end-user']
if request.POST:
form = forms.EditServiceForm(request.POST)
if form.is_valid():
# Generic node update
helpers.form_update_node(request.user, service.handle_id, form)
# Service node updates
if form.cleaned_data['relationship_provider']:
owner_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_provider'])
helpers.set_provider(request.user, service, owner_nh.handle_id)
if form.cleaned_data['relationship_user']:
user_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_user'])
helpers.set_user(request.user, service, user_nh.handle_id)
if form.cleaned_data['relationship_depends_on']:
depends_on_nh = NodeHandle.objects.get(pk=form.cleaned_data['relationship_depends_on'])
helpers.set_depends_on(request.user, service, depends_on_nh.handle_id)
if 'saveanddone' in request.POST:
return redirect(nh.get_absolute_url())
else:
return redirect('%sedit' % nh.get_absolute_url())
else:
form = forms.EditServiceForm(service.data)
return render(request, 'noclook/edit/edit_service.html',
{'node_handle': nh, 'form': form, 'node': service, 'relations': relations,
'depends_on': depends_on, 'dependency_categories': dependency_categories,
'user_categories': user_categories})
def create_cable(self, name=None):
# create object
if not name:
name = self.fake.hostname()
cable = self.get_or_create_node(
self.fake.hostname(), 'Cable', META_TYPES[0]) # Physical
# add context
self.add_network_context(cable)
# add data
cable_types = self.get_dropdown_keys('cable_types')
# check if there's any provider or if we should create one
provider_type = NetworkFakeDataGenerator.get_nodetype('Provider')
providers = NodeHandle.objects.filter(node_type=provider_type)
max_providers = self.max_cable_providers
provider = None
if not providers or len(providers) < max_providers:
provider = self.create_provider()
else:
provider = random.choice(list(providers))
# add ports
port_a = None
port_b = None
port_type = NetworkFakeDataGenerator.get_nodetype('Port')
total_ports = NodeHandle.objects.filter(node_type=port_type).count()
if total_ports < self.max_ports_total:
port_a = self.create_port()
port_b = self.create_port()
else:
all_ports = list(NodeHandle.objects.filter(node_type=port_type))
port_a = random.choice(all_ports)
port_b = random.choice(all_ports)
data = {
'cable_type' : random.choice(cable_types),
'description' : self.escape_quotes(self.fake.paragraph()),
'relationship_provider' : provider.handle_id,
'relationship_end_a' : port_a.handle_id,
'relationship_end_b' : port_b.handle_id,
}
if sunet_forms_enabled():
try:
cable_contract = random.choice(
DropModel.objects.get(name="tele2_cable_contracts").as_choices()[1:][1]
)
data['tele2_cable_contract'] = cable_contract
except DropModel.DoesNotExist:
logger.warn('Tele2 cable contracts dropdown is not available')
circuit_id = self.escape_quotes(self.fake.ean8())
data['tele2_alternative_circuit_id'] = circuit_id
for key, value in data.items():
value = self.escape_quotes(value)
cable.get_node().add_property(key, value)
# add relationship to provider
helpers.set_provider(self.user, cable.get_node(), provider.handle_id)
helpers.set_connected_to(self.user, cable.get_node(), port_a.handle_id)
helpers.set_connected_to(self.user, cable.get_node(), port_b.handle_id)
return cable
def add_provides(self, user, relation_nh, phylogical_nh):
the_node = phylogical_nh.get_node()
relation_handle_id = relation_nh.handle_id
helpers.set_provider(user, the_node, relation_handle_id)
def create_service(self, name=None):
# import services class / types if necesary
if not ServiceType.objects.all():
dirpath = os.path.dirname(os.path.realpath(__file__))
csv_file = \
'{}/../../../../../scripts/service_types/ndn_service_types.csv'\
.format(dirpath)
call_command(
'import_service_types',
csv_file=csv_file
)
default_test_gen_name = "service_id_generator"
service_types = ServiceType.objects.all()
service_type = random.choice(service_types)
# get or create a default UniqueIdGenerator
if not name:
global_preferences = global_preferences_registry.manager()
id_generator_name = global_preferences\
[NewServiceForm.Meta.id_generator_property]
if not id_generator_name:
global_preferences[NewServiceForm.Meta.id_generator_property] =\
default_test_gen_name
id_generator = UniqueIdGenerator.objects.get_or_create(
name=default_test_gen_name,
zfill=False,
creator=self.user,
modifier=self.user,
)[0]
# id_collection is always the same so we do not need config
name = unique_ids.get_collection_unique_id(
id_generator, NordunetUniqueId)
# create object
service = self.get_or_create_node(
name, 'Service', META_TYPES[1]) # Logical
# add context
self.add_network_context(service)
# check if there's any provider or if we should create one
provider_type = NetworkFakeDataGenerator.get_nodetype('Provider')
providers = NodeHandle.objects.filter(node_type=provider_type)
max_providers = self.max_cable_providers
provider = None
operational_states = self.get_dropdown_keys('operational_states')
if not providers or len(providers) < max_providers:
provider = self.create_provider()
else:
provider = random.choice(list(providers))
helpers.set_provider(self.user, service.get_node(), provider.handle_id)
service_type_name = service_type.name
operational_state = random.choice(operational_states)
data = {
'service_class': service_type.service_class.name,
'service_type': service_type_name,
'operational_state': random.choice(operational_states),
'description': self.fake.paragraph(),
'relationship_provider' : provider.handle_id,
}
if service_type_name == "Project":
data['project_end_date'] = self.get_random_date()
if data['operational_state'] == "Decommissioned":
data['decommissioned_date'] = self.get_random_date()
for key, value in data.items():
if value:
value = self.escape_quotes(value)
service.get_node().add_property(key, value)
# set responsible and support groups
group_type = NetworkFakeDataGenerator.get_nodetype('Group')
groups_nhs = NodeHandle.objects.filter(node_type=group_type)
responsible_group = None
support_group = None
community_generator = CommunityFakeDataGenerator()
if groups_nhs.exists():
responsible_group = random.choice(groups_nhs)
support_group = random.choice(groups_nhs)
else:
responsible_group = community_generator.create_group()
support_group = community_generator.create_group()
helpers.set_takes_responsibility(
self.user, service.get_node(), responsible_group.handle_id)
helpers.set_supports(
self.user, service.get_node(), support_group.handle_id)
# add users
num_users = random.randint(0, 4)
for i in range(0, num_users):
user_type = random.choice(list(self.service_user_categories.keys()))
user_f = self.service_user_categories[user_type]
user = user_f()
rel_maker = LogicalDataRelationMaker()
rel_maker.add_user(self.user, service, user)
# add dependencies
num_dependencies = random.randint(0, 4)
for i in range(0, num_dependencies):
dep_type = random.choice(list(self.service_dependency_types.keys()))
dep_f = self.service_dependency_types[dep_type]
dependency = dep_f()
rel_maker = PhysicalLogicalDataRelationMaker()
rel_maker.add_dependency(self.user, service, dependency)
return service
def link_provider(cls, user, phylog_nh, relation_nh):
helpers.set_provider(user, logical_node.get_node(),
relation_nh.handle_id)
