public ShellForm(List<string> fileNames, HashHelper.HashType type)
: this()
{
this.hashType = type;
this.fileNames = fileNames;
KeyValuePair<HashHelper.HashType, List<string>> pair = new KeyValuePair<HashHelper.HashType, List<string>>(type, fileNames);
bgWorker.RunWorkerAsync(pair);
}
public ActionResult Seed(Tenant tenant)
{
var selectedTenant = db.Tenants.Find(tenant.Id);
if (selectedTenant != null)
{
var connectionString = selectedTenant.ConnectionString;
if (!string.IsNullOrEmpty(connectionString))
{
using (var context = new GridDataContext(connectionString))
{
var accessRule = AccessRule.CreateNewUserAccessRule(true);
context.AccessRules.Add(accessRule);
context.SaveChanges();
var person = new Person();
context.Persons.Add(person);
context.SaveChanges();
var manageCompany = new Permission {
Title = "Manage Company", PermissionCode = 200
};
context.Permissions.Add(manageCompany);
var manageHRMS = new Permission {
Title = "Manage HRMS", PermissionCode = 210
};
context.Permissions.Add(manageHRMS);
var manageSales = new Permission {
Title = "Manage Sales", PermissionCode = 220
};
context.Permissions.Add(manageSales);
var manageIT = new Permission {
Title = "Manage IT", PermissionCode = 230
};
context.Permissions.Add(manageIT);
var managePMS = new Permission {
Title = "Manage PMS", PermissionCode = 240
};
context.Permissions.Add(managePMS);
var manageInventory = new Permission {
Title = "Manage Inventory", PermissionCode = 250
};
context.Permissions.Add(manageInventory);
var manageLMS = new Permission {
Title = "Manage LMS", PermissionCode = 215
};
context.Permissions.Add(manageLMS);
var manageTimeSheet = new Permission {
Title = "Manage TimeSheet", PermissionCode = 300
};
context.Permissions.Add(manageTimeSheet);
var manageRecruit = new Permission {
Title = "Manage Recruit", PermissionCode = 500
};
context.Permissions.Add(manageRecruit);
var superPermission = new Permission {
Title = "Super Permission", PermissionCode = 9999
};
context.Permissions.Add(superPermission);
var manageTMS = new Permission {
Title = "Manage TMS", PermissionCode = 550
};
context.Permissions.Add(manageTMS);
var manageKBS = new Permission {
Title = "Manage KBS", PermissionCode = 700
};
context.Permissions.Add(manageKBS);
var viewSettings = new Permission {
Title = "View Settings", PermissionCode = 909
};
context.Permissions.Add(viewSettings);
var manageCRM = new Permission {
Title = "Manage CRM", PermissionCode = 222
};
context.Permissions.Add(manageCRM);
var manageTicketDesk = new Permission {
Title = "Manage Ticket Desk", PermissionCode = 1100
};
context.Permissions.Add(manageTicketDesk);
context.SaveChanges();
var adminRole = new Role {
Name = "Admin"
};
context.Roles.Add(adminRole);
context.SaveChanges();
// Role Permission Mapping
var permissions = context.Permissions.ToList();
foreach (var permission in permissions)
{
var newMap = new RolePermission
{
RoleId = adminRole.Id,
PermissionId = permission.Id
};
context.RolePermissions.Add(newMap);
}
context.SaveChanges();
// Create User
var user = new User
{
EmployeeCode = "Code",
Username = selectedTenant.Email,
Password = HashHelper.Hash("123456"),
AccessRuleId = accessRule.Id,
PersonId = person.Id
};
context.Users.Add(user);
context.SaveChanges();
// Role Member Mapping
var newMember = new RoleMember
{
RoleId = adminRole.Id,
UserId = user.Id
};
context.RoleMembers.Add(newMember);
context.SaveChanges();
return(RedirectToAction("Index"));
}
}
}
return(View(tenant));
}
/// <summary>
/// The render version.
/// </summary>
/// <param name="footer">
/// The footer.
/// </param>
private void RenderVersion([NotNull] StringBuilder footer)
{
CodeContracts.VerifyNotNull(footer, "footer");
// Copyright Linkback Algorithm
// Please keep if you haven't purchased a removal or commercial license.
var domainKey = this.Get <YafBoardSettings>().CopyrightRemovalDomainKey;
if (domainKey.IsSet())
{
var currentDomainHash = HashHelper.Hash(
this.Get <HttpRequestBase>().Url.DnsSafeHost.ToLower(),
HashHelper.HashAlgorithmType.SHA1,
this.GetType().GetSigningKey().ToString(),
false);
if (domainKey.Equals(currentDomainHash))
{
return;
}
}
// get the theme credit info from the theme file
// it's not really an error if it doesn't exist
string themeCredit = this.Get <ITheme>().GetItem("THEME", "CREDIT", null);
// append theme Credit if it exists...
if (themeCredit.IsSet())
{
footer.AppendFormat(@"<span id=""themecredit"" style=""color:#999999"">{0}</span>", themeCredit);
footer.Append("<br />");
}
footer.Append(@"<a target=""_top"" title=""YetAnotherForum.NET"" href=""http://www.yetanotherforum.net"">");
footer.Append(this.GetText("COMMON", "POWERED_BY"));
footer.Append(@" YAF");
if (this.Get <YafBoardSettings>().ShowYAFVersion)
{
footer.AppendFormat(" {0} ", YafForumInfo.AppVersionName);
if (Config.IsDotNetNuke)
{
footer.Append(" Under DNN ");
}
else if (Config.IsRainbow)
{
footer.Append(" Under Rainbow ");
}
else if (Config.IsMojoPortal)
{
footer.Append(" Under MojoPortal ");
}
else if (Config.IsPortalomatic)
{
footer.Append(" Under Portalomatic ");
}
}
footer.AppendFormat(
@"</a> | <a target=""_top"" title=""{0}"" href=""{1}"">YAF © 2003-{2}, Yet Another Forum.NET</a>",
"YetAnotherForum.NET",
"http://www.yetanotherforum.net",
DateTime.UtcNow.Year);
}
public ServiceInfo(Type type, object tag)
{
Type = type;
Tag = tag;
_hash = HashHelper.CombineHash(Type.GetHashCode(), Tag != null ? Tag.GetHashCode() : 0);
}
public T this[object item]
{
get
{
if (_count == 0 || item == null)
{
return(default(T));
}
if (_usesHashCode)
{
if (_hashtable == null || !_hashtable.ContainsKey(item))
{
return(default(T));
}
return(_hashtable[item] as T);
}
else
{
if (_list == null)
{
return(default(T));
}
for (int i = 0; i < _list.Count; i++)
{
KeyValuePair <object, T> pair = _list[i];
if (Object.Equals(item, pair.Key))
{
return(pair.Value);
}
}
return(default(T));
}
}
set
{
// Does not cache null items
if (item == null)
{
return;
}
// When we add the first item we need to determine whether to use hashtable or list
if (_count == 0)
{
_usesHashCode = item != null && HashHelper.HasReliableHashCode(item);
}
if (_usesHashCode)
{
if (_hashtable == null)
{
_hashtable = new WeakDictionary <object, T>();
}
if (!_hashtable.ContainsKey(item) && value is T)
{
_hashtable[item] = value;
}
else
{
Debug.Assert(false, "it must not add already present Item");
}
}
else
{
if (_list == null)
{
_list = new List <KeyValuePair <object, T> >();
}
if (value is T)
{
_list.Add(new KeyValuePair <object, T>(item, value));
}
}
_count++;
}
}
public void AttachFile()
{
void Template(string fileName, EncodedFile.EncodeMode encodeMode)
{
EngineState s = EngineTests.CreateEngineState();
string srcDir = StringEscaper.Preprocess(s, Path.Combine("%TestBench%", "EncodedFile"));
string srcScript = Path.Combine(srcDir, "Blank.script");
string destDir = FileHelper.GetTempDir();
string destScript = Path.Combine(destDir, "EncodeFileTests.script");
File.Copy(srcScript, destScript, true);
try
{
Script sc = s.Project.LoadScriptRuntime(destScript, new LoadScriptRuntimeOptions());
string originFile = Path.Combine(srcDir, fileName);
EncodedFile.AttachFile(sc, "FolderExample", fileName, originFile, encodeMode, null);
// Check whether file was successfully encoded
Assert.IsTrue(sc.Sections.ContainsKey("EncodedFolders"));
string[] folders = sc.Sections["EncodedFolders"].Lines
.Where(x => x.Length != 0)
.ToArray();
Assert.IsTrue(folders.Length == 2);
Assert.IsTrue(folders[0].Equals("FolderExample", StringComparison.Ordinal));
Assert.IsTrue(sc.Sections.ContainsKey("FolderExample"));
string[] fileInfos = sc.Sections["FolderExample"].Lines
.Where(x => x.Length != 0)
.ToArray();
Assert.IsTrue(fileInfos[0].StartsWith($"{fileName}=", StringComparison.Ordinal));
Assert.IsTrue(sc.Sections.ContainsKey($"EncodedFile-FolderExample-{fileName}"));
string[] encodedFile = sc.Sections[$"EncodedFile-FolderExample-{fileName}"].Lines
.Where(x => x.Length != 0)
.ToArray();
Assert.IsTrue(1 < encodedFile.Length);
Assert.IsTrue(encodedFile[0].StartsWith("lines=", StringComparison.Ordinal));
// Check whether file can be successfully extracted
byte[] extractDigest;
using (MemoryStream ms = new MemoryStream())
{
EncodedFile.ExtractFile(sc, "FolderExample", fileName, ms, null);
ms.Position = 0;
extractDigest = HashHelper.GetHash(HashHelper.HashType.SHA256, ms);
}
byte[] originDigest;
using (FileStream fs = new FileStream(originFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
originDigest = HashHelper.GetHash(HashHelper.HashType.SHA256, fs);
}
Assert.IsTrue(originDigest.SequenceEqual(extractDigest));
}
finally
{
if (Directory.Exists(destDir))
{
Directory.Delete(destDir, true);
}
if (File.Exists(destScript))
{
File.Delete(destScript);
}
}
}
Template("Type1.jpg", EncodedFile.EncodeMode.ZLib); // Type 1
Template("Type2.7z", EncodedFile.EncodeMode.Raw); // Type 2
Template("Type3.pdf", EncodedFile.EncodeMode.XZ); // Type 3
Template("PEBakeryAlphaMemory.jpg", EncodedFile.EncodeMode.ZLib);
}
private static String HashUserAgentString(String userAgent)
{
return(HashHelper.GetHash(userAgent));
}
public async Task StateSizeLimitStateProvider_GetAndSet_Test()
{
var blockIndex = new BlockIndex
{
BlockHash = HashHelper.ComputeFrom("BlockHash"),
BlockHeight = 1
};
await _blockStateSetManger.SetBlockStateSetAsync(new BlockStateSet
{
BlockHash = blockIndex.BlockHash,
BlockHeight = blockIndex.BlockHeight
});
{
var limit = await _stateSizeLimitProvider.GetStateSizeLimitAsync(blockIndex);
limit.ShouldBe(SmartContractConstants.StateSizeLimit);
}
var expectedLimit = 50;
{
await _stateSizeLimitProvider.SetStateSizeLimitAsync(blockIndex, expectedLimit);
var limit = await _stateSizeLimitProvider.GetStateSizeLimitAsync(blockIndex);
limit.ShouldBe(expectedLimit);
expectedLimit = 1;
await _stateSizeLimitProvider.SetStateSizeLimitAsync(blockIndex, expectedLimit);
limit = await _stateSizeLimitProvider.GetStateSizeLimitAsync(blockIndex);
limit.ShouldBe(expectedLimit);
await _stateSizeLimitProvider.SetStateSizeLimitAsync(blockIndex, 0);
limit = await _stateSizeLimitProvider.GetStateSizeLimitAsync(
new ChainContext
{
BlockHash = blockIndex.BlockHash,
BlockHeight = blockIndex.BlockHeight
});
limit.ShouldBe(expectedLimit);
}
var blockIndex2 = new BlockIndex
{
BlockHash = HashHelper.ComputeFrom("BlockHash1"),
BlockHeight = blockIndex.BlockHeight + 1
};
var blockStateSet2 = new BlockStateSet
{
PreviousHash = blockIndex.BlockHash,
BlockHash = blockIndex2.BlockHash,
BlockHeight = blockIndex2.BlockHeight + 1
};
await _blockStateSetManger.SetBlockStateSetAsync(blockStateSet2);
{
var stateSizeLimit =
await _stateSizeLimitProvider.GetStateSizeLimitAsync(blockIndex2);
stateSizeLimit.ShouldBe(expectedLimit);
}
}
public async Task <bool> ComparePassword(string username, string password)
{
var user = await _db.Users.FirstAsync(user => user.Username == username);
return(user.Password == HashHelper.ComputeHash(password));
}
/// <summary>
/// Constructs a hash code used in the collections.
/// </summary>
/// <returns>Hash code of the object.</returns>
public override int GetHashCode()
{
return(HashHelper.GetHashCodeForOrderNoMatterCollection(this).CombineHashCode("Conditions"));
}
public void TestCrc64()
{
var result = HashHelper.ComputeCrc64IsoHash("paradaso");
Assert.AreEqual("53d38bec9bf23bf1", result);
}
/// <summary>
/// Gets the name of an index
/// </summary>
/// <param name="targetTable">Target table name</param>
/// <param name="targetColumn">Target column name</param>
/// <returns>Name of an index</returns>
public string GetIndexName(string targetTable, string targetColumn)
{
return("IX_" + HashHelper.CreateHash(Encoding.UTF8.GetBytes($"{targetTable}_{targetColumn}"), HASH_ALGORITHM));
}
/// <summary>
/// Gets the name of a foreign key
/// </summary>
/// <param name="foreignTable">Foreign key table</param>
/// <param name="foreignColumn">Foreign key column name</param>
/// <param name="primaryTable">Primary table</param>
/// <param name="primaryColumn">Primary key column name</param>
/// <returns>Name of a foreign key</returns>
public string CreateForeignKeyName(string foreignTable, string foreignColumn, string primaryTable, string primaryColumn)
{
return("FK_" + HashHelper.CreateHash(Encoding.UTF8.GetBytes($"{foreignTable}_{foreignColumn}_{primaryTable}_{primaryColumn}"), HASH_ALGORITHM));
}
public IRpcMethodResult ListTransactions(string account, int count, int skip = 0, bool includeWatchOnly = true)
{
try
{
var txComponent = new TransactionComponent();
var accountComponent = new AccountComponent();
var addressBookComponent = new AddressBookComponent();
var utxoComponent = new UtxoComponent();
var blockComponent = new BlockComponent();
var transactionCommentComponent = new TransactionCommentComponent();
List <PaymentOM> result = new List <PaymentOM>();
var accounts = accountComponent.GetAllAccounts();
var paymentAccountIds = accounts.Where(a => !string.IsNullOrWhiteSpace(a.PrivateKey)).Select(a => a.Id).ToList();
var allAccountIds = accounts.Select(a => a.Id).ToList();
var addressBook = addressBookComponent.GetWholeAddressBook();
var latestHeight = blockComponent.GetLatestHeight();
var data = txComponent.SearchTransactionEntities(account, count, skip, includeWatchOnly);
foreach (var tx in data)
{
long totalInput = 0;
long selfTotalOutput = 0;
long otherUserTotalOutput = 0;
bool coibase = false;
if (tx.Inputs.Count == 1 && tx.Outputs.Count == 1 && tx.Inputs[0].OutputTransactionHash == Base16.Encode(HashHelper.EmptyHash()))
{
coibase = true;
}
if (!coibase)
{
foreach (var input in tx.Inputs)
{
var oldOutput = txComponent.GetOutputEntiyByIndexAndTxHash(input.OutputTransactionHash, input.OutputIndex);
if (oldOutput != null && paymentAccountIds.Contains(oldOutput.ReceiverId))
{
totalInput += input.Amount;
}
else
{
totalInput = 0;
break;
}
}
}
foreach (var output in tx.Outputs)
{
if (allAccountIds.Contains(output.ReceiverId))
{
selfTotalOutput += output.Amount;
}
else
{
otherUserTotalOutput += output.Amount;
}
}
BlockMsg block = null;
if (tx.BlockHash != null)
{
block = blockComponent.GetBlockMsgByHash(tx.BlockHash);
}
if (coibase)
{
var payment = new PaymentOM();
payment.address = tx.Outputs[0].ReceiverId;
payment.account = accounts.Where(a => a.Id == payment.address).Select(a => a.Tag).FirstOrDefault();
payment.category = "generate";
payment.totalInput = totalInput;
payment.totalOutput = selfTotalOutput;
payment.amount = selfTotalOutput;
payment.fee = 0;
payment.txId = tx.Hash;
payment.vout = 0;
payment.time = tx.Timestamp;
payment.size = tx.Size;
var txComment = transactionCommentComponent.GetByTransactionHashAndIndex(tx.Hash, 0);
if (txComment != null)
{
payment.comment = txComment.Comment;
}
if (block != null)
{
payment.blockHash = tx.BlockHash;
payment.blockIndex = 0;// block.Transactions.FindIndex(t=>t.Hash == tx.Hash);
payment.blockTime = block.Header.Timestamp;
payment.confirmations = latestHeight - block.Header.Height + 1;
}
else
{
payment.confirmations = 0;
}
result.Add(payment);
}
else if (totalInput > 0 && otherUserTotalOutput == 0)
{
var payment = new PaymentOM();
payment.address = null;
payment.account = null;
payment.category = "self";
payment.totalInput = totalInput;
payment.totalOutput = tx.Outputs[0].Amount;// selfTotalOutput;
payment.fee = totalInput - selfTotalOutput;
payment.amount = payment.fee;
payment.txId = tx.Hash;
payment.vout = 0;
payment.time = tx.Timestamp;
payment.size = tx.Size;
var txComments = transactionCommentComponent.GetByTransactionHash(tx.Hash);
if (txComments.Count > 0)
{
payment.comment = "";
foreach (var item in txComments)
{
if (!string.IsNullOrWhiteSpace(item.Comment))
{
payment.comment += item.Comment + ";";
}
}
}
if (block != null)
{
payment.blockHash = tx.BlockHash;
payment.blockIndex = block.Transactions.FindIndex(t => t.Hash == tx.Hash);
payment.blockTime = block.Header.Timestamp;
payment.confirmations = latestHeight - block.Header.Height + 1;
}
else
{
payment.confirmations = 0;
}
result.Add(payment);
}
else if (totalInput > 0)
{
for (int i = 0; i < tx.Outputs.Count; i++)
{
if (!allAccountIds.Contains(tx.Outputs[i].ReceiverId))
{
var payment = new PaymentOM();
payment.address = tx.Outputs[i].ReceiverId;
payment.account = addressBook.Where(a => a.Address == payment.address && !string.IsNullOrWhiteSpace(a.Tag)).Select(a => a.Tag).FirstOrDefault();
payment.category = "send";
payment.totalInput = totalInput;
payment.totalOutput = tx.Outputs[i].Amount;
payment.fee = totalInput - (selfTotalOutput + otherUserTotalOutput);
payment.amount = (i == 0 ? tx.Outputs[i].Amount + payment.fee : tx.Outputs[i].Amount);
payment.txId = tx.Hash;
payment.vout = i;
payment.time = tx.Timestamp;
payment.size = tx.Size;
var txComment = transactionCommentComponent.GetByTransactionHashAndIndex(tx.Hash, i);
if (txComment != null)
{
payment.comment = txComment.Comment;
}
if (block != null)
{
payment.blockHash = tx.BlockHash;
payment.blockIndex = block.Transactions.FindIndex(t => t.Hash == tx.Hash);
payment.blockTime = block.Header.Timestamp;
payment.confirmations = latestHeight - block.Header.Height + 1;
}
else
{
payment.confirmations = 0;
}
result.Add(payment);
}
}
}
else
{
for (int i = 0; i < tx.Outputs.Count; i++)
{
if (allAccountIds.Contains(tx.Outputs[i].ReceiverId))
{
var payment = new PaymentOM();
payment.address = tx.Outputs[i].ReceiverId;
payment.account = accounts.Where(a => a.Id == payment.address).Select(a => a.Tag).FirstOrDefault();;
payment.category = "receive";
payment.totalInput = totalInput;
payment.totalOutput = tx.Outputs[i].Amount;
payment.fee = totalInput - (selfTotalOutput + otherUserTotalOutput);
payment.amount = tx.Outputs[i].Amount;
payment.txId = tx.Hash;
payment.vout = i;
payment.time = tx.Timestamp;
payment.size = tx.Size;
var txComment = transactionCommentComponent.GetByTransactionHashAndIndex(tx.Hash, i);
if (txComment != null)
{
payment.comment = txComment.Comment;
}
if (block != null)
{
payment.blockHash = tx.BlockHash;
payment.blockIndex = block.Transactions.FindIndex(t => t.Hash == tx.Hash);
payment.blockTime = block.Header.Timestamp;
payment.confirmations = latestHeight - block.Header.Height + 1;
}
else
{
payment.confirmations = 0;
}
result.Add(payment);
}
}
}
}
return(Ok(result));
}
catch (CommonException ce)
{
return(Error(ce.ErrorCode, ce.Message, ce));
}
catch (Exception ex)
{
return(Error(ErrorCode.UNKNOWN_ERROR, ex.Message, ex));
}
}
public async Task <User> LoginUser(LoginViewModel user)
{
var hashedPassword = HashHelper.ComputeHash(user.Password);
return(await _db.Users.FirstOrDefaultAsync(u => u.Email == user.Email.FixEmail() && u.Password == hashedPassword));
}
public IRpcMethodResult EstimateTxFeeForSendToAddress(string toAddress, long amount, string comment, string commentTo, bool deductFeeFromAmount)
{
try
{
EstimateTxFeeOM result = new EstimateTxFeeOM();
var utxoComponent = new UtxoComponent();
var txComponent = new TransactionComponent();
var settingComponent = new SettingComponent();
var addressBookComponent = new AddressBookComponent();
var accountComponent = new AccountComponent();
if (!AccountIdHelper.AddressVerify(toAddress))
{
throw new CommonException(ErrorCode.Service.Transaction.TO_ADDRESS_INVALID);
}
var setting = settingComponent.GetSetting();
var utxos = utxoComponent.GetAllConfirmedOutputs();
var tx = new TransactionMsg();
var totalSize = tx.Serialize().Length;
var output = new OutputMsg();
output.Amount = amount;
output.Index = 0;
output.LockScript = Script.BuildLockScipt(toAddress);
output.Size = output.LockScript.Length;
tx.Outputs.Add(output);
totalSize += output.Serialize().Length;
var blockComponent = new BlockComponent();
var lastBlockHeight = blockComponent.GetLatestHeight();
var totalInput = 0L;
var index = 0;
double totalAmount = amount;
double totalFee = setting.FeePerKB * ((double)totalSize / 1024.0);
while (index < utxos.Count)
{
var account = accountComponent.GetAccountById(utxos[index].AccountId);
if (account != null && !string.IsNullOrWhiteSpace(account.PrivateKey))
{
var utxoTX = txComponent.GetTransactionMsgByHash(utxos[index].TransactionHash);
Block utxoBlock = blockComponent.GetBlockEntiytByHash(utxos[index].BlockHash);
if (utxoTX == null || utxoBlock == null)
{
index++;
continue;
}
if (!utxoBlock.IsVerified)
{
index++;
continue;
}
if (Time.EpochTime < utxoTX.Locktime)
{
index++;
continue;
}
if (utxoTX.InputCount == 1 && utxoTX.Inputs[0].OutputTransactionHash == Base16.Encode(HashHelper.EmptyHash()))
{
var blockHeight = utxoBlock.Height;
if (lastBlockHeight - blockHeight < 100L)
{
index++;
continue;
}
}
var input = new InputMsg();
input.OutputTransactionHash = utxos[index].TransactionHash;
input.OutputIndex = utxos[index].OutputIndex;
input.UnlockScript = Script.BuildUnlockScript(input.OutputTransactionHash, input.OutputIndex, Base16.Decode(decryptPrivateKey(account.PrivateKey)), Base16.Decode(account.PublicKey));
input.Size = input.UnlockScript.Length;
tx.Inputs.Add(input);
var size = input.Serialize().Length;
totalSize += size;
totalFee += setting.FeePerKB * ((double)size / 1024.0);
totalInput += utxos[index].Amount;
}
else
{
index++;
continue;
}
if (!deductFeeFromAmount)
{
totalAmount = amount + totalFee;
}
if (totalInput >= (long)Math.Ceiling(totalAmount))
{
var size = output.Serialize().Length;
if ((totalInput - (long)Math.Ceiling(totalAmount)) > (setting.FeePerKB * (double)size / 1024.0))
{
totalSize += size;
totalFee += setting.FeePerKB * ((double)size / 1024.0);
}
break;
}
index++;
}
if (totalInput < totalAmount)
{
throw new CommonException(ErrorCode.Service.Transaction.BALANCE_NOT_ENOUGH);
}
if (deductFeeFromAmount)
{
output.Amount -= (long)Math.Ceiling(totalFee);
if (output.Amount <= 0)
{
throw new CommonException(ErrorCode.Service.Transaction.SEND_AMOUNT_LESS_THAN_FEE);
}
}
result.totalFee = Convert.ToInt64(totalFee);
result.totalSize = Convert.ToInt32(totalSize);
return(Ok(result));
}
catch (CommonException ce)
{
return(Error(ce.ErrorCode, ce.Message, ce));
}
catch (Exception ex)
{
return(Error(ErrorCode.UNKNOWN_ERROR, ex.Message, ex));
}
}
/// <summary>
/// Constructs a hash code used in the collections.
/// </summary>
/// <returns>Hash code of the object.</returns>
public override int GetHashCode()
{
return(HashHelper.GetHashCode("when", Expression, Effects));
}
public string GetHash()
{
var bytes = Serialize();
return(HashHelper.GetHash(bytes));
}
public override int GetHashCode() => HashHelper.For(X, Y, Z);
public void Base64Decode()
{
EngineState s = EngineTests.CreateEngineState();
void Template(string binFileName, string encFileName, string section, bool inMem)
{
string workDir = StringEscaper.Preprocess(s, Path.Combine("%TestBench%", "EncodedFile"));
// Be careful! encFile will be converted to LF from CRLF in git tree!
string binFile = Path.Combine(workDir, binFileName);
string encFile = Path.Combine(workDir, encFileName);
byte[] binDigest;
byte[] encDigest;
using (FileStream fs = new FileStream(binFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
binDigest = HashHelper.GetHash(HashHelper.HashType.SHA256, fs);
}
if (inMem)
{
List <string> lines = new List <string>();
using (StreamReader r = new StreamReader(encFile, Encoding.UTF8))
{
string rawLine;
while ((rawLine = r.ReadLine()) != null)
{
string line = rawLine.Trim();
if (0 < line.Length)
{
lines.Add(line);
}
}
}
byte[] decoded = SplitBase64.DecodeInMem(lines);
#if DEBUG_MIDDLE_FILE
using (FileStream fs = new FileStream(binFile + ".inMem.comp", FileMode.Create, FileAccess.Write))
{
fs.Write(decoded, 0, decoded.Length);
}
#endif
encDigest = HashHelper.GetHash(HashHelper.HashType.SHA256, decoded);
}
else
{
using (MemoryStream ms = new MemoryStream())
{
using (StreamReader tr = new StreamReader(encFile, Encoding.UTF8))
{
if (section.Length != 0)
{
IniReadWriter.FastForwardTextReader(tr, section);
}
SplitBase64.Decode(tr, ms);
}
ms.Position = 0;
#if DEBUG_MIDDLE_FILE
using (FileStream fs = new FileStream(binFile + ".noMem.comp", FileMode.Create, FileAccess.Write))
{
ms.CopyTo(fs);
}
ms.Position = 0;
#endif
encDigest = HashHelper.GetHash(HashHelper.HashType.SHA256, ms);
}
}
Assert.IsTrue(binDigest.SequenceEqual(encDigest));
}
Template("BigData.bin", "BigDataEnc4090.txt", string.Empty, true);
Template("BigData.bin", "BigDataEnc4090.txt", string.Empty, false);
Template("BigData.bin", "BigDataEnc4090S.txt", "Base64", false);
Template("Type3.pdf", "Type3Enc4090.txt", string.Empty, true);
Template("Type3.pdf", "Type3Enc4090.txt", string.Empty, false);
Template("Type3.pdf", "Type3Enc4090S.txt", "Base64", false);
Template("Type3.pdf", "Type3Enc1024.txt", string.Empty, true);
Template("Type3.pdf", "Type3Enc1024.txt", string.Empty, false);
Template("Type3.pdf", "Type3Enc1024S.txt", "Base64", false);
// https://github.com/pebakery/pebakery/issues/90
Template("Type5.bin", "Type5Enc4090.txt", string.Empty, true);
Template("Type5.bin", "Type5Enc4090.txt", string.Empty, false);
}
/// <summary>
/// 获取字符串的MD5 Hash值
/// </summary>
public static string ToMd5Hash(this string value)
{
return(HashHelper.GetMd5(value));
}
/// <summary>Returns the hash code for this StringAccessor.</summary>
/// <returns>A 32-bit signed integer hash code.</returns>
public override unsafe int GetHashCode()
{
return(HashHelper.HashBytes(this.m_ptr, this.Length));
}
private void CreateDestinationTable(string tableName)
{
DropTableTask.DropIfExists(ConnectionDestination, tableName);
TableDefinition sourceTable = new TableDefinition(tableName, new List <TableColumn>()
{
new TableColumn("id", "INT", allowNulls: false, isPrimaryKey: true, isIdentity: true),
new TableColumn("name", "NVARCHAR(100)", allowNulls: false),
new TableColumn("age", "INT", allowNulls: false),
new TableColumn("hashcode", "CHAR(40)", allowNulls: false),
});
sourceTable.CreateTable(ConnectionDestination);
SqlTask.ExecuteNonQuery(ConnectionDestination, "Insert demo data"
, $"INSERT INTO {tableName} (name, age, hashcode) VALUES('Bugs',12, '{HashHelper.Encrypt_Char40("1Bugs12")}')");
SqlTask.ExecuteNonQuery(ConnectionDestination, "Insert demo data"
, $"INSERT INTO {tableName} (name, age, hashcode) VALUES('Coyote',10, '{HashHelper.Encrypt_Char40("2Coyote10")}')");
}
public PixelStarshipsClient()
{
this.baseUrl = "https://api.pixelstarships.com";
this.hashHelper = new HashHelper();
}
public void UpdateOnHashMatch()
{
//Arrange
CreateSourceTable("dbo.HashMatchSource");
CreateDestinationTable("dbo.HashMatchDestination");
//Act
DBSource source = new DBSource(ConnectionSource, "dbo.HashMatchSource");
RowTransformation trans = new RowTransformation(
row =>
{
Array.Resize(ref row, row.Length + 1);
row[row.Length - 1] = HashHelper.Encrypt_Char40(String.Join("", row));
return(row);
});
List <string[]> allEntriesInDestination = new List <string[]>();
Lookup lookup = new Lookup(
row =>
{
var matchingIdEntry = allEntriesInDestination.Where(destRow => destRow[0] == row[0]).FirstOrDefault();
if (matchingIdEntry == null)
{
row = null;
}
else
if (matchingIdEntry[matchingIdEntry.Length - 1] != row[row.Length - 1])
{
SqlTask.ExecuteNonQuery(ConnectionDestination, "update entry with different hashcode",
$@"UPDATE dbo.HashMatchDestination
SET name = '{ row[1] }',
age = '{ row[2] }',
hashcode = '{ row[3] }'
WHERE id = { row[0] }
");
}
return(row);
},
new DBSource(ConnectionDestination, "dbo.HashMatchDestination"),
allEntriesInDestination);
VoidDestination voidDest = new VoidDestination();
source.LinkTo(trans);
trans.LinkTo(lookup);
lookup.LinkTo(voidDest);
source.Execute();
voidDest.Wait();
//Assert
Assert.Equal(1, RowCountTask.Count(ConnectionDestination, $"dbo.HashMatchDestination", $"id = 1 AND name='Bugs' AND age = 12 AND hashcode = '{HashHelper.Encrypt_Char40("1Bugs12")}'"));
Assert.Equal(1, RowCountTask.Count(ConnectionDestination, $"dbo.HashMatchDestination", $"id = 2 AND name='Coyote' AND age = 8 AND hashcode = '{HashHelper.Encrypt_Char40("2Coyote8")}'"));
}
private static int CombineHash(Type serviceType, params Type[] genericTypeArguments)
{
return(genericTypeArguments.Aggregate(
serviceType.GetHashCode(),
(i, t) => HashHelper.Combine(i, t.GetHashCode())));
}
public override int GetHashCode()
{
return(HashHelper.Array(VertexLayouts));
}
/// <summary>
/// Returns the hash code for this byteList.
/// </summary>
/// <returns>A 32-bit signed integer hash code.</returns>
public override int GetHashCode()
{
return(HashHelper.HashBytes(this.CellPtr, this.length));
}
public override int GetHashCode()
{
return(HashHelper.Combine(VeldridDescription.GetHashCode(), Multisampled.GetHashCode()));
}
/// <summary>
/// TODO: Comment
/// </summary>
public void AuthenticateExcecute()
{
//TODO: Save path in configuration
string configurationPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"SecureVault",
"settings",
"configuration.dat");
ConfigurationHelper configHelper = new ConfigurationHelper(configurationPath);
HashHelper hashHelper = new HashHelper();
SecureStringHelper secureStringHelper = new SecureStringHelper();
//Check if password is correct
if (hashHelper.ComputeHash(secureStringHelper.SecureStringToString(this.Password)).Equals(configHelper.GetPasswordHash()))
{
IEnumerable<Tuple<string, string, string>> savedData = configHelper.GetAllSavedData();
ObservableCollection<SavedData> dataCollection = new ObservableCollection<SavedData>();
foreach (var data in savedData)
{
dataCollection.Add(new SavedData() { Name = data.Item1, EncryptedValue = data.Item2, Salt = data.Item3 });
}
this.Model.SavedData = dataCollection;
//Navigate to the VaultPage
VaultPage vaultPage = new VaultPage();
vaultPage.DataContext = new VaultViewModel(this.Model);
this.MainFrame.Navigate(vaultPage);
}
else
{
this.Error = "Invalid Password";
this.Model.SavedData = null;
}
}
private void PlatformConstruct(ShaderStage stage, byte[] shaderBytecode)
{
GlslCode = System.Text.Encoding.ASCII.GetString(shaderBytecode);
HashKey = HashHelper.ComputeHash(shaderBytecode);
}
/// <summary>
/// TODO: Comment
/// </summary>
public void SaveConfigurationExcecute()
{
string configurationPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"SecureVault",
"settings",
"configuration.dat");
ConfigurationHelper configHelper = new ConfigurationHelper(configurationPath);
HashHelper hashHelper = new HashHelper();
SecureStringHelper secureStringHelper = new SecureStringHelper();
if (String.IsNullOrWhiteSpace(secureStringHelper.SecureStringToString(this.MasterPassword)) ||
String.IsNullOrWhiteSpace(secureStringHelper.SecureStringToString(this.MasterPasswordConfirmation)))
{
this.Error = "Please set a Password";
return;
}
//Check if password and confirmation are equal
if (secureStringHelper.SecureStringToString(this.MasterPassword).Equals(secureStringHelper.SecureStringToString(this.MasterPasswordConfirmation)))
{
//Create configuration file
configHelper.CreateConfigurationFile();
//Save master password
string passwordHash = hashHelper.ComputeHash(secureStringHelper.SecureStringToString(this.MasterPassword));
configHelper.SaveMasterPassword(passwordHash);
//Navigate to PasswordPage
PasswordPage passwordPage = new PasswordPage();
passwordPage.DataContext = new PasswordViewModel(new Vault(), this.MainFrame);
this.MainFrame.Navigate(passwordPage);
}
else
{
this.Error = "Not equal";
}
}
public IRpcMethodResult SendMany(string fromAccount, SendManyOutputIM[] receivers, string[] feeDeductAddresses)
{
try
{
string result = null;
var utxoComponent = new UtxoComponent();
var txComponent = new TransactionComponent();
var settingComponent = new SettingComponent();
var addressBookComponent = new AddressBookComponent();
var accountComponent = new AccountComponent();
var transactionCommentComponent = new TransactionCommentComponent();
var blockComponent = new BlockComponent();
var lastBlockHeight = blockComponent.GetLatestHeight();
var setting = settingComponent.GetSetting();
var utxos = utxoComponent.GetAllConfirmedOutputs();
var tx = new TransactionMsg();
double totalOutput = 0;
var totalSize = tx.Serialize().Length;
if (receivers == null || receivers.Length == 0)
{
throw new CommonException(ErrorCode.Service.Transaction.TO_ADDRESS_INVALID);
}
foreach (var receiver in receivers)
{
if (!AccountIdHelper.AddressVerify(receiver.address))
{
throw new CommonException(ErrorCode.Service.Transaction.TO_ADDRESS_INVALID);
}
var output = new OutputMsg();
output.Amount = receiver.amount;
output.Index = tx.Outputs.Count;
output.LockScript = Script.BuildLockScipt(receiver.address);
output.Size = output.LockScript.Length;
tx.Outputs.Add(output);
totalSize += output.Serialize().Length;
totalOutput += receiver.amount;
}
foreach (var address in feeDeductAddresses)
{
if (receivers.Where(r => r.address == address).Count() == 0)
{
throw new CommonException(ErrorCode.Service.Transaction.FEE_DEDUCT_ADDRESS_INVALID);
}
}
var totalInput = 0L;
var index = 0;
double totalFee = setting.FeePerKB * ((double)totalSize / 1024.0);
double totalAmount = totalOutput;
while (index < utxos.Count)
{
var account = accountComponent.GetAccountById(utxos[index].AccountId);
if (account != null && !string.IsNullOrWhiteSpace(account.PrivateKey))
{
var utxoTX = txComponent.GetTransactionMsgByHash(utxos[index].TransactionHash);
Block utxoBlock = blockComponent.GetBlockEntiytByHash(utxos[index].BlockHash);
if (utxoTX == null || utxoBlock == null)
{
index++;
continue;
}
if (!utxoBlock.IsVerified)
{
index++;
continue;
}
if (Time.EpochTime < utxoTX.Locktime)
{
index++;
continue;
}
if (utxoTX.InputCount == 1 && utxoTX.Inputs[0].OutputTransactionHash == Base16.Encode(HashHelper.EmptyHash()))
{
var blockHeight = utxoBlock.Height;
if (lastBlockHeight - blockHeight < 100L)
{
index++;
continue;
}
}
var input = new InputMsg();
input.OutputTransactionHash = utxos[index].TransactionHash;
input.OutputIndex = utxos[index].OutputIndex;
input.UnlockScript = Script.BuildUnlockScript(input.OutputTransactionHash, input.OutputIndex, Base16.Decode(decryptPrivateKey(account.PrivateKey)), Base16.Decode(account.PublicKey));
input.Size = input.UnlockScript.Length;
tx.Inputs.Add(input);
var size = input.Serialize().Length;
totalSize += size;
totalFee += setting.FeePerKB * ((double)size / 1024.0);
totalInput += utxos[index].Amount;
}
else
{
index++;
continue;
}
if (feeDeductAddresses == null || feeDeductAddresses.Length == 0)
{
totalAmount = totalOutput + totalFee;
}
if (totalInput >= (long)Math.Ceiling(totalAmount))
{
var size = tx.Outputs[0].Serialize().Length;
if ((totalInput - (long)Math.Ceiling(totalAmount)) > (setting.FeePerKB * (double)size / 1024.0))
{
totalSize += size;
totalFee += setting.FeePerKB * ((double)size / 1024.0);
if (feeDeductAddresses == null || feeDeductAddresses.Length == 0)
{
totalAmount = totalOutput + totalFee;
}
var newAccount = accountComponent.GenerateNewAccount();
if (setting.Encrypt)
{
if (!string.IsNullOrWhiteSpace(_cache.Get <string>("WalletPassphrase")))
{
newAccount.PrivateKey = AES128.Encrypt(newAccount.PrivateKey, _cache.Get <string>("WalletPassphrase"));
accountComponent.UpdatePrivateKeyAr(newAccount);
}
else
{
throw new CommonException(ErrorCode.Service.Wallet.WALLET_HAS_BEEN_LOCKED);
}
}
var newOutput = new OutputMsg();
newOutput.Amount = totalInput - (long)Math.Ceiling(totalAmount);
newOutput.Index = tx.Outputs.Count;
newOutput.LockScript = Script.BuildLockScipt(newAccount.Id);
newOutput.Size = newOutput.LockScript.Length;
tx.Outputs.Add(newOutput);
}
break;
}
index++;
}
var totalAmountLong = Convert.ToInt64(totalAmount);
if (totalInput < totalAmountLong)
{
throw new CommonException(ErrorCode.Service.Transaction.BALANCE_NOT_ENOUGH);
}
if (feeDeductAddresses != null && feeDeductAddresses.Length > 0)
{
var averageFee = totalFee / feeDeductAddresses.Length;
for (int i = 0; i < receivers.Length; i++)
{
if (feeDeductAddresses.Contains(receivers[i].address))
{
var fee = Convert.ToInt64(averageFee);
tx.Outputs[i].Amount -= fee;
if (tx.Outputs[i].Amount <= 0)
{
throw new CommonException(ErrorCode.Service.Transaction.SEND_AMOUNT_LESS_THAN_FEE);
}
}
}
}
tx.Timestamp = Time.EpochTime;
tx.Hash = tx.GetHash();
txComponent.AddTransactionToPool(tx);
Startup.P2PBroadcastTransactionAction(tx.Hash);
result = tx.Hash;
for (int i = 0; i < receivers.Length; i++)
{
var receiver = receivers[i];
if (!string.IsNullOrWhiteSpace(receiver.tag))
{
addressBookComponent.SetTag(receiver.address, receiver.tag);
}
if (!string.IsNullOrWhiteSpace(receiver.comment))
{
transactionCommentComponent.Add(tx.Hash, i, receiver.comment);
}
}
return(Ok(result));
}
catch (CommonException ce)
{
return(Error(ce.ErrorCode, ce.Message, ce));
}
catch (Exception ex)
{
return(Error(ErrorCode.UNKNOWN_ERROR, ex.Message, ex));
}
}
