void SendText(string text)
{
if (CommunicationMethod != null)
{
CommunicationMethod.SendText(text);
}
}
void SendBytes(byte[] bytes)
{
if (CommunicationMethod != null)
{
CommunicationMethod.SendBytes(bytes);
}
}
public BaseRoomba(string deviceName, CommunicationMethod communicationMethod)
{
if (String.IsNullOrEmpty(deviceName))
{
throw new ArgumentNullException("deviceName");
}
// TODO move this to factory
switch (communicationMethod)
{
case CommunicationMethod.Serial:
_communicationService = new SerialCommunicationService(deviceName);
break;
case CommunicationMethod.Bluetooth:
_communicationService = new BluetoothCommunicationService(deviceName);
break;
default:
_communicationService = new SerialCommunicationService(deviceName);
break;
}
// TODO remove magic number
_commandLag = TimeSpan.FromMilliseconds(200);
Velocity = 200;
}
public ActionResult DeleteConfirmed(int id)
{
CommunicationMethod communicationMethod = db.CommunicationMethods.Find(id);
db.CommunicationMethods.Remove(communicationMethod);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "CommunicationID,CommunicationName")] CommunicationMethod communicationMethod)
{
if (ModelState.IsValid)
{
db.Entry(communicationMethod).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(communicationMethod));
}
public EntryCommunicationMethod(CommunicationMethod comMethod)
{
InitializeComponent();
this._comMethod = comMethod;
//基底クラスで実装したコールバック関数でイベントフック
this.Load += base.Form_Load;
this.btnSave.Click += base.RegisterButton_Click;
}
public ActionResult Create([Bind(Include = "CommunicationID,CommunicationName")] CommunicationMethod communicationMethod)
{
if (ModelState.IsValid)
{
db.CommunicationMethods.Add(communicationMethod);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(communicationMethod));
}
/// <summary>
/// データ読み込み
/// </summary>
protected override void ReadData()
{
try
{
this._comMethod = CommunicationMethod.FindCommunicationMethodBy(base.Condition);
}
catch
{
throw;
}
this.grdList.DataSource = this._comMethod;
}
public async Task <CommunicationMethod> Invite_Test(CommunicationMethod method)
{
_smsGatewayClientMock
.Setup(mock => mock.SendMessage(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns((true, null));
_emailGateWayClientMock
.Setup(mock => mock.SendHtmlEmail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((true, null));
_dealerConfigurationServiceMock
.Setup(mock => mock.GetDealerInvitationContent(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(TestResources.DealerInvitationResponse);
return(await _underTest.Invite(TestResources.SaveCustomerVehicleRequest, TestResources.DealerConfigurationResponse, method));
}
private ExifToolResponse SendCommand(CommunicationMethod method, string cmd, params object[] args)
{
if (Status != ExeStatus.Ready)
{
throw new ExifToolException("Process must be ready");
}
ExifToolResponse resp;
lock (_lockObj)
{
_waitHandle.Reset();
_waitForErrorHandle.Reset();
if (method == CommunicationMethod.ViaFile)
{
SendViaFile(cmd, args);
}
else
{
DirectSend(cmd, args);
}
//if no output then probably there is an error, so wait at most SecondsToWaitForError for the error message to arrive
if (_output.Length == 0)
{
_waitForErrorHandle.WaitOne(TimeSpan.FromSeconds(SecondsToWaitForError));
resp = new ExifToolResponse(false, _error.ToString());
_error.Clear();
}
else
{
resp = new ExifToolResponse(true, _output.ToString());
_output.Clear();
}
_cmdCnt++;
}
if (!resp.IsSuccess && method == CommunicationMethod.Auto)
{
string err = resp.Result.ToLowerInvariant();
if (err.Contains("file not found") || err.Contains("invalid filename encoding"))
{
return(SendCommand(CommunicationMethod.ViaFile, cmd, args));
}
}
return(resp);
}
public void Invite_ExceptionIn_EmailOrSms_CommunicationMethod_Test(CommunicationMethod method)
{
_smsGatewayClientMock
.Setup(mock => mock.SendMessage(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns((false, new Exception()));
_dealerConfigurationServiceMock
.Setup(mock => mock.GetDealerInvitationContent(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(TestResources.DealerInvitationResponse);
_emailGateWayClientMock
.Setup(mock => mock.SendHtmlEmail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync((false, new Exception()));
Assert.ThrowsAsync <Exception>(() => _underTest.Invite(TestResources.SaveCustomerVehicleRequest,
TestResources.DealerConfigurationResponse, method));
}
// GET: CommunicationMethods/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CommunicationMethod communicationMethod = db.CommunicationMethods.Find(id);
if (communicationMethod == null)
{
return(HttpNotFound());
}
return(View(communicationMethod));
}
public void MapInvitation_Test(CommunicationMethod method, int communicationMethodId)
{
var invitation = _underTest.MapInvitation(TestResources.SaveCustomerVehicleRequest, TestResources.Invitation.DealerId,
communicationMethodId, method);
Assert.IsNotNull(invitation);
Assert.AreEqual(
method == CommunicationMethod.Sms
? TestResources.Customer.PhoneNumber
: TestResources.Customer.CustomerEmail, invitation.ContactDetail);
Assert.AreEqual(TestResources.Invitation.DealerId, invitation.DealerId);
Assert.AreEqual((int)Enum.Parse(typeof(CommunicationMethod), method.ToString(), true), invitation.Method);
}
public CommunicationCoordinator(CommunicationMethod method, Uri hostAddr = null, string channel = "")
{
Channel = string.IsNullOrEmpty(channel) ? DefaultPipeName : channel;
var localAddr = IpHelper.AddressToUri(IpHelper.GetMachineAddress(), false, 8081);
if (hostAddr == null)
{
hostAddr = localAddr;
}
var proc = Process.GetCurrentProcess();
CreateHost(method, hostAddr, proc);
CreateClient(method, localAddr, proc);
}
private void CreateHost(CommunicationMethod method, Uri hostAddr, Process proc)
{
_hostId = new Identity(proc.Id, "Host", Channel, IdentityRole.Host);
switch (method)
{
case CommunicationMethod.Tcp:
HostDevice = new HttpCommunicationDevice(_hostId, hostAddr);
break;
default:
HostDevice = new HttpCommunicationDevice(_hostId, hostAddr);
break;
}
HostDevice.MessageReceived += ReceivedMessage;
_hostId.Address = HostDevice.Uri;
}
private void CreateClient(CommunicationMethod method, Uri localAddr, Process proc)
{
_clientId = new Identity(proc.Id, "Client-" + proc.Id, "Client-" + Channel + proc.Id, IdentityRole.Client);
switch (method)
{
case CommunicationMethod.Tcp:
ClientDevice = new HttpCommunicationDevice(_clientId, localAddr);
break;
default:
ClientDevice = new NamedPipeCommunicationDevice(_clientId, localAddr);
break;
}
ClientDevice.ResponseReceived += ReceivedResponse;
ClientDevice.MessageReceived += ReceivedMessage;
_clientId.Address = ClientDevice.Uri;
}
/// <summary>
/// Serialize to a JSON object
/// </summary>
public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
{
if (includeStartObject)
{
writer.WriteStartObject();
}
((fhirCsR4.Models.BackboneElement) this).SerializeJson(writer, options, false);
if (Who != null)
{
writer.WritePropertyName("who");
Who.SerializeJson(writer, options);
}
if (OnBehalfOf != null)
{
writer.WritePropertyName("onBehalfOf");
OnBehalfOf.SerializeJson(writer, options);
}
if (CommunicationMethod != null)
{
writer.WritePropertyName("communicationMethod");
CommunicationMethod.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Date))
{
writer.WriteString("date", (string)Date !);
}
if (_Date != null)
{
writer.WritePropertyName("_date");
_Date.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(SourceIdentityCertificate))
{
writer.WriteString("sourceIdentityCertificate", (string)SourceIdentityCertificate !);
}
if (_SourceIdentityCertificate != null)
{
writer.WritePropertyName("_sourceIdentityCertificate");
_SourceIdentityCertificate.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(ProxyIdentityCertificate))
{
writer.WriteString("proxyIdentityCertificate", (string)ProxyIdentityCertificate !);
}
if (_ProxyIdentityCertificate != null)
{
writer.WritePropertyName("_proxyIdentityCertificate");
_ProxyIdentityCertificate.SerializeJson(writer, options);
}
if (ProxySignature != null)
{
writer.WritePropertyName("proxySignature");
ProxySignature.SerializeJson(writer, options);
}
if (SourceSignature != null)
{
writer.WritePropertyName("sourceSignature");
SourceSignature.SerializeJson(writer, options);
}
if (includeStartObject)
{
writer.WriteEndObject();
}
}
public RoombaCreate(string portName, CommunicationMethod communicationMethod)
: base(portName, communicationMethod)
{
}
/// <summary>
/// Returns filled DataTable by given SqlCommand.
/// Uses <see cref="HttpContext.Current" /> for thread-safe work.
/// </summary>
/// <param name="command">Command to execute.</param>
/// <param name="method">Method of loading of the data from a storage</param>
/// <returns>Resulting DataTable.</returns>
static public DataTable ExecuteDataTable(SqlCommand command, CommunicationMethod method)
{
bool useMSDTC = (method == CommunicationMethod.UseMSDTC) || ((method == CommunicationMethod.Default) && isMsDtcEnabled);
return(useMSDTC ? null : ExecuteDataTableWithoutMsDtc(command));
}
public void TestFindCommunicationMethodBy(int expected, Condition condition)
{
var data = CommunicationMethod.FindCommunicationMethodBy(condition);
Assert.AreEqual(expected, data.Count);
}
internal Invitation MapInvitation(SaveCustomerVehicleRequest request, int dealerId, int method, CommunicationMethod inviteCommunicationMethod)
{
var invitation = _mapper.Map <SaveCustomerVehicleRequest, Invitation>(request);
invitation.Method = method;
invitation.Timestamp = DateTime.Now;
invitation.DealerId = dealerId;
switch (inviteCommunicationMethod)
{
case CommunicationMethod.Email:
invitation.ContactDetail = request.CustomerEmail;
break;
case CommunicationMethod.Sms:
invitation.ContactDetail = request.PhoneNumber;
break;
}
return(invitation);
}
public async Task <CommunicationMethod> Invite(SaveCustomerVehicleRequest saveCustomerVehicleRequest, DealerConfigurationResponse dealerConfigResponse, CommunicationMethod method)
{
if (saveCustomerVehicleRequest == null)
{
throw new ArgumentNullException(nameof(saveCustomerVehicleRequest));
}
return(await SendInvite(saveCustomerVehicleRequest, dealerConfigResponse, method));
}
internal async Task <CommunicationMethod> SendInvite(SaveCustomerVehicleRequest request,
DealerConfigurationResponse dealerConfigResponse, CommunicationMethod method)
{
var dealerInvitationResponse = await _dealerConfigurationService.GetDealerInvitationContent(dealerConfigResponse.RooftopId, dealerConfigResponse.CommunityId);
if (dealerInvitationResponse == null)
{
throw new DealerInvitationContentException();
}
switch (method)
{
case CommunicationMethod.Email: // Send invitation via email.
return(await SendEmailWithOtherOption(request, dealerConfigResponse, dealerInvitationResponse));
case CommunicationMethod.SmsOrEmail:
{
if (!string.IsNullOrEmpty(request.PhoneNumber))
{
return(await SendSmsWithOtherOption(request, dealerConfigResponse, dealerInvitationResponse, true));
}
return(await SendEmailWithOtherOption(request, dealerConfigResponse, dealerInvitationResponse));
}
case CommunicationMethod.EmailOrSms:
return(await SendEmailWithOtherOption(request, dealerConfigResponse, dealerInvitationResponse, true));
case CommunicationMethod.Sms: // Send invitation via sms.
return(await SendSmsWithOtherOption(request, dealerConfigResponse, dealerInvitationResponse));
default:
return(CommunicationMethod.None);
}
}
/// <summary>
/// Deletes this business object from database.
/// </summary>
/// <param name="method">Method of loading of the data from a storage</param>
/// <returns>True if delete operation succeeded.</returns>
virtual public bool Delete(CommunicationMethod method)
{
return(manager.InternalDeleteObject(this, method));
}
