/// <summary>
/// Add allocations to the current transaction
/// </summary>
/// <param name="fid">
/// 3-character FID code identifying your merchant activity. These are assigned by Internal Control.
/// </param>
/// <param name="chart">
/// 1-character chart code of the account to which you want to allocate the credit transaction.
/// </param>
/// <param name="account">
/// 7-character account number to which you want to allocate the credit transaction.
/// </param>
/// <param name="subAccount">Optional</param>
/// <param name="project">Optional</param>
/// <param name="giftNotificationId">
/// Used by gift transactions to direct the generated gift document to a particular person.
/// If this value is not passed (or is not valid) then the gift document will be generated
/// to the inbox of the person set up as the default on the server.
/// This value should be the UCD Login ID of the desired recipient in upper case.
/// </param>
/// <param name="allocationValue">
/// The amount or percent to allocate to this allocation
/// </param>
/// <param name="allocationType">
/// The type of allocation -- either percent or $ amount
/// </param>
public void AddAllocation(string fid, string chart, string account, string subAccount, string project, string giftNotificationId, double allocationValue, AllocationType allocationType)
{
var allocation = new allocRequestTransactionAllocation
{
fid = fid,
chart = chart,
account = account,
subAccount = subAccount,
project = project,
giftNotificationId = giftNotificationId
};
switch (allocationType)
{
case AllocationType.Amount:
allocation.amount = allocationValue;
allocation.amountSpecified = true;
break;
case AllocationType.Percent:
allocation.percent = allocationValue;
allocation.percentSpecified = true;
break;
default:
throw new ArgumentOutOfRangeException("allocationType");
}
//Now we have an allocation, add it to the allocation collection
Allocations.Add(allocation);
}
public void AddHolding(AllocationType allocType, string symbol, decimal price, decimal quanity)
{
Holding holding = new Holding(this)
{
AllocType = allocType,
Symbol = symbol,
Price = price,
Quantity = quanity,
};
m_TotalValue += holding.Value;
Holdings.Add(holding);
}
public int ReadFrom(byte[] buffer, int offset)
{
PriorDirectEntries = Utilities.ToUInt32LittleEndian(buffer, offset);
StrategyType = Utilities.ToUInt16LittleEndian(buffer, offset + 4);
StrategyParameter = Utilities.ToUInt16LittleEndian(buffer, offset + 6);
MaxEntries = Utilities.ToUInt16LittleEndian(buffer, offset + 8);
FileType = (FileType)buffer[offset + 11];
ParentICBLocation = Utilities.ToStruct<LogicalBlockAddress>(buffer, offset + 12);
ushort flagsField = Utilities.ToUInt16LittleEndian(buffer, offset + 18);
AllocationType = (AllocationType)(flagsField & 0x3);
Flags = (InformationControlBlockFlags)(flagsField & 0xFFFC);
return 20;
}
public void AssignAllocationValue(AllocationType allocationType, int allocationId, string allocationName)
{
switch (allocationType)
{
case AllocationType.Engagement:
this.TimesheetEntrySummaryLineKey.EngagementId = allocationId;
break;
case AllocationType.Project:
this.TimesheetEntrySummaryLineKey.ProjectId = allocationId;
break;
case AllocationType.BillingRule:
this.TimesheetEntrySummaryLineKey.BillingRuleId = allocationId;
break;
case AllocationType.CostCenter:
this.TimesheetEntrySummaryLineKey.CostCenterId = allocationId;
break;
case AllocationType.GeneralLedger:
this.TimesheetEntrySummaryLineKey.GeneralLedgerId = allocationId;
break;
}
var allocationValue = new AllocationValue { AllocationType = allocationType, AllocationId = allocationId, AllocationName = allocationName };
this.timesheetEntryAllocationSlots[allocationType] = allocationValue;
}
/// <summary>
/// Allocates memory of specified type on the xbox.
/// </summary>
/// <param name="type"></param>
/// <param name="size"></param>
/// <returns>Allocated address.</returns>
public uint AllocateMemory(AllocationType type, uint size)
{
switch (type)
{
case AllocationType.Debug: return AllocateDebugMemory(size);
case AllocationType.Physical: return AllocatePhysicalMemory(size);
case AllocationType.System: return AllocateSystemMemory(size);
case AllocationType.Virtual: return AllocateVirtualMemory(size);
default: throw new Exception("Invalid allocation type.");
}
}
public static extern DWORD_PTR VirtualAllocEx( IntPtr hProcess, DWORD_PTR lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect );
private static extern IntPtr VirtualAllocEx(
IntPtr hProcess,
IntPtr lpAddress,
IntPtr dwSize,
AllocationType flAllocationType,
uint flProtect);
internal static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr address, UIntPtr size, AllocationType allocationType, MemoryProtect protect);
internal static extern IntPtr VirtualAllocEx(SafeProcessHandle processHandle, IntPtr address, SizeT size, AllocationType flAllocationType,
MemoryProtection flProtect);
static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public void FillAllocationSlot(AllocationType allocationType, AllocationValue allocationValue)
{
this.alloctionSlots[allocationType] = allocationValue;
}
public static extern int VirtualAllocEx(IntPtr hProcess, Int32 lpAddress,
Int32 dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, AllocationType flAllocationType, ProtectType flProtect);
public AllocationEntry(uint address, uint size, AllocationType type)
{
Address = address;
Size = size;
Type = type;
}
internal static extern IntPtr VirtualAllocEx(SafeProcessHandle hProcess, uint dwAddress, int nSize, AllocationType dwAllocationType, MemoryProtection dwProtect);
public static extern bool VirtualFreeEx(
IntPtr hProcess,
IntPtr lpAddress,
uint dwSize,
AllocationType dwFreeType);
public static extern bool VirtualFree(UIntPtr lpAddress, UIntPtr dwSize, AllocationType dwFreeType);
public static extern IntPtr VirtualAlloc(IntPtr lpAddress, UIntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
public AllocationInfo(AllocationType type, int size)
{
this.type = type;
this.size = size;
}
internal static extern bool VirtualFreeEx(SafeProcessHandle processHandle, IntPtr address, SizeT size, AllocationType flAllocationType);
public static extern IntPtr VirtualAlloc(IntPtr address, Int32 size, AllocationType allocationType, MemoryProtection protection);
internal static extern IntPtr VirtualAlloc(IntPtr startAddress, UIntPtr size, AllocationType allocationType, MemoryProtection protect);
public static extern IntPtr VirtualAllocEx( SafeProcessHandle processHandle, IntPtr address, UIntPtr size, AllocationType allocationType, MemoryProtection memoryProtection );
