Esempio n. 1
0
 public override Task <WorkingMode> UpdateWorkingMode(
     UpdateWorkingModeRequest request,
     ServerCallContext context)
 {
     return(this.Invoke(
                (client, request, deadline) => client.UpdateWorkingModeAsync(request, deadline),
                request.DeviceId,
                request,
                context));
 }
Esempio n. 2
0
        public async Task <WorkingMode> UpdateWorkingModeAsync(UpdateWorkingModeRequest request, DateTime?deadline)
        {
            if (request is null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            byte[] bytes = new byte[0x03];
            foreach (string path in request.UpdateMask.Paths)
            {
                switch (path)
                {
                case "device_working_mode":
                    bytes[0] = (byte)request.WorkingMode.DeviceWorkingMode;
                    break;

                case "device_flow_rate_control_mode":
                    bytes[1] = (byte)request.WorkingMode.DeviceFlowRateControlMode;
                    break;

                case "water_pump_working_mode":
                    bytes[2] = (byte)request.WorkingMode.WaterPumpWorkingMode;
                    break;

                default:
                    throw new InvalidDataException("Unrecognized update mask " + path);
                }
            }

            PlcFrame response = await this.InvokeAsync(
                PlcFrame.Create(PlcMessageType.UpdateWorkingModeRequest, ByteString.CopyFrom(bytes)),
                deadline)
                                .ConfigureAwait(false);

            if (response.FrameHeader.MessageType != PlcMessageType.GetWorkingModeResponse)
            {
                throw new InvalidDataException(
                          "Response message type mismatch: " + response.FrameHeader.MessageType);
            }

            using var reader = new BinaryReader(new MemoryStream(response.FrameBody.ToByteArray()));
            return(new WorkingMode
            {
                DeviceWorkingMode = (DeviceWorkingMode)reader.ReadByte(),
                DeviceFlowRateControlMode = (DeviceFlowRateControlMode)reader.ReadByte(),
                WaterPumpWorkingMode = (WaterPumpWorkingMode)reader.ReadByte(),
            });
        }
Esempio n. 3
0
        public override AsyncUnaryCall <WorkingMode> UpdateWorkingModeAsync(UpdateWorkingModeRequest request, Metadata headers = null, DateTime?deadline = null, CancellationToken cancellationToken = default)
        {
            WorkingMode workingMode = WorkingModes[request.DeviceId];

            if (request.UpdateMask == null)
            {
                workingMode.MergeFrom(request.WorkingMode);
            }
            else
            {
                request.UpdateMask.Merge(request.WorkingMode, workingMode);
            }

            return(TestCalls.AsyncUnaryCall(
                       Task.FromResult(workingMode),
                       Task.FromResult(new Metadata()),
                       () => Status.DefaultSuccess,
                       () => new Metadata(),
                       () => { }));
        }