public ExcelStringsExporter(XmlRequest xmlObject)
{
this.xmlObject = xmlObject;
var workbook = Workbook.Load(xmlObject.InputPath);
sheet = workbook.Sheets[0];
}
// =================================================
// PROTECTED (Methods) Protocol Cmds Event Handlers
// =================================================
/// <get what='file' id='10' />
private void OnGetEvent(PeerSocket peer, XmlRequest xml)
{
Gtk.Application.Invoke(delegate {
string what = (string)xml.Attributes["what"];
switch (what)
{
case "file-id":
try {
ulong id = ulong.Parse((string)xml.Attributes["id"]);
UploadManager.Send(peer, id);
// TODO: Manage ID Not Found
} catch (Exception e) {
Base.Dialogs.MessageError("File Not Found", e.Message);
}
break;
case "file":
string filePath = (string)xml.Attributes["path"];
filePath = Path.Combine(Paths.UserSharedDirectory(MyInfo.Name), filePath.Substring(1));
UploadManager.Send(peer, filePath);
break;
case "file-list":
string folderPath = (string)xml.Attributes["path"];
Cmd.SendFileList(peer, folderPath);
break;
}
});
}
public void GetSessionXML()
{
var request = XmlRequest.Prepare("http://localhost:8080", "auth/session");
WebMessage message = request.Get();
Assert.AreEqual(HttpStatusCode.OK, message.Code);
}
public async Task <XmlResponse> GetXmlResponseAsync(XmlRequest xmlRequestObject)
{
HttpClient client = _httpClientFactory.CreateClient();
HttpRequestMessage request = new HttpRequestMessage(new HttpMethod("POST"), _configuration.ConfigJson.ApiUrl);
xmlRequestObject.SessionId = _configuration.SessionId;
// XML Serialization
using (StringWriter stringwriter = new StringWriter())
{
XmlSerializer serializer = new XmlSerializer(typeof(XmlRequest));
serializer.Serialize(stringwriter, xmlRequestObject);
string serializedXml = stringwriter.ToString();
request.Content = new StringContent(serializedXml);
}
// Getting response
request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/xml");
string response = await client.SendAsync(request).Result.Content.ReadAsStringAsync();
// XML Deserialization
XmlResponse result;
using (TextReader reader = new StringReader(response))
{
XmlSerializer deserializer = new XmlSerializer(typeof(XmlResponse));
result = (XmlResponse)deserializer.Deserialize(reader);
}
return(result);
}
protected void OnGetEvent(PeerSocket peer, XmlRequest xml)
{
if (xml.Attributes["what"].Equals("peerlist") == true)
{
SendPeerList(peer);
}
}
public XmlGetDomainListReq()
: base(operations.GetDomainList)
{
XmlNode GetEl = XmlRequest.CreateElement(_xmlDomainElements.Get.ToString());
Parameters.AppendChild(GetEl);
}
public void makeXmlFile(List <StringObj> stringObjList, XmlRequest xmlRequest)
{
XmlDocument xmlDocument = new XmlDocument();
XmlElement resourcesNode = xmlDocument.CreateElement("resources");
foreach (StringObj stringObj in stringObjList)
{
if (stringObj.Code.Equals(FilesCoordinator.APP_NAME))
{
xmlRequest.TranslatedAppName = stringObj.StringToTranslate;
continue;
}
else if (stringObj.Code.Equals(FilesCoordinator.APP_DESCRIPTION))
{
xmlRequest.TranslatedAppDescription = stringObj.StringToTranslate;
continue;
}
else if (stringObj.Code.Equals(FilesCoordinator.APP_SUMMARY))
{
xmlRequest.TranslatedAppSummary = stringObj.StringToTranslate;
continue;
}
XmlElement stringNode = xmlDocument.CreateElement(TAG_STRING);
stringNode.SetAttribute(ATT_NAME, stringObj.Code);
stringNode.InnerText = stringObj.StringToTranslate;
resourcesNode.AppendChild(stringNode);
}
xmlDocument.AppendChild(resourcesNode);
xmlDocument.Save(xmlRequest.OutputPath);
callback.onXmlFileMade(xmlRequest);
}
public void OnGetEvent(PeerSocket peer, XmlRequest xml)
{
if (xml.Attributes["what"].Equals("imgthumb"))
{
SendImageThumb(peer, xml.BodyText);
}
}
public void onXmlRequest(XmlRequest xmlObject)
{
//todo change excel input
List <StringObj> stringObjList = new ExcelStringsExporter(xmlObject).exportStrings();
XmlFileMaker xmlFileMaker = new XmlFileMaker(callback);
xmlFileMaker.makeXmlFile(stringObjList, xmlObject);
}
public void OnSndEvent(PeerSocket peer, XmlRequest xml)
{
if (xml.Attributes["what"].Equals("imgthumb"))
{
string path = (string)xml.Attributes["path"];
ReceiveImageThumb((UserInfo)peer.Info, path, xml.BodyText);
}
}
private static void SendMessage(PeerSocket peer, string message)
{
XmlRequest xmlRequest = new XmlRequest();
xmlRequest.FirstTag = "msg";
xmlRequest.BodyText = message;
peer.Send(xmlRequest.GenerateXml());
}
// ============================================
// PRIVATE Methods
// ============================================
private void RequestPeerList(PeerSocket peer)
{
XmlRequest xml = new XmlRequest();
xml.FirstTag = "get";
xml.Attributes.Add("what", "peerlist");
peer.Send(xml.GenerateXml());
}
private void SendPeerList(PeerSocket peer)
{
XmlRequest xml = new XmlRequest();
xml.FirstTag = "peerlist";
xml.BodyText = GeneratePeerList();
peer.Send(xml.GenerateXml());
}
public void GetTestPageXML()
{
var request = XmlRequest.Prepare("http://localhost:8080", "testpage");
WebMessage message = request.Get();
Assert.AreEqual(HttpStatusCode.OK, message.Code);
Assert.AreEqual("Test Page success", message.Content);
}
public void onXmlFileMade(XmlRequest xmlRequest)
{
appNameTB.Text = xmlRequest.TranslatedAppName;
appDescriptionRTB.Text = xmlRequest.TranslatedAppDescription;
appSummaryTB.Text = xmlRequest.TranslatedAppSummary;
languageTB.Text = xmlRequest.Translation;
appDetailsGB.Enabled = true;
}
private static void SendStatus(PeerSocket peer, string status)
{
XmlRequest xmlRequest = new XmlRequest();
xmlRequest.FirstTag = "msg";
xmlRequest.BodyText = status;
xmlRequest.Attributes.Add("type", "status");
peer.Send(xmlRequest.GenerateXml());
}
private static void SendError(PeerSocket peer, string error)
{
XmlRequest xmlRequest = new XmlRequest();
xmlRequest.FirstTag = "msg";
xmlRequest.BodyText = error;
xmlRequest.Attributes.Add("type", "error");
peer.Send(xmlRequest.GenerateXml());
}
public void GetEchoXML()
{
var request = XmlRequest.Prepare("http://localhost:8080", "testecho", "value=teststring");
WebMessage message = request.Get();
Assert.AreEqual(HttpStatusCode.OK, message.Code);
Assert.AreEqual("value", message.Source);
Assert.AreEqual("teststring", message.Content);
}
/*---------------parse the xml file---------------*/
private void parseXml(string xmlname)
{
string xmlPath = Path.Combine(chdXmlPath, xmlname);
XmlRequest xmlmsg = new XmlRequest();
xmlmsg.loadXml(xmlPath);
dir = xmlmsg.parse("dir");
size = int.Parse((xmlmsg.parse("size")));
files = xmlmsg.parseList("file");
}
public AsyncCommandManager(IScriptEngine _ScriptEngine)
{
m_ScriptEngine = _ScriptEngine;
// If there is more than one scene in the simulator or multiple script engines are used on the same region
// then more than one thread could arrive at this block of code simultaneously. However, it cannot be
// executed concurrently both because concurrent list operations are not thread-safe and because of other
// race conditions such as the later check of cmdHandlerThread == null.
lock (staticLock)
{
if (m_ScriptEngines.Count == 0)
{
ReadConfig();
}
if (!m_ScriptEngines.Contains(m_ScriptEngine))
{
m_ScriptEngines.Add(m_ScriptEngine);
}
// Create instances of all plugins
if (!m_Dataserver.ContainsKey(m_ScriptEngine))
{
m_Dataserver[m_ScriptEngine] = new Dataserver(this);
}
if (!m_Timer.ContainsKey(m_ScriptEngine))
{
m_Timer[m_ScriptEngine] = new Timer(this);
}
if (!m_HttpRequest.ContainsKey(m_ScriptEngine))
{
m_HttpRequest[m_ScriptEngine] = new HttpRequest(this);
}
if (!m_Listener.ContainsKey(m_ScriptEngine))
{
m_Listener[m_ScriptEngine] = new Listener(this);
}
if (!m_SensorRepeat.ContainsKey(m_ScriptEngine))
{
m_SensorRepeat[m_ScriptEngine] = new SensorRepeat(this);
}
if (!m_XmlRequest.ContainsKey(m_ScriptEngine))
{
m_XmlRequest[m_ScriptEngine] = new XmlRequest(this);
}
numInstances++;
if (cmdHandlerThread == null)
{
cmdHandlerThread = WorkManager.StartThread(
CmdHandlerThreadLoop, "AsyncLSLCmdHandlerThread");
}
}
}
/// <ask what='file' id='10' path='/pippo.txt' size='1024' />
private void OnAskEvent(PeerSocket peer, XmlRequest xml)
{
Gtk.Application.Invoke(delegate {
string what = (string)xml.Attributes["what"];
if (what == "file")
{
AcceptFileQuestion(peer, xml);
}
});
}
// ===================================================
// PRIVATE (Sub Methods) Protocol Event Handler
// ===================================================
public void OnGetEvent(PeerSocket peer, XmlRequest xml)
{
Gtk.Application.Invoke(delegate {
string what = (string)xml.Attributes["what"];
if (what == "folder")
{
CmdManager.SendFileList(peer, xml.BodyText);
}
});
}
/// <recv-abort what='file' id='10' />
private void OnRecvAbortEvent(PeerSocket peer, XmlRequest xml)
{
Gtk.Application.Invoke(delegate {
string what = (string)xml.Attributes["what"];
if (what == "file")
{
ulong id = ulong.Parse((string)xml.Attributes["id"]);
UploadManager.Abort(peer, id);
}
});
}
/// <snd-end what='file' id='10 />
private void OnSndEndEvent(PeerSocket peer, XmlRequest xml)
{
Gtk.Application.Invoke(delegate {
string what = (string)xml.Attributes["what"];
if (what == "file")
{
ulong id = ulong.Parse((string)xml.Attributes["id"]);
DownloadManager.FinishedDownload(peer, id);
}
});
}
// ===================================================
// PRIVATE (Methods) Protocol Event Handler
// ===================================================
private void OnAcceptFileEvent(PeerSocket peer, XmlRequest xml)
{
try {
string path = (string)xml.Attributes["path"];
UserInfo userInfo = peer.Info as UserInfo;
UploadManager.Add(userInfo, path);
} catch (Exception e) {
Glue.Dialogs.MessageError("Accept File", "Peer Ip: " +
peer.GetRemoteIP().ToString() + "\n" +
e.Message);
}
}
public void GetTestStructMaxXML()
{
var request = XmlRequest.Prepare("http://localhost:8080", "testdata", "structtype=max");
WebMessage message = request.Get();
Assert.AreEqual(HttpStatusCode.OK, message.Code);
ITable <TestData> dataTable = request.Result.GetTable <TestData>();
Assert.AreEqual(1, dataTable.RowCount);
TestData data = dataTable.GetStruct(dataTable.IDs[0]);
TestData mindata = TestDataMax();
Assert.True(data.Equals(mindata));
}
public static async Task <VideoTitleParseResult> GetTitleAPIAsync(string id)
{
var url = string.Format("https://ext.nicovideo.jp/api/getthumbinfo/{0}", id);
NicoResponse nicoResponse;
try {
nicoResponse = await XmlRequest.GetXmlObjectAsync <NicoResponse>(url);
} catch (HttpRequestException x) {
return(VideoTitleParseResult.CreateError("NicoVideo (error): " + x.Message));
}
return(ParseResponse(nicoResponse));
}
public void Xml_Request_Test()
{
//Assign
IRequest baseRequest = new HttpRequest("http://test.com/", "command");
IRequest target;
HttpWebRequest actual;
//Act
target = new XmlRequest(baseRequest);
actual = target.Build();
//Assert
Assert.AreEqual("text/xml", actual.ContentType);
}
public XmlGetDomainInfoReq(string domainName)
: base(operations.GetDomainInfo)
{
XmlNode xmlDomain = XmlRequest.CreateElement(_xmlDomainElements.Domain.ToString());
xmlDomain.InnerText = domainName;
Parameters.AppendChild(xmlDomain);
XmlNode xmlGet = XmlRequest.CreateElement(_xmlDomainElements.Get.ToString());
Parameters.AppendChild(xmlGet);
foreach (var element in _getList)
{
xmlGet.AppendChild(XmlRequest.CreateElement(element.ToString()));
}
}
public void OnSndAbortEvent(PeerSocket peer, XmlRequest xml)
{
Gtk.Application.Invoke(delegate {
string what = (string)xml.Attributes["what"];
if (what == "file")
{
try {
DownloadManager.Remove(peer, xml);
} catch (Exception e) {
Glue.Dialogs.MessageError("Remove Download", e.Message);
}
}
});
}
private void ParseCommand(string xml)
{
#if DEBUG
Debug.Log("==================================================");
if (peer.Info != null) {
UserInfo userInfo = this.peer.Info as UserInfo;
Debug.Log("Response From: {0}", userInfo.Name);
} else {
Debug.Log("Response From: {0}", peer.GetRemoteIP());
}
Debug.Log("Response: '{0}'", xml);
Debug.Log("==================================================");
#endif
// Parse Xml Command
XmlRequest xmlRequest = null;
try {
xmlRequest = new XmlRequest(xml);
xmlRequest.Parse();
} catch (Exception e) {
Debug.Log("Parse Xml: {0}", e.Message);
return;
}
// Protocol Commands
switch (xmlRequest.FirstTag) {
case "login":
Login login = new Login(peer, xmlRequest);
if (login.Authentication() == true && login.User != null) {
// Add to Known User
P2PManager.AddPeer(login.User, peer);
// Start Login Event
CmdManager.StartLoginEvent(peer, login.User);
} else {
Debug.Log("Auth Failed: {0}", peer.GetRemoteIP());
}
break;
case "quit":
CmdManager.StartQuitEvent(peer, xmlRequest);
break;
case "error":
CmdManager.StartErrorEvent(peer, xmlRequest);
break;
case "get":
CmdManager.StartGetEvent(peer, xmlRequest);
break;
case "ask":
CmdManager.StartAskEvent(peer, xmlRequest);
break;
case "accept":
CmdManager.StartAcceptEvent(peer, xmlRequest);
break;
case "snd":
CmdManager.StartSndEvent(peer, xmlRequest);
break;
case "snd-start":
CmdManager.StartSndStartEvent(peer, xmlRequest);
break;
case "snd-end":
CmdManager.StartSndEndEvent(peer, xmlRequest);
break;
case "snd-abort":
CmdManager.StartSndAbortEvent(peer, xmlRequest);
break;
case "recv-abort":
CmdManager.StartRecvAbortEvent(peer, xmlRequest);
break;
default:
CmdManager.StartUnknownEvent(peer, xmlRequest);
break;
}
}
