private void ReceiveCallBack(IAsyncResult ar)
{
Settings settings = ar.AsyncState as Settings;
TransactionProtocol transaction = ar.AsyncState as TransactionProtocol;
try
{
SocketError response;
int buffsize = _socket.EndReceive(ar, out response);
if (response == SocketError.Success)
{
byte[] payloadbytes = new byte[buffsize];
Array.Copy(settings.Buffer, payloadbytes, payloadbytes.Length);
PayloadHandler.Handle(payloadbytes, settings);
}
}
catch (Exception e)
{
Console.WriteLine($"Can't receive data from Queue Server {e.Message}");
}
finally
{
try
{
settings.Socket.BeginReceive(settings.Buffer, 0, settings.Buffer.Length, SocketFlags.None, ReceiveCallBack, transaction);
}
catch (Exception e)
{
Console.WriteLine($"{e.Message}");
settings.Socket.Close();
}
}
}
internal void ErrorHandler(TransactionProtocol message, ConnectionParam connection)
{
message.Type_message = API_Transaction.Enums.TypeMessage.error;
var byte_message = ConvertToByteArray(message);
connection.Socket.Send(byte_message);
}
private static void Write(TransactionProtocol data, TransactionData transaction)
{
Console.WriteLine("\n\n" + data.Sender_id + " add to " + data.Request_id + " at " + data.Timestamp);
Console.WriteLine("Owner: " + transaction.Owner_card_id + "\nReceiver: " + transaction.Recipient_card_id + "\nTransaction: " + transaction.transactionType
+ "\nCcy: " + transaction.Ccy + "\nSum: " + transaction.Transaction_summ);
}
public void RouteRequests(ConnectionParam connection)
{
var request = Encoding.UTF8.GetString(connection.Context);
TransactionProtocol message = JsonConvert.DeserializeObject <TransactionProtocol>(request);
if (message.Type_message == TypeMessage.add)
{
AddHandler(message, connection);
}
else
if (message.Type_message == TypeMessage.give)
{
GiveHandler(message, connection);
}
else
if (message.Type_message == TypeMessage.response)
{
ResponseHandler(message, connection);
}
else
{
ErrorHandler(message, connection);
}
}
public bool TxOperation()
{
NetTcpBinding tcp = (NetTcpBinding)OperationContext.Current.Host.Description.Endpoints[0].Binding;
TransactionProtocol pro = tcp.TransactionProtocol;
WSHttpBinding ws = (WSHttpBinding)OperationContext.Current.Host.Description.Endpoints[1].Binding;
TransactionInformation info = Transaction.Current.TransactionInformation;
string localId = String.Empty;
Guid distributedId = Guid.Empty;
localId = info.LocalIdentifier;
distributedId = info.DistributedIdentifier;
DBOperation1();
localId = info.LocalIdentifier;
distributedId = info.DistributedIdentifier;
DBOperation2();
localId = info.LocalIdentifier;
distributedId = info.DistributedIdentifier;
return(true);
}
public static void WriteTransactionDataToMessage(TransactionProtocol protocol, string fileName)
{
object transactionFormatter = null;
if (protocol == TransactionProtocol.OleTransactions)
{
transactionFormatter = RefUtil.CreateInstance <object>(OleTxTransactionFormatter);
}
else if (protocol == TransactionProtocol.WSAtomicTransactionOctober2004)
{
transactionFormatter = RefUtil.CreateInstance <object>(WsatTransactionFormatter10);
}
else
{
transactionFormatter = RefUtil.CreateInstance <object>(WsatTransactionFormatter11);
}
Type type = Type.GetType(TransactionFormatter);
Message message = Message.CreateMessage(MessageVersion.Default, "http://www.artech.com/writetransaction", Transaction.Current);
RefUtil.Invoke(type, "WriteTransaction", transactionFormatter, new object[] { Transaction.Current, message });
using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
{
message.WriteMessage(writer);
}
Process.Start(fileName);
}
public static void Handle(byte[] transactionbytes, Settings settings)
{
var transactionstring = Encoding.UTF8.GetString(transactionbytes);
var data = JsonConvert.DeserializeObject <TransactionProtocol>(transactionstring);
var transaction = JsonConvert.DeserializeObject <TransactionData>(data.Transaction);
if (string.IsNullOrWhiteSpace(data.Request_id) || string.IsNullOrWhiteSpace(data.Sender_id) ||
string.IsNullOrWhiteSpace(data.Transaction))
{
data.Type_message = Enums.MessageType.error;
data.Transaction = null;
data.Message = $"Error! Transaction from {data.Sender_id} to {data.Request_id} at {data.Timestamp} was unsuccessful.";
var byte_message = ConvertToBytes(data);
settings.Socket.Send(byte_message);
}
else
{
var to_send = new TransactionProtocol();
to_send.Type_message = Enums.MessageType.response;
to_send.Transaction = null;
to_send.Message = $"Successful! Transaction from {data.Sender_id} to {data.Request_id} at {data.Timestamp} was successful.";
to_send.Timestamp = DateTime.Now;
var byte_message = ConvertToBytes(to_send);
settings.Socket.Send(byte_message);
Write(data, transaction);
}
}
private byte[] ConvertToByteArray(TransactionProtocol message)
{
var transact_format = JsonConvert.SerializeObject(message);
var byte_array = UTF8Encoding.UTF8.GetBytes(transact_format);
return(byte_array);
}
public static SecurityStandardsManager CreateStandardsManager(TransactionProtocol transactionProtocol)
{
if ((transactionProtocol != TransactionProtocol.WSAtomicTransactionOctober2004) && (transactionProtocol != TransactionProtocol.OleTransactions))
{
return(SecurityStandardsManager2007);
}
return(SecurityStandardsManager.DefaultInstance);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (typeof(string) == destinationType && value is TransactionProtocol)
{
TransactionProtocol protocol = (TransactionProtocol)value;
return(protocol.Name);
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public TransactionChannelListener(TransactionProtocol transactionProtocol, IDefaultCommunicationTimeouts timeouts, Dictionary <DirectionalAction, TransactionFlowOption> dictionary, IChannelListener <TChannel> innerListener)
: base(timeouts, innerListener)
{
this.dictionary = dictionary;
this.TransactionProtocol = transactionProtocol;
this.Acceptor = new TransactionChannelAcceptor(this, innerListener);
this.standardsManager = SecurityStandardsHelper.CreateStandardsManager(this.TransactionProtocol);
}
private void Subscribe()
{
TransactionProtocol transaction = new TransactionProtocol();
transaction.Type_message = MessageType.give;
var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(transaction));
Send(data);
}
internal void GiveHandler(TransactionProtocol message, ConnectionParam connection)
{
if (string.IsNullOrWhiteSpace(message.Transaction) == false)
{
ErrorHandler(message, connection);
}
var task = RequestStorage.GetInstance().GetTransaction();
var buffer = ConvertToByteArray(task);
connection.Socket.Send(buffer);
}
private static void WriteTransaction(TransactionProtocol transactionProtocol, Transaction transaction, string fileName)
{
string action = string.Format("http://www.lhl.com/transactionformat/{0}", transactionProtocol.GetType().Name);
Message message = Message.CreateMessage(MessageVersion.Default, action, Transaction.Current);
TransactionFormatter formatter = new TransactionFormatter(transactionProtocol);
formatter.WriteTransaction(Transaction.Current, message);
using (XmlWriter writer = new XmlTextWriter(fileName, Encoding.UTF8)) {
message.WriteMessage(writer);
}
}
public TransactionProtocol GetTransaction()
{
TransactionProtocol transaction = new TransactionProtocol();
var status = false;
while (!status)
{
status = transactions.TryDequeue(out transaction);
}
return(transaction);
}
protected void AddTransactionFlowBindingElement(BindingElementCollection bindingElements)
{
TransactionProtocol transactionProtocol = (this.protocolVersion == ProtocolVersion.Version10) ? TransactionProtocol.WSAtomicTransactionOctober2004 : TransactionProtocol.WSAtomicTransaction11;
TransactionFlowBindingElement item = new TransactionFlowBindingElement(transactionProtocol)
{
Transactions = false,
IssuedTokens = TransactionFlowOption.Allowed
};
bindingElements.Add(item);
}
internal TransactionFlowBindingElement(bool transactions, TransactionProtocol transactionProtocol)
{
_transactions = transactions;
_issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed;
if (!TransactionProtocol.IsDefined(transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(string.Format(SRServiceModel.ConfigInvalidTransactionFlowProtocolValue, transactionProtocol.ToString()));
}
_transactionProtocol = transactionProtocol;
}
internal TransactionFlowBindingElement(bool transactions, TransactionProtocol transactionProtocol)
{
this.transactions = transactions;
this.issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed;
if (!TransactionProtocol.IsDefined(transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.ConfigInvalidTransactionFlowProtocolValue, transactionProtocol.ToString()));
}
this.transactionProtocol = transactionProtocol;
}
private static void TrackAgreementTransactionProtocol(ref bool everyoneAgrees, TransactionProtocol option, ref TransactionProtocol agreedOption, ref bool anOperationCares)
{
if (!anOperationCares)
{
agreedOption = option;
anOperationCares = true;
}
else if (option != agreedOption)
{
everyoneAgrees = false;
}
}
public void AddTransaction(TransactionProtocol protocol)
{
transactions.Enqueue(protocol);
lock (_lock)
{
if (timestamp < DateTime.Now)
{
LoadStorage();
timestamp = DateTime.Now.AddMinutes(1);
}
}
}
public static SecurityStandardsManager CreateStandardsManager(TransactionProtocol transactionProtocol)
{
if (transactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004 ||
transactionProtocol == TransactionProtocol.OleTransactions)
{
return(SecurityStandardsManager.DefaultInstance);
}
else
{
return(SecurityStandardsHelper.SecurityStandardsManager2007);
}
}
public TransactionChannelFactory(
TransactionProtocol transactionProtocol,
BindingContext context,
Dictionary <DirectionalAction, TransactionFlowOption> dictionary,
bool allowWildcardAction)
: base(context.Binding, context.BuildInnerChannelFactory <TChannel>())
{
this.dictionary = dictionary;
this.TransactionProtocol = transactionProtocol;
this.allowWildcardAction = allowWildcardAction;
this.standardsManager = SecurityStandardsHelper.CreateStandardsManager(this.TransactionProtocol);
}
TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned)
: base(elementToBeCloned)
{
this.transactions = elementToBeCloned.transactions;
this.issuedTokens = elementToBeCloned.issuedTokens;
if (!TransactionProtocol.IsDefined(elementToBeCloned.transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.ConfigInvalidTransactionFlowProtocolValue, elementToBeCloned.transactionProtocol.ToString()));
}
this.transactionProtocol = elementToBeCloned.transactionProtocol;
this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction;
}
private TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned)
: base(elementToBeCloned)
{
_transactions = elementToBeCloned._transactions;
_issuedTokens = elementToBeCloned._issuedTokens;
if (!TransactionProtocol.IsDefined(elementToBeCloned._transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(string.Format(SRServiceModel.ConfigInvalidTransactionFlowProtocolValue, elementToBeCloned._transactionProtocol.ToString()));
}
_transactionProtocol = elementToBeCloned._transactionProtocol;
this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction;
}
static void Main(string[] args)
{
var random = new Random();
string typemessage, transactiontype;
Console.WriteLine("Sender is ON!");
var socket = new SocketSender();
socket.Connect(Settings.ipAddress, Settings.port);
if (socket.IsConnected)
{
var data = new TransactionProtocol();
var transaction = new TransactionData();
data.Sender_id = "1";
data.Request_id = random.Next().ToString();
data.Timestamp = DateTime.Now;
Console.WriteLine("\n\t-----Hello! Please enter details for transaction-----\n");
//-----MessageType-----
Console.Write("Type of action \n \tGive = 1 \n \tResponse = 2 \n \tAdd = 3 \n Option:");
typemessage = Console.ReadLine();
data.Type_message = (MessageType)Enum.Parse(typeof(MessageType), typemessage);
//---------------------
Console.Write("Enter owner card id: ");
transaction.Owner_card_id = Console.ReadLine();
Console.Write("Enter receiver card id: ");
transaction.Recipient_card_id = Console.ReadLine();
//-----TransactionType-----
Console.Write("Enter transaction type: ");
transactiontype = Console.ReadLine();
transaction.transactionType = (TransactionType)Enum.Parse(typeof(TransactionType), transactiontype);
//---------------------
Console.Write("Enter currency: ");
transaction.Ccy = Console.ReadLine();
Console.Write("Enter transaction sum: ");
transaction.Transaction_summ = Convert.ToInt32(Console.ReadLine());
Console.Write("Enter aditional comment: ");
transaction.Aditional_comment = Console.ReadLine();
data.Transaction = JsonConvert.SerializeObject(transaction);
var dataserial = JsonConvert.SerializeObject(data);
byte[] databyte = Encoding.UTF8.GetBytes(dataserial);
socket.Send(databyte);
}
Console.ReadLine();
}
public TransactionFormatter(TransactionProtocol transactionProtocol)
{
if (transactionProtocol == TransactionProtocol.OleTransactions)
{
this.InternalFormatter = ReflectUtil.CreateInstance(OleTxFormatterType);
}
else if (transactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004)
{
this.InternalFormatter = ReflectUtil.CreateInstance(Wsat10FormatterType);
}
else
{
this.InternalFormatter = ReflectUtil.CreateInstance(Wsat11FormatterType);
}
}
internal void AddHandler(TransactionProtocol message, ConnectionParam connection)
{
if (string.IsNullOrWhiteSpace(message.Request_id) || string.IsNullOrWhiteSpace(message.Sender_id) ||
string.IsNullOrWhiteSpace(message.Transaction))
{
ErrorHandler(message, connection);
return;
}
var request_storage = RequestStorage.GetInstance();
request_storage.AddTransaction(message);
var connection_storage = ConnectionStorage.GetInstance();
connection_storage.AddConnection(connection, message.Request_id);
}
private void LoadStorage()
{
string storage_path = Config.STORAGE_PATH;
string storage_name = Config.STORAGE_NAME;
string path_comb = Path.Combine(storage_name, storage_path);
using (Stream stream = File.Open(path_comb, FileMode.Create))
{
var formater = new BinaryFormatter();
TransactionProtocol[] transact_array = new TransactionProtocol[transactions.Count];
transactions.CopyTo(transact_array, 0);
var list_transact = transact_array.OfType <TransactionProtocol>().ToList();
formater.Serialize(stream, list_transact);
}
}
static void TrackAgreementTransactionProtocol(ref bool everyoneAgrees, TransactionProtocol option,
ref TransactionProtocol agreedOption, ref bool anOperationCares)
{
if (!anOperationCares)
{
// this is the first operation to express a preference
agreedOption = option;
anOperationCares = true;
// everyoneAgrees is still true
}
else
{
if (option != agreedOption)
{
everyoneAgrees = false;
}
}
}
internal void ResponseHandler(TransactionProtocol message, ConnectionParam connection)
{
if (string.IsNullOrWhiteSpace(message.Request_id) || string.IsNullOrWhiteSpace(message.Sender_id) ||
string.IsNullOrWhiteSpace(message.Message))
{
ErrorHandler(message, connection);
return;
}
var sender_connection = ConnectionStorage.GetInstance().GetConnection(message.Request_id);
if (sender_connection is null)
{
ErrorHandler(message, connection);
return;
}
var message_buffer = ConvertToByteArray(message);
sender_connection.Socket.Send(message_buffer);
}
