public RetailItemPricingHistory(DesktopSession desktopSession, RetailItem item, QuickCheck quickCheck)
{
DesktopSession = desktopSession;
InitializeComponent();
RetailItem = item;
QuickInformation = quickCheck;
}
public static bool ProcessChargeonNewItems(DesktopSession desktopSession, List <Item> tempItems, string storeNumber)
{
foreach (Item pItem in tempItems)
{
if (pItem != null)
{
QuickCheck pItemQInfo = pItem.QuickInformation;
Int64[] primaryMasks = getMasks(pItem);
//Insert MDSE record for this pawn item
//Calculate the cost amount of the item
//Requirement is that cost will be 65% of the amount entered as retail amount
//decimal itemCost = Utilities.GetDecimalValue(.65) * Utilities.GetDecimalValue(pItem.ItemAmount);
decimal itemCost = pItem.ItemAmount;
string errorCode;
string errorMessage;
bool curRetValue = ProcessTenderProcedures.ExecuteInsertMDSERecord(
pItem.mStore, pItem.mStore, pItem.mYear, pItem.mDocNumber,
"" + pItem.mDocType, 1, 0, pItem.CategoryCode,
"", itemCost,
0, pItemQInfo.Manufacturer,
pItemQInfo.Model, pItemQInfo.SerialNumber, pItemQInfo.Weight,
primaryMasks, pItem.TicketDescription, pItem.ItemAmount,
pItem.StorageFee, "AUDIT",
ShopDateTime.Instance.ShopDate.FormatDate(), ShopDateTime.Instance.ShopDate.ToShortDateString() + " " + ShopDateTime.Instance.ShopTime.ToString(), "", "", pItem.mDocType, "", out errorCode, out errorMessage);
if (!curRetValue)
{
return(false);
}
foreach (ItemAttribute iAttr in pItem.Attributes)
{
if (iAttr.Answer.AnswerCode == OTHERDSC_CODE)
{
bool otherDscVal = ProcessTenderProcedures.ExecuteInsertOtherDscRecord(
storeNumber, pItem.mStore, pItem.mYear, pItem.mDocNumber,
"" + pItem.mDocType, 1, 0, iAttr.MaskOrder,
iAttr.Answer.AnswerText, "AUDIT", out errorCode, out errorMessage);
if (!otherDscVal)
{
return(false);
}
}
}
MerchandiseProcedures.UpdateMerchandiseRetailPrice(desktopSession,
new Icn(pItem.Icn), pItem.RetailPrice, out errorCode, out errorMessage, storeNumber);
if (errorCode != "0")
{
return(false);
}
desktopSession.PrintTags(pItem, CurrentContext.AUDITCHARGEON);
}
}
return(true);
}
public static void WorkerMainThread(ClientWorkerData p_worker_data, IPEndPoint p_server_ip_endpoint)
{
ClientWorkerData worker_data = p_worker_data;
Dictionary <int, Thread> all_mini_threads = new Dictionary <int, Thread>();
object all_mini_threads_lock = new object();
ClientWorkerStatus status = ClientWorkerStatus.Connecting;
System.Timers.Timer worker_quick_check_timer_object = new System.Timers.Timer();
worker_quick_check_timer_object.Interval = 13500;
worker_quick_check_timer_object.AutoReset = false;
worker_quick_check_timer_object.Elapsed += new System.Timers.ElapsedEventHandler((sender, e) => worker_timer_Elapsed(sender
, e, worker_data.send_to_worker_construct
, worker_data.client_worker_pulse_object));
ClientWorkerTimer timer = new ClientWorkerTimer(worker_quick_check_timer_object);
Socket server_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
int k = 0;
while (k < 4)
{
try
{
server_socket.Connect(p_server_ip_endpoint);
k = 0;
break;
}
catch (Exception)
{
k++;
Thread.Sleep(200);
continue;
}
}
if (k > 3)
{
MessageFromWorker signal_reject_message = new MessageFromWorker(new ClientWorkerSignal(false), TypeOfMessageFromWorker.SignalMessage);
AddNewTransferMiniThread(signal_reject_message, worker_data.receive_from_worker_construct, worker_data.message_received_inform
, worker_data.main_form_invoke, all_mini_threads, all_mini_threads_lock);
try
{
server_socket.Shutdown(SocketShutdown.Both);
server_socket.Close();
}
catch
{
}
Thread.CurrentThread.Abort();
return;
}
MessageFromWorker signal_accept_message = new MessageFromWorker(new ClientWorkerSignal(true), TypeOfMessageFromWorker.SignalMessage);
AddNewTransferMiniThread(signal_accept_message, worker_data.receive_from_worker_construct, worker_data.message_received_inform
, worker_data.main_form_invoke, all_mini_threads, all_mini_threads_lock);
int last_message_sent_id = 0;
bool cancelled = false;
bool user_cancelled = false;
BinaryFormatter formatter = new BinaryFormatter();
formatter.Context = new StreamingContext(StreamingContextStates.All);
formatter.TypeFormat = FormatterTypeStyle.TypesWhenNeeded;
formatter.AssemblyFormat = FormatterAssemblyStyle.Simple;
SerializationBinder serialization_binder = formatter.Binder;
MemoryStream stream = new MemoryStream();
byte[] data_buffer = new byte[1];
status = ClientWorkerStatus.Satrting;
Queue <byte[]> temp_receive_thread_queue = new Queue <byte[]>();
WorkerReceiveThreadConstruct receive_thread_construct = new WorkerReceiveThreadConstruct(temp_receive_thread_queue);
Thread receiver_thread = new Thread(() => ReceiveThread(receive_thread_construct, ref server_socket
, ref timer, worker_data.client_worker_pulse_object));
Queue <KeyValuePair <TypeOfSend, byte[]> > send_thread_queue = new Queue <KeyValuePair <TypeOfSend, byte[]> >();
bool send_thread_queue_flag = false;
bool send_thread_cancel_flag = false;
object send_thread_pulse_object = new object();
bool send_thread_receipt_received_flag = false;
Thread send_thread = new Thread(() => SendThread(send_thread_queue, ref send_thread_queue_flag, ref send_thread_cancel_flag
, ref send_thread_receipt_received_flag, send_thread_pulse_object, worker_data.client_worker_pulse_object, receive_thread_construct, server_socket, timer));
receiver_thread.Start();
send_thread.Start();
timer.StartAndReset();
status = ClientWorkerStatus.Normal;
while (true)
{
lock (worker_data.client_worker_pulse_object)
{
if (!worker_data.cancel_construct.cancel_construct_flag && !receive_thread_construct.receive_thread_queue_flag && !worker_data.send_to_worker_construct.send_to_worker_queue_flag)
{
Monitor.Wait(worker_data.client_worker_pulse_object);
}
if (worker_data.cancel_construct.cancel_construct_flag)
{
timer.PrimerStop();
user_cancelled = true;
cancelled = true;
break;
}
if (receive_thread_construct.receive_thread_queue_flag)
{
if (receive_thread_construct.receive_thread_queue.Count > 0)
{
byte[] byte_received_data = receive_thread_construct.receive_thread_queue.Dequeue();
if (receive_thread_construct.receive_thread_queue.Count == 0)
{
receive_thread_construct.receive_thread_queue_flag = false;
}
if (byte_received_data.Length == 0)
{
timer.PrimerStop();
MessageFromWorker cancel_message_from_worker = new MessageFromWorker(null, TypeOfMessageFromWorker.OfflineInform);
AddNewTransferMiniThread(cancel_message_from_worker, worker_data.receive_from_worker_construct, worker_data.message_received_inform
, worker_data.main_form_invoke, all_mini_threads, all_mini_threads_lock);
cancelled = true;
break;
}
else
{
stream = new MemoryStream(byte_received_data);
DataForSend data_received = null;
try
{
data_received = (DataForSend)formatter.Deserialize(stream);
}
catch
{
stream = new MemoryStream();
continue;
}
stream = new MemoryStream();
if (data_received.Get_data_for_send_type == TypeOfDataForSend.QuickAnswer && status == ClientWorkerStatus.WaitForAReceipt)
{
QuickAnswer received_quick_answer = null;
try
{
received_quick_answer = ((QuickAnswer)data_received.Get_message_object);
}
catch
{
continue;
}
if (received_quick_answer.Get_id == last_message_sent_id)
{
lock (send_thread_pulse_object)
{
send_thread_receipt_received_flag = true;
Monitor.Pulse(send_thread_pulse_object);
status = ClientWorkerStatus.Normal;
}
}
}
else if (data_received.Get_data_for_send_type == TypeOfDataForSend.QuickCheck)
{
QuickCheck received_quick_check = null;
try
{
received_quick_check = ((QuickCheck)data_received.Get_message_object);
}
catch
{
continue;
}
QuickAnswer quick_answer = new QuickAnswer(received_quick_check.Get_id);
DataForSend quick_answer_for_send = new DataForSend(TypeOfDataForSend.QuickAnswer, quick_answer);
formatter.Serialize(stream, quick_answer_for_send);
byte[] byte_quick_answer = stream.GetBuffer();
stream = new MemoryStream();
lock (send_thread_pulse_object)
{
send_thread_queue.Enqueue(new KeyValuePair <TypeOfSend, byte[]>(TypeOfSend.WithoutReceipt, byte_quick_answer));
send_thread_queue_flag = true;
Monitor.Pulse(send_thread_pulse_object);
}
}
else if (data_received.Get_data_for_send_type == TypeOfDataForSend.UserMessage)
{
UserMessageToClient user_message = null;
try
{
user_message = ((UserMessageToClient)data_received.Get_message_object);
}
catch (Exception)
{
continue;
}
FinalMessageForClient client_object = null;
try
{
client_object = new FinalMessageForClient(user_message.Get_user_message.Get_message_type, user_message.Get_user_message.Get_message_object);
}
catch (Exception)
{
continue;
}
MessageFromWorker final_message_received = new MessageFromWorker(client_object, TypeOfMessageFromWorker.FinalMessage);
AddNewTransferMiniThread(final_message_received, worker_data.receive_from_worker_construct, worker_data.message_received_inform
, worker_data.main_form_invoke, all_mini_threads, all_mini_threads_lock);
QuickAnswer user_message_answer = new QuickAnswer(user_message.Get_id);
DataForSend user_answer_for_send = new DataForSend(TypeOfDataForSend.QuickAnswer, user_message_answer);
formatter.Serialize(stream, user_answer_for_send);
lock (send_thread_pulse_object)
{
send_thread_queue.Enqueue(new KeyValuePair <TypeOfSend, byte[]>(TypeOfSend.WithoutReceipt, stream.GetBuffer()));
send_thread_queue_flag = true;
Monitor.Pulse(send_thread_pulse_object);
}
stream = new MemoryStream();
}
}
}
else
{
receive_thread_construct.receive_thread_queue_flag = false;
}
}
if (worker_data.send_to_worker_construct.send_to_worker_queue_flag)
{
if (status == ClientWorkerStatus.Normal)
{
if (worker_data.send_to_worker_construct.send_to_worker_queue.Count > 0)
{
MessageToWorker object_to_send = worker_data.send_to_worker_construct.send_to_worker_queue.Dequeue();
if (worker_data.send_to_worker_construct.send_to_worker_queue.Count == 0)
{
worker_data.send_to_worker_construct.send_to_worker_queue_flag = false;
}
if (object_to_send.Get_type_of_message_to_worker_object == TypeOfMessageToWorker.QuickCheckRequest)
{
QuickCheck quick_check_to_send = new QuickCheck(HelperFunctions.GetGUID());
DataForSend client_data = new DataForSend(TypeOfDataForSend.QuickCheck, quick_check_to_send);
formatter.Serialize(stream, client_data);
byte[] byte_client_data = stream.GetBuffer();
lock (send_thread_pulse_object)
{
send_thread_queue.Enqueue(new KeyValuePair <TypeOfSend, byte[]>(TypeOfSend.WithReceipt, byte_client_data));
send_thread_queue_flag = true;
Monitor.Pulse(send_thread_pulse_object);
}
last_message_sent_id = quick_check_to_send.Get_id;
status = ClientWorkerStatus.WaitForAReceipt;
stream = new MemoryStream();
}
else if (object_to_send.Get_type_of_message_to_worker_object == TypeOfMessageToWorker.FinalMessage)
{
FinalMessageForServer final_message = (FinalMessageForServer)object_to_send.Get_message_for_worker_object;
UserMessageToServer user_message_to_send = new UserMessageToServer(HelperFunctions.GetGUID(), final_message);
DataForSend client_data = new DataForSend(TypeOfDataForSend.UserMessage, user_message_to_send);
formatter.Serialize(stream, client_data);
byte[] byte_client_data = stream.GetBuffer();
lock (send_thread_pulse_object)
{
send_thread_queue.Enqueue(new KeyValuePair <TypeOfSend, byte[]>(TypeOfSend.WithReceipt, byte_client_data));
send_thread_queue_flag = true;
Monitor.Pulse(send_thread_pulse_object);
}
last_message_sent_id = user_message_to_send.Get_id;
status = ClientWorkerStatus.WaitForAReceipt;
stream = new MemoryStream();
}
}
else
{
worker_data.send_to_worker_construct.send_to_worker_queue_flag = false;
}
}
}
}
}
if (cancelled)
{
timer.PrimerStop();
if (!user_cancelled)
{
MessageFromWorker offline_inform_message = new MessageFromWorker(null, TypeOfMessageFromWorker.OfflineInform);
AddNewTransferMiniThread(offline_inform_message, worker_data.receive_from_worker_construct, worker_data.message_received_inform
, worker_data.main_form_invoke, all_mini_threads, all_mini_threads_lock);
}
try
{
receiver_thread.Abort();
}
catch
{
}
try
{
server_socket.Shutdown(SocketShutdown.Both);
server_socket.Close();
}
catch
{
}
receiver_thread.Join();
lock (send_thread_pulse_object)
{
send_thread_cancel_flag = true;
Monitor.Pulse(send_thread_pulse_object);
}
send_thread.Join();
Thread.CurrentThread.Abort();
return;
}
}
/*__________________________________________________________________________________________*/
private void IH_AddItemToNewPawnLoan_Click(object sender, EventArgs e)
{
var pawnLoan = GlobalDataAccessor.Instance.DesktopSession.CustomerHistoryLoans
.First(pl => pl.TicketNumber == _ActiveTicketNumber);
if (pawnLoan != null)
{
Item pawnItem = pawnLoan.Items
.First(pi => pi.Icn == _ActiveICN);
if (pawnItem != null)
{
if (GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan == null)
{
GlobalDataAccessor.Instance.DesktopSession.PawnLoans = new List <PawnLoan>(1)
{
new PawnLoan()
};
if (GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan != null)
{
GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items = new List <Item>();
}
GlobalDataAccessor.Instance.DesktopSession.DescribeItemPawnItemIndex = 0;
}
else if (GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.TicketNumber != pawnLoan.TicketNumber &&
GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.TicketNumber != 0
)
{
GlobalDataAccessor.Instance.DesktopSession.PawnLoans = new List <PawnLoan>(1)
{
new PawnLoan()
};
GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items = new List <Item>();
GlobalDataAccessor.Instance.DesktopSession.DescribeItemPawnItemIndex = 0;
}
else
{
int itemAlreadyExists = GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items.FindIndex(s => s.Icn == pawnItem.Icn);
if (itemAlreadyExists >= 0)
{
GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items.RemoveAt(itemAlreadyExists);
}
GlobalDataAccessor.Instance.DesktopSession.DescribeItemPawnItemIndex = GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items.Count;
}
//The attributes of the pawn item need to be derived
int iCategoryMask = GlobalDataAccessor.Instance.DesktopSession.CategoryXML.GetCategoryMask
(pawnItem.CategoryCode);
var dmPawnItem = new DescribedMerchandise(iCategoryMask);
Item.PawnItemMerge(ref pawnItem, dmPawnItem.SelectedPawnItem, false);
pawnItem.CategoryMask = iCategoryMask;
pawnItem.ItemReason = ItemReason.BLNK;
pawnItem.mDocType = "1";
if (GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan != null)
{
if (GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items.Count > 0)
{
pawnItem.mItemOrder = GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items.Count - 1;
}
else
{
pawnItem.mItemOrder = 0;
}
}
pawnItem.mStore = Convert.ToInt32(GlobalDataAccessor.Instance.CurrentSiteId.StoreNumber);
pawnItem.mYear = Convert.ToInt16(ShopDateTime.Instance.ShopDate.Year.ToString().Substring(ShopDateTime.Instance.ShopDate.Year.ToString().Length - 1));
if (pawnItem.IsGun)
{
QuickCheck quickInfo = new QuickCheck
{
GunType = pawnItem.CategoryDescription
};
pawnItem.QuickInformation = quickInfo;
}
GlobalDataAccessor.Instance.DesktopSession.DescribeItemSelectedProKnowMatch = pawnItem.SelectedProKnowMatch;
GlobalDataAccessor.Instance.DesktopSession.DescribeItemContext = CurrentContext.NEW;
if (GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan != null)
{
GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Fees.Clear();
GlobalDataAccessor.Instance.DesktopSession.ActivePawnLoan.Items.Add(pawnItem);
}
NavControlBox.CustomDetail = "AddNewLoan";
NavControlBox.IsCustom = true;
NavControlBox.Action = NavBox.NavAction.BACKANDSUBMIT;
}
}
}
