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));
                }
            }
        }
Beispiel #2
0
        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);
        }
Beispiel #3
0
 public EnhancedNotification(DeviceToken deviceToken, IPayload payload, uint identifier, TimeSpan? expiry)
 {
     this.deviceToken = deviceToken;
     this.payload = payload;
     this.identifier = identifier;
     this.expiry = expiry;
 }
Beispiel #4
0
        /// <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();
            }
        }
Beispiel #5
0
        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++;
            }
        }
Beispiel #6
0
        private void OnPlayerShipSpawned(IPayload obj)
        {
            var data = (PlayerShipSpawnedPayload)obj;

            playerShip = data.Ship;
            playerShip.SetDependecies(gameStateHelper);
        }
Beispiel #7
0
 private Item(string internalReference, ICorrespondent source, ICorrespondent target, CorrespondenceRoute correspondenceRoute, IPayload payload)
 {
     this.internalReference = internalReference;
     this.source            = source;
     this.target            = target;
     this.payload           = payload;
 }
Beispiel #8
0
 public EnhancedNotification(DeviceToken deviceToken, IPayload payload, uint identifier, TimeSpan?expiry)
 {
     this.deviceToken = deviceToken;
     this.payload     = payload;
     this.identifier  = identifier;
     this.expiry      = expiry;
 }
Beispiel #9
0
 /// <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));
        }
Beispiel #11
0
        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);
        }
Beispiel #12
0
        private void OnUfoDestroyed(IPayload obj)
        {
            UFODestroyedPayload uFODestroyedPayload = (UFODestroyedPayload)obj;
            var ufo = uFODestroyedPayload.UFO as UFO;

            ufos.Remove(ufo);
        }
Beispiel #13
0
        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);
     }
 }
Beispiel #15
0
        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);
        }
Beispiel #16
0
 protected StoreActionContainer MakeContainer(StoreActionType type, IPayload data)
 {
     return(new StoreActionContainer()
     {
         type = type, data = data
     });
 }
Beispiel #17
0
        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));
        }
Beispiel #18
0
 public Running(Transition.IFactory transitionFactory, ILogic logic, IPayload payload, Config config, IScheduler scheduler)
 {
     _transitionFactory = transitionFactory;
     _logic             = logic;
     _payload           = payload;
     _config            = config;
     _scheduler         = scheduler;
 }
Beispiel #19
0
 public ProcessedPayload(IPayload payload)
 {
     if (payload != null)
     {
         Data     = payload.Data;
         Encoding = payload.Encoding;
     }
 }
Beispiel #20
0
 private void OnGameEnd(IPayload payload)
 {
     if (spawnCor != null)
     {
         parrentBehaviour.StopCoroutine(spawnCor);
     }
     RecycleAllAsteroids();
 }
Beispiel #21
0
 public SystemEvent(SystemEventTypesEnum eventType, long?correlationId, IPayload payload = null, string entityId = "")
 {
     EventType     = eventType;
     CorrelationId = correlationId;
     EntityId      = entityId;
     Payload       = payload;
     SystemTime    = DateTime.UtcNow;
 }
Beispiel #22
0
 public static IMessage Create(IPayload payload,
                               DistributionPattern distributionPattern = DistributionPattern.Unicast,
                               byte[] correlationId = null)
 => new Message(payload)
 {
     Distribution  = distributionPattern,
     CorrelationId = correlationId ?? EmptyCorrelationId
 };
Beispiel #23
0
 public void Send(IPayload payload)
 {
     if (!ShouldSendRequests())
     {
         return;
     }
     Delivery.Send(payload);
 }
Beispiel #24
0
 private void OnGameEnd(IPayload obj)
 {
     for (int source = 0; source < activeSources.Count; source++)
     {
         ResetStateOfAudioSource(activeSources[source]);
         RecycleToPool(activeSources[source]);
     }
 }
Beispiel #25
0
        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());
        }
Beispiel #27
0
        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);
            }
        }
Beispiel #28
0
        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));
        }
Beispiel #29
0
        public void PublishEvent(IPayload payload)
        {
            var eventName = payload.EventName;

            if (Instance.events.ContainsKey(eventName))
            {
                Instance.events[eventName].ForEach(method => method.Invoke(payload));
            }
        }
Beispiel #30
0
 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));
 }
Beispiel #31
0
        public static string GetCurrentEncoding(IPayload payload)
        {
            if (payload.Encoding.IsEmpty())
            {
                return(string.Empty);
            }

            return(payload.Encoding.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Last());
        }
Beispiel #32
0
        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;
            }
        }
Beispiel #33
0
 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;
			}
		}
Beispiel #35
0
 /// <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();
 }
Beispiel #36
0
 public SimpleNotification(DeviceToken token, IPayload payload)
 {
     this.deviceToken = token;
     this.payload = payload;
 }
Beispiel #37
0
 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);
 }
Beispiel #38
0
        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;
        }
Beispiel #39
0
 /// <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);
 }
Beispiel #40
0
 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");
     }
 }