protected virtual void OneTimeSetUp()
{
if (User == null)
{
User = new UserInfo
{
Login = ConfigurationManager.AppSettings["Login"],
ActiveWif = ConfigurationManager.AppSettings["ActiveWif"],
OwnerWif = ConfigurationManager.AppSettings["OwnerWif"]
};
Assert.IsFalse(string.IsNullOrEmpty(User.ActiveWif), "empty ActiveWif");
}
if (Api == null)
{
//HttpClient = new RepeatHttpClient();
//HttpManager = new HttpManager(HttpClient);
//Api = new OperationManager(HttpManager);
var ws = new WebSocketManager();
Api = new OperationManager(ws);
var url = ConfigurationManager.AppSettings["Url"];
Assert.IsTrue(Api.ConnectToAsync(url, CancellationToken.None).Result, "Enable connect to node");
var acc = Api.GetAccountByNameAsync(User.Login, CancellationToken.None).Result;
Assert.IsFalse(acc.IsError);
User.Account = acc.Result;
VerifyWif(User);
}
Assert.IsTrue(Api.IsConnected, "Enable connect to node");
}
public override string Execute(string jsonStr)
{
string returnJsonStr = string.Empty;
DBRepository dBRepository = new DBRepository();
try
{
UserLogoutModel model = JsonSerializer.Deserialize <UserLogoutModel>(jsonStr);
UserInfo userInfo = WebSocketManager.UserInfoDict[model.Token];
dBRepository.UserLogoutSP(userInfo.UserName);
BaseResponseModel responseModel = new BaseResponseModel();
responseModel.StatusCode = 1;
returnJsonStr = JsonSerializer.Serialize(responseModel);
WebSocketManager.RemoveUserInfoAndWebSocket(model.Token);
}
catch (Exception ex)
{
ErrorResponseModel responseModel = new ErrorResponseModel();
responseModel.StatusCode = 0;
responseModel.ErrorCode = "500";
responseModel.Message = ex.Message;
returnJsonStr = JsonSerializer.Serialize(responseModel);
}
return(returnJsonStr);
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
WebSocketManager wsmanager = WebSocketManager.Instance;
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
var websocketOptions = new WebSocketOptions()
{
ReceiveBufferSize = 4 * 1024
};
app.UseWebSockets(websocketOptions);
app.Use(async(context, next) =>
{
if (context.Request.Path.HasValue && context.Request.Path.Value.Contains("/ws"))
{
if (context.WebSockets.IsWebSocketRequest)
{
WebSocket ws = await context.WebSockets.AcceptWebSocketAsync();
await wsmanager.NewClientConnected(context, ws);
}
else
{
context.Response.StatusCode = 400;
}
}
else
{
await next();
}
});
}
private void Test_Load(object sender, EventArgs e)
{
checkFonePay = cd.FonePayCheck();
if (checkFonePay != "")
{
pictureBox1.ImageLocation = checkFonePay;
}
else
{
DataTable dt = blfp.getALLFonePayData();
if (dt.Rows.Count > 0)
{
secret_key = dt.Rows[0]["secret_key"].ToString();
user_name = dt.Rows[0]["user_name"].ToString();
password = Encryption.StringEncryption.Decrypt(dt.Rows[0]["password"].ToString(), "sblw-3hn8-sqoy19");
merchantCode = dt.Rows[0]["merchant_code"].ToString();
string dv = FonePayDataValidation.SHA512_keyHash(secret_key, amount + "," + prnNo + "," + merchantCode + ",Billing," + remarks2);
string abc = fpa.posFonePay(amount, remarks, remarks2, prnNo, merchantCode, dv.ToLower(), user_name, password);
JObject deserjson = JObject.Parse(abc);
string qrmessage = deserjson["qrMessage"].ToString();
wss = deserjson["thirdpartyQrWebSocketUrl"].ToString();
QRCodeGenerator qrgen = new QRCodeGenerator();
var qrdata = qrgen.CreateQrCode(qrmessage.ToString(), QRCodeGenerator.ECCLevel.H);
var qrcode = new QRCoder.QRCode(qrdata);
image = qrcode.GetGraphic(2);
pictureBox1.Image = image;
//WebSocketManager wsm = new WebSocketManager();
//wsm.connection(wss);
WebSocketManager.connection(wss);
}
}
}
public GolosClient(JsonNetConverter jsonConverter) : base(jsonConverter)
{
var jss = GetJsonSerializerSettings();
var cm = new WebSocketManager(jss);
_operationManager = new OperationManager(cm, jss);
}
//public StudentManager studentManager;
//public RopeManager ropeManager;
void Awake()
{
webSocketManager = FindObjectOfType<WebSocketManager>();
messageManager = FindObjectOfType<MessageManager>();
roleManager = FindObjectOfType<RoleManager>();
studentManager = FindObjectOfType<StudentManager>();
}
public JsonResult SelectPotion(int id)
{
var context = new PCContext();
var potion = context.Potions
.Where(m => m.Id == id)
.FirstOrDefault();
if (potion != null)
{
WebSocketManager.Broadcast(new ServerMessage()
{
Command = ServerMessage.Commands.Selected,
Content = POTION_HTML_ID_PREFIX + id
});
if (!potion.Selected)
{
potion.Selected = true;
context.SaveChanges();
}
return(Json(new JsonResponse <string>()
{
Code = 200,
Result = potion.Description
}, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new JsonResponse <string>()
{
Code = 404,
Result = "Not found"
}, JsonRequestBehavior.AllowGet));
}
}
public virtual void Uninitialize()
{
_features = default(FeatureReferences<FeatureInterfaces>);
if (_request != null)
{
UninitializeHttpRequest(_request);
_request = null;
}
if (_response != null)
{
UninitializeHttpResponse(_response);
_response = null;
}
if (_authenticationManager != null)
{
UninitializeAuthenticationManager(_authenticationManager);
_authenticationManager = null;
}
if (_connection != null)
{
UninitializeConnectionInfo(_connection);
_connection = null;
}
if (_websockets != null)
{
UninitializeWebSocketManager(_websockets);
_websockets = null;
}
}
protected virtual void OneTimeSetUp()
{
if (User == null)
{
User = new UserInfo
{
Login = ConfigurationManager.AppSettings["Login"],
PostingWif = ConfigurationManager.AppSettings["PostingWif"],
ActiveWif = ConfigurationManager.AppSettings["ActiveWif"]
};
}
Assert.IsFalse(string.IsNullOrEmpty(User.PostingWif), "empty PostingWif");
if (Api == null)
{
WebSocketManager = new WebSocketManager();
Api = new OperationManager(WebSocketManager);
var url = ConfigurationManager.AppSettings["Url"];
Api.ConnectTo(url, CancellationToken.None);
}
Assert.IsTrue(Api.IsConnected, "Enable connect to node");
}
void ObjWebSocket_OnMessage(WebSocketManager sender, CPqDWebSocketResultEventArgs e)
{
string result = "<None>";
try
{
result = System.Text.Encoding.UTF8.GetString(e.RawData);
WriteLog(result.Trim().Replace("\r\n", ", "));
}
catch (Exception ex)
{
WriteLog("ERROR: Retorno - " + result);
WriteLog("ERROR: " + ex.Message);
SendOnError("Erro na conversão das informações do servidor", "4025");
}
try
{
IdentifyResponse(result);
}
catch (Exception ex)
{
WriteLog("ERROR: Retorno - " + result);
WriteLog("ERROR: " + ex.Message);
SendOnError("Erro na interpretação dos dados do servidor", "4026");
}
}
public static IApplicationBuilder UseObservableControllerMiddleware <TController, TDataObject>(this IApplicationBuilder app) where TController : Controller, IObservableController <TDataObject>
{
app.UseMiddleware <ObservableControllerMiddleware <TController, TDataObject> >();
app.Use(async(context, next) =>
{
WebSocketManager webSocketManager = (WebSocketManager)context.RequestServices.GetService(typeof(WebSocketManager));
if (webSocketManager.Channels.ContainsKey(context.Request.Path))
{
var type = webSocketManager.Channels[context.Request.Path];
dynamic controllerWebSocket = context.RequestServices.GetService(type);
var initialData = controllerWebSocket.GetData();
if (context.WebSockets.IsWebSocketRequest)
{
WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
await new WebSocketHandler(webSocketManager, webSocket, context.Request.Path).Invoke(context, initialData);
}
else
{
context.Response.StatusCode = 200;
}
}
else
{
await next();
}
});
return(app);
}
private async Task ProcessRequest(WebSocketManager wsManager, int maxTicks)
{
using (var ws = await wsManager.AcceptWebSocketAsync())
{
var sender = new WebSocketSender(ws);
int ticks = 0;
void TickHandler()
{
sender.QueueSend(GetTime());
if (maxTicks != 0 && ++ticks >= maxTicks)
{
sender.CloseAsync();
}
}
_timer.Tick += TickHandler;
try
{
await sender.HandleCommunicationAsync();
}
finally
{
_timer.Tick -= TickHandler;
}
}
}
//public CustomDropdown dropdownStandtaskList;
void Awake()
{
webSocketManager = FindObjectOfType<WebSocketManager>();
messageManager = FindObjectOfType<MessageManager>();
rayCastManager = FindObjectOfType<RayCastManager>();
Finished = true;
}
public void ConnectServiceToWebSocket()
{
var manager = new WebSocketManager("ws://localhost:3000");
manager.AddService <Behaviors.TestBehavior>("/test");
var client = new WebSocket("ws://localhost:3000/test");
client.Connect();
Thread.Sleep(500);
Assert.IsTrue(Behaviors.TestBehavior.IsOpen);
client.Send("Test Message");
Thread.Sleep(500);
Assert.AreEqual("Test Message", Behaviors.TestBehavior.LastMessage);
client.Close();
Thread.Sleep(500);
Assert.IsTrue(Behaviors.TestBehavior.IsClosed);
manager.Stop();
}
protected override void OneTimeSetUp()
{
HttpClient = new RepeatHttpClient();
HttpManager = new HttpManager(HttpClient);
Api = new OperationManager(HttpManager);
WebSocketManager = new WebSocketManager();
}
public void OpenCustomWebSocket()
{
var manager = new WebSocketManager(9999, false);
Assert.AreEqual(9999, manager.Port);
Assert.IsFalse(manager.Secure);
Assert.IsTrue(string.IsNullOrEmpty(manager.Url));
manager.Stop();
}
public void OpenUrlWebSocket()
{
var manager = new WebSocketManager("ws://localhost:3000");
Assert.AreEqual(3000, manager.Port.Value);
Assert.IsFalse(manager.Secure);
Assert.AreEqual("ws://localhost", manager.Url);
manager.Stop();
}
public Main()
{
objWebSocket = new WebSocketManager();
objWebSocket.OnOpened += ObjWebSocket_OnOpened;
objWebSocket.OnOpening += ObjWebSocket_OnOpening;
objWebSocket.OnMessage += ObjWebSocket_OnMessage;
objWebSocket.OnClosed += ObjWebSocket_OnClosed;
objWebSocket.OnError += ObjWebSocket_OnError;
}
void OnEnable()
{
webSocketManager = GetComponent <WebSocketManager>();
backgroundImage = background.GetComponent <Image>();
commandCenterSetup = FindObjectOfType <CommandCenterSetup>();
CommandCenterSetup.OnMovementSetupEvent += SetUpTurns;
}
public ViewModel()
{
OnGridClickCommand = new RelayCommand(OnGridClick, () => true);
XMLmanager.Instance.SomethingHappened += modelchanged;
Debug.WriteLine("NEW VIEWMODEL!");
WebSocketManager WSM = new WebSocketManager();
WSM.InitWebSockets();
DispatcherHelper.Initialize();
}
public ApiKeyAuthenticator(IConfiguration configuration, ResourceCollection resourceCollection, WebSocketManager webSocketManager)
{
ReloadToken = configuration
.GetReloadToken()
.RegisterChangeCallback(state => Reload((IConfiguration)state), configuration);
ResourceCollection = resourceCollection;
WebSocketManager = webSocketManager;
ApiKeys = new Dictionary <string, AccessRights>();
Reload(configuration);
}
public void Init(IRenderer renderer, IClientSettings clientSettings)
{
Renderer = (WebRenderer)renderer;
ClientSettings = clientSettings;
ScreenManager = new WebScreenManager(Renderer, this);
Game.InitScreens(renderer, ScreenManager);
SocketManager = new WebSocketManager();
Game.InitSocketManager(SocketManager);
}
public async Task AddSocket(WebSocketManager socketManager)
{
WebSocket socket = await socketManager.AcceptWebSocketAsync();
if (!_sockets.Contains(socket))
{
_sockets.Add(socket);
}
await CloseSocketWhenNeed(socket);
}
protected override void OnAppearing()
{
base.OnAppearing();
// If not already connected and signed in, try to connect to web socket server
if (WebSocket == null && Account.IsSignedIn)
{
DependencyService.Get <INotificationManager>().RequestPermission();
WebSocket = new WebSocketManager(new Uri("ws://web.kraxarn.com:5000/ws"));
}
}
void OnEnable()
{
hexGrid = FindObjectOfType <HexGrid>();
propPlacement = FindObjectOfType <PropPlacement>();
startUIControl = FindObjectOfType <StartUIControl>();
setUpUIControl = FindObjectOfType <SetUpUIControl>();
turnController = FindObjectOfType <TurnController>();
cardGenerator = FindObjectOfType <CardGenerator>();
webSocketManager = FindObjectOfType <WebSocketManager>();
setGame = FindObjectOfType <SetGame>();
}
void OnEnable()
{
// tk = FindObjectOfType<TimeKeeper>();
// hexgrid = FindObjectOfType<HexGrid>();
// score = FindObjectOfType<ScoreKeeper>();
// infoGetter = FindObjectOfType<InformationGetter>();
webSocketManager = FindObjectOfType <WebSocketManager>();
// start = GameObject.Find("Start");
PropPlacement.OnMapCompleteEvent += GetHandlers;
}
void ObjWebSocket_OnClosed(WebSocketManager sender, CPqDCloseEventArgs e)
{
intConnectionOpen -= 1;
if (intConnectionOpen < 0)
{
intConnectionOpen = 0;
WriteLog("Problema na contabilização de conexões");
}
WriteLog(string.Concat("Fechou conexão - quantidades: ", intConnectionOpen.ToString(), " - Motivo: ", e.Reason, " - Code: ", e.Code));
strHandle = "";
SendOnClose(e);
}
public async Task DispatchAsync(WebSocketManager manager) {
WebSocket socket = await manager.AcceptWebSocketAsync();
SafeSocket commonSocket = new SafeSocket(socket);
Task[] senderTasks = new Task[this.senders.Count];
for (int senderIndex = 0; senderIndex < senderTasks.Length; senderIndex++) {
int index = senderIndex;// careful at index ! , make copy and use it inside closure !
senderTasks[senderIndex] = Task.Run(async () => {
await commonSocket.ReadAsync();
});
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
void OnEnable()
{
OnCardActivateEvent += AddCard;
OnCardDeactivateEvent += RemoveCard;
webSocketManager = FindObjectOfType <WebSocketManager>();
cardGenerator = FindObjectOfType <CardGenerator>();
hexgrid = FindObjectOfType <HexGrid>();
turnController = FindObjectOfType <TurnController>();
scorekeeper = GetComponent <ScoreKeeper>();
infoGetter = FindObjectOfType <InformationGetter>();
reset = false;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseExceptionHandler(new ExceptionHandlerOptions
{
ExceptionHandler = new JsonExceptionMiddleware(env).Invoke
});
app.UseCors(x => x
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
app.UseAuthentication();
app.UseMvc();
//Websocket
WebSocketManager wsmanager = WebSocketManager.Instance;
var websocketOptions = new WebSocketOptions()
{
ReceiveBufferSize = 4 * 1024
};
app.UseWebSockets(websocketOptions);
app.Use(async(context, next) =>
{
if (context.Request.Path.HasValue && context.Request.Path.Value.Contains("/ws"))
{
if (context.WebSockets.IsWebSocketRequest)
{
WebSocket ws = await context.WebSockets.AcceptWebSocketAsync();
await wsmanager.NewClientConnected(context, ws);
}
else
{
context.Response.StatusCode = 400;
}
}
else
{
await next();
}
});
Log.Information("Web server is started on: http://{0}:{1}", Config.WebHost, Config.WebPort);
Log.Information("WebSocket server is started on: ws://{0}:{1}/ws", Config.WebHost, Config.WebPort);
}
//Create the instance and connect the methods with the server
public WebSokectServer()
{
_MANAGER = new WebSocketManager();
_MANAGER._ONLINE_USERS = new ConcurrentDictionary <User, Coordinate>();
_SERVER = new WebSocketServer(_PORT, IPAddress.Any)
{
OnReceive = OnReceive,
OnSend = OnSend,
OnConnected = OnConnect,
OnDisconnect = OnDisconnect,
TimeOut = new TimeSpan(0, 5, 0)
};
}
protected override void OneTimeSetUp()
{
if (Api == null)
{
var manager = new WebSocketManager();
Api = new OperationManager(manager);
var url = ConfigurationManager.AppSettings["MainnetWs"];
Assert.IsTrue(Api.ConnectToAsync(url, CancellationToken.None).Result, "Сan`t connect to the node");
}
Assert.IsTrue(Api.IsConnected, "Сan`t connect to the node");
}
//public bool Need_InitNewSockets = false;
// Use this for initialization
void Awake()
{
webSocketManager = FindObjectOfType<WebSocketManager>();
}
protected virtual void UninitializeWebSocketManager(WebSocketManager instance) { }
