public ContraCoreClient(string hostname)
{
Task.Run(() => Read(hostname));
OnConnected += Setup;
OnConnected += () =>
{
Connected = true;
Common.Logger.Info("Connected to ContraCore");
ConnectionComplete.Set();
OnStatusChange?.Invoke();
};
OnDisconnected += () =>
{
Connected = false;
GeneratingRules = false;
GeneratingOUI = false;
ReloadingBlacklist = false;
ReloadingWhitelist = false;
OnGenRulesChange?.Invoke();
OnGenOUIChange?.Invoke();
OnReloadBlacklistChange?.Invoke();
OnReloadWhitelistChange?.Invoke();
Common.Logger.Info("Disconnected from ContraCore");
OnStatusChange?.Invoke();
};
}
public void Start()
{
if (Status == ServiceControllerStatus.Stopped)
{
WindowsService.StartServiceAsync(OpenALPRMilestoneService);
Status = WindowsService.GetServiceStatus(OpenALPRMilestoneService);
OnStatusChange?.Invoke(this, new EventArgs());
}
}
protected void ChangeStatus(PXActionStatus status, string desc = "")
{
Console.WriteLine(desc);
Status = status;
StatusDesc = desc;
context.Status = status;
context.StatusDesc = desc;
context.UpdatedAt = DateTimeOffset.Now;
OnStatusChange?.Invoke(this, new OnStatusChangeEventArgs(status, desc));
}
private void Action_OnStatusChange(object sender, OnStatusChangeEventArgs e)
{
OnStatusChange?.Invoke(sender, e);
if (e.Status == PXActionStatus.Finished)
{
var action = (IPXAction)sender;
Trace.TraceInformation($"Action [{action.context.Key}]({action.context.Url}) Finished, remove from list.");
actions.Remove(action);
}
}
public async Task ConnectionStopAsync()
{
await Task.Run(() =>
{
if (_client != null && _client.IsConnected)
{
_client.Disconnect();
OnStatusChange?.Invoke(GetConnectionStatus(), _info);
}
});
}
private bool CommitTransatction(T item, Func <T, bool> action)
{
bool startState = IsBusy;
bool b = action(item);
if (IsBusy != startState)
{
OnStatusChange?.Invoke(IsBusy);
}
return(b);
}
/// <summary>
/// Updates the tracking status of the PCF.
/// </summary>
/// <param name="newStatus">The new status to update the PCF with.</param>
private void UpdateStatus(Status newStatus)
{
Status oldStatus = this.CurrentStatus;
this.CurrentStatus = newStatus;
if ((newStatus != oldStatus && newStatus != PCF.Status.Stable) || newStatus == PCF.Status.Updated)
{
OnStatusChange?.Invoke(newStatus, this);
}
}
private void ActionM_OnStatusChange(object sender, OnStatusChangeEventArgs e)
{
var action = (IPXAction)sender;
Storage.SetAction(action.context);
if (e.Status == PXActionStatus.Finished)
{
Storage.CollectTemp(action.context);
}
OnStatusChange?.Invoke(sender, e);
}
public void SetStatus(ConditionID conditionId)
{
if (Status != null)
{
return;
}
Status = ConditionsDB.Conditions[conditionId];
Status?.OnStart?.Invoke(this);
StatusChanges.Enqueue($"{_baseTeras.Name} {Status.StatMessage}!");
OnStatusChange?.Invoke();
}
////////////// STATUS FUNCTIONS ////////////////
/// <summary>
/// Set a status condition on monster.
/// </summary>
/// <param name="conditionID">Condition to set.</param>
public void SetStatus(ConditionID conditionID)
{
// Only one status effect at a time.
if (Status != null)
{
StatusChanges.Enqueue($"{Base.Name} is already being affected by another condition!");
return;
}
Status = ConditionDB.Conditions[conditionID];
Status?.OnStart?.Invoke(this);
if (Status != null)
{
StatusChanges.Enqueue($"{Base.Name} {Status.StartMessage}");
}
OnStatusChange?.Invoke();
}
protected NetPeerBase(NetPeerConfiguration config)
{
this.Config = config;
this.baseHandlers = new Dictionary <NetIncomingMessageType, Action <NetIncomingMessage> >();
handlers = new Action <byte, NetIncomingMessage> [byte.MaxValue + 1];
// Add some default handlers
SetBaseHandler(NetIncomingMessageType.Data, (msg) =>
{
byte id = msg.PeekByte(); // Peek ID bye.
var handler = handlers[id]; // Find handler. May be null.
if (handler == null)
{
Warn($"Received data message of ID {id}, but not handler exists to process it!");
}
else
{
msg.ReadByte(); // Consume the ID byte.
handler.Invoke(id, msg);
}
});
SetBaseHandler(NetIncomingMessageType.DebugMessage, (msg) =>
{
Log(msg.ReadString());
});
SetBaseHandler(NetIncomingMessageType.WarningMessage, (msg) =>
{
Warn(msg.ReadString());
});
SetBaseHandler(NetIncomingMessageType.ErrorMessage, (msg) =>
{
Error(msg.ReadString());
});
SetBaseHandler(NetIncomingMessageType.StatusChanged, (msg) =>
{
var status = (NetConnectionStatus)msg.ReadByte();
if (LogStatusChange)
{
Trace($"Status: {msg.SenderEndPoint}, {status}");
}
OnStatusChange?.Invoke(msg.SenderConnection, status, msg);
});
}
private void ConnectionStart()
{
if (Configurations.Uri != null)
{
try
{
Connection = Configurations.GetConnection();
Connection.Start();
Session = Connection.CreateSession();
Destination = Session.GetTopic(Configurations.Topic);
IMessageConsumer consumer = Session.CreateConsumer(Destination);
consumer.Listener += Consumer_Listener;
OnConnectionSucess?.Invoke(Connection);
}
catch (Exception ex)
{
Error = ex;
}
}
OnStatusChange?.Invoke();
}
private async void DeviceOnConnectionStatusChanged(BluetoothLEDevice device, object args)
{
if (device.ConnectionStatus == BluetoothConnectionStatus.Connected)
{
//Get stuff up and running
OnStatusChange?.Invoke("Connected");
if (
this.NotificationSourceCharacteristic.CharacteristicProperties.HasFlag(
GattCharacteristicProperties.Notify))
{
this.NotificationSourceCharacteristic.ValueChanged += NotificationSourceCharacteristicOnValueChanged;
// Set the notify enable flag
try
{
await
this.NotificationSourceCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify);
}
catch (Exception ex)
{
}
}
this.DataSourceCharacteristic.ValueChanged += DataSourceCharacteristicOnValueChanged;
await
this.DataSourceCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify);
}
if (device.ConnectionStatus == BluetoothConnectionStatus.Disconnected)
{
//Stop doing stuff
this.DataSourceCharacteristic.ValueChanged -= DataSourceCharacteristicOnValueChanged;
this.NotificationSourceCharacteristic.ValueChanged -= NotificationSourceCharacteristicOnValueChanged;
OnStatusChange?.Invoke("Disconnected");
}
}
public void PollAndUpdate()
{
PreviousEstate = Estate;
Estate = new Estate(gocdService.GetPipelines());
OnStatusChange?.Invoke();
foreach (var pipeline in Estate.Pipelines)
{
var previousPipeline = PreviousEstate.Pipelines.FirstOrDefault(p => p.Name == pipeline.Name);
if (previousPipeline == null)
{
continue;
}
if ((previousPipeline.Status == PipelineStatus.Building || previousPipeline.Status == PipelineStatus.Passed) && pipeline.Status == PipelineStatus.Failed)
{
pipeline.JustFailed = true;
}
}
if (Estate.Pipelines.Any(p => p.JustFailed))
{
OnBuildFailed?.Invoke();
}
}
public async Task ConnectionStartAsync(Uri uri)
{
await Task.Run(() =>
{
try
{
_info = new IBusService.ConnectionInfo(uri, MqttConfiguration.TopicMatcher(uri));
_error = null;
_client = new MqttClient(uri.Host, uri.Port, false, null, null, MqttSslProtocols.None)
{
ProtocolVersion = MqttProtocolVersion.Version_3_1
};
var code = default(byte);
if (string.IsNullOrEmpty(uri.UserInfo))
{
code = _client.Connect(Guid.NewGuid().ToString());
}
else
{
var bUri = new UriBuilder(uri);
code = _client.Connect(Guid.NewGuid().ToString(), bUri.UserName, bUri.Password);
}
_client.Subscribe(new[] { _info.Topic }, new[] { MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE });
_client.MqttMsgPublishReceived += DefaultClient_MqttMsgPublishReceived;
OnConnection?.Invoke(code);
}
catch (Exception e)
{
_error = e;
}
finally
{
OnStatusChange?.Invoke(GetConnectionStatus(), _info);
}
});
}
internal void PushCommand(Command cmd)
{
if (cmd.Source == CommandSource.Client)
{
return;
}
switch (cmd.Token)
{
case "JCH":
{
var jch = cmd as Server_JCH_ChannelJoin;
var character = Connection.GetOrCreateCharacter(jch.Character.Identity);
if (!_Characters.Contains(character))
{
_Characters.Add(character);
}
if (!string.IsNullOrEmpty(jch.Title))
{
_Title = jch.Title;
Joined = true;
}
else
{
OnUserJoin?.Invoke(this, new ChannelUserEntryEventArgs(this, character, jch));
}
}
return;
case "LCH":
{
var lch = cmd as Server_LCH_ChannelLeave;
var character = GetCharacter(lch.Character);
_Characters.Remove(character);
if (character.Name == Connection.LocalCharacter.Name)
{
Dispose();
}
else
{
OnUserLeave?.Invoke(this, new ChannelUserEntryEventArgs(this, character, lch));
}
}
return;
case "ICH":
{
var ich = cmd as Server_ICH_ChannelInitialData;
_ChannelMode = ich.Mode;
Joined = true;
foreach (var user in ich.Users)
{
var ch = GetCharacter(user.Identity);
if (!_Characters.Contains(ch))
{
_Characters.Add(ch);
}
}
}
return;
case "COL":
{
var col = cmd as Server_COL_ChannelGetOPs;
foreach (var op in col.OPs)
{
if (!string.IsNullOrWhiteSpace(op))
{
_OPs.Add(GetCharacter(op));
}
}
}
return;
case "CDS":
{
var cds = cmd as Server_CDS_ChannelChangeDescription;
OnDescriptionChange?.Invoke(this, new ChannelEntryEventArgs <string>(this, cds.Description, cds));
_Description = cds.Description;
}
return;
case "RMO":
{
var rmo = cmd as Server_RMO_ChannelSetMode;
OnModeChange?.Invoke(this, new ChannelEntryEventArgs <ChannelMode>(this, rmo.Mode, rmo));
_ChannelMode = rmo.Mode;
}
return;
case "CSO":
{
var cso = cmd as Server_CSO_ChannelSetOwner;
OnOwnerChange?.Invoke(this, new ChannelEntryEventArgs <Character>(this, GetCharacter(cso.Character), cso));
_OwnerName = cso.Character;
}
return;
case "RST":
{
var rst = cmd as Server_RST_ChannelSetStatus;
OnStatusChange?.Invoke(this, new ChannelEntryEventArgs <ChannelStatus>(this, rst.Status, rst));
_Status = rst.Status;
}
return;
case "COA":
{
var coa = cmd as Server_COA_ChannelMakeOP;
var character = GetCharacter(coa.Character);
_OPs.Add(character);
OnOPAdded?.Invoke(this, new ChannelUserEntryEventArgs(this, character, coa));
}
return;
case "COR":
{
var cor = cmd as Server_COR_ChannelRemoveOP;
var character = GetCharacter(cor.Character);
_OPs.Remove(character);
OnOPRemoved?.Invoke(this, new ChannelUserEntryEventArgs(this, character, cor));
}
return;
case "CKU":
{
var cku = cmd as Server_CKU_ChannelKickCharacter;
var character = GetCharacter(cku.Character);
_Characters.Remove(character);
OnUserKicked?.Invoke(this, new ChannelAdminActionEventArgs(this, character, GetCharacter(cku.OP), cku));
}
return;
case "CBU":
{
var cbu = cmd as Server_CBU_ChannelBanCharacter;
var character = GetCharacter(cbu.Character);
_Characters.Remove(character);
_Banlist.Add(character);
OnUserBanned?.Invoke(this, new ChannelAdminActionEventArgs(this, character, GetCharacter(cbu.OP), cbu));
}
return;
case "CUB":
{
var cub = cmd as Server_CUB_ChannelUnbanCharacter;
var character = GetCharacter(cub.Character);
_Banlist.Remove(character);
OnUserUnbanned?.Invoke(this, new ChannelAdminActionEventArgs(this, character, GetCharacter(cub.OP), cub));
}
return;
case "CTU":
{
var ctu = cmd as Server_CTU_ChannelTimeoutCharacter;
var character = GetCharacter(ctu.Character);
_Characters.Remove(character);
OnUserTimedout?.Invoke(this, new ChannelAdminActionEventArgs(this, character, GetCharacter(ctu.OP), ctu));
}
return;
case "MSG":
{
var msg = cmd as Server_MSG_ChannelChatMessage;
OnChatMessage?.Invoke(this, new ChannelUserMessageEventArgs(this, GetCharacter(msg.Character), msg.Message, msg));
} return;
case "LRP":
{
var lrp = cmd as Server_LRP_ChannelLFRPMessage;
OnLFRPMessage?.Invoke(this, new ChannelUserMessageEventArgs(this, GetCharacter(lrp.Character), lrp.AD, lrp));
} return;
case "RLL":
{
var rll = cmd as Server_RLL_ChannelRollMessage;
OnRollMessage?.Invoke(this, new ChannelUserMessageEventArgs(this, GetCharacter(rll.Character), rll.Message, rll));
} return;
case "SYS":
{
var sys = cmd as Server_SYS_ChatSYSMessage;
OnSYSMessage?.Invoke(this, new ChannelEntryEventArgs <string>(this, sys.Message, sys));
} return;
}
}
/// <summary>
/// Remove status condition.
/// </summary>
public void RemoveStatus()
{
Status = null;
OnStatusChange?.Invoke();
}
private void PollAndUpdate()
{
Estate = new Estate(gocdService.GetPipelines());
OnStatusChange?.Invoke();
}
private void RaiseStatusChange()
{
OnStatusChange?.Invoke(this, new TestStatusChangedEventArgs(_test));
}
public void CureStatusCondition()
{
Status = null;
OnStatusChange?.Invoke();
}
public void Initialize()
{
Status = WindowsService.GetServiceStatus(OpenALPRMilestoneService);
OnStatusChange?.Invoke(this, new EventArgs());
}
private void TriggerStatusChange()
{
OnStatusChange?.Invoke(this);
}
private void EventWatcher_EventArrived(object sender, EventArrivedEventArgs e)
{
var newEvent = e.NewEvent;
if (newEvent == null)
{
return;
}
if (!(newEvent["ClassName"].ToString().Equals("CCM_Application") || newEvent["ClassName"].ToString().Equals("CCM_SoftwareUpdate")))
{
return;
}
try
{
var eventObject = (IResultObject) new WmiResultObject(newEvent);
var target = eventObject["TargetInstancePath"].StringValue;
var targetparts = target.Split(',');
switch (eventObject["ActionType"].IntegralValue)
{
case 23:
OnStatusChange?.Invoke(this, new CcmWmiEventargument
{
Id = targetparts[0].Replace("CCM_Application.Id=", string.Empty).Replace("\"", string.Empty),
Revision = targetparts[1].Replace("Revision=", string.Empty).Replace("\"", string.Empty),
IsMachineTarget = targetparts[2].Replace("IsMachineTarget=", string.Empty).Equals("1"),
});
break;
case 12:
if (_dt12 > DateTime.Now)
{
return;
}
_dt12 = DateTime.Now.AddMinutes(4);
OnNewUpdate?.Invoke(this, new NewUpdateEventArg {
ActionId = eventObject["ActionType"].IntegralValue
});
break;
case 21:
case 28:
if (_dt21 > DateTime.Now || _isEvaluation)
{
return;
}
_isEvaluation = true;
if (!string.IsNullOrEmpty(eventObject["TargetInstancePath"].StringValue))
{
var app = CcmUtils.GetSpecificApp(new ScheduledObject
{
ObjectId = targetparts[0].Replace("CCM_Application.Id=", string.Empty).Replace("\"", string.Empty),
Revision = targetparts[1].Replace("Revision=", string.Empty).Replace("\"", string.Empty),
});
if (app != null)
{
if (app.Deadline > DateTime.Now.AddMinutes(30))
{
_dt21 = DateTime.Now.AddMinutes(4);
OnNewApplication?.Invoke(this, new NewApplicationEventArg {
ActionId = eventObject["ActionType"].IntegralValue
});
}
}
}
_isEvaluation = false;
break;
}
eventObject.Dispose();
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
