public void ExpandObjectNode(TreeGridNode node, bool activate)
{
try
{
object obj = node.Tag;
if (obj == null)
{
return;
}
IReflectClass rclass = DataLayerCommon.ReflectClassFor(obj);
if (rclass == null)
{
return;
}
string classname = rclass.GetName();
if (classname != string.Empty)
{
TraverseObjTree(ref node, obj, classname);
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public TreeGridView ReturnHierarchy(object currObj, string classname)
{
InitializeImageList();
TreeGridView treegrid = InitializeTreeGridView();
try
{
TreeGridNode rootNode = new TreeGridNode();
treegrid.Nodes.Add(rootNode);
IReflectClass rclass = DataLayerCommon.ReflectClassForName(classname);
IType type = ResolveType(rclass);
rootNode.Cells[0].Value = AppendIDTo(type.FullName, GetLocalID(currObj), type);
rootNode.Cells[1].Value = ClassNameFor(currObj.ToString());
SetFieldType(rootNode, type);
rootNode.Tag = currObj;
rootNode.Cells[1].ReadOnly = true;
rootNode.Expand();
rootNode.ImageIndex = 0;
classname = DataLayerCommon.RemoveGFromClassName(classname);
TraverseObjTree(ref rootNode, currObj, classname);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
return(treegrid);
}
private void PopulateTreeGrid(object item, TreeGridNode parentNode)
{
if (item == null)
{
return;
}
IType itemType = ResolveType(DataLayerCommon.ReflectClassFor(item));
if (itemType.IsPrimitive)
{
TraverseObjTree(ref parentNode, item, container.Ext().Reflector().ForObject(item).GetName());
}
else
{
container.Ext().Activate(item, 1);
TreeGridNode collNode = new TreeGridNode();
parentNode.Nodes.Add(collNode);
collNode.Cells[0].Value = AppendIDTo(item.ToString(), GetLocalID(item), itemType);
SetFieldType(collNode, itemType);
collNode.Cells[1].Value = ClassNameFor(item.ToString());
collNode.Tag = item;
collNode.ImageIndex = 0;
collNode.Cells[1].ReadOnly = true;
TraverseObjTree(ref collNode, item, itemType.FullName);
}
}
public List <TreeGridViewRenderer> PopulatePrimitiveValues(object currObj, string fieldType)
{
if (!String.IsNullOrEmpty(fieldType))
{
try
{
TreeGridViewRenderer TreeviewRenderer = new TreeGridViewRenderer();
TreeviewRenderer.DisplayFieldName = fieldType;
TreeviewRenderer.FieldName = TreeviewRenderer.DisplayFieldName;
TreeviewRenderer.FieldValue = currObj.ToString();
TreeviewRenderer.QualifiedName =
DataLayerCommon.RemoveGFromClassName(container.Ext().Reflector().ForObject(currObj).GetName());
TreeviewRenderer.FieldType = fieldType;
TreeviewRenderer.ReadOnlyStatus = readOnly;
TreeviewRenderer.ObjectId = 0;
TreeviewRenderer.HasSubNode = false;
listTreeGridViewRenderers.Add(TreeviewRenderer);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
return(listTreeGridViewRenderers);
}
private void PopulateTreeGrid(object item)
{
if (item == null)
{
return;
}
IType itemType = ResolveType(DataLayerCommon.ReflectClassFor(item));
if (itemType.IsPrimitive)
{
PopulatePrimitiveValues(item, itemType.DisplayName);
}
else
{
container.Ext().Activate(item, 1);
Type type = item.GetType();
if (item is DictionaryEntry || (type.IsGenericType && type.GetGenericTypeDefinition() != null && type.GetGenericTypeDefinition() == typeof(KeyValuePair <,>)))
{
PopulateDictionaryEntry(item);
}
else
{
TreeGridViewRenderer treeviewRenderer = PopulateTreeGridViewRenderer(item, itemType);
listTreeGridViewRenderers.Add(treeviewRenderer);
}
}
}
public List <TreeGridViewRenderer> TraverseObjTree(long id, string classname)
{
container = Db4oClient.Client;
try
{
object currObj = Db4oClient.Client.Ext().GetByID(id);
if (currObj != null)
{
container.Ext().Activate(currObj, 2);
}
IReflectClass refClass =
DataLayerCommon.ReflectClassForName(DataLayerCommon.RemoveGFromClassName(classname));
if (refClass != null)
{
IReflectField[] fieldArr = DataLayerCommon.GetDeclaredFieldsInHeirarchy(refClass);
TraverseFields(id, fieldArr);
return(listTreeGridViewRenderers);
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
return(listTreeGridViewRenderers);
}
private TreeGridViewRenderer PopulateTreeGridViewRenderer(object item, IType itemType)
{
TreeGridViewRenderer treeviewRenderer = new TreeGridViewRenderer();
treeviewRenderer.DisplayFieldName = AppendIDTo(itemType.DisplayName, GetLocalID(item), itemType);
treeviewRenderer.FieldName = itemType.FullName;
treeviewRenderer.QualifiedName = DataLayerCommon.RemoveGFromClassName(container.Ext().Reflector().ForObject(item).GetName());
treeviewRenderer.FieldValue = ClassNameFor(itemType.FullName);
treeviewRenderer.FieldType = SetFieldType(itemType);
treeviewRenderer.ReadOnlyStatus = true;
treeviewRenderer.ObjectId = GetLocalID(item);
treeviewRenderer.ObjectType = itemType;
treeviewRenderer.HasSubNode = itemType.IsCollection || itemType.IsArray;
if (treeviewRenderer.HasSubNode)
{
long longid = GetLocalID(itemType);
if (itemType is GenericObject)
{
treeviewRenderer.ObjectId = longid;
}
else if (longid != 0)
{
treeviewRenderer.ObjectId = longid;
}
else
{
treeviewRenderer.SubObject = item;
}
}
return(treeviewRenderer);
}
public List <TreeGridViewRenderer> ExpandObjectNode(object obj, bool activate)
{
try
{
//object obj = Db4oClient.Client.Ext().GetByID(id);
if (obj == null)
{
return(null);
}
IReflectClass rclass = DataLayerCommon.ReflectClassFor(obj);
if (rclass == null)
{
return(null);
}
string classname = rclass.GetName();
if (classname != string.Empty)
{
TraverseObjTree(GetLocalID(obj), classname);
}
return(listTreeGridViewRenderers);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public void SaveValues(object targetObject, string attribName, object newValue, int offset, IType type)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield != null && !(rfield is GenericVirtualField))
{
if (type.IsArray || type.IsCollection)
{
IList list = rfield.Get(targetObject) as IList;
if (null != list)
{
list[offset] = newValue;
rfield.Set(targetObject, list);
}
}
else
{
SetObject(rfield, targetObject, newValue);
}
}
}
catch (Exception oEx)
{
objectContainer.Rollback();
LoggingHelper.HandleException(oEx);
}
}
public static IType GetType(string declaringClassName)
{
IReflectClass refClass = DataLayerCommon.ReflectClassForName(declaringClassName);
IType type = Db4oClient.TypeResolver.Resolve(refClass);
return(type);
}
public int GetFieldCount()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_className);
if (rClass != null)
{
string type1 = rClass.ToString();
type1 = DataLayerCommon.PrimitiveType(type1);
char[] arr = CommonValues.charArray;
type1 = type1.Trim(arr);
if (!CommonValues.IsPrimitive(type1) && !type1.Contains(BusinessConstants.DB4OBJECTS_SYS))
{
IReflectField[] rFields = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
return(rFields.Length);
}
}
return(0);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(0);
}
}
public static void SetFieldToNull(long id, string fieldName)
{
try
{
object obj = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(obj, 1);
IReflectClass klass = DataLayerCommon.ReflectClassFor(obj);
if (klass != null)
{
IReflectField field = DataLayerCommon.GetDeclaredFieldInHeirarchy(klass, fieldName);
if (field == null)
{
return;
}
field.Set(obj, null);
Db4oClient.Client.Store(obj);
Db4oClient.Client.Commit();
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public Hashtable GetFields()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_className);
IReflectField[] rFields = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
Hashtable FieldList = new Hashtable();
foreach (IReflectField field in rFields)
{
if (!FieldList.ContainsKey(field.GetName()))
{
FieldList.Add(
field.GetName(),
field.GetFieldType().GetName());
}
}
return(FieldList);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public TreeGridViewRenderer FillValuesInTreeGridViewRenderer(long id, string classname)
{
TreeGridViewRenderer treeGridViewRenderer = new TreeGridViewRenderer();
try
{
object currObj = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(currObj, 1);
IReflectClass rclass = DataLayerCommon.ReflectClassForName(classname);
IType type = ResolveType(rclass);
treeGridViewRenderer.QualifiedName = rclass.GetName();
treeGridViewRenderer.DisplayFieldName = AppendIDTo(type.FullName, id, type);
treeGridViewRenderer.FieldName = type.FullName;
treeGridViewRenderer.FieldValue = type.DisplayName;
treeGridViewRenderer.FieldType = SetFieldType(type);
treeGridViewRenderer.ReadOnlyStatus = true;
treeGridViewRenderer.ObjectId = id;
treeGridViewRenderer.ObjectType = type;
}
catch (Exception e)
{
LoggingHelper.HandleException(e);
}
return(treeGridViewRenderer);
}
public static bool CheckForCollection(long id)
{
object obj = GetObjById(id);
IReflectClass clazz = DataLayerCommon.ReflectClassFor(obj);
IType type = Db4oClient.TypeResolver.Resolve(clazz);
return(CheckIsCollection(type));
}
public IType GetFieldType()
{
GenericReflector reflecotr = objectContainer.Ext().Reflector();
IReflectClass klass = reflecotr.ForName(m_classname);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(klass, m_fieldname);
return(Db4oClient.TypeResolver.Resolve(rfield.GetFieldType()));
}
public OMQueryClause(string classname, string fieldname, string fieldoperator, string fieldvalue, CommonValues.LogicalOperators clauseLogicalOperator, string fieldtype)
{
m_clauseLogicalOperator = clauseLogicalOperator;
m_Classname = DataLayerCommon.RemoveGFromClassName(classname);
m_Fieldname = fieldname;
m_Operator = fieldoperator;
m_Value = fieldvalue;
m_FieldType = fieldtype;
}
public FieldDetails(string classname, string fieldname)
{
string CorrectfieldName = fieldname;
int intIndexof = CorrectfieldName.LastIndexOf('.') + 1;
CorrectfieldName = CorrectfieldName.Substring(intIndexof, CorrectfieldName.Length - intIndexof);
m_classname = DataLayerCommon.RemoveGFromClassName(classname);
m_fieldname = CorrectfieldName;
objectContainer = Db4oClient.Client;
}
public void FormulateRootConstraints(IQuery query, string classname)
{
try
{
query.Constrain(DataLayerCommon.ReflectClassForName(classname));
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
public bool CheckForCollections(object obj)
{
try
{
return(DataLayerCommon.IsCollection(obj) || DataLayerCommon.IsArray(obj));
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
public IReflectField[] GetFieldList()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_className);
IReflectField[] rFields = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
return(rFields);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public bool IsPrimitive()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
IReflectField rField = DataLayerCommon.GetDeclaredFieldInHeirarchy(rClass, m_fieldname);
return(rField.GetFieldType().IsPrimitive());
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
private static string ClassNameFor(string type)
{
try
{
if (type != "null")
{
return(DataLayerCommon.RemoveGFromClassName(type));
}
return(null);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
private static object SetField(string attribName, object subObject, object newValue)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(subObject);
if (rclass == null)
{
return(null);
}
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield == null)
{
return(null);
}
if (rfield is GenericVirtualField || rfield.IsStatic())
{
return(null);
}
IType fieldType = Db4oClient.TypeResolver.Resolve(rfield.GetFieldType());
if (!fieldType.IsEditable)
{
if (!fieldType.IsCollection && !fieldType.IsArray)
{
subObject = rfield.Get(subObject);
Db4oClient.Client.Ext().Activate(subObject, 2);
return(subObject);
}
}
else if (subObject != null)
{
rfield.Set(subObject, fieldType.Cast(newValue));
return(subObject);
}
return(null);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public object getClass(string attribName, object subObject, string fullattribName)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(subObject);
if (rclass != null)
{
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield != null)
{
string fieldType = rfield.GetFieldType().GetName();
IType type = Db4oClient.TypeResolver.Resolve(fieldType);
if (m_hashRowContent == null)
{
m_hashRowContent = new Hashtable();
}
if (!type.IsEditable)
{
if (!rfield.GetFieldType().IsCollection() && !rfield.GetFieldType().IsArray())
{
object getObj = rfield.Get(subObject);
if (getObj == null)
{
m_hashRowContent.Add(fullattribName, BusinessConstants.DB4OBJECTS_NULL);
}
return(getObj);
}
}
else
{
object objValue = rfield.Get(subObject);
m_hashRowContent.Add(fullattribName, objValue);
}
}
}
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
return(null);
}
public void TraverseObjTree(ref TreeGridNode rootNode, object currObj, string classname)
{
container = Db4oClient.Client;
IReflectClass refClass = DataLayerCommon.ReflectClassForName(classname);
if (refClass == null)
{
return;
}
string type1 = refClass.ToString();
if (!String.IsNullOrEmpty(type1))
{
try
{
IType type = Db4oClient.TypeResolver.Resolve(refClass);
if (type.IsPrimitive)
{
TreeGridNode node = new TreeGridNode();
rootNode.Nodes.Add(node);
node.Cells[0].Value = ClassNameFor(container.Ext().Reflector().ForObject(currObj).GetName());
node.Cells[1].Value = currObj.ToString();
node.Cells[1].ReadOnly = checkReadonlyStatus();
SetFieldType(node, type);
node.Tag = currObj;
node.ImageIndex = 2;
return;
}
IReflectField[] fieldArr = DataLayerCommon.GetDeclaredFieldsInHeirarchy(refClass);
rootNode = TraverseFields(rootNode, currObj, fieldArr);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
}
public int GetFieldCount()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_className);
if (rClass != null)
{
IType type = Db4oClient.TypeResolver.Resolve(rClass);
if (!type.IsEditable)
{
IReflectField[] rFields = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
return(rFields.Length);
}
}
return(0);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(0);
}
}
public bool GetModifier()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
if (rClass != null)
{
IReflectField rField = DataLayerCommon.GetDeclaredFieldInHeirarchy(rClass, m_fieldname);
if (rField != null)
{
return(rField.IsPublic());
}
}
return(false);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
public Hashtable ResultsWithAttributes(object obj, Hashtable attributeList)
{
try
{
Hashtable hash = new Hashtable();
if (attributeList.Count != 0)
{
foreach (string attribute in attributeList.Keys)
{
hash = UpdateResults(obj, attribute);
}
if (hash != null)
{
hash.Add(BusinessConstants.DB4OBJECTS_REF, obj);
}
}
else
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
if (rClass != null)
{
IReflectField[] reff = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
if (reff != null)
{
hash = checkforprimitives(reff, obj);
}
}
}
return(hash);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public static void SaveDictionary(object targetObject, string attribName, object newValue, object key)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
if (rclass != null)
{
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield != null)
{
if (!(rfield is GenericVirtualField || rfield.IsStatic()))
{
object obj = rfield.Get(targetObject);
ICollection col = (ICollection)obj;
if (col is Hashtable)
{
Hashtable hash = (Hashtable)col;
hash.Remove(key);
hash.Add(key, newValue);
rfield.Set(targetObject, hash);
}
else if (col is IDictionary)
{
IDictionary dict = (IDictionary)col;
dict.Remove(key);
dict.Add(key, newValue);
rfield.Set(targetObject, dict);
}
}
}
}
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
