288 lines
11 KiB
C#
288 lines
11 KiB
C#
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Intel Corporation, 2003 - 2012 All Rights Reserved.
|
|
//
|
|
// File: CIM_AccountManagementCapabilities.cs
|
|
//
|
|
// Contents: AccountManagementCapabilities describes the capabilities supported for managing Accounts associated with an instance of AccountManagementService. AccountManagementCapabilities is associated with an instance of AccountManagementService through the ElementCapabilities association.
|
|
// This file was automatically generated from CIM_AccountManagementCapabilities.mof
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Xml.Serialization;
|
|
using System.IO;
|
|
using Intel.Manageability.WSManagement;
|
|
using Intel.Manageability.Cim.Untyped;
|
|
|
|
|
|
namespace Intel.Manageability.Cim.Typed
|
|
{
|
|
/// <summary>
|
|
///AccountManagementCapabilities describes the capabilities supported for managing Accounts associated with an instance of AccountManagementService. AccountManagementCapabilities is associated with an instance of AccountManagementService through the ElementCapabilities association.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AccountManagementCapabilities")]
|
|
[System.Xml.Serialization.XmlRootAttribute("CIM_AccountManagementCapabilities", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_AccountManagementCapabilities", IsNullable=false)]
|
|
public class CIM_AccountManagementCapabilities : CIM_EnabledLogicalElementCapabilities
|
|
{
|
|
/// <summary>
|
|
/// Default constructor.
|
|
/// </summary>
|
|
public CIM_AccountManagementCapabilities() :base()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Constructor that recieves an xml string for deserialization.
|
|
/// </summary>
|
|
/// <param name="xml">xml string to deserialize</param>
|
|
public CIM_AccountManagementCapabilities(string xml): base((IWSManClient)null)
|
|
{
|
|
this.Deserialize(xml);
|
|
}
|
|
/// <summary>
|
|
/// Constructor which recieves a Ws-Management client object.
|
|
/// </summary>
|
|
/// <param name="client">Ws-Management client</param>
|
|
public CIM_AccountManagementCapabilities(IWSManClient client): base(client)
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Remove MaximumAccountsSupported field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveMaximumAccountsSupported()
|
|
{
|
|
RemoveField("MaximumAccountsSupported");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field MaximumAccountsSupported exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool MaximumAccountsSupportedExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("MaximumAccountsSupported");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, MaximumAccountsSupported shall indicate the maximum number of accounts that may be managed by the associated instance of CIM_AccountManagementService. Note that if multiple instances of CIM_AccountManagementService manage the accounts of a system, the total maximum number of accounts supported on the system is the sum of MaximumAccountsSupported for all of the instances of CIM_AccountManagementService. A value of zero shall indicate that the maximum number of accounts is unknown or that a maximum number of accounts is not enforced.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort MaximumAccountsSupported
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["MaximumAccountsSupported"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("MaximumAccountsSupported",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove OperationsSupported field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveOperationsSupported()
|
|
{
|
|
RemoveField("OperationsSupported");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field OperationsSupported exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool OperationsSupportedExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("OperationsSupported");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, OperationsSupported describes the type of operations that are supported for an Account associated with the AccountManagementService.
|
|
/// "Create" indicates the AccountManagementService may be used to create new accounts.
|
|
/// "Modify" indicates that the associated Accounts may be modified.
|
|
/// "Delete" indicates that associated Accounts may be deleted.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort[] OperationsSupported
|
|
{
|
|
get
|
|
{
|
|
return CimTypesUtils.StringArrayToArray<ushort>(this["OperationsSupported"]);
|
|
}
|
|
set
|
|
{
|
|
string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
|
|
this.SetOrAddField("OperationsSupported", arr);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove OtherSupportedUserPasswordEncryptionAlgorithms field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveOtherSupportedUserPasswordEncryptionAlgorithms()
|
|
{
|
|
RemoveField("OtherSupportedUserPasswordEncryptionAlgorithms");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field OtherSupportedUserPasswordEncryptionAlgorithms exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool OtherSupportedUserPasswordEncryptionAlgorithmsExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("OtherSupportedUserPasswordEncryptionAlgorithms");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Additional implementation-specific algorithms that a client may use to encrypt a value in the UserPassword property when creating or modifying an instance of CIM_Account. If this property is non-NULL, a client may select an algorithm in it by setting CIM_Account.UserPasswordEncryptionAlgorithm to 1 ("Other") and setting CIM_Account.OtherUserPasswordEncryptionAlgorithm to the value of the selected algorithm string.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual string[] OtherSupportedUserPasswordEncryptionAlgorithms
|
|
{
|
|
get
|
|
{
|
|
return CimTypesUtils.StringArrayToArray<string>(this["OtherSupportedUserPasswordEncryptionAlgorithms"]);
|
|
}
|
|
set
|
|
{
|
|
string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
|
|
this.SetOrAddField("OtherSupportedUserPasswordEncryptionAlgorithms", arr);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove SupportedUserPasswordEncryptionAlgorithms field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveSupportedUserPasswordEncryptionAlgorithms()
|
|
{
|
|
RemoveField("SupportedUserPasswordEncryptionAlgorithms");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field SupportedUserPasswordEncryptionAlgorithms exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool SupportedUserPasswordEncryptionAlgorithmsExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("SupportedUserPasswordEncryptionAlgorithms");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, This property enumerates encryption algorithms that a client may use to encrypt a value in the UserPassword property when creating or modifying an instance of CIM_Account. This capability is aimed at ensuring some measure of confidentiality when the password is transferred over an unencrypted transport protocol. An implementation may elect to accept only encrypted passwords, without regard to whether the transport protocol is encrypted. Similarly, a a client may elect to always provide encrypted passwords to implementations that accept either unencrypted or encrypted passwords, even if the underlying transport protocol is encrypted.
|
|
/// See CIM_Account property UserPasswordEncryptionAlgorithm for a description of each enum value.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort[] SupportedUserPasswordEncryptionAlgorithms
|
|
{
|
|
get
|
|
{
|
|
return CimTypesUtils.StringArrayToArray<ushort>(this["SupportedUserPasswordEncryptionAlgorithms"]);
|
|
}
|
|
set
|
|
{
|
|
string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
|
|
this.SetOrAddField("SupportedUserPasswordEncryptionAlgorithms", arr);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove UserPasswordEncryptionSalt field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveUserPasswordEncryptionSalt()
|
|
{
|
|
RemoveField("UserPasswordEncryptionSalt");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field UserPasswordEncryptionSalt exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool UserPasswordEncryptionSaltExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("UserPasswordEncryptionSalt");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, A value unique to the specific WBEM server that may be used in the selected UserPassword encryption algorithm to ensure a value that is unique among all WBEM servers even if a user uses the same password on multiple WBEM servers.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual string UserPasswordEncryptionSalt
|
|
{
|
|
get
|
|
{
|
|
return this.GetField("UserPasswordEncryptionSalt")[0];
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("UserPasswordEncryptionSalt",value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of CIM_AccountManagementCapabilities class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <param name="cimKeys">Keys for selecting the instances</param>
|
|
/// <returns>Collection of CIM_AccountManagementCapabilities objects</returns>
|
|
public static new Collection<CIM_AccountManagementCapabilities> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
|
|
{
|
|
List<CIM_AccountManagementCapabilities> ret = CimBase.Enumerate<CIM_AccountManagementCapabilities>(client, cimKeys);
|
|
return new Collection<CIM_AccountManagementCapabilities>(ret);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of CIM_AccountManagementCapabilities class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <returns>Collection of CIM_AccountManagementCapabilities objects</returns>
|
|
public static new Collection<CIM_AccountManagementCapabilities> Enumerate(IWSManClient client)
|
|
{
|
|
List<CIM_AccountManagementCapabilities> ret = CimBase.Enumerate<CIM_AccountManagementCapabilities>(client);
|
|
return new Collection<CIM_AccountManagementCapabilities>(ret);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete the instance of CIM_AccountManagementCapabilities if it is singular.
|
|
/// Note: This method will succeed only if a single instance of the class exists.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
public static new void Delete(IWSManClient client)
|
|
{
|
|
CimBase.Delete<CIM_AccountManagementCapabilities>(client);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents the keys of the CIM_AccountManagementCapabilities class.
|
|
/// </summary>
|
|
|
|
public new class CimKeys : CIM_EnabledLogicalElementCapabilities.CimKeys
|
|
{
|
|
}
|
|
|
|
}
|
|
}
|
|
|