public void MOL1_Cover_Archiviazione_Storica_3_Anni()
{
var guid = System.Guid.NewGuid();
string xmlBase = Envelopes.PostaEvoPil.Replace("%GUID%", string.Concat("", guid.ToString(), ""));
var postaEvoRequest = SerializationUtility.Deserialize <PostaEvoSubmit>(xmlBase);;
postaEvoRequest.AutoConferma = false;
postaEvoRequest.Opzioni.OpzioniServizio.ModalitaPricing = "ZONA";
postaEvoRequest.Opzioni.OpzioniServizio.AttestazioneConsegna = true;
postaEvoRequest.Opzioni.OpzioniServizio.SecondoTentativoRecapito = true;
PostaEvoResponse postaEvoResponse;
postaEvoRequest.Documenti[0].URI = ambiente.PathDocument;
postaEvoRequest.Documenti[0].HashMD5 = ambiente.HashMD5Document;
postaEvoRequest.Documenti[1].URI = ambiente.PathCov;
postaEvoRequest.Documenti[1].HashMD5 = ambiente.HashMD5Cov;
postaEvoRequest.Opzioni.OpzioniServizio.ArchiviazioneDocumenti = "STORICA";
postaEvoRequest.Opzioni.OpzioniServizio.AnniArchiviazione = 3;
postaEvoRequest.Opzioni.OpzioniServizio.AnniArchiviazioneSpecified = true;
var result = Helper.PublishToBizTalk <PostaEvoSubmit, PostaEvoResponse>(postaEvoRequest, ambiente.UrlEntryPoint, out postaEvoResponse);
Assert.AreEqual(TResultResType.I, result.ResType);
Debug.WriteLine(postaEvoResponse.IdRichiesta);
string idRichiesta = postaEvoResponse.IdRichiesta;
Assert.IsTrue(CheckStatusPostaEvo(idRichiesta, "K", TimeSpan.FromMinutes(2), TimeSpan.FromSeconds(10)));
}
public override NpceOperationResult Conferma()
{
CE ce = GetCE();
ConfirmService confirm = new ConfirmService
{
IdRichiesta = _servizio.IdRichiesta
};
ConfirmServiceResponse confirmResult = null;
ce.Body = SerializationUtility.SerializeToXmlElement(confirm);
using (WsCEClient client = new WsCEClient())
{
client.Endpoint.Address = new System.ServiceModel.EndpointAddress(_ambiente.LolUri);
client.SubmitRequest(ref ce);
try
{
confirmResult = SerializationUtility.Deserialize <ConfirmServiceResponse>(ce.Body);
}
catch (Exception ex)
{
throw (ex);
}
}
return(CreateResult(NpceOperation.Invio, ce.Result.ResType == TResultResType.I ? "0" : "99", ce.Result.Description?.Substring(0, Math.Min(ce.Result.Description.Length, 500)) ?? "Invio Ok", string.Empty, null, null));
}
public void SerializeDeserializeTest()
{
Serializable serializeTest = new Serializable()
{
int1 = 5,
int2 = 7,
array = new int[]
{
1,
2,
3,
4,
5
},
short1 = -3,
short2 = 30000,
str = "This string is for testing purposes"
};
byte[] serialized = SerializationUtility.Serialize(serializeTest);
Serializable deserialized = SerializationUtility.Deserialize <Serializable>(serialized);
Assert.IsTrue(serializeTest.int1 == deserialized.int1);
Assert.IsTrue(serializeTest.int2 == deserialized.int2);
for (int i = 0; i < 5; i++)
{
Assert.IsTrue(serializeTest.array[i] == deserialized.array[i]);
}
Assert.IsTrue(serializeTest.short1 == deserialized.short1);
Assert.IsTrue(serializeTest.short2 == deserialized.short2);
Assert.IsNull(deserialized.str, "Field 'str' is marked as non-serializable and must be ignored");
}
protected T _execute <T>(bool keepAlive, bool isAsync = false, bool moreOutput = false, bool allowCaching = false) where T : QueryResult
{
if (string.IsNullOrEmpty(Query))
{
return(null);
}
this.IsAsync = isAsync;
this.MoreOutput = moreOutput;
this.AllowCaching = allowCaching;
if (string.IsNullOrEmpty(this.ApiKey))
{
throw new NullReferenceException("API key has not been specified");
}
var request = (HttpWebRequest)WebRequest.Create(string.Format("{0}{1}", MainURL, this.Parameters));
request.KeepAlive = keepAlive;
using (var streamReader = new StreamReader(request.GetResponse().GetResponseStream()))
{
var xdoc = XDocument.Parse(streamReader.ReadToEnd());
var obj = SerializationUtility.Deserialize <T>(xdoc);
obj.DefaultResult = xdoc;
return(obj);
}
}
static void Main()
{
SerializationTest serializationTest = new SerializationTest();
serializationTest.reference = new SerializationTest()
{
yes = -300
};
byte[] bytes = SerializationUtility.Serialize(serializationTest);
if (System.IO.File.Exists("../../Content/test"))
{
System.IO.File.Delete("../../Content/test");
}
System.IO.File.WriteAllBytes("../../Content/test", bytes);
SerializationTest deserialized = SerializationUtility.Deserialize <SerializationTest>(bytes);
Console.WriteLine(deserialized);
TestGame test = new TestGame();
test.Resolution = new Vector2(1280 * 0.75f, 720 * 0.75f);
test.Run();
}
public override NPCEResult Invia()
{
LetteraSubmit letteraBE = SetLetteraSubmit();
letteraBE.IdRichiesta = IdRichiesta;
LetteraResponse letteraResult = null;
CE.Body = SerializationUtility.SerializeToXmlElement(letteraBE);
try
{
var ce = CE;;
WsCEClient.SubmitRequest(ref ce);
try
{
letteraResult = SerializationUtility.Deserialize <LetteraResponse>(ce.Body);
return(letteraResult.CreateResult(ce));
}
catch (Exception ex)
{
throw (ex);
}
}
finally
{
WsCEClient.InnerChannel.Close();
}
}
public async override Task <NPCEResult> InviaAsync()
{
LetteraSubmit letteraBE = SetLetteraSubmit();
letteraBE.IdRichiesta = IdRichiesta;
LetteraResponse letteraResult = null;
CE.Header.GUIDMessage = IdRichiesta;
CE.Body = SerializationUtility.SerializeToXmlElement(letteraBE);
try
{
SubmitRequestRequest request = new SubmitRequestRequest(CE);
var response = await WsCEClient.SubmitRequestAsync(request);
try
{
letteraResult = SerializationUtility.Deserialize <LetteraResponse>(response.CE.Body);
return(letteraResult.CreateResult(response.CE));
}
catch (Exception ex)
{
throw (ex);
}
}
finally
{
WsCEClient.InnerChannel.Close();
}
}
public override NpceOperationResult Invio()
{
CE ce = GetCE();
RaccomandataSubmit RaccomandataBE = SetRaccomandataBE();
RaccomandataBE.IdRichiesta = _idRichiesta;
RaccomandataResponse RaccomandataResult = null;
ce.Body = SerializationUtility.SerializeToXmlElement(RaccomandataBE);
using (WsCEClient client = new WsCEClient())
{
client.Endpoint.Address = new System.ServiceModel.EndpointAddress(_ambiente.RolUri);
client.SubmitRequest(ref ce);
try
{
RaccomandataResult = SerializationUtility.Deserialize <RaccomandataResponse>(ce.Body);
}
catch (Exception ex)
{
throw (ex);
}
}
return(CreateResult(NpceOperation.Invio, ce.Result.ResType == TResultResType.I ? "0" : "99", ce.Result.Description?.Substring(0, Math.Min(ce.Result.Description.Length, 500)) ?? "Invio Ok", RaccomandataResult.IdRichiesta, null, null));
}
public void MOL1_No_Cover()
{
var guid = System.Guid.NewGuid();
string xmlBase = Envelopes.PostaEvoPil.Replace("%GUID%", string.Concat("", guid.ToString(), ""));
var postaEvoRequest = SerializationUtility.Deserialize <PostaEvoSubmit>(xmlBase);;
postaEvoRequest.AutoConferma = false;
postaEvoRequest.Opzioni.OpzioniServizio.ModalitaPricing = "ZONA";
postaEvoRequest.Opzioni.OpzioniServizio.AttestazioneConsegna = true;
postaEvoRequest.Opzioni.OpzioniServizio.SecondoTentativoRecapito = true;
PostaEvoResponse postaEvoResponse;
postaEvoRequest.Documenti[0].URI = ambiente.PathDocument;
postaEvoRequest.Documenti[0].HashMD5 = ambiente.HashMD5Document;
postaEvoRequest.Documenti[1] = null;
var result = Helper.PublishToBizTalk <PostaEvoSubmit, PostaEvoResponse>(postaEvoRequest, ambiente.UrlEntryPoint, out postaEvoResponse);
Assert.AreEqual(TResultResType.I, result.ResType);
Debug.WriteLine(postaEvoResponse.IdRichiesta);
}
/// <summary>
/// Called by the generated proxy class to send the request to the remote object and get the response back.
/// </summary>
/// <param name="interfaceId">Id of the remote interface.</param>
/// <param name="methodId">Id of the remote method to be invokved.</param>
/// <param name="requestMsgBodyValue">Request body.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>A task that represents the asynchronous operation async call to remote object.</returns>
protected async Task <object> InvokeAsync(
int interfaceId,
int methodId,
object requestMsgBodyValue,
CancellationToken cancellationToken)
{
object requestMsgBody = null;
if (requestMsgBodyValue != null)
{
requestMsgBody = this.CreateRequestMessageBody(requestMsgBodyValue);
}
var requestMsgBodyBytes = SerializationUtility.Serialize(
this.GetRequestMessageBodySerializer(interfaceId),
requestMsgBody);
var responseMsgBodyBytes = await this.InvokeAsync(
interfaceId,
methodId,
requestMsgBodyBytes,
cancellationToken);
var responseMsgBody = SerializationUtility.Deserialize(
this.GetResponseMessageBodySerializer(interfaceId),
responseMsgBodyBytes);
return(responseMsgBody != null?this.GetResponseMessageBodyValue(responseMsgBody) : null);
}
public static TResult PublishToBizTalk <T, V>(T request, CEHeader ceHeader, string entryPointuri, out V response) where V : class
{
CE ce = new CE();
ce.Header = ceHeader;
ce.Body = SerializationUtility.SerializeToXmlElement(request);
BasicHttpBinding httpBinding = new BasicHttpBinding();
httpBinding.MaxReceivedMessageSize = 2147483647;
httpBinding.SendTimeout = TimeSpan.FromMinutes(20);
EndpointAddress endpointAddress = new EndpointAddress(entryPointuri);
var client = new WsCEClient(httpBinding, endpointAddress);
string guidMessage = ceHeader.GUIDMessage;
if (ce.Body.OuterXml.StartsWith("<OrderRequest"))
{
OrderRequest orderRequest = SerializationUtility.Deserialize <OrderRequest>(ce.Body);
guidMessage = orderRequest.ServiceInstance[0].GUIDMessage;
}
if (ce.Body.GetElementsByTagName("IdRichiesta").Count > 0)
{
guidMessage = ce.Body.GetElementsByTagName("IdRichiesta")[0].InnerText;
}
if (string.IsNullOrEmpty(guidMessage))
{
guidMessage = ce.Body.GetAttribute("IdRichiesta");
}
if (ce.Body.GetElementsByTagName("GUIDMessage").Count > 0)
{
guidMessage = ce.Body.GetElementsByTagName("IdRichiesta")[0].InnerText;
}
guidMessage = ce.Header.GUIDMessage;
if (string.IsNullOrEmpty(guidMessage))
{
throw new ArgumentException("IdRichiesta not found in request to submit");
}
ce.Header.GUIDMessage = guidMessage;
try
{
client.SubmitRequest(ref ce);
response = SerializationUtility.Deserialize <V>(ce.Body);
}
catch (Exception ex)
{
throw;
}
return(ce.Result);
}
public NpceOperationResult PreConferma(string idRichiesta, bool autoconfirm)
{
OrderRequest orderRequest = new PosteItaliane.OrderManagement.Schema.SchemaDefinition.OrderRequest();
OrderResponse orderResponse = null;
var ce = new CE();
ce.Header = new CEHeader();
ce.Header.GUIDMessage = Guid.NewGuid().ToString();
ce.Header = new CEHeader
{
BillingCenter = _ambiente.billingcenter,
CodiceFiscale = _ambiente.codicefiscale,
ContractId = _ambiente.contractid,
ContractType = _ambiente.contracttype,
CostCenter = _ambiente.costcenter,
Customer = _ambiente.customer,
IdCRM = string.Empty,
SenderSystem = _ambiente.sendersystem,
UserId = _ambiente.smuser,
PartitaIva = _ambiente.partitaiva,
IDSender = string.Empty,
UserType = _ambiente.usertype
};
ce.Header.GUIDMessage = idRichiesta;
orderRequest.ServiceInstance = new OrderRequestServiceInstance[1];
orderRequest.ForceOrderCreation = true;
orderRequest.ServiceInstance[0] = new OrderRequestServiceInstance();
orderRequest.ServiceInstance[0].GUIDMessage = idRichiesta;
ce.Body = SerializationUtility.SerializeToXmlElement(orderRequest);
using (WsCEClient client = new WsCEClient())
{
client.Endpoint.Address = new System.ServiceModel.EndpointAddress(_ambiente.LolUri);
client.SubmitRequest(ref ce);
try
{
orderResponse = SerializationUtility.Deserialize <OrderResponse>(ce.Body);
}
catch (Exception ex)
{
throw (ex);
}
var idOrdine = orderResponse.IdOrder;
if (autoconfirm)
{
ce = Conferma(orderResponse, ce, client);
}
}
return(CreateResult(NpceOperation.PreConfermaWithAutoconfirm, ce.Result.ResType == TResultResType.I ? "0" : "99", ce.Result.Description?.Substring(0, Math.Min(ce.Result.Description.Length, 500)) ?? "Invio Ok", orderResponse.IdOrder, null, null));
}
public override T Load()
{
if (File.Exists(FileName))
{
throw new FileNotFoundException(FileName);
}
return(SerializationUtility.Deserialize <T>(FileName));
}
public GetMessageResult TryGetMessage(CloudQueue queue, out MessageEnvelope envelope)
{
CloudQueueMessage message = null;
envelope = null;
try
{
message = queue.GetMessage(new TimeSpan(0, 2, 0)); // 2 min timeout
}
catch (Exception ex)
{
this.Observer.Notify(new FailedToReadMessage(ex, queue.Name));
return(GetMessageResult.Exception);
}
if (message == null)
{
return(GetMessageResult.Empty);
}
if (message.DequeueCount > RetryCount)
{
this.Observer.Notify(new RetrievedPoisonMessage(queue.Name, message.Id));
return(GetMessageResult.Retry);
}
try
{
envelope = SerializationUtility.Deserialize <MessageEnvelope>(this.Serializer, message.AsBytes);
//try download from blob
if (!envelope.MessageReference.IsLoaded)
{
if (envelope.MessageReference.StorageContainer != this.CloudBlob.Uri.ToString())
{
throw new InvalidOperationException("Wrong container used!");
}
var blob = this.CloudBlob.GetBlobReferenceFromServer(envelope.MessageReference.StorageReference);
var messageType = Type.GetType(envelope.MessageReference.MessageTypeName);
var stream = new MemoryStream();
blob.DownloadToStream(stream);
envelope.MessageReference.Message = SerializationUtility.Deserialize(messageType, this.Serializer, stream.ToArray()) as IMessage;
}
envelope.TransportMessage = message;
}
catch (StorageException ex)
{
this.Observer.Notify(new FailedToAccessStorage(ex, queue.Name, message.Id));
return(GetMessageResult.Retry);
}
catch (Exception ex)
{
this.Observer.Notify(new FailedToDeserializeMessage(ex, queue.Name, message.Id));
return(GetMessageResult.Exception);
}
return(GetMessageResult.Success);
}
public void TestSerializeable(string wkt)
{
var reader = new WKTReader(new GeometryFactory());
var gS = (Geometry)reader.Read(wkt);
var buffer = SerializationUtility.Serialize(gS);
var gD = SerializationUtility.Deserialize <Geometry>(buffer);
Assert.IsTrue(gD.EqualsExact(gS));
}
private static Signer ObtainSigner(byte[] keeperKeyBytes)
{
var keeperKey = (KeeperKey)SerializationUtility.Deserialize(keeperKeyBytes);
var signer = new Signer();
signer.Initialize(keeperKey);
return(signer);
}
public void testSerializable()
{
var coords = CreateArray(Size);
var seq = CsFactory.Create(coords);
// throws exception if not serializable
byte[] data = SerializationUtility.Serialize(seq);
// check round-trip gives same data
var seq2 = SerializationUtility.Deserialize <CoordinateSequence>(data);
Assert.IsTrue(IsEqual(seq2, coords));
}
public override FactimeSettings Load()
{
if (!File.Exists(GetFileName()))
{
base.Save(new FactimeSettings
{
DefaultStart = new TimeSpan(9, 0, 0),
DefaultEnd = new TimeSpan(18, 0, 0),
DefaultPreHolidaysCollection = new List <DateTime>(),
DefaultHolidaysCollection = new List <DateTime>()
});
}
return(SerializationUtility.Deserialize <FactimeSettings>(GetFileName()));
}
private static bool TryDeserializeExceptionData(byte[] data, out ServiceExceptionData result)
{
try
{
var exceptionData = (ServiceExceptionData)SerializationUtility.Deserialize(serializer, data);
result = exceptionData;
return(true);
}
catch (Exception)
{
// no-op
}
result = null;
return(false);
}
private static bool TryDeserializeExceptionData(byte[] data, out ServiceExceptionData result)
{
try
{
var exceptionData = (ServiceExceptionData)SerializationUtility.Deserialize(serializer, data);
result = exceptionData;
return(true);
}
catch (Exception e)
{
//swallowing the exception
ServiceTrace.Source.WriteWarning("RemoteExceptionInformation", " ServiceExceptionData DeSerialization failed : Reason {0}", e);
}
result = null;
return(false);
}
public override ModuleSettings Load()
{
if (!File.Exists(FileName))
{
base.Save(new ModuleSettings
{
IP = "localhost",
Port = "8080",
Id = "id123",
PrinterName = "Zebra",
PathToTemplate = "ZebraTemplate.xml",
PathToZpl = "ZebraTemplate.zpl",
IsCheckPrinterQueue = true,
PrinterBusyMessage = "Необходимо выключить и включить принтер!"
});
}
return(SerializationUtility.Deserialize <ModuleSettings>(FileName));
}
public void TestSerialization()
{
var tester = new SpatialIndexTester { SpatialIndex = new STRtree(4) };
tester.Init();
Console.WriteLine("\n\nTest with original data\n");
tester.Run();
var tree1 = (STRtree)tester.SpatialIndex;
// create the index before serialization
tree1.Query(new Envelope());
var data = SerializationUtility.Serialize(tree1);
var tree2 = SerializationUtility.Deserialize<STRtree>(data);
tester.SpatialIndex = tree2;
Console.WriteLine("\n\nTest with deserialized data\n");
tester.Run();
tester.Run();
Assert.IsTrue(tester.IsSuccess);
}
private async Task <byte[]> HandleSubscriptionRequestsAsync(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
//This can only happen if there is issue in our product code like Message Corruption or changing headers format.
ReleaseAssert.Failfast("ActorMessageHeaders Deserialization failed");
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.SubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallbackClient()));
return(null);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.UnsubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId));
}
public TResult PublishToBizTalk <T, V>(T request, out V response) where V : class
{
CE ce = new CE();
ce.Header = Helper.GetCeHeader();
ce.Body = ComunicazioniElettroniche.Common.Serialization.SerializationUtility.SerializeToXmlElement(request);
BasicHttpBinding httpBinding = new BasicHttpBinding();
httpBinding.MaxReceivedMessageSize = 64000000;
httpBinding.SendTimeout = TimeSpan.FromMinutes(20);
EndpointAddress endpointAddress = new EndpointAddress(_config.UrlEntryPoint);
var client = new WsCEClient(httpBinding, endpointAddress);
string guidMessage = string.Empty;
if (ce.Body.GetElementsByTagName("IdRichiesta").Count > 0)
{
guidMessage = ce.Body.GetElementsByTagName("IdRichiesta")[0].InnerText;
}
if (string.IsNullOrEmpty(guidMessage))
{
guidMessage = ce.Body.GetAttribute("IdRichiesta");
}
if (string.IsNullOrEmpty(guidMessage))
{
throw new ArgumentException("IdRichiesta not found in request to submit");
}
ce.Header.GUIDMessage = guidMessage;
try
{
client.SubmitRequest(ref ce);
response = SerializationUtility.Deserialize <V>(ce.Body);
}
catch (Exception ex)
{
throw;
}
return(ce.Result);
}
private async Task <byte[]> HandleSubscriptionRequests(
IServiceRemotingRequestContext requestContext,
ServiceRemotingMessageHeaders messageHeaders,
byte[] requestMsgBodyBytes)
{
ActorMessageHeaders actorMessageHeaders;
if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders))
{
throw new SerializationException(Actors.SR.ErrorActorMessageHeadersDeserializationFailed);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.SubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
new ActorEventSubscriberProxy(
castedRequestMsgBody.subscriptionId,
requestContext.GetCallbackClient()));
return(null);
}
if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId)
{
var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes);
var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value;
await this.actorService.ActorManager.UnsubscribeAsync(
actorMessageHeaders.ActorId,
castedRequestMsgBody.eventInterfaceId,
castedRequestMsgBody.subscriptionId);
return(null);
}
throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId));
}
public void TestSerialization()
{
var tester = new SpatialIndexTester {
SpatialIndex = new Quadtree <object>()
};
tester.Init();
Console.WriteLine("\n\nTest with original data\n");
tester.Run();
var tree1 = (Quadtree <object>)tester.SpatialIndex;
var data = SerializationUtility.Serialize(tree1);
var tree2 = SerializationUtility.Deserialize <Quadtree <object> >(data);
tester.SpatialIndex = tree2;
Console.WriteLine("\n\nTest with deserialized data\n");
tester.Run();
Assert.IsTrue(tester.IsSuccess);
}
/// <summary>
/// Updates the repair task for current node
/// </summary>
/// <param name="fc">Fabric client object used for carrying out service fabric client requests</param>
/// <param name="task">Repair task which needs to be updated</param>
/// <param name="taskState">State of the repair task <see cref="RepairTaskState"/></param>
/// <param name="taskResultStatus">Result status for last completed operation by RE</param>
/// <param name="resultDetails">Result details for last completed operation by RE</param>
/// <param name="executorState">Substate of repair executor</param>
/// <param name="timeout">Timeout for the async operation</param>
/// <param name="cancellationToken">The cancellation token to cancel the async operation</param>
/// <returns>A Task representing the asnyc operation</returns>
private static async Task UpdateRepairTask(FabricClient fc, RepairTask task, RepairTaskState taskState,
RepairTaskResult taskResultStatus, string resultDetails, NodeAgentSfUtilityExitCodes executorState, TimeSpan timeout,
CancellationToken cancellationToken, DateTime?restartRequesteDateTime)
{
// Do the actual work before mark the task as Executing.
task.State = taskState;
task.ResultStatus = taskResultStatus;
task.ResultDetails = resultDetails;
ExecutorDataForRmTask executorData =
SerializationUtility.Deserialize <ExecutorDataForRmTask>(task.ExecutorData);
executorData.ExecutorSubState = executorState;
if (restartRequesteDateTime.HasValue)
{
executorData.RestartRequestedTime = restartRequesteDateTime.Value;
}
task.ExecutorData = SerializationUtility.Serialize(executorData);
await fc.RepairManager.UpdateRepairExecutionStateAsync(task, timeout, cancellationToken);
}
public void TestSerializable()
{
var fact = new GeometryFactory();
var gsf = new NetTopologySuite.Utilities.GeometricShapeFactory(fact);
gsf.Size = 250;
var g = (Geometry)gsf.CreateCircle();
// serialize the object
byte[] bytes = null;
Assert.DoesNotThrow(() => bytes = SerializationUtility.Serialize(g));
// Assert that there was some serialized content produced
Assert.IsNotNull(bytes, "There was no serialized packet produced");
Assert.IsTrue(bytes.Length > 0, "There was no data in the serialized packet produced");
// deserialize and check
var gCopy = SerializationUtility.Deserialize <Geometry>(bytes);
Assert.IsTrue(gCopy.EqualsExact(g), "The deserialized object does not match the original");
}
public NpceOperationResult Execute()
{
var ce = new ComunicazioniElettroniche.Common.DataContracts.CE();
ce.Header = GetHeaders(_ambiente);
ce.Header.GUIDMessage = Guid.NewGuid().ToString();
ConfermaRequest confermaRequest = new ConfermaRequest
{
IdOrdine = _visura.IdOrdine,
PaymentDate = System.DateTime.Now,
PaymentDateSpecified = true,
PaymentType = new PaymentType {
PostPayment = true, PostPaymentSpecified = true, TypeId = "6"
}
};
SetUserInfo(confermaRequest);
ce.Body = SerializationUtility.SerializeToXmlElement(confermaRequest);
ConfermaResponse confermaResponse = null;
using (WsCEClient client = new WsCEClient())
{
client.Endpoint.Address = new System.ServiceModel.EndpointAddress(_ambiente.VolUri);
client.SubmitRequest(ref ce);
try
{
confermaResponse = SerializationUtility.Deserialize <ConfermaResponse>(ce.Body);
}
catch (Exception ex)
{
throw (ex);
}
}
return(CreateResult(NpceOperation.Conferma, confermaResponse.Result.ResType == TResultResType.I ? "0" : "99", "Invio Ok", confermaResponse.IdOrdine, null, null));
}
//public LOLPil(NPCE_Client.Model.Servizio servizio, Ambiente ambiente, string idRichiesta) : base(servizio, ambiente, idRichiesta)
//{
//}
public override async Task <NPCEResult> ConfermaAsync(string idRichiesta)
{
OrderResponse preConfirmResult;
string idOrdine;
try
{
OrderRequest preconfirmRequest = GetPreConfirmRequest(idRichiesta);
CE.Header.GUIDMessage = IdRichiesta;
CE.Body = SerializationUtility.SerializeToXmlElement(preconfirmRequest);
SubmitRequestRequest request = new SubmitRequestRequest(CE);
var response = await WsCEClient.SubmitRequestAsync(request);
preConfirmResult = SerializationUtility.Deserialize <OrderResponse>(response.CE.Body);
idOrdine = preConfirmResult.IdOrder;
ConfirmOrder confirmRequest = GetConfirmRequest(idOrdine, preConfirmResult.PaymentTypes[0].TypeDescription);
CE.Header.GUIDMessage = IdRichiesta;
CE.Body = SerializationUtility.SerializeToXmlElement(confirmRequest);
request = new SubmitRequestRequest(CE);
response = await WsCEClient.SubmitRequestAsync(request);
return(new NPCEResult {
Code = "I", Description = "Conferma avvenuta correttamente", IdOrdine = idOrdine, IdRichiesta = idRichiesta
});
}
finally
{
WsCEClient.InnerChannel.Close();
}
}
