/// <summary>
/// Constructor
/// </summary>
/// <param name="loggerService">Record errors and information during program execution</param>
/// <param name="wsService">Provide methods and events to communicate with websocket server</param>
public MessageService(LoggerService loggerService, WebSocketService wsService)
{
LoggerService = loggerService;
WsService = wsService;
wsService.OnData += RecieveWsData;
OnMessageHandlers = new List <Subscription>();
}
public void Connect_ServerExists_MessageEchoed()
{
// Arrange
EchoWebSocketServer server = new EchoWebSocketServer();
server.StartServer("0.0.0.0", 4040);
WebSocketService service = new WebSocketService();
string messageToSend = "hello";
string receivedMessage = string.Empty;
service.MessageReceived += (message) =>
{
receivedMessage = message;
};
// Act
service.Connect("ws://localhost:4040");
service.Send(messageToSend);
Thread.Sleep(100);
// Assert
Assert.Equal(messageToSend, receivedMessage);
// Clean up
server.Stop();
}
public ServerEventsViewModel(WebSocketService service)
{
Service = service;
Text = "No action";
Text2 = "1337";
IsPercentageVisible = false;
}
public async Task LongTaskAsync(WebSocketService webSocketService, CancellationToken cancellationToken, string taskId)
{
for (int i = 1; i < 10; ++i)
{
await Task.Delay(2000);
cancellationToken.ThrowIfCancellationRequested();
if (i == 5)
{
await webSocketService.SendSyncRequestToClient(taskId);
}
await webSocketService.ChangeViewModelForCurrentConnectionAsync((ServerEventsViewModel changes) =>
{
changes.Text = "task is running";
changes.Percentage = i;
});
await Task.Delay(2000);
}
await webSocketService.ChangeViewModelForCurrentConnectionAsync((ServerEventsViewModel changes) =>
{
changes.Text = "Task is Complete";
changes.Text2 = changes.Text2 + "Task is Complete";
changes.IsPercentageVisible = false;
});
}
/// <summary>
/// Отклонить входящий заказ.
/// </summary>
/// <param name="orderId"></param>
/// <returns></returns>
public async Task RejectAsync(int courierId, int orderId)
{
var courierShiftHistory = await _courierShiftHistoryService.FindCurrentOrNextAsync(courierId);
if (courierShiftHistory is null)
{
throw new AppException(AppMessage.UndefinedCourierShiftHistory);
}
//
var order = await _dbContext.Orders.FirstOrDefaultAsync(x => x.Id == orderId);
if (order.OrderStatusCode.IsFinal)
{
throw new AppException(AppMessage.OrderStatusIsCompleted);
}
order.CourierShiftHistoryId = null;
order.CourierId = null;
order.OrderStatusCodeId = (int)OrderStatusCode.CourierSelected;
var incomingOrder = new IncomingOrderHistory()
{
CourierShiftHistoryId = courierShiftHistory.Id,
OrderId = orderId,
StatusId = (int)IncomingOrderStatuses.Rejected,
UpdatedAt = DateTime.Now,
};
_dbContext.IncomingOrderHistories.Add(incomingOrder);
await _dbContext.SaveChangesAsync();
await WebSocketService.ShiftChanged(courierId);
}
private void ConfigureWebSockets(IApplicationBuilder app)
{
app.UseWebSockets();
var webSocketOptions = new WebSocketOptions()
{
KeepAliveInterval = TimeSpan.FromSeconds(120),
ReceiveBufferSize = 4 * 1024
};
//webSocketOptions.AllowedOrigins.Add("https://client.com");
app.UseWebSockets(webSocketOptions);
app.Use(async(context, next) =>
{
if (context.Request.Path == "/ws")
{
if (context.WebSockets.IsWebSocketRequest)
{
WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
await WebSocketService.HandleConnection(context, webSocket);
}
else
{
context.Response.StatusCode = 400;
}
}
else
{
await next();
}
});
}
static void Main()
{
WebServerLog.LogAdded += WebServerLog_LogAdded;
var server = new Server(new WebServerSettings(8000, 5000));
// add services
server.AddWebService(new HttpRequestParser());
server.AddWebService(new HttpHeaderPostParser());
server.AddWebService(new HttpHeaderSpecialAction());
server.AddWebService(new HttpResponseCreator());
server.AddWebService(new HttpSender());
// setup web socket
var websocket = new WebSocketService();
websocket.Add(new EchoEndpoint());
server.AddWebService(websocket);
// start server
server.Start();
// wait for console quit
while (Console.ReadKey().Key != ConsoleKey.Q)
{
;
}
// close
server.Stop();
websocket.Dispose();
}
public void Clear()
{
ID = default(int);
sClient = null;
//User.Logout();
User = null;
}
public static void Main (string[] args)
{
var wssv = new WebSocketService(81, false);
wssv.Start();
Console.WriteLine("\nPress Enter key to exit...");
Console.ReadLine();
wssv.Stop();
}
private void raiseSubscribingEvent(WebSocketService svc, SubscriptionContext Ctx)
{
var handler = Subscribing;
if (handler != null)
{
handler(svc, new NotifyChannelEventArgs {
Ctx = Ctx
});
}
}
/// <summary>
/// Disconnect from server
/// </summary>
/// <returns></returns>
public async Task DisconnectAsync()
{
Working = true;
try
{
await WebSocketService.CloseAsync();
}
finally
{
Working = false;
}
}
/// <summary>
/// Принять входящий заказ в работу.
/// </summary>
/// <param name="courierId"></param>
/// <param name="orderId"></param>
/// <returns></returns>
public async Task <IncomingOrderDto> AcceptAsync(int courierId, int orderId)
{
var pendingOrder = await GetOrderIfPendingAsync(courierId, orderId);
if (pendingOrder == null)
{
throw new AppException(new AppMessage(0, "Accept: Undefined error", HttpStatusCode.BadRequest));
}
var courierShiftHistory = await _courierShiftHistoryService.FindCurrentOrNextAsync(courierId);
if (courierShiftHistory is null)
{
throw new AppException(AppMessage.UndefinedCourierShiftHistory);
}
//
var order = await _dbContext.Orders.FirstOrDefaultAsync(x => x.Id == orderId);
if (order.OrderStatusCode.IsFinal)
{
throw new AppException(AppMessage.OrderStatusIsCompleted);
}
order.CourierShiftHistoryId = courierShiftHistory.Id;
order.OrderStatusCodeId = (int)OrderStatusCode.CourierAccepted;
var incomingOrder = new IncomingOrderHistory()
{
CourierShiftHistoryId = courierShiftHistory.Id,
OrderId = orderId,
StatusId = (int)IncomingOrderStatuses.Accepted,
UpdatedAt = DateTime.Now,
};
_dbContext.IncomingOrderHistories.Add(incomingOrder);
await _dbContext.SaveChangesAsync();
await WebSocketService.ShiftChanged(courierId);
// mocked
return(new IncomingOrderDto()
{
Id = orderId,
VendorLogo = pendingOrder.Vendor.Logo,
ClientName = pendingOrder.Client.Name,
Status = order.OrderStatusCode.Text,
TotalCost = pendingOrder.TotalCost
});
}
/// <summary>
/// Constructor
/// </summary>
public App()
{
string connectionString;
InitializeComponent();
#if __ANDROID__
connectionString = "ws://10.0.2.2:5000/ws";
#else
connectionString = "ws://localhost:5000/ws";
#endif
connectionString = "ws://beforeourtime.world:2024/ws";
// Required because of UWP 'release' build runtime error when traversing GetAssemblies()
Message.GetMessageTypeDictionary();
// Configure services
var loggerService = new LoggerService();
var wsService = new WebSocketService(loggerService, connectionString);
var messageService = new MessageService(loggerService, wsService);
var itemService = new ItemService(messageService);
var accountService = new AccountService(wsService, messageService);
var characterService = new CharacterService(accountService, messageService);
var gameService = new GameService(accountService, messageService);
var imageService = new ImageService(messageService);
var styleService = new StyleService();
// Configure Dependency Injection
var builder = new ContainerBuilder();
builder.RegisterInstance <ILoggerService>(loggerService).SingleInstance();
builder.RegisterInstance <IWebSocketService>(wsService).SingleInstance();
builder.RegisterInstance <IMessageService>(messageService).SingleInstance();
builder.RegisterInstance <IItemService>(itemService).SingleInstance();
builder.RegisterInstance <IAccountService>(accountService).SingleInstance();
builder.RegisterInstance <ICharacterService>(characterService).SingleInstance();
builder.RegisterInstance <IGameService>(gameService).SingleInstance();
builder.RegisterInstance <IImageService>(imageService).SingleInstance();
builder.RegisterInstance <IStyleService>(styleService).SingleInstance();
Container = builder.Build();
// Required because of UWP 'release' build runtime error when
// traversing GetAssemblies()
Message.GuidDictionaryErrors.ForEach(x =>
{
loggerService.Log(LogLevel.Error, x);
});
Resources = CreateStyles(styleService);
// Setup main page
MainPage = new NavigationPage(new ServerPage(Container))
{
BarBackgroundColor = Color.FromHex("606060"),
BarTextColor = Color.White,
BackgroundColor = Color.FromHex("202020")
};
}
static void Main(string[] args)
{
var router = new MyRouter(new JSONSerializer());
router.AddControllersFromAssemblies(typeof(Program).Assembly);
using (var server = new WebSocketService <MySession>(8181, router, router))
{
Console.WriteLine("Running. Press 'q' to quit");
while (Console.ReadLine() != "q")
{
}
}
}
public void Stop()
{
if (wsb != null)
{
threadReConnect.Abort();
threadReConnect = null;
ThreadRecordPriceDiff.Abort();
ThreadRecordPriceDiff = null;
wsb.stop();
wsb = null;
wss = null;
}
}
public OnlinePlayerService()
{
turnService = Container.get<TurnService>();
gameObserver = Container.get<GameObserver>();
socket = Container.get<WebSocketService>();
gameObserver.addListener("OnPlay", (message) => {
Play play = ((Message<Play>) message).message;
turnService.play(play);
});
gameObserver.addListener(Events.CARD_TO_TABLE, (message) => {
Play play = (Play) message;
if(play.player.playerType == PlayerType.LOCAL){
socket.sendMessage<Play>(new Message<Play>(
"Play",
play,
play.GetType().FullName
));
}
});
gameObserver.addListener("giveCards", (message) => {
Room room = ((Message<Room>) message).message;
turnService.currentRoom.players.ForEach((player) => {
var onPlayer = room.players.Find((play) => {
return play.id == player.id;
});
player.cards = onPlayer.cards;
});
});
gameObserver.addListener("cardsToPlayers", (message) => {
Room room = (Room) message;
if (turnService.isMaster) {
socket.sendMessage<Room>(new Message<Room>("giveCards", room, room.GetType().FullName));
}
});
}
public void HandleMessage(WebSocketService svc, MessageEventArgs args)
{
var msg = JObject.Parse(args.Data);
if (Ctx != null)
{
throw new WebsocketProtocol.ProtocolErrorException("already connected");
}
if (msg[PROPERTY_CONNECT] == null)
{
throw new WebsocketProtocol.ProtocolErrorException("connect is expected");
}
if (msg[PROPERTY_SUBSCRIBE] == null)
{
throw new WebsocketProtocol.ProtocolErrorException("subscribe is expected");
}
Ctx = new SubscriptionContext(
msg[PROPERTY_CONNECT][PROPERTY_DEVICE_ID].Value <string>(),
msg[PROPERTY_CONNECT][PROPERTY_DEVICE_NAME].Value <string>(),
svc);
var subsribe = msg[PROPERTY_SUBSCRIBE];
if (subsribe[PROPERTY_FILES_FROM_SEQ] != null)
{
Ctx.subscribe_files = true;
Ctx.files_from_seq = subsribe[PROPERTY_FILES_FROM_SEQ].Value <long>();
}
if (subsribe[PROPERTY_LABELS] != null)
{
Ctx.subscribe_labels = subsribe[PROPERTY_LABELS].Value <bool>();
Ctx.labels_from_seq = (subsribe[PROPERTY_LABELS_FROM_SEQ] != null) ? subsribe[PROPERTY_LABELS_FROM_SEQ].Value <long>() : 0;
}
if (subsribe[PROPERTY_DEVICES] != null)
{
Ctx.subscribe_devices = subsribe[PROPERTY_DEVICES].Value <bool>();
}
raiseSubscribingEvent(svc, Ctx);
}
public static IApplicationBuilder UseRedisMessagingHub(this IApplicationBuilder app)
{
app.UseWebSockets();
return(app.Use(async(context, next) =>
{
if (context.WebSockets.IsWebSocketRequest)
{
WebSocketService webSocketService = context.RequestServices.GetService <WebSocketService>();
await webSocketService.StartSocketListener(context);
}
else
{
await next.Invoke();
}
}));
}
public App()
{
InitializeComponent();
restApiManager = new RestApiManager(new RestApiService());
WebSocketService webSocketService;
var templist = new List <ASyncSocket>();
for (int i = 0; i < sources.Length; i++)
{
templist.Add(new ASyncSocket(sources[i].numericHostName, sources[i].port));
}
webSocketService = new WebSocketService(templist);
webSocketManager = new WebSocketManager(webSocketService);
MainPage = new MainPage();
}
/// <summary>
/// Attempt to authenticate, enumerate account characters, and attach to default character
/// </summary>
/// <returns>True if ready to play, false if one or more steps were unsuccessful</returns>
public async Task <bool> ConnectAsync()
{
var connected = false;
if (WebSocketService.GetState() == WebSocketState.Open)
{
var loginState = GetState();
if (GetState() == LoginState.Guest)
{
var account = GetAccount();
if (account?.Id != null)
{
await LoginAsync(account.Name, account.Password);
}
}
}
return(connected);
}
public async Task <NextStatus> UpdateStatus(int orderId, int statusId)
{
var order = await _dbContext.Orders
.FirstOrDefaultAsync(x => x.Id == orderId);
if (order is null)
{
throw new AppException(AppMessage.OrderNotExists);
}
int currentOrderStatusCodeId = order.OrderStatusCodeId;
int nextOrderStatusCodeId = 0;
if (order.OrderStatusCodeId == (int)OrderStatusCode.CourierAccepted)
{
currentOrderStatusCodeId = (int)OrderStatusCode.Prepared;
nextOrderStatusCodeId = (int)OrderStatusCode.Delivered;
}
else if (order.OrderStatusCodeId == (int)OrderStatusCode.Prepared)
{
currentOrderStatusCodeId = (int)OrderStatusCode.Delivered;
nextOrderStatusCodeId = -1;
}
order.OrderStatusCodeId = currentOrderStatusCodeId;
await _dbContext.SaveChangesAsync();
var nextOrderStatusCode = await GetOrderStatusCodeAsync(nextOrderStatusCodeId);
if (nextOrderStatusCode is null)
{
return(null);
}
var nextStatus = new NextStatus
{
Id = nextOrderStatusCode.Id,
Name = nextOrderStatusCode.Text
};
await WebSocketService.ShiftChanged((int)order.CourierId);
return(nextStatus);
}
public async Task Invoke(HttpContext httpContext)
{
if (httpContext.Request.Path == "/ws")
{
if (httpContext.WebSockets.IsWebSocketRequest)
{
WebSocket webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
await WebSocketService.ProcessWebSocket(httpContext, webSocket, this._broker);
}
else
{
httpContext.Response.StatusCode = 400;
}
}
else
{
await _nextDelegate.Invoke(httpContext);
}
}
static void Main()
{
var server = new Server(new WebServerSettings(8002, 5000));
server.AddWebService(new HttpRequestParser());
server.AddWebService(new HttpHeaderSpecialAction());
server.AddWebService(new Http404Service());
server.AddWebService(new HttpResponseCreator());
server.AddWebService(new HttpSender());
server.AddWebService(new TaskGame.SpecialFileService());
var searcher = new HttpDocumentFinder();
if (System.Diagnostics.Debugger.IsAttached)
{
searcher.Add(new HttpDocumentFinder.Rule("/content/", "../../../content/", false, true));
}
else
{
searcher.Add(new HttpDocumentFinder.Rule("/content/", "content/", false, true));
}
server.AddWebService(searcher);
server.AddWebService(new HttpDirectoryMapper(false));
using var webSocket = new WebSocketService();
webSocket.Add(new TaskGame.GameEndpoint());
server.AddWebService(webSocket);
server.Start();
while (Console.ReadKey().Key != ConsoleKey.Q)
{
;
}
server.Stop();
}
public void Start()
{
if (wsb == null)
{
wss = new BuissnesServiceImpl();
wsb = new WebSocketBase(SelectedUrl, wss);
wsb.start();
//var dict = new Dictionary<string, string>();
//dict.Add("api_key", ConfigInfo.apiKey);
//wsb.send("{\"event\":\"login\",\"parameters\":{\"api_key\":\"" + ConfigInfo.apiKey + "\",\"sign\":\"" + SignParams(dict) + "\"}}");//登录
//wsb.send("{'event':'addChannel','channel':'ok_sub_futureusd_btc_ticker_this_week'}");
//wsb.send("{'event':'addChannel','channel':'ok_sub_futureusd_btc_ticker_next_week'}");
//wsb.send("{'event':'addChannel','channel':'ok_sub_futureusd_btc_ticker_quarter'}");
ChangeChannel(WSChannelChangeType.Add, WSChannel.ThisWeekChannel);
ChangeChannel(WSChannelChangeType.Add, WSChannel.NextWeekChannel);
if (threadReConnect == null)
{
threadReConnect = new Thread(new ThreadStart(Reconnect))
{
IsBackground = true
};
threadReConnect.Start();
}
if (ThreadRecordPriceDiff == null)
{
ThreadRecordPriceDiff = new Thread(new ThreadStart(LogPriceDiff))
{
IsBackground = true
};
ThreadRecordPriceDiff.Start();
}
}
}
/// <summary>
/// Creates a new ActiveMQ consumer in order to listen to incoming sensor measurements.
/// </summary>
/// <param name="configuration">Application configuration.</param>
/// <param name="lifetime">Host application lifetime.</param>
/// <param name="dataService">The data service.</param>
/// <param name="webSocketService">The websocket service.</param>
private void CreateQueueConsumer(IConfigurationSection configuration,
IHostApplicationLifetime lifetime,
DataService dataService,
WebSocketService webSocketService)
{
_consumer = new Consumer(dataService, webSocketService);
var thread = new Thread((Object stateInfo) => _consumer.Listen());
string connectionString = configuration.GetValue <string>("ConnectionString");
string queue = configuration.GetValue <string>("Name");
// Run the consumers in a specific order, to ensure the consumer always disconnects nicely.
try
{
lifetime.ApplicationStopping.Register(() => _consumer.Disconnect());
_consumer.Connect(connectionString, queue);
thread.Start();
}
catch (Exception exception)
{
Console.Error.WriteLine($"Unable to start queue consumer: {exception.Message}");
lifetime.StopApplication();
}
}
/// <summary>
/// Creates a new consumer.
/// </summary>
/// <param name="dataService">The data service.</param>
/// <param name="webSocketService">The websocket service.</param>
public Consumer(DataService dataService, WebSocketService webSocketService)
{
_dataService = dataService;
_webSocketService = webSocketService;
}
public LocalPlayerService()
{
gameObserver = Container.get<GameObserver>();
socket = Container.get<WebSocketService>();
turnService = Container.get<TurnService>();
}
public HttpServer(CommandRunner commandRunner, RestService restService, WebSocketService webSocketService)
{
this.commandRunner = commandRunner;
this.restService = restService;
this.webSocketService = webSocketService;
}
private System.Timers.Timer t = new System.Timers.Timer(2000); //
public WebSocketBase(string url,WebSocketService webService)
{
this.webService = webService;
this.url = url;
}
public TurnService()
{
socket = Container.get<WebSocketService>();
cardStrategy = Container.get<DataSourceStrategy<Card>>();
}
public InitGameState(WebSocketService webSocketService)
{
_webSocketService = webSocketService;
}
public Startup()
{
applicationContext = ApplicationContext.Global;
webSocketService = applicationContext.Resolve <WebSocketService>();
}
public WebSocketMiddleware(RequestDelegate next, WebSocketService webSocketService)
{
_next = next;
_webSocketService = webSocketService;
}
public MessagesController(IMessagesRepository messagesRepository, WebSocketService webSocketService)
{
_messagesRepository = messagesRepository;
_webSocketService = webSocketService;
}
public WebSocketBase(string url, WebSocketService webService)
{
this.webService = webService;
this.url = url;
}
