Enable/Disable sites in Policy Based VPN Topology about fp-ngfw-smc-python HOT 8 CLOSED

pbvpn = PolicyVPN("pbvpn_name")
# depending you want satellite/central here satellite
for gw_node in pbvpn.satellite_gateway_node.all():
    # we look for Plano VPN Gateway
    if gw_node.name == "Plano VPN Gateway":
       # here we look for enabled sites  
       for site in list(gw_node.enabled_sites):
       # here we match site name
         if site.name == "PLANO_SITE":
            site.enable_disable()
pbvpn.save()

vpn_pb = {}
for one_vpn in PolicyVPN.objects.all():
    vpn_pb.update({
        one_vpn.name: one_vpn.key,
        one_vpn.key: one_vpn.name,
    })
engine = Engine("my_firewall")
engine_vpn = {}
for site in engine.vpn.sites:
    for ref in site.vpn_references:
        if ref["vpn_id"] in vpn_pb.keys():
            if vpn_pb.get(ref["vpn_id"]) not in engine_vpn.keys():
                engine_vpn[vpn_pb.get(ref["vpn_id"])] = {}
            engine_vpn[vpn_pb.get(ref["vpn_id"])].update({site.name: ref})

class ConnectionType(Element):
    typeof = 'connection_type'

class EndpointTunnel(SubElement):
    """
    A gateway tunnel represents the point to point connection
    between two IPSEC endpoints in a PolicyVPN configuration. 
    The tunnel arrangement is based on whether the nodes are placed
    as a central gateway or a satellite gateway. This provides access
    to see the point to point connections, whether the link is enabled,
    and setting the presharred key.
    """

    def enable_disable(self):
        """
        Enable or disable the tunnel link between endpoints.
        
        :raises UpdateElementFailed: failed with reason
        :return: None
        """
        if self.enabled:
            self.update(enabled=False)
        else:
            self.update(enabled=True)
    
    @property
    def enabled(self):
        """          
        Whether the VPN link between endpoints is enabled
        
        :rtype: bool
        """
        return self.data.get('enabled', False)
    
    
    @property
    def tunnel_side_a(self):
        """
        Return the gateway node for tunnel side A. This will
        be an instance of GatewayNode.
        
        :rtype: GatewayNode
        """
        return type('TunnelSideA', (InternalEndpoint,), {
            'href': self.data.get('endpoint_1')})()
    
    @property
    def tunnel_side_b(self):
        """
        Return the gateway node for tunnel side B. This will
        be an instance of GatewayNode.
        
        :rtype: GatewayNode
        """
        return type('TunnelSideB', (InternalEndpoint,), {
            'href': self.data.get('endpoint_2')})()
    @property
    def setVPNProfile(self,href):
        return self.data.get('vpn_profile', href)

    def __str__(self):
        return '{0}(tunnel_side_a={1},tunnel_side_b={2})'.format(
            self.__class__.__name__, self.tunnel_side_a.name, self.tunnel_side_b.name)

    def __repr__(self):
        return str(self)
 
 VPNPDV = PolicyVPN(name='VPN-PDV')
    VPNPDV.open()
    ###########MISE EN PLACE DE PROFILE VPN PERSONALISER SUR LES ENDPOINT#############
    for tunnel in VPNPDV.tunnels:
        tunnela = tunnel.tunnel_side_a
        tunnelb = tunnel.tunnel_side_b
        if(tunnel.enabled != ENABLE):
            if(tunnela.name.startswith("FWCENTRAL") and tunnelb.name.startswith("FWDistant") ):
                tunnel.update(enabled=ENABLE)
            

            VPNPDV.save()