Example #1
0
        public async Task <IWriterResult> UpdateTradePair(string adminUserId, UpdateTradePairModel model)
        {
            using (var context = ExchangeDataContextFactory.CreateContext())
            {
                var tradePair = await context.TradePair
                                .Include(x => x.Currency1)
                                .Include(x => x.Currency2)
                                .Where(x => x.Id == model.Id)
                                .FirstOrDefaultNoLockAsync().ConfigureAwait(false);

                if (tradePair == null)
                {
                    return(new WriterResult(false, $"TradePair {model.Id} not found."));
                }

                var oldStatus = tradePair.Status;
                tradePair.Status        = model.Status;
                tradePair.StatusMessage = model.StatusMessage;

                using (var dataContext = DataContextFactory.CreateContext())
                {
                    dataContext.LogActivity(adminUserId, $"Updating Trade Pair:{tradePair.Currency1.Symbol}_{tradePair.Currency2.Symbol} Old Status: {oldStatus}, New status {tradePair.Status}.");
                    await dataContext.SaveChangesAsync().ConfigureAwait(false);
                }

                await context.SaveChangesAsync().ConfigureAwait(false);

                await CacheService.InvalidateAsync(CacheKey.AllTradePairs(), CacheKey.TradePairs()).ConfigureAwait(false);

                return(new WriterResult(true, $"Successfully updated tradepair."));
            }
        }
Example #2
0
        public async Task <ActionResult> UpdateTradePair(UpdateTradePairModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View("UpdateTradePairModal", model));
            }

            var result = await AdminTradePairWriter.UpdateTradePair(User.Identity.GetUserId(), model);

            if (!ModelState.IsWriterResultValid(result))
            {
                return(View("UpdateTradePairModal", model));
            }

            return(CloseModal(result));
        }
Example #3
0
        public async Task <ActionResult> UpdateTradePair(UpdateTradePairModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View("UpdateTradePairModal", model));
            }

            var result = await TradePairWriter.AdminUpdateTradePair(model);

            if (!ModelState.IsWriterResultValid(result))
            {
                return(View("UpdateTradePairModal", model));
            }

            return(CloseModal(result));
        }
Example #4
0
        public async Task <WriterResult <bool> > UpdateTradePair(string userId, UpdateTradePairModel model)
        {
            using (var context = DataContextFactory.CreateContext())
            {
                var tradePair = await context.TradePair.FirstOrDefaultNoLockAsync(x => x.Id == model.Id);

                if (tradePair == null)
                {
                    return(WriterResult <bool> .ErrorResult("TradePair '{0}' not found"));
                }

                tradePair.Status        = model.Status;
                tradePair.StatusMessage = model.StatusMessage;

                await context.SaveChangesAsync();

                return(WriterResult <bool> .SuccessResult());
            }
        }
        public async Task <IWriterResult> AdminUpdateTradePair(UpdateTradePairModel model)
        {
            using (var context = ExchangeDataContextFactory.CreateContext())
            {
                var tradePair = await context.TradePair
                                .Include(x => x.Currency1)
                                .Include(x => x.Currency2)
                                .Where(x => x.Id == model.Id)
                                .FirstOrDefaultNoLockAsync().ConfigureAwait(false);

                if (tradePair == null)
                {
                    return(new WriterResult(false, $"TradePair {model.Id} not found."));
                }

                tradePair.Status        = model.Status;
                tradePair.StatusMessage = model.StatusMessage;
                await context.SaveChangesAsync().ConfigureAwait(false);

                await CacheService.InvalidateAsync(CacheKey.AllTradePairs(), CacheKey.TradePairs()).ConfigureAwait(false);

                return(new WriterResult(true, $"Successfully updated tradepair."));
            }
        }