Ejemplo n.º 1
0
        private void ProcessPropertyChange(IEntity entity, TransactionStep step)
        {
            ElementBaseData ebd = entity.__Elements.Find(e => e.Name.Equals(step.MemberName));

            if (ebd != null)
            {
                if (step.PropertyValueEntity != null)
                {
                    ElementBaseData ebdpv = step.PropertyValueEntity.__Elements.Find(e => e.Name.Equals(step.PropertyValueElementName));
                    if (ebd != null)
                    {
                        memento.Add(new Tuple <IEntity, DataProxy, object>(entity, new DataProxy((int)ebd.ID, ebd.Data), ebdpv.Data));
                        ebd.Data = ebdpv.Data;
                    }
                    else
                    {
                        //set notification
                    }
                }
                else
                {
                    memento.Add(new Tuple <IEntity, DataProxy, object>(entity, new DataProxy((int)ebd.ID, ebd.Data), step.PropertyValue));
                    ebd.Data = step.PropertyValue;
                }
            }
            else
            {
                //set notification
            }
        }
Ejemplo n.º 2
0
        //private static void PopulateChildElement<T>(SqlDataReader reader, ElementBaseData element) where T : IEntity
        //{
        //    if (reader.NextResult())
        //    {
        //        if (element.IsCollection)
        //        {
        //            Type T2 = typeof(T).GetProperties().ToList().Find(p => p.Name.Equals(element.Name)).PropertyType.GetGenericArguments()[0];
        //            //getLogger().Info(string.Format("----------- {0}--------------", T2.FullName));
        //            MethodInfo method = typeof(CRUDActions).GetMethod("PopulateChildElementCollection", BindingFlags.NonPublic | BindingFlags.Static);
        //            MethodInfo generic = method.MakeGenericMethod(T2);
        //            object[] arguments = { reader, element };
        //            generic.Invoke(null, arguments);
        //        }
        //        else
        //        {
        //            if (reader.Read())
        //                (element.Data as IEntity).Elements.Where(el => (el.MultipleResultSetIndex == null && el.IsCollection == false)).ToList<ElementBaseData>().ForEach(e => SetData(reader, e));
        //            else
        //                (element.Data as IEntity).Notifications.Add(new Notification() { Severity = Notification.NoticeType.Warning, Message = "Record not found. for " });
        //        }
        //    }
        //}

        //private static void PopulateChildElementCollection<T2>(SqlDataReader reader, ElementBaseData element)
        //{
        //    (element.Data as Collection<T2>).AddRange(reader);
        //}

        private static void PopulateChildElement <T>(SqlDataReader reader, ElementBaseData element) where T : IEntity
        {
            //if (reader.NextResult())
            //{
            if (element.IsCollection)
            {
                Type       T2        = typeof(T).GetProperties().ToList().Find(p => p.Name.Equals(element.Name)).PropertyType.GetGenericArguments()[0];
                MethodInfo method    = typeof(CRUDActions).GetMethod("PopulateChildElementCollection", BindingFlags.NonPublic | BindingFlags.Static);
                MethodInfo generic   = method.MakeGenericMethod(T2);
                object[]   arguments = { reader, element };
                generic.Invoke(null, arguments);
            }
            else
            {
                if (reader.Read())
                {
                    (element.Data as IEntity).__Elements.Where(el => (el.MultipleResultSetIndex == null && el.IsCollection == false)).ToList <ElementBaseData>().ForEach(e => SetData(reader, e));
                }
                else
                {
                    (element.Data as IEntity).Notifications.Add(new Notification()
                    {
                        Severity = Notification.NoticeType.Warning, Message = "Record not found. for "
                    });
                }
            }
            //}
        }
Ejemplo n.º 3
0
        private void Initialize()
        {
            __EntityName = "Rule";

            ElementBaseData ebdRuleType = new ElementBaseData(RuleElementIndex.RuleType)
            {
                Data = String.Empty
            };
            ElementBaseData ebdMessage = new ElementBaseData(RuleElementIndex.Message)
            {
                Data = String.Empty
            };
            ElementBaseData ebdValue = new ElementBaseData(RuleElementIndex.Value)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsString = new ElementBaseData(RuleElementIndex.IsString)
            {
                Data = false
            };

            RuleFields.Add("RuleType", AddField(ebdRuleType));
            RuleFields.Add("Message", AddField(ebdMessage));
            RuleFields.Add("Value", AddField(ebdValue));
            RuleFields.Add("IsString", AddField(ebdIsString));
        }
Ejemplo n.º 4
0
        private void Initialize()
        {
            __EntityName = "Method";

            ElementBaseData ebdArguments = new ElementBaseData(MethodElementIndex.Arguments)
            {
                Data = new List <Argument>()
            };
            ElementBaseData ebdCode = new ElementBaseData(MethodElementIndex.Code)
            {
                Data = String.Empty
            };
            ElementBaseData ebdReturnType = new ElementBaseData(MethodElementIndex.ReturnType)
            {
                Data = new FieldType()
            };
            ElementBaseData ebdFramework = new ElementBaseData(MethodElementIndex.Framework)
            {
                Data = String.Empty
            };

            MethodFields.Add("Arguments", AddField(ebdArguments));
            MethodFields.Add("Code", AddField(ebdCode));
            MethodFields.Add("ReturnType", AddField(ebdReturnType));
            MethodFields.Add("Framework", AddField(ebdFramework));

            AttachedCollections.Add(ebdArguments);
            AttachedCollections.Add(ebdReturnType);
        }
Ejemplo n.º 5
0
        private void Initialize()
        {
            __EntityName = "Action";

            ElementBaseData ebdParametersIn = new ElementBaseData(ActionElementIndex.ParametersIn)
            {
                Data = new List <Field>()
            };
            ElementBaseData ebdParametersOut = new ElementBaseData(ActionElementIndex.ParametersOut)
            {
                Data = new List <Field>()
            };
            ElementBaseData ebdParametersInOut = new ElementBaseData(ActionElementIndex.ParametersInOut)
            {
                Data = new List <Field>()
            };
            ElementBaseData ebdScript = new ElementBaseData(ActionElementIndex.Script)
            {
                Data = String.Empty
            };

            ActionFields.Add("ParametersIn", AddField(ebdParametersIn));
            ActionFields.Add("ParametersOut", AddField(ebdParametersOut));
            ActionFields.Add("ParametersInOut", AddField(ebdParametersInOut));
            ActionFields.Add("Script", AddField(ebdScript));

            AttachedCollections.Add(ebdParametersIn);
            AttachedCollections.Add(ebdParametersOut);
            AttachedCollections.Add(ebdParametersInOut);
        }
Ejemplo n.º 6
0
        private static bool SetConflicts(IEntity entity, IEntity copy)
        {
            bool ret = false;

            entity.CRUDConflict.Clear();

            long fieldsToSave = entity.Compare();

            if (fieldsToSave > 0)
            {
                long fieldsThatHaveChanged = copy.Compare(entity.__Memento);
                long otherFieldsChanged    = Math.Abs(fieldsToSave - (fieldsToSave & fieldsThatHaveChanged));
                if ((fieldsThatHaveChanged & fieldsToSave) > 0)
                {
                    List <string> conflictMessages = new List <string>();
                    conflictMessages.Add("Other users have altered some of the same data during your session.");
                    long       conflictedFields = fieldsThatHaveChanged & fieldsToSave;
                    List <int> fields           = new List <int>();
                    long       bw = 1;
                    for (int i = 0; i < 64; i++)
                    {
                        if ((conflictedFields & bw) == bw)
                        {
                            int elementId = i;
                            fields.Add(elementId);
                            ElementBaseData element = entity.__Elements[i];
                            conflictMessages.Add(String.Format("Field '{0}' has been changed from '{1}' to '{2}' by another user.", element.Name, entity.__Memento.Find(m => m.ElementId == elementId).Data.ToString(), copy.__Elements[elementId].Data.ToString()));
                        }
                        bw = bw + bw;
                    }

                    List <CRUDOption> options = new List <CRUDOption>();
                    options.Add(new CRUDOption()
                    {
                        Message    = "Save all my changes",
                        OptionType = CRUDOption.CRUDOptionType.SaveAll
                    });
                    if (otherFieldsChanged > 0)
                    {
                        options.Add(new CRUDOption()
                        {
                            Message    = "Save my changes that don't conflict",
                            OptionType = CRUDOption.CRUDOptionType.SaveNonConflicts
                        });
                    }
                    options.Add(new CRUDOption()
                    {
                        Message    = "Cancel Save",
                        OptionType = CRUDOption.CRUDOptionType.Cancel
                    });

                    entity.CRUDConflict.Fields   = fields;
                    entity.CRUDConflict.Messages = conflictMessages;
                    entity.CRUDConflict.Options  = options;
                }
            }

            return(ret);
        }
Ejemplo n.º 7
0
        private void Initialize()
        {
            __EntityName = "FieldPresentation";

            ElementBaseData ebdDefaultValue = new ElementBaseData(FieldPresentationElementIndex.DefaultValue)
            {
                Data = String.Empty
            };
            ElementBaseData ebdDisplayName = new ElementBaseData(FieldPresentationElementIndex.DisplayName)
            {
                Data = String.Empty
            };
            ElementBaseData ebdHideOnAdd = new ElementBaseData(FieldPresentationElementIndex.HideOnAdd)
            {
                Data = false
            };
            ElementBaseData ebdHideOnEdit = new ElementBaseData(FieldPresentationElementIndex.HideOnEdit)
            {
                Data = false
            };
            ElementBaseData ebdHideOnSummary = new ElementBaseData(FieldPresentationElementIndex.HideOnSummary)
            {
                Data = false
            };
            ElementBaseData ebdIsDateOnly = new ElementBaseData(FieldPresentationElementIndex.IsDateOnly)
            {
                Data = false
            };
            ElementBaseData ebdIsTimeOnly = new ElementBaseData(FieldPresentationElementIndex.IsTimeOnly)
            {
                Data = false
            };
            ElementBaseData ebdRedact = new ElementBaseData(FieldPresentationElementIndex.Redact)
            {
                Data = false
            };
            ElementBaseData ebdConfirm = new ElementBaseData(FieldPresentationElementIndex.Confirm)
            {
                Data = false
            };
            ElementBaseData ebdFieldContainerGuid = new ElementBaseData(FieldPresentationElementIndex.FieldContainerGuid)
            {
                Data = Guid.Empty
            };

            FieldPresentationFields.Add("DefaultValue", AddField(ebdDefaultValue));
            FieldPresentationFields.Add("DisplayName", AddField(ebdDisplayName));
            FieldPresentationFields.Add("HideOnAdd", AddField(ebdHideOnAdd));
            FieldPresentationFields.Add("HideOnEdit", AddField(ebdHideOnEdit));
            FieldPresentationFields.Add("HideOnSummary", AddField(ebdHideOnSummary));
            FieldPresentationFields.Add("IsDateOnly", AddField(ebdIsDateOnly));
            FieldPresentationFields.Add("IsTimeOnly", AddField(ebdIsTimeOnly));
            FieldPresentationFields.Add("Redact", AddField(ebdRedact));
            FieldPresentationFields.Add("Confirm", AddField(ebdConfirm));
            FieldPresentationFields.Add("FieldContainerGuid", AddField(ebdFieldContainerGuid));
        }
Ejemplo n.º 8
0
 private static void HydrateElement(ElementBaseData element, SqlParameter parameter)
 {
     if (parameter.SqlDbType.Equals(SqlDbType.Bit))
     {
         element.Data = bool.Parse(parameter.Value.ToString());
     }
     else
     {
         element.Data = parameter.Value;
     }
 }
Ejemplo n.º 9
0
        private void Initialize()
        {
            __EntityName = "Iteration";

            ElementBaseData ebdValue = new ElementBaseData(IterationElementIndex.Value)
            {
                Data = String.Empty
            };

            IterationFields.Add("Value", AddField(ebdValue));
        }
Ejemplo n.º 10
0
        //private bool HasColumn(DataRow row, string columnName)
        //{
        //    return row.Table.Columns.Contains(columnName);
        //}

        private void ProcessReader(ElementBaseData element, SqlDataReader reader)
        {
            if (HasColumn(reader, element.Name))
            {
                var index = reader.GetOrdinal(element.Name);
                //getLogger().Trace(string.Format("Collection->AddRange->ProcessReader {0} {1}", element.Name, reader.GetValue(reader.GetOrdinal(element.Name))));
                element.Data = reader.GetFieldType(index).Name == "Boolean" ? reader.GetBoolean(index) : reader.GetValue(index);
            }
            else
            {
                //getLogger().Debug(String.Format("---------------------------------- element '{0}' not found in data reader", element.Name));
            }
        }
Ejemplo n.º 11
0
        private void Initialize()
        {
            __EntityName = "DataType";

            ElementBaseData ebdSize = new ElementBaseData(DataTypeElementIndex.Size)
            {
                Data = null
            };
            ElementBaseData ebdPrecision = new ElementBaseData(DataTypeElementIndex.Precision)
            {
                Data = null
            };
            ElementBaseData ebdScale = new ElementBaseData(DataTypeElementIndex.Scale)
            {
                Data = null
            };
            ElementBaseData ebdIsIdentity = new ElementBaseData(DataTypeElementIndex.IsIdentity)
            {
                Data = false
            };
            ElementBaseData ebdColumnType = new ElementBaseData(DataTypeElementIndex.ColumnType)
            {
                Data = String.Empty
            };
            ElementBaseData ebdDefaultValue = new ElementBaseData(DataTypeElementIndex.DefaultValue)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsPrimaryKey = new ElementBaseData(DataTypeElementIndex.IsPrimaryKey)
            {
                Data = false
            };
            ElementBaseData ebdMultipleResultSetIndex = new ElementBaseData(DataTypeElementIndex.MultipleResultSetIndex)
            {
                Data = 0
            };
            ElementBaseData ebdIsIdentifier = new ElementBaseData(DataTypeElementIndex.IsIdentifier)
            {
                Data = false
            };

            DataTypeFields.Add("Size", AddField(ebdSize));
            DataTypeFields.Add("Precision", AddField(ebdPrecision));
            DataTypeFields.Add("Scale", AddField(ebdScale));
            DataTypeFields.Add("IsIdentity", AddField(ebdIsIdentity));
            DataTypeFields.Add("ColumnType", AddField(ebdColumnType));
            DataTypeFields.Add("DefaultValue", AddField(ebdDefaultValue));
            DataTypeFields.Add("IsPrimaryKey", AddField(ebdIsPrimaryKey));
            DataTypeFields.Add("MultipleResultSetIndex", AddField(ebdMultipleResultSetIndex));
            DataTypeFields.Add("IsIdentifier", AddField(ebdIsIdentifier));
        }
Ejemplo n.º 12
0
        private void ProcessPropertyEntityRow(IEntity entity, ElementBaseData element, DataRow row, List <string> parentPropertyEntityNames)
        {
            IEntity propertyEntity;

            if (element.Data == null)
            {
                try
                {
                    propertyEntity = (IEntity)Activator.CreateInstance(entity.GetType().AssemblyQualifiedName.Split(',')[1].Trim(), String.Format("{0}.{1}", element.EntityType, element.TypeName)).Unwrap();
                }
                catch (System.Exception ex)
                {
                    return;
                }
            }
            else
            {
                propertyEntity = (IEntity)element.Data;
            }

            parentPropertyEntityNames.Add(propertyEntity.__EntityName);

            propertyEntity.__Elements.Where(ebd => !ebd.IsEntity).ToList().ForEach(ebd =>
            {
                string rowName = String.Format("{0}_{1}", String.Join("_", parentPropertyEntityNames), ebd.Name);

                if (row.Table.Columns.Contains(rowName))
                {
                    ebd.Data = row[rowName];
                }
            });

            propertyEntity.__Elements.Where(ebd => ebd.IsEntity).ToList().ForEach(ebd =>
            {
                ProcessPropertyEntityRow(propertyEntity, ebd, row, parentPropertyEntityNames);
            });

            //foreach (ElementBaseData ebd in propertyEntity.__Elements.Where())
            //{
            //    if (ebd.IsEntity)
            //    {
            //        ProcessPropertyEntityRow(propertyEntity, ebd, row, parentPropertyEntityNames);
            //    }
            //    else if (row.Table.Columns.Contains(propertyEntity.__EntityName + "_" + ebd.Name))
            //    {
            //        ebd.Data = row[propertyEntity.__EntityName + "_" + ebd.Name];
            //    }
            //}

            element.Data = propertyEntity;
        }
Ejemplo n.º 13
0
 private static void SetData(SqlDataReader reader, ElementBaseData element)
 {
     if (HasColumn(reader, element.Name))
     {
         var index = reader.GetOrdinal(element.Name);
         //element.Data = reader.GetValue(reader.GetOrdinal(element.Name));
         element.Data = reader.GetFieldType(index).Name == "Boolean" ? reader.GetBoolean(index) : reader.GetValue(index);
         //getLogger().Trace(String.Format("SetData Name: {0} Value: '{1}'", element.Name, element.Data));
     }
     else
     {
         //getLogger().Debug(String.Format("---------------------------------- element '{0}' not found in data reader", element.Name));
     }
 }
Ejemplo n.º 14
0
        private void Initialize()
        {
            __EntityName = "Argument";

            ElementBaseData ebdFieldType = new ElementBaseData(ArgumentElementIndex.FieldType)
            {
                Data = new FieldType()
            };
            ElementBaseData ebdIsEntity = new ElementBaseData(ArgumentElementIndex.IsEntity)
            {
                Data = false
            };

            ArgumentFields.Add("FieldType", AddField(ebdFieldType));
            ArgumentFields.Add("IsEntity", AddField(ebdIsEntity));

            AttachedCollections.Add(ebdFieldType);
        }
Ejemplo n.º 15
0
        private void Initialize()
        {
            __EntityName = "Base";
            RegisterActions(typeof(BaseActions));

            ElementBaseData ebdComment = new ElementBaseData(BaseElementIndex.Comment)
            {
                ID   = (int)BaseFields.Comment,
                Data = String.Empty
            };
            ElementBaseData ebdInternalNote = new ElementBaseData(BaseElementIndex.InternalNote)
            {
                ID   = (int)BaseFields.InternalNote,
                Data = String.Empty
            };
            ElementBaseData ebdBaseGuid = new ElementBaseData(BaseElementIndex.BaseGuid)
            {
                ID   = (int)BaseFields.BaseGuid,
                Data = Guid.Empty
            };
            ElementBaseData ebdDirtyFlag = new ElementBaseData(BaseElementIndex.DirtyFlag)
            {
                ID   = (int)BaseFields.DirtyFlag,
                Data = false
            };
            ElementBaseData ebdSequence = new ElementBaseData(BaseElementIndex.Sequence)
            {
                ID   = (int)BaseFields.Sequence,
                Data = 0
            };
            ElementBaseData ebdName = new ElementBaseData(BaseElementIndex.Name)
            {
                ID   = (int)BaseFields.Name,
                Data = String.Empty
            };

            __Elements.Add(ebdComment);
            __Elements.Add(ebdInternalNote);
            __Elements.Add(ebdBaseGuid);
            __Elements.Add(ebdDirtyFlag);
            __Elements.Add(ebdSequence);
            __Elements.Add(ebdName);
        }
Ejemplo n.º 16
0
        private void Initialize()
        {
            __EntityName = "Enumeration";

            ElementBaseData ebdIterations = new ElementBaseData(EnumerationElementIndex.Iterations)
            {
                Data = new List <Iteration>()
            };
            ElementBaseData ebdFieldType = new ElementBaseData(EnumerationElementIndex.FieldType)
            {
                Data = new FieldType()
            };

            EnumerationFields.Add("Iterations", AddField(ebdIterations));
            EnumerationFields.Add("FieldType", AddField(ebdFieldType));

            AttachedCollections.Add(ebdIterations);
            AttachedCollections.Add(ebdFieldType);
        }
Ejemplo n.º 17
0
        private void Initialize()
        {
            __EntityName = "Extension";

            ElementBaseData ebdNamespace = new ElementBaseData(ExtensionElementIndex.Namespace)
            {
                Data = String.Empty
            };
            ElementBaseData ebdBluePrintGuid = new ElementBaseData(ExtensionElementIndex.BluePrintGuid)
            {
                Data = Guid.Empty
            };
            ElementBaseData ebdVersion = new ElementBaseData(ExtensionElementIndex.Version)
            {
                Data = String.Empty
            };

            ExtensionFields.Add("Namespace", AddField(ebdNamespace));
            ExtensionFields.Add("BluePrintGuid", AddField(ebdBluePrintGuid));
            ExtensionFields.Add("Version", AddField(ebdVersion));
        }
Ejemplo n.º 18
0
        private void Initialize()
        {
            __EntityName = "Interface";

            ElementBaseData ebdFields = new ElementBaseData(InterfaceElementIndex.Fields)
            {
                Data = new List <Field>()
            };
            ElementBaseData ebdNamespace = new ElementBaseData(InterfaceElementIndex.Namespace)
            {
                Data = String.Empty
            };
            ElementBaseData ebdBluePrintGuid = new ElementBaseData(InterfaceElementIndex.BluePrintGuid)
            {
                Data = Guid.Empty
            };
            ElementBaseData ebdVersion = new ElementBaseData(InterfaceElementIndex.Version)
            {
                Data = String.Empty
            };
            ElementBaseData ebdExtended = new ElementBaseData(InterfaceElementIndex.Extended)
            {
                Data = new Extension()
            };
            ElementBaseData ebdFieldContainerGuid = new ElementBaseData(InterfaceElementIndex.FieldContainerGuid)
            {
                Data = Guid.NewGuid()
            };

            InterfaceFields.Add("Fields", AddField(ebdFields));
            InterfaceFields.Add("Namespace", AddField(ebdNamespace));
            InterfaceFields.Add("BluePrintGuid", AddField(ebdBluePrintGuid));
            InterfaceFields.Add("Version", AddField(ebdVersion));
            InterfaceFields.Add("Extended", AddField(ebdExtended));
            InterfaceFields.Add("FieldContainerGuid", AddField(ebdFieldContainerGuid));

            AttachedCollections.Add(ebdFields);
            AttachedCollections.Add(ebdExtended);
        }
Ejemplo n.º 19
0
        private void ProcessRow(IEntity entity, ElementBaseData element, DataRow row)
        {
            if (element.IsEntity)
            {
                ProcessPropertyEntityRow(entity, element, row, new List <string>());
                //IEntity propertyEntity;
                //if (element.Data == null)
                //    propertyEntity = (IEntity)Activator.CreateInstance(entity.GetType().AssemblyQualifiedName.Split(',')[1].Trim(), String.Format("{0}.{1}", entity.GetType().Namespace, element.TypeName)).Unwrap();
                //else
                //    propertyEntity = (IEntity)element.Data;

                //foreach (ElementBaseData ebd in propertyEntity.__Elements)
                //{
                //    if (row.Table.Columns.Contains(propertyEntity.__EntityName + "_" + ebd.Name))
                //    {
                //        ebd.Data = row[propertyEntity.__EntityName + "_" + ebd.Name];
                //    }
                //}

                //element.Data = propertyEntity;
            }
            else
            {
                if (row.Table.Columns.Contains(element.Name))
                {
                    element.Data = row[element.Name] is System.DBNull ? null : row[element.Name];
                    //var index = reader.GetOrdinal(element.Name);
                    ////getLogger().Trace(string.Format("Collection->AddRange->ProcessReader {0} {1}", element.Name, reader.GetValue(reader.GetOrdinal(element.Name))));
                    //element.Data = reader.GetFieldType(index).Name == "Boolean" ? reader.GetBoolean(index) : reader.GetValue(index);
                }
                else
                {
                    //getLogger().Debug(String.Format("---------------------------------- element '{0}' not found in data reader", element.Name));
                }
            }
        }
Ejemplo n.º 20
0
        private static void UpdateAttachedCollection <T>(SqlConnection conn, IEntity entity, ElementBaseData attachedCollection) where T : IEntity
        {
            Type       T2      = typeof(T).GetProperties().ToList().Find(p => p.Name.Equals(attachedCollection.Name)).PropertyType.GetGenericArguments()[0];
            MethodInfo method  = typeof(CRUDActions).GetMethod("UpdateAttachedCollectionType", BindingFlags.NonPublic | BindingFlags.Static);
            MethodInfo generic = method.MakeGenericMethod(T2);

            object[] arguments = { conn, entity, attachedCollection };
            generic.Invoke(null, arguments);
        }
Ejemplo n.º 21
0
 private static void SaveCollection(ElementBaseData ebd, IEntity copy)
 {
     //(ebdData as List<T>)
 }
Ejemplo n.º 22
0
        private void Initialize()
        {
            __EntityName = "Field";

            ElementBaseData ebdDisplayName = new ElementBaseData(FieldElementIndex.DisplayName)
            {
                Data = String.Empty
            };
            ElementBaseData ebdRules = new ElementBaseData(FieldElementIndex.Rules)
            {
                Data = new List <Rule>()
            };
            ElementBaseData ebdDataType = new ElementBaseData(FieldElementIndex.DataType)
            {
                Data = new DataType()
            };
            ElementBaseData ebdAttributes = new ElementBaseData(FieldElementIndex.Attributes)
            {
                Data = new List <Attribute>()
            };
            ElementBaseData ebdDefaultValue = new ElementBaseData(FieldElementIndex.DefaultValue)
            {
                Data = String.Empty
            };
            ElementBaseData ebdFieldType = new ElementBaseData(FieldElementIndex.FieldType)
            {
                Data = new FieldType()
            };
            ElementBaseData ebdIsNodeAttribute = new ElementBaseData(FieldElementIndex.IsNodeAttribute)
            {
                Data = false
            };
            ElementBaseData ebdIsNodeValue = new ElementBaseData(FieldElementIndex.IsNodeValue)
            {
                Data = false
            };
            ElementBaseData ebdIsDateOnly = new ElementBaseData(FieldElementIndex.IsDateOnly)
            {
                Data = false
            };
            ElementBaseData ebdIsTimeOnly = new ElementBaseData(FieldElementIndex.IsTimeOnly)
            {
                Data = false
            };
            ElementBaseData ebdUseForMatching = new ElementBaseData(FieldElementIndex.UseForMatching)
            {
                Data = false
            };
            ElementBaseData ebdIsEntity = new ElementBaseData(FieldElementIndex.IsEntity)
            {
                Data = false
            };
            ElementBaseData ebdDataChangeNotification = new ElementBaseData(FieldElementIndex.DataChangeNotification)
            {
                Data = false
            };
            ElementBaseData ebdDependant = new ElementBaseData(FieldElementIndex.Dependant)
            {
                Data = false
            };
            ElementBaseData ebdHideOnAdd = new ElementBaseData(FieldElementIndex.HideOnAdd)
            {
                Data = false
            };
            ElementBaseData ebdHideOnEdit = new ElementBaseData(FieldElementIndex.HideOnEdit)
            {
                Data = false
            };
            ElementBaseData ebdHideOnSummary = new ElementBaseData(FieldElementIndex.HideOnSummary)
            {
                Data = false
            };
            ElementBaseData ebdRedact = new ElementBaseData(FieldElementIndex.Redact)
            {
                Data = false
            };
            ElementBaseData ebdConfirm = new ElementBaseData(FieldElementIndex.Confirm)
            {
                Data = false
            };
            ElementBaseData ebdFieldPresentations = new ElementBaseData(FieldElementIndex.FieldPresentations)
            {
                Data = new List <FieldPresentation>()
            };

            FieldFields.Add("DisplayName", AddField(ebdDisplayName));
            FieldFields.Add("Rules", AddField(ebdRules));
            FieldFields.Add("DataType", AddField(ebdDataType));
            FieldFields.Add("Attributes", AddField(ebdAttributes));
            FieldFields.Add("DefaultValue", AddField(ebdDefaultValue));
            FieldFields.Add("FieldType", AddField(ebdFieldType));
            FieldFields.Add("IsNodeAttribute", AddField(ebdIsNodeAttribute));
            FieldFields.Add("IsNodeValue", AddField(ebdIsNodeValue));
            FieldFields.Add("IsDateOnly", AddField(ebdIsDateOnly));
            FieldFields.Add("IsTimeOnly", AddField(ebdIsTimeOnly));
            FieldFields.Add("UseForMatching", AddField(ebdUseForMatching));
            FieldFields.Add("IsEntity", AddField(ebdIsEntity));
            FieldFields.Add("DataChangeNotification", AddField(ebdDataChangeNotification));
            FieldFields.Add("Dependant", AddField(ebdDependant));
            FieldFields.Add("HideOnAdd", AddField(ebdHideOnAdd));
            FieldFields.Add("HideOnEdit", AddField(ebdHideOnEdit));
            FieldFields.Add("HideOnSummary", AddField(ebdHideOnSummary));
            FieldFields.Add("Redact", AddField(ebdRedact));
            FieldFields.Add("Confirm", AddField(ebdConfirm));
            FieldFields.Add("FieldPresentations", AddField(ebdFieldPresentations));

            AttachedCollections.Add(ebdRules);
            AttachedCollections.Add(ebdDataType);
            AttachedCollections.Add(ebdAttributes);
            AttachedCollections.Add(ebdFieldType);
            AttachedCollections.Add(ebdFieldPresentations);
        }
Ejemplo n.º 23
0
        private static void UpdateAttachedCollectionType <T2>(SqlConnection conn, IEntity entity, ElementBaseData attachedCollection) where T2 : IEntity
        {
            SqlParameter[] para = BuildSqlParameters(entity.__Elements.Where(e => e.UseForMatching).ToList());
            para = para.Distinct().ToArray();

            if (conn.State.Equals(ConnectionState.Closed))
            {
                conn.Open();
            }

            (attachedCollection.Data as List <T2>).ForEach(e => UpdateAttachedCollectionItem <T2>(conn, entity, para, e, attachedCollection.Name));
        }
Ejemplo n.º 24
0
        private void Initialize()
        {
            __EntityName = "FieldType";

            ElementBaseData ebdFramework = new ElementBaseData(FieldTypeElementIndex.Framework)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsNullable = new ElementBaseData(FieldTypeElementIndex.IsNullable)
            {
                Data = false
            };
            ElementBaseData ebdIsCollection = new ElementBaseData(FieldTypeElementIndex.IsCollection)
            {
                Data = false
            };
            ElementBaseData ebdCollectionType = new ElementBaseData(FieldTypeElementIndex.CollectionType)
            {
                Data = String.Empty
            };
            ElementBaseData ebdDefaultValue = new ElementBaseData(FieldTypeElementIndex.DefaultValue)
            {
                Data = String.Empty
            };
            ElementBaseData ebdTextEncoding = new ElementBaseData(FieldTypeElementIndex.TextEncoding)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsFactoryEntity = new ElementBaseData(FieldTypeElementIndex.IsFactoryEntity)
            {
                Data = false
            };
            ElementBaseData ebdFieldTypeOption = new ElementBaseData(FieldTypeElementIndex.FieldTypeOption)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsInterface = new ElementBaseData(FieldTypeElementIndex.IsInterface)
            {
                Data = false
            };
            ElementBaseData ebdNamespace = new ElementBaseData(FieldTypeElementIndex.Namespace)
            {
                Data = String.Empty
            };
            ElementBaseData ebdFieldTypeName = new ElementBaseData(FieldTypeElementIndex.FieldTypeName)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsAttached = new ElementBaseData(FieldTypeElementIndex.IsAttached)
            {
                Data = false
            };
            ElementBaseData ebdDoNotPersist = new ElementBaseData(FieldTypeElementIndex.DoNotPersist)
            {
                Data = false
            };
            ElementBaseData ebdSqlDataType = new ElementBaseData(FieldTypeElementIndex.SqlDataType)
            {
                Data = String.Empty
            };
            ElementBaseData ebdBluePrintGuid = new ElementBaseData(FieldTypeElementIndex.BluePrintGuid)
            {
                Data = Guid.Empty
            };
            ElementBaseData ebdVersion = new ElementBaseData(FieldTypeElementIndex.Version)
            {
                Data = String.Empty
            };
            ElementBaseData ebdIsOneToMany = new ElementBaseData(FieldTypeElementIndex.IsOneToMany)
            {
                Data = false
            };

            FieldTypeFields.Add("Framework", AddField(ebdFramework));
            FieldTypeFields.Add("IsNullable", AddField(ebdIsNullable));
            FieldTypeFields.Add("IsCollection", AddField(ebdIsCollection));
            FieldTypeFields.Add("CollectionType", AddField(ebdCollectionType));
            FieldTypeFields.Add("DefaultValue", AddField(ebdDefaultValue));
            FieldTypeFields.Add("TextEncoding", AddField(ebdTextEncoding));
            FieldTypeFields.Add("IsFactoryEntity", AddField(ebdIsFactoryEntity));
            FieldTypeFields.Add("FieldTypeOption", AddField(ebdFieldTypeOption));
            FieldTypeFields.Add("IsInterface", AddField(ebdIsInterface));
            FieldTypeFields.Add("Namespace", AddField(ebdNamespace));
            FieldTypeFields.Add("FieldTypeName", AddField(ebdFieldTypeName));
            FieldTypeFields.Add("IsAttached", AddField(ebdIsAttached));
            FieldTypeFields.Add("DoNotPersist", AddField(ebdDoNotPersist));
            FieldTypeFields.Add("SqlDataType", AddField(ebdSqlDataType));
            FieldTypeFields.Add("BluePrintGuid", AddField(ebdBluePrintGuid));
            FieldTypeFields.Add("Version", AddField(ebdVersion));
            FieldTypeFields.Add("IsOneToMany", AddField(ebdIsOneToMany));
        }
Ejemplo n.º 25
0
        private void Initialize()
        {
            __EntityName = "Entity";

            ElementBaseData ebdFields = new ElementBaseData(EntityElementIndex.Fields)
            {
                Data = new List <Field>()
            };
            ElementBaseData ebdActions = new ElementBaseData(EntityElementIndex.Actions)
            {
                Data = new List <Action>()
            };
            ElementBaseData ebdEnumerators = new ElementBaseData(EntityElementIndex.Enumerators)
            {
                Data = new List <Enumeration>()
            };
            ElementBaseData ebdAttributes = new ElementBaseData(EntityElementIndex.Attributes)
            {
                Data = new List <Attribute>()
            };
            ElementBaseData ebdInterfaces = new ElementBaseData(EntityElementIndex.Interfaces)
            {
                Data = new List <Interface>()
            };
            ElementBaseData ebdExtended = new ElementBaseData(EntityElementIndex.Extended)
            {
                Data = new Extension()
            };
            ElementBaseData ebdEntityId = new ElementBaseData(EntityElementIndex.EntityId)
            {
                Data = 0
            };
            ElementBaseData ebdEntityName = new ElementBaseData(EntityElementIndex.EntityName)
            {
                Data = String.Empty
            };
            ElementBaseData ebdBluePrintGuid = new ElementBaseData(EntityElementIndex.BluePrintGuid)
            {
                Data = Guid.Empty
            };
            ElementBaseData ebdVersion = new ElementBaseData(EntityElementIndex.Version)
            {
                Data = String.Empty
            };
            ElementBaseData ebdDeletionType = new ElementBaseData(EntityElementIndex.DeletionType)
            {
                Data = DeletionTypeOption.Delete
            };
            ElementBaseData ebdIcon = new ElementBaseData(EntityElementIndex.Icon)
            {
                Data = String.Empty
            };
            ElementBaseData ebdMethods = new ElementBaseData(EntityElementIndex.Methods)
            {
                Data = new List <Method>()
            };
            ElementBaseData ebdFieldContainerGuid = new ElementBaseData(EntityElementIndex.FieldContainerGuid)
            {
                Data = Guid.NewGuid()
            };

            EntityFields.Add("Fields", AddField(ebdFields));
            EntityFields.Add("Actions", AddField(ebdActions));
            EntityFields.Add("Enumerators", AddField(ebdEnumerators));
            EntityFields.Add("Attributes", AddField(ebdAttributes));
            EntityFields.Add("Interfaces", AddField(ebdInterfaces));
            EntityFields.Add("Extended", AddField(ebdExtended));
            EntityFields.Add("EntityId", AddField(ebdEntityId));
            EntityFields.Add("EntityName", AddField(ebdEntityName));
            EntityFields.Add("BluePrintGuid", AddField(ebdBluePrintGuid));
            EntityFields.Add("Version", AddField(ebdVersion));
            EntityFields.Add("DeletionType", AddField(ebdDeletionType));
            EntityFields.Add("Icon", AddField(ebdIcon));
            EntityFields.Add("Methods", AddField(ebdMethods));
            EntityFields.Add("FieldContainerGuid", AddField(ebdFieldContainerGuid));

            AttachedCollections.Add(ebdFields);
            AttachedCollections.Add(ebdActions);
            AttachedCollections.Add(ebdEnumerators);
            AttachedCollections.Add(ebdAttributes);
            AttachedCollections.Add(ebdInterfaces);
            AttachedCollections.Add(ebdExtended);
            AttachedCollections.Add(ebdMethods);
        }
Ejemplo n.º 26
0
        private static void PopulateChildElementCollection <T2>(SqlDataReader reader, ElementBaseData element) where T2 : IEntity
        {
            Collection <T2> col = new Collection <T2>();

            col.AddRange(reader);

            col.ToList().ForEach(i => (element.Data as List <T2>).Add(i));
            //(element.Data as Collection<T2>).AddRange(reader);
        }
Ejemplo n.º 27
0
        private static void ConvertElementToSqlParameterIn(List <SqlParameter> parameters, ElementBaseData ebd)
        {
            //if (ebd.IsEntity)
            //{
            //    Type elementType = ebd.Data.GetType();
            //    IEntity entityInstance = (IEntity)Activator.CreateInstance(elementType);

            //    List<ElementBaseData> childElements = entityInstance.Elements.Where(i => (ebd.ChildParametersIn & i.Bitwise) = i.Bitwise);
            //}
            //else
            parameters.Add(new SqlParameter(ebd.Name, ebd.Data));
        }