moodle.waes.ac.uk/moodle.waes.ac.uk.zip/moodle.waes.ac.uk/TMG/R3-SP2-457682_intl_x64_zip.exe/TMG-KB2735208-amd64-GLB.msp/PCW_CAB_SHFx2/FpcSqmConfig.Com.xml

Extensible Markup Language | 2012-02-13 | 137KB | 3,336 lines

<?xml version="1.0" encoding="utf-8" ?>
<fpcsqm:Configuration xmlns:fpcsqm="http://www.microsoft.com/isaserver/MsFpcSqmConfiguration.xsd">

  <!-- Skiped DataPoint: 104, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
  <!-- Skiped DataPoint: 105, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
  <!-- Skiped DataPoint: 106, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
  <!-- Skiped DataPoint: 107, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
  <!-- Skiped DataPoint: 146, DATAID_DATAID_SERVER_FRAMEWORK_VERSION (no longer relevant) -->
  <!-- Skiped DataPoint: 148, DATAID_IAG_OS_VERSION_MAJOR (IAG) -->
  <!-- Skiped DataPoint: 149, DATAID_IAG_OS_VERSION_MINOR (IAG) -->
  <!-- Skiped DataPoint: 150, DATAID_IAG_OS_SP_VERSION (IAG) -->
  <!-- Skiped DataPoint: 151, DATAID_IAG_VERSION (IAG) -->
  <!-- Skiped DataPoint: 152, DATAID_IAG_SETUP_SUCCESSFUL (IAG) -->
  <!-- Skiped DataPoint: 153, DATAID_IAG_UTM_PROXY_ENABLED (IAG) -->
  <!-- Skiped DataPoint: 154, DATAID_BPA_WAS_HELPFUL (BPA) -->
  <!-- Skiped DataPoint: 155, DATAID_DATAID_BPA_ALERTS1 (BPA) -->
  <!-- Skiped DataPoint: 156, DATAID_DATAID_BPA_ALERTS2 (BPA) -->
  <!-- Skiped DataPoint: 157, DATAID_DATAID_BPA_ALERTS3 (BPA) -->
  <!-- Skiped DataPoint: 158, DATAID_DATAID_BPA_ALERTS4 (BPA) -->
  <!-- Skiped DataPoint: 159, DATAID_DATAID_BPA_ALERTS5 (BPA) -->
  <!-- Skiped DataPoint: 160, DATAID_DATAID_BPA_ALERTS6 (BPA) -->
  <!-- Skiped DataPoint: 161, DATAID_DATAID_BPA_ALERTS7 (BPA) -->
  <!-- Skiped DataPoint: 165, DATAID_IAG_OS_AUTO_UPDATE (IAG) -->
  <!-- Skiped DataPoint: 166, DATAID_IAG_OS_LANGUAGE (IAG) -->
  <!-- Skiped DataPoint: 167, DATAID_IAG_WFLB_APPS (IAG) -->
  <!-- Skiped DataPoint: 168, DATAID_IAG_WFLB_SERVERS (IAG) -->
  <!-- Skiped DataPoint: 169, DATAID_IAG_WFLB_QUESTIONS (IAG) -->

  <DataPoints>
    <!-- TMG SQM data points based on TMG COM queries -->
    <!-- Cache -->
    <DataPoint Id="1" Name="DATAID_DELEGATED_ADMINS_COUNT">
        <!-- Array DelegatedAdmins count-->
      <Script>
        $p = Get-Item fpc:\ContainingArray\AdminSecurity\DelegatedAdmins
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="2" Name="DATAID_CACHE_QUESTIONS" Operation="BitField">
      <!-- Cache configuration settings -->
      <Script>
        $cacheCfg = "fpc:\ContainingArray\Cache\CacheConfiguration"
        $result = 0

        $p = Get-ItemProperty $cacheCfg CacheNon200Responses
        if ($p.CacheNon200Responses -eq "True") { $result = 1 }

        $p = Get-ItemProperty $cacheCfg CacheWithNoLastModDate
        if ($p.CacheWithNoLastModDate -eq "True") { $result = $result -bor 2 }

        $p = Get-ItemProperty $cacheCfg QueueRequests
        if ($p.QueueRequests -eq "True") { $result = $result -bor 4 }

        $p = Get-ItemProperty $cacheCfg ReturnExpiredEnable
        if ($p.ReturnExpiredEnable -eq "True") { $result = $result -bor 8 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="3" Name="DATAID_CACHE_RULE_COUNT">
      <!-- Cache rules count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Cache\CacheConfiguration\CacheRules
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="4" Name="DATAID_CACHE_MEMORY_CACHE_MAX_URL_SIZE">
      <!-- Cache configuration: memory cache max url size -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Cache\CacheConfiguration MemoryCacheMaxURLSize
        $p.MemoryCacheMaxURLSize
      </Script>
    </DataPoint>
    <DataPoint Id="5" Name="DATAID_CACHE_MEMORY_USAGE_PERCENTAGE">
      <!-- Cache configuration: memory usage percentage -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Cache\CacheConfiguration MemoryUsagePercentage
        $p.MemoryUsagePercentage
      </Script>
    </DataPoint>
    <DataPoint Id="6" Name="DATAID_CACHE_RETURN_EXPIRED_MAX_TIME">
      <!-- Cache configuration: return expired max time -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Cache\CacheConfiguration ReturnExpiredMaxTime
        $p.ReturnExpiredMaxTime
      </Script>
    </DataPoint>
    <DataPoint Id="7" Name="DATAID_CACHE_RETURN_EXPIRED_TTL_PERCENT">
      <!-- Cache configuration: return expired TTL percentage -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Cache\CacheConfiguration ReturnExpiredTTLPercent
        $p.ReturnExpiredTTLPercent
      </Script>
    </DataPoint>
    <DataPoint Id="8" Name="DATAID_CACHE_SCHEDULED_CONTENT_DOWNLOAD">
      <!-- Cache scheduled content download count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Cache\ScheduledContentDownload
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- CSS -->
    <DataPoint Id="9" Name="DATAID_CSS_QUESTIONS" Operation="BitField">
      <!-- CSS general settings -->
      <Script>
        $css = "fpc:\ContainingArray\ConfigurationStorageServerConnection"
        $result = 0

        $p = Get-ItemProperty $css AlternateConfigurationStorageServer
        if ($p.AlternateConfigurationStorageServer.Length -gt 0) { $result = 1 }

        $p = Get-ItemProperty $css ConfigurationStorageServerConnectionType
        if ($p.ConfigurationStorageServerConnectionType -eq 1) { $result = $result -bor 2 }

        $p1 = Get-ItemProperty $css ConnectionOverVPNTunnel
        $p2 = Get-ItemProperty $css VpnBackupStorageServer
        if ($p1.ConnectionOverVPNTunnel -and $p2.VpnBackupStorageServer.Length -gt 0) { $result = $result -bor 4 }
        if ($p1.ConnectionOverVPNTunnel -eq "True") { $result = $result -bor 8 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="10" Name="DATAID_CSS_CHANGE_POLL_RATE">
      <!-- CSS change polling rate -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ConfigurationStorageServerConnection ChangePollRate
        $p.ChangePollRate
      </Script>
    </DataPoint>
    <DataPoint Id="11" Name="DATAID_CSS_FALLBACK_DELAY">
      <!-- CSS fallback delay -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ConfigurationStorageServerConnection FallbackDelay
        $p.FallbackDelay
      </Script>
    </DataPoint>
    <DataPoint Id="12" Name="DATAID_CSS_PRIMARY_STABILIZATION_DELAY">
      <!-- CSS primary stabilization delay -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ConfigurationStorageServerConnection PrimaryStabilizationDelay
        $p.PrimaryStabilizationDelay
      </Script>
    </DataPoint>
    <DataPoint Id="13" Name="DATAID_CSS_PRIMARY_TESTING_DELAY">
      <!-- CSS primary testing delay -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ConfigurationStorageServerConnection PrimaryTestingDelay
        $p.PrimaryTestingDelay
      </Script>
    </DataPoint>
    <!-- Networks -->
    <DataPoint Id="14" Name="DATAID_INTERNAL_QUESTIONS" Operation="BitField">
      <!-- Internal settings -->
      <Script>
        $internal = "fpc:\ContainingArray\NetworkConfiguration\Networks\'{4E32B556-0FAF-4A27-9111-085F679EDC9B}'"
        $nlb = $internal + "\NLBCluster"
        $listeners = $internal + "\WebListenerProperties"
        $result = 0

        $p = Get-ItemProperty $internal EnableFirewallClients
        if ($p.EnableFirewallClients -eq "True") { $result = 1 }

        $p = Get-ItemProperty $internal EnableWebProxyClients
        if ($p.EnableWebProxyClients -eq "True") { $result = $result -bor 2 }

        $p = Get-ItemProperty $internal EnableAutoDiscoveryPort
        if ($p.EnableAutoDiscoveryPort -eq "True") { $result = $result -bor 4 }

        $p = Get-ItemProperty $nlb NLBEnabled
        if ($p.NLBEnabled -eq "True") { $result = $result -bor 8 }

        $p = Get-ItemProperty $listeners ResolveInArray
        if ($p.ResolveInArray -eq "True") { $result = $result -bor 16 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="15" Name="DATAID_INTERNAL_ENTERPRISE_NETWORKS">
      <!-- Internal: number of associated enterprise networks -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\Networks\'{4E32B556-0FAF-4A27-9111-085F679EDC9B}'\EnterpriseNetworks
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="16" Name="DATAID_INTERNAL_IP_RANGE_SET">
      <!-- Internal: number of IP ranges -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\Networks\'{4E32B556-0FAF-4A27-9111-085F679EDC9B}'\IpRangeSet
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="17" Name="DATAID_INTERNAL_LDT">
      <!-- Internal: number of LDT -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\Networks\'{4E32B556-0FAF-4A27-9111-085F679EDC9B}'\LDT
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="18" Name="DATAID_EXTERNAL_NLB_ENABLED" Operation="BitField">
      <!-- External settings -->
      <Script>
        $result = 0
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkConfiguration\Networks\'{F129EACF-778B-44FE-B339-5B752D7220A3}'\NLBCluster NLBEnabled
        if ($p.NLBEnabled -eq "True") { $result = 1 }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="19" Name="DATAID_LOCALHOST_QUESTIONS" Operation="BitField">
      <!-- localhost: settings -->
      <Script>
        $localhost = "fpc:\ContainingArray\NetworkConfiguration\Networks\'{5ED77DCE-8110-4821-B445-008B7E6B7F6D}'"
        $listeners = $localhost + "\WebListenerProperties"
        $result = 0

        $p = Get-ItemProperty $localhost EnableWebProxyClients
        if ($p.EnableWebProxyClients -eq "True") { $result = 1 }

        $p = Get-ItemProperty $listeners ResolveInArray
        if ($p.ResolveInArray -eq "True") { $result = $result -bor 2 }

        $result
      </Script>
    </DataPoint>
    <!-- VPN -->
    <DataPoint Id="20" Name="DATAID_QUARANTINE_ENABLED" Operation="BitField">
      <!-- VPN: quarantine enabled -->
      <Script>
        $result = 0
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkConfiguration\VpnConfiguration\QuarantineSettings QuarantineMode
        if ($p.QuarantineMode -ne 0) { $result = 1 }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="21" Name="DATAID_VPN_QUESTIONS" Operation="BitField">
      <!-- Set of VPN settings -->
      <Script>
        $vpn = "fpc:\ContainingArray\NetworkConfiguration\VpnConfiguration"
        $result = 0

        $p = Get-ItemProperty $vpn UseDHCPForAddressAssignment
        if ($p.UseDHCPForAddressAssignment -eq "True") { $result = 1 }

        $p = Get-ItemProperty $vpn UseDHCPForDNS
        if ($p.UseDHCPForDNS -eq "True") { $result = $result -bor 2 }

        $p = Get-ItemProperty $vpn UseDHCPForWINS
        if ($p.UseDHCPForWINS -eq "True") { $result = $result -bor 4 }

        $p = Get-ItemProperty $vpn EnableRADIUSAuthentication
        if ($p.EnableRADIUSAuthentication -eq "True") { $result = $result -bor 8 }

        $p = Get-ItemProperty $vpn EnableRADIUSAccounting
        if ($p.EnableRADIUSAccounting -eq "True") { $result = $result -bor 16 }

        $p = Get-ItemProperty $vpn AllowCustomIPSecPolicyForL2TP
        if ($p.AllowCustomIPSecPolicyForL2TP -eq "True") { $result = $result -bor 32 }

        $p = Get-ItemProperty $vpn EnablePPTP
        if ($p.EnablePPTP -eq "True") { $result = $result -bor 64 }

        $p = Get-ItemProperty $vpn EnableL2TP
        if ($p.EnableL2TP -eq "True") { $result = $result -bor 128 }

        $p = Get-ItemProperty $vpn EnableWindowsAccounting
        if ($p.EnableWindowsAccounting -eq "True") { $result = $result -bor 256 }

        $p = Get-ItemProperty $vpn EnableVpnClients
        if ($p.EnableVpnClients -eq "True") { $result = $result -bor 512 }

        $p = Get-ItemProperty $vpn\PPPSettings EnableEAP
        if ($p.EnableEAP -eq "True") { $result = $result -bor 1024 }

        $p = Get-ItemProperty $vpn\PPPSettings EnableSSTP
        if ($p.EnableSSTP -eq "True") { $result = $result -bor 2048 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="22" Name="DATAID_VPN_MAXIMUM_VPN_CLIENTS">
      <!-- the max number of VPN clients allowed -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkConfiguration\VpnConfiguration MaximumVpnClients
        $p.MaximumVpnClients
      </Script>
    </DataPoint>
    <!-- Rule Elements -->
    <DataPoint Id="23" Name="DATAID_RULE_ELEMENTS_SCHEDULES">
      <!-- schedules count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\Schedules
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="24" Name="DATAID_RULE_ELEMENTS_COMPUTERS">
      <!-- Computers count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\Computers
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="25" Name="DATAID_RULE_ELEMENTS_ADDRESS_RANGES">
      <!-- Address ranges count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\AddressRanges
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="26" Name="DATAID_RULE_ELEMENTS_SUBNETS">
      <!-- Subnets count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\Subnets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="27" Name="DATAID_RULE_ELEMENTS_COMPUTER_SETS">
      <!-- Computer sets count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\ComputerSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="28" Name="DATAID_RULE_ELEMENTS_URL_SETS">
      <!-- URL sets count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\URLSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="29" Name="DATAID_RULE_ELEMENTS_DOMAIN_NAME_SETS">
      <!-- Domain name sets count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\DomainNameSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="30" Name="DATAID_RULE_ELEMENTS_PROTOCOL_DEFINITIONS">
      <!-- Protocol definitions count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\ProtocolDefinitions
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="31" Name="DATAID_RULE_ELEMENTS_EVENT_DEFINITIONS">
      <!-- Event definitions count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\EventDefinitions
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="32" Name="DATAID_RULE_ELEMENTS_RADIUS_SERVERS">
      <!-- Radius servers count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\RadiusServers
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="33" Name="DATAID_RULE_ELEMENTS_WEB_LISTENERS">
      <!-- Web listeners count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="34" Name="DATAID_RULE_ELEMENTS_CONTENT_TYPE_SETS">
      <!-- Content type sets count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\ContentTypeSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="35" Name="DATAID_RULE_ELEMENTS_USER_SETS">
      <!-- User sets count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\UserSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="36" Name="DATAID_RULE_ELEMENTS_AUTHENTICATION_SCHEMES">
      <!-- Authentication schemes count -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\AuthenticationSchemes
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="37" Name="DATAID_RULE_ELEMENTS_COMPUTER_SETS_MAX">
      <!-- The max number of cumputers in a computer set -->
      <Script>
        $result = 0
        foreach ($set in Get-ChildItem fpc:\ContainingArray\RuleElements\ComputerSets)
        {
          $path = "fpc:\ContainingArray\RuleElements\ComputerSets\'" + $set.StorageName + "'\Computers"
          $p = Get-Item $path
          if ($p.Children.Length -gt $result) { $result = $p.Children.Length }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="38" Name="DATAID_RULE_ELEMENTS_URL_SETS_MAX">
      <!-- The max number of URLs in a URL set -->
      <Script>
        $result = 0
        foreach ($set in Get-ChildItem fpc:\ContainingArray\RuleElements\URLSets)
        {
          $path = "fpc:\ContainingArray\RuleElements\URLSets\'" + $set.StorageName + "'"
          $count = 0
          foreach ($url in Get-ChildItem $path) { $count++ }
          if ($count -gt $result) { $result = $count }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="39" Name="DATAID_RULE_ELEMENTS_DOMAIN_NAME_SETS_MAX">
      <!-- The max number of domain names in a domain name set -->
      <Script>
        $result = 0
        foreach ($set in Get-ChildItem fpc:\ContainingArray\RuleElements\DomainNameSets)
        {
          $path = "fpc:\ContainingArray\RuleElements\DomainNameSets\'" + $set.StorageName + "'"
          $count = 0
          foreach ($url in Get-ChildItem $path) { $count++ }
          if ($count -gt $result) { $result = $count }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="40" Name="DATAID_RULE_ELEMENTS_USER_SETS_MAX">
      <!-- The max number of users in a users set -->
      <Script>
        $result = 0
        foreach ($set in Get-ChildItem fpc:\ContainingArray\RuleElements\UserSets)
        {
          $path = "fpc:\ContainingArray\RuleElements\UserSets\'" + $set.StorageName + "'\Accounts"
          $p = Get-Item $path
          $count = $p.Children.Length

          $path = "fpc:\ContainingArray\RuleElements\UserSets\'" + $set.StorageName + "'\NonWindowsUsers"
          $p = Get-Item $path
          $count += $p.Children.Length
          if ($count -gt $result) { $result = $count }
        }
        $result
      </Script>
    </DataPoint>
    <!-- Web Listeners -->
    <DataPoint Id="41" Name="DATAID_WEB_LISTENER_PCT_ALWAYS_AUTHENTICATE">
      <!-- The percentage of web listeners that always authenticate -->
      <Script>
        $webListeners = "fpc:\ContainingArray\RuleElements\WebListeners"
        $p = Get-Item $webListeners
        $webListenersCount = $p.Children.Length
        $alwaysAuthenticate = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path AlwaysAuthenticate
          if ($p.AlwaysAuthenticate -eq "True") { $alwaysAuthenticate += 1 }
        }

        $result = 0
        if ($alwaysAuthenticate -gt 0) { $result = $alwaysAuthenticate * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="314" Name="DATAID_WEB_LISTENER_ALWAYS_AUTH">
      <!-- The number of web listeners that always authenticate -->
      <Script>
        $alwaysAuthenticate = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path AlwaysAuthenticate
          if ($p.AlwaysAuthenticate -eq "True") { $alwaysAuthenticate += 1 }
        }

        $alwaysAuthenticate
      </Script>
    </DataPoint>
    <DataPoint Id="42" Name="DATAID_WEB_LISTENER_MAX_APPLIED_SSL_CERTIFICATES">
      <!-- The max number of SSL certificates applied on a listener -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AppliedSSLCertificates"
          $p = Get-Item $path
          if ($p.Children.Length -gt $result) { $result = $p.Children.Length }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="43" Name="DATAID_WEB_LISTENER_PCT_SSL_CERTIFICATE_AUTHENTICATION">
      <!-- The percentage of web listeners with SSL certificate authentication -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $sslCertAuthentication = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path SSLCertificateAuthentication
          if ($p.SSLCertificateAuthentication -eq "True") { $sslCertAuthentication += 1 }
        }

        $result = 0
        if ($sslCertAuthentication -gt 0) { $result = $sslCertAuthentication * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>

    <DataPoint Id="44" Name="DATAID_WEB_LISTENER_PCT_BASIC_AUTHENTICATION">
      <!-- The percentage of web listeners with basic authentication -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $basicAuthentication = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path BasicAuthentication
          if ($p.BasicAuthentication -eq "True") { $basicAuthentication += 1 }
        }

        $result = 0
        if ($basicAuthentication -gt 0) { $result = $basicAuthentication * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="315" Name="DATAID_WEB_LISTENER_BASIC_AUTH">
      <!-- The number of web listeners with basic authentication -->
      <Script>
        $basicAuthentication = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path BasicAuthentication
          if ($p.BasicAuthentication -eq "True") { $basicAuthentication += 1 }
        }

        $basicAuthentication
      </Script>
    </DataPoint>
    <DataPoint Id="45" Name="DATAID_WEB_LISTENER_PCT_BASIC_AUTH_PERSIST_SINGLE_REQUEST">
      <!-- The percentage of web listeners with basic authentication single request -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $basicAuthSingleReq = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path BasicAuthPersistSingleRequest
          if ($p.BasicAuthPersistSingleRequest -eq "True") { $basicAuthSingleReq += 1 }
        }

        $result = 0
        if ($basicAuthSingleReq -gt 0) { $result = $basicAuthSingleReq * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="316" Name="DATAID_WEB_LISTENER_BASIC_AUTH_PERSIST">
      <!-- The number of web listeners with basic authentication single request -->
      <Script>
        $basicAuthSingleReq = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path BasicAuthPersistSingleRequest
          if ($p.BasicAuthPersistSingleRequest -eq "True") { $basicAuthSingleReq += 1 }
        }
        $basicAuthSingleReq
      </Script>
     </DataPoint>
    <DataPoint Id="46" Name="DATAID_WEB_LISTENER_AVG_CONNECTION_TIMEOUT">
      <!-- The web listeners avarege connection timeout -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $totalTimeout = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path ConnectionTimeout
          $totalTimeout += $p.ConnectionTimeout
        }

        $result = 0
        if ($totalTimeout -gt 0) { $result = $totalTimeout / $webListenersCount }
        $result
      </Script>
    </DataPoint>

    <DataPoint Id="47" Name="DATAID_WEB_LISTENER_PCT_DIGEST_AUTHENTICATION">
      <!-- The percentage of web listeners with digest authentication -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $digestAuth = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path DigestAuthentication
          if ($p.DigestAuthentication -eq "True") { $digestAuth += 1 }
        }

        $result = 0
        if ($digestAuth -gt 0) { $result = $digestAuth * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="319" Name="DATAID_WEB_LISTENER_DIGEST_AUTH">
      <!-- The number of web listeners with digest authentication -->
      <Script>
        $digestAuth = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path DigestAuthentication
          if ($p.DigestAuthentication -eq "True") { $digestAuth += 1 }
        }
        $digestAuth
      </Script>
    </DataPoint>
    <DataPoint Id="48" Name="DATAID_WEB_LISTENER_PCT_DIGEST_AUTH_PERSIST_SINGLE_REQUEST">
      <!-- The percentage of web listeners with digest authentication persist single request -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $digestAuthSingleReq = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path DigestAuthPersistSingleRequest
          if ($p.DigestAuthPersistSingleRequest -eq "True") { $digestAuthSingleReq += 1 }
        }

        $result = 0
        if ($digestAuthSingleReq -gt 0) { $result = $digestAuthSingleReq * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="326" Name="DATAID_WEB_LISTENER_DIGEST_AUTH_PERSIST">
      <!-- The number of web listeners with digest authentication persist single request -->
      <Script>
        $digestAuthSingleReq = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path DigestAuthPersistSingleRequest
          if ($p.DigestAuthPersistSingleRequest -eq "True") { $digestAuthSingleReq += 1 }
        }
        $digestAuthSingleReq
      </Script>
    </DataPoint>
    <DataPoint Id="49" Name="DATAID_WEB_LISTENER_PCT_INTEGRATED_AUTH_PERSIST_SINGLE_REQUEST">
      <!-- The percentage of web listeners with integrated authentication persist single request -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $intAuthSingleReq = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path IntegratedAuthPersistSingleRequest
          if ($p.IntegratedAuthPersistSingleRequest -eq "True") { $intAuthSingleReq += 1 }
        }

        $result = 0
        if ($intAuthSingleReq -gt 0) { $result = $intAuthSingleReq * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="328" Name="DATAID_WEB_LISTENER_INTEGRATED_AUTH_PERSIST">
      <!-- The number of web listeners with integrated authentication persist single request -->
      <Script>
        $intAuthSingleReq = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path IntegratedAuthPersistSingleRequest
          if ($p.IntegratedAuthPersistSingleRequest -eq "True") { $intAuthSingleReq += 1 }
        }
        $intAuthSingleReq
      </Script>
    </DataPoint>
    <DataPoint Id="50" Name="DATAID_WEB_LISTENER_PCT_INTEGRATED_WINDOWS_AUTHENTICATION">
      <!-- The percentage of web listeners with integrated windows authentication -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $intWinAuth = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path IntegratedWindowsAuthentication
          if ($p.IntegratedWindowsAuthentication -eq "True") { $intWinAuth += 1 }
        }

        $result = 0
        if ($intWinAuth -gt 0) { $result = $intWinAuth * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="320" Name="DATAID_WEB_LISTENER_INTEGRATED_AUTH">
      <!-- The number of web listeners with integrated windows authentication -->
      <Script>
        $intWinAuth = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path IntegratedWindowsAuthentication
          if ($p.IntegratedWindowsAuthentication -eq "True") { $intWinAuth += 1 }
        }
        $intWinAuth
      </Script>
    </DataPoint>
    <DataPoint Id="51" Name="DATAID_WEB_LISTENER_MIN_NUMBER_OF_CONNECTIONS">
      <!-- the min number of connections in the web listeners -->
      <Script>
        $min = -1
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path NumberOfConnections
          if (($p.NumberOfConnections -lt $min) -or ($min -eq -1)) { $min = $p.NumberOfConnections }
        }
        $min
      </Script>
    </DataPoint>
    <DataPoint Id="52" Name="DATAID_WEB_LISTENER_MAX_NUMBER_OF_CONNECTIONS">
      <!-- the max number of connections in the web listeners -->
      <Script>
        $max = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path NumberOfConnections
          if ($p.NumberOfConnections -gt $max) { $max = $p.NumberOfConnections }
        }
        $max
      </Script>
    </DataPoint>
    <DataPoint Id="53" Name="DATAID_WEB_LISTENER_AVG_NUMBER_OF_CONNECTIONS">
      <!-- the avarage number of connections in the web listeners -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $count = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path NumberOfConnections
          $count += $p.NumberOfConnections
        }

        $result = 0
        if ($count -gt 0) { $result = $count / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="54" Name="DATAID_WEB_LISTENER_PCT_RETURN_AUTH_REQUIRED_IF_AUTH_USER_DENIED">
      <!-- The percentage of web listeners that return authorization required if user authentication denied -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $count = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path ReturnAuthRequiredIfAuthUserDenied
          if ($p.ReturnAuthRequiredIfAuthUserDenied -eq "True") { $count += 1 }
        }

        $result = 0
        if ($count -gt 0) { $result = $count * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="322" Name="DATAID_WEB_LISTENER_AUTH_REQUIRED_ON_USER_DENIED">
      <!-- The number of web listeners that return authorization required if user authentication denied -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path ReturnAuthRequiredIfAuthUserDenied
          if ($p.ReturnAuthRequiredIfAuthUserDenied -eq "True") { $result += 1 }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="55" Name="DATAID_WEB_LISTENER_PCT_SINGLE_RADIUS_SERVER_AUTH_PER_SESSION">
      <!-- The percentage of web listeners with single radius server authentication per session -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $count = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path SingleRadiusServerAuthPerSession
          if ($p.SingleRadiusServerAuthPerSession -eq "True") { $count += 1 }
        }

        $result = 0
        if ($count -gt 0) { $result = $count * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="324" Name="DATAID_WEB_LISTENER_AUTH_SINGLE_RADIUS_PER_SESSION">
      <!-- The number of web listeners with single radius server authentication per session -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path SingleRadiusServerAuthPerSession
          if ($p.SingleRadiusServerAuthPerSession -eq "True") { $result += 1 }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="56" Name="DATAID_WEB_LISTENER_PCT_UNLIMITED_NUMBER_OF_CONNECTIONS">
      <!-- The percentage of web listeners with unlimited number of connections -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $webListenersCount = $p.Children.Length
        $count = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path UnlimitedNumberOfConnections
          if ($p.UnlimitedNumberOfConnections -eq "True") { $count += 1 }
        }

        $result = 0
        if ($count -gt 0) { $result = $count * 100 / $webListenersCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="325" Name="DATAID_WEB_LISTENER_UNLIMITED_CONNECTIONS">
      <!-- The number of web listeners with unlimited number of connections -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path UnlimitedNumberOfConnections
          if ($p.UnlimitedNumberOfConnections -eq "True") { $result += 1 }
        }
        $result
      </Script>
    </DataPoint>
    <!-- Alerts -->
    <DataPoint Id="57" Name="DATAID_ALERT_DEFINITIONS_COUNT">
      <!-- The number of alert definitions -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Alerts
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- FWC -->
    <DataPoint Id="58" Name="DATAID_FIREWALL_CLIENT_QUESTIONS" Operation="BitField">
      <!-- FWC Settings -->
      <Script>
        $fwc = "fpc:\ContainingArray\FWClientConfigSettings"
        $result = 0

        $p = Get-ItemProperty $fwc EnableControlChannelEncryption
        if ($p.EnableControlChannelEncryption -eq "True") { $result = 1 }

        $p = Get-ItemProperty $fwc SupportOldFirewallClients
        if ($p.SupportOldFirewallClients -eq "True") { $result = $result -bor 2 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="59" Name="DATAID_FIREWALL_CLIENT_CONFIG_SETTINGS_COUNT">
      <!-- Count of FWC Settings -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\FWClientConfigSettings
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- Connectivity Verifiers -->
    <DataPoint Id="60" Name="DATAID_CONNECTIVITY_VERIFIER_COUNT">
      <!-- Number of connectivity verifiers -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\ConnectivityVerifiers
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- Filters -->
    <DataPoint Id="61" Name="DATAID_EXTENSIONS_APPLICATION_FILTERS_COUNT">
      <!-- The number of application filters installed -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Extensions\ApplicationFilters
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="62" Name="DATAID_EXTENSIONS_WEB_FILTERS_COUNT">
      <!-- The number of web filters installed -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Extensions\WebFilters
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- Logging -->
    <DataPoint Id="63" Name="DATAID_LOGGING_WEB_PROXY_LOG_TYPE">
      <!-- Web proxy log type -->
      <Script>
        $type = -1
        foreach ($log in Get-ChildItem fpc:\ContainingArray\Logging)
        {
          $path = "fpc:\ContainingArray\Logging\'" + $log.StorageName + "'"
          $p = Get-ItemProperty $path ComponentType
          if ($p.ComponentType -eq 1)
          {
            $t = Get-ItemProperty $path LogType
            $type = $t.LogType
          }
        }
        $type
      </Script>
    </DataPoint>
    <DataPoint Id="64" Name="DATAID_LOGGING_FIREWALL_SERVICE_LOG_TYPE">
      <!-- FW log type -->
      <Script>
        $type = -1
        foreach ($log in Get-ChildItem fpc:\ContainingArray\Logging)
        {
          $path = "fpc:\ContainingArray\Logging\'" + $log.StorageName + "'"
          $p = Get-ItemProperty $path ComponentType
          if ($p.ComponentType -eq 2)
          {
            $t = Get-ItemProperty $path LogType
            $type = $t.LogType
          }
        }
        $type
      </Script>
    </DataPoint>
    <!-- Dailing -->
    <DataPoint Id="65" Name ="DATAID_DIALING_QUESTIONS" Operation="BitField">
      <!-- Dialing settings -->
      <Script>
        $dialCfg = "fpc:\ContainingArray\NetworkConfiguration\DialingConfiguration"
        $result = 0
        $p = Get-ItemProperty $dialCfg AutoDialEnabled
        if ($p.AutoDialEnabled -eq "True") { $result = 1 }

        $p = Get-ItemProperty $dialCfg DefaultGateway
        if ($p.DefaultGateway -eq "True") { $result = $result -bor 2 }

        $result
      </Script>
    </DataPoint>
    <!-- FW Chaining -->
    <DataPoint Id="66" Name="DATAID_CHAINING_QUESTIONS" Operation="BitField">
      <!-- Firewall chaining settings -->
      <Script>
        $cfg = "fpc:\ContainingArray\NetworkConfiguration\FirewallChaining"
        $result = 0

        $p = Get-ItemProperty $cfg ForwardType
        if ($p.ForwardType -ne 0) { $result = 1 }

        $p = Get-ItemProperty $cfg AuthenticationEnabled
        if ($p.AuthenticationEnabled -eq "True") { $result = $result -bor 2 }

        $result
      </Script>
    </DataPoint>
    <!-- Networks -->
    <DataPoint Id="67" Name="DATAID_NETWORKS_COUNT">
      <!-- The number of networks -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\Networks
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="68" Name="DATAID_NETWORKS_SETS">
      <!-- The number of network sets -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\NetworkSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="69" Name="DATAID_NETWORKS_RULES">
      <!-- The number of network rules -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\NetworkRules
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="70" Name="DATAID_NETWORKS_ROUTING_RULES">
      <!-- The number of routing rules -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\RoutingRules
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="71" Name="DATAID_NETWORKS_TEMPLATES">
      <!-- The number of network templates -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\NetworkConfiguration\NetworkTemplates
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="72" Name="DATAID_NETWORKS_NLB_ENABLED" Operation="BitField">
      <!-- NLB Integration -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkConfiguration\NLBConfiguration NLBIntegrationEnabled
        $p.NLBIntegrationEnabled
      </Script>
    </DataPoint>
    <DataPoint Id="73" Name="DATAID_NETWORKS_VPN_S2S">
      <!-- The number of networks w/ S2S VPN enabled -->
      <Script>
        $count = 0
        foreach ($vpn in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\Networks\VpnConfiguration)
        {
          $path = "fpc:\ContainingArray\NetworkConfiguration\Networks\VpnConfiguration\'" + $vpn.StorageName + "'"
          $p = Get-ItemProperty $path Enable
          if ($p.Enable -eq "True") { $count += 1 }
        }
        $count
      </Script>
    </DataPoint>
    <!-- Reports -->
    <DataPoint Id="74" Name="DATAID_REPORTS_ENABLED" Operation="BitField">
      <!-- Reports enabled -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Reports\LogSummaryConfiguration Enabled
        $p.Enabled
      </Script>
    </DataPoint>
    <DataPoint Id="75" Name="DATAID_REPORTS_KEEP_OLD_DAILY_SUMMARIES">
      <!-- the number of old copies to keep of old daily summeries -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Reports\LogSummaryConfiguration KeepOldDailySummaries
        $p.KeepOldDailySummaries
      </Script>
    </DataPoint>
    <DataPoint Id="76" Name="DATAID_REPORTS_KEEP_OLD_MONTHLY_SUMMARIES">
      <!-- the number of old copies to keep of old montly summeries -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\Reports\LogSummaryConfiguration KeepOldMonthlySummaries
        $p.KeepOldMonthlySummaries
      </Script>
    </DataPoint>
    <DataPoint Id="77" Name="DATAID_REPORTS_REPORT_JOBS">
      <!-- the number of report jobs -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Reports\ReportJobs
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- Attack detection -->
    <DataPoint Id="78" Name="DATAID_ATTACK_DETECTION_QUESTIONS" Operation="BitField">
      <!-- Attack detection settings -->
      <Script>
        $cfg = "fpc:\ContainingArray\ArrayPolicy\AttackDetection"
        $result = 0

        $p = Get-ItemProperty $cfg IPFragmentsFilteringEnabled
        if ($p.IPFragmentsFilteringEnabled -eq "True") { $result = 1 }

        $p = Get-ItemProperty $cfg IntrusionDetectionEnabled
        if ($p.IntrusionDetectionEnabled -eq "True") { $result = $result -bor 2 }

        $p = Get-ItemProperty $cfg WinOutOfBandDetectionEnabled
        if ($p.WinOutOfBandDetectionEnabled -eq "True") { $result = $result -bor 4 }

        $p = Get-ItemProperty $cfg LandAttackDetectionEnabled
        if ($p.LandAttackDetectionEnabled -eq "True") { $result = $result -bor 8 }

        $p = Get-ItemProperty $cfg PingOfDeathDetectionEnabled
        if ($p.PingOfDeathDetectionEnabled -eq "True") { $result = $result -bor 16 }

        $p = Get-ItemProperty $cfg IPHalfScanDetectionEnabled
        if ($p.IPHalfScanDetectionEnabled -eq "True") { $result = $result -bor 32 }

        $p = Get-ItemProperty $cfg PortScanDetectionEnabled
        if ($p.PortScanDetectionEnabled -eq "True") { $result = $result -bor 64 }

        $p = Get-ItemProperty $cfg UdpBombDetectionEnabled
        if ($p.UdpBombDetectionEnabled -eq "True") { $result = $result -bor 128 }

        $p = Get-ItemProperty $cfg IPRoutingEnabled
        if ($p.IPRoutingEnabled -eq "True") { $result = $result -bor 256 }

        $p = Get-ItemProperty $cfg IntrusionDetectionLoggingEnabled
        if ($p.IntrusionDetectionLoggingEnabled -eq "True") { $result = $result -bor 512 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="79" Name="DATAID_ATTACK_DETECTION_PORT_SCAN_DETECTION_ALL_PORTS_THRESHOLD">
      <!-- Attack detection: port scan detection all ports threshold -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\AttackDetection PortScanDetectionAllPortsThreshold
        $p.PortScanDetectionAllPortsThreshold
      </Script>
    </DataPoint>
    <DataPoint Id="80" Name="DATAID_ATTACK_DETECTION_PORT_SCAN_DETECTION_WELL_KNOWN_PORTS_THRESHOLD">
      <!-- Attack detection: port scan detection well known ports threshold -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\AttackDetection PortScanDetectionWellKnownPortsThreshold
        $p.PortScanDetectionWellKnownPortsThreshold
      </Script>
    </DataPoint>
    <!-- Servers -->
    <DataPoint Id="81" Name="DATAID_SERVER_COUNT">
      <!-- The number of servers in the array -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\Servers
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="82" Name="DATAID_SERVER_CACHESIZE">
      <!-- This server cache drive size in MB -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer\CacheDrives TotalCacheInMegs
        $p.TotalCacheInMegs
      </Script>
    </DataPoint>
    <DataPoint Id="83" Name="DATAID_SERVER_FIREWALL_SERVICE_UPTIME">
      <!-- This server Firewall Service up time -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer FirewallServiceUpTime
        $p.FirewallServiceUpTime
      </Script>
    </DataPoint>
    <DataPoint Id="84" Name="DATAID_SERVER_JOB_SCHEDULER_UPTIME">
      <!-- This server job scheduler service up time -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer JobSchedulerServiceUpTime
        $p.JobSchedulerServiceUpTime
      </Script>
    </DataPoint>
    <DataPoint Id="85" Name="DATAID_SERVER_ADAPTERS">
      <!-- This server number of adapters -->
      <Script>
        $p = Get-Item fpc:\ContainingServer\Adapters
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="86" Name="DATAID_SERVER_OS_MAJOR_VERSION">
      <!-- This server OS major version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer OperatingSystemMajorVersion
        $p.OperatingSystemMajorVersion
      </Script>
    </DataPoint>
    <DataPoint Id="87" Name="DATAID_SERVER_OS_MINOR_VERSION">
      <!-- This server OS minor version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer OperatingSystemMinorVersion
        $p.OperatingSystemMinorVersion
      </Script>
    </DataPoint>
    <DataPoint Id="88" Name="DATAID_SERVER_OS_SUITE_MASK">
      <!-- This server OS suite mask -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer OperatingSystemSuiteMask
        $p.OperatingSystemSuiteMask
      </Script>
    </DataPoint>
    <DataPoint Id="89" Name="DATAID_SERVER_SP_MAJOR_VERSION">
      <!-- This server OS SP major version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer ServicePackMajorVersion
        $p.ServicePackMajorVersion
      </Script>
    </DataPoint>
    <DataPoint Id="90" Name="DATAID_SERVER_SP_MINOR_VERSION">
      <!-- This server OS SP minor version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer ServicePackMinorVersion
        $p.ServicePackMinorVersion
      </Script>
    </DataPoint>
    <DataPoint Id="91" Name="DATAID_SERVER_ISA_MAJOR_VERSION">
      <!-- This server TMG major version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer ProductVersion
        $p.ProductVersion.Split(".")[0]
      </Script>
    </DataPoint>
    <DataPoint Id="92" Name="DATAID_SERVER_ISA_MINOR_VERSION">
      <!-- This server TMG minor version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer ProductVersion
        $p.ProductVersion.Split(".")[1]
      </Script>
    </DataPoint>
    <DataPoint Id="93" Name="DATAID_SERVER_ISA_BUILD_VERSION">
      <!-- This server TMG build version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer ProductVersion
        $p.ProductVersion.Split(".")[2]
      </Script>
    </DataPoint>
    <DataPoint Id="94" Name="DATAID_SERVER_ISA_HF_VERSION">
      <!-- This server TMG HF version -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer ProductVersion
        $p.ProductVersion.Split(".")[3]
      </Script>
    </DataPoint>
    <!-- Array Policy -->
    <DataPoint Id="95" Name="DATAID_ARRAY_POLICY_CONNECTION_LIMIT_ENALBED" Operation="BitField">
      <!-- Connection limit policy state -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy Enabled
        $p.Enabled
      </Script>
    </DataPoint>
    <DataPoint Id="96" Name="DATAID_ARRAY_POLICY_ACCESS_RULE_COUNT">
      <!-- The number of access rules -->
      <Script>
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 0) { $count += 1 }
        }
        $count
      </Script>
    </DataPoint>
    <DataPoint Id="97" Name="DATAID_ARRAY_POLICY_WEB_PUBLISHING_RULE_COUNT">
      <!-- The number of web publishing rules -->
      <Script>
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2) { $count += 1 }
        }
        $count
      </Script>
    </DataPoint>
    <DataPoint Id="98" Name="DATAID_ARRAY_POLICY_SERVER_PUBLISHING_COUNT">
      <!-- The number of server publishing rules -->
      <Script>
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 1) { $count += 1 }
        }
        $count
      </Script>
    </DataPoint>
    <!-- Setup -->
    <DataPoint Id="99" Name="DATAID_SETUP_QUESTIONS" Operation="BitField">
      <!-- Installed features -->
      <Script>
        $result = 0

        $val = Is-FpcFeatureInstalled "Message_Screener"
        if ($val -eq "True") { $result = 1 }

        $val = Is-FpcFeatureInstalled "Publish_Share_Directory"
        if ($val -eq "True") { $result = $result -bor 2 }

        $val = Is-FpcFeatureInstalled "MSFirewall_Management"
        if ($val -eq "True") { $result = $result -bor 4 }

        # bit 4 (1000) is skiped

        $val = Is-FpcFeatureInstalled "Storage_Server"
        if ($val -eq "True") { $result = $result -bor 16 }

        $result
      </Script>
    </DataPoint>
    <!-- OS Info -->
    <DataPoint Id="100" Name="DATAID_MACHINE_CURRENT_TIME_ZONE">
      <!-- the current time zone -->
      <Script>
        $d = Get-Date
        $d = $d - $d.ToUniversalTime()
        $d.Hours * 60
      </Script>
    </DataPoint>
    <DataPoint Id="101" Name="DATAID_MACHINE_OS_LOCALE">
      <!-- The OS locale code -->
      <Script>
        $c = Get-Culture
        $c.LCID
      </Script>
    </DataPoint>
    <DataPoint Id="102" Name="DATAID_MACHINE_USER_LOCALE">
      <!-- The user locale code -->
      <Script>
        $c = Get-UICulture
        $c.LCID
      </Script>
    </DataPoint>
    <DataPoint Id="103" Name="DATAID_MACHINE_NUMBER_OF_PROCESSORS">
      <!-- The number of processors of the machine -->
      <Script>
        $cpus = Get-CpuCount
        $cpus
      </Script>
    </DataPoint>

    <!-- Skiped DataPoint: 104, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
    <!-- Skiped DataPoint: 105, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
    <!-- Skiped DataPoint: 106, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->
    <!-- Skiped DataPoint: 107, DATAID_DATAID_SIGNALED_ALERTS1 (Obsolete) -->

    <!-- Rule Elements-->
    <DataPoint Id="108" Name="DATAID_RULE_ELEMENTS_SERVER_FARMS">
      <!-- The number of server farms -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\RuleElements\ServerFarms
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="109" Name="DATAID_RULE_ELEMENTS_FARMS_PCT_CONNECTIVITY_VERIFIER_HTTP">
      <!-- The percentage of server farms with HTTP conectivity verifier -->
      <Script>
        $farms = Get-Item fpc:\ContainingArray\RuleElements\ServerFarms
        $result = 0
        if ($farms.Children.Length -gt 0)
        {
          $count = 0
          foreach ($farm in Get-ChildItem fpc:\ContainingArray\RuleElements\ServerFarms)
          {
            $path = "fpc:\ContainingArray\RuleElements\ServerFarms\'" + $farm.StorageName + "'\ConnectivityVerifier"
            $p = Get-ItemProperty $path RequestType
            if ($p.RequestType -eq 0) { $count += 1 }
          }
          $result = $count * 100 / $farms.Children.Length
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="110" Name="DATAID_RULE_ELEMENTS_FARMS_PCT_CONNECTIVITY_VERIFIER_TCP">
      <!-- The percentage of server farms with TCP conectivity verifier -->
      <Script>
        $farms = Get-Item fpc:\ContainingArray\RuleElements\ServerFarms
        $result = 0
        if ($farms.Children.Length -gt 0)
        {
          $count = 0
          foreach ($farm in Get-ChildItem fpc:\ContainingArray\RuleElements\ServerFarms)
          {
            $path = "fpc:\ContainingArray\RuleElements\ServerFarms\'" + $farm.StorageName + "'\ConnectivityVerifier"
            $p = Get-ItemProperty $path RequestType
            if ($p.RequestType -eq 2) { $count += 1 }
          }
          $result = $count * 100 / $farms.Children.Length
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="111" Name="DATAID_RULE_ELEMENTS_FARMS_PCT_CONNECTIVITY_VERIFIER_PING">
      <!-- The percentage of server farms with PING conectivity verifier -->
      <Script>
        $farms = Get-Item fpc:\ContainingArray\RuleElements\ServerFarms
        $result = 0
        if ($farms.Children.Length -gt 0)
        {
          $count = 0
          foreach ($farm in Get-ChildItem fpc:\ContainingArray\RuleElements\ServerFarms)
          {
            $path = "fpc:\ContainingArray\RuleElements\ServerFarms\'" + $farm.StorageName + "'\ConnectivityVerifier"
            $p = Get-ItemProperty $path RequestType
            if ($p.RequestType -eq 1) { $count += 1 }
          }
          $result = $count * 100 / $farms.Children.Length
        }
        $result
      </Script>
    </DataPoint>
    <!-- Web Listeners PCT -->
    <DataPoint Id="112" Name="DATAID_WEB_LISTENER_PCT_CLIENT_CERTIFICATE_AUTH">
      <!-- The percentage of web listeners with SSL certificate authentication -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
            $p = Get-ItemProperty $path SSLCertificateAuthentication
            if ($p.SSLCertificateAuthentication -eq "True") { $count += 1 }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="317" Name="DATAID_WEB_LISTENER_CLIENT_CERT_AUTH">
      <!-- The number of web listeners with SSL certificate authentication -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
          $p = Get-ItemProperty $path SSLCertificateAuthentication
          if ($p.SSLCertificateAuthentication -eq "True") { $result += 1 }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="113" Name="DATAID_WEB_LISTENER_PCT_RADIUS_OTP_AUTH">
      <!-- The percentage of web listeners with RADIUS OTP authentication -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "RADIUS OTP") { $count += 1 }
              }
            }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="321" Name="DATAID_WEB_LISTENER_OTP_AUTH">
      <!-- The number of web listeners with RADIUS OTP authentication -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "RADIUS OTP") { $result += 1 }
              }
            }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="114" Name="DATAID_WEB_LISTENER_PCT_SECUR_ID_AUTH">
      <!-- The percentage of web listeners with Secure Id authentication -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "SecurID") { $count += 1 }
              }
            }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="323" Name="DATAID_WEB_LISTENER_SECURE_ID_AUTH">
      <!-- The number of web listeners with Secure Id authentication -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "SecurID") { $result += 1 }
              }
            }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="115" Name="DATAID_WEB_LISTENER_PCT_LDAP_AUTH">
      <!-- The percentage of web listeners with LDAP authentication -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "LDAP") { $count += 1 }
              }
            }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="313" Name="DATAID_WEB_LISTENER_LDAP_AUTH">
      <!-- The number of web listeners with LDAP authentication -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "LDAP") { $result += 1 }
              }
            }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="116" Name="DATAID_WEB_LISTENER_PCT_FBA_AUTH">
      <!-- The percentage of web listeners with FBA authentication -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "FBA") { $count += 1 }
              }
            }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="312" Name="DATAID_WEB_LISTENER_FBA_AUTH">
      <!-- The number of web listeners with FBA authentication -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\AuthenticationSchemes"
            foreach ($ref in Get-ChildItem $path)
            {
              $path1 = $path + "\'" + $ref.StorageName + "'"
              foreach ($authScheme in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $authScheme.StorageName + "'"
                $p = Get-ItemProperty $path2 Namespace
                if ($p.Namespace -match "FBA") { $result += 1 }
              }
            }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="117" Name="DATAID_WEB_LISTENER_PCT_FBA_AND_CLIENT_CERTIFICATE_AUTH">
      <!-- The percentage of web listeners with FBA and client certificate authentication -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
            $p = Get-ItemProperty $path SSLCertificateAuthentication
            $sslCertAuth = $p.SSLCertificateAuthentication
            if ($sslCertAuth)
            {
              $path1 = $path + "\AuthenticationSchemes"
              foreach ($ref in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $ref.StorageName + "'"
                foreach ($authScheme in Get-ChildItem $path2)
                {
                  $path3 = $path2 + "\'" + $authScheme.StorageName + "'"
                  $p = Get-ItemProperty $path3 Namespace
                  if (($p.Namespace -match "FBA") -and ($sslCertAuth)) { $count += 1; $sslCertAuth = 0; break }
                }
                if (-not sslCertAuth) { break; }
              }
            }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="327" Name="DATAID_WEB_LISTENER_FBA_CLIENT_CERT_AUTH">
      <!-- The number of web listeners with FBA and client certificate authentication -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties"
            $p = Get-ItemProperty $path SSLCertificateAuthentication
            $sslCertAuth = $p.SSLCertificateAuthentication
            if ($sslCertAuth)
            {
              $path1 = $path + "\AuthenticationSchemes"
              foreach ($ref in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $ref.StorageName + "'"
                foreach ($authScheme in Get-ChildItem $path2)
                {
                  $path3 = $path2 + "\'" + $authScheme.StorageName + "'"
                  $p = Get-ItemProperty $path3 Namespace
                  if (($p.Namespace -match "FBA") -and ($sslCertAuth)) { $result += 1; $sslCertAuth = 0; break }
                }
                if (-not sslCertAuth) { break; }
              }
            }
        }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="118" Name="DATAID_WEB_LISTENER_PCT_CUSTOM_HTML_FORM">
      <!-- The percentage of web listeners with custom HTML authentication form -->
      <Script>
        $WL = Get-Item fpc:\ContainingArray\RuleElements\WebListeners
        $WLCount = $WL.Children.Length
        $result = 0
        if ($WLCount -gt 0)
        {
          $count = 0
          foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
          {
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\FormsBasedAuthenticationProperties"
            $p = Get-ItemProperty $path CustomFormsDirectory
            if ($p.CustomFormsDirectory.Length -gt 0) { $count +=1 }
          }
          $result = $count * 100 / $WLCount
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="318" Name="DATAID_WEB_LISTENER_CUSTOM_FBA">
      <!-- The numbe of web listeners with custom HTML authentication form -->
      <Script>
        $result = 0
        foreach ($listener in Get-ChildItem fpc:\ContainingArray\RuleElements\WebListeners)
        {
          $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listener.StorageName + "'\Properties\FormsBasedAuthenticationProperties"
          $p = Get-ItemProperty $path CustomFormsDirectory
          if ($p.CustomFormsDirectory.Length -gt 0) { $result +=1 }
        }
        $result
      </Script>
    </DataPoint>
    <!-- Array Policy - Web Publishing -->
    <DataPoint Id="119" Name="DATAID_ARRAY_POLICY_WEB_PUBLISHING_PCT_SECUR_ID_DELEGATION">
      <!-- The percentage of web publishing rules with SecureID delegation -->
      <Script>
        $wpRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $wpRulesCount += 1
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 2) { $count += 1 }
          }
        }

        $result = 0
        if ($wpRulesCount -gt 0) { $result = $count * 100 / $wpRulesCount }
        $result
      </Script>
    </DataPoint>

    <DataPoint Id="335" Name="DATAID_WEB_PUBLISHING_DELEGATION_SECURE_ID">
      <!-- The number of web publishing rules with SecureID delegation -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 2) { $result += 1 }
          }
        }
        $result
      </Script>
    </DataPoint>

    <DataPoint Id="120" Name="DATAID_ARRAY_POLICY_WEB_PUBLISHING_PCT_KERBEROS_DELEGATION">
      <!-- The percentage of web publishing rules with kerberos delegation -->
      <Script>
        $wpRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $wpRulesCount += 1
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 6) { $count += 1 }
          }
        }

        $result = 0
        if ($wpRulesCount -gt 0) { $result = $count * 100 / $wpRulesCount }
        $result
      </Script>
    </DataPoint>

    <DataPoint Id="334" Name="DATAID_WEB_PUBLISHING_DELEGATION_KCD">
      <!-- The number of web publishing rules with kerberos delegation -->
      <Script>
        $result = 0

        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 6) { $result += 1 }
          }
        }

        $result
      </Script>
    </DataPoint>

    <DataPoint Id="121" Name="DATAID_ARRAY_POLICY_WEB_PUBLISHING_PCT_SSL_BRINDGING">
      <!-- The percentage of web publishing rules with SSL binding -->
      <Script>
        $wpRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $wpRulesCount += 1
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path PublishedServerType
            if (($p.PublishedServerType -eq 1) -or ($p.PublishedServerType -eq 2))
            {
              $count += 1
            }
          }
        }

        $result = 0
        if ($wpRulesCount -gt 0) { $result = $count * 100 / $wpRulesCount }
        $result
      </Script>
    </DataPoint>

    <DataPoint Id="122" Name="DATAID_ARRAY_POLICY_WEB_PUBLISHING_PCT_CUSTOM_HTML_FORM">
      <!-- The percentage of web publishing rules with custom HTML form authentication -->
      <Script>
        $wpRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $wpRulesCount += 1
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CustomFormsDirectory
            if ($p.CustomFormsDirectory.Length -gt 0) { $count += 1 }
          }
        }

        $result = 0
        if ($wpRulesCount -gt 0) { $result = $count * 100 / $wpRulesCount }
        $result
      </Script>
    </DataPoint>
    <!-- Array Policy - Web Publishing w/ NLB -->
    <DataPoint Id="123" Name="DATAID_ARRAY_POLICY_WEB_FARM_PUBLISHING_RULE_COUNT">
      <!-- The number of web publishing rules with NLB enabled -->
      <Script>
        $wpRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $wpRulesCount += 1
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path LoadBalancingEnabled
            if ($p.LoadBalancingEnabled -eq "True") { $count += 1 }
          }
        }

        $result = 0
        if ($wpRulesCount -gt 0) { $result = $count * 100 / $wpRulesCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="124" Name="DATAID_ARRAY_POLICY_WEB_FARM_PCT_AFFINITY_IP">
      <!-- The percentage of web publishing rules with NLB enabled that have IP affinity -->
      <Script>
        $wpNlbRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path LoadBalancingEnabled
            if ($p.LoadBalancingEnabled -eq "True")
            {
              $wpNlbRulesCount += 1
              $path1 = $path + "\LoadBalancingConfig"
              $p = Get-ItemProperty $path1 AffinityType
              if ($p.AffinityType -eq 1) { $count += 1 }
            }
          }
        }

        $result = 0
        if ($wpNlbRulesCount -gt 0) { $result = $count * 100 / $wpNlbRulesCount }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="125" Name="DATAID_ARRAY_POLICY_WEB_FARM_PCT_AFFINITY_SESSION">
      <!-- The percentage of web publishing rules with NLB enabled that have session affinity -->
      <Script>
        $wpNlbRulesCount = 0
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path LoadBalancingEnabled
            if ($p.LoadBalancingEnabled -eq "True")
            {
              $wpNlbRulesCount += 1
              $path1 = $path + "\LoadBalancingConfig"
              $p = Get-ItemProperty $path1 AffinityType
              if ($p.AffinityType -eq 0) { $count += 1 }
            }
          }
        }

        $result = 0
        if ($wpNlbRulesCount -gt 0) { $result = $count * 100 / $wpNlbRulesCount }
        $result
      </Script>
    </DataPoint>
    <!-- Connections -->
    <DataPoint Id="126" Name="DATAID_CONNECTION_LIMIT_ENALBED" Operation="BitField">
      <!-- Connection limit settings -->
      <Script>
        $policy = "fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy"
        $result = 0

        $p = Get-ItemProperty $policy Enabled
        if ($p.Enabled -eq "True") { $result = 1 }

        $p = Get-ItemProperty $policy LogQuotaRejectedTraffic
        if ($p.LogQuotaRejectedTraffic -eq "True") { $result = $result -bor 2 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="127" Name="DATAID_CONNECTION_LIMIT_TCP_LIMIT">
      <!-- Connection default TCP limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy\DefaultLimit TcpLimit
        $p.TcpLimit
      </Script>
    </DataPoint>
    <DataPoint Id="128" Name="DATAID_CONNECTION_LIMIT_UDP_LIMIT">
      <!-- Connection default UDP limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy\DefaultLimit UdpLimit
        $p.UdpLimit
      </Script>
    </DataPoint>
    <DataPoint Id="129" Name="DATAID_CONNECTION_LIMIT_OTHER_LIMIT">
      <!-- Connection default other limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy\DefaultLimit OtherLimit
        $p.OtherLimit
      </Script>
    </DataPoint>
    <DataPoint Id="130" Name="DATAID_CONNECTION_LIMIT_TCP_PER_MINUTE">
      <!-- Connection default TCP connections per minute limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy\DefaultLimit TcpLimitPerMinute
        $p.TcpLimitPerMinute
      </Script>
    </DataPoint>
    <DataPoint Id="131" Name="DATAID_CONNECTION_LIMIT_HTTP_PER_MINUTE">
      <!-- Connection default HTTP connections per minute limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy\DefaultLimit HttpLimitPerMinute
        $p.HttpLimitPerMinute
      </Script>
    </DataPoint>
    <DataPoint Id="132" Name="DATAID_CONNECTION_LIMIT_RULE_PER_SECOND">
      <!-- Connection default rule evauation per second limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy RulePerSecondLimit
        $p.RulePerSecondLimit
      </Script>
    </DataPoint>
    <DataPoint Id="133" Name="DATAID_CONNECTION_LIMIT_TRIGGER_EVENT_FOR_DENIED_PACKETS">
      <!-- Connection default logged denied packet per minute limit -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\ConnectionLimitPolicy LoggedDeniedPerMinute
        $p.LoggedDeniedPerMinute
      </Script>
    </DataPoint>
    <!-- HTTP Compression -->
    <DataPoint Id="134" Name="DATAID_COMPRESSION_ENABLED" Operation="BitField">
      <!-- Compression enabled/disabled -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration Enabled
        $p.Enabled
      </Script>
    </DataPoint>
    <DataPoint Id="135" Name="DATAID_COMPRESSION_REQUEST_SOURCE_ITEMS">
      <!-- The count of source items in the RequestSource -->
      <Script>
        $count = 0

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestSource\Networks
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestSource\NetworkSets
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestSource\Computers
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestSource\AddressRanges
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestSource\Subnets
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestSource\ComputerSets
        $count += $p.Children.Length

        $count
      </Script>
    </DataPoint>
    <DataPoint Id="136" Name="DATAID_COMPRESSION_REQUEST_DESTINATION_ITEMS">
      <!-- The count of source items in the RequestDestination -->
      <Script>
        $count = 0

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestDestination\Networks
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestDestination\NetworkSets
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestDestination\Computers
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestDestination\AddressRanges
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestDestination\Subnets
        $count += $p.Children.Length

        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\RequestDestination\ComputerSets
        $count += $p.Children.Length

        $count
      </Script>
    </DataPoint>
    <DataPoint Id="137" Name="DATAID_COMPRESSION_WEB_LISTENERS">
      <!-- The count of web listeners -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\WebListeners
        $p.Children.Length
      </Script>
    </DataPoint>
    <DataPoint Id="138" Name="DATAID_COMPRESSION_CONTENT_TYPE_COUNT">
      <!-- The count of content types -->
      <Script>
        $p = Get-Item fpc:\ContainingArray\ArrayPolicy\WebProxy\HTTPCompressionConfiguration\CompressibleContentTypeSets
        $p.Children.Length
      </Script>
    </DataPoint>
    <!-- Network templates -->
    <DataPoint Id="139" Name="DATAID_NETWORK_TEMPLATE_USED">
      <!-- the network template used -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkTemplateUsed Guid

        $result = 6
        if ($p.Guid -ieq "{e826736f-262a-47af-8871-980561676073}") { $result = 1 }
        if ($p.Guid -ieq "{9be6f18a-57ad-4cea-b924-2cfedfef3799}") { $result = 2 }
        if ($p.Guid -ieq "{2ef25ed2-c029-4a5b-b274-590b9953f2f5}") { $result = 3 }
        if ($p.Guid -ieq "{1c02d67f-7cf6-429c-9b46-b7805fcced41}") { $result = 4 }
        if ($p.Guid -ieq "{2c02d67f-7cf6-429c-9b46-b7805fcced42}") { $result = 5 }
        $result
      </Script>
    </DataPoint>
    <!-- Log Count -->
    <DataPoint Id="140" Name="DATAID_LOGGING_DAILY_FW_LOG_COUNT">
      <!-- Get the FW daily log count -->
      <Script>
        $result = Get-RegValue "DailyFWLogCount"
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="141" Name="DATAID_LOGGING_DAILY_WP_LOG_COUNT">
      <!-- Get the WP daily log count -->
      <Script>
        $result = Get-RegValue "DailyWEBLogCount"
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="142" Name="DATAID_LOGGING_MAX_DAILY_FW_LOG_COUNT">
      <!-- Get the FW daily log max count -->
      <Script>
        $result = Get-RegValue "DailyFWMaxLogRate"
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="143" Name="DATAID_LOGGING_MAX_DAILY_WP_LOG_COUNT">
      <!-- Get the WP daily log max count -->
      <Script>
        $result = Get-RegValue "DailyWEBMaxLogRate"
        $result
      </Script>
    </DataPoint>
    <!-- Server info -->
    <DataPoint Id="144" Name="DATAID_SERVER_DOMAIN_MEMBERSHIP">
      <!-- Get the domain membership state of the current server -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingServer IsJoinedToDomain
        $p.IsJoinedToDomain
      </Script>
    </DataPoint>
    <!-- Windows Update -->
    <DataPoint Id="145" Name="DATAID_SERVER_AUTO_UPDATE_STATE">
      <!-- MU settings -->
      <Script>
        $result = Get-RegValue "AUOptions" -Key "SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update"
        $result
      </Script>
    </DataPoint>

    <!-- Skiped DataPoint: 146, DATAID_DATAID_SERVER_FRAMEWORK_VERSION (no longer relevant) -->

    <!-- Diagnostic logging -->
    <DataPoint Id="147" Name="DATAID_DIAG_LOGGING_USED">
      <!-- Was diagnostic logging used since the last SQM -->
      <Script>
        $result = Get-RegValue "ISAIsDiaglogOn" -ResetValue 1
        $result
      </Script>
    </DataPoint>

    <!-- Skiped DataPoint: 148, DATAID_IAG_OS_VERSION_MAJOR (IAG) -->
    <!-- Skiped DataPoint: 149, DATAID_IAG_OS_VERSION_MINOR (IAG) -->
    <!-- Skiped DataPoint: 150, DATAID_IAG_OS_SP_VERSION (IAG) -->
    <!-- Skiped DataPoint: 151, DATAID_IAG_VERSION (IAG) -->
    <!-- Skiped DataPoint: 152, DATAID_IAG_SETUP_SUCCESSFUL (IAG) -->
    <!-- Skiped DataPoint: 153, DATAID_IAG_UTM_PROXY_ENABLED (IAG) -->
    <!-- Skiped DataPoint: 154, DATAID_BPA_WAS_HELPFUL (BPA) -->
    <!-- Skiped DataPoint: 155, DATAID_DATAID_BPA_ALERTS1 (BPA) -->
    <!-- Skiped DataPoint: 156, DATAID_DATAID_BPA_ALERTS2 (BPA) -->
    <!-- Skiped DataPoint: 157, DATAID_DATAID_BPA_ALERTS3 (BPA) -->
    <!-- Skiped DataPoint: 158, DATAID_DATAID_BPA_ALERTS4 (BPA) -->
    <!-- Skiped DataPoint: 159, DATAID_DATAID_BPA_ALERTS5 (BPA) -->
    <!-- Skiped DataPoint: 160, DATAID_DATAID_BPA_ALERTS6 (BPA) -->
    <!-- Skiped DataPoint: 161, DATAID_DATAID_BPA_ALERTS7 (BPA) -->

    <DataPoint Id="162" Name="DATAID_FW_SRV_FAIL_REASON">
      <!-- The most significant failure reason since the last analysis -->
      <Script>
        $reason = Get-LogAnalysis "Reason"
        $reason
      </Script>
    </DataPoint>
    <DataPoint Id="163" Name="DATAID_FW_SRV_FAIL_DETAILS">
      <!-- The most significant failure aditional details since the last analysis -->
      <Script>
        $details = Get-LogAnalysis "Details"
        $details
      </Script>
    </DataPoint>
    <DataPoint Id="164" Name="DATAID_FW_SRV_UPTIME">
      <!-- The most significant failure FW SRV uptime since the last analysis -->
      <Script>
        $details = Get-LogAnalysis "Uptime"
        $details
      </Script>
    </DataPoint>

    <!-- Skiped DataPoint: 165, DATAID_IAG_OS_AUTO_UPDATE (IAG) -->
    <!-- Skiped DataPoint: 166, DATAID_IAG_OS_LANGUAGE (IAG) -->
    <!-- Skiped DataPoint: 167, DATAID_IAG_WFLB_APPS (IAG) -->
    <!-- Skiped DataPoint: 168, DATAID_IAG_WFLB_SERVERS (IAG) -->
    <!-- Skiped DataPoint: 169, DATAID_IAG_WFLB_QUESTIONS (IAG) -->

    <!-- Change tracking -->
    <DataPoint Id="170" Name="DATAID_ARRAY_CHANGE_TRACKING" Operation="BitField">
      <!-- change tracking settings -->
      <Script>
        $result = 0

        $p = Get-ItemProperty fpc:\ContainingArray\ChangeTracking Enabled
        if ($p.Enabled -eq "True") { $result = 1 }

        $result
      </Script>
    </DataPoint>
    <!-- Supportability -->
    <DataPoint Id="171" Name="DATAID_TRAFFIC_SIMULATOR_USED">
      <!-- Was the traffic simulator used since the last SQM upload -->
      <Script>
        $result = Get-RegValue "ISAIsTrafficSimulatorUsed" -ResetValue 1
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="172" Name="DATAID_TEST_BUTTON_USED">
      <!-- Was the test button used since the last SQM upload -->
      <Script>
        $result = Get-RegValue "ISAIsTestButtonUsed" -ResetValue 1
        $result
      </Script>
    </DataPoint>
    <!-- Alerts -->
    <DataPoint Id="173" Name="DATAID_ALERTS">
      <!-- Signaled alerts in the last 24h -->
      <Script>
        $lastTime = (Get-Date).AddDays(-1)
        $result = @{}
        foreach ($alert in Get-ChildItem fpc:\ContainingServer\SignaledAlerts)
        {
          $count = 0
          $acknowledged = 0
          $path = "fpc:\ContainingServer\SignaledAlerts\'" + $alert.Name + "'"
          foreach ($ai in Get-ChildItem $path)
          {
            $path1 = $path + "\'" + $ai.Name + "'"
            $p = Get-ItemProperty $path1 TimeStamp
            $signalTime = Get-Date $p.TimeStamp
            if ($signalTime -gt $lastTime)
            {
              $p = Get-ItemProperty $path1 Count
              $count += $p.Count
              $p = Get-ItemProperty $path1 Acknowledged
              if ($p.Acknowledged -eq "True") { $acknowledged += $ai.Children.Length }
            }
          }

          if ($count -gt 0)
          {
            $Id = Get-ItemProperty $path EventGUID
            $Key = Get-ItemProperty $path AdditionalKey
            $Name = Get-ItemProperty $path Name

            $list = $Id.EventGUID, $Key.AdditionalKey, $Name.Name, $count, $acknowledged
            $result.Add($Id.EventGUID, $list)
          }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="174" Name="DATAID_NIS_SIG_DETECT_ONLY_PERCENT">
      <!-- Percent of Network Inspection System (NIS) signatures that are applied with detect only -->
      <Script>
        $sigCount = 0
        $sigDetect = 0
        $path = "fpc:\ContainingServer\NisSignatureSet\Signatures"
        foreach ($signature in Get-ChildItem fpc:\ContainingServer\NisSignatureSet\Signatures)
        {
            $sigCount++

            $path1 = $path + "\'" + $signature.StorageName + "'"
            $response = Get-ItemProperty $path1 Response
            if ($response.Response -eq 1)
            {
                $sigDetect++
            }
        }
        $p = 0
        if ($sigCount -gt 0)
        {
            $p = 100 * $sigDetect / $sigCount
        }
        $p
      </Script>
    </DataPoint>
    <DataPoint Id="175" Name="DATAID_NIS_INSPECTION_STATUS">
      <!-- Network inspection system (NIS) status -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkInspectionSystem Enabled
        $p.Enabled
      </Script>
    </DataPoint>
    <DataPoint Id="176" Name="DATAID_NIS_NEW_SIG_POLICY">
      <!-- Network Inspection System (NIS) policy of applying new signatures: either default, detect, or disable -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkInspectionSystem InitialSignatureConfiguration
        $p.InitialSignatureConfiguration
      </Script>
    </DataPoint>
    <DataPoint Id="177" Name="DATAID_NIS_ACTIVATED_SNAPSHOT">
    <!-- Network Inspection System (NIS) snapshot activated: most recent, second most recent, ..., fifth most recent -->
      <Script>
        $index = 0
        $p = Get-ItemProperty fpc:\ContainingArray\NetworkInspectionSystem MostRecentSignatureSetUsed
        if ($p.MostRecentSignatureSetUsed -eq "False")
        {
            $activeDate = Get-ItemProperty fpc:\ContainingArray\NetworkInspectionSystem\ActiveSignatureSet ReleaseDate
            $path = "fpc:\ContainingArray\NetworkInspectionSystem\AvailableSignatureSets"
            foreach ($availableSigSet in Get-ChildItem fpc:\ContainingArray\NetworkInspectionSystem\AvailableSignatureSets)
            {
                $path1 = $path + "\'" + $availableSigSet.StorageName + "'"
                $currDate = Get-ItemProperty $path1 ReleaseDate

                if ($currDate.ReleaseDate -lt $activeDate.ReleaseDate)
                {
                    $index++
                }
            }
        }
        $index
      </Script>
    </DataPoint>
    <DataPoint Id="178" Name="DATAID_NIS_UPDATE_ACTION">
      <!-- Network Inspection System (NIS) automatic update action: either check and install, check only, or no automatic action -->
      <Script>
        $p =  Get-ItemProperty fpc:\ContainingArray\UpdateCenter\UpdateServices\'{464716F5-0BAB-494a-A51A-30400DDF127F}' UpdateAction
        $p.UpdateAction
      </Script>
    </DataPoint>
    <DataPoint Id="179" Name="DATAID_SPY_NET_SELECTION">
      <!-- SpyNet Selection: not joined, basic join, extended join -->
      <Script>
        $p = Get-ItemProperty fpc:\ContainingArray SpyNetLevel
        $p.SpyNetLevel
      </Script>
    </DataPoint>
    <DataPoint Id="180" Name="DATAID_NIS_SIG_DEFAULT_PERCENT">
    <!-- Percent of Network Inspection System (NIS) signatures that are applied with default response -->
      <Script>
        $sigCount = 0
        $sigDefault = 0
        $path = "fpc:\ContainingServer\NisSignatureSet\Signatures"
        foreach ($signature in Get-ChildItem fpc:\ContainingServer\NisSignatureSet\Signatures)
        {
            $sigCount++

            $path1 = $path + "\'" + $signature.StorageName + "'"
            $policy = Get-ItemProperty $path1 CustomPolicyUsed
            if ($policy.CustomPolicyUsed -eq "False")
            {
                $sigDefault++
            }
        }
        $p = 0
        if ($sigCount -gt 0)
        {
            $p = 100 * $sigDefault / $sigCount
        }
        $p
      </Script>
    </DataPoint>
    <!-- SIP -->
    <DataPoint Id="181" Name="DATAID_SIP_SETTINGS">
      <!-- SIP Settings -->
      <!-- Bit 1: VOIP Exist -->
      <!-- Bit 2: Centrix scenario -->
      <!-- Bit 3: SIP Trunk scenario -->
      <Script>
        # VOIP exist if there is an access rule w/ SIP protocol (bit 1)
        # SIP Trunk scenario: server publishing rule w/ SIP_SERVER protocol
        $bit1Set = 0
        $bit3Set = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"

          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 0)
          {
            # access rule
            if ($bit1Set -ne 0) { continue }
            $path += "\AccessProperties"
            $p = Get-ItemProperty $path ProtocolSelectionMethod
            if ($p.ProtocolSelectionMethod -ne 1) { continue } # ignore non-specific rules
            $path1 = $path + "\SpecifiedProtocols"
            foreach ($ref in Get-ChildItem $path1)
            {
              $path2 = $path1 + "\'" + $ref.StorageName + "'"
              foreach ($protocol in Get-ChildItem $path2)
              {
                if ($protocol.StorageName -eq "{9b5cb9f6-5b2b-47be-924e-2d6db0527292}")
                {
                  #found SIP
                  $bit1Set = 1
                }
              }
            }
          }
          elseif ($p.Type -eq 1)
          {
            # server publishing
            if ($bit3Set -ne 0) { continue }
            $path += "\ServerPublishingProperties\PublishedProtocol"
            foreach ($protocol in Get-ChildItem $path)
            {
              if ($protocol.StorageName -eq "{bb1a05b4-7fad-4690-8668-5103f69e7e4e}")
              {
                #found SIP_SERVER
                $bit3Set = 1
              }
            }
          }

          if (($bit1Set -ne 0) -and ($bit3Set -ne 0))
          {
            # both bits are set no need to continue
            break
          }
        }

        $result = 0
        if ($bit1Set -ne 0) { $result = 1 }

        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\SipSettings ExternalRegistrationEnabled
        if ($p.ExternalRegistrationEnabled -eq "True")
        {
          $result = $result -bor 2
        }

        if ($bit3Set -ne 0) { $result = $result -bor 4 }

        $result
      </Script>
    </DataPoint>


    <DataPoint Id="182" Name="DATAID_DA_GENERAL_SETTINGS" Operation="BitField">
      <!-- General settings of Direct Access feature (bitmap).
              Bit 1 - Is DA enabled?
        -->
      <Script>
        $bitmap = 0
        $DAEnabled = (get-itemproperty fpc:\ContainingArray\ArrayPolicy\IPv6Settings DirectAccessEnabled).DirectAccessEnabled
        if ($DAEnabled -eq "True")    {$bitmap = $bitmap -bor 1}
        $bitmap
      </Script>
    </DataPoint>


    <DataPoint Id="183" Name="DATAID_ISPR_CURRENT_POLICY">
      <!-- Current policy of ISP Redundancy -->
      <Script>
        $path="fpc:\ContainingArray\NetworkConfiguration\Networks\External\ISPRedundancyConfig"
        $currentPolicy = (Get-itemproperty $path IspRedundancyPolicy).IspRedundancyPolicy
        $currentPolicy
      </Script>
    </DataPoint>


    <DataPoint Id="184" Name="DATAID_ENAT_RULES_COUNT">
      <!-- The number of eNAT rules -->
      <Script>
        # We identify eNAT rule by having a non-default hiding address.
        $rulesCount = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\NetworkRules)
        {
          $addrCount = 0
          $path = "fpc:\ContainingArray\NetworkConfiguration\NetworkRules\'" + $rule.Name + "'\HidingAddresses"
          Get-ChildItem $path | foreach {$addrCount += 1}
          if ($addrCount -gt 0)
          {
            $rulesCount += 1
          }
        }
        $rulesCount
      </Script>
    </DataPoint>


    <DataPoint Id="185" Name="DATAID_ENAT_VIP_RULES_COUNT">
      <!-- Number of eNAT rules that use VIP as hiding address -->
      <Script>
        #First, Retrieving all VIPs
        $allVIPs = @()
        foreach ($network in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\Networks)
        {
          $path = "fpc:\ContainingArray\NetworkConfiguration\Networks\'" + $network.name + "'"
          if ((get-childitem $path | where {$_.name -eq "NLBCluster"}) -ne $null)
          {
            # Add the default VIP to the list
            $allVIPs += (get-itemproperty "$path\NLBCluster" VIP).VIP

            # Add the additional VIPs to the list
            get-childitem "$path\NLBCluster\AdditionalVIPs" | foreach {$allVIPs += $_.name}
          }
        }

        # Now count rules that have VIP as a hiding address
        $rulesCount = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\NetworkRules)
        {
          $addrCount = 0
          $path = "fpc:\ContainingArray\NetworkConfiguration\NetworkRules\'" + $rule.Name + "'\HidingAddresses"
          Get-ChildItem $path | foreach {if ($allVIPs -contains $_.name) { $addrCount += 1}}
          if ($addrCount -gt 0)
          {
            $rulesCount += 1
          }
        }
        $rulesCount
      </Script>
    </DataPoint>


    <DataPoint Id="186" Name="DATAID_ENAT_HIDING_ADDRESSES_PER_RULE">
      <!-- Average number of hiding addresses per eNAT rule -->
      <Script>
        $addressesCount = 0
        $rulesCount = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\NetworkRules)
        {
          $ruleAddrCount = 0
          $path = "fpc:\ContainingArray\NetworkConfiguration\NetworkRules\'" + $rule.Name + "'\HidingAddresses"
          Get-ChildItem $path | foreach {$ruleAddrCount += 1}
          if ($ruleAddrCount -gt 0)
          {
            $addressesCount += $ruleAddrCount
            $rulesCount += 1
          }
        }
        # Prevent division by 0
        if ($rulesCount -eq 0)
        {
          $average = 0
        }
        else
        {
          $average = ($addressesCount/$rulesCount)
        }

        ($average)

      </Script>
    </DataPoint>


    <DataPoint Id="187" Name="DATAID_EMAIL_POLICY_ROUTES_COUNT">
      <!-- Number of Email Policy Routes -->
      <Script>
        (get-item fpc:\ContainingArray\SmtpProtectionConfiguration\SmtpRoutes).children.length
      </Script>
    </DataPoint>


    <DataPoint Id="188" Name="DATAID_EMAIL_POLICY_SECURED_ROUTES_COUNT">
      <!-- Number of Email Policy Routes that use TLS -->
      <Script>
        $count = 0
        foreach ($smtpRoute in (Get-ChildItem fpc:\ContainingArray\SmtpProtectionConfiguration\SmtpRoutes))
        {
          # Generate the path of relevant properties
          $routeAuthPath = "fpc:\ContainingArray\SmtpProtectionConfiguration\SmtpRoutes\'" + $smtpRoute.name + "'\RouteAuthenticationSettings"
          $listenerAuthPath = "fpc:\ContainingArray\SmtpProtectionConfiguration\SmtpRoutes\'" + $smtpRoute.name + "'\ListenerAuthenticationSettings"

          # Get the properties
          $routeTlsEnabled = (Get-ItemProperty $routeAuthPath TlsEnabled).TlsEnabled
          $listenerTlsEnabled = (Get-ItemProperty $listenerAuthPath TlsEnabled).TlsEnabled

          if ($listenerTlsEnabled -eq "True" -or $routeTlsEnabled -eq "True")
          {
            $count += 1
          }
        }
        $count
      </Script>
    </DataPoint>


    <DataPoint Id="189" Name="DATAID_EMAIL_POLICY_ANTIVIRUS_ENG_COUNT">
      <!-- Number of working antivirus engines -->
      <Script>
        $engines=(get-itemproperty fpc:\ContainingArray\SmtpProtectionConfiguration\AntivirusSettings EngineSubset).EngineSubset

        # $engines is a bitmap of which engine is on.
        # In order to count them, just count the set bits
        $bitCount=0
        while ($engines -ne 0)
        {
          if ($engines%2 -ne 0)
          {
            $bitCount+=1
          }
          $engines = [math]::floor([int] $engines / [int] 2)
        }

        $bitCount
      </Script>
    </DataPoint>


    <DataPoint Id="190" Name="DATAID_EMAIL_POLICY_SCL_DIALOG_USED">
      <!-- Number of times SCL dialog was used -->
      <Script>
        $result = Get-RegValue "SclDialogUsageCounter" -ResetValue 1
        $result
      </Script>
    </DataPoint>


    <DataPoint Id="191" Name="DATAID_DA_NAT_PT_NETWORK_RULES_COUNT">
      <!--  -->
      <Script>
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\NetworkRules)
        {
          $path = "fpc:\ContainingArray\NetworkConfiguration\NetworkRules\'" + $rule.name + "'\NatPtPrefixes"
          if ((get-childitem $path) -ne $null)
          {
            $count += 1
          }
        }
        $count
      </Script>
    </DataPoint>


    <DataPoint Id="192" Name="DATAID_DA_NAT_PT_POLICY_RULES_COUNT">
      <!--  -->
      <Script>
        # We're looking for rules with source = Anywhere (IPv6)
        $ANYWHERE_V6_ADDRESS_RANGE_GUID = "{8565A7A1-6CBA-434d-9B60-C511192B8D02}"

        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.Name + "'\SourceSelectionIPs\AddressRanges"
          foreach ($range in Get-ChildItem $path)
          {
            $path = $path + "\'" + $range.name + "'"
            if ((Get-ItemProperty $path Guid).Guid -eq $ANYWHERE_V6_ADDRESS_RANGE_GUID)
            {
              $count += 1
            }
          }
        }
        $count
      </Script>
    </DataPoint>


    <DataPoint Id="193" Name="DATAID_EMAIL_POLICY_SETTINGS" Operation="BitField">
      <!-- General e-mail policy settings
              bit 1 - Is Edge subscription activated?
              bit 2 - Is Stirling controlling FSE on this host?
              bit 3 - Was the SMTP protection feature enabled?
              bit 4 - Is there any web-publishing policy rule that publishes an OWA server?
              bit 5 - Is there any server-publishing rule that publishes an SMTP server?
              bit 6 - Is any file-filter defined and active?
              bit 7 - Is any message-body-filter defined and active?
      -->
      <Script>

        $bitmap = 0

        # bit 1 - Is Edge subscription activated?
          $edgeSubscriptionEnabled = (get-itemproperty fpc:\ContainingArray\SmtpProtectionConfiguration EdgeSubscriptionEnabled).EdgeSubscriptionEnabled

          if ($edgeSubscriptionEnabled -eq "True")
          {
            $bitmap = $bitmap -bor 1
          }

        # bit 2 - Is Stirling controlling FSE on this host?
          $sasAgentStatus = (get-itemproperty fpc:\ContainingArray\SecurityAssessmentSharing SecurityAssessmentAgentStatus).SecurityAssessmentAgentStatus
          $smtpProtectionControl = (get-itemproperty fpc:\ContainingArray\SecurityAssessmentSharing SmtpProtectionControl).SmtpProtectionControl
          if (($sasAgentStatus -eq "True") -and ($smtpProtectionControl -eq "True"))
          {
            $bitmap = $bitmap -bor 2
          }

        # bit 3 - Was the SMTP protection feature enabled?
          $SMTPProtEnabled = (get-itemproperty fpc:\ContainingArray\SmtpProtectionConfiguration Enabled).Enabled
          if ($SMTPProtEnabled -eq "True")
          {
            $bitmap = $bitmap -bor 4
          }

        # bit 4 - Is there any web-publishing policy rule that publishes an OWA server?

          $WEB_PUBLISHING_RULE_TYPE = 2

          $hasOwaRule = "False"
          foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
          {
            # Generate the path of relevant properties
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.Name + "'"

            # We're interested only in web publishing rules
            if ((get-itemproperty $path Type).Type -eq $WEB_PUBLISHING_RULE_TYPE)
            {
              $path = $path + "\WebPublishingProperties\PathMappings"
              foreach ($mapping in Get-ChildItem $path)
              {
                if (($mapping.name -match "OWA") -or ($mapping.name -match "Exchange"))
                  {
                    $hasOwaRule = "True"
                    break
                  }
              }
            }
          }
          if ($hasOwaRule -eq "True")
          {
            $bitmap = $bitmap -bor 8
          }
        # bit 5 - Is there any server-publishing rule that publishes an SMTP server?
          $count = 0
          foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.Name + "'"
            get-childitem -Recurse  $path | where {("SMTP Server", "SMTPS Server") -contains $_.Name} | foreach {$count += 1}
          }
          if ($count -gt 0)
          {
            $bitmap = $bitmap -bor 16
          }

        # bit 6 - Is any file-filter defined and active?
          $fileFiltersNum = (get-item fpc:\ContainingArray\SmtpProtectionConfiguration\AntiSpamSettings\FileFilters).children.length
          if ($fileFiltersNum -gt 0)
          {
            $bitmap = $bitmap -bor 32
          }

        # bit 7 - Is any message-body-filter defined and active?
          $bodyFiltersNum = (get-item fpc:\ContainingArray\SmtpProtectionConfiguration\AntiSpamSettings\MessageBodyFilters).children.length
          if ($bodyFiltersNum -gt 0)
          {
            $bitmap = $bitmap -bor 64
          }

        $bitmap
      </Script>
    </DataPoint>

    <DataPoint Id="196" Name="DATAID_ENAT_DIP_RULES_COUNT">
      <!-- Number of eNAT rules that use DIP as hiding address -->
      <Script>
        #First, Retrieving all VIPs
        $allVIPs = @()
        foreach ($network in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\Networks)
        {
          $path = "fpc:\ContainingArray\NetworkConfiguration\Networks\'" + $network.name + "'"
          if ((get-childitem $path | where {$_.name -eq "NLBCluster"}) -ne $null)
          {
            # Add the default VIP to the list
            $allVIPs += (get-itemproperty "$path\NLBCluster" VIP).VIP

            # Add the additional VIPs to the list
            get-childitem "$path\NLBCluster\AdditionalVIPs" | foreach {$allVIPs += $_.name}
          }
        }

        # Now count rules that DON'T have VIP as a hiding address
        $rulesCount = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\NetworkConfiguration\NetworkRules)
        {
          $addrCount = 0
          $vipAddrCount = 0
          $path = "fpc:\ContainingArray\NetworkConfiguration\NetworkRules\'" + $rule.Name + "'\HidingAddresses"
          Get-ChildItem $path | foreach {$addrCount += 1}
          Get-ChildItem $path | foreach {if ($allVIPs -contains $_.name) {$vipAddrCount += 1}}
          if (($addrCount -gt 0) -and ($vipAddrCount -eq 0))
          {
            $rulesCount += 1
          }
        }
        $rulesCount
      </Script>
    </DataPoint>


    <DataPoint Id="197" Name="DATAID_ISPR_GENERAL_SETTINGS" Operation="BitField">
      <!-- ISP Redundancy general settings (bitmap).
              Bit 1 - Is ISPR enabled?                   -->
      <Script>

        $bitmap = 0

        $currentPolicy = (Get-itemproperty fpc:\ContainingArray\NetworkConfiguration\Networks\External\ISPRedundancyConfig IspRedundancyPolicy).IspRedundancyPolicy
        if ($currentPolicy -ne 0)    {$bitmap = $bitmap -bor 1}
        $bitmap
      </Script>
    </DataPoint>


      <!-- EMP -->
    <DataPoint Id="198" Name="DATAID_EMP_DEFAULT_CONTENT_DELIVERY">
      <!-- EMP Default content delivery -->
      <Script>
        $p = Get-ItemProperty "fpc:\ContainingArray\MalwareInspectionSettings\ContentDeliverySettings" DefaultContentDeliveryMethod
        $p.DefaultContentDeliveryMethod
      </Script>
    </DataPoint>
    <!-- EMS -->
    <DataPoint Id="199" Name="DATAID_EMS_NUM_OF_ENTERPRISE_POLICY_RULES">
      <!-- Number of rule origin in enterprise policy -->
      <Script>
        $prefix = Get-Resource 18613
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          if ($rule.Name.StartsWith($prefix))
          {
            $count++
          }
        }
        $count
      </Script>
    </DataPoint>
    <DataPoint Id="200" Name="DATAID_EMS_NUM_OF_ARRAY_POLICY_RULES">
      <!-- Number of rule origin in the array (not enterprise) -->
      <Script>
        $prefix = Get-Resource 18613
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          if (!$rule.Name.StartsWith($prefix))
          {
            $count++
          }
        }
        $count
      </Script>
    </DataPoint>
    <!-- GSW -->
    <DataPoint Id="201" Name="DATAID_GSW_NETWORK_TOPOLOGY">
      <!-- The network topology defined by the GSW -->
      <Script>
        $result = Get-RegValue "Chosen Network Topology" -Key "SOFTWARE\Microsoft\Fpc\Getting Started Wizard"
        $result
      </Script>
    </DataPoint>
    <!-- HTTPS Inspection -->
    <DataPoint Id="202" Name="DATAID_HTTPS_INSPECTION_SETTINGS" Operation="BitField">
      <!-- HTTPS inspection settings -->
      <Script>
        $result = 0
        $p = Get-ItemProperty "fpc:\ContainingArray\ArrayPolicy\WebProxy\OutboundHTTPSInspectionConfiguration" Enabled
        if ($p.Enabled -eq "True") { $result = 1 }

        # check that InspectionWithCertificateValidation == fpcHttpsInspectionCertificateValidationOnly
        $p = Get-ItemProperty "fpc:\ContainingArray\ArrayPolicy\WebProxy\OutboundHTTPSInspectionConfiguration" InspectionWithCertificateValidation
        if ($p.InspectionWithCertificateValidation -eq 1) {$result = $result -bor 2 }

        $p = Get-ItemProperty "fpc:\ContainingArray\ArrayPolicy\WebProxy\OutboundHTTPSInspectionConfiguration" NotifyUsers
        if ($p.NotifyUsers -eq "True") { $result = $result -bor 4 }
        $result
      </Script>
    </DataPoint>
    <!-- Reports -->
    <DataPoint Id="204" Name="DATAID_REPORTS_USAGE">
      <!-- Reports usage scenario: none, ad-hoc or continuesly -->
      <Script>
        $result = 0
        foreach ($job in Get-ChildItem fpc:\ContainingArray\Reports\ReportJobs)
        {
          $path = "fpc:\ContainingArray\Reports\ReportJobs\'" + $job.StorageName + "'"
          $p = Get-ItemProperty $path Enabled
          if ($p.Enabled -ne "True") { continue }

          # found active job, assuming ad-hoc
          $result = 1
          $p = Get-ItemProperty $path RecurrenceType
          if ($p.RecurrenceType -gt 0)
          {
            #found a reoccuring job
            $result = 2
            break
          }
        }
        $result
      </Script>
    </DataPoint>
    <!-- Server -->
    <DataPoint Id="205" Name="DATAID_SERVER_EDITION">
      <!--Server edition: 0x10 = SE, 0x20 = EE -->
      <Script>
        $p = Get-ItemProperty fpc:\ IsaEdition
        $p.IsaEdition
      </Script>
    </DataPoint>
    <!-- Stirling integration -->
    <DataPoint Id="206" Name="DATAID_STINRLING_INTEGRATION_SETTINGS" Operation="BitField">
      <!-- Stirling integration settings -->
      <!-- bit 1: stirling integration -->
      <!-- bit 2: FSE integration -->
      <Script>
        $result = 0
        $p = Get-ItemProperty fpc:\ContainingArray\SecurityAssessmentSharing SecurityAssessmentAgentStatus
        if ($p.SecurityAssessmentAgentStatus -eq "True") { $result = 1 }

        $p = Get-ItemProperty fpc:\ContainingArray\SmtpProtectionConfiguration Enabled
        if ($p.Enabled -eq "True") { $result = $result -bor 2 }

        $result
      </Script>
    </DataPoint>
    <!-- URL Filtering -->
    <DataPoint Id="207" Name="DATAID_URLF_SETTINGS" Operation="BitField">
      <!-- URLF Settings -->
      <!-- Bit 1: URLF enabled -->
      <Script>
        $result = 0
        $p = Get-ItemProperty fpc:\ContainingArray\ArrayPolicy\WebProxy\UrlFilteringSettings Enabled
        if ($p.Enabled -eq "True") { $result = 1 }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="208" Name="DATAID_URLF_NUM_OF_POLICY_RULES">
      <!-- The number of policy rules w/ URLF active -->
      <Script>
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"

          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 0)
          {
            # access rule
            $categoriesPath = $path + "\AccessProperties\UrlCategories"
            $categorySetsPath = $path + "\AccessProperties\UrlCategorySets"
            $p1 = Get-Item $categoriesPath
            $p2 = Get-Item $categorySetsPath
            if (($p1.Children.Length -gt 0) -or ($p2.Children.Length -gt 0))
            {
              # access rule w/ URL Categories or CategorySets
              $count++
            }
          }
        }
        $count
      </Script>
    </DataPoint>
    <DataPoint Id="209" Name="DATAID_URLD_NUM_OF_DENY_POLICY_RULES">
      <!-- The number of deny policy rules w/ URLF active -->
      <Script>
        $count = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"

          $p = Get-ItemProperty $path Action
          if ($p.Action -eq 1)
          {
            # deny rule
            $p = Get-ItemProperty $path Type
            if ($p.Type -eq 0)
            {
              # access rule
              $categoriesPath = $path + "\AccessProperties\UrlCategories"
              $categorySetsPath = $path + "\AccessProperties\UrlCategorySets"
              $p1 = Get-Item $categoriesPath
              $p2 = Get-Item $categorySetsPath
              if (($p1.Children.Length -gt 0) -or ($p2.Children.Length -gt 0))
              {
                # access rule w/ URL Categories or CategorySets
                $count++
              }
            }
          }
        }
        $count
      </Script>
    </DataPoint>
    <!-- EMP -->
    <DataPoint Id="210" Name="DATAID_EMP_SETTINGS" Operation="BitField">
      <!-- EMP Settings -->
      <!-- Bit 1: EMP Enabled -->
      <!-- Bit 2: EMP used for HTTP -->
      <!-- Bit 3: EMP used for HTTPS -->
      <!-- Bit 4: EMP used for FTP -->
      <!-- Bit 5: Progress page enabled -->
      <!-- Bit 6: Is fast trickling enabled -->
      <Script>
        $http = 0
        $https = 0
        $ftp = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          if (($http -gt 0) -and ($https -gt 0) -and ($ftp -gt 0)) { break }

          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $empPath = $path + "\MalwareInspectionProperties"
          $scanDown = Get-ItemProperty $empPath ScanDownload
          if ($scanDown -eq "True")
          {
            $p = Get-ItemProperty $path Type
            if ($p.Type -eq 0)
            {
              # access rule
              $p = Get-ItemProperty $path ProtocolSelectionMethod
              if ($p.ProtocolSelectionMethod -ne 1) { continue } # ignore non-specific rules
              $path1 = $path + "\SpecifiedProtocols"
              foreach ($ref in Get-ChildItem $path1)
              {
                $path2 = $path1 + "\'" + $ref.StorageName + "'"
                foreach ($protocol in Get-ChildItem $path2)
                {
                  if ($protocol.StorageName -eq "{df6cabc0-d4a3-11d2-bbc4-00a0c9d785a6}")
                  {
                    #found HTTP
                    $http = 1
                  }
                  elseif ($protocol.StorageName -eq "{fe3e20d0-d4a3-11d2-bbc4-00a0c9d785a6}")
                  {
                    #found HTTPS
                    $https = 1
                  }
                  elseif ($protocol.StorageName -eq "{f2e5ee50-030c-11d3-acd4-00a0c9d7559D}")
                  {
                    #found FTP
                    $ftp = 1
                  }
                }
              }
            }
          }
        }

        $result = 0
        $p = Get-ItemProperty fpc:\ContainingArray\MalwareInspectionSettings Enabled
        if ($p.Enabled -eq "True") { $result = 1 }

        if ($http -gt 0) { $result = $result -bor 2 }

        if ($https -gt 0) { $result = $result -bor 4 }

        if ($ftp -gt 0) { $result = $result -bor 8 }

        $p = Get-ItemProperty fpc:\ContainingArray\MalwareInspectionSettings\ContentDeliverySettings ProgressNotificationEnabled
        if ($p.ProgressNotificationEnabled -eq "True") { $result = $result -bor 16 }

        $p = Get-ItemProperty fpc:\ContainingArray\MalwareInspectionSettings\ContentDeliverySettings FastTricklingEnabled
        if ($p.FastTricklingEnabled -eq "True") { $result = $result -bor 32 }

        $result
      </Script>
    </DataPoint>
    <!-- Subscribtion services -->
    <DataPoint Id="212" Name="DATAID_WEB_ANTIVIRUS_LICENSE_STATUS">
      <!-- URLF and EMP license status -->
      <!-- 0: expired -->
      <!-- 1: eval -->
      <!-- 2: valid -->
      <Script>
        $result = 0
        $licPath = "fpc:\ContainingArray\UpdateCenter\Licenses\'{DB9AC467-82C0-4BAC-9E35-7352B7D458E3}'"
        $p = Get-ItemProperty $licPath ExpirationDate
        $expireDate = Get-Date $p.ExpirationDate
        $today = Get-Date
        if ($today -lt $expireDate)
        {
          $evalKey = Get-Resource 19717
          $p = Get-ItemProperty $licPath Key
          if ($p.Key -eq $evalKey)
          {
            $result = 1
          }
          else
          {
            $result = 2
          }
        }
        $result
      </Script>
    </DataPoint>
    <!-- Exchange web publishing -->
    <DataPoint Id="307" Name="DATAID_WEB_PUBLISH_OWA">
      <!-- Number of policy rules which are used to publish OWA -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties\PathMappings"
            foreach ($mapping in Get-ChildItem $path)
            {
                if ($mapping.name -match "OWA")
                {
                    $result += 1
                    break
                }
            }
          }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="308" Name="DATAID_WEB_PUBLISH_OMA">
      <!-- Number of policy rules which are used to publish OMA -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties\PathMappings"
            foreach ($mapping in Get-ChildItem $path)
            {
                if ($mapping.name -match "OMA")
                {
                    $result += 1
                    break
                }
            }
          }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="309" Name="DATAID_WEB_PUBLISH_ACTIVE_SYNC">
      <!-- Number of policy rules which are used to publish active sync -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties\PathMappings"
            foreach ($mapping in Get-ChildItem $path)
            {
                if ($mapping.name -match "Microsoft-Server-ActiveSync")
                {
                    $result += 1
                    break
                }
            }
          }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="336" Name="DATAID_WEB_PUBLISH_ACTIVE_SYNC_CERT">
      <!-- Number of policy rules which are used to publish active sync using a client side certificate authentication -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName  + "'\WebPublishingProperties\WebListenerUsed"
            $listenerStorageName = Get-ItemProperty $path Guid
            $path = "fpc:\ContainingArray\RuleElements\WebListeners\'" + $listenerStorageName.Guid + "'\Properties"
            $listenerClientCertificate = Get-ItemProperty $path SSLCertificateAuthentication

            if ($listenerClientCertificate.SSLCertificateAuthentication -eq "False") { continue }

            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.Name + "'\WebPublishingProperties\PathMappings"
            foreach ($mapping in Get-ChildItem $path)
            {
                if ($mapping.name -match "Microsoft-Server-ActiveSync")
                {
                    $result += 1
                    break
                }
            }
          }
        }
        $result
      </Script>
    </DataPoint>
    <DataPoint Id="310" Name="DATAID_WEB_PUBLISH_RPC_OVER_HTTP">
      <!-- Number of policy rules which are used to publish RPC over HTTP -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties\PathMappings"
            foreach ($mapping in Get-ChildItem $path)
            {
                if ($mapping.name -match "rpc")
                {
                    $result += 1
                    break
                }
            }
          }
        }
        $result
      </Script>
    </DataPoint>
    <!-- Sharepoint web publishing -->
    <DataPoint Id="311" Name="DATAID_WEB_PUBLISH_SHAREPOINT">

      <!-- Number of policy rules which are used to publish sharepoint -->
      <Script>
        $result = 0
        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $loggOffUrl = Get-ItemProperty $path LogoffURL
            if ($loggOffUrl -match "/_layouts/SignOut.aspx")
            {
                $result += 1
                continue
            }

            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties\PathMappings"
            foreach ($mapping in Get-ChildItem $path)
            {
                if (($mapping.name -match "/_layouts/") -or
                    ($mapping.name -match "/_vti_bin/") -or
                    ($mapping.name -match "/_upresources/") -or
                    ($mapping.name -match "/_vti_inf.html/"))
                {
                    $result += 1
                    break
                }
            }
          }
        }
        $result
      </Script>
    </DataPoint>


    <!-- Web publishing authentication delegation -->
    <DataPoint Id="329" Name="DATAID_WEB_PUBLISHING_NO_DELEGATION_NO_AUTH">
      <!-- The number of web publishing rules with no delegation preventing any authentication-->
      <Script>
        $result = 0

        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 1) { $result += 1 }
          }
        }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="330" Name="DATAID_WEB_PUBLISHING_DELEGATION_NO">
      <!-- The number of web publishing rules with no delegation - passthrough authentication -->
      <Script>
        $result = 0

        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 0) { $result += 1 }
          }
        }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="331" Name="DATAID_WEB_PUBLISHING_DELEGATION_BASIC">
      <!-- The number of web publishing rules with basic delegation -->
      <Script>
        $result = 0

        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 3) { $result += 1 }
          }
        }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="332" Name="DATAID_WEB_PUBLISHING_DELEGATION_NTLM">
      <!-- The number of web publishing rules with NTLM delegation -->
      <Script>
        $result = 0

        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 4) { $result += 1 }
          }
        }

        $result
      </Script>
    </DataPoint>
    <DataPoint Id="333" Name="DATAID_WEB_PUBLISHING_DELEGATION_NEGOTIATE">
      <!-- The number of web publishing rules with negotiate delegation -->
      <Script>
        $result = 0

        foreach ($rule in Get-ChildItem fpc:\ContainingArray\ArrayPolicy\PolicyRules)
        {
          $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'"
          $p = Get-ItemProperty $path Type
          if ($p.Type -eq 2)
          {
            $path = "fpc:\ContainingArray\ArrayPolicy\PolicyRules\'" + $rule.StorageName + "'\WebPublishingProperties"
            $p = Get-ItemProperty $path CredentialsDelegationType
            if ($p.CredentialsDelegationType -eq 5) { $result += 1 }
          }
        }

        $result
      </Script>
    </DataPoint>
  </DataPoints>
</fpcsqm:Configuration>