public void ProcessInput(Object sender, FileSystemEventArgs args)
{
Calls.Add(new ProcessInputCall()
{
Sender = sender, Args = args
});
}
public ControllerDescriptor(Type t, HttpServer server, bool wrapped = false)
{
if (server == null || t == null)
{
throw new ArgumentNullException("Type and Server parameter cannot be null");
}
UseWrap = wrapped;
Server = server;
ControllerType = t;
List <MethodInfo> ms = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
.Where(x => !IgnoreControllerMethodAttribute.HasAttribute(x)).ToList();
foreach (MethodInfo m in ms)
{
CallDescriptor desc = new CallDescriptor(this, m);
string name = m.Name.ToLower();
if (desc.Descriptor != null && !string.IsNullOrEmpty(desc.Descriptor.MethodName))
{
name = desc.Descriptor.MethodName;
}
Calls.Add(m.Name.ToLower(), desc);
if (desc.Descriptor != null && desc.Descriptor.IsDefault && !Calls.ContainsKey(""))
{
Calls.Add("", desc);
}
}
}
public override DataStructure Merge(DataStructure dataStructure)
{
if (dataStructure is Hook hook)
{
if (hook.IsMain)
{
if (IsMain) // both are main
{
return(null); // error
}
else // just new one is main
{
hook.Calls = Calls; // set reference
Calls = new List <Hook>(); // clear reference
hook.Calls.Add(this); // add this as a call too
return(hook); // replace the current ds with the new hook in the final ds list
}
}
else // new one isn't main
{
Calls.Add(hook);
}
return(this); // this has merged
}
return(base.Merge(dataStructure));
}
public void Call(IRecursiveCallHandler callBlock, DocRange range)
{
if (!Calls.ContainsKey(callBlock))
{
Calls.Add(callBlock, new List <DocRange>());
}
Calls[callBlock].Add(range);
}
public async Task HandleMessage(object message, IMessageProcessingContext context)
{
Calls.Add(DateTime.Now);
ExpectedIdFound = context.GetMessageId() == "1234";
await context.Complete().ConfigureAwait(false);
}
public void OnAddCall(Call call)
{
Calls.Add(call);
var handler = CallAdded;
handler?.Invoke(Calls[Calls.Count - 1]);
}
public async Task HandleMessage(object message, IMessageProcessingContext context)
{
var ExpectedTenantId = "CDBFB8A7-FEFF-4559-BFFB-301A2CB4E0BE";
ExpectedTenantIdFound = ExpectedTenantId.Equals(context.GetTenantId(), StringComparison.InvariantCultureIgnoreCase);
Calls.Add(DateTime.Now);
await context.Complete().ConfigureAwait(false);
}
public override void VisitUsingStatement(UsingStatementSyntax node)
{
Visit(node.Declaration);
var typeInUsing = _lastCalledMethodReturnType;
Visit(node.Expression);
Visit(node.Statement);
Calls.Add(ApiCall.OfMethodInvocation(typeInUsing, "Dispose"));
}
public async Task HandleMessage(object message, IMessageProcessingContext context)
{
var testMessage = message as TestMessage1;
ExpectedContentFound = testMessage.TestProperty == "巴黎";
Calls.Add(DateTime.Now);
await context.Complete().ConfigureAwait(false);
}
public void EndCall(CallInfo call)
{
call.CallPrice = CalculateCost(call);
Balance -= call.CallPrice;
CallInfo c = new CallInfo(call.CallNumber, call.ReceivingNumber, call.BeginCall, call.CallingAnswerType);
c.CallPrice = call.CallPrice;
c.EndCall = call.EndCall;
Calls.Add(c);
}
public void EmitCall(string name)
{
Buffer.Position = Length;
writer.Write((byte)Opcode.Call16);
Calls.Add((int)Buffer.Position, name);
writer.Write((short)0x0bad);
writer.Flush();
Length = (int)Buffer.Position;
}
internal void Add(StationCall call)
{
if (call == null)
{
throw new ArgumentNullException(nameof(call));
}
if (Calls.Contains(call))
{
return;
}
Calls.Add(call);
}
public void Add(StationCall call)
{
if (call == null)
{
throw new ArgumentNullException(nameof(call));
}
if (Calls.Contains(call))
{
return;
}
call.Train = this;
call.SequenceNumber = lastSequenceNumber++;
Calls.Add(call);
}
private void DiscoverRoutes()
{
var methods = ControllerType.GetMethods();
foreach (var mt in methods)
{
var routeAttr = mt.GetCustomAttribute <RouteAttribute>();
if (null == routeAttr)
{
continue;
}
ApiServiceCall call = new ApiServiceCall(this, mt);
Calls.Add(call);
}
}
public async Task <bool> AddCall(Call call)
{
lock (dbLock)
{
using (CnContext context = new CnContext())
{
context.Calls.Add(call);
Package package = GetPackageByLineId(call.LineID);
PackageDetails packDet = GetPackageDetailsByPackageId(package.ID);
packDet.UsedMinutes += call.Duration;
UpdateDBPackageDetails(packDet);
context.SaveChanges();
}
}
Calls.Add(call);
return(true);
}
private void AddNewCallEvent(VATRPCallEvent callEvent, bool refreshNow = false)
{
if (FindCallEvent(callEvent) != null)
{
return;
}
long time_uts;
var lastSeenDate = ServiceManager.Instance.ConfigurationService.Get(Configuration.ConfSection.GENERAL,
Configuration.ConfEntry.LAST_MISSED_CALL_DATE, string.Empty);
if (!long.TryParse(lastSeenDate, out time_uts))
{
time_uts = 0;
}
var contact = _contactService.FindContact(new ContactID(callEvent.RemoteParty.TrimSipPrefix(), IntPtr.Zero));
lock (this.Calls)
{
Calls.Add(new HistoryCallEventViewModel(callEvent, contact));
if (callEvent.Status == VATRPHistoryEvent.StatusType.Missed)
{
if (callEvent.EndTime.Ticks > time_uts)
{
_unseenMissedCallsCount++;
if (MissedCallsCountChanged != null)
{
MissedCallsCountChanged(callEvent, EventArgs.Empty);
}
}
}
}
ServiceManager.Instance.ConfigurationService.Set(Configuration.ConfSection.GENERAL,
Configuration.ConfEntry.LAST_MISSED_CALL_DATE, DateTime.UtcNow.Ticks.ToString());
if (refreshNow)
{
CallsListView.Refresh();
}
}
public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
{
try {
var ctorSymbol = _model.GetTypeInfo(node).Type;
if (node.ArgumentList != null)
{
foreach (var argumentSyntax in node.ArgumentList.Arguments)
{
argumentSyntax.Accept(this);
}
}
var properTypeName = GetProperTypeName(ctorSymbol);
Calls.Add(ApiCall.OfConstructor(properTypeName));
_lastCalledMethodReturnType = properTypeName;
}
catch (Exception e) {
Console.WriteLine(e.Message);
}
}
public async Task HandleMessage(object message, IMessageProcessingContext context)
{
var testMessage = message as TestMessage1;
Calls.Add(DateTime.UtcNow);
using (var connection = new NpgsqlConnection("Server=localhost;Port=6000;User Id=postgres;Password=test;Database=postgres"))
{
connection.Open();
using (var tx = connection.BeginTransaction())
{
tx?.Commit();
}
}
await context.Complete();
CommittedTransactions.Add(DateTime.UtcNow);
}
private void ProcessObject(Instruction instruction)
{
var operand = instruction.Operand as MethodReference;
if (operand != null)
{
var bfMethod = !(operand.DeclaringType is GenericInstanceType)
? _cache.GetBfMethod(operand)
: GetBfMethod(operand);
if (bfMethod != null)
{
_typesUsed.Add(bfMethod.Type);
_typesUsed.Add(bfMethod.ReturnType);
_typesUsed.AddRange(bfMethod.ParameterTypes);
_typesUsed.AddRange(_cache.GetTypeCollection(operand));
Calls.Add(bfMethod);
bfMethod.CalledBy.Add(this);
}
}
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
foreach (var argumentSyntax in node.ArgumentList.Arguments)
{
argumentSyntax.Accept(this);
}
if (node.Expression is IdentifierNameSyntax)
{
var methodName = (IdentifierNameSyntax)node.Expression;
var method = _model.GetSymbolInfo(methodName).Symbol;
if (method == null || method.Name.StartsWith("_"))
{
return;
}
Calls.Add(ApiCall.OfMethodInvocation(GetProperTypeName(method), method.Name));
UpdateLastCalledMethod(method);
}
else
{
node.Expression.Accept(this);
}
UpdateLastCalledMethod(_model.GetSymbolInfo(node).Symbol);
}
private void getInformationAboutCalls()
{
string sqlInquiryString = $"SELECT * FROM leads_and_calls WHERE login = '******'";
using var connection = new MySqlConnection(createConnection.ConnectionString());
connection.Open();
MySqlCommand command = new MySqlCommand(sqlInquiryString, connection);
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
Calls.Add(new AboutCall
{
ClientInformation = reader["client_phone_number"].ToString() + " " +
reader["create_lead_date"].ToString() + " " + reader["lead_stats"].ToString(),
CallMadeDate = reader["lead_call_date"].ToString(),
Login = reader["login"].ToString(),
CallTime = reader["call_time"].ToString()
});
}
}
}
public void Calling(object sender, ICallEventArgs e)
{
if ((Subscribers.ContainsKey(e.TargetNumber) && e.TargetNumber != e.Number) || e is EventOfEndCallArgs)
{
CallInfo callInfo = null;
Port targetPort;
Port port;
int number = 0;
int targetNumber = 0;
if (e is EventOfEndCallArgs)
{
var callListFirst = Calls.First(x => x.Id.Equals(e.Id));
if (callListFirst.Number == e.Number)
{
targetPort = Subscribers[callListFirst.TargetNumber].Item1;
port = Subscribers[callListFirst.Number].Item1;
number = callListFirst.Number;
targetNumber = callListFirst.TargetNumber;
}
else
{
port = Subscribers[callListFirst.TargetNumber].Item1;
targetPort = Subscribers[callListFirst.Number].Item1;
targetNumber = callListFirst.Number;
number = callListFirst.TargetNumber;
}
}
else
{
targetPort = Subscribers[e.TargetNumber].Item1;
port = Subscribers[e.Number].Item1;
targetNumber = e.TargetNumber;
number = e.Number;
}
if (targetPort.State == States.StateOfPort.Connect && port.State == StateOfPort.Connect)
{
var portContract = Subscribers[number];
var targetPortContract = Subscribers[targetNumber];
if (e is EventOfAnswerArgs)
{
var answerArgs = (EventOfAnswerArgs)e;
if (!answerArgs.Id.Equals(Guid.Empty) && Calls.Any(x => x.Id.Equals(answerArgs.Id)))
{
callInfo = Calls.First(x => x.Id.Equals(answerArgs.Id));
}
if (callInfo != null)
{
targetPort.AnswerCall(answerArgs.Number, answerArgs.TargetNumber, answerArgs.StateOfCall, callInfo.Id);
}
else
{
targetPort.AnswerCall(answerArgs.Number, answerArgs.TargetNumber, answerArgs.StateOfCall, callInfo.Id);
}
}
if (e is EventOfCallArgs)
{
if (portContract.Item2.Subscriber.Account > portContract.Item2.Tariff.PricePerMinute)
{
var callArgs = (EventOfCallArgs)e;
if (callArgs.Id.Equals(Guid.Empty))
{
callInfo = new CallInfo(
callArgs.Number,
callArgs.TargetNumber,
DateTime.Now);
Calls.Add(callInfo);
}
if (!callArgs.Id.Equals(Guid.Empty) && Calls.Any(x => x.Id.Equals(callArgs.Id)))
{
callInfo = Calls.First(x => x.Id.Equals(callArgs.Id));
}
if (callInfo != null)
{
targetPort.IncomingCall(callArgs.Number, callArgs.TargetNumber, callInfo.Id);
}
else
{
targetPort.IncomingCall(callArgs.Number, callArgs.TargetNumber, callInfo.Id);
}
}
else
{
Console.WriteLine("There is not enough money on the terminal {0}!", e.Number);
}
}
if (e is EventOfEndCallArgs)
{
var args = (EventOfEndCallArgs)e;
callInfo = Calls.First(x => x.Id.Equals(args.Id));
callInfo.EndOfCall = DateTime.Now;
var sumOfCall = portContract.Item2.Tariff.PricePerMinute * TimeSpan.FromTicks((callInfo.EndOfCall - callInfo.StartOfCall).Ticks).TotalMinutes;
callInfo.CostOfCall = (int)sumOfCall;
targetPortContract.Item2.Subscriber.WithdrawMoney(callInfo.CostOfCall);
targetPort.AnswerCall(args.Number, args.TargetNumber, StateOfCall.Reject, callInfo.Id);
}
}
}
else if (!Subscribers.ContainsKey(e.TargetNumber))
{
Console.WriteLine("Trying to call a non-existent number".ToUpper());
}
else
{
Console.WriteLine("Trying to call your own number".ToUpper());
}
}
public void AddCall(ICallInfo info)
{
Calls.Add(info);
}
public int Run(string a, string b)
{
Calls.Add(Invocation.Split(a, b));
return(88);
}
/// <summary>
/// We received a web_service object to process... this function will
/// determine if the request is for a new call or an existing call.
/// Additionally, if the request is a hangup, we should delete the call
/// from our list.
/// </summary>
/// <param name="ws"> The web_service request to process</param>
///
public void ProcessRequest(RESTapi.web_service ws)
{
T currentCall = null;
RESTapi.@event @event = ws.Item as RESTapi.@event;
if (@event.type == RESTapi.event_type.keepalive)
{
LoggingSingleton.Instance.Message(LogType.Library, LogLevel.Debug1,
"CallDispatcher::ProcessRequest : Keepalive received");
return;
}
String response = RestHelpers.RESTapiToXML(ws, typeof(RESTapi.web_service));
LoggingSingleton.Instance.Message(LogType.Library, LogLevel.Debug1,
"CallDispatcher::ProcessRequest : Received web service request :\n{0}",
response);
if (@event.type == RESTapi.event_type.incoming)
{
/// Note that we probably should check that this is not an existing
/// call / resource id rather than assuming...
///
currentCall = new T()
{
Dispatcher = this as ICallDispatcher <CallBase>,
Direction = "inbound",
ResourceID = @event.resource_id,
ResourceType = @event.resource_type,
CallState = CallBase.CallStateType.Ringing,
};
foreach (RESTapi.event_data data in @event.event_data)
{
switch (data.name.ToLower())
{
case "caller_uri": currentCall.CallerUri = data.value; break;
case "called_uri": currentCall.CalledUri = data.value; break;
case "uri": currentCall.Uri = data.value; break;
case "name": currentCall.Name = data.value; break;
}
}
}
else
{
foreach (T call in Calls)
{
if (call.ResourceID == @event.resource_id)
{
currentCall = call;
break;
}
}
}
if (currentCall != null)
{
/// The following is a way of calling a protected / private member
/// of a class - kind of like using "friend class" in C++. It uses
/// reflection.
///
MethodInfo handleEventMethod = currentCall.GetType().GetMethod("HandleEvent", BindingFlags.Instance | BindingFlags.NonPublic);
switch (@event.type)
{
case RESTapi.event_type.incoming:
Calls.Add(currentCall);
handleEventMethod.Invoke(currentCall, new object[] { ws });
break;
case RESTapi.event_type.hangup:
handleEventMethod.Invoke(currentCall, new object[] { ws });
Calls.Remove(currentCall);
break;
default:
handleEventMethod.Invoke(currentCall, new object[] { ws });
break;
}
}
} /* ProcessRequest() */
public int Run(string a)
{
Calls.Add(Invocation.Split(a));
return(89);
}
public int Run(IList <string> args)
{
Calls.Add(Invocation.List(args));
return(99);
}
public int Run()
{
Calls.Add(Invocation.Split());
return(79);
}
protected override void Dispose(bool disposing)
{
Calls.Add("Dispose (bool disposing)");
}
public virtual void AddCall(Call call)
{
Calls.Add(call);
call.Project = this;
}
