public override string ToString() =>
$@"{base.ToString()}: Member Accessor(
Name: {NameIdentifier.ToString().Indent()}{
(NameSymbol != null ? $"\nName Symbol: {NameSymbol.ToString().Indent()}" : string.Empty)}
Is Safe Access: {IsSafeAccess.ToString().Indent()}
Is Print Access: {IsPrintAccess.ToString().Indent()}
Call Parameters: {CallParameters?.ToString().Indent()}
)";
public XElement Serialize()
{
var result = new XElement(Constants.XMLNamespaces.SAML + "Subject");
if (NameIdentifier != null)
{
result.Add(NameIdentifier.Serialize());
}
if (SubjectConfirmation != null)
{
result.Add(SubjectConfirmation.Serialize());
}
return(result);
}
public virtual Response ResendRequestEmails(NameIdentifier nameIdentifier, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(nameIdentifier, nameof(nameIdentifier));
using var scope = _appServiceCertificateOrderClientDiagnostics.CreateScope("AppServiceCertificateOrder.ResendRequestEmails");
scope.Start();
try
{
var response = _appServiceCertificateOrderRestClient.ResendRequestEmails(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, nameIdentifier, cancellationToken);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public void writeFileHeader(Writer writer, uint offset = 0)
{
NameIdentifier name = fileName;
if (!fileName.usingHash)
{
name = new NameIdentifier(fileName.name.Replace('\\', '/').ToLower());
}
for (int y = 0; y < 16; y += 4)
{
writer.Write(name.hash[y + 3]);
writer.Write(name.hash[y + 2]);
writer.Write(name.hash[y + 1]);
writer.Write(name.hash[y + 0]);
}
writer.Write(offset);
writer.Write((uint)(fileData.Length) | (encrypted ? 0x80000000 : 0));
}
public async virtual Task <Response> ResendRequestEmailsAsync(NameIdentifier nameIdentifier, CancellationToken cancellationToken = default)
{
if (nameIdentifier == null)
{
throw new ArgumentNullException(nameof(nameIdentifier));
}
using var scope = _appServiceCertificateOrderClientDiagnostics.CreateScope("AppServiceCertificateOrder.ResendRequestEmails");
scope.Start();
try
{
var response = await _appServiceCertificateOrderRestClient.ResendRequestEmailsAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Name, nameIdentifier, cancellationToken).ConfigureAwait(false);
return(response);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// List all apps that are assigned to a hostname.
/// </summary>
/// <remarks>
/// List all apps that are assigned to a hostname.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='nameIdentifier'>
/// Hostname information.
/// </param>
public static IPage <Identifier> ListSiteIdentifiersAssignedToHostName(this IWebSiteManagementClient operations, NameIdentifier nameIdentifier)
{
return(operations.ListSiteIdentifiersAssignedToHostNameAsync(nameIdentifier).GetAwaiter().GetResult());
}
/// <summary>
/// Check if a domain is available for registration.
/// </summary>
/// <remarks>
/// Check if a domain is available for registration.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='identifier'>
/// Name of the domain.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DomainAvailablilityCheckResult> CheckAvailabilityAsync(this IDomainsOperations operations, NameIdentifier identifier, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CheckAvailabilityWithHttpMessagesAsync(identifier, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Check if a domain is available for registration.
/// </summary>
/// <remarks>
/// Check if a domain is available for registration.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='identifier'>
/// Name of the domain.
/// </param>
public static DomainAvailablilityCheckResult CheckAvailability(this IDomainsOperations operations, NameIdentifier identifier)
{
return(operations.CheckAvailabilityAsync(identifier).GetAwaiter().GetResult());
}
public override TreeTextRange GetNameRange() => NameIdentifier.GetNameRange();
/// <summary>
/// Checks if a domain is available for registration
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='identifier'>
/// Name of the domain
/// </param>
public static DomainAvailablilityCheckResult CheckDomainAvailability(this IGlobalDomainRegistrationOperations operations, NameIdentifier identifier)
{
return(Task.Factory.StartNew(s => ((IGlobalDomainRegistrationOperations)s).CheckDomainAvailabilityAsync(identifier), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public AttributeValue GetAttribute(NameIdentifier name)
{
return(_entity.GetAttribute(name));
}
public void read(Reader reader, List <string> fileNames = null, int fileID = 0)
{
for (int y = 0; y < 16; y += 4)
{
fileName.hash[y + 3] = reader.ReadByte();
fileName.hash[y + 2] = reader.ReadByte();
fileName.hash[y + 1] = reader.ReadByte();
fileName.hash[y + 0] = reader.ReadByte();
}
fileName.usingHash = true;
var md5 = MD5.Create();
fileName.name = (fileID + 1) + ".bin"; //Make a base name
for (int i = 0; fileNames != null && i < fileNames.Count; i++)
{
// RSDKv4 Hashes all Strings at Lower Case
string fp = fileNames[i].ToLower();
bool match = true;
for (int z = 0; z < 16; z++)
{
if (calculateMD5Hash(fp)[z] != fileName.hash[z])
{
match = false;
break;
}
}
if (match)
{
fileName = new NameIdentifier(fileNames[i]);
break;
}
}
uint fileOffset = reader.ReadUInt32();
uint tmp = reader.ReadUInt32();
encrypted = (tmp & 0x80000000) != 0;
uint fileSize = (tmp & 0x7FFFFFFF);
long tmp2 = reader.BaseStream.Position;
reader.BaseStream.Position = fileOffset;
// Decrypt File if Encrypted
if (encrypted && !fileName.usingHash)
{
fileData = decrypt(reader.readBytes(fileSize), false);
}
else
{
fileData = reader.readBytes(fileSize);
}
reader.BaseStream.Position = tmp2;
extension = getExtensionFromData();
if (fileName.usingHash)
{
switch (extension)
{
case ExtensionTypes.GIF:
fileName.name = "Sprite" + (fileID + 1) + ".gif";
break;
case ExtensionTypes.MDL:
fileName.name = "Model" + (fileID + 1) + ".bin";
break;
case ExtensionTypes.OGG:
fileName.name = "Music" + (fileID + 1) + ".ogg";
break;
case ExtensionTypes.PNG:
fileName.name = "Image" + (fileID + 1) + ".png";
break;
case ExtensionTypes.WAV:
fileName.name = "SoundEffect" + (fileID + 1) + ".wav";
break;
case ExtensionTypes.UNKNOWN:
fileName.name = "UnknownFileType" + (fileID + 1) + ".bin";
break;
}
}
md5.Dispose();
}
/// <summary>
/// Checks if a domain is available for registration
/// </summary>
/// <param name='identifier'>
/// Name of the domain
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public async Task <AzureOperationResponse <DomainAvailablilityCheckResult> > CheckDomainAvailabilityWithHttpMessagesAsync(NameIdentifier identifier, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (identifier == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "identifier");
}
if (this.Client.SubscriptionId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId");
}
if (this.Client.ApiVersion == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("identifier", identifier);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "CheckDomainAvailability", tracingParameters);
}
// Construct URL
var _baseUrl = this.Client.BaseUri.AbsoluteUri;
var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/providers/Microsoft.DomainRegistration/checkDomainAvailability").ToString();
_url = _url.Replace("{subscriptionId}", Uri.EscapeDataString(this.Client.SubscriptionId));
List <string> _queryParameters = new List <string>();
if (this.Client.ApiVersion != null)
{
_queryParameters.Add(string.Format("api-version={0}", Uri.EscapeDataString(this.Client.ApiVersion)));
}
if (_queryParameters.Count > 0)
{
_url += "?" + string.Join("&", _queryParameters);
}
// Create HTTP transport objects
HttpRequestMessage _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new Uri(_url);
// Set Headers
if (this.Client.GenerateClientRequestId != null && this.Client.GenerateClientRequestId.Value)
{
_httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", Guid.NewGuid().ToString());
}
if (this.Client.AcceptLanguage != null)
{
if (_httpRequest.Headers.Contains("accept-language"))
{
_httpRequest.Headers.Remove("accept-language");
}
_httpRequest.Headers.TryAddWithoutValidation("accept-language", this.Client.AcceptLanguage);
}
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
_requestContent = SafeJsonConvert.SerializeObject(identifier, this.Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
// Set Credentials
if (this.Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new CloudException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
CloudError _errorBody = SafeJsonConvert.DeserializeObject <CloudError>(_responseContent, this.Client.DeserializationSettings);
if (_errorBody != null)
{
ex = new CloudException(_errorBody.Message);
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
ex.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new AzureOperationResponse <DomainAvailablilityCheckResult>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_httpResponse.Headers.Contains("x-ms-request-id"))
{
_result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <DomainAvailablilityCheckResult>(_responseContent, this.Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public ExportableSceneObject(SceneObject sceneObject)
{
Name = sceneObject.Name;
Attributes = sceneObject.Attributes;
}
/// <summary>
/// List all apps that are assigned to a hostname.
/// </summary>
/// <remarks>
/// List all apps that are assigned to a hostname.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='nameIdentifier'>
/// Hostname information.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <IPage <Identifier> > ListSiteIdentifiersAssignedToHostNameAsync(this IWebSiteManagementClient operations, NameIdentifier nameIdentifier, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ListSiteIdentifiersAssignedToHostNameWithHttpMessagesAsync(nameIdentifier, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public override void SetName(string name) => NameIdentifier.ReplaceIdentifier(name);
public record UserCreated(Guid Id, string NameIdentifier, string FirstName, string LastName) : IdentityAdded(NameIdentifier, FirstName, LastName);
