/// <summary>
/// Handles a Destination Order entering the error state.
/// </summary>
private static void SetErrorAction(Object[] key, params Object[] parameters)
{
// A middle tier context is also required for a transacted update.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
// It is possible that the Working Order that is the object of this status update operation may have been deleted since the action was
// created. This is not an error condition. If there is no Working Order to update, then the operation is just terminated prematurely.
WorkingOrderRow workingOrderRow = DataModel.WorkingOrder.WorkingOrderKey.Find(key);
if (workingOrderRow == null)
{
return;
}
workingOrderRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
dataModelTransaction.AddLock(workingOrderRow);
if (workingOrderRow.RowState == DataRowState.Detached)
{
return;
}
// The Working Order reflects an 'Error' Status if any of its Destination Orders have an error.
if (workingOrderRow.StatusId != StatusMap.FromCode(Status.Error))
{
UpdateWorkingOrderStatus(workingOrderRow, Status.Error);
}
}
/// <summary>
/// Create a new DebtHolder
/// </summary>
/// <returns></returns>
public override Guid Create(Security record)
{
DataModel dataModel = new DataModel();
Guid securityId = Guid.NewGuid();
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
VolumeCategoryRow volumeCategoryRow = DataModel.VolumeCategory.VolumeCategoryKey.Find(record.VolumeCategoryId);
volumeCategoryRow.AcquireReaderLock(dataModelTransaction);
////Create a entry in security
dataModel.CreateSecurity(
record.AverageDailyVolume,
record.CountryId.GetValueOrDefault(),
record.Logo,
record.MarketCapitalization,
record.MinimumQuantity,
record.PriceFactor,
record.QuantityFactor,
securityId,
record.Symbol,
record.TenantId,
volumeCategoryRow.VolumeCategoryId);
return(securityId);
}
/// <summary>
/// Changes the state of the Working Order to reflect a partially filled status.
/// </summary>
private static void OnPartialAction(Object[] key, params Object[] parameters)
{
// A middle tier context is also required for a transacted update.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
// It is possible that the Working Order that is the object of this status update operation may have been deleted since the action was
// created. This is not an error condition. If there is no Working Order to update, then the operation is just terminated prematurely.
WorkingOrderRow workingOrderRow = DataModel.WorkingOrder.WorkingOrderKey.Find(key);
if (workingOrderRow == null)
{
return;
}
workingOrderRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
dataModelTransaction.AddLock(workingOrderRow);
if (workingOrderRow.RowState == DataRowState.Detached)
{
return;
}
// The error status on a Working Order cannot be cleared with a partial fill. Otherwise, a partial fill on any of the Destination Orders is
// reflected in the status of the parent Working Order.
if (workingOrderRow.StatusId != StatusMap.FromCode(Status.Error))
{
if (workingOrderRow.StatusId != StatusMap.FromCode(Status.PartiallyFilled))
{
UpdateWorkingOrderStatus(workingOrderRow, Status.PartiallyFilled);
}
}
}
/// <summary>
/// Update a match
/// </summary>
/// <returns></returns>
public override void Update(Records.Match record)
{
DataModel dataModel = new DataModel();
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
Guid blotter = record.BlotterId.GetValueOrDefault();
if (blotter == Guid.Empty || !TradingSupport.HasAccess(dataModelTransaction, blotter, AccessRight.Write))
{
throw new SecurityException("Current user does not have write access to the selected blotter");
}
if (record.RowId == null || DataModel.Match.MatchKey.Find(record.RowId) == null)
{
throw new FaultException <RecordNotFoundFault>(new RecordNotFoundFault("Match", new object[] { record.RowId }));
}
dataModel.UpdateMatch(
record.BlotterId,
record.ContraMatchId,
record.ContraOrderId,
record.HeatIndex,
record.HeatIndexDetails,
record.MatchedTime,
null, new object[] { record.RowId },
record.RowVersion,
record.StatusCodeId,
record.WorkingOrderId);
}
/// <summary>
/// Determine whether a name is unique within a parent entity.
/// </summary>
/// <param name="transaction"></param>
/// <param name="parentEntityRow"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Boolean IsNameUnique(DataModelTransaction transaction, EntityRow parentEntityRow, String name)
{
Boolean isNameUnique = true;
foreach (EntityTreeRow entityTree in parentEntityRow.GetEntityTreeRowsByFK_Entity_EntityTree_ParentId())
{
EntityRow entityRow;
String oldName;
entityTree.AcquireReaderLock(transaction);
entityRow = entityTree.EntityRowByFK_Entity_EntityTree_ChildId;
entityTree.ReleaseLock(transaction.TransactionId);
entityRow.AcquireReaderLock(transaction);
oldName = entityRow.Name;
isNameUnique = !entityRow.Name.Equals(name);
entityRow.ReleaseLock(transaction.TransactionId);
if (!isNameUnique)
{
break;
}
}
return(isNameUnique);
}
/// <summary>
/// Update Negotiation record
/// </summary>
/// <param name="record"></param>
public override void Update(FluidTrade.Guardian.Records.Negotiation record)
{
DataModel dataModel = new DataModel();
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
Guid blotter = record.BlotterId.GetValueOrDefault();
if (blotter == Guid.Empty || !TradingSupport.HasAccess(dataModelTransaction, blotter, AccessRight.Write))
{
throw new SecurityException("Current user does not have write access to the selected blotter");
}
if (record.RowId == null || DataModel.Negotiation.NegotiationKey.Find(record.RowId) == null)
{
throw new FaultException <RecordNotFoundFault>(new RecordNotFoundFault("Negotiation", new object[] { record.RowId }));
}
dataModel.UpdateNegotiation(
record.BlotterId,
record.ExecutionId,
record.IsRead,
record.MatchId,
null,
new object[] { record.RowId },
record.Quantity,
record.RowVersion,
record.StatusCodeId);
}
/// <summary>
/// Changes the state of the Working Order to reflect a filledly filled state.
/// </summary>
private static void OnFilledAction(Object[] key, params Object[] parameters)
{
// A middle tier context is also required for a transacted update.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
// It is possible that the Working Order that is the object of this status update operation may have been deleted since the action was
// created. This is not an error condition. If there is no Working Order to update, then the operation is just terminated prematurely.
WorkingOrderRow workingOrderRow = DataModel.WorkingOrder.WorkingOrderKey.Find(key);
if (workingOrderRow == null)
{
return;
}
workingOrderRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
dataModelTransaction.AddLock(workingOrderRow);
if (workingOrderRow.RowState == DataRowState.Detached)
{
return;
}
// The error status on a Working Order cannot be cleared with a fill.
if (workingOrderRow.StatusId != StatusMap.FromCode(Status.Error))
{
// The Working Order is 'Filled' when the quantity executed is the same as the quantity ordered.
Decimal quantityOrdered = WorkingOrder.GetSourceOrderQuantity(dataModelTransaction, workingOrderRow);
Decimal quantityExecuted = WorkingOrder.GetExecutionQuantity(dataModelTransaction, workingOrderRow);
if (quantityOrdered == quantityExecuted)
{
UpdateWorkingOrderStatus(workingOrderRow, Status.Filled);
}
}
}
/// <summary>
/// Create a new Math record
/// </summary>
/// <returns></returns>
public override Guid Create(Records.Match record)
{
DataModel dataModel = new DataModel();
Guid matchId = Guid.NewGuid();
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
Guid blotter = record.BlotterId.GetValueOrDefault();
if (blotter == Guid.Empty || !TradingSupport.HasAccess(dataModelTransaction, blotter, AccessRight.Write))
{
throw new SecurityException("Current user does not have write access to the selected blotter");
}
////Create a match
dataModel.CreateMatch(
record.BlotterId.GetValueOrDefault(),
record.ContraMatchId.GetValueOrDefault(),
record.ContraOrderId.GetValueOrDefault(),
record.HeatIndex,
record.HeatIndexDetails,
DateTime.UtcNow,
matchId,
record.StatusCodeId.GetValueOrDefault(),
record.WorkingOrderId.GetValueOrDefault());
return(matchId);
}
/// <summary>
/// Create Negotiation record
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
public override Guid Create(FluidTrade.Guardian.Records.Negotiation record)
{
DataModel dataModel = new DataModel();
Guid negotiationId = Guid.NewGuid();
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
Guid blotter = record.BlotterId.GetValueOrDefault();
if (blotter == Guid.Empty || !TradingSupport.HasAccess(dataModelTransaction, blotter, AccessRight.Write))
{
throw new SecurityException("Current user does not have write access to the selected blotter");
}
////Create a negotiation
dataModel.CreateNegotiation(
blotter,
record.ExecutionId.GetValueOrDefault(),
record.IsRead,
record.MatchId.GetValueOrDefault(),
negotiationId,
record.Quantity,
record.StatusCodeId.GetValueOrDefault());
return(negotiationId);
}
/// <summary>
/// Determine whether this debt class has a parent of the same type.
/// </summary>
/// <param name="transaction">The curren transaction.</param>
/// <param name="entityRow">The entity row of the debt class.</param>
/// <returns></returns>
public Boolean HasParent(DataModelTransaction transaction, EntityRow entityRow)
{
Boolean has = false;
EntityTreeRow[] entityTreeRows;
Guid typeId;
entityRow.AcquireReaderLock(transaction);
typeId = entityRow.TypeId;
entityTreeRows = entityRow.GetEntityTreeRowsByFK_Entity_EntityTree_ChildId();
entityRow.ReleaseLock(transaction.TransactionId);
foreach (EntityTreeRow entityTreeRow in entityTreeRows)
{
EntityRow parentRow;
entityTreeRow.AcquireReaderLock(transaction);
parentRow = entityTreeRow.EntityRowByFK_Entity_EntityTree_ParentId;
entityTreeRow.ReleaseLock(transaction.TransactionId);
parentRow.AcquireReaderLock(transaction);
has = parentRow.TypeId == typeId;
parentRow.ReleaseLock(transaction.TransactionId);
if (has)
{
break;
}
}
return(has);
}
/// <summary>
///
/// </summary>
public void OutputLocksToLog()
{
EventLog.Information("LOGGING LOCKS tickCount:{0}", Environment.TickCount);
List <string> transactionList = DataModelTransaction.GetTransactionStacks();
if (transactionList != null)
{
foreach (string txnStack in transactionList)
{
EventLog.Information("<<<<**>>>>Txn Stack\r\n{0}\r\n", txnStack);
}
}
DataModel.DataLock.EnterReadLock();
try
{
System.Data.DataSet ds = DataModel.Match.DataSet;
foreach (System.Data.DataTable table in ds.Tables)
{
foreach (DataRowBase row in table.Rows)
{
string tmp = row.GetCurrentLockStacks(true);
if (tmp != null)
{
EventLog.Information("<<<<**>>>>{0}\r\n{1}\r\n", row.Table.TableName, tmp);
}
}
}
}
finally
{
DataModel.DataLock.ExitReadLock();
}
}
/// <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 a new Consumer Trust
/// </summary>
/// <returns></returns>
public override Guid Create(ConsumerDebt record)
{
DataModel dataModel = new DataModel();
Guid entityId = Guid.NewGuid();
// Since DebtHolder object requires entries in Blotter, DebtClass and DebtHolder,
//a transaction is required to lock the records and change the data model.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
////Create a entry in credit card
dataModel.CreateConsumerDebt(
record.CollectionDate,
entityId,
record.ConsumerId.GetValueOrDefault(),
record.CreditCardId.GetValueOrDefault(),
record.DateOfDelinquency,
record.DebtRuleId,
record.ExternalId0,
record.Representative,
record.Tag,
record.TenantId,
record.VendorCode);
return(entityId);
}
/// <summary>
/// Create a new DebtNegotiator
/// </summary>
/// <returns></returns>
public override Guid Create(DebtNegotiator record)
{
DataModel dataModel = new DataModel();
Guid entityId = Guid.Empty;
TypeRow typeRow = null;
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
if (record.TypeId != null && record.TypeId != Guid.Empty)
{
typeRow = DataModel.Type.TypeKey.Find(record.TypeId.Value);
}
else
{
typeRow = DataModel.Type.TypeKeyExternalId0.Find("DEBT NEGOTIATOR");
}
if (typeRow != null)
{
DebtClassPersistence debtClassPersistence = new DebtClassPersistence();
typeRow.AcquireReaderLock(dataModelTransaction);
record.TypeId = typeRow.TypeId;
typeRow.ReleaseLock(dataModelTransaction.TransactionId);
entityId = debtClassPersistence.Create(record);
dataModel.CreateDebtNegotiator(entityId);
}
return(entityId);
}
/// <summary>
/// Update Credit Card
/// </summary>
/// <returns></returns>
public override void Update(CreditCard record)
{
DataModel dataModel = new DataModel();
DataModelTransaction transaction = DataModelTransaction.Current;
Guid blotterId = this.FindContainingBlotter(transaction, record.RowId);
if (record.RowId == null || DataModel.CreditCard.CreditCardKey.Find(record.RowId) == null)
{
throw new FaultException <RecordNotFoundFault>(new RecordNotFoundFault("Credit Card", new object[] { record.RowId }));
}
if (!DataModelFilters.HasAccess(transaction, TradingSupport.UserId, blotterId, AccessRight.Write))
{
throw new SecurityAccessDeniedException("The current user does not write permission to the selected blotter");
}
dataModel.UpdateCreditCard(
record.AccountBalance,
record.AccountNumber,
record.ConsumerId,
null,
new object[] { record.RowId },
record.DebtHolder,
record.DebtRuleId,
null,
record.AccountNumber,
record.OriginalAccountNumber,
record.RowVersion,
null);
}
/// <summary>
/// Create a new Credit card
/// </summary>
/// <returns></returns>
public override Guid Create(CreditCard record)
{
DataModel dataModel = new DataModel();
DataModelTransaction transaction = DataModelTransaction.Current;
Guid blotterId = this.FindContainingBlotter(transaction, record.ConsumerId.GetValueOrDefault());
Guid tenantId = PersistenceHelper.GetTenantForEntity(
transaction,
blotterId);
if (!DataModelFilters.HasAccess(transaction, TradingSupport.UserId, blotterId, AccessRight.Write))
{
throw new SecurityAccessDeniedException("The current user does not write permission to the selected blotter");
}
Guid ccId = Guid.NewGuid();
////Create a entry in credit card
dataModel.CreateCreditCard(
record.AccountBalance,
record.AccountNumber,
record.ConsumerId.GetValueOrDefault(),
ccId,
record.DebtHolder,
record.DebtRuleId,
Guid.NewGuid().ToString(),
record.AccountNumber,
record.OriginalAccountNumber,
tenantId);
return(ccId);
}
/// <summary>
/// Prototype method. This will eventually take list of guids to update
/// </summary>
/// <param name="consumerTrustId"></param>
private void GetSavingsBalance(Guid consumerTrustId)
{
string gcsAccountNumber = String.Empty;
using (TransactionScope transactionScope = new TransactionScope())
{
// This provides a context for any transactions.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
ConsumerTrustRow consumerTrustRow = DataModel.ConsumerTrust.ConsumerTrustKey.Find(consumerTrustId);
consumerTrustRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
try
{
if (consumerTrustRow.IsSavingsAccountNull() == false)
{
gcsAccountNumber = consumerTrustRow.SavingsAccount;
}
}
finally
{
consumerTrustRow.ReleaseReaderLock(dataModelTransaction.TransactionId);
}
}
//If there is no GCS account number then we have no need to continue processing.
//HACK add logging for empty account numbers
if (String.IsNullOrEmpty(gcsAccountNumber) == false)
{
Decimal savingsBalance = GetSavingsBalance(gcsAccountNumber);
if (savingsBalance != -1.0M)
{
UpdateSavingsBalance(consumerTrustId, savingsBalance);
}
}
}
/// <summary>
/// Create a new Consumer Trust
/// </summary>
/// <returns></returns>
public override Guid Create(Consumer consumer)
{
DataModel dataModel = new DataModel();
Guid consumerId = Guid.NewGuid();
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
dataModel.CreateConsumer(
consumer.Address1,
consumer.Address2,
null,
null,
consumer.City,
consumerId,
consumer.DateOfBirth,
consumer.ExternalId0,
consumer.ExternalId1,
consumer.FirstName,
consumer.IsEmployed,
consumer.LastName,
consumer.MiddleName,
consumer.PhoneNumber,
consumer.PostalCode,
consumer.ProvinceId,
consumer.Salutation,
consumer.SocialSecurityNumber,
consumer.Suffix);
return(consumerId);
}
/// <summary>
/// Create a new group.
/// </summary>
/// <param name="record">The group object.</param>
/// <returns>The GroupId of the new group.</returns>
public override Guid Create(Group record)
{
DataModel dataModel = new DataModel();
DataModelTransaction transaction = DataModelTransaction.Current;
EntityPersistence entityPersistence = new EntityPersistence();
Guid entityId;
TypeRow typeRow = DataModel.Type.TypeKeyExternalId0.Find("GROUP");
typeRow.AcquireReaderLock(transaction.TransactionId, DataModel.LockTimeout);
try
{
record.TypeId = typeRow.TypeId;
record.ImageId = typeRow.ImageId;
}
finally
{
typeRow.ReleaseReaderLock(transaction.TransactionId);
}
entityId = entityPersistence.Create(record);
dataModel.CreateRightsHolder(
entityId,
record.TenantId.Value);
dataModel.CreateGroup(
entityId,
GroupTypeMap.FromCode(record.GroupType),
record.TenantId.Value);
return(entityId);
}
/// <summary>
/// Calculate a unique entity name from a base name.
/// </summary>
/// <param name="transaction">The current transaction.</param>
/// <param name="parentEntityRow">The (writelocked) entity that would be the parent of the entity we intend to name.</param>
/// <param name="name">The base name (eg. the name of the entity, provided there isn't already a sibling with that name).</param>
/// <returns>A unique name.</returns>
private String GetUniqueName(DataModelTransaction transaction, EntityRow parentEntityRow, String name)
{
Int64 nameNumber = 1;
String uniqueName = name;
List <String> existingNames = new List <String>();
foreach (EntityTreeRow entityTree in parentEntityRow.GetEntityTreeRowsByFK_Entity_EntityTree_ParentId())
{
EntityRow entityRow;
entityTree.AcquireReaderLock(transaction);
entityRow = entityTree.EntityRowByFK_Entity_EntityTree_ChildId;
entityTree.ReleaseLock(transaction.TransactionId);
entityRow.AcquireReaderLock(transaction);
existingNames.Add(entityRow.Name);
entityRow.ReleaseLock(transaction.TransactionId);
}
existingNames.Sort();
while (existingNames.BinarySearch(uniqueName) >= 0)
{
uniqueName = String.Format("{0} ({1})", name, nameNumber);
nameNumber += 1;
}
return(uniqueName);
}
public ErrorCode DeleteRow(DataModel dataModel, DataModelTransaction transaction, DebtRuleRow debtRuleRow)
{
debtRuleRow.AcquireReaderLock(transaction);
DebtRuleMapRow[] debtRuleMaps = debtRuleRow.GetDebtRuleMapRows();
if (debtRuleRow.GetDebtClassRows().Length != 0)
{
return(ErrorCode.AccessDenied);
}
debtRuleRow.ReleaseReaderLock(transaction.TransactionId);
foreach (DebtRuleMapRow debtRuleMapRow in debtRuleMaps)
{
debtRuleMapRow.AcquireReaderLock(transaction);
if (!DataModelFilters.HasAccess(transaction, TradingSupport.UserId, debtRuleMapRow.DebtClassId, AccessRight.Write))
{
return(ErrorCode.AccessDenied);
}
debtRuleMapRow.ReleaseReaderLock(transaction.TransactionId);
}
debtRuleRow.AcquireWriterLock(transaction);
dataModel.DestroyDebtRule(new object[] { debtRuleRow.DebtRuleId }, debtRuleRow.RowVersion);
debtRuleRow.ReleaseLock(transaction.TransactionId);
return(ErrorCode.Success);
}
/// <summary>
/// Update the SavingsBalance
/// </summary>
/// <param name="consumerTrustId"></param>
/// <param name="savingsBalance"></param>
private void UpdateSavingsBalance(Guid consumerTrustId, decimal savingsBalance)
{
// An instance of the data model is required for CRUD operations.
DataModel dataModel = new DataModel();
using (TransactionScope transactionScope = new TransactionScope())
{
Int64 consumerTrustRowVersion;
// This provides a context for any transactions.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
ConsumerTrustRow consumerTrustRow = DataModel.ConsumerTrust.ConsumerTrustKey.Find(consumerTrustId);
consumerTrustRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
try
{
consumerTrustRowVersion = consumerTrustRow.RowVersion;
}
finally
{
consumerTrustRow.ReleaseReaderLock(dataModelTransaction.TransactionId);
}
dataModel.UpdateConsumerTrust(
null,
null,
new Object[] { consumerTrustId },
null,
null,
consumerTrustRowVersion,
null,
savingsBalance,
null,
null,
null);
}
}
/// <summary>
/// Changes the state of the Working Order to reflect a filledly filled state.
/// </summary>
private static void ClearErrorAction(Object[] key, params Object[] parameters)
{
// A middle tier context is also required for a transacted update.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
// It is possible that the Working Order that is the object of this status update operation may have been deleted since the action was
// created. This is not an error condition. If there is no Working Order to update, then the operation is just terminated prematurely.
WorkingOrderRow workingOrderRow = DataModel.WorkingOrder.WorkingOrderKey.Find(key);
if (workingOrderRow == null)
{
return;
}
workingOrderRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
dataModelTransaction.AddLock(workingOrderRow);
if (workingOrderRow.RowState == DataRowState.Detached)
{
return;
}
// The 'Error' status is only cleared when all the Destination Orders are valid.
Boolean isErrorStatus = false;
foreach (DestinationOrderRow siblingOrderRow in workingOrderRow.GetDestinationOrderRows())
{
siblingOrderRow.AcquireReaderLock(dataModelTransaction);
if (siblingOrderRow.StatusId == StatusMap.FromCode(Status.Error))
{
isErrorStatus = true;
break;
}
}
// The proper Working Order status must be evaluated when the error status is cleared.
if (!isErrorStatus)
{
// The aggregates will determine the new state of the Working Order.
Decimal quantityExecuted = WorkingOrder.GetExecutionQuantity(dataModelTransaction, workingOrderRow);
Decimal quantityOrdered = WorkingOrder.GetSourceOrderQuantity(dataModelTransaction, workingOrderRow);
// This restores the 'New' status when the canceled Destination Order was the only order with any fills.
if (quantityExecuted == 0.0M && workingOrderRow.StatusId != StatusMap.FromCode(Status.New))
{
UpdateWorkingOrderStatus(workingOrderRow, Status.New);
}
// This restores the 'Partially Filled' status when other executions remain.
if (0.0M < quantityExecuted && quantityExecuted < quantityOrdered && workingOrderRow.StatusId != StatusMap.FromCode(Status.PartiallyFilled))
{
UpdateWorkingOrderStatus(workingOrderRow, Status.PartiallyFilled);
}
// This restores the 'Filled' status when the quantity executed is the same as the quantity ordered.
if (quantityExecuted == quantityOrdered && workingOrderRow.StatusId != StatusMap.FromCode(Status.Filled))
{
UpdateWorkingOrderStatus(workingOrderRow, Status.Filled);
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override void Update(Consumer record)
{
// These variables are used for auditing the changes to this record.
DateTime createdTime = DateTime.UtcNow;
Guid createdUserId = TradingSupport.UserId;
DateTime modifiedTime = createdTime;
Guid modifiedUserId = createdUserId;
DataModel dataModel = new DataModel();
DataModelTransaction datamodelTransaction = DataModelTransaction.Current;
if (record.RowId == null || DataModel.Consumer.ConsumerKey.Find(record.RowId) == null)
{
record.RowId = Create(record);
}
dataModel.UpdateConsumer(
record.Address1,
record.Address2,
null,
null,
record.City,
null,
new object[] { record.RowId },
record.DateOfBirth,
record.ExternalId0,
record.ExternalId1,
record.FirstName,
record.IsEmployed,
record.LastName,
record.MiddleName,
record.PhoneNumber,
record.PostalCode,
record.ProvinceId,
record.RowVersion,
record.Salutation,
record.SocialSecurityNumber,
record.Suffix);
//If a working order is given, Update modifyTime.
Guid workingOrderId = record.WorkingOrderId.GetValueOrDefault(Guid.Empty);
if (workingOrderId != Guid.Empty)
{
WorkingOrderPersistence workingOrderPersistence = new WorkingOrderPersistence();
workingOrderPersistence.UpdateModifyTime(workingOrderId);
}
//If a working order is given, Update modifyTime.
//Guid matchId = record.MatchId.GetValueOrDefault(Guid.Empty);
//if (matchId != Guid.Empty)
//{
// MatchPersistence matchPersistence = new MatchPersistence();
// matchPersistence.UpdateModifyTime(workingOrderId);
//}
}
/// <summary>
/// Collect negotiation and settlement data to move
/// </summary>
/// <param name="dataModelTransaction"></param>
/// <param name="moveToInfo"></param>
/// <param name="matchRow"></param>
private static void CollectNegotiationData(DataModelTransaction dataModelTransaction, MoveToInfo moveToInfo, MatchRow matchRow)
{
foreach (ConsumerTrustNegotiationRow consumerTrustNegotiationRow in matchRow.GetConsumerTrustNegotiationRows())
{
consumerTrustNegotiationRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
try
{
moveToInfo.consumerTrustNegotiationRows.Add(new BaseRecord()
{
RowId = consumerTrustNegotiationRow.ConsumerTrustNegotiationId, RowVersion = consumerTrustNegotiationRow.RowVersion
});
//Get counter payment rows to move
foreach (ConsumerTrustNegotiationCounterPaymentMethodRow counterPaymentMethodRow in consumerTrustNegotiationRow.GetConsumerTrustNegotiationCounterPaymentMethodRows())
{
counterPaymentMethodRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
try
{
moveToInfo.consumerTrustNegotiationCounterPaymentMethodRows.Add(new BaseRecord()
{
RowId = counterPaymentMethodRow.ConsumerTrustNegotiationCounterPaymentMethodId, RowVersion = counterPaymentMethodRow.RowVersion
});
}
finally
{
counterPaymentMethodRow.ReleaseReaderLock(dataModelTransaction.TransactionId);
}
}
//Get offer payment rows to move
foreach (ConsumerTrustNegotiationOfferPaymentMethodRow offerPaymentMethodRow in consumerTrustNegotiationRow.GetConsumerTrustNegotiationOfferPaymentMethodRows())
{
offerPaymentMethodRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
try
{
moveToInfo.consumerTrustNegotiationOfferPaymentMethodRows.Add(new BaseRecord()
{
RowId = offerPaymentMethodRow.ConsumerTrustNegotiationOfferPaymentMethodId, RowVersion = offerPaymentMethodRow.RowVersion
});
}
finally
{
offerPaymentMethodRow.ReleaseReaderLock(dataModelTransaction.TransactionId);
}
}
//Get Settlement rows to move
CollectSettlementData(dataModelTransaction, moveToInfo, consumerTrustNegotiationRow);
}
finally
{
consumerTrustNegotiationRow.ReleaseReaderLock(dataModelTransaction.TransactionId);
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override void Update(DebtNegotiator record)
{
DataModel dataModel = new DataModel();
DataModelTransaction transaction = DataModelTransaction.Current;
EntityPersistence entityPersistence = new EntityPersistence();
DebtClassPersistence debtClassPersistence = new DebtClassPersistence();
entityPersistence.Update(record);
debtClassPersistence.Update(record);
}
/// <summary>
/// Grant a particular rights holder specific rights to an entity.
/// </summary>
/// <param name="rightsHolderId">The rights holder's id.</param>
/// <param name="entityId">The entity's id.</param>
/// <param name="rightId">The specific right's id.</param>
/// <returns>The id of the AccessControl row.</returns>
internal static Guid GrantAccess(Guid rightsHolderId, Guid entityId, Guid rightId)
{
DataModelTransaction transaction = DataModelTransaction.Current;
DataModel dataModel = new DataModel();
Guid currentUserId = TradingSupport.UserId;
UserRow currentUserRow = DataModel.User.UserKey.Find(currentUserId);
RightsHolderRow rightsHolderRow = DataModel.RightsHolder.RightsHolderKey.Find(rightsHolderId);
Guid rightsHolderTenantId;
AccessControlRow accessControlRow = DataModel.AccessControl.AccessControlKeyRightsHolderIdEntityId.Find(rightsHolderId, entityId);
Guid accessControlId = Guid.Empty;
// Determine whether current user has write access to the entity.
if (!DataModelFilters.HasAccess(transaction, currentUserId, entityId, AccessRight.Write))
{
throw new FaultException <SecurityFault>(
new SecurityFault(String.Format("{0} does not write permission to {1}", rightsHolderId, entityId)));
}
rightsHolderRow.AcquireReaderLock(transaction);
rightsHolderTenantId = rightsHolderRow.TenantId;
rightsHolderRow.ReleaseReaderLock(transaction.TransactionId);
// Determine whether current user's tenant is upstream from rights holder we're modifying.
if (!DataModelFilters.HasTenantAccess(transaction, currentUserId, rightsHolderTenantId))
{
throw new FaultException <SecurityFault>(
new SecurityFault(String.Format("{0} does not control over tenant {1}", rightsHolderId, rightsHolderTenantId)));
}
if (accessControlRow != null)
{
accessControlRow.AcquireWriterLock(transaction);
accessControlId = accessControlRow.AccessControlId;
dataModel.UpdateAccessControl(
accessControlRow.AccessControlId,
new object[] { accessControlRow.AccessControlId },
rightId,
entityId,
rightsHolderId,
accessControlRow.RowVersion,
rightsHolderTenantId);
}
else
{
accessControlId = Guid.NewGuid();
dataModel.CreateAccessControl(
accessControlId,
rightId,
entityId,
rightsHolderId,
rightsHolderTenantId);
}
return(accessControlId);
}
/// <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);
}
private static void DeleteMatch(MatchRow matchRow)
{
for (int deadlockRetry = 0; deadlockRetry < deadlockRetiesMax; deadlockRetry++)
{
try
{
using (TransactionScope transactionScope = new TransactionScope())
{
// This provides a context for any transactions.
DataModelTransaction dataModelTransaction = DataModelTransaction.Current;
long rowVersion;
Guid matchId;
matchRow.AcquireReaderLock(dataModelTransaction.TransactionId, DataModel.LockTimeout);
try
{
if (matchRow.RowState == System.Data.DataRowState.Detached ||
matchRow.RowState == System.Data.DataRowState.Deleted)
{
continue;
}
rowVersion = matchRow.RowVersion;
matchId = matchRow.MatchId;
}
finally
{
matchRow.ReleaseReaderLock(dataModelTransaction.TransactionId);
}
DataModel dataModel = new DataModel();
dataModel.DestroyMatch(new object[] { matchId }, rowVersion);
transactionScope.Complete();
return;
} //end using
}
catch (System.Data.SqlClient.SqlException sqlEx)
{
if (FluidTrade.Core.Utilities.SqlErrorHelper.IsDeadlockException(sqlEx))
{
if (deadlockRetry == deadlockRetiesMax - 1)
{
throw;
}
FluidTrade.Core.EventLog.Warning("Deadlock exception\r\n{0}: {1}\r\n{2}", sqlEx.Message, sqlEx.ToString(), sqlEx.StackTrace);
}
else
{
throw;
}
}
} //end deadlock retry
}
/// <summary>
/// Find the blotter than contains this credit card.
/// </summary>
/// <param name="transaction">The transaction object.</param>
/// <param name="creditCardId">The credit card id.</param>
/// <returns>The blotter id of the blotter that contains this credit card.</returns>
private Guid FindContainingBlotter(DataModelTransaction transaction, Guid creditCardId)
{
WorkingOrderRow workingOrderRow = this.FindWorkingOrder(transaction, creditCardId);
workingOrderRow.AcquireReaderLock(transaction);
Guid blotterId = workingOrderRow.BlotterId;
workingOrderRow.ReleaseLock(transaction.TransactionId);
return(blotterId);
}
