/// <summary> /// Constructor /// </summary> /// <param name="collection">Wether the field is a collection</param> /// <param name="name">Name of the field</param> /// <param name="description">Description for the field, used for commenting</param> /// <param name="optional">Whether the field is optionable \ nullable</param> /// <param name="minimumValue">The minimum acceptable value for this property</param> /// <param name="maximumValue">The maximum acceptable value for this property</param> /// <param name="isKey"> /// Whether the property is the primary key /// </param> /// <param name="alternativeDatabaseColumnName"> /// Name of the database column name, if it's different from the .NET property name. /// </param> public ClrDateTimePropertyInfo( CollectionType collection, System.String name, System.String description, bool optional, System.DateTime? minimumValue, System.DateTime? maximumValue, bool isKey, string alternativeDatabaseColumnName) : base(collection, name, description, optional, "System.DateTime", "Dhgms.DataManager.Model.SearchFilter.DateTime", "DateTime", false, "System.DateTime.MinValue", false, isKey, true, typeof(System.DateTime), alternativeDatabaseColumnName) { this.minimumValue = minimumValue; this.maximumValue = maximumValue; }
public bool update() { if(_updateRate == null) { if(_updated) { _updated = false; return true; } return false; } System.DateTime newTime = System.DateTime.Now; if(_start == null) { _start = newTime; return true; } if((newTime - _start.Value).TotalMilliseconds > (1000 / updateRate)) { _start = newTime; return true; } return false; }
private void OnPostprocessTexture( Texture2D texture ) { // avoid processing multiple times if( _lastImport.HasValue && System.DateTime.Now.Subtract( _lastImport.Value ).TotalSeconds < 20 ) return; // bail out if this change was because of the SKTextureUtil doing its job with a PSD if( SKTextureUtil.isCurrentlyRefreshingSourceImages ) return; var filename = Path.GetFileName( assetPath ); var sheet = SKSpriteSheet.sheetWithImageSourceFolder( Path.GetDirectoryName( assetPath ) ); if( sheet != null ) { _lastImport = System.DateTime.Now; Debug.Log( "SpriteKit detected that a texture updated (" + filename + ") from sprite sheet: " + sheet.name + ". Refreshing now." ); sheet.refreshSourceImages(); } }
/// <summary> /// Initializes a new instance of the Extension class. /// </summary> /// <param name="id">Fully qualified resource ID for the resource. Ex - /// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}</param> /// <param name="name">The name of the resource</param> /// <param name="type">The type of the resource. E.g. /// "Microsoft.Compute/virtualMachines" or /// "Microsoft.Storage/storageAccounts"</param> /// <param name="createdBy">The identity that created the /// resource.</param> /// <param name="createdByType">The type of identity that created the /// resource. Possible values include: 'User', 'Application', /// 'ManagedIdentity', 'Key'</param> /// <param name="createdAt">The timestamp of resource creation /// (UTC).</param> /// <param name="lastModifiedBy">The identity that last modified the /// resource.</param> /// <param name="lastModifiedByType">The type of identity that last /// modified the resource. Possible values include: 'User', /// 'Application', 'ManagedIdentity', 'Key'</param> /// <param name="lastModifiedAt">The timestamp of resource last /// modification (UTC)</param> /// <param name="provisioningState">Provisioning state of the Extension /// proxy resource. Possible values include: 'Succeeded', 'Failed', /// 'Canceled', 'Accepted', 'Provisioning'</param> /// <param name="forceUpdateTag">How the extension handler should be /// forced to update even if the extension configuration has not /// changed.</param> /// <param name="publisher">The name of the extension handler /// publisher.</param> /// <param name="extensionType">Specifies the type of the extension; an /// example is "CustomScriptExtension".</param> /// <param name="typeHandlerVersion">Specifies the version of the /// script handler.</param> /// <param name="autoUpgradeMinorVersion">Indicates whether the /// extension should use a newer minor version if one is available at /// deployment time. Once deployed, however, the extension will not /// upgrade minor versions unless redeployed, even with this property /// set to true.</param> /// <param name="settings">Json formatted public settings for the /// extension.</param> /// <param name="protectedSettings">Protected settings (may contain /// secrets).</param> /// <param name="aggregateState">Aggregate state of Arc Extensions /// across the nodes in this HCI cluster. Possible values include: /// 'NotSpecified', 'Error', 'Succeeded', 'Canceled', 'Failed', /// 'Connected', 'Disconnected', 'Deleted', 'Creating', 'Updating', /// 'Deleting', 'Moving', 'PartiallySucceeded', 'PartiallyConnected', /// 'InProgress'</param> /// <param name="perNodeExtensionDetails">State of Arc Extension in /// each of the nodes.</param> public Extension(string id = default(string), string name = default(string), string type = default(string), string createdBy = default(string), string createdByType = default(string), System.DateTime?createdAt = default(System.DateTime?), string lastModifiedBy = default(string), string lastModifiedByType = default(string), System.DateTime?lastModifiedAt = default(System.DateTime?), string provisioningState = default(string), string forceUpdateTag = default(string), string publisher = default(string), string extensionType = default(string), string typeHandlerVersion = default(string), bool?autoUpgradeMinorVersion = default(bool?), object settings = default(object), object protectedSettings = default(object), string aggregateState = default(string), IList <PerNodeExtensionState> perNodeExtensionDetails = default(IList <PerNodeExtensionState>)) : base(id, name, type) { CreatedBy = createdBy; CreatedByType = createdByType; CreatedAt = createdAt; LastModifiedBy = lastModifiedBy; LastModifiedByType = lastModifiedByType; LastModifiedAt = lastModifiedAt; ProvisioningState = provisioningState; ForceUpdateTag = forceUpdateTag; Publisher = publisher; ExtensionType = extensionType; TypeHandlerVersion = typeHandlerVersion; AutoUpgradeMinorVersion = autoUpgradeMinorVersion; Settings = settings; ProtectedSettings = protectedSettings; AggregateState = aggregateState; PerNodeExtensionDetails = perNodeExtensionDetails; CustomInit(); }
/// <summary> /// Initializes a new instance of the PageLog class. /// </summary> /// <param name="name">Name of the page. /// </param> /// <param name="timestamp">Log timestamp, example: /// '2017-03-13T18:05:42Z'. /// </param> /// <param name="sid">When tracking an analytics session, logs can be /// part of the session by specifying this identifier. /// This attribute is optional, a missing value means the session /// tracking is disabled (like when using only error reporting /// feature). /// Concrete types like StartSessionLog or PageLog are always part of a /// session and always include this identifier. /// </param> /// <param name="userId">optional string used for associating logs with /// users. /// </param> /// <param name="properties">Additional key/value pair parameters. /// </param> public PageLog(Device device, string name, System.DateTime?timestamp = default(System.DateTime?), System.Guid?sid = default(System.Guid?), string userId = default(string), IDictionary <string, string> properties = default(IDictionary <string, string>)) : base(device, timestamp, sid, userId, properties) { Name = name; CustomInit(); }
/// <summary> /// Initializes a new instance of the ReservationDto class. /// </summary> public ReservationDto(int?id = default(int?), bool?approvalStatus = default(bool?), string userName = default(string), string storeName = default(string), string contactMobile = default(string), System.DateTime?startTime = default(System.DateTime?), System.DateTime?stopTime = default(System.DateTime?), string image = default(string), System.DateTime?createdDate = default(System.DateTime?)) { Id = id; ApprovalStatus = approvalStatus; UserName = userName; StoreName = storeName; ContactMobile = contactMobile; StartTime = startTime; StopTime = stopTime; Image = image; CreatedDate = createdDate; CustomInit(); }
/// <summary> /// Initializes a new instance of the DocumentModel class. /// </summary> /// <param name="data">Document data.</param> /// <param name="id">Document ID.</param> /// <param name="documentId">Document OID.</param> /// <param name="replaceId">Document replace ID.</param> /// <param name="queueDateTime">Document queue date time.</param> /// <param name="status">Document status.</param> /// <param name="documentLink">Document link.</param> /// <param name="eventsLink">Events link.</param> /// <param name="formatCode">Format code.</param> /// <param name="formatCodeName">Format code name.</param> /// <param name="ihi">IHI.</param> public DocumentModel(byte[] data = default(byte[]), int?id = default(int?), string documentId = default(string), string replaceId = default(string), System.DateTime?queueDateTime = default(System.DateTime?), string status = default(string), string documentLink = default(string), string eventsLink = default(string), string formatCode = default(string), string formatCodeName = default(string), string ihi = default(string)) { Data = data; Id = id; DocumentId = documentId; ReplaceId = replaceId; QueueDateTime = queueDateTime; Status = status; DocumentLink = documentLink; EventsLink = eventsLink; FormatCode = formatCode; FormatCodeName = formatCodeName; Ihi = ihi; CustomInit(); }
/// <summary> /// Callback when Whispersync has new cloud data available. /// </summary> private void OnNewCloudData() { lastOnNewCloudData = System.DateTime.Now; }
public IQueryable <SSP.Servidor.LIQUIDO_HOJA_CTRL> ObtenerHojasLiquidosBusqueda(System.DateTime?FechaInicio, System.DateTime?FechaFin, SSP.Servidor.INGRESO Ingreso, decimal?Turno) { try { var predicado = PredicateBuilder.True <SSP.Servidor.LIQUIDO_HOJA_CTRL>(); predicado = predicado.And(x => x.HOSPITALIZACION.NOTA_MEDICA.ATENCION_MEDICA.ID_INGRESO == Ingreso.ID_INGRESO && x.HOSPITALIZACION.NOTA_MEDICA.ATENCION_MEDICA.ID_IMPUTADO == Ingreso.ID_IMPUTADO && x.HOSPITALIZACION.NOTA_MEDICA.ATENCION_MEDICA.ID_ANIO == Ingreso.ID_ANIO); if (FechaInicio.HasValue) { predicado = predicado.And(w => System.Data.Objects.EntityFunctions.TruncateTime(w.FECHA_REGISTRO) >= System.Data.Objects.EntityFunctions.TruncateTime(FechaInicio)); } if (FechaFin.HasValue) { predicado = predicado.And(w => System.Data.Objects.EntityFunctions.TruncateTime(w.FECHA_REGISTRO) <= System.Data.Objects.EntityFunctions.TruncateTime(FechaFin)); } if (Turno.HasValue) { predicado = predicado.And(x => x.LIQUIDO_HORA.ID_LIQTURNO == Turno); } return(GetData(predicado.Expand())); } catch (System.Exception exc) { throw; } }
/// <summary> /// Initializes a new instance of the ApiLimitTradeEvent class. /// </summary> public ApiLimitTradeEvent(string id = default(string), string orderId = default(string), System.DateTime?dateTime = default(System.DateTime?), string asset = default(string), string assetPair = default(string), double?volume = default(double?), double?price = default(double?), string status = default(string), string type = default(string), double?totalCost = default(double?)) { Id = id; OrderId = orderId; DateTime = dateTime; Asset = asset; AssetPair = assetPair; Volume = volume; Price = price; Status = status; Type = type; TotalCost = totalCost; CustomInit(); }
/// <summary> /// Initializes a new instance of the DiskInner class. /// </summary> /// <param name="creationData">Disk source information. CreationData /// information cannot be changed after the disk has been /// created.</param> /// <param name="managedBy">A relative URI containing the ID of the VM /// that has the disk attached.</param> /// <param name="managedByExtended">List of relative URIs containing /// the IDs of the VMs that have the disk attached. maxShares should be /// set to a value greater than one for disks to allow attaching them /// to multiple VMs.</param> /// <param name="zones">The Logical zone list for Disk.</param> /// <param name="timeCreated">The time when the disk was /// created.</param> /// <param name="osType">The Operating System type. Possible values /// include: 'Windows', 'Linux'</param> /// <param name="hyperVGeneration">The hypervisor generation of the /// Virtual Machine. Applicable to OS disks only. Possible values /// include: 'V1', 'V2'</param> /// <param name="diskSizeGB">If creationData.createOption is Empty, /// this field is mandatory and it indicates the size of the disk to /// create. If this field is present for updates or creation with other /// options, it indicates a resize. Resizes are only allowed if the /// disk is not attached to a running VM, and can only increase the /// disk's size.</param> /// <param name="diskSizeBytes">The size of the disk in bytes. This /// field is read only.</param> /// <param name="uniqueId">Unique Guid identifying the /// resource.</param> /// <param name="encryptionSettingsCollection">Encryption settings /// collection used for Azure Disk Encryption, can contain multiple /// encryption settings per disk or snapshot.</param> /// <param name="provisioningState">The disk provisioning /// state.</param> /// <param name="diskIOPSReadWrite">The number of IOPS allowed for this /// disk; only settable for UltraSSD disks. One operation can transfer /// between 4k and 256k bytes.</param> /// <param name="diskMBpsReadWrite">The bandwidth allowed for this /// disk; only settable for UltraSSD disks. MBps means millions of /// bytes per second - MB here uses the ISO notation, of powers of /// 10.</param> /// <param name="diskIOPSReadOnly">The total number of IOPS that will /// be allowed across all VMs mounting the shared disk as ReadOnly. One /// operation can transfer between 4k and 256k bytes.</param> /// <param name="diskMBpsReadOnly">The total throughput (MBps) that /// will be allowed across all VMs mounting the shared disk as /// ReadOnly. MBps means millions of bytes per second - MB here uses /// the ISO notation, of powers of 10.</param> /// <param name="diskState">The state of the disk. Possible values /// include: 'Unattached', 'Attached', 'Reserved', 'ActiveSAS', /// 'ReadyToUpload', 'ActiveUpload'</param> /// <param name="encryption">Encryption property can be used to encrypt /// data at rest with customer managed keys or platform managed /// keys.</param> /// <param name="maxShares">The maximum number of VMs that can attach /// to the disk at the same time. Value greater than one indicates a /// disk that can be mounted on multiple VMs at the same time.</param> /// <param name="shareInfo">Details of the list of all VMs that have /// the disk attached. maxShares should be set to a value greater than /// one for disks to allow attaching them to multiple VMs.</param> /// <param name="networkAccessPolicy">Possible values include: /// 'AllowAll', 'AllowPrivate', 'DenyAll'</param> /// <param name="diskAccessId">ARM id of the DiskAccess resource for /// using private endpoints on disks.</param> /// <param name="tier">Performance tier of the disk (e.g, P4, S10) as /// described here: /// https://azure.microsoft.com/en-us/pricing/details/managed-disks/. /// Does not apply to Ultra disks.</param> public DiskInner(string location, CreationData creationData, string id = default(string), string name = default(string), string type = default(string), IDictionary <string, string> tags = default(IDictionary <string, string>), string managedBy = default(string), IList <string> managedByExtended = default(IList <string>), DiskSku sku = default(DiskSku), IList <string> zones = default(IList <string>), System.DateTime?timeCreated = default(System.DateTime?), OperatingSystemTypes?osType = default(OperatingSystemTypes?), HyperVGeneration hyperVGeneration = default(HyperVGeneration), int?diskSizeGB = default(int?), long?diskSizeBytes = default(long?), string uniqueId = default(string), EncryptionSettingsCollection encryptionSettingsCollection = default(EncryptionSettingsCollection), string provisioningState = default(string), long?diskIOPSReadWrite = default(long?), long?diskMBpsReadWrite = default(long?), long?diskIOPSReadOnly = default(long?), long?diskMBpsReadOnly = default(long?), DiskState diskState = default(DiskState), Encryption encryption = default(Encryption), int?maxShares = default(int?), IList <ShareInfoElement> shareInfo = default(IList <ShareInfoElement>), NetworkAccessPolicy networkAccessPolicy = default(NetworkAccessPolicy), string diskAccessId = default(string), string tier = default(string)) : base(location, id, name, type, tags) { ManagedBy = managedBy; ManagedByExtended = managedByExtended; Sku = sku; Zones = zones; TimeCreated = timeCreated; OsType = osType; HyperVGeneration = hyperVGeneration; CreationData = creationData; DiskSizeGB = diskSizeGB; DiskSizeBytes = diskSizeBytes; UniqueId = uniqueId; EncryptionSettingsCollection = encryptionSettingsCollection; ProvisioningState = provisioningState; DiskIOPSReadWrite = diskIOPSReadWrite; DiskMBpsReadWrite = diskMBpsReadWrite; DiskIOPSReadOnly = diskIOPSReadOnly; DiskMBpsReadOnly = diskMBpsReadOnly; DiskState = diskState; Encryption = encryption; MaxShares = maxShares; ShareInfo = shareInfo; NetworkAccessPolicy = networkAccessPolicy; DiskAccessId = diskAccessId; Tier = tier; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// AzureWorkloadSAPHanaPointInTimeRecoveryPoint class. /// </summary> /// <param name="recoveryPointTimeInUTC">UTC time at which /// recoverypoint was created</param> /// <param name="type">Type of restore point. Possible values include: /// 'Invalid', 'Full', 'Log', 'Differential'</param> /// <param name="timeRanges">List of log ranges</param> public AzureWorkloadSAPHanaPointInTimeRecoveryPoint(System.DateTime?recoveryPointTimeInUTC = default(System.DateTime?), string type = default(string), IList <PointInTimeRange> timeRanges = default(IList <PointInTimeRange>)) : base(recoveryPointTimeInUTC, type, timeRanges) { CustomInit(); }
/// <summary> /// Initializes a new instance of the DomainPurchaseConsent class. /// </summary> /// <param name="agreementKeys">List of applicable legal agreement /// keys. This list can be retrieved using ListLegalAgreements API /// under <code>TopLevelDomain</code> resource.</param> /// <param name="agreedBy">Client IP address.</param> /// <param name="agreedAt">Timestamp when the agreements were /// accepted.</param> public DomainPurchaseConsent(IList <string> agreementKeys = default(IList <string>), string agreedBy = default(string), System.DateTime?agreedAt = default(System.DateTime?)) { AgreementKeys = agreementKeys; AgreedBy = agreedBy; AgreedAt = agreedAt; CustomInit(); }
/// <summary> /// Initializes a new instance of the ProcessScheduleDto class. /// </summary> /// <param name="name">The name of the schedule.</param> /// <param name="timeZoneId">The timezone under which the schedule will /// run.</param> /// <param name="enabled">Specifies if the schedule is active or /// not.</param> /// <param name="releaseId">The Id of the process associated with the /// schedule.</param> /// <param name="releaseKey">The unique key of the process associated /// with the schedule.</param> /// <param name="releaseName">The name of the process associated with /// the schedule.</param> /// <param name="packageName">The name of the package to be triggered /// with the schedule.</param> /// <param name="environmentName">The name of the environment /// associated with the schedule.</param> /// <param name="environmentId">The Id of the environment associated /// with the schedule.</param> /// <param name="jobPriority">The execution priority. If null, it will /// start jobs with the release's priority. Possible values include: /// 'Low', 'Normal', 'High'</param> /// <param name="runtimeType">The runtime type of the robot. Possible /// values include: 'NonProduction', 'Attended', 'Unattended', /// 'Studio', 'Development', 'StudioX', 'Headless', 'StudioPro', /// 'TestAutomation'</param> /// <param name="startProcessCron">The start cron expression of the /// schedule.</param> /// <param name="startProcessCronDetails">Various details that can be /// associated to the time period expression of the schedule.</param> /// <param name="startProcessCronSummary">Human readable form of cron /// expression of the schedule.</param> /// <param name="startProcessNextOccurrence">The date and time when the /// associated process will be run next.</param> /// <param name="startStrategy">States which robots from the /// environment are being run by the schedule.</param> /// <param name="executorRobots">The collection of specific robots /// selected to be targeted by the current schedule. This collection /// must be empty if the start strategy is not 0 (specific /// robots).</param> /// <param name="stopProcessExpression">The cron expression after which /// a running process will be stopped.</param> /// <param name="stopStrategy">The way a running process is stopped. /// Possible values include: 'SoftStop', 'Kill'</param> /// <param name="externalJobKey">The unique identifier of the external /// job associated with the jobs generated by this schedule. A key is /// generated for each group of jobs triggered by this /// schedule.</param> /// <param name="timeZoneIana">The timezone under which the schedule /// will run in Iana Standard.</param> /// <param name="useCalendar">DEPRECATED. Specify whether the schedule /// uses any calendar.</param> /// <param name="calendarId">The id of the calendar that a process /// schedule uses.</param> /// <param name="calendarName">The name of the calendar.</param> /// <param name="inputArguments">Input parameters that will be passed /// to each job created by this schedule.</param> /// <param name="queueDefinitionId">The Id of the queue that uses this /// schedule for activation (trigger jobs when new queue items are /// added)</param> /// <param name="queueDefinitionName">The Name of the queue that uses /// this schedule for activation (trigger jobs when new queue items are /// added)</param> /// <param name="itemsActivationThreshold">The minimum number of queue /// items that should trigger the process activation.</param> /// <param name="itemsPerJobActivationTarget">The target ratio between /// the number of queue items and the Total number of jobs created by a /// process.</param> /// <param name="maxJobsForActivation">The maximum number of jobs that /// a process can create as result of a Queue driven /// activation.</param> public ProcessScheduleDto(string name, string timeZoneId, bool?enabled = default(bool?), long?releaseId = default(long?), string releaseKey = default(string), string releaseName = default(string), string packageName = default(string), string environmentName = default(string), string environmentId = default(string), ProcessScheduleDtoJobPriority?jobPriority = default(ProcessScheduleDtoJobPriority?), ProcessScheduleDtoRuntimeType?runtimeType = default(ProcessScheduleDtoRuntimeType?), string startProcessCron = default(string), string startProcessCronDetails = default(string), string startProcessCronSummary = default(string), System.DateTime?startProcessNextOccurrence = default(System.DateTime?), int?startStrategy = default(int?), IList <RobotExecutorDto> executorRobots = default(IList <RobotExecutorDto>), string stopProcessExpression = default(string), ProcessScheduleDtoStopStrategy?stopStrategy = default(ProcessScheduleDtoStopStrategy?), string externalJobKey = default(string), string timeZoneIana = default(string), bool?useCalendar = default(bool?), long?calendarId = default(long?), string calendarName = default(string), System.DateTime?stopProcessDate = default(System.DateTime?), string inputArguments = default(string), long?queueDefinitionId = default(long?), string queueDefinitionName = default(string), long?itemsActivationThreshold = default(long?), long?itemsPerJobActivationTarget = default(long?), int?maxJobsForActivation = default(int?), long?id = default(long?)) { Enabled = enabled; Name = name; ReleaseId = releaseId; ReleaseKey = releaseKey; ReleaseName = releaseName; PackageName = packageName; EnvironmentName = environmentName; EnvironmentId = environmentId; JobPriority = jobPriority; RuntimeType = runtimeType; StartProcessCron = startProcessCron; StartProcessCronDetails = startProcessCronDetails; StartProcessCronSummary = startProcessCronSummary; StartProcessNextOccurrence = startProcessNextOccurrence; StartStrategy = startStrategy; ExecutorRobots = executorRobots; StopProcessExpression = stopProcessExpression; StopStrategy = stopStrategy; ExternalJobKey = externalJobKey; TimeZoneId = timeZoneId; TimeZoneIana = timeZoneIana; UseCalendar = useCalendar; CalendarId = calendarId; CalendarName = calendarName; StopProcessDate = stopProcessDate; InputArguments = inputArguments; QueueDefinitionId = queueDefinitionId; QueueDefinitionName = queueDefinitionName; ItemsActivationThreshold = itemsActivationThreshold; ItemsPerJobActivationTarget = itemsPerJobActivationTarget; MaxJobsForActivation = maxJobsForActivation; Id = id; CustomInit(); }
/// <summary> /// Initializes a new instance of the PaymentMethod class. /// </summary> /// <param name="id">Resource Id.</param> /// <param name="name">Resource name.</param> /// <param name="type">Resource type.</param> /// <param name="paymentMethodType">Payment method type. Possible /// values include: 'Credits', 'ChequeWire'</param> /// <param name="details">Details about the payment method.</param> /// <param name="expiration">Expiration date.</param> /// <param name="currency">The currency associated with the payment /// method.</param> public PaymentMethod(string id = default(string), string name = default(string), string type = default(string), string paymentMethodType = default(string), string details = default(string), System.DateTime?expiration = default(System.DateTime?), string currency = default(string)) : base(id, name, type) { PaymentMethodType = paymentMethodType; Details = details; Expiration = expiration; Currency = currency; CustomInit(); }
/// <summary> /// Initializes a new instance of the CertificateListOptions class. /// </summary> /// <param name="filter">An OData $filter clause.</param> /// <param name="select">An OData $select clause.</param> /// <param name="maxResults">The maximum number of items to return in /// the response.</param> /// <param name="timeout">The maximum time that the server can spend /// processing the request, in seconds. The default is 30 /// seconds.</param> /// <param name="clientRequestId">The caller-generated request /// identity, in the form of a GUID with no decoration such as curly /// braces, e.g. 9C4D50EE-2D56-4CD3-8152-34347DC9F2B0.</param> /// <param name="returnClientRequestId">Whether the server should /// return the client-request-id identifier in the response.</param> /// <param name="ocpDate">The time the request was issued. If not /// specified, this header will be automatically populated with the /// current system clock time.</param> public CertificateListOptions(string filter = default(string), string select = default(string), int?maxResults = default(int?), int?timeout = default(int?), string clientRequestId = default(string), bool?returnClientRequestId = default(bool?), System.DateTime?ocpDate = default(System.DateTime?)) { Filter = filter; Select = select; MaxResults = maxResults; Timeout = timeout; ClientRequestId = clientRequestId; ReturnClientRequestId = returnClientRequestId; OcpDate = ocpDate; }
private void OnAlreadySynchronized() { lastOnAlreadySynchronized = System.DateTime.Now; }
/// <summary> /// Initializes a new instance of the GenericResourceExpanded class. /// </summary> /// <param name="id">Resource ID</param> /// <param name="name">Resource name</param> /// <param name="type">Resource type</param> /// <param name="location">Resource location</param> /// <param name="tags">Resource tags</param> /// <param name="plan">The plan of the resource.</param> /// <param name="properties">The resource properties.</param> /// <param name="kind">The kind of the resource.</param> /// <param name="managedBy">ID of the resource that manages this /// resource.</param> /// <param name="sku">The SKU of the resource.</param> /// <param name="identity">The identity of the resource.</param> /// <param name="createdTime">The created time of the resource. This is /// only present if requested via the $expand query parameter.</param> /// <param name="changedTime">The changed time of the resource. This is /// only present if requested via the $expand query parameter.</param> /// <param name="provisioningState">The provisioning state of the /// resource. This is only present if requested via the $expand query /// parameter.</param> public GenericResourceExpanded(string id, string name, string type, string location, IDictionary <string, string> tags, Plan plan = default(Plan), object properties = default(object), string kind = default(string), string managedBy = default(string), Sku sku = default(Sku), Identity identity = default(Identity), System.DateTime?createdTime = default(System.DateTime?), System.DateTime?changedTime = default(System.DateTime?), string provisioningState = default(string)) : this(id, name, type, location, default(ExtendedLocation), tags, plan, properties, kind, managedBy, sku, identity, createdTime, changedTime, provisioningState) { }
private void OnDiskWriteComplete() { lastOnDiskWriteComplete = System.DateTime.Now; }
/// <summary> /// Initializes a new instance of the StorageAccount class. /// </summary> /// <param name="location">The geo-location where the resource /// lives</param> /// <param name="id">Fully qualified resource ID for the resource. Ex - /// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}</param> /// <param name="name">The name of the resource</param> /// <param name="type">The type of the resource. E.g. /// "Microsoft.Compute/virtualMachines" or /// "Microsoft.Storage/storageAccounts"</param> /// <param name="tags">Resource tags.</param> /// <param name="sku">Gets the SKU.</param> /// <param name="kind">Gets the Kind. Possible values include: /// 'Storage', 'StorageV2', 'BlobStorage', 'FileStorage', /// 'BlockBlobStorage'</param> /// <param name="identity">The identity of the resource.</param> /// <param name="extendedLocation">The extendedLocation of the /// resource.</param> /// <param name="provisioningState">Gets the status of the storage /// account at the time the operation was called. Possible values /// include: 'Creating', 'ResolvingDNS', 'Succeeded'</param> /// <param name="primaryEndpoints">Gets the URLs that are used to /// perform a retrieval of a public blob, queue, or table object. Note /// that Standard_ZRS and Premium_LRS accounts only return the blob /// endpoint.</param> /// <param name="primaryLocation">Gets the location of the primary data /// center for the storage account.</param> /// <param name="statusOfPrimary">Gets the status indicating whether /// the primary location of the storage account is available or /// unavailable. Possible values include: 'available', /// 'unavailable'</param> /// <param name="lastGeoFailoverTime">Gets the timestamp of the most /// recent instance of a failover to the secondary location. Only the /// most recent timestamp is retained. This element is not returned if /// there has never been a failover instance. Only available if the /// accountType is Standard_GRS or Standard_RAGRS.</param> /// <param name="secondaryLocation">Gets the location of the /// geo-replicated secondary for the storage account. Only available if /// the accountType is Standard_GRS or Standard_RAGRS.</param> /// <param name="statusOfSecondary">Gets the status indicating whether /// the secondary location of the storage account is available or /// unavailable. Only available if the SKU name is Standard_GRS or /// Standard_RAGRS. Possible values include: 'available', /// 'unavailable'</param> /// <param name="creationTime">Gets the creation date and time of the /// storage account in UTC.</param> /// <param name="customDomain">Gets the custom domain the user assigned /// to this storage account.</param> /// <param name="secondaryEndpoints">Gets the URLs that are used to /// perform a retrieval of a public blob, queue, or table object from /// the secondary location of the storage account. Only available if /// the SKU name is Standard_RAGRS.</param> /// <param name="encryption">Gets the encryption settings on the /// account. If unspecified, the account is unencrypted.</param> /// <param name="accessTier">Required for storage accounts where kind = /// BlobStorage. The access tier used for billing. Possible values /// include: 'Hot', 'Cool'</param> /// <param name="azureFilesIdentityBasedAuthentication">Provides the /// identity based authentication settings for Azure Files.</param> /// <param name="enableHttpsTrafficOnly">Allows https traffic only to /// storage service if sets to true.</param> /// <param name="networkRuleSet">Network rule set</param> /// <param name="isHnsEnabled">Account HierarchicalNamespace enabled if /// sets to true.</param> /// <param name="geoReplicationStats">Geo Replication Stats</param> /// <param name="failoverInProgress">If the failover is in progress, /// the value will be true, otherwise, it will be null.</param> /// <param name="largeFileSharesState">Allow large file shares if sets /// to Enabled. It cannot be disabled once it is enabled. Possible /// values include: 'Disabled', 'Enabled'</param> /// <param name="privateEndpointConnections">List of private endpoint /// connection associated with the specified storage account</param> /// <param name="routingPreference">Maintains information about the /// network routing choice opted by the user for data transfer</param> /// <param name="blobRestoreStatus">Blob restore status</param> /// <param name="allowBlobPublicAccess">Allow or disallow public access /// to all blobs or containers in the storage account. The default /// interpretation is true for this property.</param> /// <param name="minimumTlsVersion">Set the minimum TLS version to be /// permitted on requests to storage. The default interpretation is TLS /// 1.0 for this property. Possible values include: 'TLS1_0', 'TLS1_1', /// 'TLS1_2'</param> public StorageAccount(string location, string id = default(string), string name = default(string), string type = default(string), IDictionary <string, string> tags = default(IDictionary <string, string>), Sku sku = default(Sku), string kind = default(string), Identity identity = default(Identity), ExtendedLocation extendedLocation = default(ExtendedLocation), ProvisioningState?provisioningState = default(ProvisioningState?), Endpoints primaryEndpoints = default(Endpoints), string primaryLocation = default(string), AccountStatus?statusOfPrimary = default(AccountStatus?), System.DateTime?lastGeoFailoverTime = default(System.DateTime?), string secondaryLocation = default(string), AccountStatus?statusOfSecondary = default(AccountStatus?), System.DateTime?creationTime = default(System.DateTime?), CustomDomain customDomain = default(CustomDomain), Endpoints secondaryEndpoints = default(Endpoints), Encryption encryption = default(Encryption), AccessTier?accessTier = default(AccessTier?), AzureFilesIdentityBasedAuthentication azureFilesIdentityBasedAuthentication = default(AzureFilesIdentityBasedAuthentication), bool?enableHttpsTrafficOnly = default(bool?), NetworkRuleSet networkRuleSet = default(NetworkRuleSet), bool?isHnsEnabled = default(bool?), GeoReplicationStats geoReplicationStats = default(GeoReplicationStats), bool?failoverInProgress = default(bool?), string largeFileSharesState = default(string), IList <PrivateEndpointConnection> privateEndpointConnections = default(IList <PrivateEndpointConnection>), RoutingPreference routingPreference = default(RoutingPreference), BlobRestoreStatus blobRestoreStatus = default(BlobRestoreStatus), bool?allowBlobPublicAccess = default(bool?), string minimumTlsVersion = default(string)) : base(location, id, name, type, tags) { Sku = sku; Kind = kind; Identity = identity; ExtendedLocation = extendedLocation; ProvisioningState = provisioningState; PrimaryEndpoints = primaryEndpoints; PrimaryLocation = primaryLocation; StatusOfPrimary = statusOfPrimary; LastGeoFailoverTime = lastGeoFailoverTime; SecondaryLocation = secondaryLocation; StatusOfSecondary = statusOfSecondary; CreationTime = creationTime; CustomDomain = customDomain; SecondaryEndpoints = secondaryEndpoints; Encryption = encryption; AccessTier = accessTier; AzureFilesIdentityBasedAuthentication = azureFilesIdentityBasedAuthentication; EnableHttpsTrafficOnly = enableHttpsTrafficOnly; NetworkRuleSet = networkRuleSet; IsHnsEnabled = isHnsEnabled; GeoReplicationStats = geoReplicationStats; FailoverInProgress = failoverInProgress; LargeFileSharesState = largeFileSharesState; PrivateEndpointConnections = privateEndpointConnections; RoutingPreference = routingPreference; BlobRestoreStatus = blobRestoreStatus; AllowBlobPublicAccess = allowBlobPublicAccess; MinimumTlsVersion = minimumTlsVersion; CustomInit(); }
private void OnThrottled() { lastOnThrottled = System.DateTime.Now; }
/// <summary> /// Initializes a new instance of the /// AzureVMAppContainerProtectionContainer class. /// </summary> /// <param name="friendlyName">Friendly name of the container.</param> /// <param name="backupManagementType">Type of backup managemenent for /// the container. Possible values include: 'Invalid', 'AzureIaasVM', /// 'MAB', 'DPM', 'AzureBackupServer', 'AzureSql', 'AzureStorage', /// 'AzureWorkload', 'DefaultBackup'</param> /// <param name="registrationStatus">Status of registration of the /// container with the Recovery Services Vault.</param> /// <param name="healthStatus">Status of health of the /// container.</param> /// <param name="sourceResourceId">ARM ID of the virtual machine /// represented by this Azure Workload Container</param> /// <param name="lastUpdatedTime">Time stamp when this container was /// updated.</param> /// <param name="extendedInfo">Additional details of a workload /// container.</param> /// <param name="workloadType">Workload type for which registration was /// sent. Possible values include: 'Invalid', 'VM', 'FileFolder', /// 'AzureSqlDb', 'SQLDB', 'Exchange', 'Sharepoint', 'VMwareVM', /// 'SystemState', 'Client', 'GenericDataSource', 'SQLDataBase', /// 'AzureFileShare', 'SAPHanaDatabase'</param> public AzureVMAppContainerProtectionContainer(string friendlyName = default(string), string backupManagementType = default(string), string registrationStatus = default(string), string healthStatus = default(string), string sourceResourceId = default(string), System.DateTime?lastUpdatedTime = default(System.DateTime?), AzureWorkloadContainerExtendedInfo extendedInfo = default(AzureWorkloadContainerExtendedInfo), string workloadType = default(string)) : base(friendlyName, backupManagementType, registrationStatus, healthStatus, sourceResourceId, lastUpdatedTime, extendedInfo, workloadType) { CustomInit(); }
/// <summary> /// Initializes a new instance of the VirtualMachineUpdate class. /// </summary> /// <param name="tags">Resource tags</param> /// <param name="plan">Specifies information about the marketplace /// image used to create the virtual machine. This element is only used /// for marketplace images. Before you can use a marketplace image from /// an API, you must enable the image for programmatic use. In the /// Azure portal, find the marketplace image that you want to use and /// then click **Want to deploy programmatically, Get Started ->**. /// Enter any required information and then click **Save**.</param> /// <param name="hardwareProfile">Specifies the hardware settings for /// the virtual machine.</param> /// <param name="storageProfile">Specifies the storage settings for the /// virtual machine disks.</param> /// <param name="additionalCapabilities">Specifies additional /// capabilities enabled or disabled on the virtual machine.</param> /// <param name="osProfile">Specifies the operating system settings /// used while creating the virtual machine. Some of the settings /// cannot be changed once VM is provisioned.</param> /// <param name="networkProfile">Specifies the network interfaces of /// the virtual machine.</param> /// <param name="securityProfile">Specifies the Security related /// profile settings for the virtual machine.</param> /// <param name="diagnosticsProfile">Specifies the boot diagnostic /// settings state. <br><br>Minimum api-version: /// 2015-06-15.</param> /// <param name="availabilitySet">Specifies information about the /// availability set that the virtual machine should be assigned to. /// Virtual machines specified in the same availability set are /// allocated to different nodes to maximize availability. For more /// information about availability sets, see [Availability sets /// overview](https://docs.microsoft.com/azure/virtual-machines/availability-set-overview). /// <br><br> For more information on Azure planned /// maintenance, see [Maintenance and updates for Virtual Machines in /// Azure](https://docs.microsoft.com/azure/virtual-machines/maintenance-and-updates) /// <br><br> Currently, a VM can only be added to /// availability set at creation time. The availability set to which /// the VM is being added should be under the same resource group as /// the availability set resource. An existing VM cannot be added to an /// availability set. <br><br>This property cannot exist /// along with a non-null properties.virtualMachineScaleSet /// reference.</param> /// <param name="virtualMachineScaleSet">Specifies information about /// the virtual machine scale set that the virtual machine should be /// assigned to. Virtual machines specified in the same virtual machine /// scale set are allocated to different nodes to maximize /// availability. Currently, a VM can only be added to virtual machine /// scale set at creation time. An existing VM cannot be added to a /// virtual machine scale set. <br><br>This property cannot /// exist along with a non-null properties.availabilitySet reference. /// <br><br>Minimum api‐version: 2019‐03‐01</param> /// <param name="proximityPlacementGroup">Specifies information about /// the proximity placement group that the virtual machine should be /// assigned to. <br><br>Minimum api-version: /// 2018-04-01.</param> /// <param name="priority">Specifies the priority for the virtual /// machine. <br><br>Minimum api-version: 2019-03-01. /// Possible values include: 'Regular', 'Low', 'Spot'</param> /// <param name="evictionPolicy">Specifies the eviction policy for the /// Azure Spot virtual machine and Azure Spot scale set. /// <br><br>For Azure Spot virtual machines, both /// 'Deallocate' and 'Delete' are supported and the minimum api-version /// is 2019-03-01. <br><br>For Azure Spot scale sets, both /// 'Deallocate' and 'Delete' are supported and the minimum api-version /// is 2017-10-30-preview. Possible values include: 'Deallocate', /// 'Delete'</param> /// <param name="billingProfile">Specifies the billing related details /// of a Azure Spot virtual machine. <br><br>Minimum /// api-version: 2019-03-01.</param> /// <param name="host">Specifies information about the dedicated host /// that the virtual machine resides in. <br><br>Minimum /// api-version: 2018-10-01.</param> /// <param name="hostGroup">Specifies information about the dedicated /// host group that the virtual machine resides in. /// <br><br>Minimum api-version: 2020-06-01. /// <br><br>NOTE: User cannot specify both host and /// hostGroup properties.</param> /// <param name="provisioningState">The provisioning state, which only /// appears in the response.</param> /// <param name="instanceView">The virtual machine instance /// view.</param> /// <param name="licenseType">Specifies that the image or disk that is /// being used was licensed on-premises. <br><br> Possible /// values for Windows Server operating system are: /// <br><br> Windows_Client <br><br> /// Windows_Server <br><br> Possible values for Linux /// Server operating system are: <br><br> RHEL_BYOS (for /// RHEL) <br><br> SLES_BYOS (for SUSE) /// <br><br> For more information, see [Azure Hybrid Use /// Benefit for Windows /// Server](https://docs.microsoft.com/azure/virtual-machines/windows/hybrid-use-benefit-licensing) /// <br><br> [Azure Hybrid Use Benefit for Linux /// Server](https://docs.microsoft.com/azure/virtual-machines/linux/azure-hybrid-benefit-linux) /// <br><br> Minimum api-version: 2015-06-15</param> /// <param name="vmId">Specifies the VM unique ID which is a 128-bits /// identifier that is encoded and stored in all Azure IaaS VMs SMBIOS /// and can be read using platform BIOS commands.</param> /// <param name="extensionsTimeBudget">Specifies the time alloted for /// all extensions to start. The time duration should be between 15 /// minutes and 120 minutes (inclusive) and should be specified in ISO /// 8601 format. The default value is 90 minutes (PT1H30M). /// <br><br> Minimum api-version: 2020-06-01</param> /// <param name="platformFaultDomain">Specifies the scale set logical /// fault domain into which the Virtual Machine will be created. By /// default, the Virtual Machine will by automatically assigned to a /// fault domain that best maintains balance across available fault /// domains.<br><li>This is applicable only if the /// 'virtualMachineScaleSet' property of this Virtual Machine is /// set.<li>The Virtual Machine Scale Set that is referenced, /// must have 'platformFaultDomainCount' &gt; 1.<li>This /// property cannot be updated once the Virtual Machine is /// created.<li>Fault domain assignment can be viewed in the /// Virtual Machine Instance View.<br><br>Minimum /// api‐version: 2020‐12‐01</param> /// <param name="scheduledEventsProfile">Specifies Scheduled Event /// related configurations.</param> /// <param name="userData">UserData for the VM, which must be base-64 /// encoded. Customer should not pass any secrets in here. /// <br><br>Minimum api-version: 2021-03-01</param> /// <param name="capacityReservation">Specifies information about the /// capacity reservation that is used to allocate virtual machine. /// <br><br>Minimum api-version: 2021-04-01.</param> /// <param name="applicationProfile">Specifies the gallery applications /// that should be made available to the VM/VMSS</param> /// <param name="timeCreated">Specifies the time at which the Virtual /// Machine resource was created.<br><br>Minimum /// api-version: 2021-11-01.</param> /// <param name="identity">The identity of the virtual machine, if /// configured.</param> /// <param name="zones">The virtual machine zones.</param> public VirtualMachineUpdate(IDictionary <string, string> tags = default(IDictionary <string, string>), Plan plan = default(Plan), HardwareProfile hardwareProfile = default(HardwareProfile), StorageProfile storageProfile = default(StorageProfile), AdditionalCapabilities additionalCapabilities = default(AdditionalCapabilities), OSProfile osProfile = default(OSProfile), NetworkProfile networkProfile = default(NetworkProfile), SecurityProfile securityProfile = default(SecurityProfile), DiagnosticsProfile diagnosticsProfile = default(DiagnosticsProfile), SubResource availabilitySet = default(SubResource), SubResource virtualMachineScaleSet = default(SubResource), SubResource proximityPlacementGroup = default(SubResource), string priority = default(string), string evictionPolicy = default(string), BillingProfile billingProfile = default(BillingProfile), SubResource host = default(SubResource), SubResource hostGroup = default(SubResource), string provisioningState = default(string), VirtualMachineInstanceView instanceView = default(VirtualMachineInstanceView), string licenseType = default(string), string vmId = default(string), string extensionsTimeBudget = default(string), int?platformFaultDomain = default(int?), ScheduledEventsProfile scheduledEventsProfile = default(ScheduledEventsProfile), string userData = default(string), CapacityReservationProfile capacityReservation = default(CapacityReservationProfile), ApplicationProfile applicationProfile = default(ApplicationProfile), System.DateTime?timeCreated = default(System.DateTime?), VirtualMachineIdentity identity = default(VirtualMachineIdentity), IList <string> zones = default(IList <string>)) : base(tags) { Plan = plan; HardwareProfile = hardwareProfile; StorageProfile = storageProfile; AdditionalCapabilities = additionalCapabilities; OsProfile = osProfile; NetworkProfile = networkProfile; SecurityProfile = securityProfile; DiagnosticsProfile = diagnosticsProfile; AvailabilitySet = availabilitySet; VirtualMachineScaleSet = virtualMachineScaleSet; ProximityPlacementGroup = proximityPlacementGroup; Priority = priority; EvictionPolicy = evictionPolicy; BillingProfile = billingProfile; Host = host; HostGroup = hostGroup; ProvisioningState = provisioningState; InstanceView = instanceView; LicenseType = licenseType; VmId = vmId; ExtensionsTimeBudget = extensionsTimeBudget; PlatformFaultDomain = platformFaultDomain; ScheduledEventsProfile = scheduledEventsProfile; UserData = userData; CapacityReservation = capacityReservation; ApplicationProfile = applicationProfile; TimeCreated = timeCreated; Identity = identity; Zones = zones; CustomInit(); }
public static List <ModelResult> RecognizeDateTime(string query, string culture, DateTimeOptions options = DateTimeOptions.None, System.DateTime?refTime = null, bool fallbackToDefaultCulture = true) { var recognizer = new DateTimeRecognizer(options); var model = recognizer.GetDateTimeModel(culture, fallbackToDefaultCulture); return(model.Parse(query, refTime ?? System.DateTime.Now)); }
partial void RunCustomLogicSetStart(System.DateTime?value);
/// <summary> /// Initializes a new instance of the PacketCaptureQueryStatusResult /// class. /// </summary> /// <param name="name">The name of the packet capture resource.</param> /// <param name="id">The ID of the packet capture resource.</param> /// <param name="captureStartTime">The start time of the packet capture /// session.</param> /// <param name="packetCaptureStatus">The status of the packet capture /// session. Possible values include: 'NotStarted', 'Running', /// 'Stopped', 'Error', 'Unknown'</param> /// <param name="stopReason">The reason the current packet capture /// session was stopped.</param> /// <param name="packetCaptureError">List of errors of packet capture /// session.</param> public PacketCaptureQueryStatusResult(string name = default(string), string id = default(string), System.DateTime?captureStartTime = default(System.DateTime?), string packetCaptureStatus = default(string), string stopReason = default(string), IList <string> packetCaptureError = default(IList <string>)) { Name = name; Id = id; CaptureStartTime = captureStartTime; PacketCaptureStatus = packetCaptureStatus; StopReason = stopReason; PacketCaptureError = packetCaptureError; CustomInit(); }
/// <summary> /// Initializes a new instance of the Remediation class. /// </summary> /// <param name="policyAssignmentId">The resource ID of the policy /// assignment that should be remediated.</param> /// <param name="policyDefinitionReferenceId">The policy definition /// reference ID of the individual definition that should be /// remediated. Required when the policy assignment being remediated /// assigns a policy set definition.</param> /// <param name="resourceDiscoveryMode">The way resources to remediate /// are discovered. Defaults to ExistingNonCompliant if not specified. /// Possible values include: 'ExistingNonCompliant', /// 'ReEvaluateCompliance'</param> /// <param name="provisioningState">The status of the /// remediation.</param> /// <param name="createdOn">The time at which the remediation was /// created.</param> /// <param name="lastUpdatedOn">The time at which the remediation was /// last updated.</param> /// <param name="filters">The filters that will be applied to determine /// which resources to remediate.</param> /// <param name="deploymentStatus">The deployment status summary for /// all deployments created by the remediation.</param> /// <param name="id">The ID of the remediation.</param> /// <param name="type">The type of the remediation.</param> /// <param name="name">The name of the remediation.</param> public Remediation(string policyAssignmentId = default(string), string policyDefinitionReferenceId = default(string), string resourceDiscoveryMode = default(string), string provisioningState = default(string), System.DateTime?createdOn = default(System.DateTime?), System.DateTime?lastUpdatedOn = default(System.DateTime?), RemediationFilters filters = default(RemediationFilters), RemediationDeploymentSummary deploymentStatus = default(RemediationDeploymentSummary), string id = default(string), string type = default(string), string name = default(string)) { PolicyAssignmentId = policyAssignmentId; PolicyDefinitionReferenceId = policyDefinitionReferenceId; ResourceDiscoveryMode = resourceDiscoveryMode; ProvisioningState = provisioningState; CreatedOn = createdOn; LastUpdatedOn = lastUpdatedOn; Filters = filters; DeploymentStatus = deploymentStatus; Id = id; Type = type; Name = name; CustomInit(); }
/// <summary> /// Extracts policy information from the server's response. /// </summary> /// <param name='policy'> /// The structure to be dissected. /// </param> internal Policy(System.Collections.Generic.IDictionary<string, object> policy) { if(policy.ContainsKey("stale")){ this.Stale = ((Jayrock.Json.JsonNumber)policy ["stale"]).ToDouble(); } if(policy.ContainsKey("staleTime")){ this.stale_time = Libraries.Structures.ToCLRTimestamp(((Jayrock.Json.JsonNumber)policy ["staleTime"]).ToDouble()); } if(policy.ContainsKey("fixed")){ this.Fixed = ((Jayrock.Json.JsonNumber)policy ["fixed"]).ToDouble(); } }
/// <summary> /// Initializes a new instance of the DatetimeWrapper class. /// </summary> public DatetimeWrapper(System.DateTime?field = default(System.DateTime?), System.DateTime?now = default(System.DateTime?)) { Field = field; Now = now; CustomInit(); }
public UpdateHandler(float rate) { updateRate = rate; _start = null; }
/// <summary> /// Initializes a new instance of the InstanceViewStatus class. /// </summary> /// <param name="code">The status code.</param> /// <param name="level">The level code. Possible values include: /// 'Info', 'Warning', 'Error'</param> /// <param name="displayStatus">The short localizable label for the /// status.</param> /// <param name="message">The detailed status message, including for /// alerts and error messages.</param> /// <param name="time">The time of the status.</param> public InstanceViewStatus(string code = default(string), StatusLevelTypes?level = default(StatusLevelTypes?), string displayStatus = default(string), string message = default(string), System.DateTime?time = default(System.DateTime?)) { Code = code; Level = level; DisplayStatus = displayStatus; Message = message; Time = time; CustomInit(); }
public System.Linq.IQueryable <SSP.Servidor.LIQUIDO_HOJA_CTRL> ObtenerHojaLiquidos(decimal?_Hospitalizado, System.DateTime?_Fecha, decimal?_Hora) { try { var predicate = PredicateBuilder.True <SSP.Servidor.LIQUIDO_HOJA_CTRL>(); if (_Hospitalizado.HasValue) { predicate = predicate.And(x => x.ID_HOSPITA == _Hospitalizado); } if (_Fecha.HasValue && _Hora.HasValue) { int Hor = System.Convert.ToInt32(_Hora.Value); System.DateTime _fechaConsulta = new System.DateTime(_Fecha.Value.Year, _Fecha.Value.Month, _Fecha.Value.Day, 0, 0, 0); predicate = predicate.And(x => x.FECHA.Value.Year == _fechaConsulta.Year && x.FECHA.Value.Month == _fechaConsulta.Month && x.FECHA.Value.Day == _fechaConsulta.Day && x.ID_LIQHORA == _Hora); } ; return(GetData(predicate.Expand())); } catch (System.Exception exc) { throw exc; } }
public UpdateHandler() { _updateRate = null; _start = null; }
/// <summary> /// Initializes a new instance of the SubmissionMailEntity class. /// </summary> /// <param name="id">Fully qualified resource ID for the resource. Ex - /// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}</param> /// <param name="name">The name of the resource</param> /// <param name="type">The type of the resource. E.g. /// "Microsoft.Compute/virtualMachines" or /// "Microsoft.Storage/storageAccounts"</param> /// <param name="systemData">Azure Resource Manager metadata containing /// createdBy and modifiedBy information.</param> /// <param name="additionalData">A bag of custom fields that should be /// part of the entity and will be presented to the user.</param> /// <param name="friendlyName">The graph item display name which is a /// short humanly readable description of the graph item instance. This /// property is optional and might be system generated.</param> /// <param name="networkMessageId">The network message id of email to /// which submission belongs</param> /// <param name="submissionId">The submission id</param> /// <param name="submitter">The submitter</param> /// <param name="submissionDate">The submission date</param> /// <param name="timestamp">The Time stamp when the message is received /// (Mail)</param> /// <param name="recipient">The recipient of the mail</param> /// <param name="sender">The sender of the mail</param> /// <param name="senderIp">The sender's IP</param> /// <param name="subject">The subject of submission mail</param> /// <param name="reportType">The submission type for the given /// instance. This maps to Junk, Phish, Malware or NotJunk.</param> public SubmissionMailEntity(string id = default(string), string name = default(string), string type = default(string), SystemData systemData = default(SystemData), IDictionary <string, object> additionalData = default(IDictionary <string, object>), string friendlyName = default(string), System.Guid?networkMessageId = default(System.Guid?), System.Guid?submissionId = default(System.Guid?), string submitter = default(string), System.DateTime?submissionDate = default(System.DateTime?), System.DateTime?timestamp = default(System.DateTime?), string recipient = default(string), string sender = default(string), string senderIp = default(string), string subject = default(string), string reportType = default(string)) : base(id, name, type, systemData) { AdditionalData = additionalData; FriendlyName = friendlyName; NetworkMessageId = networkMessageId; SubmissionId = submissionId; Submitter = submitter; SubmissionDate = submissionDate; Timestamp = timestamp; Recipient = recipient; Sender = sender; SenderIp = senderIp; Subject = subject; ReportType = reportType; CustomInit(); }
/// <summary> /// Initializes a new instance of the Alert class. /// </summary> /// <param name="id">Resource Id</param> /// <param name="name">Resource name</param> /// <param name="type">Resource type</param> /// <param name="state">State of the alert (Active, Dismissed /// etc.)</param> /// <param name="reportedTimeUtc">The time the incident was reported to /// Microsoft.Security in UTC</param> /// <param name="vendorName">Name of the vendor that discovered the /// incident</param> /// <param name="alertName">Name of the alert type</param> /// <param name="alertDisplayName">Display name of the alert /// type</param> /// <param name="detectedTimeUtc">The time the incident was detected by /// the vendor</param> /// <param name="description">Description of the incident and what it /// means</param> /// <param name="remediationSteps">Recommended steps to reradiate the /// incident</param> /// <param name="actionTaken">The action that was taken as a response /// to the alert (Active, Blocked etc.)</param> /// <param name="reportedSeverity">Estimated severity of this alert. /// Possible values include: 'Informational', 'Low', 'Medium', /// 'High'</param> /// <param name="compromisedEntity">The entity that the incident /// happened on</param> /// <param name="associatedResource">Azure resource ID of the /// associated resource</param> /// <param name="systemSource">The type of the alerted resource (Azure, /// Non-Azure)</param> /// <param name="canBeInvestigated">Whether this alert can be /// investigated with Azure Security Center</param> /// <param name="isIncident">Whether this alert is for incident type or /// not (otherwise - single alert)</param> /// <param name="entities">objects that are related to this /// alerts</param> /// <param name="confidenceScore">level of confidence we have on the /// alert</param> /// <param name="confidenceReasons">reasons the alert got the /// confidenceScore value</param> /// <param name="subscriptionId">Azure subscription ID of the resource /// that had the security alert or the subscription ID of the workspace /// that this resource reports to</param> /// <param name="instanceId">Instance ID of the alert.</param> /// <param name="workspaceArmId">Azure resource ID of the workspace /// that the alert was reported to.</param> public Alert(string id = default(string), string name = default(string), string type = default(string), string state = default(string), System.DateTime?reportedTimeUtc = default(System.DateTime?), string vendorName = default(string), string alertName = default(string), string alertDisplayName = default(string), System.DateTime?detectedTimeUtc = default(System.DateTime?), string description = default(string), string remediationSteps = default(string), string actionTaken = default(string), string reportedSeverity = default(string), string compromisedEntity = default(string), string associatedResource = default(string), IDictionary <string, object> extendedProperties = default(IDictionary <string, object>), string systemSource = default(string), bool?canBeInvestigated = default(bool?), bool?isIncident = default(bool?), IList <AlertEntity> entities = default(IList <AlertEntity>), double?confidenceScore = default(double?), IList <AlertConfidenceReason> confidenceReasons = default(IList <AlertConfidenceReason>), string subscriptionId = default(string), string instanceId = default(string), string workspaceArmId = default(string)) : base(id, name, type) { State = state; ReportedTimeUtc = reportedTimeUtc; VendorName = vendorName; AlertName = alertName; AlertDisplayName = alertDisplayName; DetectedTimeUtc = detectedTimeUtc; Description = description; RemediationSteps = remediationSteps; ActionTaken = actionTaken; ReportedSeverity = reportedSeverity; CompromisedEntity = compromisedEntity; AssociatedResource = associatedResource; ExtendedProperties = extendedProperties; SystemSource = systemSource; CanBeInvestigated = canBeInvestigated; IsIncident = isIncident; Entities = entities; ConfidenceScore = confidenceScore; ConfidenceReasons = confidenceReasons; SubscriptionId = subscriptionId; InstanceId = instanceId; WorkspaceArmId = workspaceArmId; CustomInit(); }
/// <summary> /// Initializes a new instance of the ProcessingExceptionDto class. /// </summary> /// <param name="reason">The reason the processing failed.</param> /// <param name="details">Stores additional details about the /// exception.</param> /// <param name="type">The processing exception type, if any. Possible /// values include: 'ApplicationException', 'BusinessException'</param> /// <param name="associatedImageFilePath">A path on the robot running /// computer to an image file that stores relevant information about /// the exception - e.g. a system print screen.</param> /// <param name="creationTime">Time when the exception occurred</param> public ProcessingExceptionDto(string reason = default(string), string details = default(string), ProcessingExceptionDtoType?type = default(ProcessingExceptionDtoType?), string associatedImageFilePath = default(string), System.DateTime?creationTime = default(System.DateTime?)) { Reason = reason; Details = details; Type = type; AssociatedImageFilePath = associatedImageFilePath; CreationTime = creationTime; CustomInit(); }
private void OnDataUploadedToCloud() { lastOnDataUploadedToCloud = System.DateTime.Now; }
/// <summary> /// Initializes a new instance of the ApiManagementServiceResource /// class. /// </summary> /// <param name="publisherEmail">Publisher email.</param> /// <param name="publisherName">Publisher name.</param> /// <param name="sku">SKU properties of the API Management /// service.</param> /// <param name="location">Resource location.</param> /// <param name="id">Resource ID.</param> /// <param name="name">Resource name.</param> /// <param name="type">Resource type for API Management resource is set /// to Microsoft.ApiManagement.</param> /// <param name="tags">Resource tags.</param> /// <param name="notificationSenderEmail">Email address from which the /// notification will be sent.</param> /// <param name="provisioningState">The current provisioning state of /// the API Management service which can be one of the following: /// Created/Activating/Succeeded/Updating/Failed/Stopped/Terminating/TerminationFailed/Deleted.</param> /// <param name="targetProvisioningState">The provisioning state of the /// API Management service, which is targeted by the long running /// operation started on the service.</param> /// <param name="createdAtUtc">Creation UTC date of the API Management /// service.The date conforms to the following format: /// `yyyy-MM-ddTHH:mm:ssZ` as specified by the ISO 8601 /// standard.</param> /// <param name="gatewayUrl">Gateway URL of the API Management /// service.</param> /// <param name="gatewayRegionalUrl">Gateway URL of the API Management /// service in the Default Region.</param> /// <param name="portalUrl">Publisher portal endpoint Url of the API /// Management service.</param> /// <param name="managementApiUrl">Management API endpoint URL of the /// API Management service.</param> /// <param name="developerPortalUrl">Developer Portal endpoint URL of /// the API Management service.</param> /// <param name="scmUrl">SCM endpoint URL of the API Management /// service.</param> /// <param name="hostnameConfigurations">Custom hostname configuration /// of the API Management service.</param> /// <param name="publicIPAddresses">Public Static Load Balanced IP /// addresses of the API Management service in Primary region. /// Available only for Basic, Standard and Premium SKU.</param> /// <param name="privateIPAddresses">Private Static Load Balanced IP /// addresses of the API Management service in Primary region which is /// deployed in an Internal Virtual Network. Available only for Basic, /// Standard and Premium SKU.</param> /// <param name="virtualNetworkConfiguration">Virtual network /// configuration of the API Management service.</param> /// <param name="additionalLocations">Additional datacenter locations /// of the API Management service.</param> /// <param name="customProperties">Custom properties of the API /// Management service.</br>Setting /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Ciphers.TripleDes168` /// will disable the cipher TLS_RSA_WITH_3DES_EDE_CBC_SHA for all /// TLS(1.0, 1.1 and 1.2).</br>Setting /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Protocols.Tls11` /// can be used to disable just TLS 1.1.</br>Setting /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Protocols.Tls10` /// can be used to disable TLS 1.0 on an API Management /// service.</br>Setting /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Backend.Protocols.Tls11` /// can be used to disable just TLS 1.1 for communications with /// backends.</br>Setting /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Backend.Protocols.Tls10` /// can be used to disable TLS 1.0 for communications with /// backends.</br>Setting /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Protocols.Server.Http2` /// can be used to enable HTTP2 protocol on an API Management /// service.</br>Not specifying any of these properties on PATCH /// operation will reset omitted properties' values to their defaults. /// For all the settings except Http2 the default value is `True` if /// the service was created on or before April 1st 2018 and `False` /// otherwise. Http2 setting's default value is /// `False`.</br></br>You can disable any of next ciphers /// by using settings /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Ciphers.[cipher_name]`: /// TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, /// TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, /// TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, /// TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, /// TLS_RSA_WITH_AES_128_GCM_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA256, /// TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, /// TLS_RSA_WITH_AES_128_CBC_SHA. For example, /// `Microsoft.WindowsAzure.ApiManagement.Gateway.Security.Ciphers.TLS_RSA_WITH_AES_128_CBC_SHA256`:`false`. /// The default value is `true` for them.</param> /// <param name="certificates">List of Certificates that need to be /// installed in the API Management service. Max supported certificates /// that can be installed is 10.</param> /// <param name="enableClientCertificate">Property only meant to be /// used for Consumption SKU Service. This enforces a client /// certificate to be presented on each request to the gateway. This /// also enables the ability to authenticate the certificate in the /// policy on the gateway.</param> /// <param name="virtualNetworkType">The type of VPN in which API /// Management service needs to be configured in. None (Default Value) /// means the API Management service is not part of any Virtual /// Network, External means the API Management deployment is set up /// inside a Virtual Network having an Internet Facing Endpoint, and /// Internal means that API Management deployment is setup inside a /// Virtual Network having an Intranet Facing Endpoint only. Possible /// values include: 'None', 'External', 'Internal'</param> /// <param name="identity">Managed service identity of the Api /// Management service.</param> /// <param name="etag">ETag of the resource.</param> public ApiManagementServiceResource(string publisherEmail, string publisherName, ApiManagementServiceSkuProperties sku, string location, string id = default(string), string name = default(string), string type = default(string), IDictionary <string, string> tags = default(IDictionary <string, string>), string notificationSenderEmail = default(string), string provisioningState = default(string), string targetProvisioningState = default(string), System.DateTime?createdAtUtc = default(System.DateTime?), string gatewayUrl = default(string), string gatewayRegionalUrl = default(string), string portalUrl = default(string), string managementApiUrl = default(string), string developerPortalUrl = default(string), string scmUrl = default(string), IList <HostnameConfiguration> hostnameConfigurations = default(IList <HostnameConfiguration>), IList <string> publicIPAddresses = default(IList <string>), IList <string> privateIPAddresses = default(IList <string>), VirtualNetworkConfiguration virtualNetworkConfiguration = default(VirtualNetworkConfiguration), IList <AdditionalLocation> additionalLocations = default(IList <AdditionalLocation>), IDictionary <string, string> customProperties = default(IDictionary <string, string>), IList <CertificateConfiguration> certificates = default(IList <CertificateConfiguration>), bool?enableClientCertificate = default(bool?), string virtualNetworkType = default(string), ApiManagementServiceIdentity identity = default(ApiManagementServiceIdentity), string etag = default(string)) : base(id, name, type, tags) { NotificationSenderEmail = notificationSenderEmail; ProvisioningState = provisioningState; TargetProvisioningState = targetProvisioningState; CreatedAtUtc = createdAtUtc; GatewayUrl = gatewayUrl; GatewayRegionalUrl = gatewayRegionalUrl; PortalUrl = portalUrl; ManagementApiUrl = managementApiUrl; DeveloperPortalUrl = developerPortalUrl; ScmUrl = scmUrl; HostnameConfigurations = hostnameConfigurations; PublicIPAddresses = publicIPAddresses; PrivateIPAddresses = privateIPAddresses; VirtualNetworkConfiguration = virtualNetworkConfiguration; AdditionalLocations = additionalLocations; CustomProperties = customProperties; Certificates = certificates; EnableClientCertificate = enableClientCertificate; VirtualNetworkType = virtualNetworkType; PublisherEmail = publisherEmail; PublisherName = publisherName; Sku = sku; Identity = identity; Location = location; Etag = etag; CustomInit(); }
private void OnFirstSynchronize() { lastOnFirstSynchronize = System.DateTime.Now; }
/// <summary> /// Initializes a new instance of the AccountSasParameters class. /// </summary> /// <param name="services">The signed services accessible with the /// account SAS. Possible values include: Blob (b), Queue (q), Table /// (t), File (f). Possible values include: 'b', 'q', 't', 'f'</param> /// <param name="resourceTypes">The signed resource types that are /// accessible with the account SAS. Service (s): Access to /// service-level APIs; Container (c): Access to container-level APIs; /// Object (o): Access to object-level APIs for blobs, queue messages, /// table entities, and files. Possible values include: 's', 'c', /// 'o'</param> /// <param name="permissions">The signed permissions for the account /// SAS. Possible values include: Read (r), Write (w), Delete (d), List /// (l), Add (a), Create (c), Update (u) and Process (p). Possible /// values include: 'r', 'd', 'w', 'l', 'a', 'c', 'u', 'p'</param> /// <param name="sharedAccessExpiryTime">The time at which the shared /// access signature becomes invalid.</param> /// <param name="iPAddressOrRange">An IP address or a range of IP /// addresses from which to accept requests.</param> /// <param name="protocols">The protocol permitted for a request made /// with the account SAS. Possible values include: 'https,http', /// 'https'</param> /// <param name="sharedAccessStartTime">The time at which the SAS /// becomes valid.</param> /// <param name="keyToSign">The key to sign the account SAS token /// with.</param> public AccountSasParameters(string services, string resourceTypes, string permissions, System.DateTime sharedAccessExpiryTime, string iPAddressOrRange = default(string), HttpProtocol?protocols = default(HttpProtocol?), System.DateTime?sharedAccessStartTime = default(System.DateTime?), string keyToSign = default(string)) { Services = services; ResourceTypes = resourceTypes; Permissions = permissions; IPAddressOrRange = iPAddressOrRange; Protocols = protocols; SharedAccessStartTime = sharedAccessStartTime; SharedAccessExpiryTime = sharedAccessExpiryTime; KeyToSign = keyToSign; CustomInit(); }
private void OnSyncFailed() { lastOnSyncFailed = System.DateTime.Now; failReason = AGSWhispersyncClient.failReason; }
/// <summary> /// Initializes a new instance of the ManagedIntegrationRuntimeError /// class. /// </summary> /// <param name="additionalProperties">Unmatched properties from the /// message are deserialized this collection</param> /// <param name="time">The time when the error occurred.</param> /// <param name="code">Error code.</param> /// <param name="parameters">Managed integration runtime error /// parameters.</param> /// <param name="message">Error message.</param> public ManagedIntegrationRuntimeError(IDictionary <string, object> additionalProperties = default(IDictionary <string, object>), System.DateTime?time = default(System.DateTime?), string code = default(string), IList <string> parameters = default(IList <string>), string message = default(string)) { AdditionalProperties = additionalProperties; Time = time; Code = code; Parameters = parameters; Message = message; CustomInit(); }
void IPinchable.Decode(IPinchDecoder decoder) { int remainingFields = decoder.OpenSequence(); // Decode members for version 1: if (remainingFields >= 8) { int listOfOptionalDateTimeCount = decoder.OpenSequence(); _listOfOptionalDateTime = new List<System.DateTime?>(); for (int i = 0; i < listOfOptionalDateTimeCount; i++) { _listOfOptionalDateTime.Add(MyDateTimeSurrogate.SurrogateToValueOptional((MyDateTimeSurrogate)decoder.DecodeOptionalStructure(MyDateTimeSurrogateFactory.Instance, _listOfOptionalDateTimeProperties))); } decoder.CloseSequence(); int listOfOptionalUriCount = decoder.OpenSequence(); _listOfOptionalUri = new List<System.Uri>(); for (int i = 0; i < listOfOptionalUriCount; i++) { _listOfOptionalUri.Add(MyUriSurrogate.SurrogateToValueOptional((MyUriSurrogate)decoder.DecodeOptionalStructure(MyUriSurrogateFactory.Instance, _listOfOptionalUriProperties))); } decoder.CloseSequence(); int listOfRequiredDateTimeCount = decoder.OpenSequence(); _listOfRequiredDateTime = new List<System.DateTime>(); for (int i = 0; i < listOfRequiredDateTimeCount; i++) { _listOfRequiredDateTime.Add(MyDateTimeSurrogate.SurrogateToValueRequired((MyDateTimeSurrogate)decoder.DecodeRequiredStructure(MyDateTimeSurrogateFactory.Instance, _listOfRequiredDateTimeProperties))); } decoder.CloseSequence(); int listOfRequiredUriCount = decoder.OpenSequence(); _listOfRequiredUri = new List<System.Uri>(); for (int i = 0; i < listOfRequiredUriCount; i++) { _listOfRequiredUri.Add(MyUriSurrogate.SurrogateToValueRequired((MyUriSurrogate)decoder.DecodeRequiredStructure(MyUriSurrogateFactory.Instance, _listOfRequiredUriProperties))); } decoder.CloseSequence(); _optionalDateTime = MyDateTimeSurrogate.SurrogateToValueOptional((MyDateTimeSurrogate)decoder.DecodeOptionalStructure(MyDateTimeSurrogateFactory.Instance, _optionalDateTimeProperties)); _optionalUri = MyUriSurrogate.SurrogateToValueOptional((MyUriSurrogate)decoder.DecodeOptionalStructure(MyUriSurrogateFactory.Instance, _optionalUriProperties)); _requiredDateTime = MyDateTimeSurrogate.SurrogateToValueRequired((MyDateTimeSurrogate)decoder.DecodeRequiredStructure(MyDateTimeSurrogateFactory.Instance, _requiredDateTimeProperties)); _requiredUri = MyUriSurrogate.SurrogateToValueRequired((MyUriSurrogate)decoder.DecodeRequiredStructure(MyUriSurrogateFactory.Instance, _requiredUriProperties)); remainingFields -= 8; } else { if (remainingFields != 0) throw new PinchInvalidCodingException(); } if (remainingFields > 0) { OnAdditionalFutureFields(decoder); decoder.SkipFields(remainingFields); } decoder.CloseSequence(); }
/// <summary> /// Initializes a new instance of the LicenseNamedUserDto class. /// </summary> /// <param name="key">The license key.</param> /// <param name="userName">The Robot's UserName.</param> /// <param name="lastLoginDate">The last date when the Robot acquired a /// license.</param> /// <param name="machinesCount">Total number of machines where a robot /// with UserName is defined.</param> /// <param name="isLicensed">If the license is in use.</param> /// <param name="isExternalLicensed">If the robot is external /// licensed</param> /// <param name="activeRobotId">The Id of the Robot that uses the /// license.</param> /// <param name="machineNames">The Machine names of the defined /// Robot.</param> /// <param name="activeMachineNames">The Machine names of the connected /// and licensed Robot.</param> public LicenseNamedUserDto(string key = default(string), string userName = default(string), System.DateTime?lastLoginDate = default(System.DateTime?), int?machinesCount = default(int?), bool?isLicensed = default(bool?), bool?isExternalLicensed = default(bool?), long?activeRobotId = default(long?), IList <string> machineNames = default(IList <string>), IList <string> activeMachineNames = default(IList <string>)) { Key = key; UserName = userName; LastLoginDate = lastLoginDate; MachinesCount = machinesCount; IsLicensed = isLicensed; IsExternalLicensed = isExternalLicensed; ActiveRobotId = activeRobotId; MachineNames = machineNames; ActiveMachineNames = activeMachineNames; CustomInit(); }