private async Task DecrementDate(int id)
{
RegisterEntry entry = await _registerEntriesDataService.Get(id, includeRelated : false);
if (entry == null)
{
return;
}
// save the date
var date = entry.TransactionDate;
// change date and save
entry.TransactionDate = entry.TransactionDate.AddDays(-1);
bool success = await UpdateEntry(id, entry);
if (success)
{
entry.TransactionDate = date;
UndoStack.Push(new UndoArgs()
{
Action = RegisterEntryAction.Modify, Entry = entry
});
}
}
protected override async Task OnInitializedAsync()
{
_id = 0;
if (Int32.TryParse(Id, out _id) && (_id > 0))
{
IsCreateMode = false;
}
var result1 = await _registersDataService.Get(includeRelated : false);
Registers = result1.ToList();
var result2 = await _budgetCyclesDataService.Get(includeRelated : false);
BudgetCycles = result2.ToList();
var result3 = await _budgetItemsDataService.Get(includeRelated : false);
BudgetItems = result3.ToList();
if (IsCreateMode)
{
Model = new RegisterEntry();
}
else
{
Model = await _dataService.Get(id : _id, includeRelated : true);
}
Model.SelectedRegisterId = Model.RegisterId.ToString();
Model.SelectedBudgetCycleId = Model.BudgetCycleId.ToString();
Model.SelectedBudgetItemId = Model.BudgetItemId.ToString();
}
public static void ReverseAllocatedTran(PMTran tran)
{
RegisterEntry pmEntry = PXGraph.CreateInstance <RegisterEntry>();
pmEntry.FieldVerifying.AddHandler <PMTran.projectID>((PXCache sender, PXFieldVerifyingEventArgs e) => { e.Cancel = true; });
pmEntry.FieldVerifying.AddHandler <PMTran.taskID>((PXCache sender, PXFieldVerifyingEventArgs e) => { e.Cancel = true; });
pmEntry.FieldVerifying.AddHandler <PMTran.inventoryID>((PXCache sender, PXFieldVerifyingEventArgs e) => { e.Cancel = true; });
PMRegister reversalDoc = (PMRegister)pmEntry.Document.Cache.Insert();
reversalDoc.OrigDocType = PMOrigDocType.AllocationReversal;
reversalDoc.OrigDocNbr = tran.RefNbr;
reversalDoc.Description = "Allocation Reversal to Non-Billable";
pmEntry.Document.Current = reversalDoc;
PMBillEngine engine = PXGraph.CreateInstance <PMBillEngine>();
foreach (PMTran reverse in engine.ReverseTran(tran))
{
reverse.Reversed = true;
pmEntry.Transactions.Insert(reverse);
}
tran.Reversed = true;
pmEntry.Transactions.Update(tran);
pmEntry.Save.Press();
PMSetup setup = PXSelect <PMSetup> .Select(pmEntry);
if (setup.AutoReleaseAllocation == true)
{
RegisterRelease.Release(reversalDoc);
}
}
protected static void ReleaseActivities(List <EPActivityApprove> activities)
{
RegisterEntry registerEntry = (RegisterEntry)PXGraph.CreateInstance(typeof(RegisterEntry));
bool activityAdded = false;
using (PXTransactionScope ts = new PXTransactionScope())
{
if (!RecordContractUsage(activities, "Contract-Usage"))
{
throw new PXException(Messages.FailedCreateContractUsageTransactions);
}
if (!RecordCostTrans(registerEntry, activities, out activityAdded))
{
throw new PXException(Messages.FailedCreateCostTransactions);
}
ts.Complete();
}
EPSetup setup = PXSelect <EPSetup> .Select(registerEntry);
if (activityAdded && setup != null && setup.AutomaticReleasePM == true)
{
PX.Objects.PM.RegisterRelease.Release(registerEntry.Document.Current);
}
}
public static bool RecordCostTrans(RegisterEntry registerEntry, List <EPActivityApprove> activities)
{
registerEntry.FieldVerifying.AddHandler <PMTran.inventoryID>((PXCache sender, PXFieldVerifyingEventArgs e) => { e.Cancel = true; });//restriction should be applicable only for budgeting.
EmployeeCostEngine costEngine = new EmployeeCostEngine(registerEntry);
registerEntry.Views.Caches.Add(typeof(EPActivity));
PXCache activityCache = registerEntry.Caches <EPActivity>();
registerEntry.Document.Cache.Insert();
bool success = true;
bool activityAdded = false;
for (int i = 0; i < activities.Count; i++)
{
EPActivity activity = PXSelect <EPActivity> .Search <EPActivity.taskID>(registerEntry, activities[i].TaskID);
if (activity.Released == true) //activity can be released to PM via Timecard prior to releasing the case.
{
continue;
}
try
{
if (activity.ProjectTaskID != null) //cost transactions are created only if project is set.
{
EPEmployee employee = PXSelect <EPEmployee> .Search <EPEmployee.userID>(registerEntry, activity.Owner);
activity.LabourItemID = costEngine.GetLaborClass(activity);
activityCache.Update(activity);
decimal?cost = costEngine.CalculateEmployeeCost(activity, employee.BAccountID, activity.StartDate.Value);
registerEntry.CreateTransaction(activity, employee.BAccountID, activity.StartDate.Value, activity.TimeSpent, activity.TimeBillable, cost);
activity.EmployeeRate = cost;
activityAdded = true;
}
activity.Released = true;
activityCache.Update(activity);
}
catch (Exception e)
{
PXProcessing <EPActivityApprove> .SetError(i, e is PXOuterException?e.Message + "\r\n" + String.Join("\r\n", ((PXOuterException)e).InnerMessages) : e.Message);
success = false;
}
}
if (success)
{
if (activityAdded)
{
registerEntry.Save.Press();
}
else
{
activityCache.Persist(PXDBOperation.Update);
}
}
return(success);
}
private async Task NextStatus(int id)
{
RegisterEntry entry = await _registerEntriesDataService.Get(id, includeRelated : false);
if (entry == null)
{
return;
}
// save the status
var status = entry.Status;
// change status and save
entry.Status = (int)entry.NextStatus();
bool success = await UpdateEntry(id, entry);
if (success)
{
entry.Status = status;
UndoStack.Push(new UndoArgs()
{
Action = RegisterEntryAction.Modify, Entry = entry
});
}
}
private async Task <bool> ImportRegisterEntry(IDbConnection connection, RegisterEntry registerEntry)
{
Guid organisationId = Guid.NewGuid();
DateTime createdAt = DateTime.Now;
string createdBy = "Register Import";
var organisationDataImport = new OrganisationData();
organisationDataImport.StartDate = registerEntry.StartDate;
organisationDataImport.FinancialTrackRecord = registerEntry.FinancialTrackRecord;
organisationDataImport.ParentCompanyGuarantee = registerEntry.ParentCompanyGuarantee;
if (registerEntry.EndReasonId.HasValue)
{
organisationDataImport.RemovedReason = RemovedReasons.FirstOrDefault(x => x.Id == registerEntry.EndReasonId.Value);
}
string sql = $"INSERT INTO [dbo].[Organisations] " +
" ([Id] " +
",[CreatedAt] " +
",[CreatedBy] " +
",[StatusId] " +
",[ProviderTypeId] " +
",[OrganisationTypeId] " +
",[UKPRN] " +
",[LegalName] " +
",[TradingName] " +
",[StatusDate] " +
",[OrganisationData]) " +
"VALUES " +
"(@organisationId, @createdAt, @createdBy, @statusId, @providerTypeId, @organisationTypeId," +
" @ukprn, @legalName, @tradingName, @statusDate, @organisationData)";
var statusId = registerEntry.Status;
var organisationData = JsonConvert.SerializeObject(organisationDataImport, new IsoDateTimeConverter {
DateTimeFormat = RoatpDateTimeFormat
});
var organisationsCreated = await connection.ExecuteAsync(sql,
new
{
organisationId,
createdAt,
createdBy,
statusId,
registerEntry.ProviderTypeId,
registerEntry.OrganisationTypeId,
registerEntry.UKPRN,
registerEntry.LegalName,
registerEntry.TradingName,
registerEntry.StatusDate,
organisationData
});
RegisterImportLogger.Instance.LogInsertStatement(sql, registerEntry, organisationId, createdAt,
createdBy, statusId, organisationData);
return(await Task.FromResult(organisationsCreated > 0));
}
protected virtual PMTran InsertPMTran(RegisterEntry pmGraph, PXResult <EPExpenseClaimDetails, Contract, Account> res)
{
EPExpenseClaimDetails detail = res;
Contract contract = res;
Account account = res;
if (account.AccountGroupID == null && contract.BaseType == CTPRType.Project)
{
throw new PXException(Messages.AccountGroupIsNotAssignedForAccount, account.AccountCD);
}
bool released = contract.BaseType == CTPRType.Contract; //contract trans are created as released
PMTran tran = (PMTran)pmGraph.Transactions.Cache.Insert();
tran.AccountGroupID = account.AccountGroupID;
tran.BAccountID = detail.CustomerID;
tran.LocationID = detail.CustomerLocationID;
tran.ProjectID = detail.ContractID;
tran.TaskID = detail.TaskID;
tran.CostCodeID = detail.CostCodeID;
tran.InventoryID = detail.InventoryID;
tran.Qty = detail.Qty;
tran.Billable = true;
tran.BillableQty = detail.Qty;
tran.UOM = detail.UOM;
tran.TranCuryID = detail.CuryID;
tran.BaseCuryInfoID = detail.CuryInfoID;
tran.TranCuryAmount = detail.ClaimCuryTranAmt;
tran.Amount = detail.ClaimTranAmt;
tran.TranCuryUnitRate = detail.CuryUnitCost;
tran.UnitRate = detail.UnitCost;
//TODO: Review the following code (exists only to support MA302 case when UnitCost is not entered):
if (detail.CuryUnitCost == 0m && detail.Qty != 0)
{
tran.TranCuryUnitRate = detail.ClaimCuryTranAmt / detail.Qty;
tran.UnitRate = detail.ClaimTranAmt / detail.Qty;
}
tran.AccountID = detail.ExpenseAccountID;
tran.SubID = detail.ExpenseSubID;
tran.StartDate = detail.ExpenseDate;
tran.EndDate = detail.ExpenseDate;
tran.Date = detail.ExpenseDate;
tran.ResourceID = detail.EmployeeID;
tran.Released = released;
tran = pmGraph.Transactions.Update(tran);
pmGraph.Document.Current.Released = released;
if (released)
{
pmGraph.Document.Current.Status = PMRegister.status.Released;
}
PXNoteAttribute.CopyNoteAndFiles(Caches[typeof(EPExpenseClaimDetails)], detail, pmGraph.Transactions.Cache, tran, Setup.Current.GetCopyNoteSettings <PXModule.pm>());
return(tran);
}
private RegisterEntry CopyValuesToRegisterModel(RegisterEntry registerEntry)
{
registerEntry.Email = Email.Value;
registerEntry.BirthDate = BirthDate.Value;
registerEntry.FullName = FullName.Value;
registerEntry.Password = Password.Value;
return(registerEntry);
}
private void TryToUpdateRegister(ArmRegister aObjectToUpdate, RegisterCollection aSource)
{
RegisterEntry entry = aSource[aObjectToUpdate.RegType];
if (entry != null)
{
aObjectToUpdate.Value = entry.Value;
}
}
public void TC_13_01_SubjectTest_POST_LOGIN_SUC()
{
//arrange+act
IRestResponse response = GetResponse(client, "/api/login", Method.POST, HttpStatusCode.Created, "{\n \"email\": \"peter @klaven\",\n\"password\": \"cityslicka\" \n}");
RegisterEntry userResponse =
JsonConvert.DeserializeObject <RegisterEntry>(response.Content);
// assert
Assert.That(userResponse.Token, Is.EqualTo("QpwL5tke4Pnpja7X"));
}
public void TC_14_01_SubjectTest_POST_LOGIN_UNSUC()
{
//arrange+act
IRestResponse response = GetResponse(client, "/api/register", Method.POST, HttpStatusCode.BadRequest, "{\n\"email\": \"sydney @fife\"\n}");
RegisterEntry userResponse =
JsonConvert.DeserializeObject <RegisterEntry>(response.Content);
// assert
Assert.That(userResponse.Error, Is.EqualTo("Missing password"));
}
public virtual IEnumerable ViewDocument(PXAdapter adapter)
{
RegisterEntry graph = CreateInstance <RegisterEntry>();
graph.Document.Current = graph.Document.Search <PMRegister.refNbr>(Transactions.Current.RefNbr, Transactions.Current.TranType);
throw new PXRedirectRequiredException(graph, "PMTransactiosn")
{
Mode = PXBaseRedirectException.WindowMode.NewWindow
};
}
public void TC_11_01_SubjectTest_POST_RIGESTER_SUC_TokenLength()
{
//arrange+act
IRestResponse response = GetResponse(client, "/api/register", Method.POST, HttpStatusCode.Created, "{\n\"email\": \"sydney @fife\",\n\"password\": \"pistol\"\n}");
RegisterEntry userResponse =
JsonConvert.DeserializeObject <RegisterEntry>(response.Content);
// assert
Assert.That(userResponse.Token.Length, Is.EqualTo(16));
}
public int ProgramCounter => 32; // x0 ....x31, x32 = PC
public Register64()
{
register = new RegisterEntry[33]; // Register 0,1,2...32
pcRegister = 32;
for (int index = 0; index <= 32; index++)
{
register[index] = new RegisterEntry(Architecture.Rv64I);
}
}
protected virtual void InsertPMTran(RegisterEntry pmGraph, EPExpenseClaimDetails row, EPExpenseClaim doc, bool copyNotes, bool copyFiles)
{
PMProject project = PXSelect <PMProject, Where <PMProject.contractID, Equal <Required <PMProject.contractID> > > > .Select(pmGraph, row.ContractID);
Account account = PXSelect <Account, Where <Account.accountID, Equal <Required <Account.accountID> > > > .Select(this, row.ExpenseAccountID);
if (account.AccountGroupID == null && project.BaseType == PMProject.ProjectBaseType.Project)
{
throw new PXException(Messages.AccountGroupIsNotAssignedForAccount, account.AccountCD);
}
PMTran tran = (PMTran)pmGraph.Transactions.Cache.Insert();
tran.AccountGroupID = account.AccountGroupID;
tran.BAccountID = row.CustomerID;
tran.LocationID = row.CustomerLocationID;
tran.ProjectID = row.ContractID;
tran.TaskID = row.TaskID;
tran.InventoryID = row.InventoryID;
tran.Qty = row.Qty;
tran.Billable = true;
tran.BillableQty = row.Qty;
tran.UOM = row.UOM;
tran.UnitRate = row.UnitCost;
tran.Amount = row.TranAmt;
tran.AccountID = row.ExpenseAccountID;
tran.SubID = row.ExpenseSubID;
tran.StartDate = row.ExpenseDate;
tran.EndDate = row.ExpenseDate;
tran.Date = row.ExpenseDate;
tran.ResourceID = doc.EmployeeID;
tran.Released = project.BaseType == PMProject.ContractBaseType.Contract; //contract trans are created as released
pmGraph.Transactions.Update(tran);
pmGraph.Document.Current.Released = project.BaseType == PMProject.ContractBaseType.Contract;
if (copyNotes)
{
string note = PXNoteAttribute.GetNote(Caches[typeof(EPExpenseClaimDetails)], row);
if (note != null)
{
PXNoteAttribute.SetNote(pmGraph.Transactions.Cache, tran, note);
}
}
if (copyFiles)
{
Guid[] files = PXNoteAttribute.GetFileNotes(Caches[typeof(EPExpenseClaimDetails)], row);
if (files != null && files.Length > 0)
{
PXNoteAttribute.SetFileNotes(pmGraph.Transactions.Cache, tran, files);
}
}
}
private RegisterCollection GetUserContextRegisters()
{
bool isCurrent = IsCurrent;
RegisterCollection ret = new RegisterCollection(Registers, RegisterCollection.TType.ETypeUser, iParentThread.OwningProcess);
// User-land CPSR is stored in SPSR_SVC
RegisterEntry spsr = Registers[TArmRegisterType.EArmReg_SPSR];
ret[TArmRegisterType.EArmReg_CPSR].Value = spsr.Value;
// Get the context table that we'll need to work out the reg positions
UserContextTable.UserContextTable table = CrashDebugger.UserContextTableManager[UserContextType];
// Get SP and stack data for supervisor thread
uint sp = SavedSP;
ThreadStackData spData = iParentThread.StackInfoSupervisor.Data;
if (spData.Info.Data.Size > 0)
{
// This is the user side address that will be branched back to once we exit SVC mode...
uint retAddr = UserReturnAddress;
ret[TArmRegisterType.EArmReg_PC].Value = retAddr;
// Now try to get the register values off of the supervisor stack
DataBuffer superStackData = spData.Data;
foreach (ArmRegister reg in ret)
{
if (UserContextTable.UserContextTable.IsSupported(reg.RegType))
{
UserContextTableEntry uctEntry = table[reg.RegType];
if (uctEntry.IsAvailable(isCurrent))
{
ArmRegister savedSp = new ArmRegister(TArmRegisterType.EArmReg_SP, sp);
uint newValue = uctEntry.Process(savedSp, superStackData);
reg.Value = newValue;
}
}
}
}
// Getting context of current thread? Some values can be fetched directly
// from the registers if they are not available from the stack.
if (isCurrent && table[TArmRegisterType.EArmReg_SP].Type == UserContextTableEntry.TType.EOffsetFromSp)
{
RegisterCollection userRegs = CrashDebugger.InfoCpu[RegisterCollection.TType.ETypeUser];
//
ret[TArmRegisterType.EArmReg_SP].Value = userRegs[TArmRegisterType.EArmReg_SP];
ret[TArmRegisterType.EArmReg_LR].Value = userRegs[TArmRegisterType.EArmReg_LR];
}
return(ret);
}
public ActionResult CreateRegisterEntry(int localhelpId)
{
var localhelp = db.LocalHelps.Find(localhelpId);
localhelp.Description = Server.HtmlDecode(localhelp.Description);
ViewBag.localhelp = localhelp;
var reg = new RegisterEntry
{
LocalHelpId = localhelpId,
};
return(View(reg));
}
/// <summary>
/// Allocates a specific register kind for the given node.
/// </summary>
/// <param name="node">The node to allocate the register for.</param>
/// <returns>The allocated register.</returns>
public Register Allocate(Value node)
{
Debug.Assert(node != null, "Invalid node");
if (aliases.TryGetValue(node, out Value alias))
node = alias;
if (!registerLookup.TryGetValue(node, out RegisterEntry entry))
{
var targetRegister = AllocateType(node.Type);
entry = new RegisterEntry(targetRegister, node);
registerLookup.Add(node, entry);
}
return entry.Register;
}
private async Task AddEntry(RegisterEntry entry)
{
bool success = await _registerEntriesDataService.Create(entry);
if (success)
{
_toastService.ShowSuccess("Add Entry Successful", "");
var result = await _registerEntriesDataService.Get(includeRelated : true);
Register.RegisterEntries = result.ToList();
Register.Balance();
}
}
private async Task <bool> UpdateEntry(int id, RegisterEntry entry)
{
bool success = await _registerEntriesDataService.Update(id, entry);
if (success)
{
var result = await _registerEntriesDataService.Get(includeRelated : true);
Register.RegisterEntries = result.ToList();
Register.Balance();
}
return(success);
}
public void Before_each_test()
{
_registerEntry = new RegisterEntry
{
UKPRN = 10002222,
ProviderTypeId = 1,
OrganisationTypeId = 0,
LegalName = "Training Company",
Status = "1"
};
_validator = new RegisterEntryValidator();
}
public ActionResult CreateRegisterEntry(RegisterEntry reg)
{
if (ModelState.IsValid)
{
db.RegisterEntries.Add(reg);
db.SaveChanges();
return(RedirectToAction("CreateRegisterEntry", new { localhelpId = reg.LocalHelpId }));
}
var localhelp = db.LocalHelps.Find(reg.LocalHelpId);
localhelp.Description = Server.HtmlDecode(localhelp.Description);
ViewBag.localhelp = localhelp;
return(View(reg));
}
protected virtual PMTran InsertPMTran(RegisterEntry pmGraph, PXResult <EPExpenseClaimDetails, Contract, Account> res)
{
EPExpenseClaimDetails detail = res;
Contract contract = res;
Account account = res;
if (account.AccountGroupID == null && contract.BaseType == PMProject.ProjectBaseType.Project)
{
throw new PXException(Messages.AccountGroupIsNotAssignedForAccount, account.AccountCD);
}
bool released = contract.BaseType == Contract.ContractBaseType.Contract; //contract trans are created as released
PMTran tran = (PMTran)pmGraph.Transactions.Cache.Insert();
tran.AccountGroupID = account.AccountGroupID;
tran.BAccountID = detail.CustomerID;
tran.LocationID = detail.CustomerLocationID;
tran.ProjectID = detail.ContractID;
tran.TaskID = detail.TaskID;
tran.InventoryID = detail.InventoryID;
tran.Qty = detail.Qty;
tran.Billable = true;
tran.BillableQty = detail.Qty;
tran.UOM = detail.UOM;
if (detail.CuryInfoID == detail.ClaimCuryInfoID && detail.EmployeePart == 0m)
{
tran.UnitRate = detail.UnitCost;
}
else
{
tran.UnitRate = detail.ClaimTranAmt / detail.Qty;
}
tran.Amount = detail.ClaimTranAmt;
tran.AccountID = detail.ExpenseAccountID;
tran.SubID = detail.ExpenseSubID;
tran.StartDate = detail.ExpenseDate;
tran.EndDate = detail.ExpenseDate;
tran.Date = detail.ExpenseDate;
tran.ResourceID = detail.EmployeeID;
tran.Released = released;
tran = pmGraph.Transactions.Update(tran);
pmGraph.Document.Current.Released = released;
PXNoteAttribute.CopyNoteAndFiles(Caches[typeof(EPExpenseClaimDetails)], detail, pmGraph.Transactions.Cache, tran, Setup.Current.GetCopyNoteSettings <PXModule.pm>());
return(tran);
}
public static bool RecordContractUsage(List <EPActivityApprove> activities, string description)
{
RegisterEntry registerEntry = PXGraph.CreateInstance <RegisterEntry>();
registerEntry.FieldVerifying.AddHandler <PMTran.projectID>((PXCache sender, PXFieldVerifyingEventArgs e) => { e.Cancel = true; });
registerEntry.FieldVerifying.AddHandler <PMTran.inventoryID>((PXCache sender, PXFieldVerifyingEventArgs e) => { e.Cancel = true; });//restriction should be applicable only for budgeting.
registerEntry.Document.Cache.Insert();
registerEntry.Document.Current.Description = description;
registerEntry.Document.Current.Released = true;
registerEntry.Views.Caches.Add(typeof(EPActivity));
PXCache activityCache = registerEntry.Caches <EPActivity>();
bool success = true;
bool activityAdded = false;
for (int i = 0; i < activities.Count; i++)
{
EPActivity activity = activities[i];
try
{
if (activity.RefNoteID != null && PXSelect <CRCase, Where <CRCase.noteID, Equal <Required <CRCase.noteID> > > > .Select(registerEntry, activity.RefNoteID).Count == 1)
{
//Add Contract-Usage
activityAdded = registerEntry.CreateContractUsage(activity) != null || activityAdded;
activity.Billed = true;
activityCache.Update(activity);
}
}
catch (Exception e)
{
PXProcessing <EPActivityApprove> .SetError(i, e is PXOuterException?e.Message + "\r\n" + String.Join("\r\n", ((PXOuterException)e).InnerMessages) : e.Message);
success = false;
}
}
if (success)
{
if (activityAdded)
{
registerEntry.Save.Press();
}
else
{
activityCache.Persist(PXDBOperation.Update);
}
}
return(success);
}
public void LogInsertStatement(string sql, RegisterEntry registerEntry, Guid organisationId, DateTime createdAt, string createdBy, string statusId, string organisationData)
{
if (!LogEnabled)
{
return;
}
registerEntry.LegalName = registerEntry.LegalName.Replace("'", "''");
registerEntry.TradingName = registerEntry.TradingName.Replace("'", "''");
string formattedSql = $"exec sp_executesql N'{sql}',N'@organisationId uniqueidentifier,@createdAt datetime,@createdBy nvarchar(4000),@statusId nvarchar(4000),@providerTypeId int,@OrganisationTypeId int,@UKPRN bigint,@LegalName nvarchar(4000),@TradingName nvarchar(4000),@statusDate datetime,@organisationData nvarchar(4000)',@organisationId='{organisationId}',@createdAt='{createdAt.ToString("yyyyMMdd HH:mm:ss")}',@createdBy=N'{createdBy}',@statusId=N'{statusId}',@ProviderTypeId={registerEntry.ProviderTypeId},@OrganisationTypeId={registerEntry.OrganisationTypeId},@UKPRN={registerEntry.UKPRN},@LegalName=N'{registerEntry.LegalName}',@TradingName=N'{registerEntry.TradingName}',@statusDate='{registerEntry.StatusDate.Value.ToString("yyyyMMdd HH:mm:ss")}',@organisationData=N'{organisationData}'";
_logWriter.WriteLine($"{formattedSql}\n");
}
/// <summary>
/// Allocates a specific register kind for the given node.
/// </summary>
/// <param name="node">The node to allocate the register for.</param>
/// <returns>The allocated register.</returns>
public Register Allocate(Value node)
{
node.AssertNotNull(node);
if (aliases.TryGetValue(node, out Value alias))
{
node = alias;
}
if (!registerLookup.TryGetValue(node, out RegisterEntry entry))
{
var targetRegister = AllocateType(node.Type);
entry = new RegisterEntry(targetRegister, node);
registerLookup.Add(node, entry);
}
return(entry.Register);
}
/// <summary>
/// Allocates a specific register kind for the given node.
/// </summary>
/// <param name="node">The node to allocate the register for.</param>
/// <param name="description">The register description to allocate.</param>
/// <returns>The allocated register.</returns>
public PrimitiveRegister Allocate(Value node, RegisterDescription description)
{
Debug.Assert(node != null, "Invalid node");
if (aliases.TryGetValue(node, out Value alias))
node = alias;
if (!registerLookup.TryGetValue(node, out RegisterEntry entry))
{
var targetRegister = AllocateRegister(description);
entry = new RegisterEntry(targetRegister, node);
registerLookup.Add(node, entry);
}
var result = entry.Register as PrimitiveRegister;
Debug.Assert(result != null, "Invalid primitive register");
return result;
}
public async Task <IActionResult> Register(RegisterEntry entry)
{
//if (!entry.Email.Contains("@gmail.com") || !entry.Email.Contains("@outlook.com"))
//{
// ViewData["WrongRegister"] = "Only gmail.com accounts are allowed!";
// return View(entry);
//}
try
{
//User user = await _userManager.GetUserByEmailAsync(entry.Email);
//if (user != null)
//{
// ViewData["WrongRegister"] = "Email already taken!";
// return View(entry);
//}
if (null == await _userManager.GetUserByUsernameAsync(entry.DiscordUsername))
{
ViewData["WrongRegister"] = "You haven't signed up with this Discord user yet. Please type !signup in the Discord Server, where you're using the bot.";
return(View(entry));
}
var tempEmail = (await _userManager.GetUserByUsernameAsync(entry.DiscordUsername)).Email;
if (!tempEmail[tempEmail.Length - 1].Equals('@'))
{
ViewData["WrongRegister"] = "You've already signed up with this Discord user.";
//return View(entry);
}
string password = HashUtils.CreateHashCode(entry.Password);
string validationCode = HashUtils.CreateReferralCode();
User newUser = new User(entry.DiscordUsername, entry.Email, password, Role.User, validationCode, false);
_ctx.Users.Remove(_ctx.Users.FirstOrDefault(u => u.Username == entry.DiscordUsername));
_ctx.SaveChanges();
await _userManager.RegisterAsync(newUser);
await _notificationManager.SendConfirmationEmailAsync(newUser);
}
catch (Exception)
{
//await _logger.LogCustomExceptionAsync(ex, null);
return(RedirectToAction("Error", "Home"));
}
return(View("Welcome"));
}
/*
*
* x? 31 ..... 0
* x0 0000 Readonly
* x1 ????
* x2 ????
* ...
* x31 ????
* x32 pc program counter
*
*
*
*
* as a
* - collection of booleans
* - two complement signed bytes
* - two complement unsigned bytes
*/
public Register32(Architecture architecture)
{
register = new RegisterEntry[33]; // Register 0,1,2...32
if (architecture == Architecture.Rv32I)
{
pcRegister = 32;
}
else
{
pcRegister = 16;
}
for (int index = 0; index <= 32; index++)
{
register[index] = new RegisterEntry(architecture);
}
}
public static RegisterEntry GetRegister(int _Size)
{
bool[] mask = GetRegisterMask();
for (int i = 16; i < 256; i++)//first 16 registers are for UART communication
{
bool ok = true;
if (i >= 255 - TimerCount * 4) ok = false;
if (i < 128 && i + _Size >= 128) ok = false;//if the register is hanging over the edge between memory block a and b, dont create it
for (int j = 0; j < _Size; j++)
{
if (mask[i + j]) ok = false;
}
if (ok)
{
RegisterEntry e = new RegisterEntry();
e.index = (byte)i;
e.size = _Size;
UsedRegisters.Add(e);
return e;
}
}
throw new Exception("Out of registers!");
}
