private void PrintClientInfo(StreamSocketInformation information)
{
Console.WriteLine("Handling new Report...");
Console.WriteLine(String.Format(" RemoteAddress : {0}", information.RemoteHostName));
Console.WriteLine(String.Format(" RemoteHostName : {0}", information.RemoteAddress));
Console.WriteLine(String.Format(" RemoteServiceName : {0}", information.RemoteServiceName));
}
//--------------------------------------------------------Events:---------------------------------------------------------------------\\
#region --Events--
private void CONNECTION_INFO_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (sender is ConnectionInformation connectionInfo)
{
switch (e.PropertyName)
{
case nameof(connectionInfo.socketInfo):
SocketInfo = connectionInfo?.socketInfo;
LoadValuesFromCert(connectionInfo?.socketInfo?.ServerCertificate);
break;
}
}
}
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\
#region --Set-, Get- Methods--
#endregion
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public void UpdateViewModel(DependencyPropertyChangedEventArgs e)
{
if (e.OldValue is AccountDataTemplate accountOld)
{
Unsubscribe(accountOld);
}
ResetValues();
if (e.NewValue is AccountDataTemplate accountNew)
{
Subscribe(accountNew);
SocketInfo = accountNew.Account?.CONNECTION_INFO?.socketInfo;
LoadValuesFromCert(accountNew.Account?.CONNECTION_INFO?.socketInfo?.ServerCertificate);
}
}
public void ConnectAsync(SocketMsgPumpConnectData paramsObj)
{
Task.Run(async() => {
try {
this.log.InfoEntry("ConnectAsync");
this.TearDown(true);
this.log.Info("ConnectAsync", () => string.Format(
"Host:{0} Service:{1}", paramsObj.RemoteHostName, paramsObj.ServiceName));
this.readBufferMaxSizer = paramsObj.MaxReadBufferSize;
this.socket = new StreamSocket();
await this.socket.ConnectAsync(
new HostName(paramsObj.RemoteHostName),
paramsObj.ServiceName,
paramsObj.ProtectionLevel);
StreamSocketInformation i = this.socket.Information;
this.log.Info("ConnectAsync", () => string.Format(
"Connected to socket Local {0}:{1} Remote {2}:{3} - {4} : Protection:{5}",
i.LocalAddress, i.LocalPort,
i.RemoteHostName, i.RemotePort, i.RemoteServiceName, i.ProtectionLevel));
this.writer = new DataWriter(this.socket.OutputStream);
this.writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
this.reader = new DataReader(this.socket.InputStream);
this.reader.InputStreamOptions = InputStreamOptions.Partial;
this.reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
this.reader.ByteOrder = ByteOrder.LittleEndian;
this.readCancelationToken = new CancellationTokenSource();
this.readCancelationToken.Token.ThrowIfCancellationRequested();
this.continueReading = true;
this.Connected = true;
this.LaunchReadTask();
this.MsgPumpConnectResultEvent?.Invoke(this, new MsgPumpResults(MsgPumpResultCode.Connected));
}
catch (Exception e) {
this.log.Exception(9999, "Connect Asyn Error", e);
this.MsgPumpConnectResultEvent?.Invoke(this, new MsgPumpResults(MsgPumpResultCode.ConnectionFailure));
}
});
}
//--------------------------------------------------------Events:---------------------------------------------------------------------\\
#region --Events--
private void CONNECTION_INFO_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (sender is ConnectionInformation connectionInfo)
{
switch (e.PropertyName)
{
case nameof(connectionInfo.msgCarbonsState):
MsgCarbonsState = connectionInfo.msgCarbonsState;
break;
case nameof(connectionInfo.tlsConnected):
TlsConnected = connectionInfo.tlsConnected;
break;
case nameof(connectionInfo.socketInfo):
SocketInfo = connectionInfo.socketInfo;
break;
}
}
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
#endregion
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\
#region --Set-, Get- Methods--
#endregion
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\
#region --Misc Methods (Public)--
public void UpdateViewModel(DependencyPropertyChangedEventArgs e)
{
if (e.OldValue is AccountDataTemplate accountOld)
{
Unsubscribe(accountOld);
}
if (e.NewValue is AccountDataTemplate accountNew)
{
Subscribe(accountNew);
ParserStats = accountNew.Client.getMessageParserStats();
MsgCarbonsState = accountNew.Account.CONNECTION_INFO.msgCarbonsState;
SocketInfo = accountNew.Account.CONNECTION_INFO.socketInfo;
TlsConnected = accountNew.Account.CONNECTION_INFO.tlsConnected;
}
else
{
ParserStats = null;
}
}
private async Task writeResponseAsync(string request, IOutputStream os, StreamSocketInformation socketInfo)
{
try
{
string[] requestParts = request.Split('/');
#region Request for the root page, so redirect to home page
if (request.Equals("/"))
{
await redirectToPage(NavConstants.HOME_PAGE, os);
}
#endregion
#region Request for the home page
else if (request.Contains(NavConstants.HOME_PAGE))
{
// Generate the default config page
string html = await helper.GenerateStatusPage();
await WebHelper.WriteToStream(html, os);
}
#endregion
#region Request for the settings page
else if (request.Contains(NavConstants.SETTINGS_PAGE))
{
// Process the GET parameters
if (request.Contains("?"))
{
// Format the URI with the get parameters
Uri uri = new Uri("http://1.2.3.4:8000" + request);
// Take the parameters from the URL and put it into Settings
helper.ParseUriIntoSettings(uri);
await AppSettings.SaveAsync(App.Controller.XmlSettings, "Settings.xml");
// This is an event that lets us know what the controller is done restarting after the settings are applied
AutoResetEvent ase = new AutoResetEvent(false);
// Dispose and Initialize need to be called on UI thread because of DispatcherTimers
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
try
{
// Restart the controller to apply new settings
App.Controller.Dispose();
await App.Controller.Initialize();
// Create the settings page and add a confirmation message that the settings were applied successfully
string html = helper.GeneratePage("Security System Config", "Security System Config", helper.CreateHtmlFormFromSettings(), "<span style='color:Green'>Configuration saved!</span><br><br>");
await WebHelper.WriteToStream(html, os);
}
catch (Exception ex)
{
Debug.WriteLine("Error restarting controller: " + ex.Message);
}
// Signal that the restart is done
ase.Set();
});
// Wait for controller restart to finish
ase.WaitOne();
}
else
{
// Generate the default config page
string html = helper.GeneratePage("Security System Config", "Security System Config", helper.CreateHtmlFormFromSettings());
await WebHelper.WriteToStream(html, os);
}
}
#endregion
#region Request for the OneDrive page
else if (request.Contains(NavConstants.ONEDRIVE_PAGE))
{
// Take in the parameters and try to login to OneDrive
if (request.Contains("?"))
{
// I just put some arbitrary IP and port just so I have a correctly formatted URI, it's not important to have an actual IP + port
Uri uri = new Uri("http://1.2.3.4:8000" + request);
await helper.ParseOneDriveUri(uri);
var oneDrive = App.Controller.Storage as OneDrive;
if (oneDrive != null)
{
if (oneDrive.IsLoggedIn())
{
// Save tokens to settings file if we successfully logged in
await AppSettings.SaveAsync(App.Controller.XmlSettings, "Settings.xml");
}
}
}
// Generate page and write to stream
string html = helper.GenerateOneDrivePage();
await WebHelper.WriteToStream(html, os);
}
#endregion
#region Request for gallery page
else if (request.Contains(NavConstants.GALLERY_PAGE))
{
string html = "";
var storageType = App.Controller.Storage.GetType();
// If the storage type is OneDrive, generate page with link to OneDrive
if (storageType == typeof(OneDrive))
{
html = helper.GeneratePage("Gallery", "Gallery", "<b>" + storageType.Name + "</b> is set as your storage provider. "
+ "Please view your pictures on <a href='http://www.onedrive.com' target='_blank'>OneDrive</a>.<br><br>"
+ "To view your pictures here, please select <b>" + StorageProvider.Local + "</b> as your storage provider.");
}
// Otherwise show the gallery for the files on the device
else
{
StorageFolder folder = KnownFolders.PicturesLibrary;
int page = 1;
int pageSize = 30;
// Parse GET parameters
if (request.Contains("?"))
{
Uri uri = new Uri("http://1.2.3.4:8000" + request);
var parameters = helper.ParseGetParametersFromUrl(uri);
try
{
// Find the folder that's specified in the parameters
folder = await StorageFolder.GetFolderFromPathAsync(parameters["folder"]);
if (parameters.ContainsKey("page"))
{
try
{
page = Convert.ToInt32(parameters["page"]);
}
catch (Exception) { }
}
if (parameters.ContainsKey("pageSize"))
{
try
{
pageSize = Convert.ToInt32(parameters["pageSize"]);
}
catch (Exception) { }
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception finding folder: " + ex.Message);
folder = await folder.GetFolderAsync(AppSettings.FolderName);
// Log telemetry event about this exception
var events = new Dictionary <string, string> {
{ "WebServer", ex.Message }
};
TelemetryHelper.TrackEvent("FailedToGetFolderFromPath", events);
}
}
else
{
folder = await folder.GetFolderAsync(AppSettings.FolderName);
}
// Generate gallery page and write to stream
string galleryHtml = await helper.GenerateGallery(folder, page, pageSize);
html = helper.GeneratePage("Gallery", "Gallery", galleryHtml);
}
await WebHelper.WriteToStream(html, os);
}
#endregion
#region Request for API
else if (request.Contains("api"))
{
try
{
if (requestParts.Length > 2)
{
switch (requestParts[2].ToLower())
{
// An image from the gallery was requested
case "gallery":
var temp = request.Split(new string[] { "gallery/" }, StringSplitOptions.None);
// HTML decode the file path
string decodedPath = WebUtility.UrlDecode(temp[1]);
// Retrieve the file
StorageFile file = await StorageFile.GetFileFromPathAsync(decodedPath);
// Write the file to the stream
await WebHelper.WriteFileToStream(file, os);
break;
}
}
}catch (Exception ex)
{
Debug.WriteLine("Exception in web API: " + ex.Message);
// Log telemetry event about this exception
var events = new Dictionary <string, string> {
{ "WebServer", ex.Message }
};
TelemetryHelper.TrackEvent("FailedToProcessApiRequest", events);
}
}
// Request for a file that is in the Assets\Web folder (e.g. logo, css file)
#endregion
#region Generate the Action page
else if (request.Contains(NavConstants.ACTION_PAGE))
{
Debug.WriteLine("Action page requested.");
//await redirectToPage(NavConstants.HOME_PAGE, os);
string html;
string result = String.Empty;
// Process the GET parameters
if (request.Contains("?"))
{
// Format the URI with the get parameters
Uri uri = new Uri("http://1.2.3.4:8000" + request);
Dictionary <string, string> parameters = helper.ParseGetParametersFromUrl(uri);
foreach (string key in parameters.Keys)
{
Debug.WriteLine("{0} = {1}", key, parameters[key]);
}
switch (parameters["myaction"])
{
case "takephoto":
Debug.WriteLine("Manually Taking photo...");
await App.Controller.Camera.TriggerCapture();
Debug.WriteLine("Photo capture done.");
html = helper.GeneratePage("Actions", "Manual actions", helper.GenerationActionPage(), result = "<span style='color:Green'>Photo taken.</span><br><br>");
//await WebHelper.WriteToStream(html, os);
break;
case "sendknownimages":
Debug.WriteLine("Registgering known images with Cortana FaceAPI.....");
if (App.Controller.FaceClient == null)
{
result = "<span style='color:Red'>The FaceAPI key has not been set or is incorrect. Go to the Settings page and review the setting.</span><br><br>";
}
else
{
//await App.Controller.FaceClient.RegisterKnownUsersAsync();
//result = "<span style='color:Green'>Known image upload complete</span><br><br>";
}
break;
default:
break;
}
}
html = helper.GeneratePage("Actions", "Manual actions", helper.GenerationActionPage(), result);
await WebHelper.WriteToStream(html, os);
}
#endregion
#region Return assets from web folder or error is nothing else matches
else
{
using (Stream resp = os.AsStreamForWrite())
{
bool exists = true;
try
{
var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
// Map the requested path to Assets\Web folder
string filePath = @"Assets\Web" + request.Replace('/', '\\');
// Open the file and write it to the stream
using (Stream fs = await folder.OpenStreamForReadAsync(filePath))
{
string header = String.Format("HTTP/1.1 200 OK\r\n" +
"Content-Length: {0}\r\n{1}" +
"Connection: close\r\n\r\n",
fs.Length,
((request.Contains("css")) ? "Content-Type: text/css\r\n" : ""));
byte[] headerArray = Encoding.UTF8.GetBytes(header);
await resp.WriteAsync(headerArray, 0, headerArray.Length);
await fs.CopyToAsync(resp);
}
}
catch (FileNotFoundException ex)
{
exists = false;
// Log telemetry event about this exception
var events = new Dictionary <string, string> {
{ "WebServer", ex.Message }
};
TelemetryHelper.TrackEvent("FailedToOpenStream", events);
}
// Send 404 not found if can't find file
if (!exists)
{
byte[] headerArray = Encoding.UTF8.GetBytes(
"HTTP/1.1 404 Not Found\r\n" +
"Content-Length:0\r\n" +
"Connection: close\r\n\r\n");
await resp.WriteAsync(headerArray, 0, headerArray.Length);
}
await resp.FlushAsync();
}
}
#endregion
}
catch (FaceAPIException fex)
{
#region Track error for debugging
Debug.WriteLine("Exception in FaceAPI code: " + fex.Message);
#endregion
#region Display error to user
try
{
// Try to send an error page back if there was a problem servicing the request
string html = helper.GeneratePage("Error", "Error", "There's been an error: " + fex.Message + "<br><br>");
await WebHelper.WriteToStream(html, os);
}
catch (Exception e)
{
TelemetryHelper.TrackException(e);
}
#endregion
}
catch (Exception ex)
{
#region Track error for debugging
Debug.WriteLine("Exception in writeResponseAsync(): " + ex.Message);
Debug.WriteLine(ex.StackTrace);
// Log telemetry event about this exception
//var events = new Dictionary<string, string> { { "WebServer", ex.Message } };
//TelemetryHelper.TrackEvent("FailedToWriteResponse", events);
#endregion
#region Display error to user
try
{
// Try to send an error page back if there was a problem servicing the request
string html = helper.GeneratePage("Error", "Error", "There's been an error: " + ex.Message + "<br><br>" + ex.StackTrace);
await WebHelper.WriteToStream(html, os);
}
catch (Exception e)
{
TelemetryHelper.TrackException(e);
}
#endregion
}
}
/// <summary>
/// Creates a new ClientConnectedEventArgs object
/// </summary>
/// <param name="clientInformation">Client socket information</param>
/// <param name="clientId">Client's GUID</param>
public ClientConnectedEventArgs(StreamSocketInformation clientInformation, string clientId)
: base()
{
this.clientInformation = clientInformation;
this.ClientId = clientId;
}
/// <summary>
/// respond to GET/POST request
/// </summary>
/// <param name="request"></param>
/// <param name="os"></param>
/// <param name="socketInfo"></param>
/// <returns></returns>
private async Task writeResponseAsync(string request, IOutputStream os, StreamSocketInformation socketInfo)
{
try
{
request = request.TrimEnd('\0'); //remove possible null from request
string[] requestParts = request.Split('/');
//home page
if (request.Contains(NavConstants.DEFAULT_PAGE))
{
string html = "";
try
{
IDictionary<string, string> parameters = ParseParametersFromRequest(request);
if (!ValidateLoginRequest(parameters))
{
html = await LoadandUpdateStatus(loginStatus, Constants.LOGIN_ERROR, NavConstants.LOGIN);
loginStatus = Constants.LOGIN_ERROR;
}
else
{
html = await LoginWithCredentials(parameters[HostKey], parameters[DeviceKey], parameters[SharedKey]);
}
await WebHelper.WriteToStream(html, os);
}
catch (System.Exception ex)
{
try
{
// Try to send an error page back if there was a problem servicing the request
html = helper.GenerateErrorPage("There's been an error: " + ex.Message + "<br><br>" + ex.StackTrace);
await WebHelper.WriteToStream(html, os);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.StackTrace.ToString());
}
}
}
else if (request.Equals("/") || request.Contains(NavConstants.LOGIN))
{
string html = "";
//silent login- if the data exists, then login wiht the device otherwise show the login page
if (msgHub.Connect())
{
html = await LoadPage(NavConstants.DEFAULT_PAGE);
string loc = await lp.GetLocation();
devloc = "Device Location: " + loc;
html = await LoadandUpdateStatus("Device Location: #location#", devloc, NavConstants.DEFAULT_PAGE);
originalPages[NavConstants.DEFAULT_PAGE] = html;
}
else
{
html = await LoadandUpdateStatus(loginStatus, Constants.LOGIN_STD_MSG, NavConstants.LOGIN);
loginStatus = Constants.LOGIN_STD_MSG;
}
await WebHelper.WriteToStream(html, os);
}
else if (request.Contains(NavConstants.SEND_MESSAGE))
{
IDictionary<string, string> parameters = ParseParametersFromRequest(request);
string html = "";
if (parameters.ContainsKey("msgs"))
{
int numMsg = Int32.Parse(parameters["msgs"]);
SendMessages(numMsg);
html = await LoadandUpdateStatus(status, Constants.SENDING_AZURE, NavConstants.DEFAULT_PAGE);
status = Constants.SENDING_AZURE;
}
else
{
html = await LoadandUpdateStatus(status, Constants.ERROR_AZURE, NavConstants.DEFAULT_PAGE);
}
await WebHelper.WriteToStream(html, os);
}
else if (request.Contains(NavConstants.CANCEL_MESSAGE))
{
sendMsg = false;
string html = await LoadandUpdateStatus(status, Constants.READY_AZURE, NavConstants.DEFAULT_PAGE);
status = Constants.READY_AZURE;
await WebHelper.WriteToStream(html, os);
}
else if (request.Contains(NavConstants.CLEAR_LOG))
{
await UpdateLog(originalPages);
await WebHelper.WriteToStream(htmlPages[NavConstants.DEFAULT_PAGE], os);
}
else if (request.Contains(NavConstants.REFRESH_LOG))
{
await UpdateLog(htmlPages);
await WebHelper.WriteToStream(htmlPages[NavConstants.DEFAULT_PAGE], os);
}
else
{
using (Stream resp = os.AsStreamForWrite())
{
bool exists = await loadCSSPage(request, resp);
// Send 404 not found if can't find file
if (!exists)
{
byte[] headerArray = Encoding.UTF8.GetBytes(
"HTTP/1.1 404 Not Found\r\n" +
"Content-Length:0\r\n" +
"Connection: close\r\n\r\n");
await resp.WriteAsync(headerArray, 0, headerArray.Length);
}
else
{
Debug.WriteLine("LOADED: " + request);
}
await resp.FlushAsync();
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in writeResponseAsync(): " + ex.Message);
Debug.WriteLine(ex.StackTrace.ToString());
try
{
// Try to send an error page back if there was a problem servicing the request
string html = helper.GenerateErrorPage("There's been an error: " + ex.Message + "<br><br>" + ex.StackTrace);
await WebHelper.WriteToStream(html, os);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.StackTrace.ToString());
}
}
}
private async Task writeResponseAsync(string request, IOutputStream os, StreamSocketInformation socketInfo)
{
try
{
request = request.TrimEnd('\0'); //remove possible null from POST request
string[] requestParts = request.Split('/');
// Request for the root page, so redirect to home page
if (request.Equals("/"))
{
await redirectToPage(NavConstants.HOME_PAGE, os);
}
// Request for the home page
else if (request.Contains(NavConstants.HOME_PAGE))
{
// Generate the default config page
string html = await GeneratePageHtml(NavConstants.HOME_PAGE);
string onState = (this.playbackManager.PlaybackState == PlaybackState.Playing) ? "On" : "Off";
html = html.Replace("#onState#", onState);
html = html.Replace("#radioVolume#", (this.playbackManager.Volume * 100).ToString());
html = html.Replace("#currentTrack#", this.playlistManager.CurrentTrack.Name);
await WebHelper.WriteToStream(html, os);
}
// Request for the settings page
else if (request.Contains(NavConstants.SETTINGS_PAGE))
{
if (!string.IsNullOrEmpty(request))
{
string settingParam = "";
IDictionary <string, string> parameters = WebHelper.ParseGetParametersFromUrl(new Uri(string.Format("http://0.0.0.0/{0}", request)));
bool waitForPlaying = (this.playbackManager.PlaybackState == PlaybackState.Playing);
bool waitForTrackChange = false;
string trackName = this.playlistManager.CurrentTrack.Name;
settingParam = "onStateVal";
if (parameters.ContainsKey(settingParam) && !string.IsNullOrWhiteSpace(parameters[settingParam]))
{
switch (parameters[settingParam])
{
case "On":
if (!waitForPlaying)
{
this.playbackManager.Play(new Uri(this.playlistManager.CurrentTrack.Address));
}
waitForPlaying = true;
break;
case "Off":
this.playbackManager.Pause();
waitForPlaying = false;
break;
}
}
settingParam = "volumeSlide";
if (parameters.ContainsKey(settingParam) && !string.IsNullOrWhiteSpace(parameters[settingParam]))
{
double newVolume = this.playbackManager.Volume;
if (double.TryParse(parameters[settingParam], out newVolume))
{
newVolume = Math.Round(newVolume / 100, 2);
if (newVolume >= 0 && newVolume <= 1 && newVolume != this.playbackManager.Volume)
{
this.playbackManager.Volume = newVolume;
}
}
}
settingParam = "trackAction";
if (parameters.ContainsKey(settingParam) && !string.IsNullOrWhiteSpace(parameters[settingParam]))
{
waitForTrackChange = true;
switch (parameters[settingParam])
{
case "prev":
this.playbackManager.Pause();
this.playlistManager.PreviousTrack();
break;
case "next":
this.playbackManager.Pause();
this.playlistManager.NextTrack();
break;
case "track":
if (parameters.ContainsKey("trackName") && !string.IsNullOrWhiteSpace(parameters["trackName"]))
{
if (trackName != parameters["trackName"])
{
this.playbackManager.Pause();
this.playlistManager.PlayTrack(parameters["trackName"]);
}
else
{
waitForTrackChange = false;
}
}
break;
}
if (waitForTrackChange)
{
waitForPlaying = true;
}
}
DateTime timeOut = DateTime.Now.AddSeconds(30);
Debug.WriteLine("Waiting on State: playback={0}; trackname={1}", this.playbackManager.PlaybackState, trackName);
while (DateTime.Now.CompareTo(timeOut) < 0 && (
(this.playbackManager.PlaybackState == PlaybackState.Playing) != waitForPlaying ||
(this.playlistManager.CurrentTrack.Name != trackName) != waitForTrackChange
))
{
;
}
if (DateTime.Now.CompareTo(timeOut) >= 0)
{
Debug.WriteLine("track did not start playing in time limit");
}
}
//handle UI interaction
await redirectToPage(NavConstants.HOME_PAGE, os);
}
else if (request.Contains(NavConstants.ADDSTATION_PAGE))
{
string html = await GeneratePageHtml(NavConstants.ADDSTATION_PAGE);
string trackName = "";
string trackUrl = "";
if (!string.IsNullOrEmpty(request))
{
string settingParam = "trackName";
IDictionary <string, string> parameters = WebHelper.ParseGetParametersFromUrl(new Uri(string.Format("http://0.0.0.0/{0}", request)));
if (parameters.ContainsKey(settingParam) && !string.IsNullOrWhiteSpace(parameters[settingParam]))
{
Track trackToUpdate = playlistManager.CurrentPlaylist.Tracks.First(t => t.Name == parameters[settingParam]);
if (null != trackToUpdate)
{
trackName = trackToUpdate.Name;
trackUrl = trackToUpdate.Address;
}
}
}
html = html.Replace("var stationName = '';", string.Format("var stationName = '{0}';", trackName));
html = html.Replace("var stationUrl = '';", string.Format("var stationUrl = '{0}';", trackUrl));
await WebHelper.WriteToStream(html, os);
}
else if (request.Contains(NavConstants.ADDSTATIONSET_PAGE))
{
if (!string.IsNullOrEmpty(request))
{
Track origTrack = null;
Track newTrack = null;
string trackAction = "";
IDictionary <string, string> parameters = WebHelper.ParseGetParametersFromUrl(new Uri(string.Format("http://0.0.0.0/{0}", request)));
if (parameters.ContainsKey("name") && !string.IsNullOrWhiteSpace(parameters["name"]))
{
if (parameters.ContainsKey("url") && !string.IsNullOrWhiteSpace(parameters["url"]))
{
newTrack = new Track()
{
Name = parameters["name"], Address = parameters["url"]
};
}
}
if (parameters.ContainsKey("nameOrig") && !string.IsNullOrWhiteSpace(parameters["nameOrig"]))
{
origTrack = this.playlistManager.CurrentPlaylist.Tracks.First(t => t.Name == parameters["nameOrig"]);
}
if (parameters.ContainsKey("trackAction") && !string.IsNullOrWhiteSpace(parameters["trackAction"]))
{
trackAction = parameters["trackAction"];
}
if (null != newTrack)
{
switch (trackAction)
{
case "Update":
if (null != origTrack)
{
this.playlistManager.CurrentPlaylist.Tracks.Remove(origTrack);
}
this.playlistManager.CurrentPlaylist.Tracks.Add(newTrack);
break;
case "Remove":
if (null != origTrack)
{
this.playlistManager.CurrentPlaylist.Tracks.Remove(origTrack);
}
break;
case "":
case "Add":
this.playlistManager.CurrentPlaylist.Tracks.Add(newTrack);
break;
}
}
}
await redirectToPage(NavConstants.HOME_PAGE, os);
}
// Request for a file that is in the Assets\Web folder (e.g. logo, css file)
else
{
using (Stream resp = os.AsStreamForWrite())
{
bool exists = true;
try
{
var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
// Map the requested path to Assets\Web folder
string filePath = NavConstants.ASSETSWEB + request.Replace('/', '\\');
// Open the file and write it to the stream
using (Stream fs = await folder.OpenStreamForReadAsync(filePath))
{
string contentType = "";
if (request.Contains("css"))
{
contentType = "Content-Type: text/css\r\n";
}
if (request.Contains("htm"))
{
contentType = "Content-Type: text/html\r\n";
}
string header = String.Format("HTTP/1.1 200 OK\r\n" +
"Content-Length: {0}\r\n{1}" +
"Connection: close\r\n\r\n",
fs.Length,
contentType);
byte[] headerArray = Encoding.UTF8.GetBytes(header);
await resp.WriteAsync(headerArray, 0, headerArray.Length);
await fs.CopyToAsync(resp);
}
}
catch (FileNotFoundException ex)
{
exists = false;
// Log telemetry event about this exception
var events = new Dictionary <string, string> {
{ "WebServer", ex.Message }
};
TelemetryManager.WriteTelemetryEvent("FailedToOpenStream", events);
}
// Send 404 not found if can't find file
if (!exists)
{
byte[] headerArray = Encoding.UTF8.GetBytes(
"HTTP/1.1 404 Not Found\r\n" +
"Content-Length:0\r\n" +
"Connection: close\r\n\r\n");
await resp.WriteAsync(headerArray, 0, headerArray.Length);
}
await resp.FlushAsync();
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in writeResponseAsync(): " + ex.Message);
Debug.WriteLine(ex.StackTrace);
// Log telemetry event about this exception
var events = new Dictionary <string, string> {
{ "WebServer", ex.Message }
};
TelemetryManager.WriteTelemetryEvent("FailedToWriteResponse", events);
try
{
// Try to send an error page back if there was a problem servicing the request
string html = helper.GenerateErrorPage("There's been an error: " + ex.Message + "<br><br>" + ex.StackTrace);
await WebHelper.WriteToStream(html, os);
}
catch (Exception e)
{
TelemetryManager.WriteTelemetryException(e);
}
}
}
private async Task WriteResponseAsync(string requestUri, IOutputStream os, StreamSocketInformation socketInfo)
{
try
{
requestUri = requestUri.TrimEnd('\0'); //remove possible null from POST request
string[] uriParts = requestUri.Split('/');
if (requestUri == "/")
{
// Request for the root page, so redirect to home page
await redirectToPage(NavConstants.HOME_PAGE, os);
return;
}
else if (uriParts[1].ToLower().Contains("home") || uriParts[1].ToLower().Contains("index") || uriParts[1].ToLower().Contains("default"))
{
// Request for the home page
string html = await GeneratePageHtml(NavConstants.HOME_PAGE);
await WebHelper.WriteToStream(html, os);
return;
}
else if (uriParts[1].ToLower() == "api")
{
string json = await _webApiHelper.Execute(requestUri);
await WebHelper.WriteToStream(json, os);
return;
}
else// Request for a file that is in the Assets\Web folder (e.g. logo, css file)
{
using (Stream resp = os.AsStreamForWrite())
{
// Map the requested path to Assets\Web folder
StorageFolder folder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync(NavConstants.ASSETSWEB);
bool exists = await RetrieveFile(requestUri, folder, resp);
if (!exists)
{
if (requestUri.Contains(NavConstants.TEMP_FOLDER))
{
folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
exists = await RetrieveFile(requestUri, folder, resp);
if (!exists)
{
// Send 404 not found if can't find file
byte[] headerArray = Encoding.UTF8.GetBytes("HTTP/1.1 404 Not Found\r\nContent-Length:0\r\nConnection: close\r\n\r\n");
await resp.WriteAsync(headerArray, 0, headerArray.Length);
}
}
else
{
if (requestUri.Contains("favicon.ico"))//https://en.wikipedia.org/wiki/Favicon
{
folder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync(NavConstants.ASSETSWEB);
exists = await RetrieveFile(requestUri, folder, resp);
if (!exists)
{
// Send 404 not found if can't find file
byte[] headerArray = Encoding.UTF8.GetBytes("HTTP/1.1 404 Not Found\r\nContent-Length:0\r\nConnection: close\r\n\r\n");
await resp.WriteAsync(headerArray, 0, headerArray.Length);
}
}
else
{
//It raise warning message because web request shouldn't access to root installed folder
byte[] headerArray = Encoding.UTF8.GetBytes("HTTP/1.1 403 Forbidden\r\nContent-Length:0\r\nConnection: close\r\n\r\n");
await resp.WriteAsync(headerArray, 0, headerArray.Length);
}
}
}
await resp.FlushAsync();
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception in writeResponseAsync(): " + ex.Message);
Debug.WriteLine(ex.StackTrace);
// Log telemetry event about this exception
var events = new Dictionary <string, string> {
{ "WebServer", ex.Message }
};
TelemetryManager.WriteTelemetryEvent("FailedToWriteResponse", events);
try
{
// Try to send an error page back if there was a problem servicing the request
string html = _webhelper.GenerateErrorPage("There's been an error: " + ex.Message + "<br><br>" + ex.StackTrace);
await WebHelper.WriteToStream(html, os);
}
catch (Exception e)
{
TelemetryManager.WriteTelemetryException(e);
}
}
}
