public void CallServiceReturningSession2Times_sessionAreEqual()
{
var address = @"net.pipe://127.0.0.1/1/test.test/test" + MethodBase.GetCurrentMethod().Name;
var binding = new NetNamedPipeBinding();
var data = new CallbackData { Data = "1" };
var srv = new CallbackService(data);
var callback = new CallbackServiceCallback();
using (var host = new ServiceHost(srv, new Uri(address)))
{
host.AddServiceEndpoint(typeof(ICallbackService), binding, address);
host.Open();
using (var factory = new DuplexChannelFactory<ICallbackService>(new InstanceContext(callback), binding))
{
var client = factory.CreateChannel(new EndpointAddress(address));
client.Call();
}
callback.Wait.WaitOne();
Assert.AreEqual(data.Data, callback.Called.Data);
}
}
public static void RegisterMethodCallback (object proxy, string method, CallingMethodCallback calling, CalledMethodCallback called, int timeout)
{
string uri = RemotingServices.GetObjectUri ((MarshalByRefObject)proxy);
CallbackData data = new CallbackData ();
data.Target = proxy;
data.Calling = calling;
data.Called = called;
data.Timeout = timeout;
data.Method = method;
callbacks [uri + " " + method] = data;
}
internal static void Callback(CallbackData data)
{
if (data.Callback)
frmMain.Instance.EndInvoke(data.IAsyncResult);
var frm = new frmUpload(data.Collection);
frm.AutoStart = data.AutoStart;
frm.TweetString = data.DefaultText;
frm.InReplyToStatusId = data.InReplyToStatusId;
frm.FormClosed += (s, e) => frm.Dispose();
if (frmMain.Instance != null)
frm.Show(frmMain.Instance);
else
Application.Run(frm);
}
private static void OnTrackingComplete(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
CallbackData asyncState = (CallbackData)result.AsyncState;
try
{
asyncState.Executor.EndTrackPendingRecords(result);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
asyncState.WorkItem.workflowAbortException = exception;
}
asyncState.Executor.FinishWorkItemAfterTracking(asyncState.WorkItem);
}
}
public void AddListener <T>(object obj, GenericDelegate <T> func) where T : EventMessage
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (func == null)
{
throw new ArgumentNullException("func");
}
CallbackData item = new CallbackData
{
obj = obj,
type = typeof(T),
callback = new Callback <T>(func)
};
this.pendingListens.Add(item);
this.ProcessPendingListens();
}
public void Should_parse_callback_data_with_args()
{
var callbackData = new CallbackData <TestState>(TestState.Pending, "arg1", "arg2");
Assert.NotNull(callbackData);
Assert.Equal(TestState.Pending, callbackData.NextState);
Assert.NotEmpty(callbackData.Args);
var callbackDataStr = callbackData.ToString();
Assert.Equal("1>arg1|arg2", callbackDataStr);
var parsed = CallbackData <TestState> .Parse(callbackDataStr);
Assert.NotNull(parsed);
Assert.Equal(TestState.Pending, parsed.NextState);
Assert.NotEmpty(callbackData.Args);
Assert.Contains("arg1", parsed.Args);
Assert.Contains("arg2", parsed.Args);
}
public static async Task Execute(CallbackData data)
{
//достать данные из таблицы
Handlers.GoogleSheetsHandler.AddUser(data.User);
//отправить подтверждение
var receiver = data.User.Id;
//добавить пользователя
var message = new KeyboardMessage
{
Receiver = receiver,
Sender = client.BotUserData,
Text = $"Добрый день я бот который помогает учитывать данные счетчика электроэнерги. Пожалуйста зарегистрируйте квартиру и контактные данные.",
TrackingData = ViberBotTrackingData.Empty(),
Keyboard = KeyboardHandler.Start
};
await client.SendMessage(receiver, message);
}
private static void OnAssociateComplete(IAsyncResult result)
{
if (!result.CompletedSynchronously)
{
CallbackData asyncState = (CallbackData)result.AsyncState;
try
{
asyncState.Executor.EndAssociateKeys(result);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
asyncState.WorkItem.workflowAbortException = exception;
}
asyncState.Executor.FinishWorkItem(asyncState.WorkItem);
}
}
public void Data_CallbacksAreCalled()
{
Events.SubscribeToEvent(callbacks.AData, EventType.A);
Events.SubscribeToEvent(callbacks.BData, EventType.B);
Events.SubscribeToEvent(callbacks.CData, EventType.C);
Events.FireEvent(EventType.A, CallbackData.String("a"));
Events.FireEvent(EventType.B, CallbackData.String("b"));
Events.FireEvent(EventType.C, CallbackData.String("c"));
Assert.AreEqual(1, callbacks.a, "Event callback was not called");
Assert.AreEqual(1, callbacks.b, "Event callback was not called");
Assert.AreEqual(1, callbacks.c, "Event callback was not called");
Assert.AreEqual(1, a, "Event callback was not called");
Assert.AreEqual(1, b, "Event callback was not called");
Assert.AreEqual(1, c, "Event callback was not called");
Assert.AreEqual("c", dataString, "Data was not transmitted succesfully");
}
private void SendRequestMessage(GrainReference target, Message message, TaskCompletionSource <object> context, InvokeMethodOptions options, string genericArguments)
{
var targetGrainId = target.GrainId;
var oneWay = (options & InvokeMethodOptions.OneWay) != 0;
message.SendingGrain = CurrentActivationAddress.Grain;
message.SendingActivation = CurrentActivationAddress.Activation;
message.TargetGrain = targetGrainId;
if (!String.IsNullOrEmpty(genericArguments))
{
message.GenericGrainType = genericArguments;
}
if (targetGrainId.IsSystemTarget())
{
// If the silo isn't be supplied, it will be filled in by the sender to be the gateway silo
message.TargetSilo = target.SystemTargetSilo;
if (target.SystemTargetSilo != null)
{
message.TargetActivation = ActivationId.GetDeterministic(targetGrainId);
}
}
if (message.IsExpirableMessage(this.clientMessagingOptions.DropExpiredMessages))
{
// don't set expiration for system target messages.
message.TimeToLive = this.clientMessagingOptions.ResponseTimeout;
}
if (!oneWay)
{
var callbackData = new CallbackData(this.sharedCallbackData, context, message);
callbacks.TryAdd(message.Id, callbackData);
}
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace("Send {0}", message);
}
MessageCenter.SendMessage(message);
}
private void AddSyringe(CallbackData data)
{
GameObject g = data.DataObject as GameObject;
GeneralItem item = g.GetComponent <GeneralItem>();
Syringe s = item.GetComponent <Syringe>();
if (s.Container.Capacity == 20000)
{
return;
}
if (!usedSyringes.ContainsKey(s))
{
usedSyringes.Add(s, 0);
}
if (!attachedSyringes.ContainsKey(s.GetInstanceID()) && !s.hasBeenInBottle)
{
attachedSyringes.Add(s.GetInstanceID(), s.Container.Amount);
}
}
public HandleCallbackQueryCommand Handle(CallbackData data, Service service, CallbackQueryHandler handler)
{
if (!(data is SettingsCallbackData))
{
return(null);
}
if (!data.Command.EqualsAny(StringComparison.CurrentCultureIgnoreCase,
CallbackCommand.LABELS_BACK_COMMAND,
CallbackCommand.PERMISSIONS_BACK_COMMAND,
CallbackCommand.IGNORE_BACK_COMMAND,
CallbackCommand.ADDITIONAL_BACK_COMMAND
))
{
return(null);
}
HandleCallbackQueryCommand del = async sender => await handler.HandleCallbackQBackToMainMenu(sender);
return(del);
}
internal static EventArgsExtKlavye FromRawDataApp(CallbackData data)
{
var wParam = data.WParam;
var lParam = data.LParam;
const uint maskKeydown = 0x40000000; // bit 30
const uint maskKeyup = 0x80000000; // bit 31 xd
var timestamp = Environment.TickCount;
var flags = (uint)lParam.ToInt64();
var wasKeyDown = (flags & maskKeydown) > 0;
var isKeyReleased = (flags & maskKeyup) > 0;
var keyData = AppendModifierStates((Keys)wParam);
var isKeyDown = !wasKeyDown && !isKeyReleased;
var isKeyUp = wasKeyDown && isKeyReleased;
return(new EventArgsExtKlavye(keyData, timestamp, isKeyDown, isKeyUp));
}
private void ProcessCallback(CallbackData data)
{
switch (data.Event)
{
case "message":
OnMessage(data);
break;
case "conversation_started":
OnConversationStarted(data);
break;
//case MessageType.Picture:
// type = typeof(PictureMessage);
// break;
//case MessageType.Video:
// type = typeof(VideoMessage);
// break;
//case MessageType.File:
// type = typeof(FileMessage);
// break;
//case MessageType.Location:
// type = typeof(LocationMessage);
// break;
//case MessageType.Contact:
// type = typeof(ContactMessage);
// break;
//case MessageType.Sticker:
// type = typeof(StickerMessage);
// break;
//case MessageType.CarouselContent:
// throw new NotImplementedException();
//case MessageType.Url:
// type = typeof(UrlMessage);
// break;
default:
//throw new ArgumentOutOfRangeException();
break;
}
}
private void SendRequestMessage(GrainReference target, Message message, IResponseCompletionSource context, InvokeMethodOptions options)
{
message.InterfaceType = target.InterfaceType;
message.InterfaceVersion = target.InterfaceVersion;
var targetGrainId = target.GrainId;
var oneWay = (options & InvokeMethodOptions.OneWay) != 0;
message.SendingGrain = CurrentActivationAddress.Grain;
message.SendingActivation = CurrentActivationAddress.Activation;
message.TargetGrain = targetGrainId;
if (SystemTargetGrainId.TryParse(targetGrainId, out var systemTargetGrainId))
{
// If the silo isn't be supplied, it will be filled in by the sender to be the gateway silo
message.TargetSilo = systemTargetGrainId.GetSiloAddress();
message.TargetActivation = ActivationId.GetDeterministic(targetGrainId);
}
if (message.IsExpirableMessage(this.clientMessagingOptions.DropExpiredMessages))
{
// don't set expiration for system target messages.
message.TimeToLive = this.clientMessagingOptions.ResponseTimeout;
}
if (!oneWay)
{
var callbackData = new CallbackData(this.sharedCallbackData, context, message);
callbacks.TryAdd(message.Id, callbackData);
}
else
{
context?.Complete();
}
if (logger.IsEnabled(LogLevel.Trace))
{
logger.Trace("Send {0}", message);
}
MessageCenter.SendMessage(message);
}
public static void ParseCallbackQueryTest()
{
const string Query = "DateTime=2016-12-31+23%3a59%3a59&TransactionID=1234567890&OrderId=0987654321qwe" +
"&Amount=123.45&Currency=EUR&SecurityKey=036c0215b7197e33308c2a2cf219fbbf" +
"&RebillAnchor=4587fh8fhYTF5ftfytf%3d&PaymentAmount=123.45" +
"&PaymentCurrency=EUR&CardHolder=TEST+CARDHOLDER&CardNumber=411111******1111" +
"&Country=US&City=New-York&ECI=7&Code=5205&ErrorCode=3&Zip=12700&Address=Test" +
"&Phone=555-444-11-44&[email protected]&BankName=Chase&ThreedsEnrollment=0" +
"&IpCountry=RU&BinCountry=US&AuthCode=666555&GatewayTransactionId=BankTrId1" +
"&IpAddress=127.0.0.1&SpecialConditions=Validation+Required";
var callbackData = new CallbackData(HttpUtility.ParseQueryString(Query), new MerchantSettings(12345, "3844908d-4c2a-42e1-9be0-91bb5d068d22"));
Assert.AreEqual(new DateTime(2016, 12, 31, 23, 59, 59), callbackData.TransactionDate);
Assert.AreEqual(1234567890, callbackData.TransactionId);
Assert.AreEqual("0987654321qwe", callbackData.OrderInfo.OrderId);
Assert.AreEqual(123.45m, callbackData.OrderInfo.Amount);
Assert.AreEqual("EUR", callbackData.OrderInfo.Currency);
Assert.AreEqual("4587fh8fhYTF5ftfytf=", callbackData.RebillAnchor);
Assert.AreEqual(123.45, callbackData.PaymentAmount);
Assert.AreEqual("EUR", callbackData.PaymentCurrency);
Assert.AreEqual("TEST CARDHOLDER", callbackData.CardholderName);
Assert.AreEqual("411111******1111", callbackData.MaskedCardNumber);
Assert.AreEqual("US", callbackData.CountryCode);
Assert.AreEqual("New-York", callbackData.City);
Assert.AreEqual(EcommerceIndicator.MerchantResponsibility, callbackData.EcommerceIndicator);
Assert.AreEqual(5205, callbackData.DeclineCode);
Assert.AreEqual(3, callbackData.ErrorCode);
Assert.AreEqual("12700", callbackData.ZipCode);
Assert.AreEqual("Test", callbackData.StreetAddress);
Assert.AreEqual("555-444-11-44", callbackData.Phone);
Assert.AreEqual("*****@*****.**", callbackData.Email);
Assert.AreEqual("Chase", callbackData.Issuer);
Assert.AreEqual(CardEnrollmentStatus.No, callbackData.CardEnrollmentStatus);
Assert.AreEqual("RU", callbackData.IPCountryCode);
Assert.AreEqual("US", callbackData.BinCountryCode);
Assert.AreEqual("666555", callbackData.AuthorizationCode);
Assert.AreEqual("BankTrId1", callbackData.BankTransactionId);
Assert.AreEqual(IPAddress.Parse("127.0.0.1"), callbackData.IPAddress);
Assert.AreEqual("Validation Required", callbackData.SpecialConditions);
}
private static async Task <bool> IsCallbackBlocked(CallbackQuery callback, string info)
{
var message = callback.Message;
var found = _callbackBlocked.Where(c => c.MessageId == message.MessageId && c.FromId == callback.From.Id)
.ToList().FirstOrDefault();
if (found != null)
{
var countdown = (DateTime.Now - found.LastTime).Seconds;
if (countdown < _callbackBlockedTimeout)
{
await BotClient.AnswerCallbackQueryAsync(callback.Id,
$"Sabar ya kaka...\nTunggu {_callbackBlockedTimeout - countdown} dtk baru bisa tekan tombol ini lagi.",
true);
return(true);
}
return(false);
}
_log.Debug("Block Callback: {0}: {1} -- {2}", info, message.MessageId, callback.From.Id);
var callbackData = new CallbackData
{
MessageId = message.MessageId,
FromId = callback.From.Id,
Info = info,
LastTime = DateTime.Now
};
_callbackBlocked.Add(callbackData);
var timer = new Timer(_callbackBlockedTimeout * 1000);
timer.Elapsed += (ts, te) => TimerElapsed(timer, callbackData);
timer.Start();
return(false);
}
private static Int32 AddCallback(Event _event, EventNotify userMethod, Object userData)
{
Int32 callbackId;
var callbackData = new CallbackData(_event, userMethod, userData);
var gotMutex = false;
try {
gotMutex = Event.CallbackMutex.WaitOne();
do
{
callbackId = Event.CallbackId++;
} while (Event.CallbackDispatch.ContainsKey(callbackId));
Event.CallbackDispatch.Add(callbackId, callbackData);
}
finally {
if (gotMutex)
{
Event.CallbackMutex.ReleaseMutex();
}
}
return(callbackId);
}
// Token: 0x06000288 RID: 648 RVA: 0x0000E238 File Offset: 0x0000C438
protected override bool Callback(CallbackData data)
{
MouseEventExtArgs eventArgs = this.GetEventArgs(data);
if (eventArgs.IsMouseKeyDown)
{
this.ProcessDown(ref eventArgs);
}
if (eventArgs.IsMouseKeyUp)
{
this.ProcessUp(ref eventArgs);
}
if (eventArgs.WheelScrolled)
{
this.ProcessWheel(ref eventArgs);
}
if (this.HasMoved(eventArgs.Point))
{
this.ProcessMove(ref eventArgs);
}
return(!eventArgs.Handled);
}
public static async Task Execute(CallbackData data)
{
//отправить подтверждение
var receiver = data.Sender.Id;
var helpFile = client.Settings.HelpFile;
var message = new KeyboardMessage
{
Receiver = receiver,
Sender = client.BotUserData,
Text = $"Добрый день я бот который помогает учитывать данные счетчика электроэнерги. Инструкцию по использованию можно найти по адресу {helpFile.Url}.",
TrackingData = ViberBotTrackingData.Empty(),
Keyboard = KeyboardHandler.MainMenu
};
await client.SendMessage(receiver, message);
var helpLink = new LinkMessage
{
Receiver = receiver,
Sender = client.BotUserData,
Media = helpFile.Url,
};
await client.SendMessage(receiver, helpLink);
var filemessage = new FileMessage
{
Receiver = receiver,
Sender = client.BotUserData,
Media = helpFile.Url,
Size = helpFile.Size,
FileName = helpFile.FileName
};
await client.SendMessage(receiver, filemessage);
await DefaultAction.Execute(data);
}
protected override void OnCollisionEnter(Collision other)
{
base.OnCollisionEnter(other);
GameObject foundObject = GetInteractableObject(other.transform);
GeneralItem item = foundObject?.GetComponent <GeneralItem>();
if (item == null)
{
return;
}
if (item.ObjectType == ObjectType.Bottle && this.IsClean)
{
MedicineBottle bottle = item as MedicineBottle;
if (!bottle.IsClean)
{
bottle.Contamination = ContaminateState.Clean;
UISystem.Instance.CreatePopup("Lääkepullon korkki puhdistettu.", MsgType.Done);
Events.FireEvent(EventType.BottleDisinfect, CallbackData.Object(bottle));
}
}
}
private static int AddCallback(Event _event, EventNotify userMethod, object userData)
{
int callbackId;
CallbackData callbackData = new CallbackData(_event,userMethod,userData);
bool gotMutex = false;
try
{
gotMutex = CallbackMutex.WaitOne();
do
{
callbackId = CallbackId++;
} while (CallbackDispatch.ContainsKey(callbackId));
CallbackDispatch.Add(callbackId, callbackData);
}
finally
{
if (gotMutex)
CallbackMutex.ReleaseMutex();
}
return callbackId;
}
internal static IEnumerable <KeyPressEventArgsExt> FromRawDataApp(CallbackData data, IKeyEventArgs arg)
{
var wParam = data.WParam;
var lParam = data.LParam;
//http://msdn.microsoft.com/en-us/library/ms644984(v=VS.85).aspx
const uint maskKeydown = 0x40000000; // for bit 30
const uint maskKeyup = 0x80000000; // for bit 31
const uint maskScanCode = 0xff0000; // for bit 23-16
var flags = (uint)lParam.ToInt64();
//bit 30 Specifies the previous key state. The value is 1 if the key is down before the message is sent; it is 0 if the key is up.
var wasKeyDown = (flags & maskKeydown) > 0;
//bit 31 Specifies the transition state. The value is 0 if the key is being pressed and 1 if it is being released.
var isKeyReleased = (flags & maskKeyup) > 0;
if (!wasKeyDown && !isKeyReleased)
{
yield break;
}
var virtualKeyCode = (int)wParam;
var scanCode = checked ((int)(flags & maskScanCode));
const int fuState = 0;
char[] chars;
KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out chars);
if (chars == null)
{
yield break;
}
foreach (var ch in chars)
{
yield return(new KeyPressEventArgsExt(ch, arg));
}
}
public void Copy(CallbackData data)
{
if (copy == null)
{
return;
}
GeneralItem item = (GeneralItem)data.DataObject;
BreakConnection(item);
if (item.gameObject == currentObject || currentObject == null)
{
currentObject = Instantiate(copy, transform.position, transform.rotation);
GeneralItem g = Interactable.GetInteractable(currentObject.transform) as GeneralItem;
Logger.Warning("ITEM SPAWNER COPIES ITEM CONNECTION EVEN THOUGH IT ABSOLUTELY SHOULD NOT");
// Below is a budget fix, it works now but might cause problems if the system is changed
Destroy(g.GetComponent <ItemConnection>());
g.Contamination = GeneralItem.ContaminateState.Clean;
copy = currentObject;
//CopyChildStates(Interactable.GetInteractable(copy.transform) as GeneralItem, g);
}
}
protected override bool Callback(CallbackData data)
{
var eDownUp = GetDownUpEventArgs(data);
InvokeKeyDown(eDownUp);
if (KeyPress != null || KeyDownTxt != null)
{
var pressEventArgs = GetPressEventArgs(data).ToList();
foreach (var pressEventArg in pressEventArgs)
{
InvokeKeyPress(pressEventArg);
}
var downTxtEventArgs = GetDownTxtEventArgs(eDownUp, pressEventArgs);
InvokeKeyDownTxt(downTxtEventArgs);
}
InvokeKeyUp(eDownUp);
return(!eDownUp.Handled);
}
protected override bool Callback(CallbackData data)
{
var eDownUp = GetDownUpEventArgs(data);
_logger.LogInformation(new String('\t', _indentCounter++) + "→" + eDownUp.ToString());
InvokeKeyDown(eDownUp);
if (KeyPress != null)
{
var pressEventArgs = GetPressEventArgs(data);
foreach (var pressEventArg in pressEventArgs)
{
InvokeKeyPress(pressEventArg);
}
}
InvokeKeyUp(eDownUp);
_logger.LogInformation(new String('\t', --_indentCounter) + "←" + eDownUp.ToString());
//Console.Write(Environment.NewLine);
return(!eDownUp.Handled);
}
private static void InitLingo()
{
//create lingo environement
pLingoEnv = Lingo.LScreateEnvLng();
if (pLingoEnv == 0)
{
Console.WriteLine("Unable to create Lingo environment.\n");
return;
}
//create and open lingo log
int nError = Lingo.LSopenLogFileLng(pLingoEnv, "Lingo.log");
CheckError(nError);
dSatus = -1.0;
nPointersNow = -1;
// Let Lingo know we have a callback function
var cbd = new CallbackData();
var cb = new Lingo.typCallback(LngCallback.MyCallback);
nError = Lingo.LSsetCallbackSolverLng(pLingoEnv, cb, cbd);
CheckError(nError);
//// Pointer to the solution dSatus code
//nError = Lingo.LSsetPointerLng(pLingoEnv, ref dSatus, ref nPointersNow);
//CheckError(nError);
//// Point to dObjective, where Lingo will return the objective value
//nError = Lingo.LSsetPointerLng(pLingoEnv, ref dObjective, ref nPointersNow);
//CheckError(nError);
//add license
Lingo.LScreateEnvLicenseLng("lndlng12.lic", ref nError);
}
public static async Task Execute(CallbackData data)
{
var text = ((TextMessage)data.Message).Text;
var receiver = data.Sender.Id;
var trackingData = ViberBotTrackingData.Get(data.Message.TrackingData);
if (text == "no")
{
await StartSendDataAction.Execute(data);
return;
}
else if (text == "yes")
{
var flatNumber = trackingData.Data[DataField.FlatNumber.ToString()];
var flatValue = trackingData.Data[DataField.FlatValue.ToString()];
//сохранить в таблицу
Handlers.GoogleSheetsHandler.UpdateFlatData(flatNumber, flatValue, data.Sender);
await client.SendTextMessage(receiver, "Данные успешно сохранены.");
}
else
{
var message = new KeyboardMessage
{
Receiver = receiver,
Sender = client.BotUserData,
Text = $"Выберите действи из списка.",
TrackingData = ViberBotTrackingData.Build("SendDataAction", "SendDataAction", trackingData.Data),
Keyboard = KeyboardHandler.YesNoCancel()
};
await client.SendMessage(receiver, message);
}
}
protected override bool Callback(CallbackData data)
{
var e = GetEventArgs(data);
if (e.IsMouseButtonDown)
{
ProcessDown(ref e);
}
if (e.IsMouseButtonUp)
{
ProcessUp(ref e);
}
if (HasMoved(e.Point))
{
ProcessMove(ref e);
}
ProcessDrag(ref e);
return(!e.Handled);
}
private void OnTrueEnter(Interactable enteringInteractable)
{
Needle needle = enteringInteractable as Needle;
if (needle == null || !needle.Connector.HasAttachedObject)
{
return;
}
Syringe syringe = needle.Connector.AttachedInteractable as Syringe;
if (syringe == null)
{
return;
}
if (generalItem.ObjectType == ObjectType.Bottle)
{
syringe.State.On(InteractState.InBottle);
syringe.hasBeenInBottle = true;
if (!generalItem.IsClean)
{
needle.Contamination = GeneralItem.ContaminateState.Contaminated;
}
if ((G.Instance.Scene as MedicinePreparationScene).NeedleUsed)
{
TaskBase.CreateGeneralMistake("Lääkettä yritettiin ottaa uudestaan");
}
Events.FireEvent(EventType.SyringeWithNeedleEntersBottle, CallbackData.Object(syringe));
}
syringe.BottleContainer = this;
}
public static async Task Execute(CallbackData data)
{
var receiver = data.Sender.Id;
var userValue = ((TextMessage)data.Message).Text;
//TODO возможно сделать проверку номера
Regex r = new Regex(@"^\+?\d{0,2}\-?\d{4,5}\-?\d{5,6}");
if (r.IsMatch(userValue))
{
//учесть данные в поле трекинга
var trackingData = ViberBotTrackingData.Get(data.Message.TrackingData);
var contactsData = trackingData.Data[DataField.Contacts.ToString()];
trackingData.Add(DataField.Contacts.ToString(), userValue);
//запросить подтверждение
var message = new KeyboardMessage
{
Receiver = receiver,
Sender = client.BotUserData,
Text = $"Старые контактные данные - {contactsData}. Вы указали - {userValue}. Данные верны?",
TrackingData = ViberBotTrackingData.Build("СonfirmSendContactsAction", "SendContactsAction", trackingData.Data),
Keyboard = KeyboardHandler.YesNoCancel()
};
await client.SendMessage(receiver, message);
}
else
{
//неверное значение
await client.SendTextMessage(receiver, BotError.BadValue);
}
}
internal static IEnumerable <KeyPressEventArgsExt> FromRawDataGlobal(CallbackData data, IKeyEventArgs arg)
{
var wParam = data.WParam;
var lParam = data.LParam;
if ((int)wParam != Messages.WM_KEYDOWN && (int)wParam != Messages.WM_SYSKEYDOWN)
{
yield break;
}
var keyboardHookStruct =
(KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
var virtualKeyCode = keyboardHookStruct.VirtualKeyCode;
var scanCode = keyboardHookStruct.ScanCode;
var fuState = keyboardHookStruct.Flags;
if (virtualKeyCode == KeyboardNativeMethods.VK_PACKET)
{
var ch = (char)scanCode;
yield return(new KeyPressEventArgsExt(ch, arg, keyboardHookStruct.Time));
}
else
{
char[] chars;
KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out chars);
if (chars == null)
{
yield break;
}
foreach (var current in chars)
{
yield return(new KeyPressEventArgsExt(current, arg, keyboardHookStruct.Time));
}
}
}
internal static IEnumerable <EventArgsTuşBasışı> FromRawDataApp(CallbackData data)
{
var wParam = data.WParam;
var lParam = data.LParam;
const uint maskKeydown = 0x40000000; // bit 30 için
const uint maskKeyup = 0x80000000; // bit 31 için xd
const uint maskScanCode = 0xff0000; // bit 23-16 için
var flags = (uint)lParam.ToInt64();
var wasKeyDown = (flags & maskKeydown) > 0;
var isKeyReleased = (flags & maskKeyup) > 0;
if (!wasKeyDown && !isKeyReleased)
{
yield break;
}
var virtualKeyCode = (int)wParam;
var scanCode = checked ((int)(flags & maskScanCode));
const int fuState = 0;
char[] chars;
KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out chars);
if (chars == null)
{
yield break;
}
foreach (var ch in chars)
{
yield return(new EventArgsTuşBasışı(ch));
}
}
protected void OnCallback(CallbackData callbackData)
{
if (this.CallbackReceived != null)
{
this.CallbackReceived(callbackData);
}
}
void growl_NotificationCallback(Growl.Connector.Response response, Growl.Connector.CallbackData callbackData)
{
CallbackData cd = new CallbackData(callbackData);
OnCallback(cd);
}
private static int AddCallback(Event _event, EventNotify userMethod, object userData)
{
int callbackId;
CallbackData callbackData = new CallbackData(_event,userMethod,userData);
bool gotMutex = false;
try
{
gotMutex = CallbackMutex.WaitOne();
do
{
callbackId = CallbackId++;
} while (CallbackDispatch.ContainsKey(callbackId));
CallbackDispatch.Add(callbackId, callbackData);
}
finally
{
if (gotMutex)
CallbackMutex.ReleaseMutex();
}
return callbackId;
}
WebRequest SetupRequest (Uri uri, string method, CallbackData callbackData)
{
callback_data = callbackData;
WebRequest request = GetWebRequest (uri);
request.Method = DetermineMethod (uri, method);
foreach (string header in Headers.AllKeys)
request.Headers.SetHeader (header, Headers [header]);
return request;
}
/// <summary>
/// Registers a callback, so that if a packet arrives that matches the given xpath expression,
/// the callback fires. Use <see cref="AddNamespace"/> to add namespace prefixes.
/// </summary>
/// <example>jc.AddCallback("self::iq[@type='result']/roster:query", new ProtocolHandler(GotRoster));</example>
/// <param name="xpath">The xpath expression to search for</param>
/// <param name="cb">The callback to call when the xpath matches</param>
/// <returns>A guid that can be used to unregister the callback</returns>
public Guid AddCallback(string xpath, ProtocolHandler cb)
{
CallbackData cbd = new CallbackData(xpath, cb);
m_callbacks.Add(cbd);
return cbd.Guid;
}
public CallbackService(CallbackData data)
{
_data = data;
}
public void UploadStringAsync (Uri address, string method, string data, object userToken)
{
if (address == null)
throw new ArgumentNullException ("address");
if (data == null)
throw new ArgumentNullException ("data");
lock (locker) {
SetBusy ();
try {
CallbackData cbd = new CallbackData (userToken, encoding.GetBytes (data));
request = SetupRequest (address, method, cbd);
request.BeginGetRequestStream (new AsyncCallback (UploadStringRequestAsyncCallback), cbd);
}
catch (Exception e) {
WebException wex = new WebException ("Could not start operation.", e);
OnUploadStringCompleted (
new UploadStringCompletedEventArgs (null, wex, false, userToken));
}
}
}
WebRequest SetupRequest (Uri uri, string method, CallbackData callbackData)
{
callback_data = callbackData;
WebRequest request = GetWebRequest (uri);
// do not send a relative URI to Determine method
request.Method = DetermineMethod (request.RequestUri, method);
// copy headers to the request - some needs special treatments
foreach (string header in Headers) {
switch (header.ToLowerInvariant ()) {
case "content-length":
long cl = 0;
if (Int64.TryParse (Headers [header], out cl) && (cl >= 0))
request.ContentLength = cl;
break;
case "accept":
case "content-type":
// this skip the normal/user validation on headers
request.Headers.SetHeader (header, Headers [header]);
break;
default:
request.Headers [header] = Headers [header];
break;
}
}
// original headers are removed after calls
Headers.Clear ();
return request;
}
public static int MyCallback(int pLingoEnv, int nReserved, IntPtr pMyData)
{
// Lingo callback function to display the current iteration count
CallbackData cb = new CallbackData();
Marshal.PtrToStructure(pMyData, cb);
int nIterations = -1, nErr;
//回调函数
nErr = Lingo.LSgetCallbackInfoLng(pLingoEnv,
Lingo.LS_IINFO_ITERATIONS_LNG, ref nIterations);// LS_IINFO_VARIABLES_NONLINEAR_LNG LS_IINFO_ITERATIONS_LNG
if (nErr == Lingo.LSERR_NO_ERROR_LNG && nIterations != cb.nIterations)
{
cb.nIterations = nIterations;
if (nIterations % 100 == 0)
{
Console.WriteLine("Iteration count = {0}", nIterations);
}
}
Marshal.StructureToPtr(cb, pMyData, true);
return 0;
}
public void OnCallback(CallbackData message)
{
Called = message;
}
private static void InitLingo()
{
//create lingo environement
pLingoEnv = Lingo.LScreateEnvLng();
if (pLingoEnv == 0)
{
Console.WriteLine("Unable to create Lingo environment.\n");
return;
}
//create and open lingo log
int nError = Lingo.LSopenLogFileLng(pLingoEnv, "Lingo.log");
CheckError(nError);
dSatus = -1.0;
nPointersNow = -1;
// Let Lingo know we have a callback function
var cbd = new CallbackData();
var cb = new Lingo.typCallback(LngCallback.MyCallback);
nError = Lingo.LSsetCallbackSolverLng(pLingoEnv, cb, cbd);
CheckError(nError);
//// Pointer to the solution dSatus code
//nError = Lingo.LSsetPointerLng(pLingoEnv, ref dSatus, ref nPointersNow);
//CheckError(nError);
//// Point to dObjective, where Lingo will return the objective value
//nError = Lingo.LSsetPointerLng(pLingoEnv, ref dObjective, ref nPointersNow);
//CheckError(nError);
//add license
Lingo.LScreateEnvLicenseLng("lndlng12.lic", ref nError);
}
private IEnumerator IEHideLoading(CallbackData callbackData)
{
yield return new WaitForSeconds (callbackData.TimeOut);
HideLoading ();
if (callbackData.Callback != null)
{
callbackData.Callback ();
}
}
