private void GuardAgainstMissingFields(TflEntity element, Entity entity, short entityIndex)
        {
            if (_process.Mode != "metadata" && element.Fields.Count == 0)
            {
                try {
                    _process.Logger.EntityInfo(entity.Name, "Detecting fields.");
                    var connection = entity.Input.First().Connection;
                    var fields     = connection.GetEntitySchema(_process, entity, entityIndex == 0);
                    if (!fields.Any())
                    {
                        return;
                    }

                    foreach (var field in fields)
                    {
                        if (String.IsNullOrEmpty(field.Label) || field.Label.Equals(field.Alias))
                        {
                            field.Label = MetaDataWriter.AddSpacesToSentence(field.Alias, true).Replace("_", " ");
                        }
                        var name = field.Name;
                        var f    = element.GetDefaultOf <TflField>(x => x.Name = name);
                        f.Type       = field.Type;
                        f.Length     = field.Length;
                        f.PrimaryKey = field.FieldType.Equals(FieldType.PrimaryKey) || field.FieldType.Equals(FieldType.MasterKey);
                        f.Output     = true;
                        f.Default    = string.Empty;
                        f.Input      = true;
                        f.Precision  = field.Precision;
                        f.Scale      = field.Scale;
                        f.Label      = field.Label;
                        element.Fields.Add(f);
                    }
                    _process.Logger.EntityInfo(entity.Name, "Detected {0} fields.", fields.Count);
                } catch (Exception ex) {
                    throw new TransformalizeException(_process.Logger, "No fields defined.  Unable to detect them for {0}. {1}", entity.Name, ex.Message);
                } finally {
                    if (element.Fields.Count == 0)
                    {
                        throw new TransformalizeException(_process.Logger, entity.Name, "No fields defined.  Unable to detect them for {0}.", entity.Name);
                    }
                }
            }
        }
        public IEnumerable<Row> Run(Process process) {

            var result = Enumerable.Empty<Row>();
            if (!process.IsReady()) {
                return result;
            }

            var timer = new Stopwatch();
            timer.Start();

            process.Setup();

            var fileName = new FileInfo(Path.Combine(Common.GetTemporaryFolder(process.Name), "MetaData.xml")).FullName;
            var writer = new MetaDataWriter(process);
            File.WriteAllText(fileName, writer.Write(), Encoding.UTF8);
            System.Diagnostics.Process.Start(fileName);

            timer.Stop();
            process.Logger.Info( "Calculated metadata in {0}.", timer.Elapsed);
            process.Complete = true;
            return result;
        }
        public ActionResult MetaData(int id) {

            Response.AddHeader("Access-Control-Allow-Origin", "*");
            ConfigurationPart part;
            ApiRequest request;

            var query = _transformalize.GetQuery();

            foreach (var rejection in _apiService.Rejections(id, out request, out part)) {
                return rejection.ContentResult(
                    query["format"],
                    query["flavor"]
                );
            }

            request.RequestType = ApiRequestType.MetaData;
            var transformalizeRequest = new TransformalizeRequest(part, query, null, Logger);
            var logger = new TransformalizeLogger(transformalizeRequest.Part.Title(), part.LogLevel, Logger, OrchardVersion, _moduleVersion);

            var errors = transformalizeRequest.Root.Errors();
            if (errors.Any()) {
                var bad = new TransformalizeResponse();
                request.Status = 501;
                request.Message = "Configuration Problem" + errors.Length.Plural();
                bad.Log.AddRange(errors.Select(p => new[] { DateTime.Now.ToString(CultureInfo.InvariantCulture), "error", ".", ".", p }));
                return new ApiResponse(request, "<tfl></tfl>", bad).ContentResult(
                    query["format"],
                    query["flavor"]
                );
            }

            var metaData = new MetaDataWriter(ProcessFactory.CreateSingle(transformalizeRequest.Root.Processes[0], logger, new Options { Mode = "metadata" })).Write();
            return new ApiResponse(request, metaData).ContentResult(
                query["format"],
                query["flavor"]
            );
        }