Merge pull request #36 from WilliamsJason/master (58b60bb8) · Commits · for microsoft in general / xbox / tunip3 / WindowsDevicePortalWrapper

WindowsDevicePortalWrapper/MockDataGenerator/App.config

0 → 100644

+6 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8" ?>
		<configuration>
		<startup>
		<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
		</startup>
		</configuration>
		No newline at end of file

WindowsDevicePortalWrapper/MockDataGenerator/DevicePortalConnection.cs

0 → 100644

+185 −0

Original line number	Diff line number	Diff line
		//----------------------------------------------------------------------------------------------
		// <copyright file="DevicePortalConnection.cs" company="Microsoft Corporation">
		// Licensed under the MIT License. See LICENSE.TXT in the project root license information.
		// </copyright>
		//----------------------------------------------------------------------------------------------

		using System;
		using System.Net;
		using System.Security.Cryptography.X509Certificates;
		using System.Text.RegularExpressions;
		using Microsoft.Tools.WindowsDevicePortal;
		using static Microsoft.Tools.WindowsDevicePortal.DevicePortal;

		namespace MockDataGenerator
		{
		/// <summary>
		/// IDevicePortalConnection implementation for MockDataGenerator test project
		/// </summary>
		public class DevicePortalConnection : IDevicePortalConnection
		{
		/// <summary>
		/// Device Certificate
		/// </summary>
		private X509Certificate2 deviceCertificate = null;

		/// <summary>
		/// Initializes a new instance of the <see cref="DevicePortalConnection"/> class.
		/// </summary>
		/// <param name="address">device identifier</param>
		/// <param name="userName">WDP username</param>
		/// <param name="password">WDP password</param>
		public DevicePortalConnection(
		string address,
		string userName,
		string password)
		{
		this.Connection = new Uri(string.Format("https://{0}", address));
		this.Credentials = new NetworkCredential(userName, password);
		}

		/// <summary>
		/// Gets Connection property
		/// </summary>
		public Uri Connection
		{
		get;
		private set;
		}

		/// <summary>
		/// Gets Web Socket Connection property
		/// </summary>
		public Uri WebSocketConnection
		{
		get
		{
		if (this.Connection == null)
		{
		return null;
		}

		string absoluteUri = this.Connection.AbsoluteUri;

		if (absoluteUri.StartsWith("https", StringComparison.InvariantCultureIgnoreCase))
		{
		return new Uri(Regex.Replace(absoluteUri, "https", "wss", RegexOptions.IgnoreCase \| RegexOptions.CultureInvariant));
		}
		else
		{
		return new Uri(Regex.Replace(absoluteUri, "http", "ws", RegexOptions.IgnoreCase \| RegexOptions.CultureInvariant));
		}
		}
		}

		/// <summary>
		/// Gets Credentials property
		/// </summary>
		public NetworkCredential Credentials
		{
		get;
		private set;
		}

		/// <summary>
		/// Gets or sets device family
		/// </summary>
		public string Family
		{
		get;
		set;
		}

		/// <summary>
		/// Gets or sets the device name
		/// </summary>
		public string Name
		{
		get;
		set;
		}

		/// <summary>
		/// Gets or sets device OS Info
		/// </summary>
		public OperatingSystemInformation OsInfo
		{
		get;
		set;
		}

		/// <summary>
		/// Gets or sets the device's qualified name
		/// </summary>
		public string QualifiedName
		{
		get;
		set;
		}

		/// <summary>
		/// Returns certificate data
		/// </summary>
		/// <returns>certificate data</returns>
		public byte[] GetDeviceCertificateData()
		{
		return this.deviceCertificate.GetRawCertData();
		}

		/// <summary>
		/// Validates and sets the device certificate.
		/// </summary>
		/// <param name="certificate">The device's root certificate.</param>
		public void SetDeviceCertificate(X509Certificate2 certificate)
		{
		if (!certificate.IssuerName.Name.Contains(DevicePortalCertificateIssuer))
		{
		throw new DevicePortalException(
		(HttpStatusCode)0,
		"Invalid certificate issuer",
		null,
		"Failed to download device certificate");
		}

		this.deviceCertificate = certificate;
		}

		/// <summary>
		/// Sets certificate data
		/// </summary>
		/// <param name="certificateData">certificate data</param>
		public void SetDeviceCertificate(byte[] certificateData)
		{
		X509Certificate2 cert = new X509Certificate2(certificateData);
		if (!cert.IssuerName.Name.Contains(DevicePortalCertificateIssuer))
		{
		throw new DevicePortalException(
		(HttpStatusCode)0,
		"Invalid certificate issuer",
		null,
		"Failed to download device certificate");
		}

		this.deviceCertificate = cert;
		}

		/// <summary>
		/// MockDataGenerator will never update the connection.
		/// </summary>
		/// <param name="requiresHttps">https required</param>
		public void UpdateConnection(bool requiresHttps)
		{
		throw new NotImplementedException();
		}

		/// <summary>
		/// MockDataGenerator will never update the connection.
		/// </summary>
		/// <param name="ipConfig">IP info</param>
		/// <param name="requiresHttps">https required</param>
		public void UpdateConnection(IpConfiguration ipConfig, bool requiresHttps)
		{
		throw new NotImplementedException();
		}
		}
		}

WindowsDevicePortalWrapper/MockDataGenerator/MockDataGenerator.csproj

0 → 100644

+70 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
		<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
		<PropertyGroup>
		<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
		<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
		<ProjectGuid>{C5AF45CA-C804-42ED-81FD-041B9B7FDBBD}</ProjectGuid>
		<OutputType>Exe</OutputType>
		<AppDesignerFolder>Properties</AppDesignerFolder>
		<RootNamespace>MockDataGenerator</RootNamespace>
		<AssemblyName>MockDataGenerator</AssemblyName>
		<TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
		<FileAlignment>512</FileAlignment>
		<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
		<StyleCopTreatErrorsAsWarnings>True</StyleCopTreatErrorsAsWarnings>
		</PropertyGroup>
		<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug\|AnyCPU' ">
		<PlatformTarget>AnyCPU</PlatformTarget>
		<DebugSymbols>true</DebugSymbols>
		<DebugType>full</DebugType>
		<Optimize>false</Optimize>
		<OutputPath>bin\Debug\</OutputPath>
		<DefineConstants>DEBUG;TRACE</DefineConstants>
		<ErrorReport>prompt</ErrorReport>
		<WarningLevel>4</WarningLevel>
		</PropertyGroup>
		<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release\|AnyCPU' ">
		<PlatformTarget>AnyCPU</PlatformTarget>
		<DebugType>pdbonly</DebugType>
		<Optimize>true</Optimize>
		<OutputPath>bin\Release\</OutputPath>
		<DefineConstants>TRACE</DefineConstants>
		<ErrorReport>prompt</ErrorReport>
		<WarningLevel>4</WarningLevel>
		</PropertyGroup>
		<ItemGroup>
		<Reference Include="System" />
		<Reference Include="System.Core" />
		<Reference Include="System.Xml.Linq" />
		<Reference Include="System.Data.DataSetExtensions" />
		<Reference Include="Microsoft.CSharp" />
		<Reference Include="System.Data" />
		<Reference Include="System.Net.Http" />
		<Reference Include="System.Xml" />
		</ItemGroup>
		<ItemGroup>
		<Compile Include="DevicePortalConnection.cs" />
		<Compile Include="ParameterHelper.cs" />
		<Compile Include="Program.cs" />
		<Compile Include="Properties\AssemblyInfo.cs" />
		</ItemGroup>
		<ItemGroup>
		<None Include="App.config" />
		</ItemGroup>
		<ItemGroup>
		<ProjectReference Include="..\WindowsDevicePortalWrapper\WindowsDevicePortalWrapper.csproj">
		<Project>{6a9e862e-5cda-4a8a-bbc0-56e9ea921e39}</Project>
		<Name>WindowsDevicePortalWrapper</Name>
		</ProjectReference>
		</ItemGroup>
		<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
		<Import Project="$(ProgramFiles)\MSBuild\StyleCop\v4.7\StyleCop.targets" />
		<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
		Other similar extension points exist, see Microsoft.Common.targets.
		<Target Name="BeforeBuild">
		</Target>
		<Target Name="AfterBuild">
		</Target>
		-->
		</Project>
		No newline at end of file

WindowsDevicePortalWrapper/MockDataGenerator/ParameterHelper.cs

0 → 100644

+119 −0

Original line number	Diff line number	Diff line
		//----------------------------------------------------------------------------------------------
		// <copyright file="ParameterHelper.cs" company="Microsoft Corporation">
		// Licensed under the MIT License. See LICENSE.TXT in the project root license information.
		// </copyright>
		//----------------------------------------------------------------------------------------------

		using System;
		using System.Collections.Generic;

		namespace MockDataGenerator
		{
		/// <summary>
		/// Class for parsing command line parameters
		/// </summary>
		public class ParameterHelper
		{
		/// <summary>
		/// Help Flag identifier string
		/// </summary>
		public static readonly string HelpFlag = "?";

		/// <summary>
		/// Device Identifier identifier string
		/// </summary>
		public static readonly string IpOrHostname = "ip";

		/// <summary>
		/// WDP Username identifier string
		/// </summary>
		public static readonly string WdpUser = "user";

		/// <summary>
		/// WDP Password identifier string
		/// </summary>
		public static readonly string WdpPassword = "pwd";

		/// <summary>
		/// List for storing parsed command line parameters as key value pairs.
		/// </summary>
		private Dictionary<string, string> parameters = new Dictionary<string, string>();

		/// <summary>
		/// List for storing parsed command line flags.
		/// </summary>
		private List<string> flags = new List<string>();

		/// <summary>
		/// Helper for getting a parameter value for a key
		/// </summary>
		/// <param name="key">parameter key</param>
		/// <returns>parameter value or null if not present</returns>
		public string GetParameterValue(string key)
		{
		if (this.parameters.ContainsKey(key))
		{
		return this.parameters[key];
		}
		else
		{
		return null;
		}
		}

		/// <summary>
		/// Helper for determining if we have a value for a parameter
		/// </summary>
		/// <param name="key">parameter key</param>
		/// <returns>boolean indicating if the parameter is present</returns>
		public bool HasParameter(string key)
		{
		return this.parameters.ContainsKey(key);
		}

		/// <summary>
		/// Helper for determining if a flag is set
		/// </summary>
		/// <param name="flag">flag name</param>
		/// <returns>boolean indicating if the flag is set</returns>
		public bool HasFlag(string flag)
		{
		return this.flags.Contains(flag);
		}

		/// <summary>
		/// Main entry for parsing a command line array
		/// </summary>
		/// <param name="args">command line args</param>
		public void ParseCommandLine(string[] args)
		{
		// Parse the command line args
		for (int i = 0; i < args.Length; ++i)
		{
		string arg = args[i];
		if (!arg.StartsWith("/") && !arg.StartsWith("-"))
		{
		throw new Exception(string.Format("Unrecognized argument: {0}", arg));
		}

		arg = arg.Substring(1);

		int valueIndex = arg.IndexOf(':');
		string value = null;

		// If this contains a colon, seperate it into the param and value. Otherwise add it as a flag
		if (valueIndex > 0)
		{
		value = arg.Substring(valueIndex + 1);
		arg = arg.Substring(0, valueIndex);

		this.parameters.Add(arg.ToLowerInvariant(), value);
		}
		else
		{
		this.flags.Add(arg.ToLowerInvariant());
		}
		}
		}
		}
		}

WindowsDevicePortalWrapper/MockDataGenerator/Program.cs

0 → 100644

+120 −0

Original line number	Diff line number	Diff line
		//----------------------------------------------------------------------------------------------
		// <copyright file="Program.cs" company="Microsoft Corporation">
		// Licensed under the MIT License. See LICENSE.TXT in the project root license information.
		// </copyright>
		//----------------------------------------------------------------------------------------------

		using System;
		using System.IO;
		using System.Net;
		using System.Threading.Tasks;
		using Microsoft.Tools.WindowsDevicePortal;

		namespace MockDataGenerator
		{
		/// <summary>
		/// Main entry point for the test command line class.
		/// </summary>
		public class Program
		{
		/// <summary>
		/// Usage string
		/// </summary>
		private const string GeneralUsageMessage = "Usage: /ip:<system-ip or hostname> /user:<WDP username> /pwd:<WDP password> [/endpoint:<api to call>] [/directory:<directory to save mock data file(s)>";

		/// <summary>
		/// Endpoints for REST calls to populate
		/// </summary>
		private static readonly string[] Endpoints =
		{
		DevicePortal.DeviceFamilyApi,
		DevicePortal.MachineNameApi,
		DevicePortal.OsInfoApi,
		DevicePortal.XboxLiveUserApi,
		};

		/// <summary>
		/// Main entry point
		/// </summary>
		/// <param name="args">command line args</param>
		public static void Main(string[] args)
		{
		ParameterHelper parameters = new ParameterHelper();
		Program app = new Program();

		try
		{
		parameters.ParseCommandLine(args);
		}
		catch (Exception e)
		{
		Console.WriteLine(e.Message);
		Console.WriteLine();
		Console.WriteLine(GeneralUsageMessage);
		return;
		}

		if (parameters.HasFlag(ParameterHelper.HelpFlag))
		{
		Console.WriteLine(GeneralUsageMessage);
		return;
		}

		if (!parameters.HasParameter(ParameterHelper.IpOrHostname) \|\| !parameters.HasParameter(ParameterHelper.WdpUser) \|\| !parameters.HasParameter(ParameterHelper.WdpPassword))
		{
		Console.WriteLine("Missing one or more required parameter(s). Must provide ip, user, and pwd");
		Console.WriteLine();
		Console.WriteLine(GeneralUsageMessage);
		return;
		}

		DevicePortalConnection connection = new DevicePortalConnection(parameters.GetParameterValue(ParameterHelper.IpOrHostname), parameters.GetParameterValue(ParameterHelper.WdpUser), parameters.GetParameterValue(ParameterHelper.WdpPassword));
		DevicePortal portal = new DevicePortal(connection);

		Task connectTask = portal.Connect(updateConnection: false);
		connectTask.Wait();

		if (portal.ConnectionHttpStatusCode != HttpStatusCode.OK)
		{
		if (portal.ConnectionHttpStatusCode != 0)
		{
		Console.WriteLine(string.Format("Failed to connect to WDP with HTTP Status code: {0}", portal.ConnectionHttpStatusCode));
		}
		else
		{
		Console.WriteLine("Failed to connect to WDP for unknown reason.");
		}

		return;
		}

		string directory = "MockData";

		if (parameters.HasParameter("directory"))
		{
		directory = parameters.GetParameterValue("directory");
		}

		if (!Directory.Exists(directory))
		{
		Directory.CreateDirectory(directory);
		}

		if (parameters.HasParameter("endpoint"))
		{
		Task saveResponseTask = portal.SaveEndpointResponseToFile(parameters.GetParameterValue("endpoint"), directory);
		saveResponseTask.Wait();
		}
		else
		{
		foreach (string endpoint in Endpoints)
		{
		Task saveResponseTask = portal.SaveEndpointResponseToFile(endpoint, directory);
		saveResponseTask.Wait();
		}
		}

		Console.WriteLine("Data generated in directory {0}. Please make sure to remove any personally identifiable information from the response(s) before adding them as mock responses.", directory);
		}
		}
		}