public void AppWireSerializerTest003_SerializeCustomerAppEvent_ExpectNoExceptions()
{
var sz = new AppWireSerializer <AppEventArgs <Customer> >();
Customer entity = new Customer("CustomerMasterRepositoryTest001_cname", "1-800-start");
AppEventArgs <Customer> evt = new AppEventArgs <Customer>()
{
beforeChange = new Customer(),
afterChange = entity,
appEventType = AppEventType.Insert
};
this.testLogger.LogDebug($"*** Original:\n{entity.ToJson()}");
sz.Serialize(evt);
var serialized = sz.GetSerializedData();
sz.Reset();
var reconstructed = sz.Deserialize(serialized);
this.testLogger.LogDebug($"*** Deserialized:\n{reconstructed.ToJson()}");
Assert.Equal(evt.id, reconstructed.id);
}
public async Task DeleteAllAsync()
{
_logger.LogTrace(LoggingEvents.Trace, $"Deleting all entities");
var updateTimestamp = DateTime.UtcNow;
var entities = await this.GetAsync();
var filter = Builders <T> .Filter.Eq("deleted", false);
var update = Builders <T> .Update
.Set("deleted", true)
.Set("updatedDate", updateTimestamp);
var result = await this._collection.UpdateManyAsync(filter, update);
foreach (var entity in entities)
{
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Delete;
e.beforeChange = entity;
e.afterChange = e.beforeChange.Clone();
e.afterChange.updatedDate = updateTimestamp;
e.afterChange.deleted = true;
this.OnEvent(AppEventType.Delete, e);
this.OnAnyEvent(e);
}
_logger.LogTrace(LoggingEvents.Trace, $"Deleted {result.ModifiedCount} entities.");
}
public async Task DeleteAsync(ObjectId entityid)
{
_logger.LogTrace(LoggingEvents.Trace, $"Deleting entity with entityid:{entityid.ToString()}");
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Delete;
e.beforeChange = await this.GetByEntityIdAsync(entityid);
e.afterChange = e.beforeChange.Clone().Clone();
var updateTimestamp = DateTime.UtcNow;
e.afterChange.deleted = true;
e.afterChange.updatedDate = updateTimestamp;
var filter = Builders <T> .Filter.Eq("entityid", entityid);
var update = Builders <T> .Update
.Set("deleted", true)
.Set("updatedDate", updateTimestamp);
var result = await _collection.UpdateOneAsync(filter, update);
_logger.LogDebug($"{result.MatchedCount} records matched. {result.ModifiedCount} records updated");
this.OnEvent(AppEventType.Delete, e);
this.OnAnyEvent(e);
return;
}
protected internal override void OnLoad()
{
base.OnLoad();
var arg = new AppEventArgs()
{
Sender = this,
};
foreach (var i in HandlerTypes.Values)
{
if (arg.Cancel)
{
break;
}
try
{
i.OnStart(arg);
}
catch (Exception ex)
{
log.Error(string.Format("Osgi:执行OnStart(AppEventArgs)时异常！类型:'{0}'", i.GetType().FullName), ex);
}
}
}
private void participantUpdate(object sender, AppEventArgs e)
{
if (e.EventType == AppEvent.ParticipantAdded)
{
int idc = Int32.Parse(e.Data.ToString());
cursaListbox.BeginInvoke(new UpdateCursaListboxCallback(this.updateCursaListbox), new Object[] { cursaListbox, idc });
}
}
public void AppEventHandler(object sender, AppEventArgs e)
{
controller = sender as GenericController;
lblHelloWorld = controller.GetViewControl("lblHelloWorld") as Label;
helloWorldService = ServiceFactory.getService <IHelloWorld>();
Page_Load(sender, e);
}
private AppEventArgs <Customer> __getEvent()
{
AppEventArgs <Customer> evt = new AppEventArgs <Customer>();
evt.beforeChange = new Customer("testentity", "1-800-PHONE");
evt.afterChange = new Customer("testentity", "1-800-UPDATED");
evt.appEventType = AppEventType.Update;
return(evt);
}
public void AppEventHandler(object sender, AppEventArgs e)
{
controller = sender as GenericController;
lblUserName = controller.GetViewControl("lblUserName") as Label;
lbUserId = controller.GetViewControl("lbUserId") as Label;
interfaceService = ServiceFactory.getService <ICTL>();
Page_Load(sender, e);
}
public async Task KafkaMessagingTest001_PublishConsumeUsingStringMessage_ExpectNoExceptions()
{
this.testLogger.LogDebug("*** KafkaMessagingTest001 ***");
var topic = $"{TestTopic}_Test001_{Guid.NewGuid()}";
AppEventArgs <Customer> evt = this.__getEvent();
var kProducer = new app.common.messaging.simple.KafkaProducer <AppEventArgs <Customer> >(this.loggerFactory);
var producerConfig = new Dictionary <string, object>
{
{ "bootstrap.servers", this.serverAddress }
};
kProducer.Setup(producerConfig);
await kProducer.ProduceAsync(topic, evt);
kProducer.Dispose();
var kConsumer = new app.common.messaging.simple.KafkaConsumer(this.loggerFactory);
var customerConfig = new Dictionary <string, object>
{
{ "bootstrap.servers", this.serverAddress },
{ "auto.commit.interval.ms", 5000 },
{ "auto.offset.reset", "earliest" },
{ "group.id", "test-consumer-group" }
};
var consumeTopics = new List <string>()
{
topic
};
kConsumer.Setup(customerConfig, consumeTopics);
//Consume yield returns a list of messages
foreach (var message in kConsumer.Consume(this.cts.Token))
{
this.testLogger.LogDebug($"Response: Partition:{message.Partition}, Offset:{message.Offset} :: {message.Message}");
var payload = AppEventArgs <Customer> .FromJson(message.Message);
if (payload.id == evt.id)
{
this.testLogger.LogDebug($"Received EventID:{evt.id} from Kafka");
// break;
this.cts.Cancel();
}
}
kConsumer.Dispose();
}
private void Controller_Update(object sender, AppEventArgs e)
{
this.Invoke(() =>
{
var index = IndexOf(e.App.Id);
if (index < 0)
{
return;
}
SetValue(this.dataGrid.Rows[index], e.App);
});
}
public void Init()
{
if (this._init)
{
throw new InvalidOperationException();
}
this._init = true;
//Configura o evento dos botões editar e remover
this.dataGrid.CellContentClick += (object sender, DataGridViewCellEventArgs e) =>
{
if (e.RowIndex < 0 || e.RowIndex > this.dataGrid.Rows.Count)
{
return;
}
var colunmName = this.dataGrid.Columns[e.ColumnIndex].Name;
if (colunmName != "edit" && colunmName != "delete")
{
return;
}
var args = new AppEventArgs(this[e.RowIndex]);
if (colunmName == "edit")
{
this.OnAskEdit?.Invoke(this, args);
return;
}
this.OnAskRemove?.Invoke(this, args);
};
//Configura o evento de remoção de app
this.controller.OnAppRemoved += (sender, e) => this.Invoke(() =>
{
int index = this.IndexOf(e.Id);
if (index < 0)
{
return;
}
this.dataGrid.Rows.RemoveAt(index);
});
this.controller.OnAppAdded += (sender, e) => this.Invoke(() => this.dataGrid.Rows.Add(this.CreateRow(e.App)));
this.controller.OnConfigChanged += Controller_Update;
this.controller.OnStateChanged += Controller_Update;
this.Reload();
}
public async Task AddAsync(T entity)
{
_logger.LogTrace(LoggingEvents.Trace, $"Adding entity");
entity.updatedDate = DateTime.UtcNow;
await this._collection.InsertOneAsync(entity);
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Insert;
e.afterChange = entity;
this.OnEvent(AppEventType.Insert, e);
this.OnAnyEvent(e);
}
public async Task AddAsync(List <T> entities)
{
_logger.LogTrace(LoggingEvents.Trace, $"Adding {entities.Count} entities");
entities.ForEach(c => c.updatedDate = DateTime.UtcNow);
await this._collection.InsertManyAsync(entities);
entities.ForEach(c => {
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Insert;
e.afterChange = c;
this.OnEvent(AppEventType.Insert, e);
this.OnAnyEvent(e);
});
}
public async Task UpdateAsync(T entity)
{
_logger.LogTrace(LoggingEvents.Trace, $"Updating entity with entityid:{entity.entityid.ToString()}");
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Update;
e.beforeChange = await this.GetByEntityIdAsync(entity.entityid);
entity.updatedDate = DateTime.UtcNow;
var filter = Builders <T> .Filter.Eq("entityid", entity.entityid);
var result = await this._collection.FindOneAndReplaceAsync(filter, entity);
e.afterChange = entity;
this.OnEvent(AppEventType.Update, e);
this.OnAnyEvent(e);
}
public async Task <long> DeleteAsync(Expression <Func <T, bool> > predicate)
{
_logger.LogTrace(LoggingEvents.Trace, $"Deleting entities matching specified criteria");
var updateTimestamp = DateTime.UtcNow;
var entities = await this.GetAsync(predicate);
var filter = Builders <T> .Filter.And(
predicate,
Builders <T> .Filter.Eq("deleted", false)
);
var update = Builders <T> .Update
.Set("deleted", true)
.Set("updatedDate", updateTimestamp);
var result = await this._collection.UpdateManyAsync(filter, update);
if (result.ModifiedCount != entities.Count)
{
var msg = $"Not all items could be deleted - Criteria matched for:{entities.Count} ... however only {result.ModifiedCount} were deleted";
this._logger.LogWarning(msg);
throw new Exception(msg);
}
foreach (var entity in entities)
{
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Delete;
e.beforeChange = entity;
e.afterChange = e.beforeChange.Clone();
e.afterChange.updatedDate = updateTimestamp;
e.afterChange.deleted = true;
this.OnEvent(AppEventType.Delete, e);
this.OnAnyEvent(e);
}
return(result.ModifiedCount);
}
public async Task DeleteAsync(long id)
{
_logger.LogTrace(LoggingEvents.Trace, $"Updating entity with id:{id}");
AppEventArgs <T> e = new AppEventArgs <T>();
e.appEventType = AppEventType.Delete;
var entity = await this.GetByIdAsync(id);
e.beforeChange = entity.Clone();
entity.deleted = true;
entity.updatedDate = DateTime.UtcNow;
var filter = Builders <T> .Filter.Eq("id", id);
var result = await this._collection.FindOneAndReplaceAsync(filter, entity);
e.afterChange = entity;
this.OnEvent(AppEventType.Update, e);
this.OnAnyEvent(e);
}
protected override void OnPostApplicationRun(object sender, AppEventArgs e)
{
base.Application.GetService<ILogProvider>().System.Info("Launching SWIFT payment status update engine...");
_engine.Run();
}
private void OnAppExited(object sender, AppEventArgs e)
{
AppExited.Raise(() => new object[] { e.AppInfo });
}
public async Task KafkaMessagingTest004_PublishConsumeBulkMessagesUsingWire_ExpectNoExceptions()
{
this.testLogger.LogDebug("*** KafkaMessagingTest004 ***");
// Use pre-defined test topic - checkout performance
var topic = TestTopic;
const int testCount = 1000;
var kProducer = new app.common.messaging.simple.KafkaProducer <AppEventArgs <Customer> >(this.loggerFactory);
// Config for fast synchronous write without buffering
var producerConfig = new Dictionary <string, object>
{
{ "bootstrap.servers", this.serverAddress },
{ "retries", 0 },
{ "socket.blocking.max.ms", 1 },
{ "queue.buffering.max.ms", 0 },
{ "batch.num.messages", 1 },
{ "socket.nagle.disable", true }
};
kProducer.Setup(producerConfig);
// Generate 1000 events
var opTimer = Stopwatch.StartNew();
Task[] tasks = new Task[testCount];
for (int i = 0; i < testCount; i++)
{
AppEventArgs <Customer> evt = this.__getEvent();
// We want these events going off as soon as possible
tasks[i] = kProducer.ProduceAsync(topic, evt);
// kProducer.ProduceAsync(topic, evt);
}
await Task.WhenAll(tasks);
tasks = null;
opTimer.Stop();
this.testLogger.LogInformation($"KafkaProducer ::Took {opTimer.Elapsed.TotalSeconds} sec to send {testCount} events");
kProducer.Dispose();
// Test Wire based Kafka Producer
var kProducer2 = new app.common.messaging.generic.KafkaProducer <AppEventArgs <Customer> >(this.loggerFactory);
kProducer2.Setup(producerConfig);
// Generate 1000 events
opTimer = Stopwatch.StartNew();
tasks = new Task[testCount];
for (int i = 0; i < testCount; i++)
{
AppEventArgs <Customer> evt = this.__getEvent();
// We want these events going off as soon as possible
tasks[i] = kProducer2.ProduceAsync(topic, evt);
// kProducer.ProduceAsync(topic, evt);
}
await Task.WhenAll(tasks);
opTimer.Stop();
this.testLogger.LogInformation($"KafkaProducer2::Took {opTimer.Elapsed.TotalSeconds} sec to send {testCount} events");
kProducer2.Dispose();
}
public async Task KafkaMessagingTest002_PublishConsumeBulkMessages_ExpectNoExceptions()
{
this.testLogger.LogDebug("*** KafkaMessagingTest002 ***");
var topic = $"{TestTopic}_Test002_{Guid.NewGuid()}";
var kProducer = new app.common.messaging.simple.KafkaProducer <AppEventArgs <Customer> >(this.loggerFactory);
// Config for fast synchronous write without buffering
var producerConfig = new Dictionary <string, object>
{
{ "bootstrap.servers", this.serverAddress },
{ "retries", 0 },
{ "queue.buffering.max.ms", 0 },
{ "batch.num.messages", 1 },
{ "socket.nagle.disable", true }
};
kProducer.Setup(producerConfig);
// Generate 100 events
var opTimer = Stopwatch.StartNew();
for (int i = 0; i < 100; i++)
{
AppEventArgs <Customer> evt = this.__getEvent();
// We want these events going off as soon as possible
await kProducer.ProduceAsync(topic, evt);
// kProducer.ProduceAsync(topic, evt);
}
opTimer.Stop();
this.testLogger.LogInformation($"Took {opTimer.Elapsed.TotalSeconds} sec to send 100 events");
kProducer.Dispose();
var kConsumer = new app.common.messaging.simple.KafkaConsumer(this.loggerFactory);
var customerConfig = new Dictionary <string, object>
{
{ "bootstrap.servers", this.serverAddress },
{ "auto.commit.interval.ms", 5000 },
{ "auto.offset.reset", "earliest" },
{ "group.id", "test-consumer-group" }
};
var consumeTopics = new List <string>()
{
topic
};
kConsumer.Setup(customerConfig, consumeTopics);
List <AppEventArgs <Customer> > events = new List <AppEventArgs <Customer> >();
//Consume yield returns a list of messages
opTimer = Stopwatch.StartNew();
foreach (var message in kConsumer.Consume(this.cts.Token))
{
this.testLogger.LogTrace(LoggingEvents.Trace, $"Response: Partition:{message.Partition}, Offset:{message.Offset} :: {message.Message}");
events.Add(AppEventArgs <Customer> .FromJson(message.Message));
if (events.Count == 100)
{
opTimer.Stop();
this.testLogger.LogDebug($"Received 1000 events from Kafka");
this.testLogger.LogInformation($"Took {opTimer.Elapsed.TotalSeconds} sec to receive 100 events");
// break;
this.cts.Cancel();
}
}
kConsumer.Dispose();
}
protected override void OnApplicationInitialize(object sender, AppEventArgs e)
{
base.Application.GetService<ILogProvider>().System.Info("Initializing SWIFT payment status update engine...");
var efp = Application.GetService<IDbClientFactoryProvider>();
_executorFactory = efp.GetDbClientFactory();
}
/// <summary>
/// A listener method for the AppEvents.
/// This method handles all of the AppEvents that are fired from the model.
/// </summary>
/// <param name="o"></param>
/// <param name="args"></param>
private void AppEventListener(Object o, AppEventArgs args)
{
switch (args.Action)
{
case AppAction.CREATE_WORK_ITEM:
// Change the Combobox that shows the Status of the currently selected item.
WorkItemStatusComboBox.SelectedItem = _controller.GetWorkItemStatus(_model.SelectedWorkItem.workItemStatus.Status);
_model.IsBindingLoading = false;
// Move the cursor to the Task Title field.
SelectedTaskTitleField.Focus();
_model.SetApplicationMode(DataEntryMode.ADD);
break;
case AppAction.SELECT_WORK_ITEM:
// Because the UI is divided into two lists (active and closed), we need to toggle the selections of both lists.
_model.IsBindingLoading = true;
WorkItem wi = args.CurrentWorkItemSelection;
// The Work Item selection is of an 'Active' status.
// If the selection is Active, then we want to clear the Closed list selections.
if (wi.IsConsideredActive)
{
ClosedListView.SelectedItem = null;
// If an item isn't selected on the Overview list, and is in the list, then select it now.
if ((Overview.SelectedItem == null) && (Overview.Items.Contains(wi)))
{
Overview.SelectedItem = wi;
}
}
else
{
// The Work Item selection is of a 'Closed' status.
// If the selection is Closed, then we want to clear the Active list selections.
Overview.SelectedItem = null;
if ((ClosedListView.SelectedItem == null) && (ClosedListView.Items.Contains(wi)))
{
ClosedListView.SelectedItem = wi;
}
}
// ---
Console.WriteLine($"WorkItemStatusID = {wi.Meta.WorkItemStatus_ID}; WorkItemStatusEntryID={wi.WorkItemStatusEntry.WorkItemStatusEntryID}; FlaggedForUpdate={wi.Meta.WorkItemStatusNeedsUpdate}; Status={wi.Status}; Completion={wi.Completed};");
Console.WriteLine($"WorkItemStatusEntryID={wi.WorkItemStatusEntry.WorkItemStatusEntryID}; StatusID={wi.WorkItemStatusEntry.StatusID}; CompletionAmount={wi.WorkItemStatusEntry.CompletionAmount} RecordExists={wi.WorkItemStatusEntry.RecordExists}");
// WorkItemStatusID = 0; WorkItemStatusEntryID = 9; FlaggedForUpdate = False; Status = Active; Completion = 0;
// WorkItemStatusEntryID = 9; StatusID = 1; CompletionAmount = 0 RecordExists = True
// ---
// Set the Work Item Status & the DueInDays control to the values of the selected WorkItem
WorkItemStatusComboBox.SelectedItem = _controller.GetWorkItemStatus(wi.Status);
DueInDaysTextField.Text = DateMethods.GenerateDateDifferenceLabel(DateTime.Now, _model.SelectedWorkItem.DueDate, true);
// Check to see if the Journal entries for this Work Item have been loaded. Load them if not.
if (_model.SelectedWorkItem.Meta.AreJournalItemsLoaded == false)
{
_controller.LoadJournalEntries(_model.SelectedWorkItem);
}
JournalEntryList.ItemsSource = _model.SelectedWorkItem.Journals;
// Check to see if the CheckList for this WorkItem have been loaded. Load them if not.
if (_model.AreCheckListsLoaded(wi.Meta.WorkItem_ID) == false)
{
_controller.LoadWorkItemCheckLists(_model.SelectedWorkItem);
}
WorkItemCheckList.ItemsSource = _model.CheckListItems;
_model.SetApplicationMode(DataEntryMode.EDIT);
_model.IsBindingLoading = false;
break;
case AppAction.WORK_ITEM_ADDED:
SaveButton.Background = Brushes.SteelBlue;
SaveButton.Content = "Save";
break;
case AppAction.WORK_ITEM_STATUS_CHANGED:
// Before processing any actions, check to see if Binding is loading.
// If it is, then do nothing.
if (_model.IsBindingLoading == false)
{
// Unpack the event
WorkItem wi2 = args.CurrentWorkItemSelection;
WorkItemStatus newWorkItemStatus = (WorkItemStatus)args.Object1;
WorkItemStatus oldWorkItemStatus = (WorkItemStatus)args.Object2;
// Check to see if the change in status is a change between active/closed
if (newWorkItemStatus.IsConsideredActive != oldWorkItemStatus.IsConsideredActive)
{
// Active-to-Closed
// If the status is not considered to be active, then disable the progress slider.
if (newWorkItemStatus.IsConsideredActive == false)
{
WorkItemProgressSlider.IsEnabled = false;
_model.SwapList(true, wi2);
//_model.SetSelectedWorkItem(null);
}
else // Closed-to-Active
{
_model.SwapList(false, wi2);
OverviewAreaTabs.SelectedIndex = 0;
// If it's Active (i.e. not Completed) and at 100% progress then set it back to 95%
// (This is to prevent a Completed-then-Active being auto-set back to Completed when loaded again)
WorkItemProgressSlider.IsEnabled = true;
//if (wi2.Completed == 100)
if (wi2.Completed == 100)
{
string strValue = _model.GetAppPreferenceValue(PreferenceName.STATUS_ACTIVE_TO_COMPLETE_PCN);
wi2.Completed = int.Parse(strValue);
}
}
}
else
{
// do nothing
}
}
break;
case AppAction.SET_APPLICATION_MODE:
if (_model.GetApplicationMode() == DataEntryMode.ADD)
{
// Make the 'New Work Item' button unavailable.
// TODO: Not working
NewWorkItemButton.IsEnabled = false;
Overview.Background = Brushes.WhiteSmoke;
SaveButton.Content = "Create Work Item";
}
else if (_model.GetApplicationMode() == DataEntryMode.EDIT)
{
// Make the 'New Work Item' button available.
NewWorkItemButton.IsEnabled = true;
Overview.Background = Brushes.White;
SaveButton.Content = "Save";
}
break;
case AppAction.PREFERENCE_CHANGED:
// Intentionally there is no in-built protection to stop a user from editing a non-editable value. (Keeping my options open)
// Change in memory.
Enum.TryParse(args.Object1.ToString(), out PreferenceName preferenceName);
_model.GetAppPreferenceCollection()[preferenceName].Value = args.Object3.ToString();
// Change in storage.
_controller.UpdateAppPreference(preferenceName, args.Object3.ToString());
break;
case AppAction.JOURNAL_ENTRY_DELETED:
_controller.DeleteDBJournalEntry((JournalEntry)args.Object1);
break;
case AppAction.JOURNAL_ENTRY_ADDED:
_controller.InsertDBJournalEntry(args.CurrentWorkItemSelection.Meta.WorkItem_ID, (JournalEntry)args.Object1);
_controller.AddJournalEntry(args.CurrentWorkItemSelection, (JournalEntry)args.Object1);
break;
case AppAction.JOURNAL_ENTRY_EDITED:
_controller.UpdateDBJournalEntry((JournalEntry)args.Object2);
int indexOf = _model.SelectedWorkItem.Journals.IndexOf((JournalEntry)args.Object1);
_model.SelectedWorkItem.Journals.Remove((JournalEntry)args.Object1);
_model.SelectedWorkItem.Journals.Insert(indexOf, (JournalEntry)args.Object2);
break;
case AppAction.DATA_EXPORT:
ExportWindow exportDialog = new ExportWindow(_controller.GetPreferencesBeginningWith("DATA_EXPORT"));
exportDialog.ShowDialog();
if (exportDialog.WasSubmitted)
{
string dbConn = null;
if (exportDialog.ExportFromSystemFile)
{
dbConn = _controller.DBConnectionString;
}
else
{
dbConn = "data source=" + exportDialog.ExportFile;
// Save the last directory where the export has come from.
int index = exportDialog.ExportFile.LastIndexOf('\\');
string exportDirectory = exportDialog.ExportFile.Substring(0, index - 1);
if (_model.GetAppPreferenceValue(PreferenceName.DATA_EXPORT_LAST_DIRECTORY).Equals(exportDirectory) == false)
{
_controller.UpdateAppPreference(PreferenceName.DATA_EXPORT_LAST_DIRECTORY, exportDirectory);
}
}
var exportSettings = new Dictionary <ExportSetting, string>();
exportSettings.Add(ExportSetting.DATABASE_CONNECTION, dbConn);
exportSettings.Add(ExportSetting.EXPORT_TO_LOCATION, exportDialog.SaveLocation);
exportSettings.Add(ExportSetting.EXPORT_PREFERENCES, Convert.ToString(exportDialog.IncludePreferences));
exportSettings.Add(ExportSetting.EXPORT_WORK_ITEM_OPTION, exportDialog.WorkItemType);
exportSettings.Add(ExportSetting.EXPORT_DAYS_STALE, Convert.ToString(exportDialog.StaleNumber));
exportSettings.Add(ExportSetting.EXPORT_INCLUDE_DELETED, Convert.ToString(exportDialog.IncludeDeleted));
exportSettings.Add(ExportSetting.EXPORT_INCLUDE_LAST_STATUS_ONLY, Convert.ToString(!exportDialog.AllStatuses));
exportSettings.Add(ExportSetting.EXPORT_INCLUDE_LAST_DUEDATE_ONLY, Convert.ToString(!exportDialog.AllDueDates));
_controller.ExportToXML(exportDialog.ExportVersion, exportSettings);
MessageBox.Show($"Export has been saved to {exportDialog.SaveLocation}", "Export Complete");
}
break;
case AppAction.DATA_IMPORT:
string importLastDirectory = _model.GetAppPreferenceValue(PreferenceName.DATA_IMPORT_LAST_DIRECTORY);
ImportWindow importDialog = new ImportWindow(_model.GetAppPreferenceValue(PreferenceName.APPLICATION_VERSION),
importLastDirectory);
importDialog.ShowDialog();
if ((importDialog.WasSubmitted) && (importDialog.ImportSelectionCount > 0))
{
Dictionary <PreferenceName, string> preferences = new Dictionary <PreferenceName, string>();
if (importDialog.ImportPreferencesSelected)
{
preferences = importDialog.LoadedPreferences;
}
_controller.ImportData(importDialog.GetImportVersion, preferences, importDialog.GetImportStatuses, importDialog.LoadedXMLDocument);
string directoryPortionOnly = importLastDirectory.Substring(0, importLastDirectory.LastIndexOf('\\') - 1);
if (importDialog.GetImportFileLocation.Equals(directoryPortionOnly) == false)
{
_controller.UpdateAppPreference(PreferenceName.DATA_IMPORT_LAST_DIRECTORY, directoryPortionOnly);
}
}
break;
case AppAction.WORK_ITEM_DELETE_LOGICAL:
_controller.DeleteWorkItem(args.CurrentWorkItemSelection, true);
break;
case AppAction.WORK_ITEM_DELETE_PHYSICAL:
_controller.DeleteWorkItem(args.CurrentWorkItemSelection, false);
break;
case AppAction.CHECKLIST_ITEM_ADDED:
CheckListItem i2 = (CheckListItem)args.Object1;
_model.CheckListItems.Add(i2);
_controller.SetCheckListMode(DataEntryMode.EDIT);
WorkItemCheckList.SelectedItem = i2;
break;
case AppAction.CHECKLIST_ITEM_SELECTED:
if (_model.WorkItemCheckListDBNeedsUpdating)
{
Console.WriteLine("an item needs updating");
CheckListItem cli = (CheckListItem)args.Object1;
_controller.UpdateDBCheckListItem(cli, 0);
}
break;
case AppAction.CHECKLIST_ITEM_MOVED:
CheckListItem cli3 = (CheckListItem)args.Object1;
ReloadCheckListItems();
_model.SelectedCheckListItem = cli3; // TODO this isn't working. The item moved up doesn't have focus in the list.
break;
case AppAction.CHECKLIST_MODE_CHANGED:
if (_model.CheckListItemMode == DataEntryMode.ADD)
{
AddChecklistItemButton.IsEnabled = true;
CheckListItem cli2 = new CheckListItem();
_model.SelectedCheckListItem = cli2;
}
else
{
AddChecklistItemButton.IsEnabled = false;
}
break;
}
}
public void StartServer(CancellationToken cancellationToken)
{
this._logger.LogDebug(LoggingEvents.Debug, "Started Data Replication Server");
Console.WriteLine(" *** Started App Data Replication Server ***");
// This is the event handler for emailNotification queue. Make sure this does not throw exception
// Kafka message handling block would not be responsible to handle any exceptions
Func <KMessage <AppEventArgs <Customer> >, Task> appEventHandler = async(message) =>
{
this._logger.LogTrace(LoggingEvents.Trace, $"Response: Partition:{message.Partition}, Offset:{message.Offset} :: {message.Message}");
AppEventArgs <Customer> evt = message.Message;
try {
Customer customer = evt.afterChange;
switch (evt.appEventType)
{
case AppEventType.Insert:
_logger.LogTrace(LoggingEvents.Trace, String.Format("Adding new Customer:{0}", customer.name));
await _custrepo.AddAsync(customer);
await this._searchrepo.AddAsync(customer);
break;
case AppEventType.Delete:
var cust = await _custrepo.GetByEntityIdAsync(customer.entityid);
if (cust == null)
{
_logger.LogTrace(LoggingEvents.Trace, $"Trying to delete Customer {customer.name} with EmtityID: {customer.entityid} that does not exist");
}
else
{
await _custrepo.DeleteAsync(customer.entityid);
}
if (this._searchrepo.Exists(customer.id))
{
await this._searchrepo.DeleteAsync(customer.id);
}
break;
case AppEventType.Update:
_logger.LogTrace(LoggingEvents.Trace, $"Processing request to update customer:{customer.entityid}");
await _custrepo.UpdateAsync(customer);
await _searchrepo.UpdateAsync(customer);
break;
default:
_logger.LogTrace(LoggingEvents.Trace, $"No action required for event:{evt.id} of type:{evt.appEventType}");
break;
}
this._logger.LogDebug(LoggingEvents.Trace, $"Processed Customer CRUD event {evt.id}");
}
catch (Exception ex) {
var msg = $"Event:{evt.id} - Error:{ex.Message}";
this._logger.LogError(LoggingEvents.Error, ex, msg);
// We will send out a notification for every update
var notifyEvt = new EmailEventArgs {
subject = "Data Replication Error",
textMsg = $"Error replicating customer information. {msg}",
htmlMsg = $"<p> Error replicating customer information. </p><p> <b>Message Details: </b> {msg} <p>",
notifyTo = new List <string>()
{
"*****@*****.**"
},
notifyCC = new List <string>(),
notifyBCC = new List <string>()
};
await this._notificationProducer.ProduceAsync(this._notificationMsgQueueTopic, notifyEvt);
}
};
this._appEventMsgConsumer.Consume(cancellationToken, appEventHandler, null, null);
this._appEventMsgConsumer.Dispose();
Console.WriteLine(" *** Stopped App Data Replication Server ***");
this._logger.LogDebug(LoggingEvents.Debug, "Stopped App Data Replication Server");
}
private void DataApps_OnAskEdit(object sender, AppEventArgs e)
{
this.EditApp(e.Id);
}
public virtual void OnEvent(AppEventType appEventType, AppEventArgs <T> e)
{
this.__executeEventHandlers(
this.allEventHandlers.Where(ed => ed.AppEventType == appEventType), e);
}
//
// All the event handlers are called asynchronously. We wait for all of them to complete
//
private void __executeEventHandlers(IEnumerable <EventHandlerEntry <T> > eventhandlers, AppEventArgs <T> e)
{
List <Task> TaskList = new List <Task>();
foreach (var eh in eventhandlers)
{
TaskList.Add(eh.EventHandler(e));
}
Task.WaitAll(TaskList.ToArray());
}
protected override void OnPreApplicationStop(object sender, AppEventArgs e)
{
base.Application.GetService<ILogProvider>().System.Info("Stopping SWIFT payment status update engine...");
_engine.Stop(() => _block.Set());
}
public virtual void OnAnyEvent(AppEventArgs <T> e)
{
this.__executeEventHandlers(
this.allEventHandlers.Where(ed => ed.AppEventType == AppEventType.Any), e);
}
private void DataApps_OnAskRemove(object sender, AppEventArgs e)
{
this.RemoveApp(e.Id);
}
