private static void AcknowledgeMessage(IModel currentChannel, Acknowledgment acknowledgment, ulong tag)
{
// Threading notes:
// According to the RabbitMQ Client PDF documentation for .NET, a single channel is not thread safe and access to it
// must be serialized, but this typically manifest during RPC operations such as declaring a queue or
// for *committing* a transaction or publishing a message large message. For non-blocking operations (such as ack/reject)
// it performs it's own synchronization. In fact, a review of the client source code reveals a library absolutely
// filled with lock() statements to perform it's own serialization of operations. I ran several intensive tests to assert the
// behavior below. I created a console app that ran a single receiving and multiple publishing threads. I was
// able to run millions of messages through without any threading issues whatsoever. It was only by introducing
// channel.TxSelect() (along with channel.TxCommit) that I started to receive the "Pipelining of requests forbidden" message.
// In this console app, the published messages on the sending threads were tiny and only occupied a single RabbitMQ TCP frame which
// is almost certainly the reason for not having pipelining issues. Similarly, the ack/reject instructions occupy
// a single TCP frame and are "non-blocking" operations according to RabbitMQ's definition of blocking. This means
// that even though a transaction commit is only a single frame, it's a blocking operation which causes an exception to be thrown
// because multiple threads are trying to commit the transaction and it's getting multiple send operations before receiving
// confirmation of the committed transaction. In other words, the code below is entirely thread safe SO LONG AS this channel
// remains a non-transactional channel. I also asserted that confirming multiple messages while individually rejecting individual
// messages here and there worked as expected.
if (Acknowledgment.ConfirmBatch == acknowledgment)
{
currentChannel.BasicAck(tag, AcknowledgeMultiple);
}
else if (Acknowledgment.RejectSingle == acknowledgment)
{
currentChannel.BasicReject(tag, MarkAsDeadLetter);
}
else
{
currentChannel.BasicAck(tag, AcknowledgeSingle);
}
}
public void AddAcknowledgment(Response response, Acknowledgment acknowledgment)
{
foreach (IResponseModifier modifier in _modifiers)
{
modifier.AddAcknowledgment(response, acknowledgment);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ctxMenuAcknowledgmentClear_Click(object sender, EventArgs e)
{
if (listEvents.SelectedObjects.Count == 0)
{
return;
}
var list = listEvents.SelectedObjects.Cast <Event>().ToList();
(new Thread(() =>
{
SetProcessingStatus(false);
using (new HourGlass(this))
using (NPoco.Database db = new NPoco.Database(Db.GetOpenMySqlConnection()))
{
foreach (Event temp in list)
{
if (temp.AcknowledgmentId == 0)
{
continue;
}
Acknowledgment acknowledgment = new Acknowledgment();
acknowledgment.Id = temp.AcknowledgmentId;
var ack = db.SingleById <Acknowledgment>(acknowledgment.Id);
db.Delete(ack);
}
}
SetProcessingStatus(true);
LoadSearch(_currentPage);
})).Start();
}
/// <summary>
/// Parses the specified ack file into an acknowledgment object if possible.
/// </summary>
/// <param name="ackFileName">
/// The ack File Name to parse into an acknowledgment object.
/// </param>
/// <param name="stream">
/// File contents as stream of data
/// </param>
/// <returns>
/// * The Acknowledgment object resulting from the parsing attempt if the specified acknowledgment file could be found.
/// * Otherwise returns null.
/// </returns>
internal Acknowledgment Parse(string ackFileName, Stream stream)
{
Acknowledgment = new Acknowledgment();
if (stream != null)
{
FileName = Path.GetFileName(ackFileName);
DetailAcknowledgmentParser.FileName = FileName;
string recordType;
using (StreamReader streamReader = new StreamReader(stream))
{
while ((Line = streamReader.ReadLine()) != null)
{
if (Line.Length > AcknowledgmentConstants.RecordTypeLength)
{
LineNumber++;
recordType = Line.Substring(0, AcknowledgmentConstants.RecordTypeLength);
switch (recordType)
{
case DetailAcknowledgmentParser.RecordType:
ParseDetailAcknowledgmentRecord();
break;
case GeneralAcknowledgmentParser.RecordType:
ParseGeneralAcknowledgmentRecord();
break;
}
}
else
{
Log.Warning("Error parsing record in line #{0} from file \"{1}\". Unexpected end of record detected.",
(int)ResultCode.UnexpectedEndOfRecord, LineNumber, FileName);
}
}
}
// Add entries to the log if the acknowledgment file did not have the expected number of records of each type.
if (Acknowledgment.DetailAcknowledgments.Count == 0)
{
Log.Information("Acknowledgment file \"{0}\" contained no Detail Acknowledgments Records.", ackFileName);
}
if (Acknowledgment.GeneralAcknowledgments.Count != 1)
{
Log.Warning("Acknowledgment file \"{0}\" should have exactly 1 General Acknowledgments Record.",
(int)ResultCode.FileMissingExpectedRecord,
ackFileName);
}
}
else
{
Log.Error("Acknowledgment file \"{0}\" could not be found.", null, (int)ResultCode.FileNotFound, ackFileName);
Acknowledgment = null;
}
return(Acknowledgment);
}
protected override async Task HandleDocument(string companyId, TradingChannel.TradingChannel channel, TradingPartner.TradingPartner partner, TS997 ts997, TradingPartnerMessage.TradingPartnerMessage message)
{
var data = new Acknowledgment(ts997);
//data
// var shipments = Db.Get<Shipment.Shipment>(companyId);
// var shipment = await shipments.FirstOrDefaultAsync(p =>
// p.TradingPartnerId == partner.Id &&
// p.ShipmentIdentificationNumber == data.);
}
public Acknowledgment ConvertAcknowledgment(List <Interchange> interchanges, string userId)
{
// Edi section ISA
var isa = interchanges[0];
// Edi section GS
var gs = isa.FunctionGroups.ToList()[0];
// Edi section ST
var st = gs.Transactions[0];
// Edi section BIG
var bak = st.Segments.FirstOrDefault(x => x.SegmentId == "BAK");
// Edi section CUR
var cur = st.Segments.FirstOrDefault(x => x.SegmentId == "CUR");
// Edi section CTT
var ctt = st.Loops.Where(x => x.SegmentId == "CTT").ToList()[0];
var amt = ctt.Segments.ToList()[0];
// Edi section N1 - loop
var n1 = st.Loops.Where(x => x.SegmentId == "N1").ToList();
// Edi section NTE
var td5 = st.Segments.Where(x => x.SegmentId == "TD5").ToList();
// Edi section IT1 - loop
var po1 = st.Loops.Where(x => x.SegmentId == "PO1").ToList();
// Edi section REF - (ref keyword is taken so variable name can't follow convention)
var refack = st.Segments.Where(x => x.SegmentId == "REF").ToList();
var env = ExtractEnv(isa, gs, st);
var names = ExtractNames(n1);
var td5s = ExtractTransitDtl(td5);
var items = ExtractItems(po1);
var refs = ExtractRefs(refack);
var Acknowledgment = new Acknowledgment()
{
AckEnvelope = env,
UserID = userId,
BAK01_TransactionSetPurposeCode = bak != null?bak.GetElement(1) : null,
BAK02_AcknowledgmentType = bak != null?bak.GetElement(2) : null,
BAK03_PurchaseOrderNumber = bak != null?bak.GetElement(3) : null,
BAK04_Date = bak != null?bak.GetDate8Element(4) : null,
BAK05_ReleaseNumber = bak != null?bak.GetElement(5) : null,
BAK07_ContractNumber = bak != null?bak.GetElement(6) : null,
CUR01_EntityIdentifierCode = cur != null?cur.GetElement(1) : null,
CUR02_CurrencyCode = cur != null?cur.GetElement(2) : null,
CTT01_NumberOfLineItems = ctt != null?ctt.GetIntElement(1) : null,
AMT01_AmountQualifierCode = amt != null?amt.GetElement(1) : null,
AMT02_MonetaryAmount = amt != null?amt.GetDecimalElement(2) : null,
AckNames = names,
AckTd5s = td5s,
AckItems = items,
AckRefs = refs
};
Console.WriteLine(isa.SerializeToX12(true));
return(Acknowledgment);
}
public void AddAcknowledgment(Response response, Acknowledgment acknowledgment)
{
if (acknowledgment is CreatedItemAcknowledgment createdItemAcknowledgment)
{
response.StatusCode = HttpStatusCode.Created;
SetLocationHeader(response, createdItemAcknowledgment.NewIdentifier);
}
else
{
response.StatusCode = HttpStatusCode.OK;
}
}
public void AddAcknowledgment(Response response, Acknowledgment acknowledgment)
{
if (acknowledgment is CreatedItemAcknowledgment createdItemAcknowledgment)
{
response.ExtraBody[StatusKey] = "created";
response.ExtraBody["Identifier"] = createdItemAcknowledgment.NewIdentifier;
}
else
{
response.ExtraBody[StatusKey] = "ok";
}
}
public async Task <Feedback> ExecuteAsync(IRestItem item, IEndpointContext context, ResourceBody body)
{
var itemBody = body as ItemBody;
if (itemBody == null)
{
throw new ItemBodyNotSupportedException(body.ResourceType);
}
Acknowledgment acknowledgment = await item.EditAsync(itemBody.Item);
return(new AcknowledgmentFeedback(acknowledgment));
}
public async Task <Feedback> ExecuteAsync(IRestScalar scalar, IEndpointContext context, ResourceBody body)
{
var scalarBody = body as ScalarBody;
if (scalarBody == null)
{
throw new InvalidCastException("Request body type must be a scalar value for this endpoint.");
}
Acknowledgment acknowledgment = await scalar.EditAsync(scalarBody.Scalar);
return(new AcknowledgmentFeedback(acknowledgment));
}
public async Task <Acknowledgment> DeleteAllAsync(IRestCollectionQuery query)
{
using (HttpClient client = HttpClientCreator.Create())
{
var queryStringBuilder = new CollectionQueryStringBuilder(new CollectionQueryStringConfiguration());
string fullUrl = UriUtilities.AppendQueryString(Path, queryStringBuilder.BuildString(query));
HttpResponseMessage response = await client.DeleteAsync(fullUrl);
Acknowledgment acknowledgment = await EnsureSuccessAsync(response);
return(acknowledgment);
}
}
private void Acknowledge(Acknowledgment ack)
{
Console.WriteLine($"Remove: {ack.MessageId}");
if (this.remoteActor == null)
{
this.remoteActor = this.Sender;
Context.Watch(this.remoteActor);
}
this.queue.Remove(ack.MessageId);
this.Deliver();
}
public async Task <CreatedItemAcknowledgment> AddAsync(RestItemData itemData)
{
using (HttpClient client = HttpClientCreator.Create())
{
HttpResponseMessage response = await client.PostAsync(Path, Serializer.SerializeItemToContent(itemData));
Acknowledgment acknowledgment = await EnsureSuccessAsync(response);
var created = acknowledgment as CreatedItemAcknowledgment;
if (created == null)
{
throw new InvalidOperationException("REST API did not return status code 201 after creating an item.");
}
return(created);
}
}
public async Task SetValueAsync(IDeferredItem <TItem> item, object deserializedValue, IDataTransaction dataTransaction)
{
IEngineRepository <TNav> navRepository = new NavigationItemRepository <TItem, TNav>(item, _navTools.NavExpression, _navTools.Setter);
var itemData = new RestItemData(deserializedValue);
var navLocatorCreator = new NavigationItemLocatorCreator <TNav>(_subContext);
DeferredItemBase <TNav> deferredItem = await navLocatorCreator.LocateOrCreateItemAsync(navRepository, itemData, item.LoadAsync);
try
{
IDataTransaction transaction = new VoidTransaction(); // we commit the transaction in the parent. TODO optional save-as-you-go ?
var navContext = new FullEngineContext <TNav>(transaction, navRepository, _subContext);
var navEngineItem = new EngineRestItem <TNav>(navContext, deferredItem);
Acknowledgment acknowledgment = await navEngineItem.EditAsync(itemData);
}
catch (RestApiException ex)
{
throw new SubWriterException(ex, item);
}
}
public void SetDeliveryInfo(Acknowledgment acknowledgment,
DateTime arrivedTime,
IMessageQueue destinationQueue,
string id,
MessageType messageType,
byte[] senderId,
long senderVersion,
DateTime sentTime,
string sourceMachine,
string transactionId)
{
this.acknowledgment = acknowledgment;
this.arrivedTime = arrivedTime;
this.destinationQueue = destinationQueue;
this.id = id;
this.messageType = messageType;
this.senderId = senderId;
this.senderVersion = senderVersion;
this.sentTime = sentTime;
this.sourceMachine = sourceMachine;
this.transactionId = transactionId;
this.isDelivered = true;
}
public async Task SetValueAsync(IDeferredItem <TItem> item, object deserializedValue, IDataTransaction dataTransaction)
{
IEngineRepository <TNav> navRepository = new NavigationCollectionRepository <TItem, TCollection, TNav>(item, _navTools.NavExpression, _navTools.Setter);
IDataTransaction transaction = new VoidTransaction(); // we commit the transaction in the parent. TODO optional save-as-you-go ?
var navContext = new FullEngineContext <TNav>(transaction, navRepository, _subContext);
var navLocatorCreator = new NavigationItemLocatorCreator <TNav>(_subContext);
IEnumerable deserializedCollection = (IEnumerable)deserializedValue; // todo null ?
foreach (object deserializedItem in deserializedCollection)
{
var itemData = new RestItemData(deserializedItem);
DeferredItemBase <TNav> deferredItem = await navLocatorCreator.LocateOrCreateItemAsync(navRepository, itemData, item.LoadAsync);
var navEngineItem = new EngineRestItem <TNav>(navContext, deferredItem);
Acknowledgment acknowledgment = await navEngineItem.EditAsync(itemData);
}
// TODO: remove items that were not located?
}
public void AddAcknowledgment(Response response, Acknowledgment acknowledgment)
{
}
public void SetDeliveryInfo (Acknowledgment acknowledgment,
DateTime arrivedTime,
IMessageQueue destinationQueue,
string id,
MessageType messageType,
byte[] senderId,
long senderVersion,
DateTime sentTime,
string sourceMachine,
string transactionId)
{
this.acknowledgment = acknowledgment;
this.arrivedTime = arrivedTime;
this.destinationQueue = destinationQueue;
this.id = id;
this.messageType = messageType;
this.senderId = senderId;
this.senderVersion = senderVersion;
this.sentTime = sentTime;
this.sourceMachine = sourceMachine;
this.transactionId = transactionId;
this.isDelivered = true;
}
public void Create(Acknowledgment entity)
{
_unitOfWork.AcknowledgmentRepository.Add(entity);
_unitOfWork.Commit();
}
public void Update(Acknowledgment entity)
{
_unitOfWork.AcknowledgmentRepository.Edit(entity);
_unitOfWork.Commit();
}
public void Delete(Acknowledgment entity)
{
_unitOfWork.AcknowledgmentRepository.Delete(entity);
_unitOfWork.Commit();
}
private void ProcessAcknowledgement()
{
// Deserialize ack file into an ack object.
AcknowledgmentParser acknowledgmentParser = new AcknowledgmentParser(Context.Log);
Acknowledgment acknowledgment = acknowledgmentParser.Parse(AcknowledgmentFileName, AcknowledgmentFileStream);
Collection <int> successfullyRedeemedReferenceNumbers = new Collection <int>();
Collection <int> rejectedByPartnerReferenceNumbers = new Collection <int>();
Collection <int> successfullyGrantedRewards = new Collection <int>();
Collection <int> rejectedRewards = new Collection <int>();
if (acknowledgment != null)
{
// if we have general ack records to process, get the first one
// We should ideally have only one B record, and we will log warning in parsing code otherwise.
if (acknowledgment.GeneralAcknowledgments.Count > 0)
{
GeneralAcknowledgment generalAcknowledgment = acknowledgment.GeneralAcknowledgments[0];
if (generalAcknowledgment.AcknowledgementCode != AcknowledgmentConstants.SuccessfulSubmissionAckCode)
{
// log failure and return
Context.Log.Warning(
"The PTS file submission was rejected. Details: \r\n:" +
"Record Seq Number : {0} \r\n" +
"Received Acknowledgment Code : {1} \r\n" +
"Sumission Id : {2} \r\n",
(int)ResultCode.SubmissionRejected,
generalAcknowledgment.RecordSequenceNumber,
generalAcknowledgment.AcknowledgementCode,
generalAcknowledgment.SubmissionId);
return;
}
}
// process each Detail Ack Record.
foreach (DetailAcknowledgment detailAcknowledgment in acknowledgment.DetailAcknowledgments)
{
if (detailAcknowledgment != null)
{
// No overflow because reference number will never be more than int range.
int referenceNumber = Convert.ToInt32(detailAcknowledgment.ReferenceNumber);
// add all the successfull
if (detailAcknowledgment.AcknowledgementCode == AcknowledgmentConstants.SuccessfulRedemptionAckCode)
{
if (String.Equals(detailAcknowledgment.MerchantDescriptor,
ReferredRedemptionRewardsMerchantDescriptor, StringComparison.OrdinalIgnoreCase) == false)
{
successfullyRedeemedReferenceNumbers.Add(referenceNumber);
}
else
{
successfullyGrantedRewards.Add(referenceNumber);
}
}
else
{
Context.Log.Warning(
"Deal with reference number {0} was not accepted by the partner. " +
"We expected AcknowledgmentCode of {1} but we got {2}",
(int)ResultCode.RedeemedDealRejectedByPartner,
referenceNumber,
AcknowledgmentConstants.SuccessfulRedemptionAckCode,
detailAcknowledgment.AcknowledgementCode);
if (String.Equals(detailAcknowledgment.MerchantDescriptor,
ReferredRedemptionRewardsMerchantDescriptor, StringComparison.OrdinalIgnoreCase) == false)
{
rejectedByPartnerReferenceNumbers.Add(referenceNumber);
}
else
{
rejectedRewards.Add(referenceNumber);
}
}
}
}
}
if (successfullyRedeemedReferenceNumbers.Count > 0)
{
UpdateRedeemedDeals(successfullyRedeemedReferenceNumbers, CreditStatus.CreditGranted);
WorkerActions.UpdateOutstandingReferredRedemptionRewards(successfullyGrantedRewards, RewardPayoutStatus.Paid, RewardOperations, Context);
}
if (rejectedByPartnerReferenceNumbers.Count > 0)
{
UpdateRedeemedDeals(rejectedByPartnerReferenceNumbers, CreditStatus.RejectedByPartner);
WorkerActions.UpdateOutstandingReferredRedemptionRewards(rejectedRewards, RewardPayoutStatus.Rescinded, RewardOperations, Context);
}
}
public async Task <Feedback> ExecuteAsync(IRestItem item, IEndpointContext context, ResourceBody body)
{
Acknowledgment acknowledgment = await item.DeleteAsync();
return(new AcknowledgmentFeedback(acknowledgment));
}
public AcknowledgmentFeedback(Acknowledgment acknowledgment)
{
Acknowledgment = acknowledgment;
}
public async Task UpdateAsync(Acknowledgment entity)
{
_unitOfWork.AcknowledgmentRepository.Edit(entity);
await _unitOfWork.CommitAsync();
}
public async Task DeleteAsync(Acknowledgment entity)
{
_unitOfWork.AcknowledgmentRepository.Delete(entity);
await _unitOfWork.CommitAsync();
}
public async Task <Feedback> ExecuteAsync(IRestScalar scalar, IEndpointContext context, ResourceBody body)
{
Acknowledgment acknowledgment = await scalar.EditAsync(null);
return(new AcknowledgmentFeedback(acknowledgment));
}
/// <summary>
///
/// </summary>
private void Process()
{
AcknowledgmentClass acknowledgmentClass = (AcknowledgmentClass)cboClassification.Items[cboClassification.SelectedIndex];
string initials = txtInitials.Text.ToUpper();
string notes = txtNotes.Text;
bool successful = chkSuccessful.Checked;
btnOk.Enabled = false;
btnCancel.Enabled = false;
(new Thread(() =>
{
try
{
bool acknowledgedPrevious = false;
bool errors = false;
using (new HourGlass(this))
using (NPoco.Database db = new NPoco.Database(Db.GetOpenMySqlConnection()))
{
db.BeginTransaction();
foreach (Event temp in _events)
{
try
{
bool insert = true;
var ack = db.Fetch <Acknowledgment>("select * from acknowledgment where cid=@0 and sid=@1", new object[] { temp.Cid, temp.Sid });
if (ack.Count() > 0)
{
if (ack.First().Initials.ToUpper() != initials)
{
acknowledgedPrevious = true;
insert = false;
}
else
{
db.Delete(ack.First());
}
}
if (insert == true)
{
Acknowledgment acknowledgment = new Acknowledgment();
acknowledgment.Cid = temp.Cid;
acknowledgment.Sid = temp.Sid;
acknowledgment.Initials = initials;
acknowledgment.Notes = notes;
acknowledgment.Class = acknowledgmentClass.Id;
acknowledgment.Successful = successful;
acknowledgment.Timestamp = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
db.Insert(acknowledgment);
}
}
catch (Exception ex)
{
db.AbortTransaction();
errors = true;
IO.WriteTextToFile("Acknowledgement Insert Error (" + DateTime.Now + "): " + ex.ToString() + Environment.NewLine,
System.IO.Path.Combine(Misc.GetUserDataDirectory(), "Errors.txt"),
true);
break;
}
}
if (errors == false)
{
db.CompleteTransaction();
}
}
if (acknowledgedPrevious == true)
{
UserInterface.DisplayMessageBox(this,
"Some events were not classified due to being already classified",
MessageBoxIcon.Exclamation);
}
if (errors == true)
{
UserInterface.DisplayMessageBox(this,
"Errors occured, check the Errors.txt file",
MessageBoxIcon.Exclamation);
}
}
catch (Exception ex)
{
UserInterface.DisplayMessageBox(this,
"Errors occured, check the Errors.txt file",
MessageBoxIcon.Exclamation);
IO.WriteTextToFile("Acknowledgement Insert Error (" + DateTime.Now + "): " + ex.ToString() + Environment.NewLine,
System.IO.Path.Combine(Misc.GetUserDataDirectory(), "Errors.txt"),
true);
}
finally
{
this.DialogResult = DialogResult.OK;
}
})).Start();
}
