// POST api/values
public async Task<IHttpActionResult> Post(DeviceRegistrationRequest request)
{
var registrationKeyStorage = new RegistrationKeyStorage(ConfigurationManager.AppSettings["StorageConnectionString"]);
var registrationKey = registrationKeyStorage.GetRegistrationKey(request.RegistrationKey);
if (registrationKey != null
&& registrationKey.ValidUntil > DateTime.UtcNow
&& !registrationKey.UsedOn.HasValue)
{
registrationKey.UsedOn = DateTime.UtcNow;
await registrationKeyStorage.UpdateRegistrationKey(registrationKey);
var registryManager = RegistryManager.CreateFromConnectionString(ConfigurationManager.AppSettings["IoTHubConnectionString"]);
try
{
var device = await registryManager.AddDeviceAsync(new Device(request.DeviceId));
var iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(ConfigurationManager.AppSettings["IoTHubConnectionString"]);
return Ok(new DeviceRegistrationResponse
{
HostName = iotHubConnectionStringBuilder.HostName,
AccessKey = device.Authentication.SymmetricKey.PrimaryKey
});
}
catch (DeviceAlreadyExistsException)
{
}
}
return BadRequest();
}
// POST api/values
public async Task <IHttpActionResult> Post(DeviceRegistrationRequest request)
{
var registrationKeyStorage = new RegistrationKeyStorage(ConfigurationManager.AppSettings["StorageConnectionString"]);
var registrationKey = registrationKeyStorage.GetRegistrationKey(request.RegistrationKey);
if (registrationKey != null &&
registrationKey.ValidUntil > DateTime.UtcNow &&
!registrationKey.UsedOn.HasValue)
{
registrationKey.UsedOn = DateTime.UtcNow;
await registrationKeyStorage.UpdateRegistrationKey(registrationKey);
var registryManager = RegistryManager.CreateFromConnectionString(ConfigurationManager.AppSettings["IoTHubConnectionString"]);
try
{
var device = await registryManager.AddDeviceAsync(new Device(request.DeviceId));
var iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(ConfigurationManager.AppSettings["IoTHubConnectionString"]);
return(Ok(new DeviceRegistrationResponse
{
HostName = iotHubConnectionStringBuilder.HostName,
AccessKey = device.Authentication.SymmetricKey.PrimaryKey
}));
}
catch (DeviceAlreadyExistsException)
{
}
}
return(BadRequest());
}
public async Task <IActionResult> UnsubscribePushNotification([FromBody] string DeviceID)
{
ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User);
DeviceRegistrationRequest Request = new DeviceRegistrationRequest();
CommunicationResponse Response = new CommunicationResponse();
try
{
if (user == null)
{
Response.ReturnCode = enResponseCode.Fail;
Response.ReturnMsg = EnResponseMessage.StandardLoginfailed;
Response.ErrorCode = enErrorCode.StandardLoginfailed;
}
else
{
Request.DeviceID = DeviceID;
Request.UserID = user.Id;
Request.SubsscrptionType = EnDeviceSubsscrptionType.UnSubsscribe;
Response = await _mediator.Send(Request);
}
return(Ok(Response));
}
catch (Exception ex)
{
Response.ReturnCode = enResponseCode.InternalError;
return(BadRequest(new BizResponseClass {
ReturnCode = enResponseCode.InternalError, ReturnMsg = ex.ToString(), ErrorCode = enErrorCode.Status500InternalServerError
}));
}
}
private static ClientCredentials RegisterDevice(Guid applicationId, Uri issuerUri, DeviceUserName userName)
{
bool doContinue = true;
int attempt = 1;
while (doContinue)
{
string environment = DiscoverEnvironment(issuerUri);
LiveDevice device = new LiveDevice()
{
User = userName, Version = 1
};
DeviceRegistrationRequest request = new DeviceRegistrationRequest(applicationId, device);
string url = string.Format(CultureInfo.InvariantCulture, LiveIdConstants.RegistrationEndpointUriFormat,
string.IsNullOrWhiteSpace(environment) ? null : "-" + environment);
try
{
DeviceRegistrationResponse response = ExecuteRegistrationRequest(url, request);
if (!response.IsSuccess)
{
throw new DeviceRegistrationFailedException(response.RegistrationErrorCode.GetValueOrDefault(), response.ErrorSubCode);
}
WriteDevice(environment, device);
}
catch (Exception error)
{
if (error.Message.ToLower().Contains("unknown"))
{
if (attempt > 3)
{
if (MessageBox.Show("Failed to connect 3 times.\r\n\r\nDo you want to retry?", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
{
doContinue = false;
}
}
attempt++;
}
else
{
throw error;
}
}
return(device.User.ToClientCredentials());
}
return(null);
}
private static ClientCredentials RegisterDevice(Guid applicationId, Uri issuerUri, DeviceUserName userName)
{
var text = DeviceIdManager.DiscoverEnvironment(issuerUri);
var liveDevice = new LiveDevice
{
User = userName,
Version = 1
};
var registrationRequest = new DeviceRegistrationRequest(applicationId, liveDevice);
var deviceRegistrationResponse = DeviceIdManager.ExecuteRegistrationRequest(string.Format(CultureInfo.InvariantCulture, "https://login.live{0}.com/ppsecure/DeviceAddCredential.srf", string.IsNullOrWhiteSpace(text) ? null : ("-" + text)), registrationRequest);
if (!deviceRegistrationResponse.IsSuccess)
{
throw new DeviceRegistrationFailedException((Microsoft.Xrm.Tooling.Connector.DeviceRegistrationErrorCode)deviceRegistrationResponse.Error.RegistrationErrorCode, deviceRegistrationResponse.ErrorSubCode);
}
DeviceIdManager.WriteDevice(text, liveDevice);
return(liveDevice.User.ToClientCredentials());
}
private static ClientCredentials RegisterDevice(Guid applicationId, Uri issuerUri, LiveDevice device)
{
EnvironmentConfiguration environment = DiscoverEnvironmentInternal(issuerUri);
DeviceRegistrationRequest request = new DeviceRegistrationRequest(applicationId, device);
string url = string.Format(CultureInfo.InvariantCulture, LiveIdConstants.RegistrationEndpointUriFormat,
environment.HostName);
DeviceRegistrationResponse response = ExecuteRegistrationRequest(url, request);
if (!response.IsSuccess)
{
bool throwException = true;
if (DeviceRegistrationErrorCode.DeviceAlreadyExists == response.Error.RegistrationErrorCode)
{
if (!PersistToFile)
{
//If the file is not persisted, the registration will always occur (since the credentials are not
//persisted to the disk. However, the credentials may already exist. To avoid an exception being continually
//processed by the calling user, DeviceAlreadyExists will be ignored if the credentials are not persisted to the disk.
return(device.User.ToClientCredentials());
}
else if (PersistIfDeviceAlreadyExists)
{
// This flag indicates that the
throwException = false;
}
}
if (throwException)
{
throw new DeviceRegistrationFailedException(response.Error.RegistrationErrorCode, response.ErrorSubCode);
}
}
if (PersistToFile || PersistIfDeviceAlreadyExists)
{
WriteDevice(environment, device);
}
return(device.User.ToClientCredentials());
}
public async Task <IActionResult> Register(DeviceRegistrationRequest registration)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (TryExtractPlatform(out MobilePlatform platform))
{
var registrationId = await _pushNotificationService.CreateRegistrationId(registration.Handle);
await _pushNotificationService.Register(platform, registration.Handle, registrationId, new[] { registration.Tag });
return(Ok(new DeviceRegistrationResult {
RegistrationId = registrationId
}));
}
return(BadRequest("Unknown device platform or missing user-agent."));
}
private static DeviceRegistrationResponse ExecuteRegistrationRequest(string url, DeviceRegistrationRequest registrationRequest)
{
//Create the request that will submit the request to the server
WebRequest request = WebRequest.Create(url);
request.ContentType = "application/soap+xml; charset=UTF-8";
request.Method = "POST";
request.Timeout = 180000;
request.Proxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
//Write the envelope to the RequestStream
using (Stream stream = request.GetRequestStream())
{
Serialize(stream, registrationRequest);
}
// Read the response into an XmlDocument and return that doc
try
{
using (WebResponse response = request.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
return(Deserialize <DeviceRegistrationResponse>(stream));
}
}
}
catch (WebException ex)
{
if (null != ex.Response)
{
using (Stream stream = ex.Response.GetResponseStream())
{
return(Deserialize <DeviceRegistrationResponse>(stream));
}
}
throw;
}
}
private async Task Authenticate(string accessToken)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("User-Agent", "AGSLauncher/1.0.0");
var reqData = new DeviceRegistrationRequest();
reqData.auth_data.access_token = accessToken;
reqData.registration_data.app_name = "AGSLauncher for Windows";
reqData.registration_data.app_version = "1.0.0";
reqData.registration_data.device_model = "Windows";
reqData.registration_data.device_serial = Computer.GetMachineGuid().ToString("N");
reqData.registration_data.device_type = "A2UMVHOX7UP4V7";
reqData.registration_data.domain = "Device";
reqData.registration_data.os_version = Environment.OSVersion.Version.ToString(4);
reqData.requested_extensions = new List <string> {
"customer_info", "device_info"
};
reqData.requested_token_type = new List <string> {
"bearer", "mac_dms"
};
var authPostContent = Serialization.ToJson(reqData, true);
var authResponse = await client.PostAsync(
@"https://api.amazon.com/auth/register",
new StringContent(authPostContent, Encoding.UTF8, "application/json"));
var authResponseContent = await authResponse.Content.ReadAsStringAsync();
var authData = Serialization.FromJson <DeviceRegistrationResponse>(authResponseContent);
if (authData.response?.success != null)
{
FileSystem.WriteStringToFile(tokensPath, Serialization.ToJson(authData.response.success.tokens.bearer));
}
}
}
private static DeviceRegistrationResponse ExecuteRegistrationRequest(string url, DeviceRegistrationRequest registrationRequest)
{
var webRequest = WebRequest.Create(url);
webRequest.ContentType = "application/soap+xml; charset=UTF-8";
webRequest.Method = "POST";
webRequest.Timeout = 180000;
using (var requestStream = webRequest.GetRequestStream())
{
DeviceIdManager.Serialize <DeviceRegistrationRequest>(requestStream, registrationRequest);
}
DeviceRegistrationResponse result;
try
{
using (var response = webRequest.GetResponse())
{
using (var responseStream = response.GetResponseStream())
{
result = DeviceIdManager.Deserialize <DeviceRegistrationResponse>(responseStream);
}
}
}
catch (WebException ex)
{
if (ex.Response != null)
{
using (var responseStream2 = ex.Response.GetResponseStream())
{
return(DeviceIdManager.Deserialize <DeviceRegistrationResponse>(responseStream2));
}
}
throw;
}
return(result);
}
private static DeviceRegistrationResponse ExecuteRegistrationRequest(string url, DeviceRegistrationRequest registrationRequest)
{
//Create the request that will submit the request to the server
WebRequest request = WebRequest.Create(url);
request.ContentType = "application/soap+xml; charset=UTF-8";
request.Method = "POST";
request.Timeout = 180000;
//Write the envelope to the RequestStream
using (Stream stream = request.GetRequestStream()) {
Serialize(stream, registrationRequest);
}
// Read the response into an XmlDocument and return that doc
try {
using (WebResponse response = request.GetResponse()) {
using (Stream stream = response.GetResponseStream()) {
return(Deserialize <DeviceRegistrationResponse>("Deserializing Registration Response", stream));
}
}
} catch (WebException ex) {
System.Diagnostics.Trace.TraceError("Microsoft account Device Registration Failed (HTTP Code: {0}): {1}",
ex.Status, ex.Message);
if (null != ex.Response)
{
using (Stream stream = ex.Response.GetResponseStream()) {
return(Deserialize <DeviceRegistrationResponse>("Deserializing Failed Registration Response", stream));
}
}
throw;
}
}
public async Task <IActionResult> RegisterDevice([FromRoute] string DeviceId, [FromBody] DeviceRegistrationRequest deviceRegistrationRequest)
{
try
{
if (deviceRegistrationRequest.DeviceId != DeviceId)
{
throw new ApplicationException("The device id posted does not correspond to the device id specified in the URL.");
}
throw new NotImplementedException("Devices registration is not available at the moment.");
}
catch (Exception exc)
{
return(await Task.Run(() => StatusCode(StatusCodes.Status501NotImplemented, exc)));
}
// return Ok();
}
