public CoordSysCatalogPresenter(ICoordSysCatalogView view, FdoToolbox.Base.Services.CoordSysCatalog catalog)
{
_view = view;
_catalog = catalog;
_view.DeleteEnabled = false;
_view.EditEnabled = false;
}
/// <summary>
/// Adds a FDO connection.
/// </summary>
/// <param name="name">The name of the connection.</param>
/// <param name="conn">The connection.</param>
public void AddConnection(string name, FdoToolbox.Core.Feature.FdoConnection conn)
{
if (_ConnectionDict.ContainsKey(name))
throw new FdoConnectionException("Unable to add connection named " + name + " to the connection manager");
if (conn.State != FdoConnectionState.Open)
conn.Open();
_ConnectionDict.Add(name, conn);
this.ConnectionAdded(this, new EventArgs<string>(name));
}
void OnMessageSent(object sender, FdoToolbox.Core.MessageEventArgs e)
{
if (txtOutput.InvokeRequired)
{
txtOutput.Invoke(new AppendTextHandler(this.AppendText), e.Message);
}
else
{
this.AppendText(e.Message);
}
}
/// <summary>
/// Prepares the specified bulk copy definition (freshly deserialized) before the loading process begins
/// </summary>
/// <param name="def">The bulk copy definition.</param>
protected override NameValueCollection Prepare(FdoToolbox.Core.Configuration.FdoBulkCopyTaskDefinition def)
{
/* There is subtle precondition that would've resulted in all connection references being named to a
* single reference, thus invalidating the whole task when loaded.
*
* If the task definition has any connection names to an *already* loaded connection, a rename operation
* could overwrite a previous rename operation. Consider:
*
* Connection A) SDF_Desktop
* Connection B) SDFConnection0
*
* Loaded Connections:
* - SDFConnection0
* - SDFConnection1
*
* If during loading, SDF_Desktop matches to SDFConnection0, and SDFConnection0 matches to SDFConnection1 the rename operations
* would then be:
*
* 1) Rename SDF_Desktop to SDFConnection0
* 2) Rename SDF_Connection0 to SDFConnection1
*
* As a result, all referenced connections will eventually be renamed to SDFConnection1, which is not what we want.
*
* The solution bere is to "fix" the definition by renaming the named connections to something we know is not already a loaded
* connection. This is done regardless to ensure consistent behaviour. Thsi method performs this solution.
*/
string prefix = "Connection";
int counter = 0;
FdoConnectionManager connMgr = ServiceManager.Instance.GetService<FdoConnectionManager>();
NameValueCollection nameMappings = new NameValueCollection();
foreach (FdoConnectionEntryElement el in def.Connections)
{
string newName = prefix + counter;
while (connMgr.GetConnection(newName) != null)
{
counter++;
newName = prefix + counter;
}
string oldName = el.name;
def.UpdateConnectionReferences(oldName, newName);
nameMappings.Add(newName, oldName);
counter++;
}
return nameMappings;
}
void OnTaskAdded(object sender, FdoToolbox.Core.EventArgs<string> e)
{
string name = e.Data;
TreeNode node = new TreeNode();
node.Name = node.Text = name;
node.ImageKey = node.SelectedImageKey = IMG_TASK;
node.ContextMenuStrip = _explorer.GetContextMenu(NODE_TASK);
TreeNode root = _explorer.GetRootNode(RootNodeName);
root.Nodes.Add(node);
node.Expand();
root.Expand();
}
void OnTaskRemoved(object sender, FdoToolbox.Core.EventArgs<string> e)
{
_explorer.GetRootNode(RootNodeName).Nodes.RemoveByKey(e.Data);
}
protected virtual void OnConnectionAdded(object sender, FdoToolbox.Core.EventArgs<string> e) { }
public void SetRestrictions(FdoToolbox.Core.Feature.ICapability cap)
{
}
/// <summary>
/// Called when this process has finished processing.
/// </summary>
/// <param name="op">The op.</param>
protected override void OnFinishedProcessing(FdoToolbox.Core.ETL.Operations.FdoOperationBase op)
{
//We want to avoid log chatter on specialized ETL processes so suppress the base call
}
/// <summary>
/// Called when a row is processed.
/// </summary>
/// <param name="op">The operation.</param>
/// <param name="dictionary">The dictionary.</param>
protected override void OnFeatureProcessed(FdoToolbox.Core.ETL.Operations.FdoOperationBase op, FdoRow dictionary)
{
//We want to avoid log chatter on specialized ETL processes so suppress the base call
}
void OnConnectionRefreshed(object sender, FdoToolbox.Core.EventArgs<string> e)
{
TreeNode root = _explorer.GetRootNode(RootNodeName);
root.Nodes.RemoveByKey(e.Data);
string name = e.Data;
TreeNode node = new TreeNode();
node.Name = node.Text = name;
FdoConnection conn = _connMgr.GetConnection(name);
ProviderDatastoreType dtype = conn.DataStoreType;
switch (dtype)
{
case ProviderDatastoreType.ProviderDatastoreType_DatabaseServer:
node.ImageKey = node.SelectedImageKey = IMG_DB_CONNECTION;
break;
case ProviderDatastoreType.ProviderDatastoreType_File:
node.ImageKey = node.SelectedImageKey = IMG_FILE_CONNECTION;
break;
case ProviderDatastoreType.ProviderDatastoreType_Unknown:
node.ImageKey = node.SelectedImageKey = IMG_CONNECTION;
break;
case ProviderDatastoreType.ProviderDatastoreType_WebServer:
node.ImageKey = node.SelectedImageKey = IMG_SERVER_CONNECTION;
break;
}
node.ContextMenuStrip = _explorer.GetContextMenu(NODE_CONNECTION);
CreateSchemaNodes(node);
node.Tag = true; //Schema fully loaded
SetConnectionToolTip(node, conn);
root.Nodes.Add(node);
node.Expand();
root.Expand();
}
void OnConnectionAdded(object sender, FdoToolbox.Core.EventArgs<string> e)
{
string name = e.Data;
TreeNode node = new TreeNode();
node.Name = node.Text = name;
FdoConnection conn = _connMgr.GetConnection(name);
ProviderDatastoreType dtype = conn.DataStoreType;
switch (dtype)
{
case ProviderDatastoreType.ProviderDatastoreType_DatabaseServer:
node.ImageKey = node.SelectedImageKey = IMG_DB_CONNECTION;
break;
case ProviderDatastoreType.ProviderDatastoreType_File:
node.ImageKey = node.SelectedImageKey = IMG_FILE_CONNECTION;
break;
case ProviderDatastoreType.ProviderDatastoreType_Unknown:
node.ImageKey = node.SelectedImageKey = IMG_CONNECTION;
break;
case ProviderDatastoreType.ProviderDatastoreType_WebServer:
node.ImageKey = node.SelectedImageKey = IMG_SERVER_CONNECTION;
break;
}
node.ContextMenuStrip = _explorer.GetContextMenu(NODE_CONNECTION);
//Don't Describe the schema now, do it when node is expanded for the first time
//use a boolean tag to indicate this state.
node.Tag = false; //Schema not loaded
//HACK: TreeNode requires at least one child node to display the expand icon
//so add a dummy node. When expanded, and describe schema executes for the first time,
//the node will be gone anyway.
node.Nodes.Add(string.Empty);
TreeNode root = _explorer.GetRootNode(RootNodeName);
root.Nodes.Add(node);
root.Expand();
SetConnectionToolTip(node, conn);
}
public bool DependsOnConnection(FdoToolbox.Core.Feature.FdoConnection conn)
{
IFdoConnectionManager connMgr = ServiceManager.Instance.GetService<IFdoConnectionManager>();
FdoConnection left = connMgr.GetConnection(this.SelectedLeftConnection);
FdoConnection right = connMgr.GetConnection(this.SelectedRightConnection);
FdoConnection target = connMgr.GetConnection(this.SelectedTargetConnection);
return conn == left || conn == right || conn == target;
}
/// <summary>
/// Adds the property.
/// </summary>
/// <param name="p">The p.</param>
public void AddProperty(FdoToolbox.Core.Connections.DictionaryProperty p)
{
DataGridViewRow row = new DataGridViewRow();
DataGridViewTextBoxCell nameCell = new DataGridViewTextBoxCell();
nameCell.Value = p.LocalizedName;
DataGridViewTextBoxCell valueCell = new DataGridViewTextBoxCell();
if (p.IsFile || p.IsPath)
{
valueCell.ContextMenuStrip = ctxHelper;
valueCell.ToolTipText = "Right click for helpful options";
}
valueCell.Value = p.DefaultValue;
row.Cells.Add(nameCell);
row.Cells.Add(valueCell);
grdProperties.Rows.Add(row);
if (p.Protected)
pwdCells.Add(valueCell);
}
protected override void OnConnectionRemoved(object sender, FdoToolbox.Core.EventArgs<string> e)
{
string name = e.Data;
btnAddConnection.DropDown.Items.RemoveByKey(name);
}
protected override void OnConnectionAdded(object sender, FdoToolbox.Core.EventArgs<string> e)
{
string name = e.Data;
btnAddConnection.DropDown.Items.Add(name, null, delegate(object s, EventArgs evt)
{
AddParticipatingConnection(name);
});
}
