public Task Init(Func<PushContext, Task> pipe, CriticalError criticalError, PushSettings settings)
{
pipeline = pipe;
path = BaseDirectoryBuilder.BuildBasePath(settings.InputQueue);
purgeOnStartup = settings.PurgeOnStartup;
return TaskEx.CompletedTask;
}
public Task Init(Func <PushContext, Task> pipe, CriticalError criticalError, PushSettings settings)
{
pipeline = pipe;
path = BaseDirectoryBuilder.BuildBasePath(settings.InputQueue);
purgeOnStartup = settings.PurgeOnStartup;
return(TaskEx.CompletedTask);
}
public async Task <bool> NotificationDeleteAsync(Ekreta.Mobile.Core.Models.Profile profile, bool useGlobalMobileApiV1 = false)
{
if (profile == null)
{
throw new ArgumentNullException(nameof(profile));
}
PushSettings pushSettings;
try
{
pushSettings = await this._globalMobileApi.NotificationDeleteAsync(profile?.PushSettings?.RegistrationId, NotificationMessageSource.Kreta, useGlobalMobileApiV1);
}
catch (KeyNotFoundException ex)
{
profile.PushSettings = (PushSettings)null;
this._profileRepository.AddOrUpdate(profile);
pushSettings = new PushSettings();
}
if (pushSettings != null)
{
pushSettings.FirstTimePushRun = true;
pushSettings.UpdateEugyintezes = true;
profile.PushSettings = pushSettings;
this._profileRepository.AddOrUpdate(profile);
}
return(pushSettings != null);
}
void AddReceivers(IBuilder builder, RecoverabilityExecutorFactory recoverabilityExecutorFactory)
{
var requiredTransactionSupport = configuration.TransactionMode;
var recoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(eventAggregator, configuration.LocalAddress);
var pushSettings = new PushSettings(configuration.LocalAddress, errorQueue, configuration.PurgeOnStartup, requiredTransactionSupport);
var dequeueLimitations = configuration.PushRuntimeSettings;
receivers.Add(new TransportReceiver(MainReceiverId, BuildMessagePump(), pushSettings, dequeueLimitations, mainPipelineExecutor, recoverabilityExecutor, criticalError));
if (configuration.InstanceSpecificQueue != null)
{
var instanceSpecificQueue = configuration.InstanceSpecificQueue;
var instanceSpecificRecoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(eventAggregator, instanceSpecificQueue);
var sharedReceiverPushSettings = new PushSettings(instanceSpecificQueue, errorQueue, configuration.PurgeOnStartup, requiredTransactionSupport);
receivers.Add(new TransportReceiver(MainReceiverId, BuildMessagePump(), sharedReceiverPushSettings, dequeueLimitations, mainPipelineExecutor, instanceSpecificRecoverabilityExecutor, criticalError));
}
foreach (var satellitePipeline in configuration.SatelliteDefinitions)
{
var satelliteRecoverabilityExecutor = recoverabilityExecutorFactory.Create(satellitePipeline.RecoverabilityPolicy, eventAggregator, satellitePipeline.ReceiveAddress);
var satellitePushSettings = new PushSettings(satellitePipeline.ReceiveAddress, errorQueue, configuration.PurgeOnStartup, satellitePipeline.RequiredTransportTransactionMode);
receivers.Add(new TransportReceiver(satellitePipeline.Name, BuildMessagePump(), satellitePushSettings, satellitePipeline.RuntimeSettings, new SatellitePipelineExecutor(builder, satellitePipeline), satelliteRecoverabilityExecutor, criticalError));
}
}
private async void InitializeNotificationChannel()
{
#region UI logic
this.InitializePushButton.IsEnabled = false;
this.PushStatusTextBlock.Text = "initializing...";
this.PushStatusTextBlock.Foreground = new SolidColorBrush(Colors.Orange);
this.ShowProgress();
#endregion
try
{
//initialize push functionality
var pushSettings = new PushSettings()
{
AutoBindToShellTile = true,
AutoBindToShellToast = true,
ServiceName = ConnectionSettings.PushServiceName
};
this.initializationResult = await this.app.WorkWith().Push().CurrentDevice.Initialize(pushSettings).ExecuteAsync();
this.OnPushTokenAvailable();
}
catch (Exception ex)
{
MessageBox.Show("There was an error initializing the push functionality.");
this.InitializePushButton.IsEnabled = true;
this.PushStatusTextBlock.Text = "error";
this.PushStatusTextBlock.Foreground = new SolidColorBrush(Colors.Red);
}
}
List <TransportReceiver> BuildMainReceivers(string errorQueue, bool purgeOnStartup, TransportTransactionMode requiredTransactionSupport, RecoverabilityExecutorFactory recoverabilityExecutorFactory, IPipeline <ITransportReceiveContext> mainPipeline)
{
var localAddress = settings.LocalAddress();
var distributorAddress = settings.GetOrDefault <string>("LegacyDistributor.Address");
var recoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(eventAggregator, distributorAddress ?? localAddress);
var pushSettings = new PushSettings(settings.LocalAddress(), errorQueue, purgeOnStartup, requiredTransactionSupport);
var mainPipelineExecutor = new MainPipelineExecutor(builder, eventAggregator, pipelineCache, mainPipeline);
var dequeueLimitations = GetDequeueLimitationsForReceivePipeline();
var receivers = new List <TransportReceiver>();
receivers.Add(new TransportReceiver(MainReceiverId, builder.Build <IPushMessages>(), pushSettings, dequeueLimitations, mainPipelineExecutor, recoverabilityExecutor, criticalError));
if (settings.InstanceSpecificQueue() != null)
{
var instanceSpecificQueue = settings.InstanceSpecificQueue();
var instanceSpecificRecoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(eventAggregator, instanceSpecificQueue);
var sharedReceiverPushSettings = new PushSettings(settings.InstanceSpecificQueue(), errorQueue, purgeOnStartup, requiredTransactionSupport);
receivers.Add(new TransportReceiver(MainReceiverId, builder.Build <IPushMessages>(), sharedReceiverPushSettings, dequeueLimitations, mainPipelineExecutor, instanceSpecificRecoverabilityExecutor, criticalError));
}
return(receivers);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var realmSettings = new RealmSettings();
Configuration.Bind("RealmOptions", realmSettings);
var tweetSettings = new TweetSettings();
Configuration.Bind("TweetOptions", tweetSettings);
var pushSettings = new PushSettings();
Configuration.Bind("PushOptions", pushSettings);
services.AddSingleton(realmSettings);
services.AddSingleton(tweetSettings);
services.AddSingleton(pushSettings);
services.AddScoped <PushNotificationsManager>();
services
.AddControllers()
.AddNewtonsoftJson();
services.AddOpenApiDocument(document => document.DocumentName = "DotNetRu App API");
}
public Task Init(Func<MessageContext, Task> onMessage, Func<ErrorContext, Task<ErrorHandleResult>> onError, CriticalError criticalError, PushSettings settings)
{
peekCircuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("MsmqPeek", TimeSpan.FromSeconds(30), ex => criticalError.Raise("Failed to peek " + settings.InputQueue, ex));
receiveCircuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("MsmqReceive", TimeSpan.FromSeconds(30), ex => criticalError.Raise("Failed to receive from " + settings.InputQueue, ex));
var inputAddress = MsmqAddress.Parse(settings.InputQueue);
var errorAddress = MsmqAddress.Parse(settings.ErrorQueue);
if (!string.Equals(inputAddress.Machine, RuntimeEnvironment.MachineName, StringComparison.OrdinalIgnoreCase))
{
throw new Exception($"MSMQ Dequeuing can only run against the local machine. Invalid inputQueue name '{settings.InputQueue}'.");
}
inputQueue = new MessageQueue(inputAddress.FullPath, false, true, QueueAccessMode.Receive);
errorQueue = new MessageQueue(errorAddress.FullPath, false, true, QueueAccessMode.Send);
if (settings.RequiredTransactionMode != TransportTransactionMode.None && !QueueIsTransactional())
{
throw new ArgumentException($"Queue must be transactional if you configure the endpoint to be transactional ({settings.InputQueue}).");
}
inputQueue.MessageReadPropertyFilter = DefaultReadPropertyFilter;
if (settings.PurgeOnStartup)
{
inputQueue.Purge();
}
receiveStrategy = receiveStrategyFactory(settings.RequiredTransactionMode);
receiveStrategy.Init(inputQueue, errorQueue, onMessage, onError, criticalError);
return TaskEx.CompletedTask;
}
protected async Task StartPump(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, TransportTransactionMode transactionMode, Action <string, Exception> onCriticalError = null)
{
InputQueueName = GetTestName() + transactionMode;
ErrorQueueName = $"{InputQueueName}.error";
transportSettings.Set("NServiceBus.Routing.EndpointName", InputQueueName);
var queueBindings = new QueueBindings();
queueBindings.BindReceiving(InputQueueName);
queueBindings.BindSending(ErrorQueueName);
transportSettings.Set(ErrorQueueSettings.SettingsKey, ErrorQueueName);
transportSettings.Set <QueueBindings>(queueBindings);
transportSettings.Set <EndpointInstances>(new EndpointInstances());
Configurer = CreateConfigurer();
var configuration = Configurer.Configure(transportSettings, transactionMode);
TransportInfrastructure = configuration.TransportInfrastructure;
IgnoreUnsupportedTransactionModes(transactionMode);
IgnoreUnsupportedDeliveryConstraints();
ReceiveInfrastructure = TransportInfrastructure.ConfigureReceiveInfrastructure();
SendInfrastructure = TransportInfrastructure.ConfigureSendInfrastructure();
lazyDispatcher = new Lazy <IDispatchMessages>(() => SendInfrastructure.DispatcherFactory());
MessagePump = ReceiveInfrastructure.MessagePumpFactory();
var queueCreator = ReceiveInfrastructure.QueueCreatorFactory();
await queueCreator.CreateQueueIfNecessary(queueBindings, WindowsIdentity.GetCurrent().Name);
var pushSettings = new PushSettings(InputQueueName, ErrorQueueName, configuration.PurgeInputQueueOnStartup, transactionMode);
await MessagePump.Init(
context =>
{
if (context.Headers.ContainsKey(TestIdHeaderName) && context.Headers[TestIdHeaderName] == testId)
{
return(onMessage(context));
}
return(Task.FromResult(0));
},
context =>
{
if (context.Message.Headers.ContainsKey(TestIdHeaderName) && context.Message.Headers[TestIdHeaderName] == testId)
{
return(onError(context));
}
return(Task.FromResult(ErrorHandleResult.Handled));
},
new FakeCriticalError(onCriticalError),
pushSettings);
MessagePump.Start(configuration.PushRuntimeSettings);
}
private void MigratePushSettingsFromOldSettings()
{
PushSettings pushSettings = new PushSettings();
pushSettings.msg = pushSettings.chat = this.MessageNotificationsEnabled;
pushSettings.msg_no_text = pushSettings.chat_no_text = !this.MessageTextInNotification;
pushSettings.friend = this.FriendsNotificationsEnabled;
pushSettings.mention = this.MentionsNotificationsEnabled;
pushSettings.reply = this.ReplyNotificationsEnabled;
this.PushSettings = pushSettings;
this.PushNotificationsEnabled = pushSettings.msg || pushSettings.chat || (pushSettings.friend || pushSettings.mention) || pushSettings.reply;
if (!this.PushNotificationsEnabled)
{
return;
}
pushSettings.comment = true;
pushSettings.event_soon = true;
pushSettings.event_soon = true;
pushSettings.friend_accepted = true;
pushSettings.friend_found = true;
pushSettings.group_accepted = true;
pushSettings.group_invite = true;
pushSettings.like = true;
pushSettings.new_post = true;
pushSettings.reply = true;
pushSettings.repost = true;
pushSettings.wall_post = true;
pushSettings.wall_publish = true;
}
List <TransportReceiver> CreateReceivers(IPipeline <ITransportReceiveContext> mainPipeline)
{
if (settings.GetOrDefault <bool>("Endpoint.SendOnly"))
{
return(new List <TransportReceiver>());
}
var purgeOnStartup = settings.GetOrDefault <bool>("Transport.PurgeOnStartup");
var errorQueue = settings.ErrorQueueAddress();
var dequeueLimitations = GeDequeueLimitationsForReceivePipeline();
var requiredTransactionSupport = settings.GetRequiredTransactionModeForReceives();
var recoverabilityExecutorFactory = builder.Build <RecoverabilityExecutorFactory>();
var receivers = BuildMainReceivers(errorQueue, purgeOnStartup, requiredTransactionSupport, dequeueLimitations, recoverabilityExecutorFactory, mainPipeline);
foreach (var satellitePipeline in settings.Get <SatelliteDefinitions>().Definitions)
{
var satelliteRecoverabilityExecutor = recoverabilityExecutorFactory.Create(satellitePipeline.RecoverabilityPolicy, eventAggregator, satellitePipeline.ReceiveAddress);
var satellitePushSettings = new PushSettings(satellitePipeline.ReceiveAddress, errorQueue, purgeOnStartup, satellitePipeline.RequiredTransportTransactionMode);
receivers.Add(new TransportReceiver(satellitePipeline.Name, builder.Build <IPushMessages>(), satellitePushSettings, dequeueLimitations, new SatellitePipelineExecutor(builder, satellitePipeline), satelliteRecoverabilityExecutor, criticalError));
}
return(receivers);
}
public ConsumerHolder(string connectionString, string endpointName, PushSettings settings, SettingsHolder settingsHolder, Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, bool doNotSubscribeToEndPointQueue = false)
{
this.onMessage = onMessage;
this.onError = onError;
this.settings = settings;
this.settingsHolder = settingsHolder;
this.connectionString = connectionString;
this.endpointName = endpointName;
this.doNotSubscribeToEndPointQueue = doNotSubscribeToEndPointQueue;
circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("kafka circuit breaker", new TimeSpan(30), ex => criticalError.Raise("Failed to receive message from Kafka.", ex));
if (consumer == null)
{
lock (o)
{
if (consumer == null)
{
CreateConsumer();
}
}
}
}
public async Task <bool> NotificationRegistrationAsync(Ekreta.Mobile.Core.Models.Profile profile)
{
try
{
if (!this._pushNotificationPlatformSpecificService.IsPushNotificationEnabledByDevice())
{
throw new DisabledPushByDeviceException().SetErrorCode <DisabledPushByDeviceException>("/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/Repository/DataServices/ProfileDataService.cs", 123);
}
string platform = this._pushNotificationHandler.Platform.ToString();
NotificationMessageType notificationType = NotificationMessageType.All;
string handle = this._pushNotificationHandler.Token;
NotificationMessageSource notificationSource = NotificationMessageSource.Kreta;
TokenData tokenData = this._secureStore.GetTokenData(profile.Id);
if (tokenData.ExpiresAt <= DateTime.Now)
{
tokenData = await((IAuthDataService)Mvx.get_IoCProvider().Resolve <IAuthDataService>()).RefreshToken(profile);
}
if (tokenData == null)
{
return(false);
}
profile.TokenInfo = (TokenInfo)JsonConvert.DeserializeObject <TokenInfo>(TokenDecoder.Decode(tokenData.AccessToken));
PushSettings pushSettings = await this._globalMobileApi.NotificationRegistrationAsync(profile.TokenInfo.InstituteCode, profile.TokenInfo.InstituteUserId, profile.TokenInfo.TutelaryId, platform, handle, profile.TokenInfo.Role, notificationSource, (int)notificationType, profile.Id);
if (pushSettings != null)
{
pushSettings.NotificationTypes = notificationType;
pushSettings.FirstTimePushRun = true;
pushSettings.UpdateEugyintezes = true;
pushSettings.Token = handle;
profile.PushSettings = pushSettings;
}
else if (profile.PushSettings != null)
{
profile.PushSettings.FirstTimePushRun = true;
}
else
{
profile.PushSettings = new PushSettings()
{
FirstTimePushRun = true
}
};
this.AddOrUpdate(profile);
return(pushSettings != null);
}
catch (DisabledPushByDeviceException ex)
{
ex.SetErrorCode <DisabledPushByDeviceException>("/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/Repository/DataServices/ProfileDataService.cs", 180);
throw;
}
catch (Exception ex)
{
CrossMobileAnalytics.Current.TrackException(ex, (IDictionary <string, string>)null, "ProfileDataService.NotificationRegistrationAsync", "/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/Repository/DataServices/ProfileDataService.cs", 75);
return(false);
}
}
RawTransportReceiver BuildMainReceiver(string poisonMessageQueue, bool purgeOnStartup, TransportTransactionMode requiredTransactionSupport)
{
var pushSettings = new PushSettings(localAddress, poisonMessageQueue, purgeOnStartup, requiredTransactionSupport);
var dequeueLimitations = GetDequeueLimitationsForReceivePipeline();
var errorHandlingPolicy = settings.Get <IErrorHandlingPolicy>();
var receiver = new RawTransportReceiver(messagePump, dispatcher, onMessage, pushSettings, dequeueLimitations, criticalError,
new RawEndpointErrorHandlingPolicy(settings.EndpointName(), localAddress, dispatcher, errorHandlingPolicy));
return(receiver);
}
//--------------------| Метод account.account.setPushSettings |----
/// <summary>
/// Изменяет настройку Push-уведомлений
/// </summary>
/// <param name="device_id">уникальный идентификатор устройства</param>
/// <param name="settings">объект, описывающий настройки уведомлений</param>
/// <param name="key">ключ уведомления</param>
/// <param name="value">новое значение уведомления</param>
public void setPushSettings(string device_id,
PushSettings settings, string key, PushSettings value)
{
Dictionary <string, string> d = VkAPI.Account.setPushSettings(AccessToken, device_id, settings, key, value);
if (d.ContainsKey("error_code"))
{
data.SetData("data", 1, d);
}
}
void IInitializeSystem.Initialize()
{
// слушаем изменение позиции
_context.input.inputPositionEntity.AddInputPositionListener(this);
_randomService = _context.game.services.ProvideRandomService();
CharacterSettings = _context.game.services.ProvideConfigService().GetCharacterSettings();
PushSettings = _context.game.services.ProvideConfigService().GetPushSettings();
}
public void ShouldThrowIfConfiguredToReceiveFromRemoteQueue()
{
var messagePump = new MessagePump(mode => null);
var pushSettings = new PushSettings("queue@remote", "error", false, TransportTransactionMode.None);
var exception = Assert.Throws<Exception>(() =>
{
messagePump.Init(context => null, context => null, null, pushSettings);
});
Assert.That(exception.Message, Does.Contain($"MSMQ Dequeuing can only run against the local machine. Invalid inputQueue name '{pushSettings.InputQueue}'."));
}
public void ShouldThrowIfConfiguredToReceiveFromRemoteQueue()
{
var messagePump = new MessagePump(mode => null);
var pushSettings = new PushSettings("queue@remote", "error", false, TransportTransactionMode.None);
var exception = Assert.Throws <Exception>(() =>
{
messagePump.Init(context => null, context => null, null, pushSettings);
});
Assert.That(exception.Message, Does.Contain($"MSMQ Dequeuing can only run against the local machine. Invalid inputQueue name '{pushSettings.InputQueue}'."));
}
/// <summary>
/// Изменяет настройку Push-уведомлений.
/// </summary>
/// <param name="deviceId">
/// Уникальный идентификатор устройства. строка, обязательный параметр (Строка,
/// обязательный
/// параметр).
/// </param>
/// <param name="settings">
/// Сериализованный JSON-объект, описывающий настройки уведомлений в специальном
/// формате данные в
/// формате JSON (Данные в формате JSON).
/// </param>
/// <param name="key"> Ключ уведомления. строка (Строка). </param>
/// <param name="value">
/// Новое значение уведомления в специальном формате. список слов, разделенных
/// через запятую (Список
/// слов, разделенных через запятую).
/// </param>
/// <returns>
/// Возвращает 1 в случае успешного выполнения метода.
/// </returns>
/// <remarks>
/// Страница документации ВКонтакте http://vk.com/dev/account.setPushSettings
/// </remarks>
public bool SetPushSettings(string deviceId, PushSettings settings, string key, List <string> value)
{
var parameters = new VkParameters
{
{ "device_id", deviceId }
, { "settings", settings }
, { "key", key }
, { "value", value }
};
return(_vk.Call(methodName: "account.setPushSettings", parameters: parameters));
}
public Task Init(
Func <MessageContext, Task> onMessage,
Func <ErrorContext, Task <ErrorHandleResult> > onError,
CriticalError criticalError,
PushSettings settings)
{
this.passMessageToNsb = onMessage;
this.letNsbKnowAboutAnError = onError;
this.criticalError = criticalError;
this.nsbSettings = settings;
this.messagePumpName = $"MessagePump-{this.nsbSettings.InputQueue}";
return(Task.CompletedTask);
}
public Task Init(
Func <MessageContext, Task> onMessage,
Func <ErrorContext, Task <ErrorHandleResult> > onError,
CriticalError criticalError,
PushSettings settings)
{
pushSettings = settings;
this.criticalError = criticalError;
this.onError = onError;
this.onMessage = onMessage;
inputQueue = settings.InputQueue;
return(Task.CompletedTask);
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
if (settings.PurgeOnStartup)
{
throw new Exception("Azure Service Bus transport doesn't support PurgeOnStartup behavior");
}
this.onMessage = onMessage;
this.onError = onError;
pushSettings = settings;
circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker($"'{settings.InputQueue}'", timeToWaitBeforeTriggeringCircuitBreaker, criticalError);
return(Task.CompletedTask);
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
this.onMessage = onMessage;
this.onError = onError;
this.settings = settings;
this.criticalError = criticalError;
circuitBreaker = new MessagePumpConnectionFailedCircuitBreaker($"'{settings.InputQueue} MessagePump'", timeToWaitBeforeTriggeringCircuitBreaker, criticalError);
if (settings.PurgeOnStartup)
{
queuePurger.Purge(settings.InputQueue);
}
return(Task.CompletedTask);
}
IEnumerable <TransportReceiver> BuildPipelines()
{
var errorQueue = ErrorQueueSettings.GetConfiguredErrorQueue(settings);
var dequeueLimitations = GeDequeueLimitationsForReceivePipeline();
var requiredTransactionSupport = settings.GetRequiredTransactionModeForReceives();
var pushSettings = new PushSettings(settings.LocalAddress(), errorQueue, settings.GetOrDefault <bool>("Transport.PurgeOnStartup"), requiredTransactionSupport);
yield return(BuildPipelineInstance(pipelineConfiguration.MainPipeline, "Main", pushSettings, dequeueLimitations));
foreach (var satellitePipeline in pipelineConfiguration.SatellitePipelines)
{
var satellitePushSettings = new PushSettings(satellitePipeline.ReceiveAddress, errorQueue, settings.GetOrDefault <bool>("Transport.PurgeOnStartup"), satellitePipeline.RequiredTransportTransactionMode);
yield return(BuildPipelineInstance(satellitePipeline, satellitePipeline.Name, satellitePushSettings, satellitePipeline.RuntimeSettings));
}
}
public TransportReceiver(
string id,
IPushMessages pushMessages,
PushSettings pushSettings,
PushRuntimeSettings pushRuntimeSettings,
IPipelineExecutor pipelineExecutor,
RecoverabilityExecutor recoverabilityExecutor,
CriticalError criticalError)
{
this.criticalError = criticalError;
Id = id;
this.pushRuntimeSettings = pushRuntimeSettings;
this.pipelineExecutor = pipelineExecutor;
this.recoverabilityExecutor = recoverabilityExecutor;
this.pushSettings = pushSettings;
receiver = pushMessages;
}
public TransportReceiver(
string id,
IPushMessages pushMessages,
PushSettings pushSettings,
PushRuntimeSettings pushRuntimeSettings,
IPipelineExecutor pipelineExecutor,
RecoverabilityExecutor recoverabilityExecutor,
CriticalError criticalError)
{
this.criticalError = criticalError;
Id = id;
this.pushRuntimeSettings = pushRuntimeSettings;
this.pipelineExecutor = pipelineExecutor;
this.recoverabilityExecutor = recoverabilityExecutor;
this.pushSettings = pushSettings;
receiver = pushMessages;
}
protected override void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
LoadApplication(new App());
//RegisterReceiver(new NotificationDemo.Droid.NotifyMessageReceiver(), new IntentFilter(""));
PushManager.StartWork(ApplicationContext, PushConstants.LoginTypeApiKey, ConfigurationSettings.API_KEY);
PushSettings.EnableDebugMode(ApplicationContext, true);
//JPushInterface.SetDebugMode(true);
//JPushInterface.Init(this);
//var name = typeof(MainActivity).Assembly.ToString();
}
private void NotificationChange(object sender, EventArgs e)
{
if (!(sender is UISwitch switcher))
{
return;
}
var subscription = PushSettings.None;
if (Equals(sender, _notificationUpvotesSwitch))
{
subscription = PushSettings.Upvote;
}
else if (Equals(sender, _notificationCommentsUpvotesSwitch))
{
subscription = PushSettings.UpvoteComment;
}
else if (Equals(sender, _notificationFollowingSwitch))
{
subscription = PushSettings.Follow;
}
else if (Equals(sender, _notificationCommentsSwitch))
{
subscription = PushSettings.Comment;
}
else if (Equals(sender, _notificationPostingSwitch))
{
subscription = PushSettings.User;
}
else if (Equals(sender, _notificationTranfserSwitch))
{
subscription = PushSettings.Transfer;
}
if (switcher.On)
{
PushSettings |= subscription;
}
else
{
PushSettings ^= subscription;
}
}
private void NotificationChange(object sender, CompoundButton.CheckedChangeEventArgs e)
{
if (!(sender is SwitchCompat))
{
return;
}
var subscription = PushSettings.None;
if (Equals(sender, _notificationUpvotesSwitch))
{
subscription = PushSettings.Upvote;
}
else if (Equals(sender, _notificationCommentsUpvotesSwitch))
{
subscription = PushSettings.UpvoteComment;
}
else if (Equals(sender, _notificationFollowingSwitch))
{
subscription = PushSettings.Follow;
}
else if (Equals(sender, _notificationCommentsSwitch))
{
subscription = PushSettings.Comment;
}
else if (Equals(sender, _notificationPostingSwitch))
{
subscription = PushSettings.User;
}
else if (Equals(sender, _notificationTransferSwitch))
{
subscription = PushSettings.Transfer;
}
if (e.IsChecked)
{
PushSettings |= subscription;
}
else
{
PushSettings ^= subscription;
}
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
SetBackButton();
CreateView();
PushSettings = AppSettings.User.PushSettings;
_notificationUpvotesSwitch.On = PushSettings.HasFlag(PushSettings.Upvote);
_notificationCommentsUpvotesSwitch.On = PushSettings.HasFlag(PushSettings.UpvoteComment);
_notificationFollowingSwitch.On = PushSettings.HasFlag(PushSettings.Follow);
_notificationCommentsSwitch.On = PushSettings.HasFlag(PushSettings.Comment);
_notificationPostingSwitch.On = PushSettings.HasFlag(PushSettings.User);
_notificationUpvotesSwitch.ValueChanged += NotificationChange;
_notificationCommentsUpvotesSwitch.ValueChanged += NotificationChange;
_notificationFollowingSwitch.ValueChanged += NotificationChange;
_notificationCommentsSwitch.ValueChanged += NotificationChange;
_notificationPostingSwitch.ValueChanged += NotificationChange;
}
public async Task <bool> InitNotificationHubAsync(string hubName, string hubConnectionString, string[] marks)
{
isRegisted = null;
userMarks = marks;
//Java.Lang.JavaSystem.LoadLibrary("libbdpush_V2_7");
NotifyMessageReceiver.Binded += BaiduBinded;
PushSettings.EnableDebugMode(Xamarin.Forms.Forms.Context, true);
PushManager.StartWork(Xamarin.Forms.Forms.Context, PushConstants.LoginTypeApiKey, BiaduConfigurationSettings.API_KEY);
while (isRegisted == null)
{
await Task.Delay(50);
}
return(isRegisted.Value);
}
public async Task <bool> NotificationUpdateAsync(
Ekreta.Mobile.Core.Models.Profile profile,
NotificationMessageType notificationType,
string token)
{
try
{
PushSettings pushSettings = await this._globalMobileApi.NotificationUpdateAsync(profile.PushSettings.RegistrationId, (int)notificationType, NotificationMessageSource.Kreta, token);
profile.PushSettings.NotificationTypes = notificationType;
profile.PushSettings.Token = token;
this.AddOrUpdate(profile);
return(true);
}
catch (Exception ex)
{
CrossMobileAnalytics.Current.TrackException(ex, (IDictionary <string, string>)null, nameof(NotificationUpdateAsync), "/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/Repository/DataServices/ProfileDataService.cs", 206);
return(false);
}
}
List<TransportReceiver> CreateReceivers(IPipeline<ITransportReceiveContext> mainPipeline)
{
if (settings.GetOrDefault<bool>("Endpoint.SendOnly"))
{
return new List<TransportReceiver>();
}
var purgeOnStartup = settings.GetOrDefault<bool>("Transport.PurgeOnStartup");
var errorQueue = settings.ErrorQueueAddress();
var requiredTransactionSupport = settings.GetRequiredTransactionModeForReceives();
var recoverabilityExecutorFactory = builder.Build<RecoverabilityExecutorFactory>();
var receivers = BuildMainReceivers(errorQueue, purgeOnStartup, requiredTransactionSupport, recoverabilityExecutorFactory, mainPipeline);
foreach (var satellitePipeline in settings.Get<SatelliteDefinitions>().Definitions)
{
var satelliteRecoverabilityExecutor = recoverabilityExecutorFactory.Create(satellitePipeline.RecoverabilityPolicy, eventAggregator, satellitePipeline.ReceiveAddress);
var satellitePushSettings = new PushSettings(satellitePipeline.ReceiveAddress, errorQueue, purgeOnStartup, satellitePipeline.RequiredTransportTransactionMode);
receivers.Add(new TransportReceiver(satellitePipeline.Name, builder.Build<IPushMessages>(), satellitePushSettings, satellitePipeline.RuntimeSettings, new SatellitePipelineExecutor(builder, satellitePipeline), satelliteRecoverabilityExecutor, criticalError));
}
return receivers;
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
this.onError = onError;
pipeline = onMessage;
path = BaseDirectoryBuilder.BuildBasePath(settings.InputQueue);
purgeOnStartup = settings.PurgeOnStartup;
return(Task.CompletedTask);
}
public async Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
pipeline = onMessage;
this.onError = onError;
inputQueue = settings.InputQueue;
receiveCircuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("EventStoreReceive", TimeSpan.FromSeconds(30), ex => criticalError.Raise("Failed to receive from " + settings.InputQueue, ex));
this.criticalError = criticalError;
if (settings.PurgeOnStartup)
{
//inputQueue.Purge();
}
await connection.ConnectAsync().ConfigureAwait(false);
await onStart(criticalError).ConfigureAwait(false);
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
throw new NotImplementedException();
}
public Task Init(Func<MessageContext, Task> onMessage, Func<ErrorContext, Task<ErrorHandleResult>> onError, CriticalError criticalError, PushSettings settings)
{
throw new NotImplementedException();
}
/// <summary>
/// Изменяет настройку Push-уведомлений.
/// </summary>
/// <param name="deviceId">Уникальный идентификатор устройства. строка, обязательный параметр (Строка, обязательный параметр).</param>
/// <param name="settings">Сериализованный JSON-объект, описывающий настройки уведомлений в специальном формате данные в формате JSON (Данные в формате JSON).</param>
/// <param name="key">Ключ уведомления. строка (Строка).</param>
/// <param name="value">Новое значение уведомления в специальном формате. список слов, разделенных через запятую (Список слов, разделенных через запятую).</param>
/// <returns>
/// Возвращает 1 в случае успешного выполнения метода.
/// </returns>
/// <remarks>
/// Страница документации ВКонтакте <see href="http://vk.com/dev/account.setPushSettings" />.
/// </remarks>
public bool SetPushSettings(string deviceId, PushSettings settings, string key, List<string> value)
{
var parameters = new VkParameters
{
{ "device_id", deviceId },
{ "settings", settings },
{ "key", key },
{ "value", value }
};
return _vk.Call("account.setPushSettings", parameters);
}
List<TransportReceiver> BuildMainReceivers(string errorQueue, bool purgeOnStartup, TransportTransactionMode requiredTransactionSupport, RecoverabilityExecutorFactory recoverabilityExecutorFactory, IPipeline<ITransportReceiveContext> mainPipeline)
{
var localAddress = settings.LocalAddress();
var distributorAddress = settings.GetOrDefault<string>("LegacyDistributor.Address");
var recoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(eventAggregator, distributorAddress ?? localAddress);
var pushSettings = new PushSettings(settings.LocalAddress(), errorQueue, purgeOnStartup, requiredTransactionSupport);
var mainPipelineExecutor = new MainPipelineExecutor(builder, eventAggregator, pipelineCache, mainPipeline);
var dequeueLimitations = GetDequeueLimitationsForReceivePipeline();
var receivers = new List<TransportReceiver>();
receivers.Add(new TransportReceiver(MainReceiverId, builder.Build<IPushMessages>(), pushSettings, dequeueLimitations, mainPipelineExecutor, recoverabilityExecutor, criticalError));
if (settings.InstanceSpecificQueue() != null)
{
var instanceSpecificQueue = settings.InstanceSpecificQueue();
var instanceSpecificRecoverabilityExecutor = recoverabilityExecutorFactory.CreateDefault(eventAggregator, instanceSpecificQueue);
var sharedReceiverPushSettings = new PushSettings(settings.InstanceSpecificQueue(), errorQueue, purgeOnStartup, requiredTransactionSupport);
receivers.Add(new TransportReceiver(MainReceiverId, builder.Build<IPushMessages>(), sharedReceiverPushSettings, dequeueLimitations, mainPipelineExecutor, instanceSpecificRecoverabilityExecutor, criticalError));
}
return receivers;
}
public Task Init(Func<PushContext, Task> pipe, CriticalError criticalError, PushSettings settings)
{
throw new NotImplementedException();
}
public Task Init(Func<MessageContext, Task> onMessage, Func<ErrorContext, Task<ErrorHandleResult>> onError, NServiceBus.CriticalError criticalError, PushSettings settings)
{
this.criticalError = criticalError;
return Task.FromResult(0);
}
public Task Init(Func<MessageContext, Task> onMessage, Func<ErrorContext, Task<ErrorHandleResult>> onError, CriticalError criticalError, PushSettings settings)
{
pushSettings = settings;
return Task.FromResult(0);
}
