public static IEsp8266Device GetDevice(SerialPort Port)
{
#region Error checking
if (Port == null)
{
throw new ArgumentNullException(nameof(Port));
}
if (!Port.IsOpen)
{
try {
Port.Open();
}
catch (UnauthorizedAccessException e) {
throw new EspConnectionException($"Failed to open port '{Port.PortName}' because: {e.Message}", Port);
}
}
#endregion
StreamWriter sw = new StreamWriter(Port.BaseStream)
{
AutoFlush = true
};
StreamReader sr = new StreamReader(Port.BaseStream);
CommandInvoker c = new CommandInvoker(sr, sw);
DeviceResponse Response = c.Send("AT");
if (Response.RequestSucceeded)
{
return(new BasicEspDevice(c));
}
throw new EspConnectionException(Port);
}
public async Task <ActionResult> Post(Device device)
{
ActionResult action;
try
{
if (this.ModelState.IsValid)
{
DeviceResponse response = await this.bussiness.Create(device);
Uri urlGet = new Uri(string.Format("{0}{1}/{2}", this.Request.Host.Value, this.Request.Path, device._id));
action = this.Created(urlGet, response.ActionResponse.Message);
}
else
{
action = this.Conflict(this.ModelState);
}
}
catch (System.Exception ex)
{
action = this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
}
return(action);
}
//Get a list of Available Roku Devices
public static async Task <RokuDevice[]> Discover(string ip = "239.255.255.250", int port = 1900, int waitSeconds = 15)
{
var token = new CancellationTokenSource();
var ucs = new UdpClient();
var mcEndpoint = new IPEndPoint(IPAddress.Parse(ip), port);
var data = string.Format(DISCOVER_MESSAGGE, ip, port);
var discoverBytes = Encoding.UTF8.GetBytes(data);
var startTime = DateTime.Now;
UdpReceiveResult result;
string DeviceResponse;
token.CancelAfter(TimeSpan.FromSeconds(waitSeconds));
var deviceQueries = new List <Task <RokuDevice> >();
using (var udp = new UdpClient())
{
await ucs.SendAsync(discoverBytes, discoverBytes.Length, mcEndpoint);
while (!token.IsCancellationRequested)
{
var operation = ucs.ReceiveAsync();
try
{
operation.Wait(token.Token); //Wait for result until cancelled
}
catch (Exception ex)
{
//We either have no devices or we didn't get any additional devices
//Not sure where to log this but can't display to user
}
if (operation.IsCompleted && !operation.IsFaulted)
{
result = operation.Result;
DeviceResponse = Encoding.ASCII.GetString(result.Buffer);
var match = Regex.Match(DeviceResponse, LOCATION_PATTERN, RegexOptions.IgnoreCase);
if (match.Success && DeviceResponse.ToLower().Contains("roku"))
{
var address = match.Groups["address"].Value;
//Don't allow device info request to hold up discovering additional devices
var deviceQuery = ReadDevice(address);
deviceQueries.Add(deviceQuery);
}
}
}
}
//Wait seconds does not apply to this
var devices = await Task.WhenAll(deviceQueries);
return(devices);
}
public DeviceResponse GetByID(string id)
{
DeviceResponse result = null;
using (SqlConnection connection = new SqlConnection(Connection.String))
{
SqlCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "DeviceGetByID";
command.Parameters.Add(new SqlParameter("@Id", id));
connection.Open();
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
result = MapResponsel(reader);
}
}
}
return(result);
}
public async Task <DeviceResponse> UpdateAsync(int id, Device device)
{
try
{
var exist = await _deviceRepository.FindByIdAsync(id);
DeviceResponse response = exist == null ? new DeviceResponse($"Device {id} not found") : new DeviceResponse(exist);
exist.UserName = device.UserName != "" ? device.UserName : exist.UserName;
exist.FirstBlock = device.FirstBlock != "" ? device.FirstBlock : exist.FirstBlock;
exist.SecondBlock = device.SecondBlock != "" ? device.SecondBlock : exist.SecondBlock;
exist.ThirdBlock = device.ThirdBlock != "" ? device.ThirdBlock : exist.ThirdBlock;
exist.FourthBlock = device.FourthBlock != "" ? device.FourthBlock : exist.FourthBlock;
_deviceRepository.Update(exist);
await _unitOfWork.CompleteAsync();
return(response);
}
catch (Exception e)
{
return(new DeviceResponse($"An error occurred when updating the access: { e.Message }"));
}
}
public async Task Move_SlotInfoAndComputerInfo_CarouselShouldMove(bool isOutsideComputer)
{
IUtility utility = new Utility();
_carousel = new CarWhiteIpcDualAccess(controlType: ControllerType.WhiteIPCDualAccess, ipAddr: _carouselData.Attribute.IPAddress, carAddr: _carouselData.Attribute.DeviceNumber,
port: _carouselData.Attribute.Port, timeOut: 10, returnsStatus: true, deviceResponse: _deviceResponse, socket: _socket);
_carousel.Connect();
//Assume
IDeviceResponse expected = new DeviceResponse()
{
HasError = false,
Message = "Data is written on device successfully.",
CurrentCarrier = 0
};
//Act
IDeviceResponse actual = await _carousel.Move(slot : await utility.BuildStorageSpaceItem(_carouselData.StorageSpaces), isOutsideComputer : isOutsideComputer);
_carousel.Disconnect();
//Assert
Assert.Equal(expected: expected.HasError, actual: actual.HasError);
Assert.Equal(expected: expected.Message, actual: actual.Message);
Assert.Equal(expected: expected.CurrentCarrier, actual: actual.CurrentCarrier);
}
public async Task MoveCarouse__TransactionQueue_DeviceResponse_CarWhiteTB1470H_Positive()
{
//Assume
IDeviceResponse expected = new DeviceResponse()
{
HasError = false
};
CarouselFactory carouselFactory = new CarouselFactory();
Utility utility = new Utility();
CarouselManager objCarouselManager = new CarouselManager(_configuration, _logger.Object, carouselFactory, _socket.Object, _deviceResponse.Object);
TransactionData data = CreateTransactionQueueData();
Device device = data.Devices.FirstOrDefault(dev => dev.Type.Equals("Carousel"));
device.Attribute.DeviceClass = ControllerType.WhiteTB1470H.ToString().ToUpper();
await objCarouselManager.CreateCarousel(data);
Slot slot = await utility.BuildStorageSpaceItem(device.StorageSpaces);
//Act
IDeviceResponse actual = await objCarouselManager.MoveCarousel(data, slot);
//Assert
Assert.Equal(expected.HasError, actual.HasError);
}
public bool CheckDeviceResponse(string response)
{
if (DeviceResponse == null)
{
return(response == null);
}
return(DeviceResponse.Equals(response));
}
public async Task TestUpdateDevice(UpdateDeviceRequest obj, ObjectResult resultAction, bool elementCreated = false)
{
DeviceResponse defaultCompany = await this.CreatedDefaultDevice();
obj.Id = elementCreated == true ? defaultCompany.Id : obj.Id;
IActionResult actionResult = await this.UpdateDevice(obj);
base.CheckAssert(actionResult, resultAction);
}
public async Task TestGetDevice(GetDeviceByIdRequest getcom, ObjectResult resultAction, bool elementCreated = false)
{
DeviceResponse defaultNotification = await this.CreatedDefaultDevice();
getcom.Id = elementCreated == true ? defaultNotification.Id : getcom.Id;
IActionResult actionResult = await this.GetDeviceById(getcom);
base.CheckAssert(actionResult, resultAction);
}
public async Task <string> GetVersionAsync()
{
DeviceResponse Response = await this.Command.SendAsync("AT+GMR");
if (Response.RequestSucceeded)
{
return(Response.Data.ElementAt(0));
}
throw new EspCommunicationException(Response);
}
/// <summary>
/// Attach Get Device Commands
/// </summary>
/// <param name="client">Spotify Sdk Client</param>
/// <param name="response">Device Response</param>
/// <param name="isAttach">Is Attach?</param>
public static void AttachGetDeviceCommands(
this ISpotifySdkClient client,
DeviceResponse response,
bool isAttach)
{
if (isAttach && response != null)
{
// Transfer User Playback Command
response.TransferUserPlaybackCommand = new GenericCommand <DeviceResponse>(
client.TransferUserPlaybackHandler);
}
}
public async Task TestDeleteNotification(DeleteDeviceByIdRequest delnot, ObjectResult resultAction, bool elementCreated = false)
{
DeviceResponse defaultNotification = await this.CreatedDefaultDevice();
//Guid createdtransactionId = CompanyComponentsValues.GetCompanyAviability();
delnot.Id = elementCreated == true ? defaultNotification.Id : delnot.Id;
IActionResult actionResult = await this.DeleteDevice(delnot);
base.CheckAssert(actionResult, resultAction);
}
/// <summary>
/// 向缓存中登记一个新的设备状态信息
/// </summary>
/// <param name="property">设备集合状态</param>
/// <param name="EndTime">过期时限</param>
/// <returns>返回0为成功，其它为错误值</returns>
public int AddDeviceCache(string deviceKey, DeviceResponse deviceResponse, DateTime EndTime)
{
bool bFlag = mc.AddObject(deviceKey, deviceResponse, EndTime);
if (bFlag)
{
return(0);
}
else
{
return((int)CodeEnum.ApplicationErr);
}
}
/// <summary>
/// Constructor to initialize the common fields to be used in all the test cases
/// </summary>
public CarWhiteIPCDualAccessTest()
{
//Default initialization
_carouselData = CreateTransactionQueueData().Devices.FirstOrDefault(dev => dev.Type.Equals("Carousel"));
_socket = new MockIIPSocket();
_deviceResponse = new DeviceResponse();
//Setup mock methods
_socket.setup_ConnectToServer(_carouselData.Attribute.IPAddress, _carouselData.Attribute.Port, 10);
_socket.setup_Disconnect();
_socket.setup_WriteSocket(string.Empty);
_socket.setup_IsConnected();
}
private DeviceResponse MapResponsel(SqlDataReader data)
{
DeviceResponse result = new DeviceResponse();
result.Id = data["Id"].ToString();
result.ManufacturerID = int.Parse(data["ManufacturerID"].ToString());
result.ScreenSize = double.Parse(data["ScreenSize"].ToString());
result.Model = data["Model"].ToString();
result.OperatingSystem = data["OperatingSystem"].ToString();
result.Ram = int.Parse(data["Ram"].ToString());
result.Manufacturer = data["Manufacturer"].ToString();
return(result);
}
public async Task <ActionResult <DeviceResponse> > Advertise(string port)
{
string selectedPort = port == null? Request.Cookies[Cookies.CookieRecentPortKey]: port;
DeviceResponse info = portApplication.Get(selectedPort);
if (info == null)
{
return(NotFound());
}
await steerer.AdvertiseAsync(selectedPort);
return(Ok(info));
}
public ActionResult <DeviceResponse> Get([FromRoute] string port)
{
DeviceResponse info = portApplication.Get(port);
if (info == null)
{
return(NotFound());
}
else
{
Response.Cookies.Append(Cookies.CookieRecentPortKey, info.Port);
return(Ok(info));
}
}
public async Task <DeviceResponse> FindAsync(int id)
{
try
{
var exist = await _deviceRepository.FindByIdAsync(id);
DeviceResponse response = exist == null ? new DeviceResponse($"Device {id} not found") : new DeviceResponse(exist);
return(response);
}
catch (Exception e)
{
return(new DeviceResponse($"An error occurred when finding the access: { e.Message }"));
}
}
public async Task <ActionResult> Delete(string id)
{
ActionResult action;
try
{
DeviceResponse response = await this.bussiness.Delete(id);
action = this.Ok(response.ActionResponse.Message);
}
catch (System.Exception ex)
{
action = this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
}
return(action);
}
public async Task MoveCarousel_ErrorFound_At_CreateCarousel_DeviceResponse()
{
IDeviceResponse deviceResponseAtCreateCarousel = new DeviceResponse()
{
HasError = true, Message = "Error Found at CreateCarousel."
};
IDeviceResponse deviceResponseMoveCarousel = new DeviceResponse();
var transactionData = CreateTransactionQueueData();
_carouselManager.Setup(x => x.CreateCarousel(transactionData)).Returns(Task.FromResult(deviceResponseAtCreateCarousel));
_carouselManager.Setup(x => x.MoveCarousel(transactionData, new Slot())).Returns(Task.FromResult(deviceResponseMoveCarousel));
CarouselProcess carouselProcess = new CarouselProcess(_logger.Object, _deviceResponse.Object, _carouselManager.Object, _utility.Object);
IDeviceResponse deviceResponse = await carouselProcess.MoveCarousel(transactionData);
Assert.Equal(deviceResponseAtCreateCarousel.HasError, deviceResponse.HasError);
Assert.Equal(deviceResponseAtCreateCarousel.Message, deviceResponse.Message);
}
public void PlaySong(List <string> uris)
{
try
{
Device = SpotifyClient.Player.GetAvailableDevices().Result;
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
Uris = uris,
PositionMs = 0,
DeviceId = Device.Devices.First().Id
};
SpotifyClient.Player.ResumePlayback(request);
}
catch (APIException e)
{
throw e;
}
}
public HttpResponseMessage Get(string userId)
{
logger.Info("ApiController GET (api/userId) called with userid [{0}]", userId);
Dictionary <string, DeviceResponse> deviceResponseList = new Dictionary <string, DeviceResponse>();
foreach (Device device in Globals.DeviceList.List())
{
DeviceResponse newDR = DeviceResponse.createResponse(device.name, device.id);
deviceResponseList.Add(device.id.ToString(), newDR);
}
HueApiResponse haResponse = new HueApiResponse();
haResponse.lights = deviceResponseList;
logger.Info("ApiController GET (api/userId) returned HueApi device with [{0}] light(s)", deviceResponseList.Count);
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, haResponse));
}
public void PlayAlbum(string uri)
{
try
{
Device = SpotifyClient.Player.GetAvailableDevices().Result;
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
ContextUri = "spotify:album:" + uri,
PositionMs = 0,
DeviceId = Device.Devices.First().Id
};
SpotifyClient.Player.ResumePlayback(request);
}
catch (APIException e)
{
throw e;
}
}
public async Task CreateCarousel_TransactionQueue_shouldCreateWhiteIPCDualAccessCarousel_Negative()
{
//Arrange
TransactionData objTransactionData = CreateTransactionQueueData();
Device _carouselData = objTransactionData.Devices.FirstOrDefault(dev => dev.Type.Equals("Carousel"));
_carousel = null;
IDeviceResponse divDeviceResponse = new DeviceResponse();
_carouselFactory.Setup(x => x.GetCarouselType(_carouselData, It.IsAny <IDeviceResponse>(), It.IsAny <IIPSocket>(), It.IsAny <string>())).Returns(Task.FromResult(_carousel));
CarouselManager objCarouselManager = new CarouselManager(_configuration, _logger.Object, _carouselFactory.Object, _socket.Object, divDeviceResponse);
//Act
IDeviceResponse deviceResponse = await objCarouselManager.CreateCarousel(objTransactionData);
//Assert
Assert.True(deviceResponse.HasError);
}
private void SearchSocketRecv(IAsyncResult Result)
{
if (SearchSocket == null)
{
return;
}
try
{
EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
int num = SearchSocket.EndReceiveFrom(Result, ref endPoint);
if (num <= 0)
{
return;
}
var msg = Encoding.UTF8.GetString(ReceiveBytes, 0, num);
var lines = msg.Split('\n', '\r');
var headers = lines.Where(x => x.Contains(":"))
.ToDictionary(
x => x.Substring(0, x.IndexOf(':')).Trim(),
x => x.Substring(x.IndexOf(':') + 1).Trim());
if (headers.Count == 0)
{
return;
}
var response = new DeviceResponse
{
FullHeaders = headers,
EndPoint = endPoint as IPEndPoint,
};
OnResponse?.Invoke(response);
}
finally
{
SearchSocket.BeginReceiveFrom(ReceiveBytes, 0, ReceiveBytes.Length, SocketFlags.None, ref endPoint, new AsyncCallback(SearchSocketRecv), this);
}
}
public async Task <ActionResult <Device> > Get(string id)
{
ActionResult action;
try
{
DeviceResponse response = await this.bussiness.GetById(id);
Device device = (response as DeviceResponseQueryByOne).Device;
action = response.ActionResponse.Success ? this.Ok(device) : (ActionResult)this.NotFound(response.ActionResponse.Message);
}
catch (System.Exception ex)
{
action = this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
}
return(action);
}
public async Task <ActionResult <IEnumerable <Device> > > Get()
{
ActionResult action;
try
{
DeviceResponse response = await this.bussiness.GetAll();
IEnumerable <Device> devices = (response as DeviceResponseQueryBySeveral).Devices;
action = response.ActionResponse.Success ? this.Ok(devices) : (ActionResult)this.NotFound(response.ActionResponse.Message);
}
catch (System.Exception ex)
{
action = this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message);
}
return(action);
}
public void PlaySong(string uri)
{
try
{
Device = SpotifyClient.Player.GetAvailableDevices().Result;
List <string> temp = new List <string>();
temp.Add("spotify:track:" + uri);
PlayerResumePlaybackRequest request = new PlayerResumePlaybackRequest()
{
Uris = temp,
PositionMs = 0,
DeviceId = Device.Devices.First().Id
};
SpotifyClient.Player.ResumePlayback(request);
}
catch (APIException e)
{
throw e;
}
}
public async Task MoveCarousel_ErrorFound_At_MoveCarousel_DeviceResponse()
{
IDeviceResponse deviceResponseAtMoveCarousel = new DeviceResponse()
{
HasError = true, Message = "Erro Found at MoveCarousel."
};
IDeviceResponse deviceResponseMoveCarousel = new DeviceResponse();
var transactionData = CreateTransactionQueueData();
Device device = transactionData.Devices.FirstOrDefault(dev => dev.Type.Equals("Carousel"));
Slot slot = new Slot();
_utility.Setup(x => x.BuildStorageSpaceItem(device.StorageSpaces)).Returns(Task.FromResult(slot));
_carouselManager.Setup(x => x.CreateCarousel(transactionData)).Returns(Task.FromResult(deviceResponseMoveCarousel));
_carouselManager.Setup(x => x.MoveCarousel(transactionData, slot)).Returns(Task.FromResult(deviceResponseAtMoveCarousel));
CarouselProcess carouselProcess = new CarouselProcess(_logger.Object, _deviceResponse.Object, _carouselManager.Object, _utility.Object);
IDeviceResponse deviceResponse = await carouselProcess.MoveCarousel(transactionData);
Assert.Equal(deviceResponseAtMoveCarousel.HasError, deviceResponse.HasError);
Assert.Equal(deviceResponseAtMoveCarousel.Message, deviceResponse.Message);
}
