0
# Configuration and Settings
1

2
Security Center configuration and settings management capabilities, providing centralized configuration for security settings, contact management, workspace settings, auto-provisioning, and data export configuration.
3

4
## Capabilities
5

6
### Settings Management
7

8
Manage Azure Security Center configuration settings including data export, alert synchronization, and feature enablement.
9

10
```python { .api }
11
def list(
12
    **kwargs: Any
13
) -> Iterator[Setting]:
14
    """
15
    List all security settings for the subscription.
16
    
17
    Returns:
18
    Iterator[Setting]: Iterator of Setting objects
19
    """
20

21
def get(
22
    setting_name: str,
23
    **kwargs: Any
24
) -> Setting:
25
    """
26
    Get details of a specific security setting.
27
    
28
    Parameters:
29
    - setting_name (str): Name of the setting (MCAS, WDATP, SENTINEL)
30
    
31
    Returns:
32
    Setting: Security setting details
33
    """
34

35
def update(
36
    setting_name: str,
37
    setting: Setting,
38
    **kwargs: Any
39
) -> Setting:
40
    """
41
    Update a security setting.
42
    
43
    Parameters:
44
    - setting_name (str): Name of the setting
45
    - setting (Setting): Updated setting configuration
46
    
47
    Returns:
48
    Setting: Updated security setting
49
    """
50
```
51

52
### Security Contacts
53

54
Manage security contact information for alert notifications and communication.
55

56
```python { .api }
57
def list(
58
    **kwargs: Any
59
) -> Iterator[SecurityContact]:
60
    """
61
    List security contacts for the subscription.
62
    
63
    Returns:
64
    Iterator[SecurityContact]: Iterator of SecurityContact objects
65
    """
66

67
def get(
68
    security_contact_name: str,
69
    **kwargs: Any
70
) -> SecurityContact:
71
    """
72
    Get details of a specific security contact.
73
    
74
    Parameters:
75
    - security_contact_name (str): Name of the security contact
76
    
77
    Returns:
78
    SecurityContact: Security contact details
79
    """
80

81
def create(
82
    security_contact_name: str,
83
    security_contact: SecurityContact,
84
    **kwargs: Any
85
) -> SecurityContact:
86
    """
87
    Create a security contact.
88
    
89
    Parameters:
90
    - security_contact_name (str): Name of the security contact
91
    - security_contact (SecurityContact): Contact information
92
    
93
    Returns:
94
    SecurityContact: Created security contact
95
    """
96

97
def update(
98
    security_contact_name: str,
99
    security_contact: SecurityContact,
100
    **kwargs: Any
101
) -> SecurityContact:
102
    """
103
    Update a security contact.
104
    
105
    Parameters:
106
    - security_contact_name (str): Name of the security contact
107
    - security_contact (SecurityContact): Updated contact information
108
    
109
    Returns:
110
    SecurityContact: Updated security contact
111
    """
112

113
def delete(
114
    security_contact_name: str,
115
    **kwargs: Any
116
) -> None:
117
    """
118
    Delete a security contact.
119
    
120
    Parameters:
121
    - security_contact_name (str): Name of the security contact
122
    
123
    Returns:
124
    None
125
    """
126
```
127

128
### Auto Provisioning Settings
129

130
Manage automatic provisioning of security agents and extensions.
131

132
```python { .api }
133
def list(
134
    **kwargs: Any
135
) -> Iterator[AutoProvisioningSetting]:
136
    """
137
    List auto provisioning settings for the subscription.
138
    
139
    Returns:
140
    Iterator[AutoProvisioningSetting]: Iterator of auto provisioning settings
141
    """
142

143
def get(
144
    setting_name: str,
145
    **kwargs: Any
146
) -> AutoProvisioningSetting:
147
    """
148
    Get details of a specific auto provisioning setting.
149
    
150
    Parameters:
151
    - setting_name (str): Name of the setting
152
    
153
    Returns:
154
    AutoProvisioningSetting: Auto provisioning setting details
155
    """
156

157
def create(
158
    setting_name: str,
159
    setting: AutoProvisioningSetting,
160
    **kwargs: Any
161
) -> AutoProvisioningSetting:
162
    """
163
    Create an auto provisioning setting.
164
    
165
    Parameters:
166
    - setting_name (str): Name of the setting
167
    - setting (AutoProvisioningSetting): Setting configuration
168
    
169
    Returns:
170
    AutoProvisioningSetting: Created auto provisioning setting
171
    """
172
```
173

174
### Workspace Settings
175

176
Manage Log Analytics workspace settings for Security Center data collection.
177

178
```python { .api }
179
def list(
180
    **kwargs: Any
181
) -> Iterator[WorkspaceSetting]:
182
    """
183
    List workspace settings for the subscription.
184
    
185
    Returns:
186
    Iterator[WorkspaceSetting]: Iterator of WorkspaceSetting objects
187
    """
188

189
def get(
190
    workspace_setting_name: str,
191
    **kwargs: Any
192
) -> WorkspaceSetting:
193
    """
194
    Get details of a specific workspace setting.
195
    
196
    Parameters:
197
    - workspace_setting_name (str): Name of the workspace setting
198
    
199
    Returns:
200
    WorkspaceSetting: Workspace setting details
201
    """
202

203
def create(
204
    workspace_setting_name: str,
205
    workspace_setting: WorkspaceSetting,
206
    **kwargs: Any
207
) -> WorkspaceSetting:
208
    """
209
    Create a workspace setting.
210
    
211
    Parameters:
212
    - workspace_setting_name (str): Name of the workspace setting
213
    - workspace_setting (WorkspaceSetting): Workspace configuration
214
    
215
    Returns:
216
    WorkspaceSetting: Created workspace setting
217
    """
218

219
def update(
220
    workspace_setting_name: str,
221
    workspace_setting: WorkspaceSetting,
222
    **kwargs: Any
223
) -> WorkspaceSetting:
224
    """
225
    Update a workspace setting.
226
    
227
    Parameters:
228
    - workspace_setting_name (str): Name of the workspace setting
229
    - workspace_setting (WorkspaceSetting): Updated workspace configuration
230
    
231
    Returns:
232
    WorkspaceSetting: Updated workspace setting
233
    """
234

235
def delete(
236
    workspace_setting_name: str,
237
    **kwargs: Any
238
) -> None:
239
    """
240
    Delete a workspace setting.
241
    
242
    Parameters:
243
    - workspace_setting_name (str): Name of the workspace setting
244
    
245
    Returns:
246
    None
247
    """
248
```
249

250
### Sensitivity Settings
251

252
Manage data sensitivity and classification settings for Security Center.
253

254
```python { .api }
255
def list(
256
    **kwargs: Any
257
) -> Iterator[GetSensitivitySettingsResponse]:
258
    """
259
    List sensitivity settings for the subscription.
260
    
261
    Returns:
262
    Iterator[GetSensitivitySettingsResponse]: Iterator of sensitivity settings
263
    """
264

265
def get(
266
    **kwargs: Any
267
) -> GetSensitivitySettingsResponse:
268
    """
269
    Get sensitivity settings for the subscription.
270
    
271
    Returns:
272
    GetSensitivitySettingsResponse: Sensitivity settings details
273
    """
274

275
def create_or_update(
276
    sensitivity_settings: UpdateSensitivitySettingsRequest,
277
    **kwargs: Any
278
) -> GetSensitivitySettingsResponse:
279
    """
280
    Create or update sensitivity settings.
281
    
282
    Parameters:
283
    - sensitivity_settings (UpdateSensitivitySettingsRequest): Sensitivity configuration
284
    
285
    Returns:
286
    GetSensitivitySettingsResponse: Created or updated sensitivity settings
287
    """
288
```
289

290
### Information Protection Policies
291

292
Manage information protection and data classification policies.
293

294
```python { .api }
295
def list(
296
    scope: str,
297
    **kwargs: Any
298
) -> Iterator[InformationProtectionPolicy]:
299
    """
300
    List information protection policies for a scope.
301
    
302
    Parameters:
303
    - scope (str): Resource scope (subscription or management group)
304
    
305
    Returns:
306
    Iterator[InformationProtectionPolicy]: Iterator of protection policies
307
    """
308

309
def get(
310
    scope: str,
311
    information_protection_policy_name: str,
312
    **kwargs: Any
313
) -> InformationProtectionPolicy:
314
    """
315
    Get details of a specific information protection policy.
316
    
317
    Parameters:
318
    - scope (str): Resource scope
319
    - information_protection_policy_name (str): Name of the policy
320
    
321
    Returns:
322
    InformationProtectionPolicy: Protection policy details
323
    """
324

325
def create_or_update(
326
    scope: str,
327
    information_protection_policy_name: str,
328
    information_protection_policy: InformationProtectionPolicy,
329
    **kwargs: Any
330
) -> InformationProtectionPolicy:
331
    """
332
    Create or update an information protection policy.
333
    
334
    Parameters:
335
    - scope (str): Resource scope
336
    - information_protection_policy_name (str): Name of the policy
337
    - information_protection_policy (InformationProtectionPolicy): Policy configuration
338
    
339
    Returns:
340
    InformationProtectionPolicy: Created or updated policy
341
    """
342
```
343

344
### Locations and Operations
345

346
Access Security Center supported locations and available operations.
347

348
```python { .api }
349
def list_locations(
350
    **kwargs: Any
351
) -> Iterator[AscLocation]:
352
    """
353
    List supported Azure Security Center locations.
354
    
355
    Returns:
356
    Iterator[AscLocation]: Iterator of supported locations
357
    """
358

359
def get_location(
360
    asc_location: str,
361
    **kwargs: Any
362
) -> AscLocation:
363
    """
364
    Get details of a specific Azure Security Center location.
365
    
366
    Parameters:
367
    - asc_location (str): Azure Security Center location
368
    
369
    Returns:
370
    AscLocation: Location details
371
    """
372

373
def list_operations(
374
    **kwargs: Any
375
) -> Iterator[Operation]:
376
    """
377
    List available Security Center operations.
378
    
379
    Returns:
380
    Iterator[Operation]: Iterator of available operations
381
    """
382
```
383

384
### Microsoft Defender for Endpoint Onboarding
385

386
Manage Microsoft Defender for Endpoint (MDE) onboarding configurations.
387

388
```python { .api }
389
def list(
390
    **kwargs: Any
391
) -> Iterator[MdeOnboardingData]:
392
    """
393
    List Microsoft Defender for Endpoint onboarding configurations.
394
    
395
    Returns:
396
    Iterator[MdeOnboardingData]: Iterator of MDE onboarding configurations
397
    """
398

399
def get(
400
    **kwargs: Any
401
) -> MdeOnboardingData:
402
    """
403
    Get Microsoft Defender for Endpoint onboarding data.
404
    
405
    Returns:
406
    MdeOnboardingData: MDE onboarding configuration
407
    """
408
```
409

410
### Security Operators
411

412
Manage security operator configurations and access.
413

414
```python { .api }
415
def list(
416
    **kwargs: Any
417
) -> Iterator[SecurityOperator]:
418
    """
419
    List security operators for the subscription.
420
    
421
    Returns:
422
    Iterator[SecurityOperator]: Iterator of SecurityOperator objects
423
    """
424

425
def get(
426
    security_operator_name: str,
427
    **kwargs: Any
428
) -> SecurityOperator:
429
    """
430
    Get details of a specific security operator.
431
    
432
    Parameters:
433
    - security_operator_name (str): Name of the security operator
434
    
435
    Returns:
436
    SecurityOperator: Security operator details
437
    """
438

439
def create_or_update(
440
    security_operator_name: str,
441
    security_operator_body: SecurityOperator,
442
    **kwargs: Any
443
) -> SecurityOperator:
444
    """
445
    Create or update a security operator.
446
    
447
    Parameters:
448
    - security_operator_name (str): Name of the security operator
449
    - security_operator_body (SecurityOperator): Operator configuration
450
    
451
    Returns:
452
    SecurityOperator: Created or updated security operator
453
    """
454

455
def delete(
456
    security_operator_name: str,
457
    **kwargs: Any
458
) -> None:
459
    """
460
    Delete a security operator.
461
    
462
    Parameters:
463
    - security_operator_name (str): Name of the security operator
464
    
465
    Returns:
466
    None
467
    """
468
```
469

470
## Types
471

472
```python { .api }
473
class Setting:
474
    id: Optional[str]
475
    name: Optional[str]
476
    type: Optional[str]
477
    kind: str                                  # DataExportSettings, AlertSyncSettings
478

479
class DataExportSettings:
480
    enabled: bool
481
    
482
class AlertSyncSettings:
483
    enabled: bool
484

485
class SecurityContact:
486
    id: Optional[str]
487
    name: Optional[str]
488
    type: Optional[str]
489
    emails: Optional[str]                      # Semicolon-separated email addresses
490
    phone: Optional[str]
491
    alert_notifications: Optional[AlertNotifications]
492
    notifications_by_role: Optional[NotificationsByRole]
493

494
class AlertNotifications:
495
    state: Optional[str]                       # On, Off
496
    minimal_severity: Optional[str]            # High, Medium, Low
497

498
class NotificationsByRole:
499
    state: Optional[str]                       # On, Off
500
    roles: Optional[List[str]]                 # Owner, Contributor, ServiceAdmin, AccountAdmin
501

502
class AutoProvisioningSetting:
503
    id: Optional[str]
504
    name: Optional[str]
505
    type: Optional[str]
506
    auto_provision: str                        # On, Off
507

508
class WorkspaceSetting:
509
    id: Optional[str]
510
    name: Optional[str]
511
    type: Optional[str]
512
    workspace_id: Optional[str]
513
    scope: Optional[str]
514

515
class GetSensitivitySettingsResponse:
516
    sensitive_info_types_ids: Optional[List[str]]
517
    sensitivity_threshold_label_order: Optional[float]
518
    sensitivity_threshold_label_id: Optional[str]
519

520
class UpdateSensitivitySettingsRequest:
521
    sensitive_info_types_ids: Optional[List[str]]
522
    sensitivity_threshold_label_order: Optional[float]
523
    sensitivity_threshold_label_id: Optional[str]
524

525
class InformationProtectionPolicy:
526
    id: Optional[str]
527
    name: Optional[str]
528
    type: Optional[str]
529
    last_modified_utc: Optional[datetime]
530
    version: Optional[str]
531
    labels: Optional[Dict[str, SensitivityLabel]]
532
    information_types: Optional[Dict[str, InformationType]]
533

534
class SensitivityLabel:
535
    display_name: Optional[str]
536
    description: Optional[str]
537
    rank: Optional[int]
538
    enabled: Optional[bool]
539
    order: Optional[float]
540

541
class InformationType:
542
    display_name: Optional[str]
543
    description: Optional[str]
544
    order: Optional[float]
545
    recommended_label_id: Optional[str]
546
    enabled: Optional[bool]
547
    custom: Optional[bool]
548
    keywords: Optional[List[InformationProtectionKeyword]]
549

550
class InformationProtectionKeyword:
551
    pattern: Optional[str]
552
    custom: Optional[bool]
553
    can_be_numeric: Optional[bool]
554
    excluded: Optional[bool]
555

556
class AscLocation:
557
    id: Optional[str]
558
    name: Optional[str]
559
    type: Optional[str]
560
    properties: Optional[AscLocationProperties]
561

562
class AscLocationProperties:
563
    display_name: Optional[str]
564

565
class Operation:
566
    name: Optional[str]
567
    origin: Optional[str]
568
    display: Optional[OperationDisplay]
569

570
class OperationDisplay:
571
    provider: Optional[str]
572
    resource: Optional[str]
573
    operation: Optional[str]
574
    description: Optional[str]
575

576
class MdeOnboardingData:
577
    id: Optional[str]
578
    name: Optional[str]
579
    type: Optional[str]
580
    onboarding_package_windows: Optional[bytes]
581
    onboarding_package_linux: Optional[bytes]
582

583
class SecurityOperator:
584
    id: Optional[str]
585
    name: Optional[str]
586
    type: Optional[str]
587
    identity: Optional[Identity]
588

589
class Identity:
590
    principal_id: Optional[str]
591
    tenant_id: Optional[str]
592
    type: Optional[str]                        # SystemAssigned
593
```
594

595
## Usage Examples
596

597
### Security Settings Configuration
598

599
```python
600
from azure.identity import DefaultAzureCredential
601
from azure.mgmt.security import SecurityCenter
602

603
credential = DefaultAzureCredential()
604
client = SecurityCenter(credential, "subscription-id")
605

606
# List all security settings
607
settings = client.settings.list()
608
for setting in settings:
609
    print(f"Setting: {setting.name}")
610
    print(f"Kind: {setting.kind}")
611
    
612
    if setting.kind == "DataExportSettings":
613
        print(f"Data Export Enabled: {setting.enabled}")
614
    elif setting.kind == "AlertSyncSettings":
615
        print(f"Alert Sync Enabled: {setting.enabled}")
616

617
# Get specific setting
618
mcas_setting = client.settings.get("MCAS")
619
print(f"MCAS Setting: {mcas_setting.name}")
620
print(f"Enabled: {mcas_setting.enabled}")
621

622
# Update data export settings
623
data_export_setting = {
624
    "kind": "DataExportSettings",
625
    "enabled": True
626
}
627

628
updated_setting = client.settings.update("DataExportSettings", data_export_setting)
629
print(f"Data export updated: {updated_setting.enabled}")
630

631
# Enable WDATP integration
632
wdatp_setting = {
633
    "kind": "AlertSyncSettings", 
634
    "enabled": True
635
}
636

637
wdatp_updated = client.settings.update("WDATP", wdatp_setting)
638
print(f"WDATP integration enabled: {wdatp_updated.enabled}")
639
```
640

641
### Security Contact Management
642

643
```python
644
# List existing security contacts
645
contacts = client.security_contacts.list()
646
for contact in contacts:
647
    print(f"Contact: {contact.name}")
648
    print(f"Emails: {contact.emails}")
649
    print(f"Phone: {contact.phone}")
650
    
651
    if contact.alert_notifications:
652
        print(f"Alert Notifications: {contact.alert_notifications.state}")
653
        print(f"Minimal Severity: {contact.alert_notifications.minimal_severity}")
654
    
655
    if contact.notifications_by_role:
656
        print(f"Role Notifications: {contact.notifications_by_role.state}")
657
        print(f"Roles: {contact.notifications_by_role.roles}")
658

659
# Create a new security contact
660
security_contact = {
661
    "emails": "security-team@company.com;soc@company.com",
662
    "phone": "+1-555-123-4567",
663
    "alert_notifications": {
664
        "state": "On",
665
        "minimal_severity": "Medium"
666
    },
667
    "notifications_by_role": {
668
        "state": "On",
669
        "roles": ["Owner", "Contributor"]
670
    }
671
}
672

673
contact = client.security_contacts.create("primary", security_contact)
674
print(f"Created security contact: {contact.name}")
675

676
# Update existing contact
677
updated_contact = {
678
    "emails": "security-team@company.com;soc@company.com;ciso@company.com",
679
    "phone": "+1-555-123-4567",
680
    "alert_notifications": {
681
        "state": "On",
682
        "minimal_severity": "High"  # Changed to High
683
    },
684
    "notifications_by_role": {
685
        "state": "On",
686
        "roles": ["Owner", "Contributor", "ServiceAdmin"]
687
    }
688
}
689

690
updated = client.security_contacts.update("primary", updated_contact)
691
print(f"Updated contact minimal severity to: {updated.alert_notifications.minimal_severity}")
692
```
693

694
### Auto Provisioning Configuration
695

696
```python
697
# List auto provisioning settings
698
auto_settings = client.auto_provisioning_settings.list()
699
for setting in auto_settings:
700
    print(f"Auto Provisioning: {setting.name}")
701
    print(f"Status: {setting.auto_provision}")
702

703
# Get specific auto provisioning setting
704
log_analytics_setting = client.auto_provisioning_settings.get("default")
705
print(f"Log Analytics Auto Provisioning: {log_analytics_setting.auto_provision}")
706

707
# Enable auto provisioning
708
auto_provision_config = {
709
    "auto_provision": "On"
710
}
711

712
enabled_setting = client.auto_provisioning_settings.create(
713
    "default", 
714
    auto_provision_config
715
)
716
print(f"Auto provisioning enabled: {enabled_setting.auto_provision}")
717
```
718

719
### Workspace Settings Management
720

721
```python
722
# List workspace settings
723
workspace_settings = client.workspace_settings.list()
724
for setting in workspace_settings:
725
    print(f"Workspace Setting: {setting.name}")
726
    print(f"Workspace ID: {setting.workspace_id}")
727
    print(f"Scope: {setting.scope}")
728

729
# Create workspace setting
730
workspace_config = {
731
    "workspace_id": "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.OperationalInsights/workspaces/security-workspace",
732
    "scope": "/subscriptions/sub-id"
733
}
734

735
workspace_setting = client.workspace_settings.create("default", workspace_config)
736
print(f"Workspace configured: {workspace_setting.workspace_id}")
737

738
# Update workspace setting
739
updated_workspace_config = {
740
    "workspace_id": "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.OperationalInsights/workspaces/new-security-workspace",
741
    "scope": "/subscriptions/sub-id"
742
}
743

744
updated_workspace = client.workspace_settings.update("default", updated_workspace_config)
745
print(f"Workspace updated: {updated_workspace.workspace_id}")
746
```
747

748
### Information Protection Policy Management
749

750
```python
751
# List information protection policies
752
scope = "subscriptions/subscription-id"
753
policies = client.information_protection_policies.list(scope)
754

755
for policy in policies:
756
    print(f"Policy: {policy.name}")
757
    print(f"Version: {policy.version}")
758
    print(f"Last Modified: {policy.last_modified_utc}")
759
    
760
    if policy.labels:
761
        print(f"Labels: {len(policy.labels)}")
762
        for label_id, label in policy.labels.items():
763
            print(f"  {label_id}: {label.display_name} (Rank: {label.rank})")
764
    
765
    if policy.information_types:
766
        print(f"Information Types: {len(policy.information_types)}")
767
        for info_type_id, info_type in policy.information_types.items():
768
            print(f"  {info_type_id}: {info_type.display_name}")
769

770
# Get specific policy
771
specific_policy = client.information_protection_policies.get(scope, "effective")
772
print(f"Effective Policy Labels: {len(specific_policy.labels or {})}")
773
```
774

775
### Sensitivity Settings Configuration
776

777
```python
778
# Get current sensitivity settings
779
sensitivity_settings = client.sensitivity_settings.get()
780
print(f"Sensitivity Info Types: {len(sensitivity_settings.sensitive_info_types_ids or [])}")
781
print(f"Threshold Label ID: {sensitivity_settings.sensitivity_threshold_label_id}")
782
print(f"Threshold Order: {sensitivity_settings.sensitivity_threshold_label_order}")
783

784
# Update sensitivity settings
785
updated_sensitivity = {
786
    "sensitive_info_types_ids": [
787
        "50842eb7-edc8-4019-85dd-5a5c1f2bb085",  # Credit Card Number
788
        "a44669fe-0d48-453d-a9b1-2cc83f2cba77",  # U.S. Social Security Number
789
        "be1daff4-7406-4a0c-8f23-7d0a5217e2a4"   # Email Address
790
    ],
791
    "sensitivity_threshold_label_order": 2.0,
792
    "sensitivity_threshold_label_id": "confidential-label-id"
793
}
794

795
updated_settings = client.sensitivity_settings.create_or_update(updated_sensitivity)
796
print(f"Updated sensitivity settings with {len(updated_settings.sensitive_info_types_ids)} info types")
797
```
798

799
### Microsoft Defender for Endpoint Integration
800

801
```python
802
# Get MDE onboarding data
803
mde_data = client.mde_onboardings.get()
804
print(f"MDE Onboarding: {mde_data.name}")
805

806
if mde_data.onboarding_package_windows:
807
    print("Windows onboarding package available")
808
    # Save to file for deployment
809
    with open("mde_windows_package.zip", "wb") as f:
810
        f.write(mde_data.onboarding_package_windows)
811

812
if mde_data.onboarding_package_linux:
813
    print("Linux onboarding package available")
814
    # Save to file for deployment
815
    with open("mde_linux_package.zip", "wb") as f:
816
        f.write(mde_data.onboarding_package_linux)
817
```
818

819
### Security Configuration Dashboard
820

821
```python
822
def create_security_configuration_dashboard():
823
    """Create a comprehensive security configuration dashboard."""
824
    
825
    print("Security Configuration Dashboard")
826
    print("=" * 50)
827
    
828
    # Security Settings
829
    print("\n1. Security Settings:")
830
    settings = client.settings.list()
831
    settings_status = {}
832
    
833
    for setting in settings:
834
        if hasattr(setting, 'enabled'):
835
            settings_status[setting.name] = setting.enabled
836
        else:
837
            settings_status[setting.name] = "Unknown"
838
    
839
    for name, status in settings_status.items():
840
        print(f"   {name}: {'✓ Enabled' if status else '✗ Disabled'}")
841
    
842
    # Security Contacts
843
    print("\n2. Security Contacts:")
844
    contacts = client.security_contacts.list()
845
    contact_count = sum(1 for _ in contacts)
846
    print(f"   Configured Contacts: {contact_count}")
847
    
848
    # Auto Provisioning
849
    print("\n3. Auto Provisioning:")
850
    auto_settings = client.auto_provisioning_settings.list()
851
    auto_enabled = False
852
    
853
    for setting in auto_settings:
854
        if setting.auto_provision == "On":
855
            auto_enabled = True
856
            break
857
    
858
    print(f"   Status: {'✓ Enabled' if auto_enabled else '✗ Disabled'}")
859
    
860
    # Workspace Settings
861
    print("\n4. Workspace Configuration:")
862
    workspace_settings = client.workspace_settings.list()
863
    workspace_configured = sum(1 for _ in workspace_settings) > 0
864
    print(f"   Status: {'✓ Configured' if workspace_configured else '✗ Not Configured'}")
865
    
866
    # Locations
867
    print("\n5. Supported Locations:")
868
    locations = client.locations.list()
869
    location_count = sum(1 for _ in locations)
870
    print(f"   Available Locations: {location_count}")
871
    
872
    # Configuration Score
873
    config_score = 0
874
    if settings_status.get("MCAS", False):
875
        config_score += 1
876
    if settings_status.get("WDATP", False):
877
        config_score += 1
878
    if contact_count > 0:
879
        config_score += 1
880
    if auto_enabled:
881
        config_score += 1
882
    if workspace_configured:
883
        config_score += 1
884
    
885
    print(f"\n6. Configuration Health Score: {config_score}/5")
886
    
887
    if config_score >= 4:
888
        print("   🟢 Excellent configuration")
889
    elif config_score >= 3:
890
        print("   🟡 Good configuration, minor improvements needed")
891
    else:
892
        print("   🔴 Configuration needs attention")
893
    
894
    return {
895
        "settings_status": settings_status,
896
        "contact_count": contact_count,
897
        "auto_provisioning_enabled": auto_enabled,
898
        "workspace_configured": workspace_configured,
899
        "location_count": location_count,
900
        "config_score": config_score
901
    }
902

903
# Generate the configuration dashboard
904
config_data = create_security_configuration_dashboard()
905
```