/// <summary>
/// Saves the join options to xml
/// </summary>
/// <param name="opts">The opts.</param>
/// <param name="name">The name.</param>
/// <param name="file">The file.</param>
public void ToXml(FdoJoinOptions opts, string name, string file)
{
FdoJoinTaskDefinition jdef = new FdoJoinTaskDefinition();
jdef.name = name;
jdef.JoinSettings = new FdoJoinSettings();
if (!string.IsNullOrEmpty(opts.GeometryProperty))
{
jdef.JoinSettings.DesignatedGeometry = new FdoDesignatedGeometry();
jdef.JoinSettings.DesignatedGeometry.Property = opts.GeometryProperty;
jdef.JoinSettings.DesignatedGeometry.Side = opts.Side;
}
List <JoinKey> keys = new List <JoinKey>();
foreach (string left in opts.JoinPairs.Keys)
{
JoinKey key = new JoinKey();
key.left = left;
key.right = opts.JoinPairs[left];
keys.Add(key);
}
jdef.JoinSettings.JoinKeys = keys.ToArray();
jdef.Left = new FdoJoinSource();
jdef.Left.Class = opts.Left.ClassName;
jdef.Left.ConnectionString = opts.Left.Connection.ConnectionString;
jdef.Left.FeatureSchema = opts.Left.SchemaName;
jdef.Left.Prefix = opts.LeftPrefix;
jdef.Left.PropertyList = new List <string>(opts.LeftProperties).ToArray();
jdef.Left.Provider = opts.Left.Connection.Provider;
jdef.Right = new FdoJoinSource();
jdef.Right.Class = opts.Right.ClassName;
jdef.Right.ConnectionString = opts.Right.Connection.ConnectionString;
jdef.Right.FeatureSchema = opts.Right.SchemaName;
jdef.Right.Prefix = opts.RightPrefix;
jdef.Right.PropertyList = new List <string>(opts.RightProperties).ToArray();
jdef.Right.Provider = opts.Right.Connection.Provider;
jdef.Target = new FdoJoinTarget();
jdef.Target.Class = opts.Target.ClassName;
jdef.Target.ConnectionString = opts.Target.Connection.ConnectionString;
jdef.Target.FeatureSchema = opts.Target.SchemaName;
jdef.Target.Provider = opts.Target.Connection.Provider;
using (XmlTextWriter writer = new XmlTextWriter(file, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
writer.Indentation = 4;
XmlSerializer ser = new XmlSerializer(typeof(FdoJoinTaskDefinition));
ser.Serialize(writer, jdef);
}
}
public void Init(FdoJoin join)
{
this.Init();
_join = join;
FdoJoinOptions options = join.Options;
_view.SelectedJoinType = options.JoinType;
_view.SelectedLeftConnection = _connMgr.GetName(options.Left.Connection);
_view.SelectedLeftSchema = options.Left.SchemaName;
_view.SelectedLeftClass = options.Left.ClassName;
_view.SelectedRightConnection = _connMgr.GetName(options.Right.Connection);
_view.SelectedRightSchema = options.Right.SchemaName;
_view.SelectedRightClass = options.Right.ClassName;
_view.SelectedTargetConnection = _connMgr.GetName(options.Target.Connection);
_view.SelectedTargetSchema = options.Target.SchemaName;
_view.SelectedTargetClass = options.Target.ClassName;
_view.LeftPrefix = options.LeftPrefix;
_view.RightPrefix = options.RightPrefix;
_view.LeftFilter = options.LeftFilter;
_view.RightFilter = options.RightFilter;
_view.CheckLeftProperties(options.LeftProperties);
_view.CheckRightProperties(options.RightProperties);
if (options.BatchSize > 0)
{
//assert _view.BatchEnabled == true;
_view.BatchSize = options.BatchSize;
}
if (!string.IsNullOrEmpty(options.GeometryProperty))
{
_view.TargetGeometryPropertyEnabled = true;
if (options.Side == FdoToolbox.Core.Configuration.JoinSide.Left)
{
_view.LeftGeometryChecked = true;
//_view.LeftGeometryEnabled = true;
}
else //Right
{
_view.RightGeometryChecked = true;
//_view.RightGeometryEnabled = true;
}
}
foreach (string leftProp in options.JoinPairs.Keys)
{
_view.AddPropertyJoin(leftProp, options.JoinPairs[leftProp]);
}
}
public void Load()
{
TaskLoader ldr = new TaskLoader();
string path = Preferences.SessionDirectory;
if (System.IO.Directory.Exists(path))
{
string[] files = System.IO.Directory.GetFiles(path, "*" + TaskDefinitionHelper.BULKCOPYDEFINITION);
foreach (string f in files)
{
try
{
string name = string.Empty;
FdoBulkCopyOptions opt = ldr.BulkCopyFromXml(f, ref name, false);
FdoBulkCopy cpy = new FdoBulkCopy(opt);
AddTask(name, cpy);
}
catch { }
}
files = System.IO.Directory.GetFiles(path, "*" + TaskDefinitionHelper.JOINDEFINITION);
foreach (string f in files)
{
try
{
string name = string.Empty;
FdoJoinOptions opt = ldr.JoinFromXml(f, ref name, false);
FdoJoin join = new FdoJoin(opt);
AddTask(name, join);
}
catch { }
}
files = System.IO.Directory.GetFiles(path, "*" + TaskDefinitionHelper.SEQUENTIALPROCESS);
foreach (string f in files)
{
try
{
string prefix = Path.GetFileNameWithoutExtension(f);
string name = prefix;
int counter = 0;
while (this.NameExists(name))
{
counter++;
name = prefix + counter;
}
SequentialProcessDefinition spd = (SequentialProcessDefinition)SequentialProcessDefinition.Serializer.Deserialize(File.OpenRead(f));
FdoSequentialProcess proc = new FdoSequentialProcess(spd);
AddTask(name, proc);
}
catch { }
}
}
}
public override void Run()
{
TaskManager mgr = ServiceManager.Instance.GetService <TaskManager>();
TaskLoader ldr = new TaskLoader();
string file = FileService.OpenFile(ResourceService.GetString("TITLE_LOAD_TASK"), ResourceService.GetString("FILTER_TASK_DEFINITION"));
if (FileService.FileExists(file))
{
using (new TempCursor(Cursors.WaitCursor))
{
LoggingService.Info(ResourceService.GetString("LOADING_TASK_DEFINITION_WAIT"));
if (TaskDefinitionHelper.IsBulkCopy(file))
{
string name = string.Empty;
FdoBulkCopyOptions opt = ldr.BulkCopyFromXml(file, ref name, false);
FdoBulkCopy cpy = new FdoBulkCopy(opt);
mgr.AddTask(name, cpy);
}
else if (TaskDefinitionHelper.IsJoin(file))
{
string name = string.Empty;
FdoJoinOptions opt = ldr.JoinFromXml(file, ref name, false);
FdoJoin join = new FdoJoin(opt);
mgr.AddTask(name, join);
}
else if (TaskDefinitionHelper.IsSequentialProcess(file))
{
using (var fs = File.OpenRead(file))
{
int counter = 0;
var prefix = Path.GetFileNameWithoutExtension(file);
var name = prefix;
while (mgr.NameExists(name))
{
counter++;
name = prefix + counter;
}
var def = (SequentialProcessDefinition)SequentialProcessDefinition.Serializer.Deserialize(fs);
var proc = new FdoSequentialProcess(def);
mgr.AddTask(name, proc);
}
}
}
}
}
/// <summary>
/// Loads join options from xml
/// </summary>
/// <param name="def">The deserialized definition</param>
/// <param name="name">The name.</param>
/// <param name="owner">if set to <c>true</c> [owner].</param>
/// <returns></returns>
private FdoJoinOptions JoinFromXml(FdoJoinTaskDefinition def, ref string name, bool owner)
{
FdoJoinOptions opts = new FdoJoinOptions(owner);
name = def.name;
if (def.JoinSettings.DesignatedGeometry != null)
{
opts.GeometryProperty = def.JoinSettings.DesignatedGeometry.Property;
opts.Side = def.JoinSettings.DesignatedGeometry.Side;
}
foreach (JoinKey key in def.JoinSettings.JoinKeys)
{
opts.JoinPairs.Add(key.left, key.right);
}
string dummy = string.Empty;
opts.JoinType = (FdoJoinType)Enum.Parse(typeof(FdoJoinType), def.JoinSettings.JoinType.ToString());
opts.SetLeft(
CreateConnection(def.Left.Provider, def.Left.ConnectionString, null, ref dummy),
def.Left.FeatureSchema,
def.Left.Class);
foreach (string p in def.Left.PropertyList)
{
opts.AddLeftProperty(p);
}
opts.SetRight(
CreateConnection(def.Right.Provider, def.Right.ConnectionString, null, ref dummy),
def.Right.FeatureSchema,
def.Right.Class);
foreach (string p in def.Right.PropertyList)
{
opts.AddRightProperty(p);
}
opts.SetTarget(
CreateConnection(def.Target.Provider, def.Target.ConnectionString, null, ref dummy),
def.Target.FeatureSchema,
def.Target.Class);
opts.LeftPrefix = def.Left.Prefix;
opts.RightPrefix = def.Right.Prefix;
opts.LeftFilter = def.Left.Filter;
opts.RightFilter = def.Right.Filter;
return(opts);
}
/// <summary>
/// Handles the file drop
/// </summary>
/// <param name="file">The file being dropped</param>
public void HandleDrop(string file)
{
TaskManager mgr = ServiceManager.Instance.GetService <TaskManager>();
TaskLoader ldr = new TaskLoader();
string prefix = string.Empty;
FdoJoinOptions opt = ldr.JoinFromXml(file, ref prefix, false);
FdoJoin join = new FdoJoin(opt);
string name = prefix;
int counter = 0;
while (mgr.NameExists(name))
{
counter++;
name = prefix + counter;
}
mgr.AddTask(name, join);
}
public override int Execute()
{
CommandStatus retCode;
DefinitionLoader loader = new DefinitionLoader();
string name = null;
if (TaskDefinitionHelper.IsBulkCopy(_file))
{
FdoBulkCopyTaskDefinition def = null;
using (var sr = new StreamReader(_file))
{
XmlSerializer ser = new XmlSerializer(typeof(FdoBulkCopyTaskDefinition));
def = (FdoBulkCopyTaskDefinition)ser.Deserialize(sr);
}
if (def == null)
{
return((int)CommandStatus.E_FAIL_TASK_VALIDATION);
}
//If more than one task specified, load the default task and weed
//out unneeded elements.
if (_taskNames.Length > 0)
{
base.WriteLine("Certain tasks have been specified, only part of the bulk copy definition will execute");
var keepConnections = new Dictionary <string, FdoConnectionEntryElement>();
var keepTasks = new List <FdoCopyTaskElement>();
//Store needed tasks
foreach (var task in def.CopyTasks)
{
if (Array.IndexOf(_taskNames, task.name) >= 0)
{
keepTasks.Add(task);
}
}
//Store needed connections
foreach (var task in keepTasks)
{
foreach (var conn in def.Connections)
{
//Is referenced as source/target connection?
if (task.Source.connection == conn.name || task.Target.connection == conn.name)
{
if (!keepConnections.ContainsKey(conn.name))
{
keepConnections.Add(conn.name, conn);
}
}
}
}
if (keepTasks.Count != _taskNames.Length)
{
List <string> names = new List <string>();
foreach (var n in _taskNames)
{
bool found = false;
foreach (var task in keepTasks)
{
if (task.name == n)
{
found = true;
break;
}
}
if (!found)
{
names.Add(n);
}
}
base.WriteError("Could not find specified tasks in bulk copy definition: " + string.Join(",", names.ToArray()));
return((int)CommandStatus.E_FAIL_MISSING_BULK_COPY_TASKS);
}
//Now replace
def.Connections = new List <FdoConnectionEntryElement>(keepConnections.Values).ToArray();
def.CopyTasks = keepTasks.ToArray();
}
using (FdoBulkCopyOptions opts = loader.BulkCopyFromXml(def, ref name, true))
{
FdoBulkCopy copy = new FdoBulkCopy(opts);
copy.ProcessMessage += delegate(object sender, MessageEventArgs e)
{
base.WriteLine(e.Message);
};
copy.ProcessAborted += delegate(object sender, EventArgs e)
{
base.WriteLine("Bulk Copy Aborted");
};
copy.ProcessCompleted += delegate(object sender, EventArgs e)
{
base.WriteLine("Bulk Copy Completed");
};
copy.Execute();
List <Exception> errors = new List <Exception>(copy.GetAllErrors());
if (errors.Count > 0)
{
string file = GenerateLogFileName("bcp-error-");
LogErrors(errors, file);
base.WriteError("Errors were encountered during bulk copy.");
retCode = CommandStatus.E_FAIL_BULK_COPY_WITH_ERRORS;
}
else
{
retCode = CommandStatus.E_OK;
}
}
}
else if (TaskDefinitionHelper.IsJoin(_file))
{
if (_taskNames.Length > 0)
{
base.WriteError("Parameter -bcptask is not applicable for join tasks");
return((int)CommandStatus.E_FAIL_INVALID_ARGUMENTS);
}
using (FdoJoinOptions opts = loader.JoinFromXml(_file, ref name, true))
{
opts.Left.Connection.Open();
opts.Right.Connection.Open();
opts.Target.Connection.Open();
FdoJoin join = new FdoJoin(opts);
join.ProcessMessage += delegate(object sender, MessageEventArgs e)
{
base.WriteLine(e.Message);
};
join.Execute();
List <Exception> errors = new List <Exception>(join.GetAllErrors());
if (errors.Count > 0)
{
string file = GenerateLogFileName("join-error-");
LogErrors(errors, file);
base.WriteError("Errors were encountered during join operation");
retCode = CommandStatus.E_FAIL_JOIN_WITH_ERRORS;
}
else
{
retCode = CommandStatus.E_OK;
}
}
}
else if (TaskDefinitionHelper.IsSequentialProcess(_file))
{
var def = (SequentialProcessDefinition)SequentialProcessDefinition.Serializer.Deserialize(File.OpenRead(_file));
var proc = new FdoSequentialProcess(def);
proc.ProcessMessage += delegate(object sender, MessageEventArgs e)
{
base.WriteLine(e.Message);
};
proc.Execute();
List <Exception> errors = new List <Exception>(proc.GetAllErrors());
if (errors.Count > 0)
{
string file = GenerateLogFileName("seq-process-");
LogErrors(errors, file);
base.WriteError("Errors were encountered during sequential process");
}
//Why E_OK? the user should check the log for the underlying return codes
//of individual FdoUtil.exe invocations!
retCode = CommandStatus.E_OK;
}
else
{
retCode = CommandStatus.E_FAIL_UNRECOGNISED_TASK_FORMAT;
}
return((int)retCode);
}
internal void SaveTask()
{
if (string.IsNullOrEmpty(_view.TaskName))
{
throw new TaskValidationException(ResourceService.GetString("ERR_TASK_NAME_REQUIRED"));
}
var leftPropNames = _view.LeftProperties;
var rightPropNames = _view.RightProperties;
var allPropNames = new List <string>();
foreach (var p in leftPropNames)
{
var name = _view.LeftPrefix + p;
if (allPropNames.Contains(name))
{
throw new TaskValidationException(ResourceService.GetStringFormatted("ERR_MERGED_CLASS_DUPLICATE_PROPERTY", name));
}
allPropNames.Add(name);
}
foreach (var p in rightPropNames)
{
var name = _view.RightPrefix + p;
if (allPropNames.Contains(name))
{
throw new TaskValidationException(ResourceService.GetStringFormatted("ERR_MERGED_CLASS_DUPLICATE_PROPERTY", name));
}
allPropNames.Add(name);
}
FdoJoinOptions options = null;
if (_join == null)
{
options = new FdoJoinOptions();
}
else
{
options = _join.Options;
options.Reset();
}
options.SetLeft(
_connMgr.GetConnection(_view.SelectedLeftConnection),
_view.SelectedLeftSchema,
_view.SelectedLeftClass);
options.SetRight(
_connMgr.GetConnection(_view.SelectedRightConnection),
_view.SelectedRightSchema,
_view.SelectedRightClass);
options.SetTarget(
_connMgr.GetConnection(_view.SelectedTargetConnection),
_view.SelectedTargetSchema,
_view.SelectedTargetClass);
if (_view.BatchEnabled)
{
options.BatchSize = _view.BatchSize;
}
if (_view.TargetGeometryPropertyEnabled)
{
if (!string.IsNullOrEmpty(_view.LeftGeometryName) && _view.LeftGeometryChecked)
{
options.GeometryProperty = _view.LeftGeometryName;
options.Side = FdoToolbox.Core.Configuration.JoinSide.Left;
}
else if (!string.IsNullOrEmpty(_view.RightGeometryName) && _view.RightGeometryChecked)
{
options.GeometryProperty = _view.RightGeometryName;
options.Side = FdoToolbox.Core.Configuration.JoinSide.Right;
}
}
options.SetJoinPairs(_view.GetJoinedProperties());
options.JoinType = _view.SelectedJoinType;
foreach (string leftProp in _view.LeftProperties)
{
options.AddLeftProperty(leftProp);
}
foreach (string rightProp in _view.RightProperties)
{
options.AddRightProperty(rightProp);
}
options.LeftPrefix = _view.LeftPrefix;
options.RightPrefix = _view.RightPrefix;
options.LeftFilter = _view.LeftFilter;
options.RightFilter = _view.RightFilter;
options.Validate();
FdoJoin join = null;
if (_join == null) //New join
{
join = new FdoJoin(options);
_taskMgr.AddTask(_view.TaskName, join);
}
else //Join was loaded. Update its options
{
_join.Options = options;
}
}
