public void JsonSerialization_ReturnsCorrectJson()
{
var response = new InitializeResponse(MessageResponseCode.Success);
var json = TestUtilities.Serialize(response);
Assert.Equal("{\"ResponseCode\":\"Success\"}", json);
}
private async Task <InitializeResponse> InitializeAsync(uint passNumber, CancellationToken ct)
{
InitializeResponse response = new InitializeResponse();
response.IsSuccess = false;
response.IsEchoed = false;
response.VersionName = string.Empty;
List <byte> txFrame = new List <byte>();
List <byte> rxFrame = new List <byte>();
myCommMainCtrl.PurgeReceiveBuffer();
txFrame = myCommInstructions.MakeTryConnectionRequest(passNumber);
await myCommMainCtrl.PushAsync(txFrame);
while (true)
{
rxFrame = await myCommMainCtrl.PullAsync(ct);
if (rxFrame.Count == 0)
{
break;
}
if (ct.IsCancellationRequested == true)
{
break;
}
if (myCommInstructions.IsResponseValid(txFrame, rxFrame))
{
if (txFrame.SequenceEqual(rxFrame))
{
response.IsEchoed = true;
}
else
{
rxFrame.RemoveAt(0); // remove unnecessary header data
rxFrame.RemoveAt(rxFrame.Count - 1); // remove unnecessary crc data
var endIndex = rxFrame.Count() - 1;
if (rxFrame[endIndex] == 0x00)
{
rxFrame.RemoveAt(endIndex); // remove null data
}
response.IsSuccess = true;
response.VersionName = System.Text.Encoding.ASCII.GetString(rxFrame.ToArray());
}
break;
}
}
return(response);
}
public void SendInitializeAffirmToCenter(MasProtocol Protocol, string point, ushort crc)
{
InitializeResponse ResponseObject = new InitializeResponse();
Protocol.ProtocolType = ProtocolType.InitializeResponse;
ResponseObject.StationCrc = crc;
ResponseObject.DeviceCode = point;
Protocol.Protocol = ResponseObject;
}
private void ProcessInitialize(InitializeResponse response)
{
if (response.Result == InitializeResult.Success)
{
Scheduler.Schedule(this.thread, Job.Create(new Action(this.Heartbeat)), new TimeSpan(0, 0, 30));
}
if (this.InitializeResponsed != null)
{
this.InitializeResponsed(response);
}
}
private void connection_PacketReceive(object sender, EventArgs <ArraySegment <byte> > e)
{
Packet packet = new Packet(e.Value);
switch (packet.PacketType)
{
case PacketType.Initialize:
{
InitializeResponse arg = new InitializeResponse(ref packet);
this.thread.Enqueue(Job.Create <InitializeResponse>(new Action <InitializeResponse>(this.ProcessInitialize), arg));
return;
}
case PacketType.Login:
{
LoginResponse arg2 = new LoginResponse(ref packet);
this.thread.Enqueue(Job.Create <LoginResponse>(new Action <LoginResponse>(this.ProcessLogin), arg2));
return;
}
case PacketType.Logout:
break;
case PacketType.Terminate:
{
TerminateRequest arg3 = new TerminateRequest(ref packet);
this.thread.Enqueue(Job.Create <TerminateRequest>(new Action <TerminateRequest>(this.ProcessTerminate), arg3));
break;
}
case PacketType.Message:
{
MessageRequest arg4 = new MessageRequest(ref packet);
this.thread.Enqueue(Job.Create <MessageRequest>(new Action <MessageRequest>(this.ProcessMessage), arg4));
return;
}
case PacketType.Synchronize:
{
SynchronizeRequest arg5 = new SynchronizeRequest(ref packet);
this.thread.Enqueue(Job.Create <SynchronizeRequest>(new Action <SynchronizeRequest>(this.ProcessSync), arg5));
return;
}
default:
return;
}
}
private void connection_InitializeResponsed(InitializeResponse response)
{
Log <CafeAuthService> .Logger.InfoFormat("Initialize response from Session server: [{0}]", response);
InitializeResult result = response.Result;
if (result == InitializeResult.Success)
{
Log <CafeAuthService> .Logger.WarnFormat("Successfully initialized with DoaminSN {0}", response.DomainSN);
CafeAuthService.AddCafeAuthServiceLog(this.journalID, "InitializeResponse", "Success", "");
return;
}
Log <CafeAuthService> .Logger.FatalFormat("Initialization failed ({0}) with DoaminSN {1}: {2}", response.Result, response.DomainSN, response.Message);
CafeAuthService.AddCafeAuthServiceLog(this.journalID, "InitializeResponse", response.Result.ToString().Substring(0, Math.Min(response.Result.ToString().Length, 19)), response.Message.Substring(0, Math.Min(response.Message.Length, 29)));
Scheduler.Schedule(base.Thread, Job.Create(new Action(this.connection.RequestInitialize)), 10000);
}
/// <summary>
/// 应答核心业务逻辑层的初始化接收确认。
/// </summary>
/// <param name="Fzh"></param>
private void SendInitializeAffirmToCenter(string Fzh)
{
ProtocolDataCreatedEventArgs upData = new ProtocolDataCreatedEventArgs();
InitializeResponse cData = new InitializeResponse();//初始化应答数据
DeviceInfo def = Cache.CacheManager.QueryFrist <DeviceInfo>(p => p.Fzh == Convert.ToInt16(Fzh) && p.DevPropertyID == 0, true);
if (def == null)
{
return;
}
upData.DriverCode = this.DriverCode;
upData.DeviceCode = def.Point;
upData.MasProtocol = new MasProtocol(SystemType.Security, DirectionType.Up, ProtocolType.InitializeResponse);
upData.MasProtocol.DeviceNumber = Convert.ToUInt16(Fzh);
cData.DeviceCode = def.Point;
upData.MasProtocol.Protocol = cData;
OnProtocolData(upData);
}
/// <summary>
/// Handles incoming <see cref="Packet"/> objects.
/// </summary>
/// <param name="p"><see cref="Packet"/> to handle.</param>
internal void Handle(Packet p)
{
Logger.WriteLine("Received {0}", p.ToString());
switch (p.FirstOpcode)
{
case ServiceLayer.Identity:
{
switch (p.SecondOpcode)
{
case ServiceLayer.InitializeRequest:
{
return; // login service not handles incoming connections.
}
case ServiceLayer.InitializeResponse: // connection init response
{
InitializeResponse data = new InitializeResponse(p);
switch (data.Answer)
{
case InitializeResponse.Accepted:
{
Logger.WriteLine(Source.InnerNetwork, "Connected to {0} (0x{1})", GameServiceConnection.Connection.ServiceType, GameServiceConnection.Connection.ServiceID.ToString("x2"));
return;
}
case InitializeResponse.Rejected:
{
Logger.WriteLine(Source.InnerNetwork, "Connection rejected by remote service {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
return;
}
}
return;
}
}
break;
}
}
Logger.WriteLine("Unknown packet received from {0} service on layer 0x{1}:{2}{3}", ServiceType.GameService, p.FirstOpcode.ToString("x2"), Environment.NewLine, p.ToString());
}
protected override void HandleInitializeRequestAsync(IRequestResponder <InitializeArguments, InitializeResponse> responder)
{
var response = new InitializeResponse
{
SupportsConfigurationDoneRequest = true,
SupportsEvaluateForHovers = true,
SupportsStepBack = true,
SupportsStepInTargetsRequest = true,
SupportTerminateDebuggee = false,
SupportsRestartRequest = false,
SupportsRestartFrame = false,
SupportedChecksumAlgorithms = new List <ChecksumAlgorithm> {
ChecksumAlgorithm.SHA256
}
};
responder.SetResponse(response);
Protocol.SendEvent(new InitializedEvent());
CompletedInitializationRequest.SetResult(null);
}
protected override InitializeResponse HandleInitializeRequest(InitializeArguments arguments)
{
if (arguments.LinesStartAt1 == true)
{
this.clientsFirstLine = 1;
}
var res = new InitializeResponse()
{
SupportsConfigurationDoneRequest = true,
SupportsSetVariable = true,
SupportsConditionalBreakpoints = true,
SupportsDebuggerProperties = true,
SupportsSetExpression = true,
SupportsExceptionOptions = true,
SupportsExceptionConditions = true,
SupportsExceptionInfoRequest = true,
SupportsValueFormattingOptions = true,
SupportsEvaluateForHovers = true,
};
return(res);
}
protected override void HandleInitializeRequestAsync(IRequestResponder <InitializeArguments, InitializeResponse> responder)
{
var response = new InitializeResponse
{
SupportsConfigurationDoneRequest = true,
SupportsEvaluateForHovers = true,
SupportsStepBack = true,
SupportsStepInTargetsRequest = true,
SupportTerminateDebuggee = false,
SupportsRestartRequest = false,
SupportsRestartFrame = false,
SupportedChecksumAlgorithms = new List <ChecksumAlgorithm> {
ChecksumAlgorithm.SHA256
},
SupportsExceptionInfoRequest = true
};
response.ExceptionBreakpointFilters = new List <ExceptionBreakpointsFilter>
{
new ExceptionBreakpointsFilter
{
Filter = EXCEPTION_BREAKPOINT_FILTER_ALL,
Label = EXCEPTION_BREAKPOINT_FILTER_ALL,
Default = false
},
new ExceptionBreakpointsFilter
{
Filter = EXCEPTION_BREAKPOINT_FILTER_UNHANDLED,
Label = EXCEPTION_BREAKPOINT_FILTER_UNHANDLED,
Default = true
}
};
responder.SetResponse(response);
Protocol.SendEvent(new InitializedEvent());
CompletedInitializationRequest.SetResult(null);
}
public async Task HandleInitializeRequest()
{
// Setup:
// ... Create an initialize handler and register it in the service host
var mockHandler = new Mock <Func <InitializeParameters, IEventSender, Task> >();
mockHandler.Setup(f => f(It.IsAny <InitializeParameters>(), It.IsAny <IEventSender>()))
.Returns(Task.FromResult(true));
var sh = GetServiceHost();
sh.RegisterInitializeTask(mockHandler.Object);
sh.RegisterInitializeTask(mockHandler.Object);
// ... Set a dummy value to return as the initialize response
var ir = new InitializeResponse();
// ... Create a mock request that will handle sending a result
// TODO: Replace with event flow validation
var initParams = new InitializeParameters();
var bc = new BlockingCollection <Message>();
var mockContext = new RequestContext <InitializeResponse>(Message.CreateRequest(InitializeRequest.Type, CommonObjects.MessageId, initParams), bc);
// If: I handle an initialize request
await sh.HandleInitializeRequest(initParams, mockContext);
// Then:
// ... The mock handler should have been called twice
mockHandler.Verify(h => h(initParams, mockContext), Times.Exactly(2));
// ... There should have been a response sent
var outgoing = bc.ToArray();
Assert.Single(outgoing);
Assert.Equal(CommonObjects.MessageId, outgoing[0].Id);
Assert.Equal(JToken.FromObject(ir), JToken.FromObject(ir));
}
public void Constructor_InitializesResponseCodeProperty()
{
var response = new InitializeResponse(MessageResponseCode.Success);
Assert.Equal(MessageResponseCode.Success, response.ResponseCode);
}
async Task <InitializeResponse> IRequestHandler <InitializeRequestArguments, InitializeResponse> .Handle(
InitializeRequestArguments request,
CancellationToken cancellationToken
)
{
_settingsBag.ClientSettings = request;
await DebugAdapterEventingHelper.Run(
_initializeDelegates,
(handler, ct) => handler(this, request, ct),
_initializeHandlers.Union(_collection.Select(z => z.Handler).OfType <IOnDebugAdapterServerInitialize>()),
(handler, ct) => handler.OnInitialize(this, request, ct),
_concurrency,
cancellationToken
).ConfigureAwait(false);
var response = new InitializeResponse {
AdditionalModuleColumns = _capabilities.AdditionalModuleColumns,
ExceptionBreakpointFilters = _capabilities.ExceptionBreakpointFilters,
SupportedChecksumAlgorithms = _capabilities.SupportedChecksumAlgorithms,
SupportsCompletionsRequest = _capabilities.SupportsCompletionsRequest || _collection.ContainsHandler(typeof(ICompletionsHandler)),
SupportsConditionalBreakpoints = _capabilities.SupportsConditionalBreakpoints,
SupportsDataBreakpoints = _capabilities.SupportsDataBreakpoints ||
_collection.ContainsHandler(typeof(IDataBreakpointInfoHandler)) || _collection.ContainsHandler(typeof(ISetDataBreakpointsHandler)),
SupportsDisassembleRequest = _capabilities.SupportsDisassembleRequest || _collection.ContainsHandler(typeof(IDisassembleHandler)),
SupportsExceptionOptions = _capabilities.SupportsExceptionOptions,
SupportsFunctionBreakpoints = _capabilities.SupportsFunctionBreakpoints || _collection.ContainsHandler(typeof(ISetFunctionBreakpointsHandler)),
SupportsLogPoints = _capabilities.SupportsLogPoints,
SupportsModulesRequest = _capabilities.SupportsModulesRequest || _collection.ContainsHandler(typeof(IModuleHandler)),
SupportsRestartFrame = _capabilities.SupportsRestartFrame || _collection.ContainsHandler(typeof(IRestartFrameHandler)),
SupportsRestartRequest = _capabilities.SupportsRestartRequest || _collection.ContainsHandler(typeof(IRestartHandler)),
SupportsSetExpression = _capabilities.SupportsSetExpression || _collection.ContainsHandler(typeof(ISetExpressionHandler)),
SupportsSetVariable = _capabilities.SupportsSetVariable || _collection.ContainsHandler(typeof(ISetVariableHandler)),
SupportsStepBack = _capabilities.SupportsStepBack ||
_collection.ContainsHandler(typeof(IStepBackHandler)) && _collection.ContainsHandler(typeof(IReverseContinueHandler)),
SupportsTerminateRequest = _capabilities.SupportsTerminateRequest || _collection.ContainsHandler(typeof(ITerminateHandler)),
SupportTerminateDebuggee = _capabilities.SupportTerminateDebuggee,
SupportsConfigurationDoneRequest = _capabilities.SupportsConfigurationDoneRequest || _collection.ContainsHandler(typeof(IConfigurationDoneHandler)),
SupportsEvaluateForHovers = _capabilities.SupportsEvaluateForHovers,
SupportsExceptionInfoRequest = _capabilities.SupportsExceptionInfoRequest || _collection.ContainsHandler(typeof(IExceptionInfoHandler)),
SupportsGotoTargetsRequest = _capabilities.SupportsGotoTargetsRequest || _collection.ContainsHandler(typeof(IGotoTargetsHandler)),
SupportsHitConditionalBreakpoints = _capabilities.SupportsHitConditionalBreakpoints,
SupportsLoadedSourcesRequest = _capabilities.SupportsLoadedSourcesRequest || _collection.ContainsHandler(typeof(ILoadedSourcesHandler)),
SupportsReadMemoryRequest = _capabilities.SupportsReadMemoryRequest || _collection.ContainsHandler(typeof(IReadMemoryHandler)),
SupportsTerminateThreadsRequest = _capabilities.SupportsTerminateThreadsRequest || _collection.ContainsHandler(typeof(ITerminateThreadsHandler)),
SupportsValueFormattingOptions = _capabilities.SupportsValueFormattingOptions,
SupportsDelayedStackTraceLoading = _capabilities.SupportsDelayedStackTraceLoading,
SupportsStepInTargetsRequest = _capabilities.SupportsStepInTargetsRequest || _collection.ContainsHandler(typeof(IStepInTargetsHandler)),
SupportsCancelRequest = _capabilities.SupportsCancelRequest || _collection.ContainsHandler(typeof(ICancelHandler)),
SupportsClipboardContext = _capabilities.SupportsClipboardContext,
SupportsInstructionBreakpoints = _capabilities.SupportsInstructionBreakpoints || _collection.ContainsHandler(typeof(ISetInstructionBreakpointsHandler)),
SupportsSteppingGranularity = _capabilities.SupportsSteppingGranularity,
SupportsBreakpointLocationsRequest = _capabilities.SupportsBreakpointLocationsRequest || _collection.ContainsHandler(typeof(IBreakpointLocationsHandler))
};
_settingsBag.ServerSettings = response;
await DebugAdapterEventingHelper.Run(
_initializedDelegates,
(handler, ct) => handler(this, request, response, ct),
_initializedHandlers.Union(_collection.Select(z => z.Handler).OfType <IOnDebugAdapterServerInitialized>()),
(handler, ct) => handler.OnInitialized(this, request, response, ct),
_concurrency,
cancellationToken
).ConfigureAwait(false);
_receiver.Initialized();
_initializeComplete.OnNext(response);
_initializeComplete.OnCompleted();
return(response);
}
/// <summary>
/// Emits a response with initialization status.
/// </summary>
/// <param name="response"></param>
public static void EmitInitializeResponse(InitializeResponse response)
{
EmitSerializedOutput(AvailableCommand.Initialize, response);
}
private async void OnClientDataReceived(object sender, ClientDataReceivedEventArgs e)
{
byte[] bytes = e._dataBytes;
string receiveStr = DataHelper.ByteArrayToHexString(bytes);
//用于确认连接成功的
if (receiveStr == "10010000")
{
await _client.SendAsync(DataHelper.HexStringToByteArray("11010010"));
}
else
{
Object obj = (Object)DataHelper.DeserializeWithBinary(bytes);
Type type = obj.GetType();
//操作模式的反馈
if (type == typeof(OperationModeResponse))
{
OperationModeResponse operationModeResponse = obj as OperationModeResponse;
if (operationModeResponse.Response == "OfflineIsOk")
{
operationMode = "offline";
}
if (operationModeResponse.Response == "OnlineIsOk")
{
operationMode = "online";
}
//operationMode = operationModeResponse.Response;
MessageBox.Show(operationModeResponse.Response);
}
//初始化的反馈
if (type == typeof(InitializeResponse))
{
InitializeResponse initializeResponse = obj as InitializeResponse;
MessageBox.Show(initializeResponse.Response);
}
#region 来自PLC相关的数据
//入库上料反馈
if (type == typeof(WarehousePLCInputLoadTrayResponse))
{
WarehousePLCInputLoadTrayResponse classPLCInputLoadTrayResponse = obj as WarehousePLCInputLoadTrayResponse;
MessageBox.Show(classPLCInputLoadTrayResponse.InputLoadTrayResponse);
}
//读取RFID的反馈
if (type == typeof(WarehousePLCReadRFIDResponse))
{
WarehousePLCReadRFIDResponse classPLCReadRFIDResponse = obj as WarehousePLCReadRFIDResponse;
InputOldRFIDNumber = classPLCReadRFIDResponse.ReadRFIDResponse;
}
//写入RFID的反馈
if (type == typeof(WarehousePLCWriteRFIDResponse))
{
WarehousePLCWriteRFIDResponse WarehousePLCWriteRFIDResponse = obj as WarehousePLCWriteRFIDResponse;
MessageBox.Show(WarehousePLCWriteRFIDResponse.WriteRFIDResponse);
}
//入库执行的反馈
if (type == typeof(WarehousePLCInputExecuteResponse))
{
WarehousePLCInputExecuteResponse classPLCInputExecuteResponse = obj as WarehousePLCInputExecuteResponse;
MessageBox.Show(classPLCInputExecuteResponse.InputExecuteResponseStorageLocation.ToString());
MessageBox.Show(classPLCInputExecuteResponse.InputExecuteResponseResult);
}
//出库执行的反馈
if (type == typeof(WarehousePLCOutputExecuteResponse))
{
WarehousePLCOutputExecuteResponse WarehousePLCOutputExecuteResponse = obj as WarehousePLCOutputExecuteResponse;
MessageBox.Show(WarehousePLCOutputExecuteResponse.OutputExecuteResponseStorageLocation.ToString());
MessageBox.Show("出库状态" + WarehousePLCOutputExecuteResponse.OutputExecuteResponseResult);
}
#endregion
#region 来自AGV相关的数据
if (type == typeof(AGVQueryCurrentPositionResponse))
{
AGVQueryCurrentPositionResponse classAGVQueryCurrentPositionResponse = obj as AGVQueryCurrentPositionResponse;
switch (classAGVQueryCurrentPositionResponse.QueryCurrentPositionResponse)
{
case 1: AGVCurrentPosition = "入库点"; break;
case 2: AGVCurrentPosition = "出库点"; break;
case 3: AGVCurrentPosition = "对接平台点"; break;
case 10: AGVCurrentPosition = "原点"; break;
default: break;
}
}
if (type == typeof(AGVTaskResponse))
{
AGVTaskResponse classAGVTaskResponse = obj as AGVTaskResponse;
switch (classAGVTaskResponse.TaskResponse)
{
case 1: MessageBox.Show("到达入库点！"); break;
case 2: MessageBox.Show("到达出库点！"); break;
case 3: MessageBox.Show("到达对接平台点！"); break;
case 10: MessageBox.Show("回原点完成！"); break;
case 6: MessageBox.Show("放料盘完成！"); break;
case 7: MessageBox.Show("进料盘完成！"); break;
default: break;
}
}
#endregion
#region 来自CloudPlatform相关的数据
//获取所有的库位信息，用于显示
if (type == typeof(List <CloudPlatformStorageQueryResponse>))
{
List <CloudPlatformStorageQueryResponse> classStorageQueryShowResponses = obj as List <CloudPlatformStorageQueryResponse>;
App.Current.Dispatcher.Invoke(() => { _storagesList.Clear(); });//更新新的数据之前先清空列表
//List<StorageInfoModel> test = new List<StorageInfoModel>();
foreach (var item in classStorageQueryShowResponses)
{
var list = new StorageInfoModel
{
Location = item.StorageQueryLocation,
Category = item.StorageQueryCategory,
Amount = item.StorageQueryAmount,
RFIDNumber = item.StorageQueryRFID,
EditStoragesInfo = item.StorageQueryCategory != "null",
EditOutput = item.StorageQueryCategory != "null"
};
App.Current.Dispatcher.Invoke(() => { _storagesList.Add(list); });
}
}
//获取所有的入库记录，用于显示
if (type == typeof(List <CloudPlatformQueryInputRecordResponse>))
{
List <CloudPlatformQueryInputRecordResponse> classQueryInputRecordResponses = obj as List <CloudPlatformQueryInputRecordResponse>;
App.Current.Dispatcher.Invoke(() => { _inputRecordList.Clear(); });//更新新的数据之前先清空列表
foreach (var item in classQueryInputRecordResponses)
{
var list = new InputRecordModel
{
RFIDNumber = item.QueryInputRecordResponseRFIDNumber,
Location = item.QueryInputRecordResponseLocation,
Amount = item.QueryInputRecordResponseAmount,
OperationTime = item.QueryInputRecordResponseOperationTime,
Category = item.QueryInputRecordResponseCategory
};
App.Current.Dispatcher.Invoke(() => { _inputRecordList.Add(list); });
}
}
//获取所有的出库记录用于显示
if (type == typeof(List <CloudPlatformQueryOutputRecordResponse>))
{
List <CloudPlatformQueryOutputRecordResponse> classQueryOutputRecordResponses = obj as List <CloudPlatformQueryOutputRecordResponse>;
App.Current.Dispatcher.Invoke(() => { _outputRecordList.Clear(); });//更新新的数据之前先清空列表
foreach (var item in classQueryOutputRecordResponses)
{
var list = new OutputRecordModel
{
Location = item.QueryOutputRecordResponseLocation,
RFIDNumber = item.QueryOutputRecordResponseRFIDNumber,
Amount = item.QueryOutputRecordResponseAmount,
OperationTime = item.QueryOutputRecordResponseOperationTime,
Category = item.QueryOutputRecordResponseCategory
};
App.Current.Dispatcher.Invoke(() => { _outputRecordList.Add(list); });
}
}
//获取所有的库位修改记录用于显示
if (type == typeof(List <CloudPlatformQueryModifyStorageRecordResponse>))
{
List <CloudPlatformQueryModifyStorageRecordResponse> cloudPlatformQueryModifyStorageRecordResponses = obj as List <CloudPlatformQueryModifyStorageRecordResponse>;
App.Current.Dispatcher.Invoke(() => { _modifyStorageRecordList.Clear(); });
foreach (var item in cloudPlatformQueryModifyStorageRecordResponses)
{
var list = new ModifyStorageRecordModel
{
Location = item.Location,
ModifyType = item.Type,
RFIDNumber = item.RFIDNumber,
Category = item.CategoryNew,
Amount = item.AmountNew,
ModifyTime = item.ModifyTime
};
App.Current.Dispatcher.Invoke(() => { _modifyStorageRecordList.Add(list); });
}
}
//手动维护库位信息的反馈
if (type == typeof(CloudPlatformModifyStorageInfoResponse))
{
CloudPlatformModifyStorageInfoResponse cloudPlatformModifyStorageInfoResponse = obj as CloudPlatformModifyStorageInfoResponse;
MessageBox.Show(cloudPlatformModifyStorageInfoResponse.Type.ToString());
MessageBox.Show(cloudPlatformModifyStorageInfoResponse.Location.ToString());
MessageBox.Show(cloudPlatformModifyStorageInfoResponse.RFIDNumber);
MessageBox.Show(cloudPlatformModifyStorageInfoResponse.CategoryNew);
MessageBox.Show(cloudPlatformModifyStorageInfoResponse.AmountNew.ToString());
MessageBox.Show(cloudPlatformModifyStorageInfoResponse.Result);
}
#endregion
}
}
internal static void Handle(Packet p)
{
//Logger.WriteLine(p.ToString());
switch (p.FirstOpcode)
{
case ServiceLayer.Identity:
{
switch (p.SecondOpcode)
{
case ServiceLayer.InitializeRequest:
{
return; // login service not handles incoming connections.
}
case ServiceLayer.InitializeResponse: // connection init response
{
InitializeResponse data = new InitializeResponse(p);
switch (data.Answer)
{
case InitializeResponse.Accepted:
{
CacheServiceConnection.Connection.SetRemoteService(data.RemoteServiceID, ( ServiceType )data.RemoteServiceType);
Logger.WriteLine(Source.InnerNetwork, "Authorized on {0} (0x{1})", CacheServiceConnection.Connection.ServiceType, CacheServiceConnection.Connection.ServiceID.ToString("x2"));
// send set-settings request if needed
World.StartUp();
return;
}
case InitializeResponse.Rejected:
{
Logger.WriteLine(Source.InnerNetwork, "Connection rejected by {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
return;
}
}
return;
}
case ServiceLayer.SetSettingsRequest:
{
return; // login service not handles remote service settings request
}
case ServiceLayer.SetSettingsResponse:
{
SetSettingsResponse response = new SetSettingsResponse(p);
switch (response.Response)
{
case SetSettingsResponse.Accepted:
{
Logger.WriteLine(Source.InnerNetwork, "Cache service accepted service settings.");
//UserConnectionsListener.Enable(); // start listen incoming user connections
return;
}
default:
{
Service.Terminate(new ServiceShutdownEventArgs("Cache service rejected settings setup."));
return;
}
}
}
default:
{
Logger.WriteLine("Unknown packet received on layer 0x{0}: {1}", ServiceLayer.Identity.ToString("x2"), p.ToString());
return;
}
}
}
case WorldDataLayer.Identity:
{
switch (p.SecondOpcode)
{
case WorldDataLayer.SetWorldActiveResponse:
Logger.WriteLine(Source.InnerNetwork, "World is ready for incoming user connections!");
break;
}
break;
}
}
}
internal static void Handle(Packet p)
{
switch (p.FirstOpcode)
{
case ServiceLayer.Identity:
{
switch (p.SecondOpcode)
{
case ServiceLayer.InitializeRequest:
{
return; // login service not handles incoming connections.
}
case ServiceLayer.InitializeResponse: // connection init response
{
InitializeResponse data = new InitializeResponse(p);
switch (data.Answer)
{
case InitializeResponse.Accepted:
{
CacheServiceConnection.Connection.SetRemoteService(data.RemoteServiceID, ( ServiceType )data.RemoteServiceType);
Logger.WriteLine(Source.InnerNetwork, "Connected to {0} (0x{1})", CacheServiceConnection.Connection.ServiceType, CacheServiceConnection.Connection.ServiceID.ToString("x2"));
// send set-settings request
//CacheServiceConnection.Send
// (
// new SetSettingsRequest().ToPacket
// (
// new LoginServiceSettings
// (
// Service.LocalServiceUniqueId,
// Service.AutoCreateUsers,
// Service.DefaultAccessLevel
// )
// )
// );
return;
}
case InitializeResponse.Rejected:
{
Logger.WriteLine(Source.InnerNetwork, "Connection rejected by remote service {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
return;
}
}
return;
}
case ServiceLayer.SetSettingsRequest:
{
return; // login service not handles remote service settings request
}
case ServiceLayer.SetSettingsResponse:
{
SetSettingsResponse response = new SetSettingsResponse(p);
switch (response.Response)
{
case SetSettingsResponse.Accepted:
{
Logger.WriteLine(Source.InnerNetwork, "Cache service accepted service settings.");
//UserConnectionsListener.Enable(); // start listen incoming user connections
return;
}
default:
{
Service.Terminate(new ServiceShutdownEventArgs("Cache service rejected settings setup."));
return;
}
}
}
default:
{
Logger.WriteLine("Unknown packet received on layer 0x{0}: {1}", ServiceLayer.Identity.ToString("x2"), p.ToString());
return;
}
}
}
}
}
/// <summary>
/// This function reads data from the csv files and write them into the database
/// Needs to be run once time
/// </summary>
public async Task <InitializeResponse> InitializeDB(InitializeRequest request)
{
var response = new InitializeResponse();
try
{
#region Validate
var currentDbRegions = await _db.Regions.ToListAsync();
var currentDbEmployees = await _db.Employees.ToListAsync();
if (currentDbRegions.Count > 0 || currentDbEmployees.Count > 0)
{
throw new Exception("Database Already Initialized");
}
#endregion
var currentpath = Directory.GetCurrentDirectory();
var regionsCsvPath = Path.Combine(currentpath, "CSV", "regions.csv");
var employeesCsvPath = Path.Combine(currentpath, "CSV", "employees.csv");
var regions = await File.ReadAllLinesAsync(regionsCsvPath);
var employees = await File.ReadAllLinesAsync(employeesCsvPath);
#region ReadRegions
var listRegions = new List <Regions>();
foreach (var region in regions)
{
string[] arr = new string[3];
//checking if starts with double quotes
if (region.StartsWith("\""))
{
arr[0] = region.Substring(region.IndexOf("\""), region.LastIndexOf("\"") + 1);
var ids = region.Replace(arr[0], "");
arr[1] = ids.Split(",")[1];
arr[2] = ids.Split(",")[2];
}
else
{
arr = region.Split(",");
}
// checking if contains any parent
int?idParent = null;
if (!string.IsNullOrEmpty(arr[2]))
{
idParent = Convert.ToInt32(arr[2]);
}
//checking if the data is valid, if not valid, skip current region
int id = 0;
int.TryParse(arr[1], out id);
if (id == 0)
{
continue;
}
listRegions.Add(new Regions()
{
Name = arr[0],
Id = id,
IdParent = idParent
});
}
_db.Regions.AddRange(listRegions);
#endregion
#region ReadEmployees
var listEmployees = new List <Employees>();
foreach (var employee in employees)
{
string[] arr = employee.Split(",");
listEmployees.Add(new Employees()
{
IdRegion = Convert.ToInt32(arr[0]),
FirstName = arr[1],
LastName = arr[2]
});
}
_db.Employees.AddRange(listEmployees);
#endregion
await _db.SaveChangesAsync();
response.Message = $"Inserted {listEmployees.Count} Employees and {listRegions} regions";
response.IsSuccess = true;
}
catch (Exception ex)
{
response.SetException(ex);
_logger.LogError(ex, ex.Message);
}
return(response);
}
/// <summary>
/// Handles incoming packet.
/// </summary>
/// <param name="p">Received <see cref="Packet"/> object.</param>
internal static void Handle(Packet p)
{
switch (p.FirstOpcode)
{
case ServiceLayer.Identity:
{
switch (p.SecondOpcode)
{
case ServiceLayer.InitializeRequest:
{
return; // login service not handles incoming connections.
}
case ServiceLayer.InitializeResponse: // connection init response
{
InitializeResponse data = new InitializeResponse(p);
switch (data.Answer)
{
case InitializeResponse.Accepted:
{
CacheServiceConnection.Connection.SetRemoteService(data.RemoteServiceID, ( ServiceType )data.RemoteServiceType);
Logger.WriteLine(Source.InnerNetwork, "Authorized on {0} (0x{1})", CacheServiceConnection.Connection.ServiceType, CacheServiceConnection.Connection.ServiceID.ToString("x2"));
// send set-settings request
CacheServiceConnection.Send
(
new SetSettingsRequest().ToPacket
(
new LoginServiceSettings
(
Settings.Default.ServiceUniqueID,
Settings.Default.LoginServiceAutoCreateUsers,
Settings.Default.LoginServiceDefaultAccessLevel
)
)
);
return;
}
case InitializeResponse.Rejected:
{
Logger.WriteLine(Source.InnerNetwork, "Connection rejected by {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
return;
}
}
return;
}
case ServiceLayer.SetSettingsRequest:
{
return; // login service not handles remote service settings request
}
case ServiceLayer.SetSettingsResponse:
{
SetSettingsResponse response = new SetSettingsResponse(p);
switch (response.Response)
{
case SetSettingsResponse.Accepted:
{
Logger.WriteLine(Source.InnerNetwork, "Cache service accepted service settings.");
//UserConnectionsListener.Enable(); // start listen incoming user connections
return;
}
default:
{
Service.Terminate(new ServiceShutdownEventArgs("Cache service rejected settings setup."));
return;
}
}
}
default:
{
Logger.WriteLine("Unknown packet received on layer 0x{0}: {1}", ServiceLayer.Identity.ToString("x2"), p.ToString());
return;
}
}
}
case UserDataLayer.Identity:
{
switch (p.SecondOpcode)
{
case UserDataLayer.UserAuthenticationResponse:
{
UserAuthenticationResponse response = new UserAuthenticationResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
switch (response.Response)
{
case UserAuthenticationResponseType.UserAccepted: // accepted or created by cache
{
request.UserConnection.Session.AccountID = response.UserID;
request.UserConnection.Session.LastWorld = response.LastWorldID;
if (response.AccessLevel < Settings.Default.LoginServiceAllowedAccessLevel)
{
request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.AccessFailed));
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
return;
}
long requestId = long.MinValue;
if (QueuedRequestsPool.Enqueue(request.UserConnection, ref requestId))
{
CacheServiceConnection.Send
(
new CacheUserSessionRequest
(
requestId,
request.UserConnection.Session
).ToPacket()
);
}
else
{
Logger.WriteLine(Source.InnerNetwork, "Failed to send CacheUserSessionRequest to cache service, request was not enqueued by QueuedRequestsPool ?...");
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
}
return;
}
default:
{
request.Send(LoginFailed.ToPacket(response.Response));
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
return;
}
}
}
break;
}
case UserDataLayer.CacheUserSessionResponse:
{
CacheUserSessionResponse response = new CacheUserSessionResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
switch (response.Response)
{
case CacheUserSessionResponse.Failed:
{
Logger.WriteLine("Failed to cache user session data on cache server side");
request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.SystemError));
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
return;
}
case CacheUserSessionResponse.Accepted:
{
request.Send(LoginOk.ToPacket(request.UserConnection.Session));
return;
}
}
}
else
{
Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
}
return;
}
case UserDataLayer.WorldsListResponse:
{
WorldsListResponse response = new WorldsListResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
request.Send(ServerList.ToPacket(request.UserConnection.Session.LastWorld, response.Data));
}
else
{
Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
}
return;
}
case UserDataLayer.JoinWorldResponse:
{
JoinWorldResponse response = new JoinWorldResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
switch (response.Result)
{
case JoinWorldRequestResult.Accepted:
{
request.UserConnection.Send(PlayAccepted.ToPacket(request.UserConnection.Session));
break;
}
default:
{
request.UserConnection.Send(PlayFail.ToPacket(response.Result));
break;
}
}
}
UserConnectionsListener.CloseConnectionWithoutLogout(request.UserConnection);
return;
}
}
break;
}
}
Logger.WriteLine("Unknown packet received from {0} service on layer 0x{1}:{2}{3}", ServiceType.LoginService, p.FirstOpcode.ToString("x2"), Environment.NewLine, p.ToString());
}
