예제 #1
0
        /// <summary>
        ///     Froms the class metadata.
        /// </summary>
        /// <param name="classMetadata">The class metadata.</param>
        /// <returns>MemberSuiteObject.</returns>
        public static MemberSuiteObject FromClassMetadata(ClassMetadata classMetadata)
        {
            var mso = new MemberSuiteObject();

            mso.ClassType   = classMetadata.Name;
            mso.ParentTypes = classMetadata.ParentTypes;

            foreach (var field in classMetadata.Fields)
            {
                if (field.Name == null)
                {
                    //throw new ApplicationException("Null field name found - this should not happen.");
                    continue;
                }
                if (mso.Fields.ContainsKey(field.Name))
                {
                    /*throw new ApplicationException(string.Format("Field '{0}' for object type '{1}' was specified more than once.",
                     *  field.Name, classMetadata.Name));*/
                    continue;
                }

                mso.Fields.Add(field.Name, getValidDefaultValue(field.DataType, field.DefaultValue));
            }

            return(mso);
        }
예제 #2
0
        public static MemberSuiteObject2 FromMemberSuiteObject(MemberSuiteObject src)
        {
            var obj2 = new MemberSuiteObject2();

            obj2.ClassType   = src.ClassType;
            obj2.ParentTypes = src.ParentTypes;

            foreach (var entry in src.Fields)
            {
                var value     = entry.Value;
                var childList = value as IList <MemberSuiteObject>;

                // if we have a list of membersuite objects, we need to do something about it
                if (childList != null)
                {
                    //{
                    //    List<MemberSuiteObject2> childList2 = new List<MemberSuiteObject2>();
                    //    foreach (var obj in childList)
                    //        childList2.Add(MemberSuiteObject2.FromMemberSuiteObject(obj));

                    //    value = childList2;

                    //} else if (value is MemberSuiteObject)
                    //    value = MemberSuiteObject2.FromMemberSuiteObject((MemberSuiteObject) value);
                    continue;
                }

                obj2.Fields.Add(new NameValuePair(entry.Key, value));
            }

            return(obj2);
        }
예제 #3
0
        /// <summary>
        ///     Converts to.
        /// </summary>
        /// <param name="mso">The mso.</param>
        /// <param name="t">The t.</param>
        /// <returns>MemberSuiteObject.</returns>
        /// <exception cref="System.Exception">no contructor found for  + t.FullName</exception>
        public static MemberSuiteObject ConvertTo(this MemberSuiteObject mso, Type t)
        {
            if (mso == null)
            {
                return(null);
            }

            var ci = t.GetConstructor(new[] { typeof(MemberSuiteObject) });

            if (ci == null)
            {
                throw new Exception("no contructor found for " + t.FullName);
            }


            var newMSO = (MemberSuiteObject)ci.Invoke(new object[] { mso });

            // change out the lists
            foreach (var pi in t.GetProperties())
            {
                if (typeof(IEnumerable).IsAssignableFrom(pi.PropertyType))
                {
                    var genericArgs = pi.PropertyType.GetGenericArguments();
                    if (genericArgs.Length > 0 && genericArgs[0].IsSubclassOf(typeof(MemberSuiteObject)))
                    {
                        // let's create a new list

                        //!!! Important! Don't use Container in any shared code. Shared code is used by API and JES as well as Console and Portal.
                        // Console and Portal are not configured to use Container!
                        //IList newList = (IList)MemberSuite.Container.GetOrCreateInstance(typeof(List<>).MakeGenericType(genericArgs[0]));

                        var newList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(genericArgs[0]));


                        var oldList = newMSO[pi.Name] as IEnumerable;

                        if (oldList != null)
                        {
                            foreach (MemberSuiteObject msoOld in oldList)
                            {
                                newList.Add(msoOld.ConvertTo(genericArgs[0]));
                            }
                        }

                        newMSO[pi.Name] = newList; // swap out the list
                    }
                }
            }

            newMSO.ClassType = mso.ClassType; // make sure the old class type is kept

            if (mso.ParentTypes != null)
            {
                // copy over parent types
                newMSO.ParentTypes = new List <string>();
                newMSO.ParentTypes.AddRange(mso.ParentTypes);
            }
            return(newMSO);
        }
예제 #4
0
        /// <summary>
        ///     Clones this instance.
        /// </summary>
        /// <returns>MemberSuiteObject.</returns>
        public MemberSuiteObject Clone()
        {
            var mso = new MemberSuiteObject {
                ClassType = ClassType, ParentTypes = ParentTypes
            };

            mso.Fields = new MemberSuiteFieldsDictionary();
            foreach (var item in Fields)
            {
                mso.Fields[item.Key] = item.Value;
            }
            return(mso);
        }
예제 #5
0
 /// <summary>
 ///     _absorbs the specified ms object to absorb.
 /// </summary>
 /// <param name="msObjectToAbsorb">The ms object to absorb.</param>
 /// <exception cref="SDKException">MemberSuite Object of type '{0}' cannot absorb an object of type '{1}'</exception>
 private void _absorb(MemberSuiteObject msObjectToAbsorb)
 {
     if (msObjectToAbsorb == null)
     {
         return;                           // nothing to absorb
     }
     if (ClassType != null && ClassType != msObjectToAbsorb.ClassType)
     {
         throw new SDKException("MemberSuite Object of type '{0}' cannot absorb an object of type '{1}'",
                                ClassType, msObjectToAbsorb.ClassType);
     }
     ClassType = msObjectToAbsorb.ClassType;
     Fields    = msObjectToAbsorb.Fields;
 }
예제 #6
0
        /// <summary>
        ///     Takes an object that is of a type derived from MS Object and converts it to a pure membersuite object
        /// </summary>
        /// <param name="memberSuiteObject">The member suite object.</param>
        /// <returns>MemberSuiteObject.</returns>
        public static MemberSuiteObject ConvertToMemberSuiteObject(MemberSuiteObject memberSuiteObject)
        {
            if (memberSuiteObject == null)
            {
                return(null);
            }
            //if (memberSuiteObject.GetType() == typeof(MemberSuiteObject)) return memberSuiteObject; // no conversion necessary

            var clone = memberSuiteObject.Clone();

            var newValues = new Dictionary <string, object>();

            // now go through and find any lists
            if (clone.Fields != null)
            {
                foreach (var entry in clone.Fields)
                {
                    if (entry.Value == null || !typeof(IEnumerable).IsAssignableFrom(entry.Value.GetType()))
                    {
                        continue;
                    }

                    var genericArgs = entry.Value.GetType().GetGenericArguments();
                    if (genericArgs.Length == 0)
                    {
                        continue;
                    }

                    if (genericArgs[0].IsSubclassOf(typeof(MemberSuiteObject)))  // we have to clone all of these
                    {
                        var objects = new List <MemberSuiteObject>();
                        foreach (var listEntry in (IEnumerable)entry.Value)
                        {
                            objects.Add(ConvertToMemberSuiteObject((MemberSuiteObject)listEntry));
                        }

                        newValues[entry.Key] = objects; // set the new value
                    }
                }
            }

            foreach (var newEntry in newValues)
            {
                clone.Fields[newEntry.Key] = newEntry.Value;
            }

            return(clone);
        }
예제 #7
0
        /// <summary>
        ///     Froms the data row.
        /// </summary>
        /// <param name="dataRow">The data row.</param>
        /// <returns>MemberSuiteObject.</returns>
        public static MemberSuiteObject FromDataRow(DataRow dataRow)
        {
            var result = new MemberSuiteObject();

            foreach (DataColumn column in dataRow.Table.Columns)
            {
                if (column.DataType == typeof(Guid))
                {
                    result[column.ColumnName] = dataRow[column] == DBNull.Value ? null : dataRow[column].ToString();
                    continue;
                }

                result[column.ColumnName] = dataRow[column] == DBNull.Value ? null : dataRow[column];
            }

            return(result);
        }
예제 #8
0
        //public T To<T>() where T : msAggregate, new()
        //{
        //    T mso = new T();

        //    mso._absorb(this);
        //    return mso;

        //}

        /// <summary>
        ///     Initializes a new instance of the <see cref="MemberSuiteObject" /> class,
        ///     using the fields in the absorbing object
        /// </summary>
        /// <param name="msObjectToAbsorb">The ms object to absorb.</param>
        public MemberSuiteObject(MemberSuiteObject msObjectToAbsorb)
        {
            _absorb(msObjectToAbsorb);
        }
예제 #9
0
 /// <summary>
 ///     Converts to.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="mso">The mso.</param>
 /// <returns>``0.</returns>
 public static T ConvertTo <T>(this MemberSuiteObject mso) where T : msDomainObject
 {
     return((T)ConvertTo(mso, typeof(T)));
 }