/// <summary>
/// Build the folder tree below this node.
/// </summary>
/// <param name="entityRow"></param>
private void BuildTree(EntityRow entityRow)
{
EntityTreeRow[] entityTreeRows = entityRow.GetEntityTreeRowsByFK_Entity_EntityTree_ParentId();
foreach (EntityTreeRow entityTreeRow in entityTreeRows)
{
Boolean inserted = false;
// Add the new tree relations in alphabetical order.
for (int targetIndex = 0; !inserted && targetIndex < this.Children.Count; targetIndex++)
{
if (entityTreeRow.EntityRowByFK_Entity_EntityTree_ChildId.Name.CompareTo(this.Children[targetIndex].Entity.Name) < 0)
{
this.Children.Insert(targetIndex, new FolderTreeNode(entityTreeRow));
inserted = true;
}
}
// Any we missed go at the end.
if (!inserted)
{
this.Children.Add(new FolderTreeNode(entityTreeRow));
}
}
}
/// <summary>
/// Update the entity with the information current in the DataModel.
/// </summary>
/// <param name="entityRow">The entity row to base the update on.</param>
public override void Update(EntityRow entityRow)
{
// HACK: CommissionSchedule should be in all blotters.
DebtClassRow debtClassRow = DataModel.DebtClass.DebtClassKey.Find(entityRow.EntityId);
base.Update(entityRow);
if (!this.Modified && this.EntityId == entityRow.EntityId)
{
if (debtClassRow != null && debtClassRow.CommissionScheduleRow != null)
{
if (this.commissionSchedule != null)
{
this.commissionSchedule.Update(debtClassRow.CommissionScheduleRow);
}
else
{
this.commissionSchedule = new CommissionSchedule(debtClassRow.CommissionScheduleRow);
this.commissionSchedule.PropertyChanged += this.OnCommissionScheduleChanged;
}
}
else if (this.commissionSchedule != null)
{
this.commissionSchedule.PropertyChanged -= this.OnCommissionScheduleChanged;
this.commissionSchedule = null;
}
this.Modified = false;
}
}
/// <summary>
/// Filter what rows are included in the list based on the value of includeRemovedUsers.
/// </summary>
/// <param name="row">The row to examine.</param>
/// <returns>False if IncludeRemovedUsers is false and the user has been removed; true otherwise.</returns>
protected override bool Filter(DataRow row)
{
RightsHolderRow rightsHolderRow = null;
UserRow[] userRow;
if (row is RightsHolderRow)
{
rightsHolderRow = row as RightsHolderRow;
}
else if (row is EntityRow)
{
EntityRow entityRow = row as EntityRow;
if (entityRow.GetRightsHolderRows().Length != 0)
{
rightsHolderRow = entityRow.GetRightsHolderRows()[0];
}
}
else
{
throw new RowNotHandledException("row isn't the right kind of row");
}
userRow = rightsHolderRow.GetUserRows();
return(this.includeRemovedUsers || userRow.Length == 0 || !userRow[0].IsRemoved);
}
/// <summary>
/// Initialize the list of root folders.
/// </summary>
private void InitializeFolders(Guid parentId)
{
lock (DataModel.SyncRoot)
{
LambdaComparer <FolderTreeNode> folderTreeNodeComparer = new LambdaComparer <FolderTreeNode>((l, r) => l.Entity.Name.CompareTo(r.Entity.Name));
List <FolderTreeNode> folders = new List <FolderTreeNode>();
EntityRow parentEntityRow = DataModel.Entity.EntityKey.Find(parentId);
foreach (EntityTreeRow entityTreeRow in parentEntityRow.GetEntityTreeRowsByFK_Entity_EntityTree_ParentId())
{
FolderTreeNode folderTreeNode = new FolderTreeNode()
{
Entity = new Entity(entityTreeRow.EntityRowByFK_Entity_EntityTree_ChildId)
};
Int32 index = folders.BinarySearch(folderTreeNode, folderTreeNodeComparer);
if (index < 0)
{
index = ~index;
}
folders.Insert(index, folderTreeNode);
}
this.Dispatcher.BeginInvoke(new Action(() => this.Folders = folders), DispatcherPriority.Normal);
}
}
/// <summary>
/// See if the ChildId is a ParentId to stop circular reference.
/// </summary>
/// <param name="transaction"></param>
/// <param name="parent"></param>
/// <param name="childId"></param>
/// <returns></returns>
private bool IsParentEntity(DataModelTransaction transaction, EntityRow parent, Guid childId)
{
parent.AcquireReaderLock(transaction.TransactionId, DataModel.LockTimeout);
try
{
//Make sure we are not adding a child element that is also a parent.
foreach (EntityTreeRow entityRow in parent.GetEntityTreeRowsByFK_Entity_EntityTree_ChildId())
{
entityRow.AcquireWriterLock(transaction.TransactionId, DataModel.LockTimeout);
try
{
if (entityRow.ParentId == childId)
{
return(true);
}
if (IsParentEntity(transaction, entityRow.EntityRowByFK_Entity_EntityTree_ParentId, childId) == true)
{
return(true);
}
}
finally
{
entityRow.ReleaseLock(transaction.TransactionId);
}
}
}
finally
{
parent.ReleaseReaderLock(transaction.TransactionId);
}
return(false);
}
/// <summary>
/// Create an entity.
/// </summary>
/// <param name="entityRow">The description of the entity.</param>
public Entity(EntityRow entityRow)
{
// Initialize the object
this.createdTime = entityRow.CreatedTime.ToLocalTime();
this.description = entityRow.IsDescriptionNull() ? String.Empty : entityRow.Description;
this.entityId = entityRow.EntityId;
this.modifiedTime = entityRow.ModifiedTime.ToLocalTime();
this.name = entityRow.Name;
this.imageId = entityRow.ImageId;
this.imageData = entityRow.ImageRow.Image;
this.isReadOnly = entityRow.IsReadOnly;
this.isHidden = entityRow.IsHidden;
this.rowVersion = entityRow.RowVersion;
this.tenantId = entityRow.TenantId;
this.typeId = entityRow.TypeId;
this.typeName = entityRow.TypeRow.Description;
this.viewerType = entityRow.TypeRow.ViewerType;
this.propertiesWindow = null;
if (this.NeedLateLoad())
{
this.finishedLoading = false;
DataModel.EndMerge += this.FinishLateLoad;
}
else
{
this.finishedLoading = true;
this.FinishLoad();
}
}
/// <summary>
/// Find the nearest ancestor DebtClass that has a value for a particular field.
/// </summary>
/// <param name="debtClassId">The DebtClassId of the debt class to start with.</param>
/// <param name="field">The column to look at.</param>
/// <returns>The row of the first debt class found to have a value for the indicated field (including the initial debt class).</returns>
private static DebtClassRow FindParentWithField(Guid debtClassId, DataColumn field)
{
DebtClassRow parent = null;
DebtClassRow debtClass = DataModel.DebtClass.DebtClassKey.Find(debtClassId);
Guid typeId = DataModel.Entity.EntityKey.Find(debtClassId).TypeId;
while (debtClass != null && parent == null)
{
EntityRow child = DataModel.Entity.EntityKey.Find(debtClass.DebtClassId);
EntityTreeRow[] parents = child.GetEntityTreeRowsByFK_Entity_EntityTree_ChildId();
if (!debtClass.IsNull(field))
{
parent = debtClass;
}
if (parents.Length != 0)
{
debtClass = DataModel.DebtClass.DebtClassKey.Find(parents[0].ParentId);
}
else
{
debtClass = null;
}
}
return(parent);
}
/// <summary>
/// Get a list of the entity names that describes the path to this object.
/// </summary>
/// <param name="current">The current entity in the path to the object.</param>
/// <param name="target">The entityId of the entity we're building a path for.</param>
/// <returns>The list of entity names that represent the path to the object.</returns>
private List <string> GetLocation(EntityRow current, Guid target)
{
List <string> list = null;
if (current == null)
{
return(null);
}
// If current is the entity that we're looking for, we'll create our own list.
if (current.EntityId == target)
{
list = new List <string>();
}
// .... Otherwise, see if we can generate a path list from one of our children.
else
{
foreach (EntityTreeRow node in current.GetEntityTreeRowsByFK_Entity_EntityTree_ParentId())
{
list = this.GetLocation(node.EntityRowByFK_Entity_EntityTree_ChildId, target);
if (list != null)
{
break;
}
}
}
if (list != null)
{
list.Insert(0, current.Name);
}
return(list);
}
/// <summary>
/// Count all of the working orders and matches in blotters below the parent entity. The caller should lock the DataModel.
/// </summary>
/// <param name="parent">The parent entity.</param>
/// <param name="totalRecords">The total number of records. Should initially be 0.</param>
/// <param name="matchedRecords">The number of of valid matches. Should initially be 0.</param>
private void CountAccounts(EntityRow parent, ref int totalRecords, ref int matchedRecords)
{
BlotterRow blotter = DataModel.Blotter.BlotterKey.Find(parent.EntityId);
if (blotter != null)
{
MatchRow[] matches = blotter.GetMatchRows();
WorkingOrderRow[] orders = blotter.GetWorkingOrderRows();
matchedRecords += matches.Length;
// Count up the credit cards for everything.
foreach (WorkingOrderRow order in orders)
{
Guid security = order.SecurityId;
ConsumerTrustRow trust = DataModel.ConsumerTrust.ConsumerTrustKey.Find(security);
if (trust != null)
{
totalRecords += trust.ConsumerRow.GetCreditCardRows().Length;
}
}
}
// Do the same for all of the blotters under this one.
foreach (EntityTreeRow tree in DataModel.EntityTree)
{
if (tree.ParentId == parent.EntityId)
{
this.CountAccounts(tree.EntityRowByFK_Entity_EntityTree_ChildId, ref totalRecords, ref matchedRecords);
}
}
}
/// <summary>
/// Determine whether a rights holder has particular rights on an entity.
/// </summary>
/// <param name="rightsHolderRow">The rights holder</param>
/// <param name="entity">The entity.</param>
/// <param name="right">The required rights.</param>
/// <returns>True if the rights holder has the specified rights to the entity.</returns>
public static Boolean HasAccess(RightsHolderRow rightsHolderRow, EntityRow entity, AccessRight right)
{
// TODO: Remove this method? Current there are no calls to this method.
// NOTE: This must be used in a background thread.
Boolean grantedAccess = false;
lock (DataModel.SyncRoot)
{
UserRow userRow = DataModel.User.UserKey.Find(rightsHolderRow.RightsHolderId);
// See if the rights holder themself has access.
foreach (AccessControlRow accessControlRow in rightsHolderRow.GetAccessControlRows())
{
if (accessControlRow.EntityId == entity.EntityId &&
(accessControlRow.AccessRightRow.AccessRightCode & right) == right)
{
grantedAccess = true;
}
}
if (userRow != null)
{
foreach (GroupUsersRow groupUsersRow in userRow.GetGroupUsersRows())
{
if (AccessControl.HasAccess(groupUsersRow.GroupRow.RightsHolderRow, entity, right))
{
grantedAccess = true;
}
}
}
}
return(grantedAccess);
}
/// <summary>
/// Filter what rows are included in the list based on Filter.
/// </summary>
/// <param name="row">The row to examine.</param>
/// <returns>The return value of Filter.</returns>
protected override bool Filter(DataRow row)
{
BlotterRow blotterRow = null;
if (row is BlotterRow)
{
blotterRow = row as BlotterRow;
}
else if (row is EntityRow)
{
EntityRow entityRow = row as EntityRow;
if (entityRow.GetBlotterRows().Length != 0)
{
blotterRow = entityRow.GetBlotterRows()[0];
}
}
else
{
throw new RowNotHandledException("row isn't the right kind of row");
}
if (blotterRow == null)
{
return(false);
}
return(true);
}
static public string AutoGenKey(ref EntityRow row)
{
var table = row.Table;
if (table == null)
{
return(null);
}
var pk = row.Table.PrimaryKey;
var keyGen = pk.GetAttributesEntity().KeyGen;
if (string.IsNullOrEmpty(keyGen))
{
return(null);
}
var tableAttri = table.GetAttributesEntity();
long keyIndex = tableAttri.KeyCount + 1;
var key = CommonExtension.StringFormat(keyGen, keyIndex);
tableAttri.KeyCount = keyIndex;
row.SetValue(table.PrimaryKey, key, true);
return(key);
//Table.GetAttributesEntity().KeyCount
}
/// <summary>
/// Update the User based on an EntityRow.
/// </summary>
/// <param name="entityRow">The row to update from.</param>
public override void Update(EntityRow entityRow)
{
UserRow userRow = DataModel.User.UserKey.Find(entityRow.EntityId);
base.Update(entityRow);
if (userRow != null)
{
if (!this.Modified && entityRow.EntityId == this.EntityId)
{
this.IdentityName = userRow.IdentityName;
this.isRemoved = userRow.IsRemoved;
this.groups.Clear();
foreach (GroupUsersRow groupRow in userRow.GetGroupUsersRows())
{
this.groups.Add(Entity.New(groupRow.GroupRow.RightsHolderRow.EntityRow) as Group);
}
// The information kept in AD takes a really long time to come back, so we'll grab it in another thread.
ThreadPoolHelper.QueueUserWorkItem(data => this.LoadAdInformation(data as String), this.IdentityName);
}
this.rowVersion = userRow.RowVersion;
}
}
private void UnregistRowTransaction(EntityRow row)
{
if (State != DataTransactionState.Begin)
{
return;
}
rowTransactionMap.Remove(row.InternalId);
}
/// <summary>
/// Creates a node from an object in the data model.
/// </summary>
/// <param name="entityRow">The data model object used to create a node in the TreeView.</param>
public FolderTreeNode(EntityRow entityRow)
{
// Initialize the object from the data in the record.
this.relationId = Guid.Empty;
this.rowVersion = Int64.MinValue;
this.entity = Entity.New(entityRow);
this.BuildTree(entityRow);
}
/// <summary>
/// Determines if a given blotter is visible on the current document.
/// </summary>
/// <param name="parentRow">The current object in the recursive search.</param>
/// <param name="blotterId">The blotter id to be found.</param>
/// <returns>true if the blotter is part of the tree structure.</returns>
public static List <Guid> GetDescendants(EntityRow parentRow)
{
lock (DataModel.SyncRoot)
{
List <Guid> descendants = new List <Guid>();
GetDescendants(descendants, parentRow);
return(descendants);
}
}
private void Restore(EntityRow srcRow)
{
if (srcRow.ItemArray.Length != Row.ItemArray.Length)
{
throw new Exception("EntityRowTransaction.Restore()");
}
Row.Attributes = srcRow.Attributes;
srcRow.CopyItermArrayTo(Row);
}
/// <summary>
/// Create a new User object based on an entity row.
/// </summary>
/// <param name="entityRow">An entity row from the DataModel.</param>
public User(EntityRow entityRow) : base(entityRow)
{
if (this.groups == null)
{
this.groups = new ObservableCollection <Group>();
}
this.groups.CollectionChanged += this.OnGroupsChanged;
}
static public EntityRelation BuildEntityRelation(EntityRow parentRow, EntityColumn column)
{
var value = parentRow[column];
if (value == null)
{
return(null);
}
return(BuildEntityRelation(parentRow, value.ToString()));
}
/// <summary>
/// Create a new Entity object from an EntityRow from the DataModel.
/// </summary>
/// <param name="entityRow">The entity row to base the entity object from.</param>
/// <returns>The newly populated Entity object.</returns>
public static Entity New(EntityRow entityRow)
{
String[] typeParts = entityRow.TypeRow.Type.Split(',');
Assembly assembly;
string className;
Entity.LoadAssembly(entityRow.TypeRow.Type, out assembly, out className);
return(assembly.CreateInstance(className, false, BindingFlags.CreateInstance, null,
new object[] { entityRow }, CultureInfo.InvariantCulture, null) as Entity);
}
private void DoRegist(EntityTable registedTable, EntityRow row, OPStatus opStatus)
{
IEntityRowAttributes rowAttributes = row.GetAttributesEntity();
bool isExist = registedTable.Rows.Contains(row);
bool inTransaction = (State == DataTransactionState.Begin);
switch (opStatus)
{
case OPStatus.Delete:
if (isExist)
{
registedTable.Rows.Remove(row);
}
if (rowAttributes.Status == OPStatus.Add)
{
UnregistRowTransaction(row);
}
else
{
RegistRowTransaction(row, true);
rowAttributes.Status = opStatus;
}
break;
case OPStatus.Add:
if (!isExist)
{
registedTable.Rows.Add(row);
}
RegistRowTransaction(row, false);
rowAttributes.Status = opStatus;
break;
case OPStatus.Update:
if (rowAttributes.Status != OPStatus.Add && rowAttributes.Status != OPStatus.Delete)
{
rowAttributes.Status = opStatus;
//100/11/30 by Feng,避免已經BeginUpdate後才又有Table被查詢regist
RegistRowTransaction(row, true);
}
break;
case OPStatus.Steady:
if (!isExist)
{
rowAttributes.Status = opStatus;
registedTable.Rows.Add(row);
RegistRowTransaction(row, true);
}
break;
default:
throw new Exception("EntityTableTransaction.Regist()");
}
}
/// <summary>
/// Creates a node from an object in the data model.
/// </summary>
/// <param name="entityTreeRow">The data model object used to create a node in the TreeView.</param>
public FolderTreeNode(EntityTreeRow entityTreeRow)
{
EntityRow entityRow = entityTreeRow.EntityRowByFK_Entity_EntityTree_ChildId;
// Initialize the object from the data in the record.
this.relationId = entityTreeRow.EntityTreeId;
this.rowVersion = entityTreeRow.RowVersion;
this.entity = Entity.New(entityRow);
this.BuildTree(entityRow);
}
/// <summary>
/// Handle an update to the data model. If no changes have been made to the entity, re-populate the dialog box.
/// </summary>
private void OnEndMerge(object sender, EventArgs eventArgs)
{
if (this.MustRedisplay)
{
EntityRow entityRow = DataModel.Entity.EntityKey.Find(this.entityId);
FluidTrade.Core.ThreadPoolHelper.QueueUserWorkItem(data => this.Populate(data as Entity), entityRow == null ? null : Entity.New(entityRow));
this.MustRedisplay = false;
}
}
/// <summary>
/// Placeholder
/// </summary>
/// <param name="record"></param>
public override void Update(EntityTree record)
{
DataModel dataModel = new DataModel();
DataModelTransaction transaction = DataModelTransaction.Current;
EntityTreeRow entityTreeRow = DataModel.EntityTree.EntityTreeKey.Find(record.RowId);
EntityRow child = DataModel.Entity.EntityKey.Find(record.ChildId);
EntityRow parent = DataModel.Entity.EntityKey.Find(record.ParentId);
String childName;
entityTreeRow.AcquireWriterLock(transaction);
if (!DataModelFilters.HasAccess(transaction, TradingSupport.UserId, entityTreeRow.ParentId, AccessRight.Write))
{
throw new SecurityException("Current user does not have write access to the old parent entity");
}
if (!DataModelFilters.HasAccess(transaction, TradingSupport.UserId, record.ParentId, AccessRight.Write))
{
throw new SecurityException("Current user does not have write access to the new parent entity");
}
parent.AcquireWriterLock(transaction);
child.AcquireReaderLock(transaction);
childName = child.Name;
child.ReleaseLock(transaction.TransactionId);
if (record.ChildId == record.ParentId)
{
throw new FaultException <ArgumentFault>(new ArgumentFault("Create EntityTree"),
new FaultReason(String.Format("Cannot add {0} as a child of this element because it wil create a circular relationship", childName)));
}
if (IsParentEntity(transaction, parent, record.ChildId) == true)
{
throw new FaultException <ArgumentFault>(new ArgumentFault("Create EntityTree"),
new FaultReason(String.Format("Cannot add {0} as a child of this element because it wil create a circular relationship", childName)));
}
if (!EntityPersistence.IsNameUnique(transaction, parent, childName))
{
throw new FaultException <RecordExistsFault>(
new RecordExistsFault("Entity", new object[] { childName }),
"An entity with this name already exists");
}
dataModel.UpdateEntityTree(
record.ChildId,
entityTreeRow.EntityTreeId,
new object[] { entityTreeRow.EntityTreeId },
null,
record.ParentId,
entityTreeRow.RowVersion);
}
/// <summary>
/// Create a new EffectiveDebtClass from an EntityRow.
/// </summary>
/// <param name="entityRow">The entity row to base the debt class on.</param>
public EffectiveDebtClass(EntityRow entityRow)
: base(entityRow)
{
// This would have retrieved values from the hierarchy.
//this.Construct();
// We watch DebtClass in case data in one of our ancestors changes.
DataModel.DebtClass.DebtClassRowChanged += this.OnDebtClassChanged;
// And we watch EntityTree in case we or one of our ancestors moves.
//DataModel.EntityTree.EntityTreeRowChanged += this.OnEntityTreeChanged;
}
static public EntityRowProxy <TEntity> GenProxy <TEntity>(this EntityRow dataRow, IEntityTableSource entityTableSource = null)
{
string proxyKey = typeof(EntityRowProxy <TEntity>).FullName;
EntityRowProxy <TEntity> proxy;
if (!dataRow.TryGetCache(proxyKey, out proxy))
{
proxy = new EntityRowProxy <TEntity>(dataRow, entityTableSource);
dataRow.AddCache(proxyKey, proxy);
}
return(proxy);
}
/// <summary>
/// Clears the given blotter of all working orders.
/// </summary>
/// <param name="dataModelClient">Used to execute Web Services.</param>
/// <param name="blotterName">The name of the blotter to be reset.</param>
private static void DestroyWorkingOrders(DataModelClient dataModelClient, String blotterName)
{
// Destroy all the Working Orders for Kai Hitori
foreach (WorkingOrderRow workingOrderRow in DataModel.WorkingOrder)
{
EntityRow entityRow = workingOrderRow.BlotterRow.EntityRow;
if (entityRow.Name == blotterName)
{
dataModelClient.DestroyWorkingOrder(workingOrderRow.RowVersion, new object[] { workingOrderRow.WorkingOrderId });
}
}
}
private void sel_topic_list_sel_changed(object sender, RoutedEventArgs e)
{
EntityRow sel = this.entity_list.SelectedValue as EntityRow;
Guid? guid = this.sel_topic_list.SelectedValue as Guid?;
if ((sel is null) || (sel.type is null) || (sel.guid is null) || (sel.topics is null) || (guid is null))
{
this.topic_view_but.IsEnabled = false;
return;
}
this.topic_view_but.IsEnabled = (guid.Value != this.guid);
}
/// <summary>
/// Count all of the entities beneath an entity in the hierarchy and return the total. The caller should lock the DataModel.
/// </summary>
/// <param name="parent">The entity to start from.</param>
/// <returns>The total number of entities beneath 'entity' in the hierarchy.</returns>
private int CountChildren(EntityRow parent)
{
int count = 0;
foreach (EntityTreeRow row in parent.GetEntityTreeRowsByFK_Entity_EntityTree_ParentId())
{
count += 1;
count += this.CountChildren(row.EntityRowByFK_Entity_EntityTree_ChildId);
}
return(count);
}
/// <summary>
/// Create a new SystemFolder based on an entity row.
/// </summary>
/// <param name="entityRow">An entity row in the DataModel.</param>
public SystemFolder(EntityRow entityRow) : base(entityRow)
{
SystemFolderRow systemFolderRow = DataModel.SystemFolder.SystemFolderKey.Find(entityRow.EntityId);
// Start the application off by opening up the start page.
string onOpenText = ConfigurationManager.AppSettings["OnOpen"];
if (onOpenText != null)
{
string[] onOpenArguments = onOpenText.Split(new char[] { ',' });
this.Url = onOpenArguments[2].Trim();
}
}
