private ServiceResult OnGenerateAASCall(ISystemContext context, MethodState method, IList <object> inputArguments, IList <object> outputArguments)
{
try
{
string packagePath = Path.Combine(Directory.GetCurrentDirectory(), "Station.aasx");
using (Package package = Package.Open(packagePath, FileMode.Create))
{
// add package origin part
PackagePart origin = package.CreatePart(new Uri("/aasx/aasx-origin", UriKind.Relative), MediaTypeNames.Text.Plain, CompressionOption.Maximum);
using (Stream fileStream = origin.GetStream(FileMode.Create))
{
var bytes = Encoding.ASCII.GetBytes("Intentionally empty.");
fileStream.Write(bytes, 0, bytes.Length);
}
package.CreateRelationship(origin.Uri, TargetMode.Internal, "http://www.admin-shell.io/aasx/relationships/aasx-origin");
// add package spec part
PackagePart spec = package.CreatePart(new Uri("/aasx/aasenv-with-no-id/aasenv-with-no-id.aas.xml", UriKind.Relative), MediaTypeNames.Text.Xml);
string packageSpecPath = Path.Combine(Directory.GetCurrentDirectory(), "aasenv-with-no-id.aas.xml");
using (FileStream fileStream = new FileStream(packageSpecPath, FileMode.Open, FileAccess.Read))
{
CopyStream(fileStream, spec.GetStream());
}
origin.CreateRelationship(spec.Uri, TargetMode.Internal, "http://www.admin-shell.io/aasx/relationships/aas-spec");
// add the nodeset2.xml as a supplemental document part
PackagePart supplementalDoc = package.CreatePart(new Uri("/aasx/Station.NodeSet2.xml", UriKind.Relative), MediaTypeNames.Text.Xml);
string documentPath = Path.Combine(Directory.GetCurrentDirectory(), "Station.NodeSet2.xml");
using (FileStream fileStream = new FileStream(documentPath, FileMode.Open, FileAccess.Read))
{
CopyStream(fileStream, supplementalDoc.GetStream());
}
package.CreateRelationship(supplementalDoc.Uri, TargetMode.Internal, "http://www.admin-shell.io/aasx/relationships/aas-suppl");
}
return(ServiceResult.Good);
}
catch (Exception ex)
{
return(ServiceResult.Create(ex, StatusCodes.BadUnexpectedError, "Failed to create Asset Admin Shell!"));
}
}
/// <summary>
/// Sends a fault response secured with the asymmetric keys.
/// </summary>
private void SendServiceFault(uint requestId, ServiceResult fault)
{
Utils.Trace("Channel {0} Request {1}: SendServiceFault()", ChannelId, requestId);
BufferCollection chunksToSend = null;
try
{
// construct fault.
ServiceFault response = new ServiceFault();
response.ResponseHeader.ServiceResult = fault.Code;
StringTable stringTable = new StringTable();
response.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
fault,
DiagnosticsMasks.NoInnerStatus,
true,
stringTable);
response.ResponseHeader.StringTable = stringTable.ToArray();
// serialize fault.
byte[] buffer = BinaryEncoder.EncodeMessage(response, Quotas.MessageContext);
// secure message.
chunksToSend = WriteAsymmetricMessage(
TcpMessageType.Open,
requestId,
ServerCertificate,
ClientCertificate,
new ArraySegment <byte>(buffer, 0, buffer.Length));
// write the message to the server.
BeginWriteMessage(chunksToSend, null);
chunksToSend = null;
}
catch (Exception e)
{
if (chunksToSend != null)
{
chunksToSend.Release(BufferManager, "SendServiceFault");
}
ForceChannelFault(ServiceResult.Create(e, StatusCodes.BadTcpInternalError, "Unexpected error sending a service fault."));
}
}
/// <summary>
/// Returns the data dictionary from cache or disk (updates the data type version as well).
/// </summary>
protected virtual byte[] ReadDictionary(double maxAge)
{
byte[] dictionary = Value;
// return cached value.
if (dictionary != null)
{
if (Timestamp.AddMilliseconds(MinimumSamplingInterval) > DateTime.UtcNow)
{
return(dictionary);
}
if (Timestamp.AddMilliseconds(maxAge) > DateTime.UtcNow)
{
return(dictionary);
}
if (m_assembly != null)
{
return(dictionary);
}
}
// read from source.
try
{
if (m_assembly != null)
{
dictionary = ReadDictionaryFromResource(m_filePath);
}
else if (m_filePath.StartsWith(Uri.UriSchemeHttp))
{
dictionary = ReadDictionaryFromHttpFile(m_filePath);
}
else
{
dictionary = ReadDictionaryFromDiskFile(m_filePath);
}
return(dictionary);
}
catch (Exception e)
{
ServiceResult error = ServiceResult.Create(e, StatusCodes.BadOutOfService, "Could not access data dictionary file: {0}.", m_filePath);
UpdateStatus(error);
return(null);
}
}
private ServiceResult OnWriteEnabled(ISystemContext context, NodeState node, ref object value)
{
try
{
simulationEnabled_ = (bool)value;
simulationTimer_.Change(100, simulationEnabled_ ? simulationInterval_ : 0);
return(ServiceResult.Good);
}
catch (Exception e)
{
Utils.Trace(e, "Error writing Enabled variable.");
return(ServiceResult.Create(e, StatusCodes.Bad, "Error writing Enabled variable."));
}
}
/// <summary>
/// Handle method call to get configured endpoints
/// </summary>
private ServiceResult OnGetConfiguredEndpointsCall(ISystemContext context, MethodState method, IList <object> inputArguments, IList <object> outputArguments)
{
string logPrefix = "GetConfiguredEndpointsCall:";
try
{
var methodResult = HubCommunication.HandleGetConfiguredEndpointsMethodAsync(new Microsoft.Azure.Devices.Client.MethodRequest("GetConfiguredEndpointsMethod", Encoding.UTF8.GetBytes(inputArguments[0] as string)), null).Result;
outputArguments[0] = methodResult.ResultAsJson;
}
catch (Exception ex)
{
Logger.Error($"{logPrefix} The request is invalid!");
return(ServiceResult.Create(ex, null, StatusCodes.Bad));
}
return(ServiceResult.Good);
}
public async Task <IActionResult> GetCommandDescriptor(string serviceId, string address)
{
IEnumerable <ServiceCommandDescriptor> list = null;
if (!string.IsNullOrEmpty(serviceId))
{
list = await ServiceLocator.GetService <IFaultTolerantProvider>().GetCommandDescriptor(serviceId);
}
else if (!string.IsNullOrEmpty(address))
{
list = await ServiceLocator.GetService <IFaultTolerantProvider>().GetCommandDescriptorByAddress(address);
}
var result = ServiceResult <IEnumerable <ServiceCommandDescriptor> > .Create(true, list);
return(Json(result));
}
/// <summary>
/// Sends a fault response secured with the symmetric keys.
/// </summary>
private void SendServiceFault(TcpChannelToken token, uint requestId, ServiceResult fault)
{
// Utils.Trace("Channel {0} Request {1}: SendServiceFault()", ChannelId, requestId);
BufferCollection buffers = null;
try {
// construct fault.
ServiceFault response = new ServiceFault();
response.ResponseHeader.ServiceResult = fault.Code;
StringTable stringTable = new StringTable();
response.ResponseHeader.ServiceDiagnostics = new DiagnosticInfo(
fault,
DiagnosticsMasks.NoInnerStatus,
true,
stringTable);
response.ResponseHeader.StringTable = stringTable.ToArray();
// the limits should never be exceeded when sending a fault.
bool limitsExceeded = false;
// secure message.
buffers = WriteSymmetricMessage(
TcpMessageType.Message,
requestId,
token,
response,
false,
out limitsExceeded);
// send message.
BeginWriteMessage(buffers, Int32.MaxValue, null);
buffers = null;
} catch (Exception e) {
if (buffers != null)
{
buffers.Release(BufferManager, "SendServiceFault");
}
ForceChannelFault(ServiceResult.Create(e, StatusCodes.BadTcpInternalError,
"Unexpected error sending a service fault."));
}
}
public ServiceResult OnWriteValue(ISystemContext context, NodeState node, ref object value)
{
if (context.UserIdentity == null || context.UserIdentity.TokenType == UserTokenType.Anonymous)
{
TranslationInfo info = new TranslationInfo(
"BadUserAccessDenied",
"en-US",
"User cannot change value.");
return(new ServiceResult(StatusCodes.BadUserAccessDenied, new LocalizedText(info)));
}
// attempt to update file system.
try
{
string filePath = value as string;
PropertyState <string> variable = node as PropertyState <string>;
if (!String.IsNullOrEmpty(variable.Value))
{
FileInfo file = new FileInfo(variable.Value);
if (file.Exists)
{
file.Delete();
}
}
if (!String.IsNullOrEmpty(filePath))
{
FileInfo file = new FileInfo(filePath);
using (StreamWriter writer = file.CreateText())
{
writer.WriteLine(System.Security.Principal.WindowsIdentity.GetCurrent().Name);
}
}
value = filePath;
}
catch (Exception e)
{
return(ServiceResult.Create(e, StatusCodes.BadUserAccessDenied, "Could not update file system."));
}
return(ServiceResult.Good);
}
//writing value on specific intervals
private ServiceResult OnWriteInterval(ISystemContext context, NodeState node, ref object value)
{
try
{
m_simulationInterval = (UInt16)value;
if (m_simulationEnabled)
{
m_simulationTimer.Change(100, (int)m_simulationInterval);
}
return(ServiceResult.Good);
}
catch (Exception e)
{
Utils.Trace(e, "Error writing Interval variable.");
return(ServiceResult.Create(e, StatusCodes.Bad, "Error writing Interval variable."));
}
}
/// <summary>
/// Data node in the server which registers ourselves with IoT Hub when this node is written to
/// </summary>
public ServiceResult ConnectionStringWrite(ISystemContext context, NodeState node, NumericRange indexRange, QualifiedName dataEncoding, ref object value, ref StatusCode statusCode, ref DateTime timestamp)
{
var connectionString = value as string;
if (string.IsNullOrEmpty(connectionString))
{
Program.Trace("ConnectionStringWrite: Invalid Argument!");
return(ServiceResult.Create(StatusCodes.BadArgumentsMissing, "Please provide all arguments as strings!"));
}
statusCode = StatusCodes.Bad;
timestamp = DateTime.Now;
// read current connection string and compare to the one passed in
string currentConnectionString = SecureIoTHubToken.Read(Program.m_configuration.ApplicationName);
if (string.Equals(connectionString, currentConnectionString, StringComparison.OrdinalIgnoreCase))
{
Program.Trace("ConnectionStringWrite: Connection string up to date!");
return(ServiceResult.Create(StatusCodes.Bad, "Connection string already up-to-date!"));
}
Program.Trace("Attemping to configure publisher with connection string: " + connectionString);
// configure publisher and write connection string
try
{
DeviceClient newClient = DeviceClient.CreateFromConnectionString(connectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt);
newClient.RetryPolicy = RetryPolicyType.Exponential_Backoff_With_Jitter;
newClient.OpenAsync().Wait();
SecureIoTHubToken.Write(Program.m_configuration.ApplicationName, connectionString);
Program.m_deviceClient = newClient;
}
catch (Exception ex)
{
statusCode = StatusCodes.Bad;
Program.Trace("ConnectionStringWrite: Exception: " + ex.ToString());
return(ServiceResult.Create(StatusCodes.Bad, "Publisher registration failed: " + ex.Message));
}
statusCode = StatusCodes.Good;
Program.Trace("ConnectionStringWrite: Success!");
return(statusCode);
}
private (bool, ServiceResult <object>) OnAuthorization(ServiceRoute route, Dictionary <string, object> model)
{
bool isSuccess = true;
var serviceResult = ServiceResult <object> .Create(false, null);
if (route.ServiceDescriptor.EnableAuthorization())
{
if (route.ServiceDescriptor.AuthType() == AuthorizationType.JWT.ToString())
{
isSuccess = ValidateJwtAuthentication(route, model, ref serviceResult);
}
else
{
isSuccess = ValidateAppSecretAuthentication(route, model, ref serviceResult);
}
}
return(new ValueTuple <bool, ServiceResult <object> >(isSuccess, serviceResult));
}
public async Task <ServiceResult <object> > Post(string path, string serviceKey, Dictionary <string, object> model)
{
model = model ?? new Dictionary <string, object>();
ServiceResult <object> result = ServiceResult <object> .Create(false, null);
path = string.IsNullOrEmpty(path) ?
GateWayAppConfig.AuthorizationRoutePath : path.ToLower();
if (OnAuthorization(path, model, ref result))
{
if (path == GateWayAppConfig.AuthorizationRoutePath)
{
var token = await _authorizationServerProvider.GenerateTokenCredential(model);
if (token != null)
{
result = ServiceResult <object> .Create(true, token);
result.StatusCode = (int)ServiceStatusCode.Success;
}
else
{
result = new ServiceResult <object> {
IsSucceed = false, StatusCode = (int)ServiceStatusCode.AuthorizationFailed, Message = "Invalid authentication credentials"
};
}
}
else
{
if (!string.IsNullOrEmpty(serviceKey))
{
result = ServiceResult <object> .Create(true, await _serviceProxyProvider.Invoke <object>(model, path, serviceKey));
result.StatusCode = (int)ServiceStatusCode.Success;
}
else
{
result = ServiceResult <object> .Create(true, await _serviceProxyProvider.Invoke <object>(model, path));
result.StatusCode = (int)ServiceStatusCode.Success;
}
}
}
return(result);
}
public ServiceResult <Manager> GetManagerById(string id)
{
try
{
ServiceResult <Manager> result = null;
var manageId = 0;
int.TryParse(id, out manageId);
result = ServiceResult <Manager> .Create(true, _managerService.GetManagerById(manageId));
return(result);
}
catch (ServiceException e)
{
var result = ServiceResult <Manager> .Create(false, e.Message, null);
result.ErrorCode = e.Code;
return(result);
}
}
private ServiceResult OnWriteInterval(ISystemContext context, NodeState node, ref object value)
{
try
{
simulationInterval_ = (ushort)value;
if (simulationEnabled_)
{
simulationTimer_.Change(100, simulationInterval_);
}
return(ServiceResult.Good);
}
catch (Exception e)
{
Utils.Trace(e, "Error writing Interval variable.");
return(ServiceResult.Create(e, StatusCodes.Bad, "Error writing Interval variable."));
}
}
public async Task <(bool, ServiceResult <object>)> ValidateJwtAuthentication(ServiceRoute route, Dictionary <string, object> model)
{
var result = ServiceResult <object> .Create(false, null);
bool isSuccess = true;
var author = HttpContext.Request.Headers["Authorization"];
if (author.Count > 0)
{
isSuccess = await _authorizationServerProvider.ValidateClientAuthentication(author);
if (!isSuccess)
{
result = new ServiceResult <object> {
IsSucceed = false, StatusCode = Surging.Core.CPlatform.Exceptions.StatusCode.UnAuthentication, Message = "Invalid authentication credentials"
};
}
else
{
var payload = _authorizationServerProvider.GetPayloadString(author);
RpcContext.GetContext().SetAttachment("payload", payload);
if (model.Count > 0)
{
var keyValue = model.FirstOrDefault();
if (!(keyValue.Value is IConvertible) || !typeof(IConvertible).GetTypeInfo().IsAssignableFrom(keyValue.Value.GetType()))
{
dynamic instance = keyValue.Value;
instance.Payload = payload;
model.Remove(keyValue.Key);
model.Add(keyValue.Key, instance);
}
}
}
}
else
{
result = new ServiceResult <object> {
IsSucceed = false, StatusCode = Surging.Core.CPlatform.Exceptions.StatusCode.RequestError, Message = "Request error"
};
isSuccess = false;
}
return(isSuccess, result);
}
/// <summary>
/// Called when the alarm is acknowledged.
/// </summary>
private ServiceResult OnAcknowledge(
ISystemContext context,
MethodState method,
NodeId objectId,
byte[] eventId,
LocalizedText comment)
{
ComAeClientManager system = (ComAeClientManager)this.SystemContext.SystemHandle;
ComAeClient client = (ComAeClient)system.SelectClient((ServerSystemContext)context, false);
try
{
return(client.Acknowledge((ServerSystemContext)context, eventId, comment));
}
catch (Exception e)
{
return(ServiceResult.Create(e, StatusCodes.BadUnexpectedError, "Could not acknowledge event."));
}
}
/// <summary>
/// Handles a read complete event.
/// </summary>
private void OnReadComplete(object sender, SocketAsyncEventArgs e)
{
lock (m_readLock)
{
ServiceResult error = null;
try
{
bool innerCall = m_readState == ReadState.ReadComplete;
error = DoReadComplete(e);
// to avoid recursion, inner calls of OnReadComplete return
// after processing the ReadComplete and let the outer call handle it
if (!innerCall && !ServiceResult.IsBad(error))
{
while (ReadNext())
{
;
}
}
}
catch (Exception ex)
{
Utils.Trace(ex, "Unexpected error during OnReadComplete,");
error = ServiceResult.Create(ex, StatusCodes.BadTcpInternalError, ex.Message);
}
finally
{
e?.Dispose();
}
if (ServiceResult.IsBad(error))
{
if (m_receiveBuffer != null)
{
m_bufferManager.ReturnBuffer(m_receiveBuffer, "OnReadComplete");
m_receiveBuffer = null;
}
m_sink?.OnReceiveError(this, error);
}
}
}
private async Task <(bool, ServiceResult <object>)> OnAuthorization(string path, Dictionary <string, object> model)
{
bool isSuccess = true;
var route = await _serviceRouteProvider.GetRouteByPath(path);
var serviceResult = ServiceResult <object> .Create(false, null);
if (route.ServiceDescriptor.EnableAuthorization())
{
if (route.ServiceDescriptor.AuthType() == AuthorizationType.JWT.ToString())
{
isSuccess = ValidateJwtAuthentication(route, model, ref serviceResult);
}
else
{
isSuccess = ValidateAppSecretAuthentication(route, path, model, ref serviceResult);
}
}
return(new ValueTuple <bool, ServiceResult <object> >(isSuccess, serviceResult));
}
/// <summary>
/// Data node in the server which registers ourselves with IoT Hub when this node is written.
/// </summary>
public ServiceResult OnConnectionStringWrite(ISystemContext context, NodeState node, NumericRange indexRange, QualifiedName dataEncoding, ref object value, ref StatusCode statusCode, ref DateTime timestamp)
{
var connectionString = value as string;
if (string.IsNullOrEmpty(connectionString))
{
Trace("ConnectionStringWrite: Invalid Argument!");
return(ServiceResult.Create(StatusCodes.BadArgumentsMissing, "Please provide all arguments as strings!"));
}
statusCode = StatusCodes.Bad;
timestamp = DateTime.Now;
// read current connection string and compare to the one passed in
string currentConnectionString = SecureIoTHubToken.Read(OpcConfiguration.ApplicationName, IotDeviceCertStoreType, IotDeviceCertStorePath);
if (string.Equals(connectionString, currentConnectionString, StringComparison.OrdinalIgnoreCase))
{
Trace("ConnectionStringWrite: Connection string up to date!");
return(ServiceResult.Create(StatusCodes.Bad, "Connection string already up-to-date!"));
}
Trace($"ConnectionStringWrite: Attempting to configure publisher with connection string: {connectionString}");
// configure publisher and write connection string
try
{
IotHubCommunication.ConnectionStringWrite(connectionString);
}
catch (Exception e)
{
statusCode = StatusCodes.Bad;
Trace(e, $"ConnectionStringWrite: Exception while trying to create IoTHub client and store device connection string in cert store");
return(ServiceResult.Create(StatusCodes.Bad, "Publisher registration failed: " + e.Message));
}
statusCode = StatusCodes.Good;
Trace("ConnectionStringWrite: Success!");
return(statusCode);
}
/// <summary>
/// Handle method call to call direct IoTHub methods
/// </summary>
private ServiceResult OnIoTHubDirectMethodCall(ISystemContext context, MethodState method, IList <object> inputArguments, IList <object> outputArguments)
{
string logPrefix = "OnIoTHubDirectMethodCall:";
try
{
if (string.IsNullOrEmpty(inputArguments[0] as string))
{
string errorMessage = "There is no direct method name specified.";
Logger.Error($"{logPrefix} {errorMessage}");
return(ServiceResult.Create(StatusCodes.BadArgumentsMissing, errorMessage));
}
string methodRequest = string.Empty;
if ((inputArguments[1] as string) != null)
{
methodRequest = inputArguments[1] as string;
}
string methodName = inputArguments[0] as string;
if (IotHubDirectMethods.ContainsKey(inputArguments[0] as string))
{
var methodCallback = IotHubDirectMethods.GetValueOrDefault(methodName);
var methodResponse = methodCallback(new MethodRequest(methodName, Encoding.UTF8.GetBytes(methodRequest)), null).Result;
outputArguments[0] = methodResponse.ResultAsJson;
}
else
{
var methodCallback = IotHubDirectMethods.GetValueOrDefault(methodName);
var methodResponse = DefaultMethodHandlerAsync(new MethodRequest(methodName, Encoding.UTF8.GetBytes(methodRequest)), null).Result;
outputArguments[0] = methodResponse.ResultAsJson;
return(ServiceResult.Create(StatusCodes.BadNotImplemented, "The IoTHub direct method is not implemented"));
}
}
catch (Exception ex)
{
Logger.Error($"{logPrefix} The request is invalid!");
return(ServiceResult.Create(ex, null, StatusCodes.Bad));
}
return(ServiceResult.Good);
}
private async Task <(bool, ServiceResult <object>)> OnAuthorization(ServiceRoute route, Dictionary <string, object> model)
{
var isSuccess = true;
var serviceResult = ServiceResult <object> .Create(false, null);
var result = (isSuccess, serviceResult);
if (route.ServiceDescriptor.EnableAuthorization())
{
if (route.ServiceDescriptor.AuthType() == AuthorizationType.JWT.ToString())
{
result = await ValidateJwtAuthentication(route, model);
}
else
{
isSuccess = ValidateAppSecretAuthentication(route, model, ref serviceResult);
result = (isSuccess, serviceResult);
}
}
return(result);
}
/// <summary cref="IReplyChannel.EndTryReceiveRequest" />
public bool EndTryReceiveRequest(IAsyncResult result, out System.ServiceModel.Channels.RequestContext context)
{
context = null;
TcpAsyncOperation <RequestContext> operation = (TcpAsyncOperation <RequestContext>)result;
try
{
context = operation.End(Int32.MaxValue);
return(true);
}
catch (TimeoutException)
{
return(false);
}
catch (Exception e)
{
m_fault = ServiceResult.Create(e, StatusCodes.BadInternalError, "Could not receive request from a UA TCP channel.");
Utils.Trace(m_fault.ToLongString());
return(false);
}
}
public async Task <ServiceResult <object> > Path(string path, [FromQuery] string serviceKey, [FromBody] Dictionary <string, object> model)
{
ServiceResult <object> result = ServiceResult <object> .Create(false, null);
if (OnAuthorization(path, model, ref result))
{
if (!string.IsNullOrEmpty(serviceKey))
{
result = ServiceResult <object> .Create(true, await _serviceProxyProvider.Invoke <object>(model, path, serviceKey));
result.StatusCode = (int)ServiceStatusCode.Success;
}
else
{
result = ServiceResult <object> .Create(true, await _serviceProxyProvider.Invoke <object>(model, path));
result.StatusCode = (int)ServiceStatusCode.Success;
}
}
return(result);
}
/// <summary>
/// Write a single message.
/// </summary>
private void WriteMessage(WriteOperation operation)
{
// get the buffers to write.
BufferCollection buffers = operation.ChunksToSend;
// get the socket.
Socket socket = null;
lock (m_socketLock)
{
socket = m_socket;
}
// check if the socket has been closed.
if (socket == null)
{
operation.Fault(ServiceResult.Create(StatusCodes.BadConnectionClosed, "Socket is no longer available."));
return;
}
// begin the write operation (blocks until data is copied into the transport buffer).
try
{
int bytesSent = socket.Send(buffers, SocketFlags.None);
// check that all the data was sent.
if (bytesSent < buffers.TotalSize)
{
operation.Fault(ServiceResult.Create(StatusCodes.BadConnectionClosed, "Write operation could not complete."));
return;
}
// everything ok - yeah!.
operation.Complete(bytesSent);
}
catch (Exception e)
{
operation.Fault(ServiceResult.Create(e, StatusCodes.BadConnectionClosed, "Write to socket failed."));
}
}
/// <summary>
/// Handles a write complete event.
/// </summary>
protected virtual void OnWriteComplete(object sender, SocketAsyncEventArgs e)
{
lock (DataLock)
{
ServiceResult error = ServiceResult.Good;
try
{
if (e.BytesTransferred == 0)
{
error = ServiceResult.Create(StatusCodes.BadConnectionClosed, "The socket was closed by the remote application.");
}
HandleWriteComplete(e.UserToken, e.BytesTransferred, error);
}
catch (Exception ex)
{
error = ServiceResult.Create(ex, StatusCodes.BadTcpInternalError, "Unexpected error during write operation.");
HandleWriteComplete(e.UserToken, e.BytesTransferred, error);
}
}
}
/// <summary>
/// Get an external order
/// </summary>
/// <param name="orderId"></param>
/// <param name="supplier"></param>
/// <returns></returns>
public async Task <IServiceResult <ExternalOrderResponse> > GetExternalOrderAsync(string orderId, string supplier)
{
switch (supplier.ToLower())
{
case "digikey":
if (!_digikeyApi.IsConfigured)
{
throw new InvalidOperationException($"DigiKey Api is not configured!");
}
return(await GetExternalDigikeyOrderAsync(orderId));
case "mouser":
if (!_mouserApi.IsConfigured)
{
throw new InvalidOperationException($"Mouser Api is not configured!");
}
return(ServiceResult <ExternalOrderResponse> .Create(new ExternalOrderResponse()));
default:
throw new InvalidOperationException($"Unknown supplier {supplier}");
}
}
public ServiceResult Update(BookInfo book)
{
var query = _db.Books.FirstOrDefaultAsync(q => q.Id == book.Id);
if (query.IsCompleted && query.Result == null)
{
return(ServiceResult.Error("数据不存在"));
}
else
{
query.Result.AminId = book.AminId;
query.Result.Author = book.Author;
query.Result.CoverImage = book.CoverImage;
query.Result.CreateDT = book.CreateDT;
query.Result.Name = book.Name;
query.Result.Price = book.Price;
query.Result.Publish = book.Publish;
query.Result.RealPrice = book.RealPrice;
query.Result.SubName = book.SubName;
_db.SaveChanges();
return(ServiceResult.Create(true, "操作成功"));
}
}
/// <summary>
/// Reads an error from a stream.
/// </summary>
protected static ServiceResult ReadErrorMessageBody(BinaryDecoder decoder)
{
// read the status code.
uint statusCode = decoder.ReadUInt32(null);
string reason = null;
// ensure the reason does not exceed the limits in the protocol.
int reasonLength = decoder.ReadInt32(null);
if (reasonLength > 0 && reasonLength < TcpMessageLimits.MaxErrorReasonLength)
{
byte[] reasonBytes = new byte[reasonLength];
for (int ii = 0; ii < reasonLength; ii++)
{
reasonBytes[ii] = decoder.ReadByte(null);
}
reason = new UTF8Encoding().GetString(reasonBytes, 0, reasonLength);
}
return(ServiceResult.Create(statusCode, "Error received from remote host: {0}", reason));
}
/// <summary>
/// Called when an asynchronous operation completes.
/// </summary>
public bool Fault(bool doNotBlock, Exception e, uint defaultCode, string format, params object[] args)
{
return(InternalComplete(doNotBlock, ServiceResult.Create(e, defaultCode, format, args)));
}
/// <summary>
/// Called when an asynchronous operation completes.
/// </summary>
public bool Fault(bool doNotBlock, uint code, string format, params object[] args)
{
return(InternalComplete(doNotBlock, ServiceResult.Create(code, format, args)));
}
