示例#1
0
        private static AccountOperation Map(SqlDataReader reader)
        {
            AccountOperation accountOperation = new AccountOperation();

            accountOperation.Id            = reader.GetInt32(0);
            accountOperation.Account       = reader.GetString(1);
            accountOperation.OperationDate = reader.GetDateTime(2);

            int operationTypeId = reader.GetInt32(3);

            accountOperation.OperationType = new OperationType {
                Id = operationTypeId, Name = reader.GetString(5)
            };

            if (!reader.IsDBNull(4))
            {
                accountOperation.OperationStatus = (OperationStatus)Enum.Parse(typeof(OperationStatus), reader.GetString(4));
            }

            return(accountOperation);
        }
        public void Block(AccountOperation accountOperation)
        {
            using (DbContextTransaction transaction = context.Database.BeginTransaction())
            {
                try
                {
                    accountOperation.OperationStatus = OperationStatus.EX;
                    context.SaveChanges();

                    context.OperationTypes.Add(new OperationType {
                        Name = "Test"
                    });
                    context.SaveChanges();

                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                }
            }
        }
示例#3
0
        public void Update(AccountOperation accountOperation)
        {
            string sql = "UPDATE Santander.AccountOperations SET Account = @Account, OperationDate = @OperationDate, OperationTypeId = @OperationTypeId, OperationStatus = @OperationStatus WHERE AccountOperationId = @AccountOperationId";

            SqlCommand command = new SqlCommand(sql, connection);

            command.Parameters.AddWithValue("@AccountOperationId", accountOperation.Id);
            command.Parameters.AddWithValue("@Account", accountOperation.Account);
            command.Parameters.AddWithValue("@OperationDate", accountOperation.OperationDate);
            command.Parameters.AddWithValue("@OperationTypeId", accountOperation.OperationType.Id);
            command.Parameters.AddWithValue("@OperationStatus", Map(accountOperation.OperationStatus));

            connection.Open();
            int rowsAffected = command.ExecuteNonQuery();

            connection.Close();

            if (rowsAffected == 0)
            {
                throw new InvalidOperationException();
            }
        }
示例#4
0
        public AccountOperation Get(int id)
        {
            string sql = "SELECT AccountOperationId, Account, OperationDate, Santander.AccountOperations.OperationTypeId, OperationStatus, [Name] FROM Santander.AccountOperations INNER JOIN Santander.OperationTypes ON Santander.AccountOperations.OperationTypeId = Santander.OperationTypes.OperationTypeId WHERE AccountOperationId = @AccountOperationId";

            SqlCommand command = new SqlCommand(sql, connection);

            command.Parameters.AddWithValue("@AccountOperationId", id);

            connection.Open();
            SqlDataReader reader = command.ExecuteReader();

            AccountOperation accountOperation = null;

            if (reader.Read())
            {
                accountOperation = Map(reader);
            }

            connection.Close();

            return(accountOperation);
        }
示例#5
0
        private static void AccountOperations(int j)
        {
            new Task(delegate()
            {
                for (int i = 0; i < 1000; i++)
                {
                    var r = new Random();
                    AccountOperation ao = new AccountOperation()
                    {
                        Account           = new Data.Account(j, ""),
                        OperationType     = OperationType.Credit,
                        TransactionAmount = 10
                    };
                    Task.Delay(r.Next(100));
                    AccountOperationAction.AccountOperation.Send(ao);
                }
            }).Start();

            new Task(delegate()
            {
                for (int i = 0; i < 1000; i++)
                {
                    var r = new Random();
                    AccountOperation ao = new AccountOperation()
                    {
                        Account           = new Data.Account(j, ""),
                        OperationType     = OperationType.Debit,
                        TransactionAmount = 10
                    };
                    Task.Delay(r.Next(100));
                    AccountOperationAction.AccountOperation.Send(ao);
                    // Thread.Sleep(10);
                }
            }).Start();
            //Thread.Sleep(120);
        }
示例#6
0
 public ConfirmationToken(User target, AccountOperation operation, string argument)
 {
     Target    = target ?? throw new ArgumentNullException(nameof(target));
     Operation = operation;
     Argument  = argument ?? throw new ArgumentNullException(nameof(argument));
 }
 public OperationController(IRepositoryProvider repositoryProvider)
 {
     _accountOperation = new AccountOperation(repositoryProvider);
 }
        public void Handle(Message message)
        {
            AccountOperation accountOperation = message as AccountOperation;

            switch (accountOperation.OperationType)
            {
            case OperationType.NewAccount:
            {
                var ad = new AccountDetail();

                var a = ad.AccountAction.ProceesSync(new AccountMessage()
                    {
                        Account = accountOperation.Account, MessageType = AccountMessage.AccountMessageType.AddAccount
                    });
                if (a != null)
                {
                    var am = a as AccountMessage;
                    OutputAction.Action.SendSync(new Output()
                        {
                            Message = "Account Opened , ID : " + am.Account.Id + " Name :" + am.Account.Name
                        });
                    activeAccounts.GetOrAdd(am.Account.Id, ad);
                }
                break;
            }

            case OperationType.Credit:
            {
                var ad = activeAccounts[accountOperation.Account.Id];

                var tr = new TransactionInfoMessage();
                tr.Account = GetAccountMessage(ad, accountOperation).Account;

                tr.TransactionInfo = new Data.TransactionInfo(tr.Account.Id, Data.TransactionType.Credit, accountOperation.TransactionAmount);
                var accountMessage = ad.TransactionAction.ProceesSync(tr);
                DoTransactionReconcile(ad, tr.Account);

                break;
            }

            case OperationType.Debit:
            {
                var ad = activeAccounts[accountOperation.Account.Id];

                var tr = new TransactionInfoMessage();
                tr.Account = GetAccountMessage(ad, accountOperation).Account;

                tr.TransactionInfo = new Data.TransactionInfo(tr.Account.Id, Data.TransactionType.Debit, accountOperation.TransactionAmount);
                var accountMessage = ad.TransactionAction.ProceesSync(tr);

                DoTransactionReconcile(ad, tr.Account);

                break;
            }

            case OperationType.BalanceInfo:
                var aBalInfo = activeAccounts[accountOperation.Account.Id].AccountAction.ProcessMessage(new AccountMessage()
                {
                    Account = accountOperation.Account, MessageType = AccountMessage.AccountMessageType.GetAccountInfo
                }) as AccountMessage;
                if (aBalInfo != null && aBalInfo.Account == null)
                {
                    OutputAction.Action.Send(new Output()
                    {
                        Message = string.Format("Account with ID : {0} Current balance {1}", aBalInfo.Account.Id, aBalInfo.Account.CurrentBalance)
                    });
                }

                break;

            case OperationType.ListOfTransactions:
            {
                var acc = activeAccounts[accountOperation.Account.Id].AccountAction.ProcessMessage(new AccountMessage()
                    {
                        Account = accountOperation.Account, MessageType = AccountMessage.AccountMessageType.GetAccountInfo
                    }) as AccountMessage;
                if (acc != null && acc.Account != null)
                {
                    activeAccounts[accountOperation.Account.Id].TransactionAction.Send(new TransactionInfoMessage()
                        {
                            Account = acc.Account, Operation = TransactionInfoMessage.TransactionOperation.Statement
                        });
                }
            }
            break;

            case OperationType.UpdateBalance:
                activeAccounts[accountOperation.Account.Id].AccountAction.Send(new AccountMessage()
                {
                    Account = accountOperation.Account, MessageType = AccountMessage.AccountMessageType.UpdateBalance
                });
                break;

            default:
                break;
            }
        }
示例#9
0
 public AccountRegistrationInfo(AccountRegistrationCoreTransaction transaction, AccountOperation operation)
 {
     Transaction = transaction;
     Operation   = operation;
 }
示例#10
0
        public static GenesisBlockResult Generate(Base.Storage storage)
        {
            (var networkKeyStore, var networkKey, _) = LoadCoreAccountKey(storage, "Network Account", "Heleus Core");

            if (networkKeyStore == null)
            {
                networkKey = Key.Generate(KeyTypes.Ed25519);
                var networkPassword = Hex.ToString(Rand.NextSeed(32));
                networkKeyStore = new CoreAccountKeyStore("Heleus Core Network Account", CoreAccount.NetworkAccountId, networkKey, networkPassword);

                SaveCoreAccountKey(storage, networkKeyStore, "Network Account", networkPassword, "Heleus Core");
            }

            Console.WriteLine($"Heleus Core Network Account Key: {networkKey.PublicKey.HexString}.");

            var networkKeys      = new List <NetworkKey>();
            var networkChainKeys = new List <PublicChainKey>();

            for (var i = 0; i < 3; i++)
            {
                var keyFlags = GetCoreKeyFlags(i);
                var keyName  = $"Network {GetKeyName(keyFlags, true)}";

                (var store, var key, var storePassword) = LoadKeyStore <ChainKeyStore>(storage, null, keyName, "Heleus Core");

                if (store == null)
                {
                    key           = Key.Generate(KeyTypes.Ed25519);
                    storePassword = Hex.ToString(Rand.NextSeed(32));

                    var publicChainKey = new PublicChainKey(keyFlags, CoreChain.CoreChainId, 0, 0, (short)i, key);
                    store = new ChainKeyStore($"Heleus Core {keyName}", publicChainKey, key, storePassword);

                    SaveKeyStore(storage, store, storePassword, null, keyName, "Heleus Core");
                }

                Console.WriteLine($"Heleus Core {keyName}: {key.PublicKey.HexString}.");

                networkKeys.Add(new NetworkKey {
                    Key = key, Password = storePassword, PublicKey = store.PublicChainKey, Store = store
                });
                networkChainKeys.Add(store.PublicChainKey);
            }

            var timestamp = Time.Timestamp;

            timestamp = Protocol.GenesisTime;

            var coreOperations = new List <CoreOperation>();

            var endPoints = new List <string>();

            Console.WriteLine("Type the core chain name (default: Heleus Core)");
            var name = Program.IsDebugging ? "Heleus Core" : Console.ReadLine();

            if (string.IsNullOrWhiteSpace(name))
            {
                name = "Heleus Core";
            }
            Console.WriteLine($"Chain name: {name}");

            Console.WriteLine("Type the core chain website (default: https://heleuscore.com)");
            var website = Program.IsDebugging ? "https://heleuscore.com" : Console.ReadLine();

            if (string.IsNullOrWhiteSpace(website))
            {
                website = "https://heleuscore.com";
            }
            Console.WriteLine($"Chain Website: {website}");

            Console.WriteLine("Type the core chain endpoints. (none for none, default: https://heleusnode.heleuscore.com)");
            while (true)
            {
                if (Program.IsDebugging)
                {
                    var ips = GetLocalIPV4Addresss();
                    foreach (var ip in ips)
                    {
                        endPoints.Add($"http://{ip}:54321/");
                    }
                    break;
                }

                var ep = Console.ReadLine();
                if (string.IsNullOrWhiteSpace(ep))
                {
                    if (endPoints.Count == 0)
                    {
                        endPoints.Add("https://heleusnode.heleuscore.com");
                    }
                    break;
                }

                if (ep.IsValdiUrl(false))
                {
                    Console.WriteLine($"Added endpoint {ep}");
                    endPoints.Add(ep);
                }

                if (ep == "none")
                {
                    break;
                }
            }

            Console.WriteLine($"Chain Endpoints: {string.Join(", ", endPoints)}");

            var useGenesisInfo       = false;
            var useCoreChainEndpoint = false;

            if (storage.FileExists("genesisservices.txt"))
            {
                Console.WriteLine("Process genesisservices.txt [yes/no] (default: yes)");

                var p = Program.IsDebugging ? "yes" : Console.ReadLine();
                if (string.IsNullOrWhiteSpace(p) || p.ToLower() == "yes")
                {
                    Console.WriteLine("Processing genesisservices.txt");

                    useGenesisInfo = true;

                    if (endPoints.Count > 0)
                    {
                        Console.WriteLine("Use first core chain endpoint, not endpoint from genesisservices.txt [yes/no] (default: no)");

                        var p2 = Program.IsDebugging ? "yes" : Console.ReadLine()?.ToLower();

                        if (p2 == "yes")
                        {
                            useCoreChainEndpoint = true;
                            Console.WriteLine($"Using endpoint {endPoints[0]} for all services from genesisservices.txt");
                        }
                    }
                }
            }

            coreOperations.Add((ChainInfoOperation) new ChainInfoOperation(CoreChain.CoreChainId, CoreAccount.NetworkAccountId, name, website, timestamp, networkChainKeys, endPoints, new List <PurchaseInfo>()).UpdateOperationId(Operation.FirstTransactionId));
            coreOperations.Add((AccountOperation) new AccountOperation(CoreAccount.NetworkAccountId, networkKey.PublicKey, timestamp).UpdateOperationId(coreOperations.Count + 1)); // network account
            coreOperations.Add(((AccountUpdateOperation) new AccountUpdateOperation().UpdateOperationId(Operation.FirstTransactionId + 2)).AddAccount(CoreAccount.NetworkAccountId, coreOperations.Count + 1, long.MaxValue / 2).AddTransfer(CoreAccount.NetworkAccountId, CoreAccount.NetworkAccountId, long.MaxValue / 2, null, timestamp));

            var blockStateOperation = new BlockStateOperation();

            var nextChainId       = CoreChain.CoreChainId + 1;
            var nextTransactionId = coreOperations.Count + 1;
            var nextAccountId     = CoreAccount.NetworkAccountId + 1;

            var accounts = new List <AccountOperation>();
            var serviceTransactionsList = new Dictionary <int, List <ServiceTransaction> >();

            if (useGenesisInfo)
            {
                try
                {
                    var json = storage.ReadFileText("genesisservices.txt");
                    if (json != null)
                    {
                        var services = Newtonsoft.Json.JsonConvert.DeserializeObject <List <GenesisService> >(json);
                        if (services != null)
                        {
                            foreach (var service in services)
                            {
                                if (!service.Valid)
                                {
                                    continue;
                                }

                                var serviceKeys = new List <PublicChainKey>();
                                var ep          = useCoreChainEndpoint ? endPoints[0] : service.Endpoint;
                                var accountId   = service.AccountId;

                                if (accountId != CoreAccount.NetworkAccountId)
                                {
                                    var found = accounts.Find((a) => a.AccountId == accountId) != null;
                                    if (!found)
                                    {
                                        (var store, var key, var accountPassword) = LoadCoreAccountKey(storage, "Core Account " + accountId, "Core Accounts");
                                        if (store == null)
                                        {
                                            key             = Key.Generate(KeyTypes.Ed25519);
                                            accountPassword = Hex.ToString(Rand.NextSeed(32));
                                            store           = new CoreAccountKeyStore(service.AccountName, accountId, key, accountPassword);

                                            SaveCoreAccountKey(storage, store, "Core Account " + accountId, accountPassword, "Core Accounts");
                                        }

                                        if (accountId == nextAccountId)
                                        {
                                            var ao = new AccountOperation(accountId, key.PublicKey, timestamp);
                                            ao.UpdateOperationId(nextTransactionId);

                                            coreOperations.Add(ao);
                                            accounts.Add(ao);

                                            nextTransactionId++;
                                            nextAccountId++;
                                        }
                                        else
                                        {
                                            Console.WriteLine($"Invalid account id for {service.Title}, should be {nextAccountId}, but is {accountId}.");
                                            continue;
                                        }
                                    }
                                }

                                Console.WriteLine($"Adding Service {service.Title} with endpoint {ep}.");

                                var count = 2 + service.DataChainCount;
                                for (var i = 0; i < count; i++)
                                {
                                    var keyFlags  = GetServiceKeyFlags(i);
                                    var keyName   = $"{service.Name} {GetKeyName(keyFlags, false)}";
                                    var dataChain = i >= 2;
                                    if (dataChain)
                                    {
                                        keyName += $" (ChainIndex {i - 2})";
                                    }

                                    (var store, var key, var servicePassword) = LoadKeyStore <ChainKeyStore>(storage, null, keyName, service.Name);

                                    if (store == null)
                                    {
                                        key             = Key.Generate(KeyTypes.Ed25519);
                                        servicePassword = Hex.ToString(Rand.NextSeed(32));

                                        var signedKey = new PublicChainKey(keyFlags, nextChainId, dataChain ? (uint)i - 2 : 0, 0, (short)i, key);
                                        store = new ChainKeyStore($"{service.Name} {keyName}", signedKey, key, servicePassword);

                                        SaveKeyStore(storage, store, servicePassword, null, keyName, service.Name);
                                    }

                                    Console.WriteLine($"{service.Name} {keyName}: {key.PublicKey.HexString}.");

                                    serviceKeys.Add(store.PublicChainKey);
                                }

                                var pc = new ChainInfoOperation(nextChainId, accountId, service.Title, service.Website, timestamp, serviceKeys, new List <string> {
                                    ep
                                }, new List <PurchaseInfo>());
                                pc.UpdateOperationId(nextTransactionId);
                                coreOperations.Add(pc);

                                nextTransactionId++;

                                if (service.Revenue > 0)
                                {
                                    var rev = new ChainRevenueInfoOperation(nextChainId, service.Revenue, service.RevenueAccountFactor, timestamp);
                                    rev.UpdateOperationId(nextTransactionId);
                                    coreOperations.Add(rev);
                                    nextTransactionId++;
                                }

                                if (service.Accounts > 0)
                                {
                                    var serviceTransactions = new List <ServiceTransaction>();
                                    for (var i = 0; i < service.Accounts; i++)
                                    {
                                        (var accountStore, var accountKey, var accountPassword) = LoadCoreAccountKey(storage, "Core Account " + nextAccountId, "Core Accounts");
                                        if (accountStore == null)
                                        {
                                            accountKey      = Key.Generate(KeyTypes.Ed25519);
                                            accountPassword = Hex.ToString(Rand.NextSeed(32));
                                            accountStore    = new CoreAccountKeyStore($"Core Account {nextAccountId}", nextAccountId, accountKey, accountPassword);

                                            SaveCoreAccountKey(storage, accountStore, "Core Account " + nextAccountId, accountPassword, "Core Accounts");
                                        }

                                        (var serviceAccountStore, var serviceAccountKey, var serviceAccountPassword) = LoadKeyStore <ServiceAccountKeyStore>(storage, null, $"{service.Name} Service Account {nextAccountId}", $"{service.Name}/Service Accounts");
                                        if (serviceAccountStore == null)
                                        {
                                            serviceAccountKey      = Key.Generate(KeyTypes.Ed25519);
                                            serviceAccountPassword = Hex.ToString(Rand.NextSeed(32));

                                            var signedPublicKey = PublicServiceAccountKey.GenerateSignedPublicKey(nextAccountId, nextChainId, 0, 0, serviceAccountKey.PublicKey, accountKey);
                                            serviceAccountStore = new ServiceAccountKeyStore($"{service.Name} Service Account {nextAccountId}", signedPublicKey, serviceAccountKey, serviceAccountPassword);

                                            SaveKeyStore(storage, serviceAccountStore, serviceAccountPassword, null, $"{service.Name} Service Account {nextAccountId}", $"{service.Name}/Service Accounts");
                                        }

                                        var join = new JoinServiceTransaction(serviceAccountStore.SignedPublicKey)
                                        {
                                            SignKey = accountKey
                                        };
                                        join.ToArray();
                                        serviceTransactions.Add(join);

                                        var ao = new AccountOperation(nextAccountId, accountKey.PublicKey, timestamp);
                                        ao.UpdateOperationId(nextTransactionId);

                                        coreOperations.Add(ao);
                                        accounts.Add(ao);

                                        nextTransactionId++;
                                        nextAccountId++;
                                    }

                                    blockStateOperation.AddBlockState(nextChainId, Protocol.GenesisBlockId, 0, 0, serviceTransactions.Count);
                                    serviceTransactionsList[nextChainId] = serviceTransactions;
                                }

                                nextChainId++;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log.HandleException(ex, LogLevels.Error);
                }
            }

            coreOperations.Add(blockStateOperation);
            blockStateOperation.UpdateOperationId(nextTransactionId);
            blockStateOperation.AddBlockState(Protocol.CoreChainId, Protocol.GenesisBlockId, Protocol.GenesisBlockNetworkKeyIssuer, 0, nextTransactionId);

            var block = new CoreBlock(Protocol.GenesisBlockId, Protocol.GenesisBlockNetworkKeyIssuer, 0, timestamp, nextAccountId, nextChainId, Hash.Empty(Protocol.TransactionHashType), Hash.Empty(ValidationOperation.ValidationHashType), coreOperations, new List <CoreTransaction>());

            var signatures = new BlockSignatures(block);

            signatures.AddSignature(block.Issuer, block, networkKey);

            return(new GenesisBlockResult(block, signatures, networkKey.PublicKey, networkKeys[1].Store, networkKeys[1].Password, serviceTransactionsList));
        }
        //Withdraw from Account
        public bool AccountWithdraw(string AccNo, double Amount, string Currency)
        {
            var withdraw = AccountOperation.Withdraw(AccNo, Amount, Currency);

            return(withdraw);
        }
        //Account Deposit
        public bool AccountDeposit(string AccNo, double Amount, string Currency)
        {
            var deposit = AccountOperation.Deposit(AccNo, Amount, Currency);

            return(deposit);
        }