Example #1
0
        public IDictionary <string, object> create_default_object(mmria.common.metadata.app p_metadata, IDictionary <string, object> p_parent)
        {
            p_parent.Add("_id", Guid.NewGuid().ToString());
            for (var i = 0; i < p_metadata.children.Length; i++)
            {
                mmria.common.metadata.node child = p_metadata.children[i];
                create_default_object(child, p_parent);
            }

            return(p_parent);
        }
Example #2
0
        public static Type CreateObjectFromMetadata(mmria.common.metadata.node node)
        {
            Type result = null;

            switch (node.type.ToLower())
            {
            default:
                Console.WriteLine("CreateObjectFromMetadata unimplemented (0}", node.type);
                break;
            }


            return(result);
        }
Example #3
0
        public mmria.common.metadata.node get_metadata_node(mmria.common.metadata.app p_object, string p_path)
        {
            mmria.common.metadata.node           result       = null;
            System.Text.RegularExpressions.Regex number_regex = new System.Text.RegularExpressions.Regex(@"^\d+$");
            try
            {
                string[] path = p_path.Split('/');

                for (int i = 0; i < path.Length; i++)
                {
                    if (i == 0)
                    {
                        result = p_object.children.Where(c => c.name.Equals(path[i], StringComparison.OrdinalIgnoreCase)).First();
                    }
                    else if (number_regex.IsMatch(path[i]))
                    {
                        continue;
                    }
                    else
                    {
                        switch (result.type.ToLower())
                        {
                        case "form":
                        case "grid":
                        case "group":
                            foreach (mmria.common.metadata.node child in result.children)
                            {
                                if (child.name.Equals(path[i], StringComparison.OrdinalIgnoreCase))
                                {
                                    result = child;
                                    break;
                                }
                            }

                            break;

                        default:
                            System.Console.WriteLine("get_metadata_object: {0} - {1} - {2}", path, result.type, path[i]);
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                System.Console.WriteLine("case_maker.set_value bad mapping {0}\n {1}", p_path, ex);
            }

            return(result);
        }
Example #4
0
        public IDictionary <string, object> create_default_object(mmria.common.metadata.node p_metadata, IDictionary <string, object> p_parent)
        {
            switch (p_metadata.type.ToLower())
            {
            case "grid":
                //p_parent.Add(p_metadata.name, new List<object>());
                var temp             = new List <object>();
                var sample_grid_item = new Dictionary <string, object> {
                };
                for (var i = 0; i < p_metadata.children.Length; i++)
                {
                    mmria.common.metadata.node child = p_metadata.children[i];
                    create_default_object(child, sample_grid_item);
                }
                temp.Add(sample_grid_item);
                p_parent.Add(p_metadata.name, temp);

                break;

            case "form":

                var temp_object = new Dictionary <string, object>();
                for (var i = 0; i < p_metadata.children.Length; i++)
                {
                    mmria.common.metadata.node child = p_metadata.children[i];
                    create_default_object(child, temp_object);
                }

                if
                (
                    !string.IsNullOrWhiteSpace(p_metadata.cardinality) &&
                    (
                        p_metadata.cardinality == "+" ||
                        p_metadata.cardinality == "*"
                    )
                )
                {
                    var temp2 = new List <object>();
                    temp2.Add(temp_object);
                    p_parent.Add(p_metadata.name, temp2);
                }
                else
                {
                    p_parent[p_metadata.name] = temp_object;
                }

                break;

            case "group":
                var temp3 = new Dictionary <string, object>();
                for (var i = 0; i < p_metadata.children.Length; i++)
                {
                    mmria.common.metadata.node child = p_metadata.children[i];
                    create_default_object(child, temp3);
                    if (!p_parent.ContainsKey(p_metadata.name))
                    {
                        p_parent.Add(p_metadata.name, temp3);
                    }
                }
                break;                        /*
                                               * case "app":
                                               * p_parent["_id"] = new Date().toISOString();
                                               * for (var i = 0; i < p_metadata.children.Length; i++)
                                               * {
                                               * mmria.common.metadata.node child  = p_metadata.children[i];
                                               * create_default_object(child, p_parent);
                                               * }
                                               * break;*/

            case "string":
            case "textarea":
            case "address":
                if (!string.IsNullOrWhiteSpace(p_metadata.default_value) && p_metadata.default_value != "")
                {
                    p_parent[p_metadata.name] = p_metadata.default_value;
                }
                else if (!string.IsNullOrWhiteSpace(p_metadata.pre_fill) && p_metadata.pre_fill != "")
                {
                    p_parent[p_metadata.name] = p_metadata.pre_fill;
                }
                else
                {
                    p_parent[p_metadata.name] = "";
                }
                break;

            case "number":
                if (!string.IsNullOrWhiteSpace(p_metadata.default_value) && p_metadata.default_value != "")
                {
                    p_parent[p_metadata.name] = double.Parse(p_metadata.default_value);
                }
                else
                {
                    p_parent[p_metadata.name] = new Double?();
                }
                break;

            case "boolean":
                if (!string.IsNullOrWhiteSpace(p_metadata.default_value) && p_metadata.default_value != "")
                {
                    p_parent[p_metadata.name] = bool.Parse(p_metadata.default_value);
                }
                else
                {
                    p_parent[p_metadata.name] = new Boolean?();
                }
                break;

            case "list":
            case "yes_no":
                if (p_metadata.is_multiselect.HasValue && p_metadata.is_multiselect == true)
                {
                    p_parent[p_metadata.name] = new List <string>();
                }
                else
                {
                    p_parent[p_metadata.name] = "";
                }

                break;

            case "date":
            case "datetime":
                if (!string.IsNullOrWhiteSpace(p_metadata.default_value) && p_metadata.default_value != "")
                {
                    p_parent[p_metadata.name] = DateTimeOffset.Parse(p_metadata.default_value).ToUniversalTime();
                }
                else
                {
                    p_parent[p_metadata.name] = new DateTime? ();
                }
                break;

            case "time":
                if (!string.IsNullOrWhiteSpace(p_metadata.default_value) && p_metadata.default_value != "")
                {
                    p_parent[p_metadata.name] = DateTime.Parse(p_metadata.default_value).ToUniversalTime();
                }
                else
                {
                    p_parent[p_metadata.name] = new DateTime?();
                }
                //p_parent[p_metadata.name] = DateTime.Parse("2016-01-01T00:00:00.000Z");
                break;

            case "label":
            case "button":
                break;

            default:
                System.Console.WriteLine("create_default_object not processed {0}", p_metadata);
                break;
            }

            return(p_parent);
        }
Example #5
0
        static void Set_LookUp(IDictionary <string, NJsonSchema.JsonSchema> p_parent, mmria.common.metadata.node p_node)
        {
//https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Schema_JsonSchema.htm

            /*
             * var schema = new NJsonSchema.JsonSchema();
             *
             * schema.Type =  NJsonSchema.JsonObjectType.Object;
             * schema.Title = "mmria_case";
             * schema.Description = "Here is a case for your ...!";
             *
             * schema.SchemaVersion = "http://json-schema.org/draft-06/schema#";
             */


            NJsonSchema.JsonSchemaProperty property = null;
            //schema.Properties.Add("name", new NJsonSchema.JsonSchemaProperty(){ Type = NJsonSchema.JsonObjectType.String});
            //schema.Properties.Add("prompt", new NJsonSchema.JsonSchemaProperty(){ Type = NJsonSchema.JsonObjectType.String});

            try
            {
                switch (p_node.type.ToLower())
                {
                case "list":
                    if (p_node.is_multiselect.HasValue && p_node.is_multiselect.Value == true)
                    {
                        property = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.Array
                        };
                        foreach (var value in p_node.values)
                        {
                            property.EnumerationNames.Add(value.value);
                        }
                    }
                    else
                    {
                        property = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.String
                        };
                        p_parent.Add(p_node.name, property);

                        foreach (var value in p_node.values)
                        {
                            property.EnumerationNames.Add(value.value);
                        }
                    }


                    break;
                }
            }
            catch (Exception ex)
            {
                System.Console.Write($"GetSchemaGetSchema(p_parent, p_node) Exception: {ex}");
            }
            //return p_parent;
        }
Example #6
0
        static async Task <NJsonSchema.JsonSchema> GetSchema(IDictionary <string, NJsonSchema.JsonSchema> p_lookup, NJsonSchema.JsonSchema p_parent, mmria.common.metadata.node p_node)
        {
            //https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_Schema_JsonSchema.htm

            /*
             * var schema = new NJsonSchema.JsonSchema();
             *
             * schema.Type =  NJsonSchema.JsonObjectType.Object;
             * schema.Title = "mmria_case";
             * schema.Description = "Here is a case for your ...!";
             *
             * schema.SchemaVersion = "http://json-schema.org/draft-06/schema#";
             */


            NJsonSchema.JsonSchemaProperty property      = null;
            NJsonSchema.JsonSchemaProperty property_list = null;
            //schema.Properties.Add("name", new NJsonSchema.JsonSchemaProperty(){ Type = NJsonSchema.JsonObjectType.String});
            //schema.Properties.Add("prompt", new NJsonSchema.JsonSchemaProperty(){ Type = NJsonSchema.JsonObjectType.String});

            try
            {
                switch (p_node.type.ToLower())
                {
                case "form":
                    if (p_node.type.ToLower() == "form" && p_node.cardinality == "*")
                    {
                        property = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.Object
                        };
                        foreach (var child in p_node.children)
                        {
                            await GetSchema(p_lookup, property, child);
                        }
                        p_lookup.Add(p_node.name + "_type", property);
                        property_list = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.Array, Item = p_lookup[p_node.name + "_type"]
                        };
                        //property_list.Properties..Items.Allof(property);
                        p_parent.Properties.Add(p_node.name + "_form", property_list);
                    }
                    else
                    {
                        property = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.Object
                        };
                        foreach (var child in p_node.children)
                        {
                            await GetSchema(p_lookup, property, child);
                        }
                        p_parent.Properties.Add(p_node.name, property);
                    }
                    break;

                case "grid":
                    property = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.Object
                    };
                    foreach (var child in p_node.children)
                    {
                        await GetSchema(p_lookup, property, child);
                    }
                    var number = -1;
                    var key    = p_node.name + "_row";
                    var suffix = "";
                    if (p_lookup.ContainsKey(key))
                    {
                        number = p_lookup.Count;
                        suffix = number.ToString();
                    }

                    var property_name = key + suffix;
                    p_lookup.Add(property_name, property);

                    property_list = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.Array, Item = p_lookup[property_name]
                    };

                    var grid_name = p_node.name + "_grid" + suffix;

                    p_parent.Properties.Add(grid_name, property_list);

                    break;

                case "app":
                case "group":

                    property = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.Object
                    };

                    p_parent.Properties.Add(p_node.name, property);

                    foreach (var child in p_node.children)
                    {
                        await GetSchema(p_lookup, property, child);
                    }
                    break;

                case "textarea":
                case "hidden":
                case "string":
                    var string_property = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.String
                    };

                    if (p_node.default_value != null)
                    {
                        string_property.Default = p_node.default_value;
                    }

                    if (p_node.is_required.HasValue && p_node.is_required.Value)
                    {
                        string_property.IsRequired = true;
                    }

                    p_parent.Properties.Add(p_node.name, string_property);
                    break;

                case "datetime":
                case "date":
                case "time":
                    var date_property = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.String, Format = "date-time"
                    };
                    if (p_node.is_required.HasValue && p_node.is_required.Value)
                    {
                        date_property.IsRequired = true;
                    }
                    p_parent.Properties.Add(p_node.name, date_property);
                    break;

                case "number":
                    var number_property = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.Number
                    };
                    if (p_node.default_value != null)
                    {
                        decimal decimal_value;
                        if (decimal.TryParse(p_node.default_value, out decimal_value))
                        {
                            number_property.Default = decimal_value;
                        }
                    }

                    if (p_node.is_required.HasValue && p_node.is_required.Value)
                    {
                        number_property.IsRequired = true;
                    }

                    if (p_node.min_value != null)
                    {
                        decimal number_value;
                        if (decimal.TryParse(p_node.min_value, out number_value))
                        {
                            number_property.Minimum = number_value;
                        }
                    }

                    if (p_node.max_value != null)
                    {
                        decimal number_value;
                        if (decimal.TryParse(p_node.max_value, out number_value))
                        {
                            number_property.Maximum = number_value;
                        }
                    }

                    p_parent.Properties.Add(p_node.name, number_property);
                    break;

                case "boolean":
                    var boolean_property = new NJsonSchema.JsonSchemaProperty()
                    {
                        Type = NJsonSchema.JsonObjectType.Boolean
                    };
                    if (p_node.is_required.HasValue && p_node.is_required.Value)
                    {
                        boolean_property.IsRequired = true;
                    }

                    if (p_node.default_value != null)
                    {
                        bool bool_value;

                        if (bool.TryParse(p_node.default_value, out bool_value))
                        {
                            boolean_property.Default = bool_value;
                        }
                    }
                    p_parent.Properties.Add(p_node.name, boolean_property);
                    break;

                case "list":
                    if (p_node.is_multiselect.HasValue && p_node.is_multiselect.Value == true)
                    {
                        property = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.Array
                        };
                        p_parent.Properties.Add(p_node.name, property);

                        if (!string.IsNullOrWhiteSpace(p_node.path_reference))
                        {
                            property.Reference = p_lookup[p_node.path_reference.Replace("lookup/", "")];
                            //p_parent.Properties.Add(p_node.name, property);
                        }
                        else
                        {
                            foreach (var value in p_node.values)
                            {
                                property.EnumerationNames.Add(value.value);
                            }
                        }
                    }
                    else
                    {
                        property = new NJsonSchema.JsonSchemaProperty()
                        {
                            Type = NJsonSchema.JsonObjectType.String
                        };
                        p_parent.Properties.Add(p_node.name, property);

                        if (!string.IsNullOrWhiteSpace(p_node.path_reference))
                        {
                            property.Reference = p_lookup[p_node.path_reference.Replace("lookup/", "")];
                            //p_parent.Properties.Add(p_node.name, property);
                        }
                        else
                        {
                            foreach (var value in p_node.values)
                            {
                                property.EnumerationNames.Add(value.value);
                            }
                        }
                    }


                    break;

                case "button":
                case "chart":
                case "label":
                    break;

                default:
                    System.Console.Write($"Convert.cs.GetSchema.switch.Missing: {p_node.type}");
                    break;
                }
            }
            catch (Exception ex)
            {
                System.Console.Write($"GetSchemaGetSchema(p_parent, p_node) Exception: {ex}");
            }
            return(p_parent);
        }
Example #7
0
        private void generate_path_map
        (
            mmria.common.metadata.node p_metadata,
            string p_path,
            string p_file_name,
            string p_form_path,
            System.Collections.Generic.Dictionary <string, int> p_path_to_int_map,
            System.Collections.Generic.Dictionary <string, string> p_path_to_file_name_map,
            System.Collections.Generic.Dictionary <string, mmria.common.metadata.node> p_path_to_node_map,
            System.Collections.Generic.Dictionary <string, string> p_path_to_grid_map,
            System.Collections.Generic.Dictionary <string, string> p_path_to_multi_form_map,
            bool p_is_multiform_context,
            System.Collections.Generic.Dictionary <string, string> p_multi_form_to_grid_map,
            bool p_is_grid_context,
            System.Collections.Generic.HashSet <string> p_path_to_flat_map
        )
        {
            /*
             * if (p_path == "death_certificate/causes_of_death")
             * {
             *      System.Console.Write("break");
             * }*/

            bool is_flat_map  = true;
            bool is_grid      = false;
            bool is_multiform = false;

            string file_name = p_file_name;
            string form_path = p_form_path;

            p_path_to_int_map.Add(p_path, p_path_to_int_map.Count);
            p_path_to_node_map.Add(p_path, p_metadata);



            if (p_metadata.type.ToLower() == "grid")
            {
                is_flat_map = false;
                is_grid     = true;

                /*
                 * if (p_is_multiform_context)
                 * {
                 * }
                 * else
                 * {*/

                file_name = this.convert_path_to_file_name(p_path);

                p_path_to_grid_map.Add(p_path, file_name);

                if (p_is_multiform_context)
                {
                    p_multi_form_to_grid_map.Add(p_path, form_path);
                }
                //}
            }
            else
            {
                is_grid = p_is_grid_context;
            }

            if (p_metadata.type.ToLower() == "form" && (p_metadata.cardinality == "*" || p_metadata.cardinality == "+"))
            {
                is_flat_map  = false;
                file_name    = this.convert_path_to_file_name(p_path);
                form_path    = p_path;
                is_multiform = true;
                p_path_to_multi_form_map.Add(p_path, file_name);
            }
            else
            {
                is_multiform = p_is_multiform_context;
            }

            if (is_flat_map && !(is_multiform || is_grid || p_is_grid_context || p_is_multiform_context))
            {
                p_path_to_flat_map.Add(p_path);
            }

            p_path_to_file_name_map.Add(p_path, file_name);

            if (p_metadata.children != null)
            {
                IList <mmria.common.metadata.node> children = p_metadata.children as IList <mmria.common.metadata.node>;

                for (var i = 0; i < children.Count; i++)
                {
                    var child = children[i];

                    generate_path_map(child, p_path + "/" + child.name, file_name, form_path, p_path_to_int_map, p_path_to_file_name_map, p_path_to_node_map, p_path_to_grid_map, p_path_to_multi_form_map, is_multiform, p_multi_form_to_grid_map, is_grid, p_path_to_flat_map);
                }
            }
        }
Example #8
0
        public void generate(System.Text.StringBuilder result, mmria.common.metadata.node node)
        {
            switch (node.type.ToLower())
            {
            case "form":
                if
                (
                    node.cardinality != null &&
                    (
                        node.cardinality == "*" ||
                        node.cardinality == "+"
                    )
                )
                {
                    result.Append("\"");
                    result.Append(node.name); result.Append("\":{");
                    result.Append("\"type\": \"array\",");
                    result.Append("\"items\": { \"type\":\"object\", \"properties\": { ");

                    for (int i = 0; i < node.children.Length; i++)
                    {
                        var child = node.children [i];
                        generate(result, child);
                        if (i < node.children.Length - 1)
                        {
                            result.Append(",");
                        }
                    }
                    result.Append("}}}\n");
                }
                else
                {
                    result.Append("\"");
                    result.Append(node.name); result.Append("\":{");
                    //result.Append ("\"title\": \"case_item schema\",");
                    result.Append("\"type\": \"object\",");
                    result.Append("\"properties\": {");

                    for (int i = 0; i < node.children.Length; i++)
                    {
                        var child = node.children [i];
                        generate(result, child);
                        if (i < node.children.Length - 1)
                        {
                            result.Append(",");
                        }
                    }
                    result.Append("}}\n");
                }

                break;

            case "group":
                result.Append("\"");
                result.Append(node.name); result.Append("\":{");
                //result.Append ("\"title\": \"case_item schema\",");
                result.Append("\"type\": \"object\",");
                result.Append("\"properties\": {");

                for (int i = 0; i < node.children.Length; i++)
                {
                    var child = node.children [i];
                    generate(result, child);
                    if (i < node.children.Length - 1)
                    {
                        result.Append(",");
                    }
                }
                result.Append("}}\n");
                break;

            case "grid":
                result.Append("\"");
                result.Append(node.name); result.Append("\":{");
                //result.Append ("\"title\": \"case_item schema\",");
                result.Append("\"type\": \"array\",");
                result.Append("\"items\": { \"type\":\"object\", \"properties\": { ");

                for (int i = 0; i < node.children.Length; i++)
                {
                    var child = node.children [i];
                    generate(result, child);
                    if (i < node.children.Length - 1)
                    {
                        result.Append(",");
                    }
                }
                result.Append("}}}\n");
                break;

            default:

                result.Append("\""); result.Append(node.name); result.Append("\": {");
                //result.Append ("\"description\": \"text item.\",");
                switch (node.type.ToLower())
                {
                //case "button":
                case "boolean":
                    result.Append("\"type\": \"boolean\"");
                    break;

                case "date":
                    result.Append("\"type\": \"date\"");
                    break;

                case "number":
                    result.Append("\"type\": \"double\"");
                    break;

                case "time":
                    result.Append("\"type\": \"dateTime\"");
                    break;

                case "list":
                    if (node.is_multiselect != null && node.is_multiselect.HasValue && node.is_multiselect.Value)
                    {
                        result.Append("\"type\": \"array\"");
                    }
                    else
                    {
                        result.Append("\"type\": \"string\"");
                    }

                    break;

                case "string":
                case "label":
                case "textarea":
                default:
                    result.Append("\"type\": \"string\"");
                    break;
                }
                result.Append("}\n");
                break;
            }
        }