public ControlInterruptDialog()
{
this.InitializeComponent();
this.closeButton.Visible = false;
this.connectModel = new ConnectModel(this);
this.connectModel.setConnectReloadCallback(this);
}
public ActionResult Connect(ConnectModel model)
{
if (ConnectModelSession.ConnectSufficent())
{
model = ConnectModelSession;
if (Connections.Get(model.Guid) != null)
{
return(View(model));
}
}
if (model.ConnectSufficent())
{
model.Error = true;
ConnectModelSession = model;
return(RedirectToAction("Index"));
}
try
{
model.IP = Dns.GetHostAddressesAsync(model.IP).Result[0].ToString();
model.Guid = Connections.Connect(model);
}
catch (Exception ex)
{
model.Error = true;
model.ErrorMessage = ex.Message;
ConnectModelSession = model;
return(RedirectToAction("Index"));
}
ConnectModelSession = model;
return(View(model));
}
// GET: Connect
public ActionResult Index()
{
ConnectModel model = new ConnectModel {
Message = "Welcome to Kite Connect"
};
return(View(model));
}
/// <summary>
/// Attempts to connect and login to the Teamspeak Query
/// </summary>
/// <param name="model">Model</param>
/// <param name="Local">Local IP</param>
/// <exception cref="Exception">Throws a general exception containing a message</exception>
public static string Connect(ConnectModel model)
{
var conn = new Connection(IPAddress.Parse(model.IP), model.Port);
conn.Login(model.Username, model.Password);
connections.Add(conn);
return(conn.Guid);
}
public NetworkDialog()
{
this.InitializeComponent();
this.connectModel = new ConnectModel(this);
this.connectModel.setConnectReloadCallback(this);
this.connectModel.setSwitchChannelCallback(this);
this.OnCloseClick = new BaseDialogForm.OnCloseClickDelegate(this.OnCloseButtonClick);
}
private ConnectedList BuildAcceptRequest(ConnectModel connectModel)
{
return(new ConnectedList
{
User1 = connectModel.UserId1,
User2 = connectModel.UserId2
});
}
/// <summary>
///the constructor of ConnectViewModel.
/// </summary>
public ConnectViewModel(ConnectModel cm)
{
// updth the model and add fuction.
this.cmodel = cm;
cmodel.PropertyChanged += delegate(Object sender, PropertyChangedEventArgs e)
{
NotifyPropertyChanged("VM_" + e.PropertyName);
};
}
public ActionResult ClearMessages()
{
ConnectHelper.Message = string.Empty;
ConnectModel model = new ConnectModel
{
Message = ConnectHelper.Message
};
return(View("Index", model));
}
void Refresh_Click(object sender, RoutedEventArgs e)
{
try
{
ConnectModel.DiscoverDevices();
}
catch (Exception ex)
{
}
}
void InitializeResources(ConnectModel model)
{
AddCameraModel = new AddCameraModel(this)
{
ConnectModel = model
};
AddCameraModel.CameraAdded += AddCameraModel_CameraAdded;
OnPropertyChanged("AddCameraModel");
}
public ActionResult GetByFilter()
{
ConnectModel looking = new ConnectModel();
VoilaEntities db = new VoilaEntities();
looking.Cities = db.Cities.ToList();
looking.Proffesions = db.Proffesions.ToList();
looking.Price = db.Prices.ToList();
return(View(looking));
}
public ActionResult GetByFilter()
{
ConnectModel looking = new ConnectModel();
SocialBEntities db = new SocialBEntities();
looking.Followers = db.Followers.ToList();
looking.Regions = db.Regions.ToList();
looking.Compensation = db.Compensations.ToList();
return(View(looking));
}
ProtocolBackModel IProtocol.RecieveDataProcess(ConnectModel connect, int len)
{
ProtocolBackModel model = new ProtocolBackModel();
var strArray = Encoding.Default.GetBytes("hello world");
byte[] array = new byte[len + strArray.Length];
Array.Copy(strArray, array, strArray.Length);
Array.Copy(connect.rData, 0, array, strArray.Length, len);
model.Array = array;
model.Status = BackStatus.WAITNEXT;
return(model);
}
public void Load()
{
if (LicenseManager.UsageMode != LicenseUsageMode.Designtime)
{
try
{
CheckDirectorySettings();
ConnectModel loadedSettings = Json.Read <ConnectModel>(GetFileNameSettings());
InitProperties(loadedSettings);
}
catch { }
}
}
public ActionResult Index(ConnectModel model)
{
if (ConnectModelSession.Error)
{
model = ConnectModelSession;
ClearSession();
return(View(model));
}
else
{
return(View(model));
}
}
public ControlCheckWindow()
{
ControlCheckWindow.log.Trace("ControlCheckWindow");
this.InitializeComponent();
ControlCheckWindow.log.Trace("after ControlCheckWindow");
this.connectModel = new ConnectModel(this);
this.connectModel.setConnectStatusCallback(this);
this.OnWirelessFinishListener = new ControlCheckWindow.OnWirelessFinishDelegate(this.OnWirelessFinish);
this.socketModel = new SocketModel(this);
this.addSocketCallback();
this.initView();
ControlCheckWindow.log.Trace("ip == " + ConfigureUtil.AdapterIP());
ControlCheckWindow.log.Trace("type = " + ConfigureUtil.getClientType());
}
void Disconnect()
{
if (CurrentModel == null)
{
return;
}
CurrentModel.Disconnect();
var succ = ConnectModel.RemoveCamera(CurrentModel);
WireDownCameraEvents(CurrentModel);
StopViewer();
}
public ActionResult Connection(ConnectModel obj)
{
int cid = (int)Session["CategoryID"];
int sno = (int)Session["StudentNo"];
List <object> Parameters = new List <object>();
obj.CategoryID = cid;
obj.StudentNo = sno;
Parameters.Add(obj.CategoryID);
Parameters.Add(obj.StudentNo);
object[] objectarray = Parameters.ToArray();
int output = Db.Database.ExecuteSqlCommand("insert into ConnectTable(CategoryID,StudentNo) values(@p0,@p1)", objectarray);
return(RedirectToAction("Create", "Home"));
}
void ListenerBeginCall(IAsyncResult iResult)
{
var listener = iResult.AsyncState as TcpListener;
Socket clientSocket = listener.EndAcceptSocket(iResult);
ConnectModel connect = new ConnectModel()
{
rData = new byte[BufLen], client = clientSocket
};
clientSocket.BeginReceive(connect.rData, 0, BufLen, 0, ResultCallBace, connect);
if (clientSocket.Connected)
{
Console.WriteLine("\nClient Connected!!\n==================\nCLient IP {0}\n", clientSocket.RemoteEndPoint);
}
listener.BeginAcceptSocket(ListenerBeginCall, listener);
}
public ViewResult Instruments()
{
ConnectModel model = new ConnectModel();
try
{
List <Instrument> instruments = _helper.GetInstruments();
return(View("Index", new ConnectModel {
Message = ConnectHelper.Message.ToString()
}));
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
/// <summary>Called when [connect command].</summary>
private void OnConnectCommand()
{
if (cm == null)
{
// First connect
cm = new ConnectModel();
}
else if (!cm.IP.Equals(Properties.Settings.Default.FlightServerIP) ||
!cm.Port.Equals(Properties.Settings.Default.FlightCommandPort))
{
// Values changed
// Stop running thread
cm.stop();
// Create new connect model
cm = new ConnectModel();
}
}
public ViewResult Positions()
{
ConnectModel model = new ConnectModel();
try
{
PositionResponse positions = _helper.GetPositions();
return(View("Index", new ConnectModel {
Message = ConnectHelper.Message.ToString()
}));
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
public ActionResult Login()
{
ConnectModel model = new ConnectModel();
try
{
string loginUrl = _helper.GetLoginURL();
var result = Redirect(loginUrl);
return(result);
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
public ViewResult OrderById(string orderId)
{
ConnectModel model = new ConnectModel();
try
{
List <Order> orderinfo = _helper.GetOrderById(orderId);
return(View("Index", new ConnectModel {
Message = ConnectHelper.Message.ToString()
}));
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
public ViewResult LTP()
{
ConnectModel model = new ConnectModel();
string[] instrumentId = new string[] { "NSE:INFY", "NSE:ASHOKLEY" };
try
{
Dictionary <string, LTP> ltp = _helper.GetLTP(instrumentId);
return(View("Index", new ConnectModel {
Message = ConnectHelper.Message.ToString()
}));
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
public ViewResult TriggerRange()
{
ConnectModel model = new ConnectModel();
string[] instrumentId = new string[] { "NSE:INFY", "NSE:ASHOKLEY" };
string transactionType = Constants.TRANSACTION_TYPE_BUY;
try
{
Dictionary <string, TrigerRange> trigerRange = _helper.GetTriggerRange(instrumentId, transactionType);
return(View("Index", new ConnectModel {
Message = ConnectHelper.Message.ToString()
}));
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
public string GetInfo(string ip, int port)
{
// Load model
ConnectModel model = new ConnectModel(ip, port);
// Wait for update event
bool rudderChanged = false;
bool throttleChanged = false;
AutoResetEvent waitHandle = new AutoResetEvent(false);
// create and attach event handler for the "Completed" event
EventHandler eventHandler = delegate(object sender, EventArgs e)
{
string propertyName = ((PropertyChangedEventArgs)e).PropertyName;
if (propertyName == "Rudder" && !rudderChanged)
{
waitHandle.Set();
rudderChanged = true;
}
else if (propertyName == "Throttle" && !throttleChanged)
{
waitHandle.Set();
throttleChanged = true;
}
};
model.positionChanged += eventHandler;
model.updateRudder();
model.updateThrottle();
waitHandle.WaitOne();
waitHandle.WaitOne();
float rudder = model.Rudder;
float throttle = model.Throttle;
model.stop();
// Return the values
return(String.Format("{0},{1}", rudder, throttle));
}
public string GetLocation(string ip, int port)
{
// Get model
ConnectModel model = new ConnectModel(ip, port);
// Wait for update event
bool lonChanged = false;
bool latChanged = false;
AutoResetEvent waitHandle = new AutoResetEvent(false);
// create and attach event handler for the "Completed" event
EventHandler eventHandler = delegate(object sender, EventArgs e)
{
string propertyName = ((PropertyChangedEventArgs)e).PropertyName;
if ((propertyName == "Lat" && !latChanged))
{
waitHandle.Set();
latChanged = true;
}
else if (propertyName == "Lon" && !lonChanged)
{
waitHandle.Set();
lonChanged = true;
}
};
model.positionChanged += eventHandler;
model.updatePosition();
waitHandle.WaitOne();
waitHandle.WaitOne();
float lat = model.Lat;
float lon = model.Lon;
model.stop();
// Return the position
return(String.Format("{0},{1}", lon, lat));
}
void ResultCallBace(IAsyncResult asyncCall)
{
try
{
ProtocolBackModel res = null;
ConnectModel connect = asyncCall.AsyncState as ConnectModel;
var len = connect.client.EndReceive(asyncCall);
for (int i = 0; i < Protocol.Count; i++)
{
var _protocol = Protocol[i];
res = _protocol.RecieveDataProcess(connect, len);
if (res.Array != null && res.Array.Length > 0)
{
connect.client.Send(res.Array);
}
if (res.Status != BackStatus.ABANDONED) //这个协议对本次请求有特殊要求
{
break; //跳出循环
}
}
//此处预留后期扩展成协议池
switch (res.Status)
{
case BackStatus.ABANDONED:
connect.client.Shutdown(SocketShutdown.Both);
break;
case BackStatus.NOOP:
break;
case BackStatus.WAITNEXT:
connect.client.BeginReceive(connect.rData, 0, BufLen, 0, ResultCallBace, connect);
break;
}
}
catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
}
public ViewResult Initialize()
{
ConnectModel model = new ConnectModel();
var requestToken = Request.QueryString["request_token"];
try
{
User user = _helper.InitializeSession(requestToken);
_accessToken = user.AccessToken;
_publicToken = user.PublicToken;
_helper.InitializeTicker(_accessToken);
model = new ConnectModel {
Message = ConnectHelper.Message.ToString()
};
return(View("Index", model));
}
catch (Exception e)
{
model.Message = e.Message;
return(View("Index", model));
}
}
