private void LoadFile()
{
_bLoading = true;
try
{
if (_scintilla == null)
{
ScintillaTextEditorFactory factory = new ScintillaTextEditorFactory();
_scintilla = factory.Create(new RDMPCombineableFactory());
groupBox1.Controls.Add(_scintilla);
_scintilla.SavePointLeft += ScintillaOnSavePointLeft;
ObjectSaverButton1.BeforeSave += objectSaverButton1_BeforeSave;
}
SetupAutocomplete();
try
{
_scintilla.Text = File.ReadAllText(_processTask.Path);
_scintilla.SetSavePoint();
}
catch (Exception e)
{
CommonFunctionality.Fatal("Could not open file " + _processTask.Path, e);
}
}
finally
{
_bLoading = false;
}
}
public override void SetDatabaseObject(IActivateItems activator, CatalogueItem databaseObject)
{
_catalogueItem = databaseObject;
if (_scintillaDescription == null)
{
var f = new ScintillaTextEditorFactory();
_scintillaDescription = f.Create(null, null, null, true, false, activator.CurrentDirectory);
_scintillaDescription.Font = System.Drawing.SystemFonts.DefaultFont;
panel1.Controls.Add(_scintillaDescription);
}
base.SetDatabaseObject(activator, databaseObject);
if (_catalogueItem.ExtractionInformation != null)
{
CommonFunctionality.AddToMenu(new ExecuteCommandActivate(activator, _catalogueItem.ExtractionInformation), "Go To Extraction Information");
}
else
{
CommonFunctionality.AddToMenu(new ExecuteCommandMakeCatalogueItemExtractable(activator, _catalogueItem), "Make Extractable");
}
if (_catalogueItem.ColumnInfo_ID != null)
{
CommonFunctionality.AddToMenu(new ExecuteCommandShow(activator, _catalogueItem.ColumnInfo, 0, true));
}
}
public void SetCollection(IActivateItems activator, IPersistableObjectCollection collection)
{
SetItemActivator(activator);
Collection = (SessionCollection)collection;
if (!CommonTreeFunctionality.IsSetup)
{
CommonTreeFunctionality.SetUp(RDMPCollection.None, olvTree, activator, olvName, olvName, new RDMPCollectionCommonFunctionalitySettings()
{
// add custom options here
});
}
RefreshSessionObjects();
CommonFunctionality.ClearToolStrip();
CommonFunctionality.Add(new ToolStripButton("Add...", null, AddObjectToSession));
CommonFunctionality.Add(new ToolStripButton("Remove...", null, RemoveObjectsFromSession));
if (_firstTime)
{
CommonTreeFunctionality.SetupColumnTracking(olvName, new Guid("a6abe085-f5cc-4ce0-85ef-0d42e7dbfced"));
_firstTime = false;
}
}
public static void ScoresResultsIncludeStringResults()
{
var request = new CheckResult
{
Checked = Now,
DnsResult = new DnsResult {
Dmarc = true, HadResults = true, DmarcPolicy = "test"
},
Domain = "test.test",
Rank = 0,
HttpResult = null,
RequestId = Id
};
var result = CommonFunctionality.ScoreResult(request);
Assert.NotNull(result);
Assert.NotNull(result.Results);
Assert.NotEmpty(result.Results);
Assert.True(result.Score > 0);
var stringDisplayResults = result.Results.OfType <StringDisplayResult>().ToList();
Assert.NotEmpty(stringDisplayResults);
Assert.Equal(request.DnsResult.DmarcPolicy, stringDisplayResults.First().StringResult);
}
protected void BuildMenu(IActivateItems activator)
{
if (!menuInitialized)
{
menuInitialized = true;
if (DatabaseObject != null)
{
CommonFunctionality.AddToMenu(new ExecuteCommandActivate(activator, DatabaseObject));
}
CommonFunctionality.AddToMenu(new ToolStripSeparator());
CommonFunctionality.AddToMenu(miSaveImages);
CommonFunctionality.AddToMenu(miCopyToClipboard);
CommonFunctionality.AddToMenu(btnCache);
CommonFunctionality.Add(btnResendQuery);
foreach (var c in _timeoutControls.GetControls())
{
CommonFunctionality.Add(c);
}
}
}
private void GenerateQuery()
{
QueryEditor.ReadOnly = false;
CommonFunctionality.ResetChecks();
try
{
var cic = (CohortIdentificationConfiguration)DatabaseObject;
var builder = new CohortQueryBuilder(cic, null);
if (!btnUseCache.Checked && cic.QueryCachingServer_ID.HasValue)
{
builder.CacheServer = null;
}
QueryEditor.Text = builder.SQL;
CommonFunctionality.ScintillaGoRed(QueryEditor, false);
}
catch (Exception ex)
{
QueryEditor.Text = "Could not build Sql:" + ex.Message;
CommonFunctionality.ScintillaGoRed(QueryEditor, true);
CommonFunctionality.Fatal("Failed to build query", ex);
}
QueryEditor.ReadOnly = true;
}
private void RegenerateCodeInQueryEditor()
{
try
{
if (_extractionConfiguration.Cohort_ID == null)
{
throw new Exception("No cohort has been defined for this ExtractionConfiguration");
}
//We are generating what the extraction SQL will be like, that only requires the dataset so empty bundle is fine
_request = new ExtractDatasetCommand(_extractionConfiguration, new ExtractableDatasetBundle(_extractableDataSet));
_request.GenerateQueryBuilder();
QueryEditor.ReadOnly = false;
//get the SQL from the query builder
QueryEditor.Text = _request.QueryBuilder.SQL;
QueryEditor.ReadOnly = true;
CommonFunctionality.ScintillaGoRed(QueryEditor, false);
}
catch (Exception ex)
{
CommonFunctionality.ScintillaGoRed(QueryEditor, ex);
}
}
public override void SetDatabaseObject(IActivateItems activator, SupportingSQLTable databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_supportingSQLTable = databaseObject;
_bLoading = true;
QueryPreview.Text = _supportingSQLTable.SQL;
//if it has an external server configured
if (_supportingSQLTable.ExternalDatabaseServer_ID != null)
{
ddExternalServers.Text = _supportingSQLTable.ExternalDatabaseServer.ToString();
}
else
{
ddExternalServers.Text = NoExternalServer;
}
tcTicket.TicketText = _supportingSQLTable.Ticket;
_bLoading = false;
CommonFunctionality.AddHelp(cbExtractable, "SupportingSQLTable.Extractable");
CommonFunctionality.AddHelp(cbGlobal, "SupportingSqlTable.IsGlobal");
RefreshUIFromDatabase();
}
public override void SetDatabaseObject(IActivateItems activator, PermissionWindow databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_permissionWindow = databaseObject;
var periods = _permissionWindow.PermissionWindowPeriods;
var periodsByDay = new Dictionary <int, List <PermissionWindowPeriod> >();
foreach (var period in periods)
{
if (!periodsByDay.ContainsKey(period.DayOfWeek))
{
periodsByDay.Add(period.DayOfWeek, new List <PermissionWindowPeriod>());
}
periodsByDay[period.DayOfWeek].Add(period);
}
var textBoxes = new[] { tbSunday, tbMonday, tbTuesday, tbWednesday, tbThursday, tbFriday, tbSaturday };
for (var i = 0; i < 7; ++i)
{
PopulatePeriodTextBoxForDay(textBoxes[i], i, periodsByDay);
}
CommonFunctionality.AddHelp(tbMonday, "IPermissionWindow.PermissionWindowPeriods");
}
private void tbChunkPeriod_TextChanged(object sender, EventArgs e)
{
CommonFunctionality.DoActionAndRedIfThrows(tbChunkPeriod, () =>
{
_cacheProgress.ChunkPeriod = TimeSpan.Parse(tbChunkPeriod.Text);
});
}
public override void SetDatabaseObject(IActivateItems activator, CacheProgress databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
CommonFunctionality.AddHelp(tbCacheProgress, "ICacheProgress.CacheFillProgress");
CommonFunctionality.AddHelp(ddCacheLagDurationType, "ICacheProgress.CacheLagPeriod");
CommonFunctionality.AddHelp(ddCacheLagDelayDurationType, "ICacheProgress.CacheLagPeriodLoadDelay");
CommonFunctionality.AddHelp(tbChunkPeriod, "ICacheProgress.ChunkPeriod");
CommonFunctionality.AddHelp(pPipeline, "ICacheProgress.Pipeline_ID");
_cacheProgress = databaseObject;
CommonFunctionality.AddToMenu(new ExecuteCommandExecuteCacheProgress(activator, databaseObject), "Go To Execute");
ragSmiley1.Reset();
try
{
PopulateCacheProgressPanel(_cacheProgress);
}
catch (Exception e)
{
ragSmiley1.Fatal(e);
}
}
public override void SetDatabaseObject(IActivateItems activator, Catalogue databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
timePeriodicityChart1.SetItemActivator(activator);
//clear old DQE graphs
ClearDQEGraphs();
DQERepository dqeRepository = null;
try
{
//try to get the dqe server
dqeRepository = new DQERepository(databaseObject.CatalogueRepository);
}
catch (Exception)
{
//there is no dqe server, ah well nevermind
}
//dqe server did exist!
if (dqeRepository != null)
{
//get evaluations for the catalogue
Evaluation[] evaluations = dqeRepository.GetAllEvaluationsFor(databaseObject).ToArray();
//there have been some evaluations
evaluationTrackBar1.Evaluations = evaluations;
}
CommonFunctionality.Add(new ExecuteCommandConfigureCatalogueValidationRules(activator).SetTarget(databaseObject));
CommonFunctionality.Add(new ExecuteCommandRunDQEOnCatalogue(activator, databaseObject), "Run Data Quality Engine...");
}
public override void SetDatabaseObject(IActivateItems activator, ExternalCohortTable databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_externalCohortTable = databaseObject;
serverDatabaseTableSelector1.DatabaseType = _externalCohortTable.DatabaseType;
string password = null;
try
{
password = _externalCohortTable.GetDecryptedPassword();
}
catch (Exception)
{
password = null;
}
serverDatabaseTableSelector1.SetExplicitDatabase(_externalCohortTable.Server, _externalCohortTable.Database, _externalCohortTable.Username, password);
CommonFunctionality.AddHelp(tbTableName, "IExternalCohortTable.TableName");
CommonFunctionality.AddHelp(tbPrivateIdentifierField, "IExternalCohortTable.PrivateIdentifierField");
CommonFunctionality.AddHelp(tbReleaseIdentifierField, "IExternalCohortTable.ReleaseIdentifierField");
CommonFunctionality.AddHelp(tbDefinitionTableForeignKeyField, "IExternalCohortTable.DefinitionTableForeignKeyField");
CommonFunctionality.AddHelp(tbDefinitionTableName, "IExternalCohortTable.DefinitionTableName");
CommonFunctionality.AddChecks(_externalCohortTable);
}
/// <summary>
/// Adds the all <see cref="IAtomicCommand"/> specified by <see cref="IActivateItems.PluginUserInterfaces"/> for the current control. Commands
/// will appear in the menu drop down options at the top of the control
/// </summary>
protected void AddPluginCommandsToMenu()
{
foreach (IAtomicCommand cmd in GetPluginCommands())
{
CommonFunctionality.AddToMenu(cmd);
}
}
public override void SetDatabaseObject(IActivateItems activator, Lookup databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_keyColumn = databaseObject.PrimaryKey;
_descriptionColumn = databaseObject.Description;
_tableInfo = _keyColumn.TableInfo;
lblCode.Text = _keyColumn.GetRuntimeName();
lblDescription.Text = _descriptionColumn.GetRuntimeName();
ScintillaTextEditorFactory factory = new ScintillaTextEditorFactory();
_scintilla = factory.Create();
gbScintilla.Controls.Add(_scintilla);
try
{
SendQuery();
}
catch (System.Exception ex)
{
CommonFunctionality.Fatal("Could not connect to database", ex);
}
}
public override void SetDatabaseObject(IActivateItems activator, LoadMetadata databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
if (!_collectionCommonFunctionality.IsSetup)
{
_collectionCommonFunctionality.SetUp(RDMPCollection.None, tlvLoadedTables, activator, null, null, new RDMPCollectionCommonFunctionalitySettings()
{
AddFavouriteColumn = false,
AddIDColumn = false,
AllowPinning = false,
SuppressChildrenAdder = true,
SuppressActivate = true,
AddCheckColumn = false
});
}
if (_dragDropProvider == null)
{
_dragDropProvider = new DragDropProvider(new RDMPCommandFactory(), new RDMPCommandExecutionFactory(Activator), tlvLoadedTables);
}
_loadMetadata = databaseObject;
RefreshUIFromDatabase();
CommonFunctionality.Add(_btnFetchData);
}
public override void SetDatabaseObject(IActivateItems activator, GovernancePeriod databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_governancePeriod = databaseObject;
//clear related catalogues
olvCatalogues.ClearObjects();
ticketingControl1.TicketText = _governancePeriod.Ticket;
lblExpired.Visible = _governancePeriod.IsExpired();
dtpStartDate.Value = _governancePeriod.StartDate;
if (_governancePeriod.EndDate == null)
{
rbNeverExpires.Checked = true;
}
else
{
rbExpiresOn.Checked = true;
dtpEndDate.Value = (DateTime)_governancePeriod.EndDate;
}
//add related catalogues
olvCatalogues.AddObjects(_governancePeriod.GovernedCatalogues.ToArray());
CommonFunctionality.AddHelp(olvCatalogues, "GovernancePeriod.GovernedCatalogues");
CommonFunctionality.AddChecks(_governancePeriod);
CommonFunctionality.StartChecking();
}
/// <summary>
///
/// </summary>
/// <param name="activeTest"></param>
/// <param name="log"></param>
void RunCodeTest(LayoutTest activeTest, TestLog log)
{
try
{
//create window
((CodeTest)activeTest).CreateWindow();
CommonFunctionality.FlushDispatcher();
//load test info..
((CodeTest)activeTest).WindowSetup();
CommonFunctionality.FlushDispatcher();
//call test actions..
((CodeTest)activeTest).TestActions();
CommonFunctionality.FlushDispatcher();
////call verify..
((CodeTest)activeTest).TestVerify();
CommonFunctionality.FlushDispatcher();
((CodeTest)activeTest).CloseWindow();
CommonFunctionality.FlushDispatcher();
}
catch (Exception ex)
{
GlobalLog.LogEvidence(ex);
activeTest.Result = false;
}
}
private void SetupRibbon()
{
if (_ribbonInitialized)
{
return;
}
_ribbonInitialized = true;
foreach (var o in GetRibbonObjects())
{
if (o is string)
{
CommonFunctionality.Add((string)o);
}
else if (o is DatabaseEntity)
{
CommonFunctionality.AddToMenu(new ExecuteCommandShow(Activator, (DatabaseEntity)o, 0, true));
}
else
{
throw new NotSupportedException(
"GetRibbonObjects can only return strings or DatabaseEntity objects, object '" + o +
"' is not valid because it is a '" + o.GetType().Name + "'");
}
}
}
public void SetCollection(IActivateItems activator, IPersistableObjectCollection collection)
{
_activator = activator;
_collection = (DatasetRacewayObjectCollection)collection;
SetItemActivator(activator);
btnAddCatalogue.Image = _activator.CoreIconProvider.GetImage(RDMPConcept.Catalogue, OverlayKind.Import);
btnAddExtractableDatasetPackage.Image = _activator.CoreIconProvider.GetImage(RDMPConcept.ExtractableDataSetPackage, OverlayKind.Import);
ddShowPeriod.ComboBox.SelectedItem = _collection.ShowPeriod;
cbIgnoreRowCounts.Checked = _collection.IgnoreRows;
UpdateIgnoreRowCountCheckBoxIconAndText();
if (isFirstTime)
{
isFirstTime = false;
racewayRenderArea.RequestDeletion += (c) =>
{
_collection.RemoveCatalogue(c);
SaveCollectionChanges();
};
racewayRenderArea.NotifyEditModeChange(_isEditmodeOn);
}
CommonFunctionality.Add(btnAddCatalogue);
CommonFunctionality.Add(btnAddExtractableDatasetPackage);
CommonFunctionality.Add(btnRemoveAll);
CommonFunctionality.Add(toolStripLabel1);
CommonFunctionality.Add(ddShowPeriod);
CommonFunctionality.Add(cbIgnoreRowCounts);
GenerateChart();
}
public override void SetDatabaseObject(IActivateItems activator, ANOTable databaseObject)
{
_anoTable = databaseObject;
base.SetDatabaseObject(activator, databaseObject);
llServer.Text = _anoTable.Server.Name;
CommonFunctionality.AddChecks(databaseObject);
CommonFunctionality.StartChecking();
SetEnabledness();
CommonFunctionality.AddHelp(tbSuffix, "ANOTable.Suffix");
CommonFunctionality.AddHelp(llServer, "ANOTable.Server_ID");
CommonFunctionality.AddHelpString(tbInputDataType, "DataType", "Datatype for private identifiers being mapped e.g. varchar(100)");
CommonFunctionality.AddHelp(nIntegers, "ANOTable.NumberOfIntegersToUseInAnonymousRepresentation");
CommonFunctionality.AddHelp(nCharacters, "ANOTable.NumberOfCharactersToUseInAnonymousRepresentation");
if (!_anoTable.Server.WasCreatedBy(new ANOStorePatcher()))
{
_serverErrorProvider.SetError(llServer, "Server is not an ANO server");
}
else
{
_serverErrorProvider.Clear();
}
}
public virtual void SetDatabaseObject(IActivateItems activator, T databaseObject)
{
SetItemActivator(activator);
Activator.RefreshBus.EstablishSelfDestructProtocol(this, activator, databaseObject);
DatabaseObject = databaseObject;
CommonFunctionality.ClearToolStrip();
if (_colorIndicator == null && AssociatedCollection != RDMPCollection.None)
{
var colorProvider = new BackColorProvider();
_colorIndicator = new Control();
_colorIndicator.Dock = DockStyle.Top;
_colorIndicator.Location = new Point(0, 0);
_colorIndicator.Size = new Size(150, BackColorProvider.IndiciatorBarSuggestedHeight);
_colorIndicator.TabIndex = 0;
_colorIndicator.BackColor = colorProvider.GetColor(AssociatedCollection);
this.Controls.Add(this._colorIndicator);
}
if (_binder == null)
{
_binder = new BinderWithErrorProviderFactory(activator);
}
SetBindings(_binder, databaseObject);
if (this is ISaveableUI)
{
ObjectSaverButton1.SetupFor(this, databaseObject, activator);
}
}
public void SetCollection(IActivateItems activator, IPersistableObjectCollection collection)
{
_bLoading = true;
SetItemActivator(activator);
_collection = (GoodBadCataloguePieChartObjectCollection)collection;
if (firstTime)
{
SetupFlags();
}
btnAllCatalogues.Checked = !_collection.IsSingleCatalogueMode;
btnSingleCatalogue.Checked = _collection.IsSingleCatalogueMode;
btnShowLabels.Checked = _collection.ShowLabels;
CommonFunctionality.Add(btnAllCatalogues);
CommonFunctionality.Add(toolStripLabel1);
CommonFunctionality.Add(btnAllCatalogues);
CommonFunctionality.Add(btnSingleCatalogue);
CommonFunctionality.Add(btnShowLabels);
CommonFunctionality.Add(btnRefresh);
foreach (var mi in _flagOptions)
{
CommonFunctionality.AddToMenu(mi);
}
GenerateChart();
_bLoading = false;
}
public void RefreshUIFromDatabase(object oRefreshFrom)
{
if (tlvCatalogues.ModelFilter is CatalogueCollectionFilter f)
{
f.ChildProvider = Activator.CoreChildProvider;
}
//if there are new catalogues we don't already have in our tree
if (_allCatalogues != null)
{
var newCatalogues = CommonTreeFunctionality.CoreChildProvider.AllCatalogues.Except(_allCatalogues);
if (newCatalogues.Any())
{
oRefreshFrom = CatalogueFolder.Root;//refresh from the root instead
tlvCatalogues.RefreshObject(oRefreshFrom);
}
}
_allCatalogues = CommonTreeFunctionality.CoreChildProvider.AllCatalogues;
if (isFirstTime)
{
CommonFunctionality.Add(new ExecuteCommandCreateNewCatalogueByImportingFile(Activator), GlobalStrings.FromFile, null, "New...");
CommonFunctionality.Add(new ExecuteCommandCreateNewCatalogueByImportingExistingDataTable(Activator), GlobalStrings.FromDatabase, null, "New...");
}
if (isFirstTime || Equals(oRefreshFrom, CatalogueFolder.Root))
{
tlvCatalogues.RefreshObject(CatalogueFolder.Root);
tlvCatalogues.Expand(CatalogueFolder.Root);
isFirstTime = false;
}
}
public override void SetDatabaseObject(IActivateItems activator, PreLoadDiscardedColumn databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
CommonFunctionality.AddChecks(databaseObject);
CommonFunctionality.StartChecking();
CommonFunctionality.AddToMenu(new SetDumpServerMenuItem(Activator, databaseObject.TableInfo));
}
public override void SetDatabaseObject(IActivateItems activator, StandardRegex databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_standardRegex = databaseObject;
CommonFunctionality.AddChecks(_standardRegex);
CommonFunctionality.StartChecking();
}
public override void SetDatabaseObject(IActivateItems activator, CohortIdentificationConfiguration databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_configuration = databaseObject;
RebuildClearCacheCommand();
gbCicInfo.Text = $"Name: {_configuration.Name}";
tbDescription.Text = $"Description: {_configuration.Description}";
ticket.TicketText = _configuration.Ticket;
if (_commonFunctionality == null)
{
activator.RefreshBus.Subscribe(this);
_commonFunctionality = new RDMPCollectionCommonFunctionality();
_commonFunctionality.SetUp(RDMPCollection.Cohort, tlvCic, activator, olvNameCol, olvNameCol, new RDMPCollectionCommonFunctionalitySettings
{
SuppressActivate = true,
AddFavouriteColumn = false,
AddCheckColumn = false,
AllowPinning = false,
AllowSorting = true, //important, we need sorting on so that we can override sort order with our OrderableComparer
});
_commonFunctionality.MenuBuilt += MenuBuilt;
tlvCic.AddObject(_configuration);
tlvCic.ExpandAll();
}
CommonFunctionality.AddToMenu(cbIncludeCumulative);
CommonFunctionality.AddToMenu(new ToolStripSeparator());
CommonFunctionality.AddToMenu(new ExecuteCommandSetQueryCachingDatabase(Activator, _configuration));
CommonFunctionality.AddToMenu(new ExecuteCommandClearQueryCache(Activator, _configuration));
CommonFunctionality.AddToMenu(new ExecuteCommandCreateNewQueryCacheDatabase(activator, _configuration));
CommonFunctionality.AddToMenu(
new ExecuteCommandSet(activator, _configuration, _configuration.GetType().GetProperty("Description"))
{
OverrideIcon =
Activator.CoreIconProvider.GetImage(RDMPConcept.CohortIdentificationConfiguration, OverlayKind.Edit)
});
CommonFunctionality.AddToMenu(new ToolStripSeparator());
CommonFunctionality.AddToMenu(new ExecuteCommandShowXmlDoc(activator, "CohortIdentificationConfiguration.QueryCachingServer_ID", "Query Caching"), "Help (What is Query Caching)");
CommonFunctionality.Add(new ExecuteCommandCreateNewCohortByExecutingACohortIdentificationConfiguration(activator, null).SetTarget(_configuration),
"Commit Cohort",
activator.CoreIconProvider.GetImage(RDMPConcept.ExtractableCohort, OverlayKind.Add));
foreach (var c in _timeoutControls.GetControls())
{
CommonFunctionality.Add(c);
}
_queryCachingServer = _configuration.QueryCachingServer;
Compiler.CohortIdentificationConfiguration = _configuration;
Compiler.CoreChildProvider = activator.CoreChildProvider;
RecreateAllTasks();
}
public override void SetItemActivator(IActivateItems activator)
{
base.SetItemActivator(activator);
_factory = new RunnerFactory();
CommonFunctionality.AddToMenu(new ExecuteCommandGenerateRunCommand(activator, Detatch_CommandGetter));
loadProgressUI1.ApplyTheme(activator.Theme);
}
public override void SetDatabaseObject(IActivateItems activator, SelectedDataSets databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_extractionConfiguration = databaseObject.ExtractionConfiguration;
_extractableDataSet = databaseObject.ExtractableDataSet;
RegenerateCodeInQueryEditor();
CommonFunctionality.Add(btnRun);
}
public override void SetDatabaseObject(IActivateItems activator, ProcessTask databaseObject)
{
base.SetDatabaseObject(activator, databaseObject);
_processTask = databaseObject;
SetupForFile();
CommonFunctionality.AddChecks(GetRuntimeTask);
CommonFunctionality.StartChecking();
}
