A specialized form of EtlProcess that merges two feature classes into one. The merged class is created before commencing the join
Inheritance: FdoSpecializedEtlProcess
Exemple #1
0
 public FdoJoinCtl(string taskName, FdoJoin options)
     : this()
 {
     _initOptions = options;
     txtName.Text = taskName;
     txtName.ReadOnly = true; //This is edit mode, so the task name can't be changed
 }
Exemple #2
0
        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 { }
                }
            }
        }
        /// <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);
        }
        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;
            }
        }
        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]);
            }
        }
Exemple #6
0
        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);
                        }
                    }
                }
            }
        }
        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;
        }