public void RegisterForRemoteNotifications()
{
if (this.notificationManager == null)
{
return;
}
this.notificationManager.RegisterForRemoteNotifications();
string deviceToken = this.notificationManager.GetDeviceToken();
if (!string.IsNullOrEmpty(deviceToken))
{
RegisterDeviceRequest registerDeviceRequest = new RegisterDeviceRequest();
registerDeviceRequest.DeviceToken = deviceToken;
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
if (currentPlayer == null)
{
Service.Get <StaRTSLogger>().Warn("Trying to register for remote notification before CurrentPlayer is available");
return;
}
registerDeviceRequest.PlayerId = currentPlayer.PlayerId;
RegisterDeviceCommand registerDeviceCommand = new RegisterDeviceCommand(registerDeviceRequest);
registerDeviceCommand.AddSuccessCallback(new AbstractCommand <RegisterDeviceRequest, RegisterDeviceResponse> .OnSuccessCallback(this.OnRegisterSuccess));
if (!Service.Get <ServerAPI>().Enabled&& Service.Get <CurrentPlayer>().CampaignProgress.FueInProgress)
{
Service.Get <ServerAPI>().Enabled = true;
}
Service.Get <ServerAPI>().Sync(registerDeviceCommand);
Service.Get <BILoggingController>().TrackNetworkMappingInfo("ur", deviceToken);
}
}
public RegisterDeviceResponse RegisterDevice(RegisterDeviceRequest request)
{
AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
RegisterDeviceHeaders headers = new RegisterDeviceHeaders();
return(RegisterDeviceWithOptions(request, headers, runtime));
}
public async Task <RegisterDeviceResponse> RegisterDeviceAsync(RegisterDeviceRequest request)
{
AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
RegisterDeviceHeaders headers = new RegisterDeviceHeaders();
return(await RegisterDeviceWithOptionsAsync(request, headers, runtime));
}
internal virtual RegisterDeviceResponse RegisterDevice(RegisterDeviceRequest request)
{
var marshaller = RegisterDeviceRequestMarshaller.Instance;
var unmarshaller = RegisterDeviceResponseUnmarshaller.Instance;
return(Invoke <RegisterDeviceRequest, RegisterDeviceResponse>(request, marshaller, unmarshaller));
}
public void RegisterForRemoteNotifications()
{
if (this.notificationManager == null)
{
return;
}
this.notificationManager.RegisterForRemoteNotifications();
string deviceToken = this.notificationManager.GetDeviceToken();
RegisterDeviceRequest registerDeviceRequest = new RegisterDeviceRequest();
registerDeviceRequest.DeviceToken = deviceToken;
CurrentPlayer currentPlayer = Service.CurrentPlayer;
if (currentPlayer == null)
{
Service.Logger.Warn("Trying to register for remote notification before CurrentPlayer is available");
return;
}
registerDeviceRequest.PlayerId = currentPlayer.PlayerId;
RegisterDeviceCommand registerDeviceCommand = new RegisterDeviceCommand(registerDeviceRequest);
registerDeviceCommand.AddSuccessCallback(new AbstractCommand <RegisterDeviceRequest, RegisterDeviceResponse> .OnSuccessCallback(this.OnRegisterSuccess));
if (!Service.ServerAPI.Enabled && Service.CurrentPlayer.CampaignProgress.FueInProgress)
{
Service.ServerAPI.Enabled = true;
}
Service.ServerAPI.Sync(registerDeviceCommand);
}
/// <summary>
/// 注册设备
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
/// <remarks></remarks>
public RegisterDevicesResult RegisterDevice(RegisterDeviceRequest request)
{
var result = new RegisterDevicesResult();
var device = CreateDevice(request);
return(RegisterDevice(device));
}
public async Task <ResponseDTO> Register(RegisterDeviceRequest device)
{
if (ModelState.IsValid)
{
return(await _deviceApplicationService.RegisterDeviceAsync(device));
}
return(ModelState.ToResponse());
}
/// <summary>
/// Initiates the asynchronous execution of the RegisterDevice operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RegisterDevice operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/cognito-sync-2014-06-30/RegisterDevice">REST API Reference for RegisterDevice Operation</seealso>
public virtual Task <RegisterDeviceResponse> RegisterDeviceAsync(RegisterDeviceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = RegisterDeviceRequestMarshaller.Instance;
var unmarshaller = RegisterDeviceResponseUnmarshaller.Instance;
return(InvokeAsync <RegisterDeviceRequest, RegisterDeviceResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public virtual Device CreateDevice(RegisterDeviceRequest request)
{
var result = new Device()
{
AppId = request.AppId, DeviceToken = request.DeviceToken, DeviceType = request.DeviceType
};
return(result);
}
internal virtual RegisterDeviceResponse RegisterDevice(RegisterDeviceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterDeviceRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterDeviceResponseUnmarshaller.Instance;
return(Invoke <RegisterDeviceResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the RegisterDevice operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RegisterDevice operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/cognito-sync-2014-06-30/RegisterDevice">REST API Reference for RegisterDevice Operation</seealso>
public virtual Task <RegisterDeviceResponse> RegisterDeviceAsync(RegisterDeviceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterDeviceRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterDeviceResponseUnmarshaller.Instance;
return(InvokeAsync <RegisterDeviceResponse>(request, options, cancellationToken));
}
public async Task <RegisterDeviceResponse> RegisterDeviceWithOptionsAsync(RegisterDeviceRequest request, RegisterDeviceHeaders headers, AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime)
{
AlibabaCloud.TeaUtil.Common.ValidateModel(request);
Dictionary <string, object> body = new Dictionary <string, object>()
{
};
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.Collaborators))
{
body["collaborators"] = request.Collaborators;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DepartmentId))
{
body["departmentId"] = request.DepartmentId;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.Description))
{
body["description"] = request.Description;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DeviceKey))
{
body["deviceKey"] = request.DeviceKey;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DeviceName))
{
body["deviceName"] = request.DeviceName;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.Managers))
{
body["managers"] = request.Managers;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.UserId))
{
body["userId"] = request.UserId;
}
Dictionary <string, string> realHeaders = new Dictionary <string, string>()
{
};
if (!AlibabaCloud.TeaUtil.Common.IsUnset(headers.CommonHeaders))
{
realHeaders = headers.CommonHeaders;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(headers.XAcsDingtalkAccessToken))
{
realHeaders["x-acs-dingtalk-access-token"] = AlibabaCloud.TeaUtil.Common.ToJSONString(headers.XAcsDingtalkAccessToken);
}
AlibabaCloud.OpenApiClient.Models.OpenApiRequest req = new AlibabaCloud.OpenApiClient.Models.OpenApiRequest
{
Headers = realHeaders,
Body = AlibabaCloud.OpenApiUtil.Client.ParseToMap(body),
};
return(TeaModel.ToObject <RegisterDeviceResponse>(await DoROARequestAsync("RegisterDevice", "devicemng_1.0", "HTTP", "POST", "AK", "/v1.0/devicemng/devices", "json", req, runtime)));
}
public async Task RegisterDevice_Call()
{
//-------------- Arrange -------------
CommonArrangements();
var request = new RegisterDeviceRequest();
var command = new RegisterDeviceCommand();
A.CallTo(() => mapper.Map <RegisterDeviceRequest, RegisterDeviceCommand>(request)).Returns(command);
//-------------- Act -------------
var resp = deviceService.RegisterDeviceAsync(request);
//-------------- Assert -------------
A.CallTo(() => bus.SendAsync(command)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <IActionResult> CreateDevice([FromBody] RegisterDeviceRequest request)
{
var user = await UserManager.GetUserAsync(User);
if (user == null)
{
return(NotFound());
}
var device = await DbContext.UserDevices.SingleOrDefaultAsync(x => x.UserId == user.Id && x.DeviceId == request.DeviceId);
if (device is not null)
{
ModelState.AddModelError(nameof(request.DeviceId), $"A device with id {request.DeviceId} already exists.");
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
var shouldEnablePushNotifications = !string.IsNullOrWhiteSpace(request.PnsHandle);
if (shouldEnablePushNotifications)
{
try {
await PushNotificationService.Register(request.DeviceId, request.PnsHandle, request.Platform, user.Id, request.Tags?.ToArray());
} catch (Exception exception) {
Logger.LogError("An exception occurred when connection to Azure Notification Hubs. Exception is '{Exception}'. Inner Exception is '{InnerException}'.", exception.Message, exception.InnerException?.Message ?? "N/A");
throw;
}
}
device = new UserDevice {
DeviceId = request.DeviceId,
Name = request.Name,
Platform = request.Platform,
IsPushNotificationsEnabled = shouldEnablePushNotifications,
UserId = user.Id,
DateCreated = DateTimeOffset.UtcNow,
Model = request.Model,
OsVersion = request.OsVersion,
Data = request.Data
};
DbContext.UserDevices.Add(device);
await DbContext.SaveChangesAsync();
var response = DeviceInfo.FromUserDevice(device);
var @event = new DeviceCreatedEvent(response, SingleUserInfo.FromUser(user));
await EventService.Publish(@event);
return(CreatedAtAction(nameof(GetDeviceById), new { deviceId = device.DeviceId }, response));
}
public async Task <ResponseDTO> RegisterDeviceAsync(RegisterDeviceRequest newDevice)
{
//Map to Command
var command = _mapper.Map <RegisterDeviceRequest, RegisterDeviceCommand>(newDevice);
var response = await ValidateCellphoneAndUser(newDevice.CellphoneNumber, newDevice.AssignedAmigoTenantTUserId);
if (response.IsValid)
{
//Execute Command
var resp = await _bus.SendAsync(command);
ResponseBuilder.Correct(resp);
}
return(response);
}
/// <summary>
/// Initiates the asynchronous execution of the RegisterDevice operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the RegisterDevice operation on AmazonCognitoSyncClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void RegisterDeviceAsync(RegisterDeviceRequest request, AmazonServiceCallback <RegisterDeviceRequest, RegisterDeviceResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new RegisterDeviceRequestMarshaller();
var unmarshaller = RegisterDeviceResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <RegisterDeviceRequest, RegisterDeviceResponse> responseObject
= new AmazonServiceResult <RegisterDeviceRequest, RegisterDeviceResponse>((RegisterDeviceRequest)req, (RegisterDeviceResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <RegisterDeviceRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
//在某一产品下创建一台设备
public void TestRegisterDevice()
{
DefaultAcsClient acsClient = Demo.IotClient.GetClient();
RegisterDeviceRequest request = new RegisterDeviceRequest();
request.ProductKey = "<productKey>";
request.DeviceName = "device0822";
RegisterDeviceResponse response = acsClient.GetAcsResponse(request);
Console.WriteLine(response.Success);
Console.WriteLine(response.ErrorMessage);
RegisterDeviceResponse.RegisterDevice_Data device = response.Data;
Console.WriteLine("Device IotId: " + device.IotId);
Console.WriteLine("Device Secret: " + device.DeviceSecret);
Console.WriteLine("Device Name: " + device.DeviceName);
}
protected override async Task <Entity> CreateNewAsync(ApiOptions options)
{
// Create a new object
var request = new RegisterDeviceRequest()
{
Device = this
};
ApiOptions.Apply(request, options);
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
{
throw response.Status.ToFault();
}
// 3. Update the last known state based on the differences
Debug.Assert(response.Device != null, "If status is successful, then created device should not be null.");
return(response.Device);
}
/// <summary>
/// Подписывает приложение на получение Push-уведомлений.
/// </summary>
/// <param name="updateChanel">Требуется ли обновить канал получения уведомлений.</param>
public static async Task <bool> Connect(bool updateChanel = false)
{
if (_chanel == null)
{
_chanel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
_chanel.PushNotificationReceived += chanel_PushNotificationReceived;
}
var request = new RegisterDeviceRequest(_chanel.Uri)
{
DeviceID = CoreHelper.GetUniqueDeviceID(),
DeviceModel = CoreHelper.GetDeviceName(),
Subscribe = new List <VKSubscribeTypes>
{
VKSubscribeTypes.Friend, VKSubscribeTypes.Group,
VKSubscribeTypes.Like, VKSubscribeTypes.Mention,
VKSubscribeTypes.Message, VKSubscribeTypes.Reply
}
};
var result = await request.ExecuteAsync();
return(result.Error.ErrorType == VKErrors.None ? true : false);
}
protected override async Task<Entity> CreateNewAsync(ApiOptions options)
{
// Create a new object
var request = new RegisterDeviceRequest() { Device = this };
ApiOptions.Apply(request, options);
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
throw response.Status.ToFault();
// 3. Update the last known state based on the differences
Debug.Assert(response.Device != null, "If status is successful, then created device should not be null.");
return response.Device;
}
public async Task <RegisterDeviceResponse> RegisterDeviceWithOptionsAsync(RegisterDeviceRequest request, RegisterDeviceHeaders headers, AlibabaCloud.TeaUtil.Models.RuntimeOptions runtime)
{
AlibabaCloud.TeaUtil.Common.ValidateModel(request);
Dictionary <string, object> body = new Dictionary <string, object>()
{
};
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.CorpId))
{
body["corpId"] = request.CorpId;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DeviceName))
{
body["deviceName"] = request.DeviceName;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DeviceStatus))
{
body["deviceStatus"] = request.DeviceStatus;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DeviceType))
{
body["deviceType"] = request.DeviceType;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.DeviceTypeName))
{
body["deviceTypeName"] = request.DeviceTypeName;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.Id))
{
body["id"] = request.Id;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.LiveUrls.ToMap()))
{
body["liveUrls"] = request.LiveUrls;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.Location))
{
body["location"] = request.Location;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.NickName))
{
body["nickName"] = request.NickName;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.ParentId))
{
body["parentId"] = request.ParentId;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(request.ProductType))
{
body["productType"] = request.ProductType;
}
Dictionary <string, string> realHeaders = new Dictionary <string, string>()
{
};
if (!AlibabaCloud.TeaUtil.Common.IsUnset(headers.CommonHeaders))
{
realHeaders = headers.CommonHeaders;
}
if (!AlibabaCloud.TeaUtil.Common.IsUnset(headers.XAcsDingtalkAccessToken))
{
realHeaders["x-acs-dingtalk-access-token"] = AlibabaCloud.TeaUtil.Common.ToJSONString(headers.XAcsDingtalkAccessToken);
}
AlibabaCloud.OpenApiClient.Models.OpenApiRequest req = new AlibabaCloud.OpenApiClient.Models.OpenApiRequest
{
Headers = realHeaders,
Body = AlibabaCloud.OpenApiUtil.Client.ParseToMap(body),
};
return(TeaModel.ToObject <RegisterDeviceResponse>(await DoROARequestAsync("RegisterDevice", "diot_1.0", "HTTP", "POST", "AK", "/v1.0/diot/devices/register", "json", req, runtime)));
}
public async Task <RegisterDeviceResponse> RegisterDeviceAsync(RegisterDeviceRequest registerDeviceRequest)
{
return(await _onenetClient.ExecuteAsync <RegisterDeviceResponse>(registerDeviceRequest));
}
public async Task <ResponseData <TokenInfo> > RegisterDevice([FromBody] RegisterDeviceRequest request)
{
var response = new ResponseData <TokenInfo>();
try
{
var email = $"{request.DeviceId}@mobile.device";
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
var password = Guid.NewGuid().ToString().Replace("-", "");
user = new ApplicationUser
{
Id = Guid.NewGuid(),
OS = request.OS,
DeviceId = request.DeviceId,
Email = email,
EmailConfirmed = true,
UserName = email
};
await _userManager.CreateAsync(user, password);
_context.Add(new XUserInfo
{
name = "App",
family = "Mobile",
login = user.Id.ToString(),
XUserInfoId = user.Id
});
await _context.SaveChangesAsync();
}
await _userManager.AddToRoleAsync(user, MyIdentityRole.ROLE_MOBILEAPP);
await _signInManager.SignInAsync(user, false);
var currentUser = user;
string encodedJwt = await CreateToken(currentUser);
// Serialize and return the response
var oldTokens = await _identityContext.RefreshTokens.
Where(p => p.UserId == currentUser.Id && p.IsExpired).
ToListAsync();
oldTokens.ForEach(p => { p.IsExpired = true; });
var refresh_token = Guid.NewGuid().ToString().Replace("-", "");
var refreshToken = new RefreshToken
{
Id = Guid.NewGuid(),
UserId = currentUser.Id,
Token = refresh_token,
DateIssued = DateTime.Now,
IsExpired = false,
};
response.code = BaseStatus.Success;
response.data = new TokenInfo
{
access_token = encodedJwt,
expires_in = (int)_jwtOptions.ValidFor.TotalSeconds,
token_type = "jwt",
refresh_token = refresh_token
};
_identityContext.Add(refreshToken);
await _identityContext.SaveChangesAsync();
}
catch (Exception ex)
{
response.code = BaseStatus.Exception;
response.data = null;
response.message = ex.Message;
response.description = "Не удалось зарегистрироваться ";
}
return(response);
}
