/// <summary>
/// Adds the record to list.
/// </summary>
/// <param name="list">The list.</param>
/// <param name="record">The record.</param>
private static void AddRecordToList(List <IActiveRecord> list, IActiveRecord record)
{
lock (list)
{
list.Add(record);
}
}
protected override Module CreateRecord(IActiveRecord activeRecord)
{
ModuleX dalModule = (ModuleX)activeRecord;
return(new Module(dalModule.Id, dalModule.ProjectID, dalModule.Name, dalModule.Description,
dalModule.StartDate, dalModule.ExpEndDate, dalModule.ActEndDate));
}
public virtual DataTable Join(IActiveRecord that, Func <dynamic, dynamic, bool> condition, params ScopedAttribute[] selectedColumns)
{
var results = BuildMergeResultsSet(that);
var thisIdx = Index;
var thatIdx = that.Index;
DataRow[] leftData = new DataRow[GetData().Rows.Count],
rightData = new DataRow[(that.GetData().Rows.Count)];
GetData().Rows.CopyTo(leftData, 0);
that.GetData().Rows.CopyTo(rightData, 0);
var data = from leftRow in leftData
from rightRow in rightData
let left = new VariablesWrapper(vn => leftRow[vn], (vn, v) => leftRow[vn] = v)
let right = new VariablesWrapper(vn => rightRow[vn], (vn, v) => rightRow[vn] = v)
where condition(left, right)
select BuildMergeResultRow(results, leftRow, rightRow);
foreach (var row in data)
{
results.Rows.Add(row);
}
//selectedColumns = selectedColumns?.SelectFrom(n => n.ToLowerInvariant());
results = results.ReduceColumnsToAliases(selectedColumns);
//FinalizeColumns(results, selectedColumns);
GoTo(thisIdx);
that.GoTo(thatIdx);
return(results);
}
public T CreateActiveRecord(IObject esriObject)
{
IActiveRecord objectWrapper = (IActiveRecord)Activator.CreateInstance(typeof(T));
objectWrapper.UnderlyingObject = esriObject;
return((T)objectWrapper);
}
private static object FindRelatedObjects(this IActiveRecord wrapper, FieldAttribute relationshipAttribute)
{
List <IActiveRecord> result;
if (!(relationshipAttribute is RelationshipAttribute))
{
throw new ActiveRecordAttributeException(wrapper.GetType(),
"O atributo não é do tipo HasMany. Não foi possível retornar os objetos relacionados.");
}
var attribute = relationshipAttribute as RelationshipAttribute;
if (attribute.GetType() == typeof(HasManyAttribute))
{
return(HasMany(wrapper, relationshipAttribute));
}
if (attribute.GetType() == typeof(OneToOneAttribute))
{
return(OneToOne(wrapper, relationshipAttribute));
}
if (attribute.GetType() == typeof(BelongsToAttribute))
{
return(Belongs(wrapper, relationshipAttribute));
}
throw new ActiveRecordAttributeException(wrapper.GetType(), "Não foi possível buscar os objetos relacionados.");
}
/// <summary>
/// This method is responsible for translanting between coded domain names
/// and their values, setting into UnderlyingObject the correct value.
/// </summary>
/// <remarks>
/// Imagine a ICodedDomain like:
/// 1 = "Alphanumeric"
/// 2 = "Geographic"
///
/// This method will aways set the value to 1 when passed
/// "Alphanumeric"
/// </remarks>
/// <exception cref="ActiveRecrdAttributeException"></exception>
/// <param name="wrapper"></param>
/// <param name="propertyName"></param>
/// <param name="displayValue"></param>
/// <returns></returns>
private static void SetDisplayValue(this IActiveRecord wrapper, FieldAttribute fieldAtt, string displayValue)
{
if (wrapper.UnderlyingObject == null)
{
FetchUnderlyingObject(wrapper);
}
if (!(fieldAtt is DomainFieldAttribute))
{
throw new ActiveRecordAttributeException(wrapper.GetType(), "O atributo não é tipo domínio.");
}
DomainFieldAttribute domainField = fieldAtt as DomainFieldAttribute;
ICodedValueDomain domain = wrapper.UnderlyingObject.Fields.get_Field(domainField.Index).Domain as ICodedValueDomain;
if (domain == null)
{
throw new ActiveRecordAttributeException(wrapper.GetType(), "Não foi possível localizar o domínio.");
}
for (var i = 0; i <= domain.CodeCount - 1; i++)
{
if (domain.get_Name(i) == displayValue)
{
object codedValue = domain.get_Value(i);
wrapper.UnderlyingObject.set_Value(domainField.Index, codedValue);
}
}
}
protected override Task CreateRecord(IActiveRecord activeRecord)
{
DAL.Task dalTask = (DAL.Task)activeRecord;
return(new Task(dalTask.Id, dalTask.ModuleID, dalTask.Name, dalTask.Description,
(TaskComplexity)dalTask.Complexity, dalTask.StartDate, dalTask.ExpEndDate,
dalTask.ActEndDate));
}
/// <summary>
/// This method retrieves an IActiveRecord by it's ObjectID.
/// </summary>
/// <param name="oid">int</param>
/// <exception cref="RepositoryQueryException"></exception>
/// <returns>T (IActiveRecord)</returns>
public T SingleByOID(int oid)
{
ITable table = GetTable;
IObject esriObject = null;
try
{
esriObject = table.GetRow(oid) as IObject;
}
catch (COMException comEx)
{
_log.Error("Ocorreu um erro COM ao tentar buscar o objeto via OBJECTID.", comEx);
}
catch (Exception ex)
{
_log.Error("Ocorreu um erro desconhecido ao tentar buscar o objeto via OBJECTID", ex);
}
if (esriObject == null)
{
throw new RepositoryQueryException(
"O objeto pesquisado não pode ser encontrado.",
GetWorkspaceDefinition, GetTableDefinition, IsBeingEdited,
String.Format("OID = {0}", oid.ToString()));
}
IActiveRecordFactory <T> factory = new ActiveRecordFactory <T>();
IActiveRecord objectWrapper = factory.CreateActiveRecord(esriObject);
return((T)objectWrapper);
}
public T CreateActiveRecord(int oid)
{
IActiveRecord objectWrapper = (IActiveRecord)Activator.CreateInstance(typeof(T));
objectWrapper.ObjectId = oid;
return((T)objectWrapper);
}
public List <T> Filter(IQueryFilter filter)
{
var results = new List <T>();
var table = this.GetTable;
ICursor cursor = null;
if (table == null)
{
throw new ActiveRecordAttributeException(
this.GetType(),
"Não foi possível encontrar o atributo de tabela.");
}
try
{
var count = table.RowCount(filter);
if (count == 0)
{
return(results);
}
// if we have more records then treshold,
// just grab the object id field
if (count > GetTableDefinition.RecordTreshold)
{
filter.SubFields = table.OIDFieldName;
}
cursor = table.Search(filter, false);
IActiveRecordFactory <T> factory = new ActiveRecordFactory <T>();
IObject tempObject = null;
while ((tempObject = cursor.NextRow() as IObject) != null)
{
if (count <= GetTableDefinition.RecordTreshold)
{
IActiveRecord wrapper = factory.CreateActiveRecord(tempObject);
results.Add((T)wrapper);
}
else
{
IActiveRecord proxyWrapper = factory.CreateActiveRecord(tempObject.OID);
results.Add((T)proxyWrapper);
}
}
}
catch (Exception ex)
{
}
finally
{
if (cursor != null)
{
Marshal.ReleaseComObject(cursor);
}
}
return(results);
}
/// <summary>
/// Retrieves a collection of IActiveRecord using a specific filter.
/// </summary>
/// <param name="filter">Filtering rules</param>
/// <returns>List(T) (IActiveRecord)</returns>
public List <T> FilterLazy(IQueryFilter filter)
{
List <T> results = new List <T>();
ITable table = this.GetTable;
ICursor cursor = null;
if (table == null)
{
throw new RepositoryException(
"Não foi possível obter a tabela para pesquisa",
GetWorkspaceDefinition,
GetTableDefinition,
IsBeingEdited);
}
// lets just grab the object id field to speed things up a bit
filter.SubFields = table.OIDFieldName;
try
{
int count = table.RowCount(filter);
if (count == 0)
{
return(results);
}
cursor = table.Search(filter, false);
IActiveRecordFactory <T> factory = new ActiveRecordFactory <T>();
IObject tempObject = null;
while ((tempObject = cursor.NextRow() as IObject) != null)
{
IActiveRecord proxyWrapper = factory.CreateActiveRecord(tempObject.OID);
results.Add((T)proxyWrapper);
}
}
catch (COMException comEx)
{
throw new RepositoryQueryException(
"Ocorreu um erro durante a pesquisa.",
comEx,
GetWorkspaceDefinition,
GetTableDefinition,
IsBeingEdited,
filter.WhereClause);
}
finally
{
if (cursor != null)
{
Marshal.ReleaseComObject(cursor);
}
}
return(results);
}
public static RepositoryAttribute GetRepositoryDefinition(this IActiveRecord wrapper)
{
object[] attributes = wrapper.GetType().GetCustomAttributes(typeof(RepositoryAttribute), true);
if (attributes.Length != 1)
{
throw new ActiveRecordAttributeException(wrapper.GetType(), "Não foi possível definir o atributo repositório para este tipo.");
}
return(attributes[0] as RepositoryAttribute);
}
private static object HasMany(this IActiveRecord wrapper, FieldAttribute relationshipAttribute)
{
if (!(relationshipAttribute is RelationshipAttribute))
{
throw new ActiveRecordAttributeException(wrapper.GetType(),
"O atributo não é do tipo HasMany. Não foi possível retornar os objetos relacionados.");
}
HasManyAttribute hasMany = relationshipAttribute as HasManyAttribute;
object[] customAttributes = hasMany.ClassType.GetCustomAttributes(typeof(RepositoryAttribute), true);
if (customAttributes.Length != 1)
{
throw new ActiveRecordAttributeException(hasMany.ClassType, "Não foi possível encontrar o controlador da classe.");
}
RepositoryAttribute controlled = (RepositoryAttribute)customAttributes[0];
object relatedController = Activator.CreateInstance(controlled.ControllerType);
if (relatedController == null)
{
throw new ActiveRecordAttributeException(controlled.ControllerType, "Não foi possível instanciar o controller.");
}
PrimaryFieldAttribute pkAtt = wrapper.GetPrimaryKeyDefinition();
if (pkAtt == null)
{
throw new ActiveRecordAttributeException(wrapper.GetType(), "Não foi possível encontrar a chave primária da classe.");
}
IQueryFilter filter = new QueryFilterClass();
filter.WhereClause = String.Format(pkAtt.QuoteValue ? "{0} = '{1}'" : "{0} = {1}", hasMany.FieldName, wrapper.UnderlyingObject.get_Value(pkAtt.Index));
if (!String.IsNullOrEmpty(hasMany.OrderBy))
{
IQueryFilterDefinition definition = filter as IQueryFilterDefinition;
definition.PostfixClause = hasMany.OrderBy;
}
// prepare the method for invoke
// check if the method is lazy or not
MethodInfo filterMethod = null;
filterMethod = controlled.ControllerType.GetMethod(hasMany.Lazy ? "FilterLazy" : "Filter");
var parameters = new object[1];
parameters[0] = filter;
// invoke and return
return(filterMethod.Invoke(relatedController, parameters));
}
public List <T> FindAll()
{
var results = new List <T>();
var table = GetTable;
ICursor cursor = null;
if (table == null)
{
throw new ArgumentException("Não foi possível obter a tabela para pesquisa.");
}
try
{
IQueryFilter filter = new QueryFilterClass {
WhereClause = String.Empty
};
var count = table.RowCount(filter);
if (count > GetTableDefinition.RecordTreshold)
{
filter.SubFields = table.OIDFieldName;
}
cursor = table.Search(null, false);
IActiveRecordFactory <T> factory = new ActiveRecordFactory <T>();
IObject tempObject = null;
while ((tempObject = cursor.NextRow() as IObject) != null)
{
if (count <= GetTableDefinition.RecordTreshold)
{
IActiveRecord wrapper = factory.CreateActiveRecord(tempObject);
results.Add((T)wrapper);
}
else
{
IActiveRecord proxyWrapper = factory.CreateActiveRecord(tempObject.OID);
results.Add((T)proxyWrapper);
}
}
}
finally
{
if (cursor != null)
{
Marshal.ReleaseComObject(cursor);
}
}
return(results);
}
public T Create()
{
ITable table = this.GetTable;
if (table == null)
{
throw new ArgumentException("A tabela não pode ser obtida.");
}
IActiveRecordFactory <T> factory = new ActiveRecordFactory <T>();
IActiveRecord objectWrapper = factory.CreateActiveRecord(table.CreateRow() as IObject);
return((T)objectWrapper);
}
protected virtual DataTable BuildMergeResultsSet(IActiveRecord that)
{
var col = that.GetData().Columns;
var results = new DataTable();
foreach (DataColumn c in Data.Columns)
{
results.Columns.Add(new DataColumn($"{this.TableName}.{c.ColumnName}"));
}
foreach (DataColumn c in col)
{
results.Columns.Add(new DataColumn($"{that.TableName}.{c.ColumnName}"));
}
return(results);
}
public static IActiveRecordState ValidateCar(IActiveRecord record)
{
IActiveRecordState state = new ActiveRecordState();
state.Record = record;
var car = (Car)record;
if (car.CarName.Length > 10)
{
state.AddRuleViolation("CarName", "O nome do carro não pode ter mais de 10 letras.");
}
return(state);
}
protected virtual DataTable BuildMergeResultsSet(IActiveRecord left, IActiveRecord right)
{
var colL = left.GetData().Columns;
var colR = right.GetData().Columns;
var results = new DataTable();
foreach (DataColumn c in colL)
{
results.Columns.Add(new DataColumn($"{left.TableName}.{c.ColumnName}"));
}
foreach (DataColumn c in colR)
{
results.Columns.Add(new DataColumn($"{right.TableName}.{c.ColumnName}"));
}
return(results);
}
public void Delete(IActiveRecord record)
{
if (record == null)
{
return;
}
if (Deleted.Contains(record))
{
return;
}
OnBeforeDelete(new ActiveRecordTransactionEventArgs(record));
_deleted.Add(record);
}
/// <summary>
/// Gets the Owner of a specific IActiveRecord
/// </summary>
/// <param name="wrapper">IActiveRecord</param>
/// <param name="propertyName">string</param>
/// <returns>object</returns>
private static object Belongs(this IActiveRecord wrapper, FieldAttribute relationshipAttribute)
{
if (!(relationshipAttribute is RelationshipAttribute))
{
throw new ActiveRecordAttributeException(wrapper.GetType(),
"O atributo não é do tipo HasMany. Não foi possível retornar os objetos relacionados.");
}
var attribute = relationshipAttribute as BelongsToAttribute;
object[] customAttributes = attribute.ClassType.GetCustomAttributes(typeof(RepositoryAttribute), true);
if (customAttributes.Length != 1)
{
throw new ActiveRecordAttributeException(attribute.ClassType, "Não foi possível encontrar o controlador da classe.");
}
RepositoryAttribute controlled = (RepositoryAttribute)customAttributes[0];
object relatedController = Activator.CreateInstance(controlled.ControllerType);
if (relatedController == null)
{
throw new ActiveRecordAttributeException(controlled.ControllerType, "Não foi possível instanciar o controller.");
}
IQueryFilter filter = new QueryFilterClass();
filter.WhereClause = String.Format(attribute.QuoteValue ? "{0} = '{1}'" : "{0} = {1}", attribute.FieldName, wrapper.UnderlyingObject.get_Value(attribute.ParentValueFieldIndex));
// prepare the method for invoke
// check if the method is lazy or not
MethodInfo singleMethod = null;
singleMethod = controlled.ControllerType.GetMethod("SingleByPrimaryKey");
var parameters = new object[1];
parameters[0] = wrapper.UnderlyingObject.get_Value(attribute.ParentValueFieldIndex);
//case not exist value in foreign key, return null
if (parameters[0] == null || parameters[0].ToString().Equals(""))
{
return(null);
}
// invoke and return
return(singleMethod.Invoke(relatedController, parameters));
}
public static void SetBlobValue(this IActiveRecord wrapper, FieldAttribute attribute, object value)
{
if (!(value is IPersistStream))
{
throw new ActiveRecordException("Nâo é possível persistir um objeto que não implementa IPersistStream.");
}
IMemoryBlobStream memStream = new MemoryBlobStreamClass();
IObjectStream objStream = new ObjectStreamClass();
objStream.Stream = memStream;
IPersistStream persist = (IPersistStream)value;
persist.Save(memStream, 0);
wrapper.UnderlyingObject.set_Value(attribute.Index, memStream);
}
/// <summary>
/// Presets the message details.
/// </summary>
/// <param name="msg">The MSG.</param>
private void PresetMessageDetails(IActiveRecord rec)
{
if (rec.GetType() == typeof(IncomingMessage))
{
IncomingMessage msg = rec as IncomingMessage;
txtMessageContent.Text = msg.Message;
pnlMessage.Visible = true;
pnlWapPush.Visible = false;
}
else if (rec.GetType() == typeof(OutgoingMessage))
{
OutgoingMessage msg = rec as OutgoingMessage;
OutgoingMessageType messageType = (OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), msg.MessageType);
if (messageType == OutgoingMessageType.SMS)
{
txtMessageContent.Text = msg.Message;
pnlMessage.Visible = true;
pnlWapPush.Visible = false;
}
else if (messageType == OutgoingMessageType.WAPPush)
{
cboMessageType.Text = msg.MessageType;
txtWapPushMessage.Text = msg.Message;
txtWapPushUrl.Text = msg.WapUrl;
cboWapPushSignal.Text = msg.WapSignal;
if (msg.WapCreateDate.HasValue)
{
chkWapPushCreated.Checked = true;
dtpWapPushCreated.Value = msg.WapCreateDate.Value;
}
if (msg.WapExpiryDate.HasValue)
{
chkWapPushExpiry.Checked = true;
dtpWapPushExpiryDate.Value = msg.WapExpiryDate.Value;
}
pnlMessage.Visible = false;
pnlWapPush.Visible = true;
}
}
}
/// <summary>
/// This method is responsible for translating between coded domain values
/// and their names, returning the correct name.
/// </summary>
/// Imagine a ICodedDomain like:
/// 1 = "Alphanumeric"
/// 2 = "Geographic"
///
/// This method will always return "Alphanumeric" for the value 1,
/// fetched from UnderlyingObject
/// </remarks>
/// <exception cref="ActiveRecrdAttributeException"></exception>
/// <param name="wrapper">IActiveRecord</param>
/// <param name="propertyName">string</param>
/// <returns>string</returns>
private static string GetDisplayValue(this IActiveRecord wrapper, FieldAttribute fieldAtt)
{
if (wrapper.UnderlyingObject == null)
{
FetchUnderlyingObject(wrapper);
}
if (!(fieldAtt is DomainFieldAttribute))
{
throw new ActiveRecordAttributeException(wrapper.GetType(), "Não é possível obter o atributo de domínio.");
}
DomainFieldAttribute domainField = fieldAtt as DomainFieldAttribute;
ICodedValueDomain domain = wrapper.UnderlyingObject.Fields.get_Field(domainField.Index).Domain as ICodedValueDomain;
if (domain == null)
{
throw new ActiveRecordAttributeException(wrapper.GetType(),
String.Format("Não foi possível localizar o domínio {0}.", domainField.DomainName));
}
string codedValue = wrapper.UnderlyingObject.get_Value(domainField.Index).ToString();
string displayValue = String.Empty;
for (int i = 0; i <= domain.CodeCount - 1; i++)
{
if (domain.get_Value(i).ToString() == codedValue)
{
displayValue = domain.get_Name(i);
break;
}
}
if (displayValue == String.Empty)
{
return(codedValue);
}
else
{
return(displayValue);
}
}
public static object GetBlobValue(this IActiveRecord wrapper, FieldAttribute attribute)
{
IMemoryBlobStream blobStream = wrapper.UnderlyingObject.get_Value(attribute.Index) as IMemoryBlobStream;
if (blobStream == null)
{
return(null);
}
IObjectStream stream = new ObjectStreamClass()
{
Stream = blobStream
};
IPersistStream blob = new PropertySetClass();
blob.Load(blobStream);
return(blob as IPropertySet);
}
/// <summary>
/// This method is responsible for fetching lazy IObjects;
/// </summary>
/// <exception cref="ActiveRecordAttributeException"></exception>
/// <exception cref="ArgumentException"></exception>
private static void FetchUnderlyingObject(this IActiveRecord wrapper)
{
// we can only fetch this object if it's a proxy
if (!wrapper.IsProxy && wrapper.UnderlyingObject != null)
{
return;
}
if (wrapper.ObjectId == 0)
{
return;
}
// find out which controller is responsible for this type of object
RepositoryAttribute controlledAtt = null;
var customAtts = wrapper.GetType().GetCustomAttributes(typeof(RepositoryAttribute), true);
// test if out attribute is configured properly
if (customAtts.Length == 1)
{
controlledAtt = (RepositoryAttribute)customAtts[0];
}
if (controlledAtt == null)
{
throw new ActiveRecordAttributeException(wrapper.GetType(), "Não foi possível localizar o atributo controller.");
}
var controllerType = controlledAtt.ControllerType;
var controller = Activator.CreateInstance(controllerType);
// lets get the method we need and set our parameters
var singleMethod = controllerType.GetMethod("SingleByOID");
var parameters = new object[1];
parameters[0] = wrapper.ObjectId;
// finally invoke the method and set our underlyingObject.
wrapper.UnderlyingObject =
((IActiveRecord)singleMethod.Invoke(controller, parameters)).UnderlyingObject;
}
protected virtual DataTable Join(IExecutionContext ctx, IActiveRecord left, IActiveRecord right)
{
var results = BuildMergeResultsSet(left, right);
var condition = _join;
var leftIdx = left.Index;
var rightIdx = right.Index;
for (left.MoveFirst(); !left.IsAtEnd; left.MoveNext())
{
for (right.MoveFirst(); !right.IsAtEnd; right.MoveNext())
{
if (!left.IsAtEnd && !right.IsAtEnd && (bool)condition.GetGenericValue(ctx))
{
var dr = AddMergeResultRow(results, left.CurrentRow, right.CurrentRow);
}
}
}
left.GoTo(leftIdx);
right.GoTo(rightIdx);
return(results);
}
/// <summary>
/// Retrieves the Primary Key attribute without the need to know
/// the property name
/// </summary>
/// <param name="wrapper">IActiveRecord</param>
/// <returns>PrimaryFieldAttribute</returns>
public static PrimaryFieldAttribute GetPrimaryKeyDefinition(this IActiveRecord wrapper)
{
PrimaryFieldAttribute pkAttribute = null;
var t = wrapper.GetType();
try
{
PropertyInfo[] properties = t.GetProperties();
foreach (PropertyInfo pi in properties)
{
object[] attributes = pi.GetCustomAttributes(typeof(PrimaryFieldAttribute), true);
if (attributes.Length != 1)
{
continue;
}
pkAttribute = (PrimaryFieldAttribute)attributes[0];
break;
}
}
catch (AmbiguousMatchException ambEx)
{
throw new ActiveRecordAttributeException(
wrapper.GetType(),
String.Format("A classe {0} possui dois ou mais atributos de chave primária.", t.Name),
ambEx);
}
catch (ArgumentException argEx)
{
throw new ActiveRecordAttributeException(
wrapper.GetType(),
String.Format("A classe {0} não possui nenhum atributo de chave primária.", t.Name),
argEx);
}
return(pkAttribute);
}
protected override User CreateRecord(IActiveRecord activeRecord)
{
//TODO: optimize UserService.CreateRecord()
DAL.User dalUser = ((DAL.User)activeRecord);
UserProfile profile = new UserProfile(dalUser.Id);
User user = new User(dalUser.Id, (UserRole)dalUser.Role, dalUser.Username, dalUser.Password)
{
Address = profile.Address,
City = profile.City,
Email = profile.Email,
Enabled = dalUser.Enabled,
FirstName = profile.FirstName,
LastName = profile.LastName,
PhoneNumber = profile.PhoneNumber,
State = profile.State,
ZipCode = profile.Zip
};
user.ManagerID = GetManagerID(user.ID);
return(user);
}
/// <summary>
/// Retrieves the Primary Keys attributes without the need to know
/// the property name
/// </summary>
/// <param name="wrapper">IActiveRecord</param>
/// <returns>List of PrimaryFieldAttribute</returns>
public static List <PrimaryFieldAttribute> GetPrimarysKeyDefinitions(this IActiveRecord wrapper)
{
var lstPkAttribute = new List <PrimaryFieldAttribute>();
var t = wrapper.GetType();
try
{
var properties = t.GetProperties();
foreach (var pi in properties)
{
var attributes = pi.GetCustomAttributes(typeof(PrimaryFieldAttribute), true);
if (Equals(attributes.Length, 0))
{
continue;
}
lstPkAttribute.AddRange(attributes.Cast <PrimaryFieldAttribute>());
}
}
catch (AmbiguousMatchException ambEx)
{
throw new ActiveRecordAttributeException(
wrapper.GetType(),
String.Format("A classe {0} possui dois ou mais atributos de chave primária.", t.Name),
ambEx);
}
catch (ArgumentException argEx)
{
throw new ActiveRecordAttributeException(
wrapper.GetType(),
String.Format("A classe {0} não possui nenhum atributo de chave primária.", t.Name),
argEx);
}
return(lstPkAttribute);
}
/// <summary>
/// Gets a value from a specific property.
/// </summary>
/// <remarks>
/// If the IObjectWrapper is a proxy, this method fetches the IObject
/// from the database and assigns it to this.UnderlyingObject
/// </remarks>
/// <exception cref="ActiveRecordAttributeException"></exception>
/// <param name="propertyName">string</param>
/// <returns>object</returns>
public static object GetValue(this IActiveRecord wrapper, string propertyName)
{
if (wrapper.IsProxy)
{
wrapper.FetchUnderlyingObject();
}
if (wrapper.Deleted)
{
throw new ActiveRecordException("O objeto foi deletado e não é possível acessar seus atributos.");
}
FieldAttribute att = wrapper.GetFieldDefinition(typeof(FieldAttribute), propertyName);
if (att == null)
{
throw new ActiveRecordAttributeException(wrapper.GetType(),
String.Format("Não foi possível localizar o atributo de campo para a propriedade {0}", propertyName));
}
if (att is DomainFieldAttribute)
{
return(GetDisplayValue(wrapper, att));
}
if (att is RelationshipAttribute)
{
return(FindRelatedObjects(wrapper, att));
}
if (att.FieldType == esriFieldType.esriFieldTypeBlob)
{
return(GetBlobValue(wrapper, att));
}
return(att.Index == -1 ? null : wrapper.UnderlyingObject.get_Value(att.Index));
}
public ActiveRecordTransactionEventArgs(IActiveRecord record)
{
_record = record;
}
public void Update(IActiveRecord record)
{
if (record == null)
return;
if (Updated.Contains(record))
return;
OnBeforeUpdate(new ActiveRecordTransactionEventArgs(record));
_updated.Add(record);
}
/// <summary>
/// This method is responsible for
/// binding the control data to the
/// database object.
/// </summary>
/// <returns></returns>
public virtual ActiveRecordState BindToDatabase(IActiveRecord record, object control)
{
throw new NotImplementedException();
}
