private async Task RaiseAsyncCommands <TData>( IContainer container, IList <IHandlerDto> handlers, object command, IPayload <TData> payload) { for (var i = 0; i < handlers.Count; i++) { var instanse = container.Resolve(handlers[i].HandlerType); try { await(handlers[i] as AsyncHandlerDto).ExecuteMethod(instanse, command); } catch (Exception exception) { if (payload is ErrorPayload) { throw; } await RaiseCommand(new ErrorPayload($"Handler {handlers[i].GetType()}", exception)); } } }
public bool Handle(IPacket header, IIBLVMSocket socket) { if (header.Type == PacketType.ClientLoginRequest) { Utils.PacketValidation(socket.Status, (int)SocketStatus.Connected, header.GetPayloadSize(), false); IPayload <IAuthInfo> packet = socket.PacketFactory.CreateClientLoginRequest(null, null, 0, socket.CryptoProvider.CryptoStream); packet.ParsePayload(header.GetPayloadSize(), socket.SocketStream); bool isSuccess = session.Auth(new Account(packet.Payload.Account.Id, packet.Payload.Account.Password)); IPacket response = socket.PacketFactory.CreateServerLoginResponse(isSuccess); if (isSuccess) { OnClientLoggedIn(packet.Payload); } Utils.SendPacket(socket.SocketStream, response); socket.Status = (int)SocketStatus.LoggedIn; return(true); } return(false); }
public EnhancedNotification(DeviceToken deviceToken, IPayload payload, uint identifier, TimeSpan? expiry) { this.deviceToken = deviceToken; this.payload = payload; this.identifier = identifier; this.expiry = expiry; }
/// <summary> /// Sends a payload to all registered callbacks. /// </summary> /// <param name="payload"></param> public void Dispatch(IPayload payload) { if (IsDispatching) { throw new DispatcherExceptions.AlreadyDispatchingException(); } startDispatching(payload); try { foreach (KeyValuePair <DispatchToken, Action <IPayload> > callback in callbackRegistry) { if (isPending.Contains(callback.Key)) { continue; } invokeCallback(callback.Key); } } finally { stopDispatching(); } }
public override async Task WriteRecordsAsync(IAsyncEnumerable <IPayload> records, CancellationToken cancellationToken) { if ((object)records == null) { throw new ArgumentNullException(nameof(records)); } if (!this.HeaderRecordWritten) { await this.WriteHeaderFieldsAsync(null, cancellationToken); // force fields if not explicitly called in advance } long recordIndex = 0; IAsyncEnumerator <IPayload> recordz; recordz = records.GetEnumerator(); while (await recordz.MoveNext(cancellationToken)) { IPayload record = recordz.Current; long fieldIndex = 0; foreach (KeyValuePair <string, object> item in record) { await this.WriteFieldAsync(fieldIndex == 0, this.FormatFieldValue(fieldIndex, item.Key, item.Value), cancellationToken); fieldIndex++; } if (!SolderFascadeAccessor.DataTypeFascade.IsNullOrEmpty(this.TextualSpec.RecordDelimiter)) { await this.BaseTextWriter.WriteAsync(this.TextualSpec.RecordDelimiter /*, cancellationToken*/); // TODO: no CT overload in 2.0 - SMH } recordIndex++; } }
private void OnPlayerShipSpawned(IPayload obj) { var data = (PlayerShipSpawnedPayload)obj; playerShip = data.Ship; playerShip.SetDependecies(gameStateHelper); }
private Item(string internalReference, ICorrespondent source, ICorrespondent target, CorrespondenceRoute correspondenceRoute, IPayload payload) { this.internalReference = internalReference; this.source = source; this.target = target; this.payload = payload; }
public EnhancedNotification(DeviceToken deviceToken, IPayload payload, uint identifier, TimeSpan?expiry) { this.deviceToken = deviceToken; this.payload = payload; this.identifier = identifier; this.expiry = expiry; }
/// <summary> /// Initiates the dispatch process. /// </summary> /// <param name="payload"></param> protected void startDispatching(IPayload payload) { isPending = new List <DispatchToken>(); isHandled = new List <DispatchToken>(); currentPayload = payload; IsDispatching = true; }
public static WebRequest PrepareRequest(RichPresence presence, string applicationID, int port = 6463) { //Validate the presence if (presence != null) { //Send valid presence //Validate the presence with our settings if (presence.HasSecrets()) { throw new BadPresenceException("Cannot send a presence with secrets as HTTP endpoint does not suppport events."); } if (presence.HasParty() && presence.Party.Max < presence.Party.Size) { throw new BadPresenceException("Presence maximum party size cannot be smaller than the current size."); } } //Prepare some params int pid = System.Diagnostics.Process.GetCurrentProcess().Id; //Prepare the payload PresenceCommand command = new PresenceCommand() { PID = pid, Presence = presence }; IPayload payload = command.PreparePayload(DateTime.UtcNow.ToFileTime()); string json = JsonConvert.SerializeObject(payload); string url = "http://127.0.0.1:" + port + "/rpc?v=" + RpcConnection.VERSION + "&client_id=" + applicationID; return(new WebRequest(url, json)); }
public bool Handle(IPacket header, IIBLVMSocket socket) { if (header.Type == PacketType.ServerKeyResponse) { Utils.PacketValidation(socket.Status, (int)ClientSocketStatus.Handshaking, header.GetPayloadSize(), false); CryptoProvider cryptoProvider = socket.CryptoProvider; IPayload <byte[]> packet = socket.PacketFactory.CreateServerKeyResponse(null); packet.ParsePayload(header.GetPayloadSize(), socket.SocketStream); cryptoProvider.SharedKey = cryptoProvider.ECDiffieHellman.DeriveKeyMaterial(CngKey.Import(packet.Payload, CngKeyBlobFormat.EccPublicBlob)); cryptoProvider.CryptoStream = new CryptoMemoryStream(cryptoProvider.SharedKey); byte[] nonce = new byte[cryptoProvider.CryptoStream.IV.Length]; Array.Copy(cryptoProvider.SharedKey, nonce, nonce.Length); cryptoProvider.CryptoStream.IV = nonce; IPacket responsePacket = socket.PacketFactory.CreateClientKeyResponse(cryptoProvider.ECDiffieHellman.PublicKey.ToByteArray()); Utils.SendPacket(socket.SocketStream, responsePacket); socket.Status = (int)ClientSocketStatus.Connected; return(true); } return(false); }
private void OnUfoDestroyed(IPayload obj) { UFODestroyedPayload uFODestroyedPayload = (UFODestroyedPayload)obj; var ufo = uFODestroyedPayload.UFO as UFO; ufos.Remove(ufo); }
public async Task Raise(IPayload payload) { var handlers = config.Container .Resolve <IEventHolder>() .GetHandlers(payload); foreach (var handler in handlers) { using (var scope = config.Scope()) { scope.Register(payload.Data.GetType()) .ImplementedBy(c => payload.Data) .As <Singleton>(); var container = scope.Container; var instanse = container.Resolve(handler); var @event = container.Resolve(payload.Event); await((Task)handler.InvokeMember( "Execute", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, instanse, new[] { @event })).ConfigureAwait(false); } } }
public async Task SendAsync(IPayload payload, CancellationToken cancellationToken = default(CancellationToken)) { foreach (var provider in _payloadClientProviders) { await provider.GetPayloadClient().WriteAsync(payload, cancellationToken); } }
public bool Handle(IPacket header, IIBLVMSocket socket) { if (header.Type == PacketType.ServerBitLockerLockRequest) { Utils.PacketValidation(socket.Status, (int)ClientSocketStatus.LoggedIn, header.GetPayloadSize(), false); IPayload <DriveInformation> packet = socket.PacketFactory.CreateServerBitLockerLockRequest(null); packet.ParsePayload(header.GetPayloadSize(), socket.SocketStream); BitLocker bitLocker = BitLocker.GetVolume(packet.Payload.Name); bool isSuccess = true; try { bitLocker.Lock(true); } catch (Exception) { isSuccess = false; } IPayload <bool> result = socket.PacketFactory.CreateClientBitLockerCommandResponse(isSuccess); Utils.SendPacket(socket.SocketStream, result); return(true); } return(false); }
protected StoreActionContainer MakeContainer(StoreActionType type, IPayload data) { return(new StoreActionContainer() { type = type, data = data }); }
public override Result <ProcessedPayload> Encode(IPayload payload, DecodingContext context) { var options = context.ChannelOptions; var currentPayload = new ProcessedPayload(payload); if (IsEmpty(payload.Data) || IsEncrypted(currentPayload)) { return(Result.Ok(new ProcessedPayload(currentPayload))); } if (options.Encrypted == false) { return(Result.Ok(new ProcessedPayload(currentPayload))); } if (currentPayload.Data is string data) { currentPayload.Data = data.GetBytes(); currentPayload.Encoding = AddEncoding(payload, "utf-8"); } var cipher = Crypto.GetCipher(options.CipherParams); var result = new ProcessedPayload( cipher.Encrypt(currentPayload.Data as byte[]), AddEncoding(currentPayload, $"{EncodingName}+{options.CipherParams.CipherType.ToLower()}")); return(Result.Ok(result)); }
public Running(Transition.IFactory transitionFactory, ILogic logic, IPayload payload, Config config, IScheduler scheduler) { _transitionFactory = transitionFactory; _logic = logic; _payload = payload; _config = config; _scheduler = scheduler; }
public ProcessedPayload(IPayload payload) { if (payload != null) { Data = payload.Data; Encoding = payload.Encoding; } }
private void OnGameEnd(IPayload payload) { if (spawnCor != null) { parrentBehaviour.StopCoroutine(spawnCor); } RecycleAllAsteroids(); }
public SystemEvent(SystemEventTypesEnum eventType, long?correlationId, IPayload payload = null, string entityId = "") { EventType = eventType; CorrelationId = correlationId; EntityId = entityId; Payload = payload; SystemTime = DateTime.UtcNow; }
public static IMessage Create(IPayload payload, DistributionPattern distributionPattern = DistributionPattern.Unicast, byte[] correlationId = null) => new Message(payload) { Distribution = distributionPattern, CorrelationId = correlationId ?? EmptyCorrelationId };
public void Send(IPayload payload) { if (!ShouldSendRequests()) { return; } Delivery.Send(payload); }
private void OnGameEnd(IPayload obj) { for (int source = 0; source < activeSources.Count; source++) { ResetStateOfAudioSource(activeSources[source]); RecycleToPool(activeSources[source]); } }
public async Task <IActionResult> New(GenricApartment <ListsVM, RentVM, SaleVM, ApartmentVM> apartment, IFormFile file) { Messages msg = new Messages(); if (!ModelState.IsValid) { msg.SetMessage(ToastTypes.error, "There is an error in the entered data.", "Error"); } else { try { IPayload entity = (apartment.In2, apartment.In3) switch { (null, _) => apartment.In3.Sale, (_, null) => apartment.In2.Rent, _ => throw new ArgumentOutOfRangeException("Invalid arguments values.") }; Guid requestId = Guid.NewGuid(); var payload = new Payload <IPayload>(apartment.In4.Apartment, entity); payload.Apartment.RequestId = requestId; await _apartmentService.Save(payload); ModelState.Clear(); await _apartmentService.UploadImage(file, requestId); msg.SetMessage(ToastTypes.success, "Apartment data was saved.", "Success"); } catch (Exception ex) { if (ex.GetType() == typeof(ArgumentException)) { msg.SetMessage(ToastTypes.warning, ex.Message ?? "Apartment service is inoperative.", "Warning"); } else { msg.SetMessage(ToastTypes.error, ex.Message ?? "Apartment service is inoperative."); } } } try { ViewBag.msg = msg; string result = await _apartmentService.PopulateLists(); var model = PopulateLists(result, (Rent rent, Sale sale, Apartment apartData) => { rent = apartment.In2?.Rent; sale = apartment.In3?.Sale; apartData = apartment.In4?.Apartment; }); return(ActionResult(model)); } catch { return(RedirectToAction(nameof(Blank))); } }
/// <inheritdoc /> public async Task <Result> SendPayloadAsync(IPayload payload, CancellationToken ct = default) { if (_clientWebSocket is null) { return(new InvalidOperationError("The transport service is not connected.")); } if (_clientWebSocket.State != WebSocketState.Open) { return(new InvalidOperationError("The socket was not open.")); } await using var memoryStream = new MemoryStream(); byte[]? buffer = null; try { await JsonSerializer.SerializeAsync(memoryStream, payload, _jsonOptions, ct); if (memoryStream.Length > 4096) { return(new NotSupportedError ( "The payload was too large to be accepted by the gateway." )); } buffer = ArrayPool <byte> .Shared.Rent((int)memoryStream.Length); memoryStream.Seek(0, SeekOrigin.Begin); // Copy the data var bufferSegment = new ArraySegment <byte>(buffer, 0, (int)memoryStream.Length); await memoryStream.ReadAsync(bufferSegment, ct); // Send the whole payload as one chunk await _clientWebSocket.SendAsync(bufferSegment, WebSocketMessageType.Text, true, ct); if (_clientWebSocket.CloseStatus.HasValue) { if (Enum.IsDefined(typeof(GatewayCloseStatus), (int)_clientWebSocket.CloseStatus)) { return(new GatewayDiscordError((GatewayCloseStatus)_clientWebSocket.CloseStatus)); } return(new GatewayWebSocketError(_clientWebSocket.CloseStatus.Value)); } } finally { if (buffer is not null) { ArrayPool <byte> .Shared.Return(buffer); } } return(Result.FromSuccess()); }
public void NavigateTo(Type viewModelType, IPayload parameter = null, Action <Guid> callback = null) { if (viewModelType == null) { return; } if (_viewMapperDictionary.TryGetValue(viewModelType, out Type concreteType) == false) { throw new System.Exception($"The viewmodel '{viewModelType.ToString()}' does not exist in view mapper!"); } if (concreteType.IsSubclassOf(typeof(FragmentBase))) { LoadFragment(concreteType, parameter, callback); return; } var concreteTypeJava = Class.FromType(concreteType); var intent = new Intent(Context, concreteTypeJava); if (parameter != null) { intent.SetPayload(parameter); } if (callback != null) { var currentActivity = Context as Activity; if (currentActivity == null) { System.Diagnostics.Debug.WriteLine("AppNavigation.NavigateTo: Context is null or not an activity!"); return; } intent.SetCallback(callback); if (CanUseActivityTrasitions) { currentActivity.StartActivityForResult(intent, CallbackActivityRequestCode, ActivityOptions.MakeSceneTransitionAnimation(Context as Activity).ToBundle()); } else { currentActivity.StartActivityForResult(intent, CallbackActivityRequestCode); } return; } if (CanUseActivityTrasitions) { Context.StartActivity(intent, ActivityOptions.MakeSceneTransitionAnimation(Context as Activity).ToBundle()); } else { Context.StartActivity(intent); } }
public async Task <MsgOp> RequestAsync(string subject, IPayload body, int?timeoutMs = null) { ThrowIfDisposed(); EnsureArg.IsNotNullOrWhiteSpace(subject, nameof(subject)); EnsureArg.IsNotNull(body, nameof(body)); return(await DoRequestAsync(subject, body.GetBytes().ToArray(), timeoutMs).ConfigureAwait(false)); }
public void PublishEvent(IPayload payload) { var eventName = payload.EventName; if (Instance.events.ContainsKey(eventName)) { Instance.events[eventName].ForEach(method => method.Invoke(payload)); } }
public Task WriteAsync(IPayload payload, CancellationToken cancellationToken = default(CancellationToken)) { foreach (var point in payload) { var lineProtocolPoint = new LineProtocolPoint(point.Name, point.GetFields(), point.GetTags(), point.Timestamp); _pointMap.TryAdd(new PointState(lineProtocolPoint), null); } return(Task.FromResult(0)); }
public static string GetCurrentEncoding(IPayload payload) { if (payload.Encoding.IsEmpty()) { return(string.Empty); } return(payload.Encoding.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Last()); }
public void Read(Stream s) { BinaryReader br = new BinaryReader(s); magic = br.ReadUInt32(); command = br.ReadBytes(12); length = br.ReadUInt32(); checksum = br.ReadBytes(4); switch (strcmd) { case "addr": payload = Addr.FromStream(s); break; case "alert": payload = Alert.FromStream(s); break; case "block": payload = Block.FromStream(s); break; case "getaddr": payload = GetAddr.FromStream(s); break; case "getblocks": payload = GetBlocks.FromStream(s); break; case "getdata": payload = GetData.FromStream(s); break; case "getheaders": payload = GetHeaders.FromStream(s); break; case "headers": payload = Headers.FromStream(s); break; case "inv": payload = Inv.FromStream(s); break; case "ping": payload = Ping.FromStream(s); break; case "tx": payload = Tx.FromStream(s); break; case "verack": payload = VerAck.FromStream(s); break; case "version": payload = Version.FromStream(s); break; default: payload = UnknownPayload.FromStream(s, length, command); break; } }
public Message(String command, IPayload payload, bool TestNet = false) { SHA256 sha256 = new SHA256Managed(); Byte[] payloadBytes = payload.ToBytes(); if (!TestNet) this.magic = 0xD9B4BEF9; else this.magic = 0x0709110B; this.command = Encoding.ASCII.GetBytes(command).Concat(new Byte[12 - command.Length]).ToArray(); this.length = (UInt32)payloadBytes.Length; this.checksum = sha256.ComputeHash(sha256.ComputeHash(payloadBytes)).Take(4).ToArray(); this.payload = payload; }
public void Evaluate(int SpreadMax) { if (FWidth.IsChanged || FHeight.IsChanged || FMode.IsChanged || FBalanced.IsChanged) { switch (FMode[0]) { case PayloadMode.Graycode: { FPayload = new PayloadGraycode(FWidth[0], FHeight[0], FBalanced[0]); } break; } FOutput[0] = FPayload; FCount[0] = (int)FPayload.FrameCount; } }
/// <summary> /// Construct DTO model using payload object. /// The error code is ZERO and error message is NULL. /// </summary> /// <param name="payload">the DTO payload object</param> public DtoModelOutgoing(IPayload payload) { Payload = payload; Service = new ServiceObject(); }
public SimpleNotification(DeviceToken token, IPayload payload) { this.deviceToken = token; this.payload = payload; }
public void Reset() { ChunkType = 0; ChunkStreamId = 0; TimeStamp = 0; Length = 0; Type = default(PayloadType); MessageStreamId = 0; HasAbsTimestamp = false; BytesRead = 0; BytePayload = new byte[0]; Payload = default(IPayload); }
IFluentLogObject IFluentLogObject.WithExtraPayload(IPayload payload) { if (payload == null) throw new ArgumentNullException("payload"); PayloadTypes pldt; try { pldt = payload.GetType().GetPayloadType(); } catch (ArgumentException x) { throw new ArgumentException("Given payload is of unkown type.", x); } if ((this.PayloadTypes & pldt) == 0) this.PayloadTypes |= pldt; else throw new InvalidOperationException("The object already contains a payload of the same type." + Environment.NewLine + "Duplicated type: " + pldt); this.payloads.Add(payload); return this; }
/// <summary> /// Construct DTO model without payload object using WebApiServiceException. /// </summary> /// <param name="exception">the exception</param> public DtoModelOutgoing(ManagedException exception, IPayload errorDetails = null) { Payload = errorDetails; Service = new ServiceObject(exception.ErrorCode, exception.ErrorMessage); }
public void DecodePayload() { if (PayloadMapping.ContainsKey(Type)) { Payload = (IPayload) Activator.CreateInstance(PayloadMapping[Type]); Payload.Decode(BytePayload); } else { throw new ArgumentException("Type not found in map"); } }