catalystwan 0.41.2.dev9__py3-none-any.whl → 0.41.3__py3-none-any.whl

catalystwan/api/templates/device_template/device_template.py

@@ -3,37 +3,28 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
-from uuid import UUID
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, List
 
+from jinja2 import DebugUndefined, Environment, FileSystemLoader, meta  # type: ignore
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+from catalystwan.utils.device_model import DeviceModel
+
 if TYPE_CHECKING:
     from catalystwan.session import ManagerSession
 
 logger = logging.getLogger(__name__)
 
 
-TemplateType = Literal["file", "template"]  # file == cli, template == feature
-
-
-def str_to_uuid(s: str) -> Optional[UUID]:
-    try:
-        return UUID(s)
-    except ValueError:
-        return None
-
-
 class GeneralTemplate(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    name: str = Field(default="")
+    name: str = ""
+    subTemplates: List[GeneralTemplate] = []
 
-    sub_templates: List[GeneralTemplate] = Field(
-        default=[], serialization_alias="subTemplates", validation_alias="subTemplates"
-    )
-    template_id: str = Field(default="", serialization_alias="templateId", validation_alias="templateId")
-    template_type: str = Field(default="", serialization_alias="templateType", validation_alias="templateType")
+    templateId: str = ""
+    templateType: str = ""
 
 
 class DeviceTemplate(BaseModel):
@@ -53,67 +44,28 @@ class DeviceTemplate(BaseModel):
     >>> session.api.templates.create(device_template)
     """
 
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    template_name: str = Field(serialization_alias="templateName", validation_alias="templateName")
-    template_description: str = Field(serialization_alias="templateDescription", validation_alias="templateDescription")
-    device_type: str = Field(serialization_alias="deviceType", validation_alias="deviceType")
-    device_role: str = Field(default="sdwan-edge", serialization_alias="deviceRole", validation_alias="deviceRole")
-    config_type: Optional[str] = Field(
-        default="template", serialization_alias="configType", validation_alias="configType"
-    )
-    factory_default: Optional[bool] = Field(
-        default=False, serialization_alias="factoryDefault", validation_alias="factoryDefault"
-    )
-    policy_id: str = Field(default="", serialization_alias="policyId", validation_alias="policyId")
-    feature_template_uid_range: Optional[List] = Field(
-        default=[], serialization_alias="featureTemplateUidRange", validation_alias="featureTemplateUidRange"
-    )
-
-    connection_preference_required: Optional[bool] = Field(
-        default=True,
-        serialization_alias="connectionPreferenceRequired",
-        validation_alias="connectionPreferenceRequired",
-    )
-    connection_preference: Optional[bool] = Field(
-        default=True, serialization_alias="connectionPreference", validation_alias="connectionPreference"
-    )
-
-    general_templates: List[GeneralTemplate] = Field(
-        default=[], serialization_alias="generalTemplates", validation_alias="generalTemplates"
-    )
-    security_policy_id: str = Field(
-        default="", serialization_alias="securityPolicyId", validation_alias="securityPolicyId"
-    )
-    voice_policy_id: Optional[str] = Field(
-        default=None, serialization_alias="voicePolicyId", validation_alias="voicePolicyId"
-    )
-    template_configuration_edited: Optional[str] = Field(
-        default=None, serialization_alias="templateConfigurationEdited", validation_alias="templateConfigurationEdited"
-    )
-    template_configuration: Optional[str] = Field(
-        default=None, serialization_alias="templateConfiguration", validation_alias="templateConfiguration"
-    )
-    rid: Optional[int] = Field(default=None, serialization_alias="@rid", validation_alias="@rid")
-    cli_type: Optional[str] = Field(default=None, serialization_alias="cliType", validation_alias="cliType")
-    copy_edited: Optional[bool] = Field(default=None, serialization_alias="copyEdited", validation_alias="copyEdited")
-
-    def get_security_policy_uuid(self) -> Optional[UUID]:
-        return str_to_uuid(self.security_policy_id)
-
-    def get_policy_uuid(self) -> Optional[UUID]:
-        return str_to_uuid(self.policy_id)
-
-    def get_voice_policy_uuid(self) -> Optional[UUID]:
-        if self.voice_policy_id is None:
-            return None
-        return str_to_uuid(self.voice_policy_id)
-
-    def has_any_policy(self) -> bool:
-        return any((self.policy_id, self.security_policy_id, self.voice_policy_id))
+    template_name: str = Field(alias="templateName")
+    template_description: str = Field(alias="templateDescription")
+    general_templates: List[GeneralTemplate] = Field(alias="generalTemplates")
+    device_role: str = Field(default="sdwan-edge", alias="deviceRole")
+    device_type: DeviceModel = Field(alias="deviceType")
+    security_policy_id: str = Field(default="", alias="securityPolicyId")
+    policy_id: str = Field(default="", alias="policyId")
 
     def generate_payload(self) -> str:
-        output = self.model_dump_json(by_alias=True)
+        env = Environment(
+            loader=FileSystemLoader(self.payload_path.parent),
+            trim_blocks=True,
+            lstrip_blocks=True,
+            undefined=DebugUndefined,
+        )
+        template = env.get_template(self.payload_path.name)
+        output = template.render(self.model_dump())
+
+        ast = env.parse(output)
+        if meta.find_undeclared_variables(ast):
+            logger.info(meta.find_undeclared_variables(ast))
+            raise Exception("There are undeclared variables.")
         return output
 
     @field_validator("general_templates", mode="before")
@@ -127,63 +79,16 @@ class DeviceTemplate(BaseModel):
                 output.append(template)
         return output
 
+    payload_path: Final[Path] = Path(__file__).parent / "device_template_payload.json.j2"
+
     @classmethod
     def get(self, name: str, session: ManagerSession) -> DeviceTemplate:
         device_template = session.api.templates.get(DeviceTemplate).filter(name=name).single_or_default()
         resp = session.get(f"dataservice/template/device/object/{device_template.id}").json()
         return DeviceTemplate(**resp)
 
-    def associate_feature_template(self, template_type: str, template_uuid: UUID) -> None:
-        self.general_templates.append(
-            GeneralTemplate(name="", template_id=str(template_uuid), template_type=template_type)
-        )
-
-    def associate_security_policy(self, security_policy_uuid: UUID) -> None:
-        self.security_policy_id = str(security_policy_uuid)
-
-    def associate_policy(self, policy_uuid: UUID) -> None:
-        self.policy_id = str(policy_uuid)
-
     model_config = ConfigDict(populate_by_name=True, use_enum_values=True)
 
 
 class DeviceSpecificValue(BaseModel):
     property: str
-
-
-class DeviceTemplateConfigAttached(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-    host_name: Optional[str] = Field(None, serialization_alias="host-name", validation_alias="host-name")
-    device_ip: Optional[str] = Field(None, serialization_alias="deviceIP", validation_alias="deviceIP")
-    local_system_ip: Optional[str] = Field(
-        None, serialization_alias="local-system-ip", validation_alias="local-system-ip"
-    )
-    site_id: Optional[str] = Field(None, serialization_alias="site-id", validation_alias="site-id")
-    device_groups: Optional[List[str]] = Field(
-        None, serialization_alias="device-groups", validation_alias="device-groups"
-    )
-    uuid: Optional[str] = Field(None, serialization_alias="uuid", validation_alias="uuid")
-    personality: Optional[str] = Field(None, serialization_alias="personality", validation_alias="personality")
-    config_cloudx_mode: Optional[str] = Field(
-        None, serialization_alias="configCloudxMode", validation_alias="configCloudxMode"
-    )
-
-
-class CreateDeviceInputPayload(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    template_id: str = Field(serialization_alias="templateId", validation_alias="templateId")
-    device_ids: List[str] = Field(serialization_alias="deviceIds", validation_alias="deviceIds")
-    is_edited: bool = Field(serialization_alias="isEdited", validation_alias="isEdited")
-    is_master_edited: bool = Field(serialization_alias="isMasterEdited", validation_alias="isMasterEdited")
-
-
-class DeviceInputValues(BaseModel):
-    model_config = ConfigDict(populate_by_name=True, extra="allow")
-    csv_device_ip: str = Field(validation_alias="csv-deviceIP", serialization_alias="csv-deviceIP")
-    csv_device_id: str = Field(validation_alias="csv-deviceId", serialization_alias="csv-deviceId")
-    csv_host_name: str = Field(validation_alias="csv-host-name", serialization_alias="csv-host-name")
-    csv_status: str = Field(validation_alias="csv-status", serialization_alias="csv-status")
-
-    @property
-    def values(self) -> Dict[str, Any]:
-        return self.__pydantic_extra__ or dict()

catalystwan/api/templates/device_template/device_template_payload.json.j2

@@ -0,0 +1,19 @@
+{
+  "templateName": "{{ template_name }}",
+  "templateDescription": "{{ template_description }}",
+  "deviceType": "{{ device_type }}",
+  "deviceRole": "{{ device_role }}",
+  "configType": "template",
+  "factoryDefault": false,
+  "policyId": "{{ policy_id }}",
+  "featureTemplateUidRange": [],
+  "connectionPreferenceRequired": true,
+  "connectionPreference": true,
+  "generalTemplates": [
+        {% for template in general_templates %}
+			{{ template | tojson }}
+		{% if not loop.last %},{% endif %}
+		{% endfor %}
+  ],
+  "securityPolicyId": "{{ security_policy_id }}"
+}

catalystwan/api/templates/feature_template.py

@@ -11,7 +11,7 @@ from jinja2 import DebugUndefined, Environment, FileSystemLoader, meta  # type:
 from pydantic import BaseModel, model_validator
 
 from catalystwan.api.templates.device_variable import DeviceVariable
-from catalystwan.models.common import DeviceModel
+from catalystwan.utils.device_model import DeviceModel
 from catalystwan.utils.dict import FlattenedDictValue, flatten_dict
 from catalystwan.utils.feature_template.find_template_values import find_template_values
 from catalystwan.utils.pydantic_field import get_extra_field
@@ -118,7 +118,7 @@ class FeatureTemplate(FeatureTemplateValidator, ABC):
         template_info = (
             session.api.templates._get_feature_templates(summary=False).filter(name=name).single_or_default()
         )
-        template_definition_as_dict = json.loads(cast(str, template_info.template_definition))
+        template_definition_as_dict = json.loads(cast(str, template_info.template_definiton))
 
         feature_template_model = choose_model(type_value=template_info.template_type)
 
@@ -128,6 +128,6 @@ class FeatureTemplate(FeatureTemplateValidator, ABC):
         return feature_template_model(
             template_name=template_info.name,
             template_description=template_info.description,
-            device_models=[model for model in template_info.device_type],
+            device_models=[DeviceModel(model) for model in template_info.device_type],
             **flattened_values,
         )

catalystwan/api/templates/models/cisco_aaa_model.py

@@ -1,331 +1,84 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
+from enum import Enum
 from pathlib import Path
-from typing import ClassVar, List, Literal, Optional
+from typing import ClassVar, List, Optional
 
 from pydantic import ConfigDict, Field
 
-from catalystwan.api.templates.bool_str import BoolStr
 from catalystwan.api.templates.feature_template import FeatureTemplate, FeatureTemplateValidator
 
-Privilage = Literal["1", "15"]
-
-AccountingMethod = Literal["commands", "exec", "network", "system"]
-
-AuthorizationMethod = Literal["commands"]
-
-DomainStripping = Literal["yes", "no", "right-to-left"]
-
-AuthenticationType = Literal["any", "all", "session-key"]
-
-
-class PubkeyChain(FeatureTemplateValidator):
-    key_string: str = Field(
-        description="Set the RSA key string",
-        json_schema_extra={"vmanage_key": "key-string"},
-    )
-    key_type: Optional[str] = Field(
-        default="ssh-rsa",
-        description="Only RSA is supported",
-        json_schema_extra={"vmanage_key": "key-type"},
-    )
-
 
 class User(FeatureTemplateValidator):
-    name: str = Field(description="The name of the user")
-    password: Optional[str] = Field(default=None, description="The password for the user")
-    secret: Optional[str] = Field(default=None, description="The secret for the user")
-    privilege: Optional[Privilage] = Field(default="15", description="The privilege level for the user")
-    pubkey_chain: Optional[List[PubkeyChain]] = Field(
-        default=None,
-        description="List of public keys for the user",
-        json_schema_extra={"vmanage_key": "pubkey-chain"},
-    )
-
-
-class AccountingRule(FeatureTemplateValidator):
-    model_config = ConfigDict(populate_by_name=True)
-
-    rule_id: str = Field(
-        description="Accounting Rule ID",
-        json_schema_extra={"vmanage_key": "rule-id"},
-    )
-    method: AccountingMethod = Field(
-        description="Configure Accounting Method",
-        json_schema_extra={"vmanage_key": "method"},
-    )
-    level: Optional[Privilage] = Field(
-        default=None,
-        description="Privilege level when method is commands",
-        json_schema_extra={"vmanage_key": "level"},
-    )
-    start_stop: Optional[BoolStr] = Field(
-        default=True,
-        description="Enable Start-Stop",
-        json_schema_extra={"vmanage_key": "start-stop"},
-    )
-    group: str = Field(
-        description="List of groups.",
-        json_schema_extra={"vmanage_key": "group"},
-    )
-
-
-class AuthorizationRules(FeatureTemplateValidator):
-    model_config = ConfigDict(populate_by_name=True)
-
-    rule_id: str = Field(
-        description="Authorization Rule ID",
-        json_schema_extra={"vmanage_key": "rule-id"},
-    )
-    method: AuthorizationMethod = Field(
-        description="Configure Authorization Method",
-        json_schema_extra={"vmanage_key": "method"},
-    )
-    level: Optional[Privilage] = Field(
-        default=None,
-        description="Privilege level when method is commands",
-        json_schema_extra={"vmanage_key": "level"},
-    )
-    group: str = Field(
-        description="List of groups.",
-        json_schema_extra={"vmanage_key": "group"},
-    )
-    authenticated: Optional[BoolStr] = Field(
-        default=False,
-        description="Succeed if user has authenticated",
-        json_schema_extra={"vmanage_key": "if-authenticated"},
-    )
+    name: str
+    password: Optional[str] = None
+    secret: Optional[str] = None
+    privilege: Optional[str] = None
+    pubkey_chain: List[str] = Field(default=[], json_schema_extra={"vmanage_key": "pubkey-chain", "vip_type": "ignore"})
 
 
 class RadiusServer(FeatureTemplateValidator):
     model_config = ConfigDict(populate_by_name=True, coerce_numbers_to_str=True)
 
-    address: str = Field(description="The IP address or hostname of the RADIUS server")
-    auth_port: int = Field(
-        default=1812,
-        json_schema_extra={"vmanage_key": "auth-port"},
-        description="The authentication port for the RADIUS server",
-    )
-    acct_port: int = Field(
-        default=1813,
-        json_schema_extra={"vmanage_key": "acct-port"},
-        description="The accounting port for the RADIUS server",
-    )
-    timeout: int = Field(default=5, description="The timeout period in seconds for the RADIUS server")
-    retransmit: int = Field(default=3, description="The number of retransmit attempts for the RADIUS server")
-    key: str = Field(description="The key for the RADIUS server")
-    secret_key: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "secret-key"},
-        description="The secret key for the RADIUS server",
-    )
-    key_enum: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "key-enum"},
-        description="The key enumeration for the RADIUS server",
-    )
-    key_type: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "key-type"},
-        description="The key type for the RADIUS server",
-    )
+    address: str
+    auth_port: int = Field(default=1812, json_schema_extra={"vmanage_key": "auth-port"})
+    acct_port: int = Field(default=1813, json_schema_extra={"vmanage_key": "acct-port"})
+    timeout: int = Field(default=5)
+    retransmit: int = 3
+    key: str
+    secret_key: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "secret-key"})
+    key_enum: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "key-enum"})
+    key_type: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "key-type"})
 
 
 class RadiusGroup(FeatureTemplateValidator):
     model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
-    group_name: str = Field(
-        json_schema_extra={"vmanage_key": "group-name"},
-        description="The name of the RADIUS group",
-    )
-    vpn: Optional[int] = Field(default=None, description="The VPN ID for the RADIUS group")
-    source_interface: Optional[str] = Field(
-        json_schema_extra={"vmanage_key": "source-interface"},
-        description="The source interface for the RADIUS group",
-    )
-    server: List[RadiusServer] = Field(default=[], description="The list of RADIUS servers for the group")
+    group_name: str = Field(json_schema_extra={"vmanage_key": "group-name"})
+    vpn: Optional[int] = None
+    source_interface: Optional[str] = Field(json_schema_extra={"vmanage_key": "source-interface"})
+    server: List[RadiusServer] = []
 
 
-class RadiusVPN(FeatureTemplateValidator):
-    name: str = Field(
-        description="VPN ID",
-        json_schema_extra={
-            "vmanage_key": "name",
-        },
-    )
-    server_key: str = Field(
-        description="Specify a RADIUS client server-key",
-        json_schema_extra={
-            "vmanage_key": "server-key",
-        },
-    )  # needs enryption
-
-
-class RadiusClient(FeatureTemplateValidator):
-    ip: str = Field(
-        description="The Client IP",
-        json_schema_extra={"vmanage_key": "ip"},
-    )
-    vpn: List[RadiusVPN] = Field(
-        description="The VPN Configuration",
-        json_schema_extra={"vmanage_key": "vpn"},
-    )
+class DomainStripping(str, Enum):
+    YES = "yes"
+    NO = "no"
+    RIGHT_TO_LEFT = "right-to-left"
 
 
 class TacacsServer(FeatureTemplateValidator):
     model_config = ConfigDict(populate_by_name=True)
 
-    address: str = Field(description="The IP address or hostname of the TACACS+ server")
-    key: str = Field(description="The key for the TACACS+ server")
-    port: int = Field(default=49, description="The port for the TACACS+ server")
-    timeout: int = Field(default=5, description="The timeout period in seconds for the TACACS+ server")
-    secret_key: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "secret-key"},
-        description="The secret key for the TACACS+ server",
-    )
-    key_enum: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "key-enum"},
-        description="The key enumeration for the TACACS+ server",
-    )
+    address: str
+    port: int = 49
+    timeout: int = Field(default=5)
+    key: str
+    secret_key: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "secret-key"})
+    key_enum: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "key-enum"})
 
 
 class TacacsGroup(FeatureTemplateValidator):
     model_config = ConfigDict(populate_by_name=True)
 
-    group_name: str = Field(
-        json_schema_extra={"vmanage_key": "group-name"},
-        description="The name of the TACACS+ group",
-    )
-    vpn: int = Field(default=0, description="The VPN ID for the TACACS+ group")
-    source_interface: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "source-interface"},
-        description="The source interface for the TACACS+ group",
-    )
-    server: List[TacacsServer] = Field(default=[], description="The list of TACACS+ servers for the group")
+    group_name: str = Field(json_schema_extra={"vmanage_key": "group-name"})
+    vpn: int = 0
+    source_interface: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "source-interface"})
+    server: List[TacacsServer] = []
 
 
 class CiscoAAAModel(FeatureTemplate):
     model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-    _docs_description: str = "Cisco AAA Feature Template configuration"
 
-    authentication_group: Optional[BoolStr] = Field(
-        default=False,
-        json_schema_extra={
-            "data_path": ["authentication", "dot1x", "default"],
-            "vmanage_key": "authentication_group",
-        },
-        description="Whether to enable the authentication group, GUI equivalent: Authentication Param",
-    )
-    accounting_group: Optional[BoolStr] = Field(
-        default=False,
-        json_schema_extra={
-            "data_path": ["accounting", "dot1x", "default", "start-stop"],
-            "vmanage_key": "accounting_group",
-        },
-        description="Whether to enable the accounting group, GUI equivalent: Accounting Param",
-    )
-    server_auth_order: str = Field(
-        default="local",
-        json_schema_extra={"vmanage_key": "server-auth-order"},
-        description="ServerGroups authentication order to user access",
-    )  # example: "local,tacacs-5,radius-4"
-    user: Optional[List[User]] = Field(default=None, description="List of local user configurations")
-
-    accounting_rules: Optional[List[AccountingRule]] = Field(
-        default=None,
-        description="Configure the accounting rules",
-        json_schema_extra={
-            "data_path": ["accounting"],
-            "vmanage_key": "accounting-rule",
-        },
-    )
-
-    authorization_console: Optional[BoolStr] = Field(
-        default=None,
-        description="For enabling console authorization",
-        json_schema_extra={
-            "data_path": ["authorization"],
-            "vmanage_key": "authorization-console",
-        },
-    )
-    authorization_config_commands: Optional[BoolStr] = Field(
-        default=None,
-        description="For configuration mode commands",
-        json_schema_extra={
-            "data_path": ["authorization"],
-            "vmanage_key": "authorization-config-commands",
-        },
-    )
-    authorization_rules: Optional[List[AuthorizationRules]] = Field(
-        default=None,
-        description="Configure the accounting rules",
-        json_schema_extra={
-            "data_path": ["authorization"],
-            "vmanage_key": "authorization-rule",
-        },
-    )
-    radius: Optional[List[RadiusGroup]] = Field(default=None, description="List of Radius group configurations")
-    radius_client: Optional[List[RadiusClient]] = Field(
-        default=None,
-        json_schema_extra={
-            "data_path": ["radius-dynamic-author"],
-            "vmanage_key": "radius-client",
-        },
-        description="Specify a RADIUS client",
-    )
+    user: Optional[List[User]] = None
+    authentication_group: bool = Field(default=False, json_schema_extra={"vmanage_key": "authentication_group"})
+    accounting_group: bool = True
+    radius: Optional[List[RadiusGroup]] = None
     domain_stripping: Optional[DomainStripping] = Field(
-        default=None,
-        json_schema_extra={
-            "data_path": ["radius-dynamic-author"],
-            "vmanage_key": "domain-stripping",
-        },
-        description="The domain stripping configuration",
-    )
-    authentication_type: Optional[AuthenticationType] = Field(
-        default="any",
-        json_schema_extra={
-            "data_path": ["radius-dynamic-author"],
-            "vmanage_key": "auth-type",
-        },
-        description="Authentication Type",
-    )
-    port: Optional[int] = Field(
-        default=1700,
-        json_schema_extra={
-            "data_path": ["radius-dynamic-author"],
-            "vmanage_key": "port",
-        },
-        description="Specify Radius Dynamic Author Port",
-    )
-    server_key_password: Optional[str] = Field(
-        default=None,
-        json_schema_extra={
-            "data_path": ["radius-dynamic-author"],
-            "vmanage_key": "rda-server-key",
-        },
-        description="Specify a radius dynamic author server-key",
-    )  # needs encryption
-
-    cts_authorization_list: Optional[str] = Field(
-        default=None,
-        json_schema_extra={
-            "data_path": ["radius-trustsec"],
-            "vmanage_key": "cts-auth-list",
-        },
-        description="Specify a radius dynamic author server-key",
-    )
-    radius_trustsec_group: Optional[str] = Field(
-        default=None,
-        json_schema_extra={
-            "data_path": ["radius-trustsec"],
-            "vmanage_key": "radius-trustsec-group",
-        },
-        description="RADIUS trustsec group",
+        default=None, json_schema_extra={"vmanage_key": "domain-stripping"}
     )
-    tacacs: Optional[List[TacacsGroup]] = Field(default=None, description="List of TACACS group configurations")
+    port: int = 1700
+    tacacs: Optional[List[TacacsGroup]] = None
+    server_auth_order: str = Field(default="local", json_schema_extra={"vmanage_key": "server-auth-order"})
 
     payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
     type: ClassVar[str] = "cedge_aaa"

catalystwan/api/templates/models/cisco_banner_model.py

@@ -10,18 +10,9 @@ from catalystwan.api.templates.feature_template import FeatureTemplate
 
 class CiscoBannerModel(FeatureTemplate):
     model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-    _docs_description: str = "Cisco Banner configuration for login and message of the day (MOTD)"
 
-    login_banner: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "login"},
-        description="The login banner text displayed before authentication",
-    )
-    motd_banner: Optional[str] = Field(
-        default=None,
-        json_schema_extra={"vmanage_key": "motd"},
-        description="The message of the day (MOTD) banner text displayed after successful authentication",
-    )
+    login_banner: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "login"})
+    motd_banner: Optional[str] = Field(default=None, json_schema_extra={"vmanage_key": "motd"})
 
     payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
     type: ClassVar[str] = "cisco_banner"