public void TestTransactionLogOptions()
        {
            using (TempFile temp = new TempFile())
            {
                temp.Delete();
                var opt = new TransactionLogOptions<int, string>(temp.TempPath,
                                                              PrimitiveSerializer.Int32,
                                                              PrimitiveSerializer.String);
                //FileName
                Assert.AreEqual(temp.TempPath, opt.FileName);
                //Key/Value serializers
                Assert.IsTrue(ReferenceEquals(opt.KeySerializer, PrimitiveSerializer.Int32));
                Assert.IsTrue(ReferenceEquals(opt.ValueSerializer, PrimitiveSerializer.String));
                //FileOptions
                Assert.AreEqual(FileOptions.WriteThrough, opt.FileOptions);
                Assert.AreEqual(FileOptions.WriteThrough | FileOptions.Asynchronous, opt.FileOptions |= FileOptions.Asynchronous);
                //Read Only
                Assert.AreEqual(false, opt.ReadOnly);
                Assert.AreEqual(true, opt.ReadOnly = true);
                //File Buffer
                Assert.AreEqual(8, opt.FileBuffer);
                Assert.AreEqual(0x40000, opt.FileBuffer = 0x40000);
                //Clone
                Assert.IsFalse(ReferenceEquals(opt, opt.Clone()));

                using(TransactionLog<int, string> log = new TransactionLog<int,string>(opt))
                    Assert.AreEqual(0, log.Size);
            }
        }
        public void Start_the_persistence_engine_with_a_non_empty_transaction_log()
        {
            var transaction1 = MakeTransaction(
                new Trade(1, 5465, "TATA", DateTime.Now.Date, 150),
                new Trade(2, 5467, "TATA", DateTime.Now.Date, 180)
                );

            var transaction2 = MakeTransaction(
                new Trade(2, 5467, "TOTO", DateTime.Now.Date, 190)
                );

            var log = new TransactionLog();

            log.NewTransaction(
                SerializationHelper.ObjectToBytes(transaction1, SerializationMode.ProtocolBuffers, null));
            log.NewTransaction(
                SerializationHelper.ObjectToBytes(transaction2, SerializationMode.ProtocolBuffers, null));
            log.Dispose();

            var engine = new PersistenceEngine();

            engine.Start();

            engine.WaitForPendingTransactions();

            engine.Stop();


            var processor = new TestProcessor();

            //reload data from persistent storage
            var unused = new ReliableStorage(processor);

            unused.LoadPersistentData();
            unused.Dispose();

            Assert.AreEqual(2, processor.LoadedObjects.Count);

            var reloaded = processor.LoadedObjects.Select(CachedObject.Unpack <Trade>).First(t => t.Id == 2);

            Assert.AreEqual("TOTO", reloaded.Folder);

            //reload data from transaction log. Check no more pending transactions
            log = new TransactionLog();
            Assert.AreEqual(0, log.PendingTransactionsCount);
            log.Dispose();
        }
        public void TestAddOperation()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                var token = log.BeginTransaction();
                log.AddValue(ref token, 1, "test");
                log.CommitTransaction(ref token);

                var test = new Dictionary<int, string>();
                log.ReplayLog(test);

                Assert.AreEqual(1, test.Count);
                Assert.IsTrue(test.ContainsKey(1));
                Assert.AreEqual("test", test[1]);
            }
        }
Ejemplo n.º 4
0
        public void LogTransaction(CustomerAccount customerAccount, decimal amount, TransactionType transactionType)//overload for customers accounts
        {
            var transaction = new TransactionLog
            {
                Name                = customerAccount.AccountName,
                Amount              = amount,
                Date                = DateTime.Now,
                AccountCode         = Convert.ToInt64(customerAccount.AccountNumber),
                TransactionType     = transactionType,
                MainAccountCategory = customerAccount.AccountType == AccountType.Loan //Exception: Loan accounts are assets
                    ? MainAccountCategory.Asset
                    : MainAccountCategory.Liability,
            };

            _db.Add(transaction);
            _db.Save(transaction);
        }
Ejemplo n.º 5
0
        private static async Task <bool> SendDeviceToCloudMessagesAsync(TransactionLog transactionLog)
        {
            try
            {
                var messageString = JsonConvert.SerializeObject(transactionLog);
                var message       = new Message(Encoding.ASCII.GetBytes(messageString));

                await deviceClient.SendEventAsync(message);

                return(true);
            }
            catch (Exception ex)
            {
                var message = ex.Message;
                return(false);
            }
        }
Ejemplo n.º 6
0
        public PieDatabase(TransactionStore store, SerializerSettings settings = null, Func<DataStore> createDataStore = null)
        {
            settings = settings ?? new SerializerSettings();
            createDataStore = createDataStore ?? (() => new DataStore(settings));

            var writeTransaction = new Func<GenericTransaction<DataStore>, string>(
                tran => JsonConvert.SerializeObject(tran, settings))
                .Then(Funcs.AppendStringToStream);

            var readTransactions = Funcs.StreamToStreamReader.Then(Funcs.ReadStringsFromStreamReader)
                                        .ThenForEach(
                                            str =>
                                            JsonConvert.DeserializeObject<GenericTransaction<DataStore>>(str, settings));

            _transactionLog = new TransactionLog<DataStore>(createDataStore, writeTransaction, readTransactions, store);
            DataStore = new Lazy<DataStore>(() => _transactionLog.Value);
        }
Ejemplo n.º 7
0
        public void TestCommitEmptyAndReplay()
        {
            using (TempFile tmp = new TempFile())
                using (var log = new TransactionLog <int, string>(Options(tmp)))
                {
                    var token = log.BeginTransaction();
                    log.CommitTransaction(ref token);//commit empty

                    token = log.BeginTransaction();
                    log.AddValue(ref token, 1, "test");
                    log.CommitTransaction(ref token);//add value

                    var test = new Dictionary <int, string>();
                    log.ReplayLog(test);
                    Assert.AreEqual(1, test.Count);
                }
        }
Ejemplo n.º 8
0
        public void TestAddOperation()
        {
            using (TempFile tmp = new TempFile())
                using (var log = new TransactionLog <int, string>(Options(tmp)))
                {
                    var token = log.BeginTransaction();
                    log.AddValue(ref token, 1, "test");
                    log.CommitTransaction(ref token);

                    var test = new Dictionary <int, string>();
                    log.ReplayLog(test);

                    Assert.AreEqual(1, test.Count);
                    Assert.IsTrue(test.ContainsKey(1));
                    Assert.AreEqual("test", test[1]);
                }
        }
Ejemplo n.º 9
0
        public void Transaction(TransactionLogEnum type, string username, string eventCode)
        {
            User user = _userRepository.GetAll().Where(x => x.Username.Equals(username)).FirstOrDefault();

            if (user != null)
            {
                TransactionLog data = new TransactionLog
                {
                    Action    = type.ToString(),
                    Username  = user.Username,
                    EventCode = eventCode,

                    Time = Clock.Now
                };
                Log.ForContext("Data", JsonConvert.SerializeObject(data)).Information(TypeLogEnum.TransactionLog.ToString());
            }
        }
Ejemplo n.º 10
0
        public override int GetHashCode()
        {
            int hash = 1;

            if (State != 0)
            {
                hash ^= State.GetHashCode();
            }
            if (ExpirationMs != 0UL)
            {
                hash ^= ExpirationMs.GetHashCode();
            }
            if (player_ != null)
            {
                hash ^= Player.GetHashCode();
            }
            if (friend_ != null)
            {
                hash ^= Friend.GetHashCode();
            }
            if (TradingS2CellId != 0L)
            {
                hash ^= TradingS2CellId.GetHashCode();
            }
            if (TransactionLog.Length != 0)
            {
                hash ^= TransactionLog.GetHashCode();
            }
            if (friendshipLevelData_ != null)
            {
                hash ^= FriendshipLevelData.GetHashCode();
            }
            if (IsSpecialTrading != false)
            {
                hash ^= IsSpecialTrading.GetHashCode();
            }
            if (preTradingFriendshipLevel_ != null)
            {
                hash ^= PreTradingFriendshipLevel.GetHashCode();
            }
            if (_unknownFields != null)
            {
                hash ^= _unknownFields.GetHashCode();
            }
            return(hash);
        }
        private void RefreshFinances()
        {
            // clear the panel
            financeListView.Items.Clear();

            TransactionLog temp = new TransactionLog();


            foreach (TransactionLog log in this.guest.Wallet.History)
            {
                financeListView.Items.Add(new ListViewItem(new string[] {
                    (-log.Amount).ToString(),
                    log.Time.ToString(),
                    log.Reason,
                }));
            }
        }
Ejemplo n.º 12
0
        public static async Task <bool> PushToWebApi(string serverUrl, TransactionLog transactionLog)
        {
            try
            {
                var json   = JsonConvert.SerializeObject(transactionLog);
                var url    = new Uri(serverUrl);
                var client = new WebClient();

                client.Headers.Add("Content-Type", "application/json");
                await client.UploadStringTaskAsync(url, json);

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Ejemplo n.º 13
0
        public int InsertLogs(int itemId, int quantiy, DateTime dateReceived, int itemType)
        {
            TransactionLogRepository transactionLogRepo = new TransactionLogRepository();

            TransactionLog transactionLog = new TransactionLog
            {
                ItemId              = itemId,
                Quantity            = quantiy,
                TransactionMethodId = (int)ETransactionMethod.Receiving,
                CompanyId           = Sessions.CompanyId.Value,
                Date       = dateReceived,
                ItemTypeId = itemType
            };

            transactionLogRepo.Add(transactionLog);

            return(transactionLog.Id);
        }
Ejemplo n.º 14
0
        public void InsertTransactionLog(TransactionLog tranLog)
        {
            SpCall call = new SpCall("COR.TRANSACTION_LOG_INSERT");

            call.SetVarchar("@TRAN_CODE", tranLog.TransactionCode);
            call.SetBinary("@TRANSACTION_LOG", tranLog.Log);
            call.SetVarchar("@TRANSACTION_JSON", tranLog.LogJson);
            call.SetVarchar("@TRANSACTION_STATUS", tranLog.Status);
            call.SetBigInt("@TRANSACTION_OBJECT_ID", tranLog.LogObjectId);
            call.SetVarchar("@ACTION_TYPE", tranLog.ActionType);
            call.SetVarchar("@REQUEST_TYPE", tranLog.RequestType);
            call.SetDateTime("@CREATE_DATE", DateTime.Now);
            call.SetVarchar("@CREATE_USER", tranLog.CreatedUser);
            call.SetDecimal("@DURATION", tranLog.Duration);
            long id = db.ExecuteScalar <long>(call);

            tranLog.Id = id;
        }
Ejemplo n.º 15
0
        public void InsertTransactionHistory()
        {
            var transactionRepo = new TransactionRepo();

            var log = new TransactionLog
            {
                Type        = TransactionType.SuccessfulPurchase,
                PlayerName  = "Lionel Messi",
                SearchPrice = 150000,
                //SellPrice = 175000,
                TransactionDate = DateTime.Now,
                UserName        = "******"
            };

            transactionRepo.InsertTransactionLog(log);

            Assert.IsTrue(log.TransactionId.Length > 0);
        }
        private static void PrintChanges(TransactionLog log)
        {
            foreach (var change in log.Changes)
            {
                Console.WriteLine(@"Entity: #{0}={1}, Change: {2}", change.Entity.EntityLabel, change.Entity.GetType().Name, change.ChangeType);
                Console.WriteLine(@"    Original entity: {0}", change.OriginalEntity);
                Console.WriteLine(@"    Current entity: {0}", change.CurrentEntity);
                if (change.ChangeType != ChangeType.Modified)
                {
                    continue;
                }

                foreach (var prop in change.ChangedProperties)
                {
                    Console.WriteLine(@"        Property '{0}' changed from {1} to {2}", prop.Name, prop.OriginalValue, prop.CurrentValue);
                }
            }
        }
Ejemplo n.º 17
0
        public void SetTransactionLog(TransactionLog log)
        {
            gridControl1.DataSource = log.TransCollection; // should be based on symbolname
            // select the last entry and scroll to it
            gridView1.BestFitColumns();
            //gridControl1.RefreshDataSource();
            //gridView1.FocusedRowHandle = gridView1.RowCount - 1;

            /*gridView1.SelectRow(gridView1.RowCount - 1);
             * if (gridView1.IsRowVisible(gridView1.RowCount - 1) != DevExpress.XtraGrid.Views.Grid.RowVisibleState.Visible)
             * {
             *  gridView1.MakeRowVisible(gridView1.RowCount - 1, true);
             * }*/



            UpdateButtons();
        }
        public static void SaveError(int OrderId, string Description, string Request, string Response)
        {
            TransactionLog transactionLog = new TransactionLog();

            try
            {
                transactionLog.OrderId     = OrderId;
                transactionLog.Description = Description;
                transactionLog.Request     = Request;
                transactionLog.Response    = Response;
                transactionLog.LogDate     = DateTime.Now;

                Repository <TransactionLog> userRep = new Repository <TransactionLog>();
                userRep.Add(transactionLog);
                userRep.Save();
            }
            catch { }
        }
Ejemplo n.º 19
0
        public TransactionInfo WireTransferToAccount(Claim claim, TransactionRequest request)
        {
            if (request.Amount <= 0)
            {
                throw new NullReferenceException("Amount to transfer must be greater than 0");
            }
            Users accountUser = _accountMapper.GetAccountNumberByUserName(claim);
            var   accounts    = _unitOfWork.Accounts
                                .GetFiltered(i => i.AccountId == accountUser.Account || i.AccountId == request.AccountToTransfer);
            var accountToRemote = accounts.FirstOrDefault(i => i.AccountId == accountUser.Account);
            var accountToAdd    = accounts.FirstOrDefault(i => i.AccountId == request.AccountToTransfer);

            if (accountToAdd == null)
            {
                return new TransactionInfo
                       {
                           TransactionException = new Exception("Account to Transfer does not exists")
                       }
            }
            ;
            accountToRemote.Balance -= request.Amount;
            accountToAdd.Balance    += request.Amount;

            var transactionLog = new TransactionLog
            {
                DestinationAccount = accountToAdd.AccountId,
                SourceAccount      = accountToRemote.AccountId,
                TransactionType    = TransactionTypes.WireTransfer,
                UserName           = accountUser.UserName,
                Date   = DateTime.Now,
                Amount = request.Amount
            };

            _unitOfWork.TransactionLog.Add(transactionLog);

            _unitOfWork.Commit();
            return(new TransactionInfo {
                PrimaryAccount = accountToRemote.AccountId,
                PrimaryAccountBalance = accountToRemote.Balance,
                SecondaryAccount = accountToAdd.AccountId,
                TransactionType = TransactionTypes.WireTransfer
            });
        }
    }
Ejemplo n.º 20
0
            /// <summary>
            /// Converts from non sale tender operation type to transaction log.
            /// </summary>
            /// <param name="nonSalesTransaction">Non sale tender transaction.</param>
            /// <returns>Returns the transaction log entity.</returns>
            private TransactionLog Convert(NonSalesTransaction nonSalesTransaction)
            {
                ThrowIf.NullOrWhiteSpace(nonSalesTransaction.Id, "nonSalesTransaction.Id");

                var transaction = new TransactionLog();

                transaction.Id                          = nonSalesTransaction.Id;
                transaction.StoreId                     = nonSalesTransaction.StoreId;
                transaction.TransactionType             = (TransactionType)nonSalesTransaction.TransactionTypeValue;
                transaction.StaffId                     = nonSalesTransaction.StaffId;
                transaction.ShiftId                     = nonSalesTransaction.ShiftId;
                transaction.ShiftTerminalId             = nonSalesTransaction.ShiftTerminalId;
                transaction.TerminalId                  = nonSalesTransaction.TerminalId;
                transaction.Description                 = nonSalesTransaction.Description;
                transaction.ChannelCurrencyExchangeRate = nonSalesTransaction.ChannelCurrencyExchangeRate;
                transaction.ChannelCurrency             = nonSalesTransaction.ChannelCurrency;

                return(transaction);
            }
Ejemplo n.º 21
0
 public static bool SaveTransactionLog(ITransactionLogAppService _tranService, string tranForm, string tranType, string id, string userName)
 {
     try
     {
         TransactionLog tranLog = new TransactionLog();
         tranLog.TranForm     = tranForm;
         tranLog.TranType     = tranType;
         tranLog.TranDateTime = DateTime.Now.ToString();
         tranLog.TranNo       = id;
         tranLog.UserName     = userName;
         _tranService.Add(tranLog);
         _tranService.Save();
         return(true);
     }
     catch (Exception ex)
     {
         return(false);
     }
 }
Ejemplo n.º 22
0
        public async Task <IActionResult> Run(
            [HttpTrigger(Constants.AUTHORIZATION_LEVEL, "post", Route = "accepttaskweek")] HttpRequest req, ILogger log, CancellationToken ct)
        {
            TaskWeek data = null;

            try
            {
                string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
                data = JsonConvert.DeserializeObject <TaskWeek>(requestBody);
                log.LogTrace($"AcceptTaskWeek function processed a request for taskWeekId:{data.Id}.");

                var userIdentifier = await GetTargetUserIdentifier(req);

                if (!await IsParent(req))
                {
                    throw new SecurityException("Invalid attempt to accept a taskweek by an invalid user");
                }
                await _taskWeekService.Update(data, false);

                var account = await _accountService.GetByUser(data.UserIdentifier);

                account.Balance += data.Value;
                await _accountService.Update(account, false);

                var transaction = new TransactionLog()
                {
                    AccountId      = account.Id.Value,
                    UserIdentifier = req.GetUserIdentifier(),
                    Amount         = data.Value,
                    CategoryId     = (int)Constants.TransactionCategory.Deposit,
                    Date           = DateTime.Now,
                    Description    = "Weekly allowance deposit."
                };
                await _transactionLogService.Create(transaction, false);

                await _transactionLogService.SaveChanges();
            }
            catch (Exception exception)
            {
                return(new BadRequestObjectResult($"Error trying to execute PutTaskWeek.  {exception.Message}"));
            }
            return(new OkObjectResult(data.Id.Value));
        }
Ejemplo n.º 23
0
        public PieDatabase(TransactionStore store, SerializerSettings settings = null, Func <DataStore> createDataStore = null)
        {
            settings        = settings ?? new SerializerSettings();
            createDataStore = createDataStore ?? (() => new DataStore(settings));

            var writeTransaction = new Func <GenericTransaction <DataStore>, string>(
                tran => JsonConvert.SerializeObject(tran, settings))
                                   .Then(Funcs.AppendStringToStream);

            var readTransactions = Funcs.StreamToStreamReader.Then(Funcs.ReadStringsFromStreamReader)
                                   .ThenForEach(
                str =>
                JsonConvert.DeserializeObject <GenericTransaction <DataStore> >(str, settings));



            _transactionLog = new TransactionLog <DataStore>(createDataStore, writeTransaction, readTransactions, store);
            DataStore       = new Lazy <DataStore>(() => _transactionLog.Value);
        }
Ejemplo n.º 24
0
 public double CalculateDiscount(int userid, TransactionLog trxRecord)
 {
     try
     {
         string user = LoggedInuser.LoggedInUser();
         if (user != null || user != "" || user != ConfigurationManager.AppSettings["PaelytEmail"])
         {
             var DiscountAmount = 0;
             var DiscountValue  = 0;
             MyUtility.SaveWallet(trxRecord, "Discount", userid, DiscountValue, DiscountAmount);
         }
         return(0);
     }
     catch (Exception ex)
     {
         WebLog.Log(ex.Message.ToString());
         return(0);
     }
 }
Ejemplo n.º 25
0
        public void CreateTransactionLog(TransactionLog transactionLog, out string recipientName)
        {
            var recipient = _db.Users
                            .FirstOrDefault(el => el.Id == transactionLog.RecipientId);

            recipientName = recipient.Name;

            _currentUser.Balance -= transactionLog.Sum;
            recipient.Balance    += transactionLog.Sum;

            transactionLog.SenderId       = _currentUser.Id;
            transactionLog.CreateDateTime = DateTime.Now;
            transactionLog.TotalRecipient = recipient.Balance;
            transactionLog.TotalSender    = _currentUser.Balance;

            _db.TransactionLogs.Add(transactionLog);

            _db.SaveChanges();
        }
Ejemplo n.º 26
0
            /// <summary>
            /// Converts from non sale tender operation type to transaction log.
            /// </summary>
            /// <param name="tenderTransaction">Non sale tender transaction.</param>
            /// <returns>Returns the transaction log entity.</returns>
            private TransactionLog Convert(DropAndDeclareTransaction tenderTransaction)
            {
                ThrowIf.NullOrWhiteSpace(tenderTransaction.Id, "tenderTransaction.Id");

                var transaction = new TransactionLog();

                transaction.Id                          = tenderTransaction.Id;
                transaction.StoreId                     = tenderTransaction.StoreId;
                transaction.TransactionType             = (TransactionType)tenderTransaction.TransactionType;
                transaction.StaffId                     = tenderTransaction.StaffId;
                transaction.ShiftId                     = tenderTransaction.ShiftId;
                transaction.ShiftTerminalId             = tenderTransaction.ShiftTerminalId;
                transaction.TerminalId                  = tenderTransaction.TerminalId;
                transaction.ChannelCurrencyExchangeRate = tenderTransaction.ChannelCurrencyExchangeRate;
                transaction.ChannelCurrency             = tenderTransaction.ChannelCurrency;
                transaction.Description                 = tenderTransaction.Description;

                return(transaction);
            }
Ejemplo n.º 27
0
        public static int SaveWallet(TransactionLog tLog, string narration, int userID, double discountValue, double discountamount = 0)
        {
            int walletID = 0;

            try
            {
                if (userID == 0)
                {
                    return(walletID);
                }

                GlobalTransactEntitiesData pwr = new GlobalTransactEntitiesData();

                var qry = pwr.CustomerWallets
                          .Where(x => x.RefNumber == tLog.ReferenceNumber && x.User_FK == userID).ToList();

                if (qry == null || qry.Count == 0)
                {
                    double         walletPoint = Convert.ToDouble(tLog.Amount) * 0.01 * discountValue;
                    CustomerWallet cwObj       = new CustomerWallet
                    {
                        Credit     = discountamount == 0 ? walletPoint : discountamount,
                        CustomerID = tLog.CustomerID,
                        Debit      = 0,
                        IsVisible  = 1,
                        Narration  = narration,
                        RefNumber  = tLog.ReferenceNumber,
                        TrnDate    = tLog.TrnDate,
                        User_FK    = userID,
                        ValueDate  = Utility.GetCurrentDateTime().ToString("yyyy/MM/dd")
                    };
                    pwr.CustomerWallets.Add(cwObj);
                    pwr.SaveChanges();
                    walletID = cwObj.ID;
                    // return cwObj.ID;
                }
            }
            catch (Exception ex)
            {
                // WebLog.Log(ex.Message + "##", ex.StackTrace);
            }
            return(walletID);
        }
Ejemplo n.º 28
0
        public static void AddTransactionHistoryParams(NpgsqlCommand cmd, TransactionLog log)
        {
            string postgresSucksAtEnums;

            switch (log.Type)
            {
            case TransactionType.SuccessfulPurchase:
                postgresSucksAtEnums = "SuccessfulPurchase";
                break;

            case TransactionType.FailedPurchase:
                postgresSucksAtEnums = "FailedPurchase";
                break;

            case TransactionType.SuccessfulSale:
                postgresSucksAtEnums = "SuccessfulSale";
                break;

            case TransactionType.FailedSale:
                postgresSucksAtEnums = "FailedSale";
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            cmd.Parameters.AddWithValue("transactionType", postgresSucksAtEnums);
            cmd.Parameters.AddWithValue("playerName", log.PlayerName);
            cmd.Parameters.AddWithValue("searchPrice", log.SearchPrice);

            if (log.SellPrice == null)
            {
                cmd.Parameters.AddWithValue("sellPrice", DBNull.Value);
            }
            else
            {
                cmd.Parameters.AddWithValue("sellPrice", log.SellPrice);
            }

            cmd.Parameters.AddWithValue("transactionDate", log.TransactionDate);
            cmd.Parameters.AddWithValue("userName", log.UserName);
        }
        public async void GetTransactions()
        {
            User user = (User)HttpContext.Items["User"];

            try
            {
                TransactionLog log = new TransactionLog();

                if (user.Username == "admin")
                {
                    //get transactions from database
                    ArrayList trans = TransactionLog.GetAllTransactions();
                    HttpContext.Response.ContentType = "application/json";
                    await HttpContext.Response.Body.WriteAsync(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(trans)));

                    log.Type = "Admin Viewed Logs";
                }
                else
                {
                    HttpContext.Response.StatusCode = 400;
                    await HttpContext.Response.Body.WriteAsync(Encoding.ASCII.GetBytes("You do not have permission."));

                    log.Type = "Non Admin Blocked from Logs";
                }

                log.Username             = user.Username;
                HttpContext.Items["Log"] = log;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.StackTrace);
                User           u   = (User)HttpContext.Items["User"];
                TransactionLog log = new TransactionLog
                {
                    Type     = "Non Admin Blocked from Logs",
                    Username = u.Username
                };
                HttpContext.Items["Log"]        = log;
                HttpContext.Response.StatusCode = 400;
                await HttpContext.Response.Body.WriteAsync(Encoding.ASCII.GetBytes("You do not have permission."));
            }
        }
Ejemplo n.º 30
0
        public void TestLogCorruption()
        {
            using (TempFile tmp = new TempFile())
            {
                using (var log = new TransactionLog <int, string>(Options(tmp)))
                {
                    var token = log.BeginTransaction();
                    log.AddValue(ref token, 1, Guid.NewGuid().ToString());
                    log.CommitTransaction(ref token);
                    var  test   = new Dictionary <int, string>();
                    long offset = 0;
                    log.ReplayLog(test, ref offset);
                    Assert.AreEqual(1, test.Count);
                }
                byte[] bytes = tmp.ReadAllBytes();

                var TestVariants =
                    new Converter <KeyValuePair <int, byte[]>, byte[]>[]
                {
                    kv => { kv.Value[kv.Key] ^= 0xff; return(kv.Value); },
                    kv => { kv.Value[kv.Key] = 0xff; return(kv.Value); },
                    kv => { byte[] b = kv.Value; Array.Resize(ref b, kv.Key); return(b); },
                };

                for (int corruptionIx = 0; corruptionIx < bytes.Length; corruptionIx++)
                {
                    foreach (var testcase in TestVariants)
                    {
                        byte[] corrupt = testcase(new KeyValuePair <int, byte[]>(corruptionIx, (byte[])bytes.Clone()));
                        tmp.WriteAllBytes(corrupt);

                        using (var log = new TransactionLog <int, string>(Options(tmp)))
                        {
                            var test = new Dictionary <int, string>();
                            log.ReplayLog(test);
                            Assert.AreEqual(0, test.Count);
                        }
                        Assert.IsFalse(File.Exists(tmp.TempPath));
                    }
                }
            }
        }
Ejemplo n.º 31
0
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            //Bu attribute ile donatilmis her action,
            //kendi islemini kayit altina alir. TransactionLog olarak kayit eder.
            var            IpAddress         = HttpContext.Current.Request.UserHostAddress;
            var            sessionData       = HttpContext.Current.Session["TurkcellSessionId"];
            string         TurkcellSession   = sessionData == null ? null : sessionData.ToString();
            BaseController controllerDefault = (BaseController)filterContext.Controller;

            //SessionManager s = new SessionManager();
            UserFb userData       = null;
            var    sessionManager = SessionManager.GetInstance();
            var    serializer     = new Serialize();

            if (sessionManager.HasSessionUser)
            {
                //Sessionda user bilgileri var ise, bunlari deserilaze edip data'ya aktariyoruz.
                userData = (UserFb)serializer.DeserializeObject(sessionManager.SessionUser, typeof(UserFb));
            }

            string msisdn   = userData == null ? "" : userData.Msisdn;
            int    userId   = userData == null ? 0 : userData.Id;
            string userFbId = userData == null ? "" : userData.FbId;


            TransactionLog log = new TransactionLog();

            log.Status       = LogService.LogDefinitions.ActionCall.ToString();
            log.Naming       = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName + "::" + filterContext.ActionDescriptor.ActionName;
            log.IP           = IpAddress;
            log.Msisdn       = msisdn;
            log.UserId       = userId;
            log.FbId         = userFbId;
            log.TcellSession = TurkcellSession;
            log.Details      = ActionDescription;

            LogService logger = LogService.GetInstance();

            logger.Log <TransactionLog>(log);

            base.OnActionExecuting(filterContext);
        }
Ejemplo n.º 32
0
        /// <summary>
        /// 创建交易日志
        /// </summary>
        /// <returns></returns>
        private async Task <TransactionLog> CreateToPayTransactionInfo(PayInputBase input, Exception exception = null)
        {
            var transactionInfo = new TransactionInfo()
            {
                Amount           = input.TotalAmount,
                CustomData       = input.CustomData,
                OutTradeNo       = input.OutTradeNo ?? GenerateOutTradeNo(),
                PayChannel       = input.PayChannel,
                Subject          = input.Subject,
                TransactionState = TransactionStates.NotPay,
                //TransactionId = "",
                Exception = exception
            };
            TransactionLog transactionLog = null;

            transactionLog = _transactionLogHelper.CreateTransactionLog(transactionInfo);
            await _transactionLogHelper.SaveAsync(transactionLog);

            return(transactionLog);
        }
Ejemplo n.º 33
0
        public void TestMultipleWriteAndReplay()
        {
            using (TempFile tmp = new TempFile())
                using (var log = new TransactionLog <int, string>(Options(tmp)))
                {
                    var token = log.BeginTransaction();
                    log.AddValue(ref token, 1, "test");
                    log.AddValue(ref token, 2, "test");
                    log.AddValue(ref token, 3, "test");
                    log.CommitTransaction(ref token);

                    var test = new Dictionary <int, string>();
                    log.ReplayLog(test);
                    Assert.AreEqual(3, test.Count);
                    for (int i = 1; i <= 3; i++)
                    {
                        Assert.AreEqual("test", test[i]);
                    }
                }
        }
        public void TestBenchmarkWriteSpeed()
        {
            //Write 2,147,483,776 bytes in: 00:02:09.7934237 (in chunks of 128 bytes)
            //Write 4,295,032,832 bytes in: 00:00:18.4990581 (in chunks of 65536 bytes)
            //Logged 2,398,000,000 bytes in: 00:00:36.7621027


            string newpath = Path.Combine(@"C:\Temp\LogTest\", Guid.NewGuid() + ".tmp");
            using (TempFile tmp = TempFile.Attach(newpath))
            {
                byte[] bytes;
                DateTime start;
                //bytes = new byte[128];
                //new Random().NextBytes(bytes);

                //start = DateTime.UtcNow;
                //using (var io = new FileStream(tmp.TempPath, FileMode.Append, FileAccess.Write, FileShare.Read, 8))
                //{
                //    for (int i = 0; i <= 16777216; i++)
                //        io.Write(bytes, 0, 128);
                //}
                //Console.WriteLine("Write {0:n0} bytes in: {1}", tmp.Length, DateTime.UtcNow - start);
                //tmp.Delete();

                var options = new TransactionLogOptions<Guid, byte[]>(
                    tmp.TempPath, PrimitiveSerializer.Guid, PrimitiveSerializer.Bytes) 
                    {
                        FileBuffer = ushort.MaxValue,
                        FileOptions = FileOptions.None | FileOptions.SequentialScan,
                    };

                Guid[] ids = new Guid[1000000];
                for (int i = 0; i < ids.Length; i++)
                    ids[i] = Guid.NewGuid();

                bytes = new byte[100];
                new Random().NextBytes(bytes);

                start = DateTime.UtcNow;

                using (var log = new TransactionLog<Guid, byte[]>(options))
                {
                    foreach(Guid id in ids)
                    {
                        var token = log.BeginTransaction();
                        for (int i = 0; i < 20; i++)
                            log.AddValue(ref token, id, bytes);
                        log.CommitTransaction(ref token);
                    }
                }

                Console.WriteLine("Logged {0:n0} bytes in: {1}", tmp.Length, DateTime.UtcNow - start);
            }
        }
        public void TestSyncFromLogging()
        {
            using (var tempFile = new TempFile())
            using (var logfile = new TempFile())
            using (var tempCopy = new TempFile())
            {
                var options = new BPlusTree<int, string>.OptionsV2(new PrimitiveSerializer(), new PrimitiveSerializer())
                {
                    CreateFile = CreatePolicy.Always,
                    FileName = tempFile.TempPath,
                    TransactionLogFileName = logfile.TempPath,
                }.CalcBTreeOrder(4, 10);

                var readcopy = options.Clone();
                readcopy.FileName = tempCopy.TempPath;
                readcopy.StoragePerformance = StoragePerformance.Fastest;

                using (var tree = new BPlusTree<int, string>(options))
                using (var copy = new BPlusTree<int, string>(readcopy))
                using (var tlog = new TransactionLog<int, string>(
                    new TransactionLogOptions<int, string>(logfile.TempPath, PrimitiveSerializer.Int32, PrimitiveSerializer.String) { ReadOnly = true }))
                {
                    tree.Add(0, "0");
                    tree.Commit();

                    long logpos = 0;
                    copy.EnableCount();
                    //start by copying the data from tree's file into the copy instance:
                    copy.BulkInsert(
                        BPlusTree<int, string>.EnumerateFile(options),
                        new BulkInsertOptions { InputIsSorted = true, CommitOnCompletion = false, ReplaceContents = true }
                        );

                    Assert.AreEqual(1, copy.Count);
                    Assert.AreEqual("0", copy[0]);

                    tlog.ReplayLog(copy, ref logpos);
                    Assert.AreEqual(1, copy.Count);

                    //insert some data...
                    tree.AddRange(MakeValues(1, 99));

                    tlog.ReplayLog(copy, ref logpos);
                    Assert.AreEqual(100, copy.Count);

                    //insert some data...
                    for (int i = 0; i < 100; i++)
                        tree.Remove(i);
                    tlog.ReplayLog(copy, ref logpos);
                    Assert.AreEqual(0, copy.Count);

                    tree.AddRange(MakeValues(1000, 1000));

                    tlog.ReplayLog(copy, ref logpos);
                    Assert.AreEqual(1000, copy.Count);
                }
            }
        }
        public void TestMultipleTransAndReplay()
        {

            using (TempFile tmp = new TempFile())
            {
                var opts = Options(tmp);
                using (var log = new TransactionLog<int, string>(opts))
                {
                    var token = log.BeginTransaction();
                    log.AddValue(ref token, 1, "test");
                    log.CommitTransaction(ref token);
                    token = log.BeginTransaction();
                    log.AddValue(ref token, 2, "test");
                    log.CommitTransaction(ref token);
                    token = log.BeginTransaction();
                    log.AddValue(ref token, 3, "test");
                    log.CommitTransaction(ref token);
                    log.Close();
                }

                using (var log = new TransactionLog<int, string>(opts))
                {
                    var test = new Dictionary<int, string>();
                    log.ReplayLog(test);
                    Assert.AreEqual(3, test.Count);
                    for (int i = 1; i <= 3; i++)
                        Assert.AreEqual("test", test[i]);
                }
            }
        }
        public void TestRemoveOperation()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                var token = log.BeginTransaction();
                log.RemoveValue(ref token, 1);
                log.CommitTransaction(ref token);

                var test = new Dictionary<int, string>();
                test.Add(1, null);
                log.ReplayLog(test);

                Assert.AreEqual(0, test.Count);
            }
        }
Ejemplo n.º 38
0
 public void CommitCallback(TransactionLog transactionLog)
 {
     foreach (var eventToRaise in transactionLog.Events)
     {
         _arguments.Enqueue(eventToRaise);
     }
 }
        public void TestLogWithJunkAppended()
        {
            string testdata = Guid.NewGuid().ToString();
            using (TempFile tmp = new TempFile())
            {
                using (var log = new TransactionLog<int, string>(Options(tmp)))
                {
                    var token = log.BeginTransaction();
                    for (int i = 0; i < 20; i++)
                        log.AddValue(ref token, i, testdata);
                    log.CommitTransaction(ref token);
                }
                using (var log = new TransactionLog<int, string>(Options(tmp)))
                {
                    var test = new Dictionary<int, string>();
                    log.ReplayLog(test);
                    Assert.AreEqual(20, test.Count);
                    for (int i = 0; i < 20; i++)
                        Assert.AreEqual(testdata, test[i]);
                }

                long flength;
                byte[] junk = new byte[512];
                new Random().NextBytes(junk);
                using(Stream io = File.OpenWrite(tmp.TempPath))
                {
                    flength = io.Seek(0, SeekOrigin.End);
                    io.Write(junk, 0, junk.Length);
                }

                using (var log = new TransactionLog<int, string>(Options(tmp)))
                {
                    var test = new Dictionary<int, string>();
                    log.ReplayLog(test);
                    Assert.AreEqual(20, test.Count);
                    for (int i = 0; i < 20; i++)
                        Assert.AreEqual(testdata, test[i]);
                }
                // The file will be truncated to a valid position
                Assert.AreEqual(flength, new FileInfo(tmp.TempPath).Length);
            }
        }
        public void TestCommitEmptyAndReplay()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                var token = log.BeginTransaction();
                log.CommitTransaction(ref token);//commit empty

                token = log.BeginTransaction();
                log.AddValue(ref token, 1, "test");
                log.CommitTransaction(ref token);//add value

                var test = new Dictionary<int, string>();
                log.ReplayLog(test);
                Assert.AreEqual(1, test.Count);
            }
        }
        public void test_plan()
        {
            var customer = new Customer();
            TransactionLog log = new TransactionLog()
            {
                Action = "UPSERT",
                Object = JsonConvert.SerializeObject(customer),
                ObjectId = $"{customer.PartitionKey}|{customer.RowKey}",
                TableName = "Customer",
                Type = "Customer"
            };

            var action = log.Create("UseDevelopmentStorage=True");
            action?.Invoke();
        }
        public void TestSingleRollbackAndReplay()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                var token = log.BeginTransaction();
                log.AddValue(ref token, 1, "test");
                log.RollbackTransaction(ref token);

                var test = new Dictionary<int, string>();
                log.ReplayLog(test);
                Assert.AreEqual(0, test.Count);
            }
        }
        public void TestProgressiveReplay()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                var token = log.BeginTransaction();
                log.AddValue(ref token, 1, "test");
                log.CommitTransaction(ref token);

                var test = new Dictionary<int, string>();
                long position = 0;
                log.ReplayLog(test, ref position);
                Assert.AreEqual(1, test.Count);
                test.Clear();

                log.ReplayLog(test, ref position);
                Assert.AreEqual(0, test.Count);

                token = log.BeginTransaction();
                log.AddValue(ref token, 2, "test");
                log.CommitTransaction(ref token);

                log.ReplayLog(test, ref position);
                Assert.AreEqual(1, test.Count);
                Assert.IsTrue(test.ContainsKey(2));
                Assert.AreEqual("test", test[2]);
            }
        }
        public void TestPositionAndReplay()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                var token = log.BeginTransaction();
                log.AddValue(ref token, 1, "test");
                log.CommitTransaction(ref token);

                long size = long.MaxValue;
                log.ReplayLog(null, ref size);

                token = log.BeginTransaction();
                log.AddValue(ref token, 2, "test");
                log.CommitTransaction(ref token);

                var test = new Dictionary<int, string>();
                log.ReplayLog(test, ref size);
                Assert.AreEqual(1, test.Count);
                Assert.AreEqual("test", test[2]);
            }
        }
 public void TestReplayEmpty()
 {
     using (TempFile tmp = new TempFile())
     using (var log = new TransactionLog<int, string>(Options(tmp)))
     {
         var test = new Dictionary<int, string>();
         log.ReplayLog(test);
         Assert.AreEqual(0, test.Count);
     }
 }
        public void TestLogCorruption()
        {
            using (TempFile tmp = new TempFile())
            {
                using (var log = new TransactionLog<int, string>(Options(tmp)))
                {
                    var token = log.BeginTransaction();
                    log.AddValue(ref token, 1, Guid.NewGuid().ToString());
                    log.CommitTransaction(ref token);
                    var test = new Dictionary<int, string>();
                    long offset = 0;
                    log.ReplayLog(test, ref offset);
                    Assert.AreEqual(1, test.Count);
                }
                byte[] bytes = tmp.ReadAllBytes();

                var TestVariants =
                    new Converter<KeyValuePair<int, byte[]>, byte[]>[]
                        {
                            kv => { kv.Value[kv.Key] ^= 0xff; return kv.Value; },
                            kv => { kv.Value[kv.Key] = 0xff; return kv.Value; },
                            kv => { byte[] b = kv.Value; Array.Resize(ref b, kv.Key); return b; },
                        };

                for (int corruptionIx = 0; corruptionIx < bytes.Length; corruptionIx++)
                {
                    foreach (var testcase in TestVariants)
                    {
                        byte[] corrupt = testcase(new KeyValuePair<int, byte[]>(corruptionIx, (byte[]) bytes.Clone()));
                        tmp.WriteAllBytes(corrupt);

                        using (var log = new TransactionLog<int, string>(Options(tmp)))
                        {
                            var test = new Dictionary<int, string>();
                            log.ReplayLog(test);
                            Assert.AreEqual(0, test.Count);
                        }
                        Assert.IsFalse(File.Exists(tmp.TempPath));
                    }
                }
            }
        }
        public void TestLargeWriteAndReplay()
        {
            using (TempFile tmp = new TempFile())
            using (var log = new TransactionLog<int, string>(Options(tmp)))
            {
                string testdata = new String('*', 512);
                var token = log.BeginTransaction();
                for (int i = 0; i < 20; i++)
                    log.AddValue(ref token, i, testdata);
                log.CommitTransaction(ref token);

                var test = new Dictionary<int, string>();
                log.ReplayLog(test);
                Assert.AreEqual(20, test.Count);
                for (int i = 0; i < 20; i++)
                    Assert.AreEqual(testdata, test[i]);
            }
        }