private void RetrieveTableColumns(List <DbTableInfo> tables, CancellationTokenSource cancellationTokenSource)
{
if (cancellationTokenSource == null)
{
cancellationTokenSource = new CancellationTokenSource();
}
OpenConnection();
var status = new StatusInformation {
Total = tables.Count()
};
try
{
foreach (var table in tables)
{
RetrieveTableColumns(table, status);
status.Progress++;
if (cancellationTokenSource.IsCancellationRequested)
{
break;
}
}
}
catch
{
throw;
}
finally
{
CloseConnection();
}
}
public MainWindow()
{
InitializeComponent();
// check for WinPcap
if (Pcap.Version.Contains("pcap is not installed"))
{
MessageBox.Show("Please install the latest version of WinPcap (http://www.winpcap.org/).", "WinPcap",
MessageBoxButton.OK, MessageBoxImage.Error);
Close();
return;
}
var app = Assembly.GetEntryAssembly().GetName();
// display current assembly version in windows' title
Title += String.Format(" {0}.{1}", app.Version.Major, app.Version.Minor);
// bind debugging information to GUI control
DebugInformation.Bind(DebugInfoBox);
// bind status information to GUI control
StatusInformation.Bind(CurrentStatus);
}
public async Task <CommandStatus> Handle(CancelApplicationCommand message, CancellationToken cancellationToken)
{
var application = await this._applicationRepository.GetAsync(message.ApplicationNumber);
if (application == null)
{
return(new CommandStatus {
CommandResult = StandardCommandResult.NOT_FOUND
});
}
var statusInfo = new StatusInformation
{
Title = "Canceled",
Description = "Your request is cancelled.",
Html = ""
};
application.Status = ApplicationStatus.Canceled;
application.StatusInformation = statusInfo;
application.CancelationReason = message.CancelationReason;
application.CancelationComment = message.CancelationComment;
_applicationRepository.Update(application);
await _applicationRepository.UnitOfWork.SaveEntitiesAsync();
try
{
await _auditClient.WriteLogEntry(AuditLogEntryAction.Cancel, AuditLogEntryStatus.Success, "application", application.ApplicationNumber, "Canceled application", new { });
}
catch (Exception ex)
{
_logger.LogError(ex, "Audit error in CancelApplicationCommandHandler");
}
var msgBuilder = _messageEventFactory.CreateBuilder("offer", "offer-canceled")
.AddHeaderProperty("application-number", message.ApplicationNumber.GetApplicationNumber())
.AddBodyProperty("cancelation-reason", application.CancelationReason);
var commercialDetails = _applicationRepository.GetCommercialDetails(message.ApplicationNumber);
if (application.LeadId != null)
{
var stat = Enum.GetName(typeof(ApplicationStatus), application.Status);
msgBuilder.AddBodyProperty("status", stat)
.AddBodyProperty("lead-id", application.LeadId);
}
if (commercialDetails != null)
{
foreach (var key in commercialDetails.Keys)
{
msgBuilder.AddBodyProperty(key, commercialDetails[key]);
}
}
_logger.LogInformation("Sending message {BrokerMessageName} event to broker on topic {BrokerTopicName} for application: {ApplicationNumber}", "offer-canceled", "offer", message.ApplicationNumber);
_eventBus.Publish(msgBuilder.Build());
return(new CommandStatus {
CommandResult = StandardCommandResult.OK
});
}
public StatusInformation Add(StatusInformation value)
{
return(new StatusInformation()
{
ConnectingCount = ConnectingCount + value.ConnectingCount,
ConnectedCount = ConnectedCount + value.ConnectedCount,
DisconnectedCount = DisconnectedCount + value.DisconnectedCount,
ReconnectingCount = ReconnectingCount + value.ReconnectingCount,
FaultedCount = FaultedCount + value.FaultedCount,
TargetConnectionCount = TargetConnectionCount + value.TargetConnectionCount,
});
}
public void RetrieveTableColumns(DbTableInfo table, StatusInformation statusInfo)
{
if (table.Columns != null && table.Columns.Count > 0)
{
return;
}
if (statusInfo == null)
{
statusInfo = new StatusInformation();
}
statusInfo.Message = $"Retrieving columns for table: {table.Name}";
StatusChanged?.Invoke(statusInfo, null);
var connectionWasNull = (_connection == null);
if (connectionWasNull)
{
OpenConnection();
}
table.Columns = new List <DbColumnInfo>();
var command = _connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = $"SELECT Column_Name, Ordinal_Position, Is_Nullable, Data_Type, Character_Maximum_Length" +
$" FROM Information_Schema.Columns" +
$" WHERE TABLE_SCHEMA + '.' + TABLE_NAME = '{table.Name}'" +
$" ORDER BY ORDINAL_POSITION";
var reader = command.ExecuteReader();
while (reader.Read())
{
table.Columns.Add(new DbColumnInfo
{
Name = (string)reader["Column_Name"],
Index = ((int)reader["Ordinal_Position"]) - 1,
IsNullable = ((string)reader["Is_Nullable"] == "YES"),
DataType = (string)reader["Data_Type"],
CharacterMaxLength = (reader["Character_Maximum_Length"] is DBNull ? 0 : (int)reader["Character_Maximum_Length"])
});
}
reader.Close();
statusInfo.Message = $"Retrieving columns for table: {table.Name} - DONE";
StatusChanged?.Invoke(statusInfo, null);
if (connectionWasNull)
{
CloseConnection();
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public StatusInformation GatherStatusInformation( )
{
StatusInformation si = new StatusInformation( );
lock ( this ) {
foreach ( string key in this.Channels.Keys ) {
Channel<TSettings, TTransparentFlow, TRealFlow, THostRuntimeSettings> channel = this.Channels[key];
if ( !channel.Terminated ) {
si.Channels.Add( channel.GatherStatusInformation( ) );
}
}
}
return si;
}
public async Task <IActionResult> RejectApplication([FromRoute] long applicationNumber)
{
_logger.LogInformation("Updating application status for application {applicationNumber} to {status}", applicationNumber, "Rejected");
var statusInfo = new StatusInformation
{
Title = "Reject",
Description = "Your request is rejected.",
Html = ""
};
UpdateApplicationStatusCommand updateStatusCommand = new UpdateApplicationStatusCommand {
Status = ApplicationStatus.Rejected, StatusInformation = statusInfo
};
var result = await UpdateApplicationStatus(applicationNumber, updateStatusCommand);
return(result);
}
public void HistoryStatusTest()
{
// Arrange
int random = new Random().Next(111);
int random2 = new Random().Next(111);
DateTime now = DateTime.Now;
// Act
HistoryStatus historyStatus = this.CreateHistoryStatus();
StatusInformation StatusOrder = new StatusInformation();
StatusOrder.Id = random;
historyStatus.Id = random;
historyStatus.Created = now;
historyStatus.StatusOrder = StatusOrder;
// Assert
Assert.IsTrue(historyStatus.Id == random);
Assert.IsTrue(historyStatus.Created == now);
Assert.IsTrue(historyStatus.StatusOrder.Id == StatusOrder.Id);
}
public void StatusInformationTest()
{
// Arrange
string test = Guid.NewGuid().ToString();
int random = new Random().Next(111);
int random2 = new Random().Next(111);
// Act
StatusInformation statusInformation = this.CreateStatusInformation();
statusInformation.Id = random;
statusInformation.Description = test;
statusInformation.Group = random2;
// Assert
Assert.IsTrue(statusInformation.Id == random);
Assert.IsTrue(statusInformation.Description == test);
Assert.IsTrue(statusInformation.Group == random2);
}
private void ButtonStartStop_Click(object sender, RoutedEventArgs e)
{
if (!PacketDispatcher.Instance.IsStarted())
{
if (!PacketDispatcher.Instance.Bind((NetworkInterface)ComboInterfaces.SelectedItem))
{
MessageBox.Show("Please select an interface with a valid gateway address.", "Interface error", MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
PacketDispatcher.Instance.Start();
ButtonStartStop.Content = "Stop";
StatusInformation.ChangeStatus("Status: traffic fiddler started!", true);
}
else
{
PacketDispatcher.Instance.Stop();
ButtonStartStop.Content = "Start";
StatusInformation.ChangeStatus("Status: traffic fiddler stopped!", false);
}
}
internal DMXTimeseries(TimeseriesSourceKey sourceKey, TimeseriesKey seriesKey)
{
SourceKey = sourceKey;
SeriesKey = seriesKey;
Status = new StatusInformation();
}
public ApplicationDetailsView()
{
StatusInformation = new StatusInformation();
}
