/// <summary>
///
/// </summary>
/// <param name="connectionId"></param>
/// <param name="bitrate"></param>
/// <param name="framerate"></param>
public void ChangeVideoParameters(string connectionId, ulong?bitrate, uint?framerate)
{
if (!Senders.TryGetValue(connectionId, out var sender))
{
return;
}
RTCRtpSendParameters parameters = sender.GetParameters();
foreach (var encoding in parameters.encodings)
{
if (bitrate != null)
{
encoding.maxBitrate = bitrate;
}
if (framerate != null)
{
encoding.maxFramerate = framerate;
}
}
sender.SetParameters(parameters);
}
/// <summary>
/// Boardcast the message to all message accounts by speicifed sender , subject and body
/// </summary>
/// <param name="sender">The registered message sender object name.</param>
/// <param name="subject">The message subject.</param>
/// <param name="body">The message body.</param>
/// <param name="from">Identines who send this message .</param>
public void Boardcast(string sender, string subject, string body, string from)
{
if (string.IsNullOrEmpty(sender))
{
throw new ArgumentNullException("sender");
}
if (string.IsNullOrEmpty(from))
{
throw new ArgumentNullException("from");
}
if (!Senders.ContainsKey(sender))
{
throw new Exception(string.Format("{0} message sender not found.", sender));
}
Senders[sender].Boardcast(new Message()
{
Body = body, Subject = subject, Creation = DateTime.Now, ContentType = "text/html"
}, from);
}
public void Send(string sender, string from, string to, Message msg)
{
if (string.IsNullOrEmpty(sender))
{
throw new ArgumentNullException("sender");
}
if (string.IsNullOrEmpty(from))
{
throw new ArgumentNullException("from");
}
if (string.IsNullOrEmpty(to))
{
throw new ArgumentNullException("to");
}
if (!Senders.ContainsKey(sender))
{
throw new Exception(string.Format("{0} message sender not found.", sender));
}
Senders[sender].Send(msg, from, to);
}
public async Task <IActionResult> RegisterRider(Rider rider)
{
long number;
var email = rider.Email;
rider.Pass_word = HashAndSalt.HashSalt(rider.Pass_word);
using (IDbConnection dbConnection = Connection)
{
string sQuery0 = "SELECT FirstName FROM Rider WHERE Email = @email";
dbConnection.Open();
String result = dbConnection.QueryFirstOrDefault <String>(sQuery0, new { @Email = email });
dbConnection.Close();
if (string.IsNullOrEmpty(result))
{
rider.VerifiCode = VerifiCodeGenarator.CreateRandomPassword();
rider.Validated = false;
string sQuery = "INSERT INTO Rider(FirstName,LastName,Pass_word,Email,MobileNo,VerifiCode,Validated,LicenseNo,Nic)" +
"VALUES(@FirstName,@LastName,@Pass_word,@Email,@MobileNo,@VerifiCode,@Validated,@LicenseNo,@Nic)";
dbConnection.Open();
dbConnection.Execute(sQuery, rider);
dbConnection.Close();
string sQuery1 = "SELECT RiderId FROM Rider WHERE Email = @email";
dbConnection.Open();
String result2 = dbConnection.QueryFirstOrDefault <String>(sQuery1, new { @Email = email });
number = Int64.Parse(result2);
Image toupload = new Image(rider.image, number);
Senders emailsender = new Senders();
await emailsender.SendEmail(email, rider.VerifiCode);
return(await UploadImage(toupload));
}
return(new ConflictResult());
}
}
public override async Task Execute()
{
IReceive arv = null;
if (Receivers?.Count == 1)
{
arv = Receivers[0];
}
if (arv == null)
{
if (AllReceiversAsync)
{
arv = new AsyncReceiverMultiple(Receivers.Select(it => it.Value).ToArray());
}
else
{
arv = new SyncReceiverMultiple(Receivers.Select(it => it.Value).ToArray());
}
}
await arv.LoadData();
bool existsVar = (RuntimeParameters?.Length ?? 0) > 0;
string[] nameObjectsWithVariables = null;
if (existsVar)
{
nameObjectsWithVariables = RuntimeParameters
.SelectMany(it => it.NameObjectsToApplyTo)
.Select(it => it.NameObjectToApplyTo.ToLowerInvariant())
.Distinct()
.ToArray();
}
IRow[] data = arv.valuesRead;
foreach (var filterKV in FiltersAndTransformers)
{
var var = filterKV.Value as TransformIntoVariable;
if (var != null)
{
if (!existsVar)
{
//TODO:log
continue;
}
var param = RuntimeParameters.FirstOrDefault(it => it.VariableName == var.VariableName);
if (param == null)
{
throw new ArgumentException($"in runtime parameters I cannot find variable {var.VariableName}");
}
await var.Run();
variables[param] = var.Result;
continue;
}
bool hasVar = (nameObjectsWithVariables?.Length > 0) && (nameObjectsWithVariables.Contains(filterKV.Value.Name.ToLowerInvariant()));
if (hasVar)
{
TransformPropertyFromVar(filterKV.Value);
}
//TODO: see also IFilterTransformer
var transform = filterKV.Value as ITransform;
if (transform != null)
{
transform.valuesRead = data;
await transform.Run();
data = transform.valuesTransformed;
continue;
}
var filter = filterKV.Value as IFilter;
if (filter != null)
{
filter.valuesRead = data;
await filter.Run();
data = filter.valuesTransformed;
continue;
}
Debug.Assert(false, "base object is not found");
//@class.Log(LogLevel.Error,0,$"base object is not found",null,null);
Debug.Assert(false, "filter is not found");
}
//await SenderData(data);
if (Senders.Count == 0)
{
return;
}
ISend send = null;
if (Senders.Count == 1)
{
send = Senders[0];
}
if (send == null)
{
if (AllSendersAsync)
{
send = new ASyncSenderMultiple(Senders.Select(it => it.Value).ToArray());
}
else
{
send = new SyncSenderMultiple(Senders.Select(it => it.Value).ToArray());
}
}
send.valuesToBeSent = data;
await send.Send();
}
public void InitCredential()
{
_searchCondition = new SearchCondition();
SearchCondition condition = null;
if (!string.IsNullOrEmpty(Senders))
{
List <string> mSenders = Senders.Split(';').ToList();
condition = SearchCondition.From(mSenders[0]);
for (int i = 1; i < mSenders.Count; i++)
{
string sender = mSenders[i];
if (string.IsNullOrEmpty(sender))
{
continue;
}
condition = condition.Or(SearchCondition.From(sender));
}
}
SearchCondition conditionSubject = null;
if (!string.IsNullOrEmpty(Subjects))
{
List <string> mSubjects = Subjects.Split(';').ToList();
conditionSubject = SearchCondition.Subject(mSubjects[0]);
for (int i = 1; i < mSubjects.Count; i++)
{
string sub = mSubjects[i];
if (string.IsNullOrEmpty(sub))
{
continue;
}
conditionSubject = conditionSubject.Or(SearchCondition.Subject(sub));
}
}
_searchCondition = SearchCondition.Unseen();
if (condition != null)
{
_searchCondition = _searchCondition.And(condition);
}
if (conditionSubject != null)
{
_searchCondition = _searchCondition.And(conditionSubject);
}
try
{
if (_email != null)
{
_email.Logout();
}
}
catch
{
}
try
{
if (!string.IsNullOrEmpty(Credential.UserName) && !string.IsNullOrEmpty(Credential.Host))
{
_email = new ImapClient(Credential.Host, Credential.Port, Credential.UserName, Credential.Password, AuthMethod.Login, Credential.Ssl);
}
}
catch (Exception ex)
{
Console.Write(ex.Message);
throw ex;
}
}
public async Task <bool> ResumeFromCheckpoint(LeaseManager leaseManager)
{
var start = stopwatch.Elapsed;
try
{
// kick off the load
var storageConnectionString = configuration.StorageConnectionString;
var loadtask = AzureBlobStorageStateManager.Load(storageConnectionString, HostLogger, processId);
// register host services
application.HostServices.RegisterSend(Send);
application.HostServices.RegisterApplicationLogger(ApplicationLogger);
application.HostServices.RegisterRuntimeLogger(RuntimeLogger);
// if (_configuration.AppInsightsInstrumentationKey != null)
// _application.HostServices.RegisterTelemetryListener(new ApplicationInsightsTelemetryListener(_configuration.AppInsightsInstrumentationKey, "eventhubs"));
if (blobTelemetryListener != null)
{
application.HostServices.RegisterTelemetryListener(blobTelemetryListener);
}
// read the checkpoint
var checkpointedState = await loadtask;
SetDeploymentTimestamp(checkpointedState.DeploymentTimestamp);
seenClock = checkpointedState.SeenClock;
ourClock = checkpointedState.OurClock;
var state = checkpointedState.State;
lastCheckpointedSequenceNumber = checkpointedState.Version;
HostLogger.LogDebug($"Resuming at position {lastCheckpointedSequenceNumber}");
Connections.ResumeFrom(lastCheckpointedSequenceNumber);
// build the process
IProcess process = application.MakeProcess(processId);
if (state == null)
{
process.FirstStart();
}
else
{
process.Restore(state, out var label);
}
process.BecomePrimary();
// start the message receiving loop
long lastProcessedPosition = 0;
int iterationCount = 0;
int dedupCount = 0;
int receiveCount = 0;
int loopbackCount = 0;
int clientCount = 0;
TimeSpan lastReport = stopwatch.Elapsed;
long lastReportedPosition = 0;
while (true)
{
iterationCount++;
if (lastProcessedPosition > lastReportedPosition && stopwatch.Elapsed - lastReport > TimeSpan.FromSeconds(15))
{
HostLogger.LogInformation($"progress to v{lastProcessedPosition} after {stopwatch.Elapsed.TotalSeconds:f2}s, {receiveCount + dedupCount + loopbackCount + clientCount} messages ({receiveCount} new, {loopbackCount} loopback, {clientCount} client, {dedupCount} deduped) in {iterationCount} batches");
lastReportedPosition = lastProcessedPosition;
lastReport = stopwatch.Elapsed;
CombinedLogger.Flush();
}
try
{
bool outOfTime = stopwatch.Elapsed > configuration.TimeLimit;
IEnumerable <EventData> eventData = outOfTime ? null :
await Connections.ProcessReceiver.ReceiveAsync(configuration.MaxReceiveBatchSize, iterationCount == 1?TimeSpan.FromSeconds(10) : configuration.ReceiveWaitTime);
if (eventData == null)
{
HostLogger.LogTrace($"{ DateTime.UtcNow:o} Received nothing. {Connections.ProcessReceiver.RuntimeInfo.LastSequenceNumber}");
if (process.RequestsOutstanding() && !outOfTime)
{
HostLogger.LogDebug($"continue for outstanding requests.");
CombinedLogger.Flush();
continue;
}
else if (lastProcessedPosition > lastCheckpointedSequenceNumber)
{
await Task.WhenAll(Senders.Select(s => s.WaitForCurrentWorkToBeServiced()).ToList());
lastCheckpointedSequenceNumber = lastProcessedPosition;
await Save(storageConnectionString, process, leaseManager);
HostLogger.LogDebug($"continue for saving snapshot.");
continue;
}
else
{
// no more work to do here
HostLogger.LogInformation($"{(outOfTime ? "out of time" : "done")} after {stopwatch.Elapsed.TotalSeconds}s, {receiveCount + dedupCount + loopbackCount + clientCount} messages ({receiveCount} new, {loopbackCount} loopback, {clientCount} client, {dedupCount} deduped) in {iterationCount} batches");
CombinedLogger.Flush();
return(!outOfTime);
}
}
foreach (var ed in eventData)
{
var body = ed.Body;
var message = ProcessMessage.Deserialize(body.Array);
HostLogger.LogTrace($"{DateTime.UtcNow:o} Received {message}");
if (!message.IsExternalRequest && message.DeploymentTimestamp < deploymentTimestamp)
{
HostLogger.LogDebug($"Ignoring message from earlier deployment {message.DeploymentTimestamp}");
}
else if (!message.IsExternalRequest && message.DeploymentTimestamp > deploymentTimestamp)
{
HostLogger.LogError($"****** MISSING STATE ERROR process state is from older deployment, should have been initialized for new one! {message.DeploymentTimestamp} != {deploymentTimestamp}");
}
else if (message.IsSequenced &&
seenClock.HasSeen(message.Source, message.LastClock.Value))
{
dedupCount++;
HostLogger.LogTrace($"Deduping: {message}");
}
else if (message.IsExternalRequest)
{
clientCount++;
HostLogger.LogTrace($"Processing: {message}");
// deserialize content
List <IMessage> payload;
MemoryStream stream = new MemoryStream(message.Payload);
using (var binaryDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
payload = (List <IMessage>)payloadSerializerLoopback.ReadObject(binaryDictionaryReader);
}
// Iterate
foreach (var m in payload)
{
process.ProcessMessage(m);
}
}
else if (message.IsLoopback)
{
loopbackCount++;
HostLogger.LogTrace($"Processing: {message}");
// deserialize content
List <IMessage> payload;
MemoryStream stream = new MemoryStream(message.Payload);
using (var binaryDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
payload = (List <IMessage>)payloadSerializerLoopback.ReadObject(binaryDictionaryReader);
}
// Iterate
foreach (var m in payload)
{
process.ProcessMessage(m);
}
}
else
{
receiveCount++;
HostLogger.LogTrace($"Processing: {message}");
// deserialize content
List <KeyValuePair <long, IMessage> > payload;
MemoryStream stream = new MemoryStream(message.Payload);
using (var binaryDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
payload = (List <KeyValuePair <long, IMessage> >)payloadSerializer.ReadObject(binaryDictionaryReader);
}
// Iterate
foreach (var kvp in payload)
{
if (!seenClock.HasSeen(message.Source, kvp.Key))
{
process.ProcessMessage(kvp.Value);
}
}
// Update seen clock.
seenClock.Set(message.Source, message.LastClock.Value);
}
lastProcessedPosition = ed.SystemProperties.SequenceNumber;
// Checkpoint and commit every X.
if (lastProcessedPosition > lastCheckpointedSequenceNumber &&
lastProcessedPosition % configuration.CheckpointInterval == configuration.CheckpointInterval - 1)
{
await Task.WhenAll(Senders.Select(s => s.WaitForCurrentWorkToBeServiced()).ToList());
// Checkpoint state.
lastCheckpointedSequenceNumber = lastProcessedPosition;
await Save(storageConnectionString, process, leaseManager);
}
}
}
catch (System.OperationCanceledException)
{
HostLogger.LogDebug($"receive returned OperationCanceledException, scheduling retry!");
continue;
}
}
}
finally
{
if (this.collectHostEvents)
{
this.blobTelemetryListener.OnApplicationEvent(processId, invocationId.ToString(), $"Process {processId}", "", OperationSide.Caller, OperationType.Host, (stopwatch.Elapsed - start).TotalMilliseconds);
}
}
}
private void frmLoader_Load(object sender, EventArgs e)
{
lblUser.Text = lblUser.Text.Replace("{{ USERNAME }}", Session.Username);
lblRank.Text = lblRank.Text.Replace("{{ RANK }}", Session.Rank);
Senders.Products();
}
public Header(Id id, Party sender)
: this(id)
{
Senders.Add(sender);
}
public async Task <IActionResult> SendEmail(Email email)
{
Senders sender = new Senders();
return(await(sender.SendEmail(email.Message, "xdcfvg")));
}
public Sender GetSender(TcpClient client)
{
var sender = Senders.Where(p => p.Tcp != null && p.Tcp.Equals(client)).FirstOrDefault();
return(sender);
}
private void btnLogin_Click(object sender, EventArgs e)
{
this.Enabled = false;
Senders.Authentication(this, txtUsername.Text.Trim(), txtPassword.Text, Local.HWID);
}
/// <summary>
/// 构造服务器接收命令事件
/// </summary>
public ServerCommandReciver(Senders.ServerConsole sender, Command command, String[] args)
{
this.Sender = sender;
this.Command = command;
this.Args = args;
}
async void SendMail(String mail, string VerifiCode)
{
Senders emailsender = new Senders();
await emailsender.SendEmail(mail, VerifiCode);
}
