/// <summary>
/// Using Ajax to search data table Sales Project Detail by User
/// </summary>
/// <param name="model"></param>
/// <param name="condition"></param>
/// <param name="TAB_ID"></param>
/// <returns></returns>
public ActionResult SearchSalesProjectDetail(DataTablesModel model, SalesProjectDetailCondition condition, string TAB_ID)
{
if (Request.IsAjaxRequest() && ModelState.IsValid)
{
condition.CompanyCode = GetLoginUser().CompanyCode;
var pageInfo = this.mainService.GetListSalesProjectDetail(model, condition);
Session[Constant.SESSION_SEARCH_RESULT + TAB_ID] = pageInfo.Items;
decimal totalSales = 0;
decimal totalCost = 0;
decimal totalProfit = 0;
foreach (var data in pageInfo.Items)
{
totalSales += data.sales_amount;
totalCost += data.cost;
totalProfit += data.profit;
}
var result = Json(
new
{
sEcho = model.sEcho,
iTotalRecords = pageInfo.TotalItems,
iTotalDisplayRecords = pageInfo.TotalItems,
aaData = (from t in pageInfo.Items
select new object[]
{
t.user_sys_id,
t.peta_rn,
HttpUtility.HtmlEncode(t.user_name),
t.sales_amount.ToString("#,##0") + "円",
t.cost.ToString("#,##0") + "円",
t.profit.ToString("#,##0") + "円",
}).ToList(),
totalSales = totalSales.ToString("#,##0") + "円",
totalCost = totalCost.ToString("#,##0") + "円",
totalProfit = totalProfit.ToString("#,##0") + "円"
},
JsonRequestBehavior.AllowGet);
return(result);
}
return(new EmptyResult());
}
public async Task <DataTablesResponse> GetNews(DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.NewsItem
.AsNoTracking()
.Select(x => new
{
Id = x.Id,
Title = x.Title,
Author = x.User.UserName,
Status = x.Status,
Timestamp = x.Timestamp
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetBannedUsers(DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.Users
.AsNoTracking()
.Where(u => !u.IsDisabled && u.ChatBanEndTime > DateTime.UtcNow)
.Select(user => new
{
//UserId = user.Id,
ChatHandle = user.ChatHandle,
//UserName = user.UserName,
BanEnds = user.ChatBanEndTime,
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetCompletedVerifications(DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.UserVerification
.Where(x => x.User.VerificationLevel == VerificationLevel.Level2)
.Select(uv => new
{
uv.Id,
User = uv.User.UserName,
Requested = uv.Timestamp,
uv.Approved,
ApprovedBy = uv.ApprovedByUser == null ? string.Empty : uv.ApprovedByUser.UserName,
}).OrderByDescending(x => x.Requested);
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> GetBalances(string userId, DataTablesModel model)
{
var now = DateTime.UtcNow;
using (var context = ExchangeDataContextFactory.CreateContext())
{
var query = from currency in context.Currency.Where(p => p.RewardsExpires > now)
from balance in context.Balance.Where(b => b.CurrencyId == currency.Id && b.UserId == Constant.SYSTEM_USER_REWARD).DefaultIfEmpty()
select new
{
Currency = currency.Symbol,
Remaining = (decimal?)balance.Total ?? 0,
CurrencyId = currency.Id
};
return(await query.GetDataTableResultNoLockAsync(model, true).ConfigureAwait(false));
}
}
/// <summary>
/// JSON反序列化
/// </summary>
public static DataTablesModel JsonDeserialize(string jsondatas)
{
List <NameValuePair <string, string> > list = JsonConvert.DeserializeObject <List <NameValuePair <string, string> > >(jsondatas);
DataTablesModel model = new DataTablesModel();
PropertyInfo[] properties = model.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (NameValuePair <string, string> info in list)
{
foreach (PropertyInfo item in properties)
{
if (info.Name.Equals(item.Name))
{
item.SetValue(model, Convert.ChangeType(info.Value, item.PropertyType), null);
}
}
}
return(model);
}
public async Task <DataTablesResponse> GetCurrencies(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.Currency
.AsNoTracking()
.Where(x => x.IsEnabled)
.Select(x => new
{
Id = x.Id,
Currency = x.Symbol,
Amount = x.Name,
Type = x.Type
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
/// <summary>
/// Function call ajax to load list User
/// </summary>
/// <param name="model">DataTablesModel</param>
/// <param name="condition">Condition</param>
/// <returns>Json User List</returns>
public ActionResult Search(DataTablesModel model, Condition condition, string hdnOrderBy, string hdnOrderType, string TAB_ID)
{
if (Request.IsAjaxRequest())
{
if (ModelState.IsValid)
{
var pageInfo = this._service.Search(model, condition, GetLoginUser().CompanyCode);
if (!String.IsNullOrEmpty(TAB_ID)) // if current screen is User list
{
Session[Constant.SESSION_SEARCH_RESULT + TAB_ID] = this._service.GetListUser(condition, GetLoginUser().CompanyCode, hdnOrderBy, hdnOrderType);
}
var result = Json(
new
{
sEcho = model.sEcho,
iTotalRecords = pageInfo.TotalItems,
iTotalDisplayRecords = pageInfo.TotalItems,
aaData = (from t in pageInfo.Items
select new object[]
{
t.user_sys_id,
t.peta_rn,
HttpUtility.HtmlEncode(t.display_name),
HttpUtility.HtmlEncode(t.display_name_group),
HttpUtility.HtmlEncode(t.display_name_position),
t.base_unit_cost != null ? t.base_unit_cost.Value.ToString("#,##0") : "-",
(t.entry_date != null)?t.entry_date.Value.ToString("yyyy/MM/dd") : "",
(t.mail_address_1 != null)? HttpUtility.HtmlEncode(t.mail_address_1) : "",
t.is_active,
(t.upd_date != null)?t.upd_date.ToString("yyyy/MM/dd HH:mm") : "",
(t.user_update != null)? HttpUtility.HtmlEncode(t.user_update) : "",
t.user_sys_id,
t.del_flg,
t.group_id
}).ToList()
});
SaveRestoreData(condition);
return(result);
}
}
return(new EmptyResult());
}
public async Task <DataTablesResponse> GetPayoutHistory(string userId, DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var currentUser = new Guid(userId);
var query = context.Transfer
.AsNoTracking()
.Where(x => x.TransferType == TransferType.ShareDividend && x.ToUserId == currentUser)
.Select(transfer => new
{
Id = transfer.Id,
Currency = transfer.Currency.Symbol,
Amount = transfer.Amount,
Timestamp = transfer.Timestamp
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetTransfers(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.Transfer
.AsNoTracking()
.Select(x => new
{
Id = x.Id,
Sender = x.User.UserName,
Receiver = x.ToUser.UserName,
Amount = x.Amount,
Type = x.TransferType,
Timestamp = x.Timestamp
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetTradePairs(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.TradePair
.AsNoTracking()
.Select(x => new
{
Id = x.Id,
Name = string.Concat(x.Currency1.Symbol, "_", x.Currency2.Symbol),
Currency = x.Currency1.Name,
BaseCurrency = x.Currency2.Name,
Status = x.Status,
StatusMessage = x.StatusMessage,
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetReadyTransactions(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.NzdtTransaction
.AsNoTracking()
.Where(x => x.TransactionStatus == NzdtTransactionStatus.ReadyForProcessing)
.Select(x => new
{
Id = x.Id,
UniqueId = x.UniqueId,
Amount = x.Amount,
UserName = x.User.UserName,
CreatedOn = x.CreatedOn
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetTradePairUserOpenOrdersDataTable(DataTablesModel model, int tradePairId, string userId)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.Trade
.Where(x => x.TradePairId == tradePairId && x.UserId == userId && (x.Status == TradeStatus.Partial || x.Status == TradeStatus.Pending))
.Select(x => new TradeOpenOrderModel
{
Id = x.Id,
Timestamp = x.Timestamp,
TradeType = x.TradeType,
Rate = x.Rate,
Amount = x.Amount,
Remaining = x.Remaining,
Status = x.Status
}).OrderByDescending(x => x.Id).Take(500);
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> GetChatMessages(DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.ChatMessages
.AsNoTracking()
.Select(message => new
{
message.Id,
message.User.ChatHandle,
message.User.UserName,
message.Message,
message.Timestamp,
message.IsEnabled
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetIncompleteWithdrawals(DataTablesModel model)
{
var newest = DateTime.Now.AddHours(-2.0);
List <int> pendingApprovalIds = null;
using (var approvalContext = DataContextFactory.CreateReadOnlyContext())
{
var approvals = await approvalContext.ApprovalQueue
.Where(a => a.Type == ApprovalQueueType.WithdrawalReprocessing && a.Status == ApprovalQueueStatus.Pending)
.Select(a => a)
.ToListNoLockAsync().ConfigureAwait(false);
pendingApprovalIds = approvals.Select(a =>
{
int id;
bool success = int.TryParse(JsonConvert.DeserializeObject <ReprocessingApprovalDataModel>(a.Data).WithdrawalId, out id);
return(new { success, id });
})
.Where(x => x.success)
.Select(x => x.id).ToList();
}
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.Withdraw
.AsNoTracking()
.Where(w => w.Status == Enums.WithdrawStatus.Processing && w.Confirmed <= newest && !pendingApprovalIds.Contains(w.Id))
.Select(x => new
{
Id = x.Id,
UserName = x.User.UserName,
Currency = x.Currency.Symbol,
Amount = x.Amount,
Address = x.Address,
Confirmed = x.Confirmed,
RetryCount = x.RetryCount
});
var result = await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false);
return(result);
}
}
public async Task <DataTablesResponse> GetTransferDataTable(DataTablesModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.TransferHistory
.Select(transfer => new TransferModel
{
Id = transfer.Id,
Symbol = transfer.Currency.Symbol,
Amount = transfer.Amount,
Fee = transfer.Fee,
TransferType = transfer.TransferType,
Sender = transfer.User.UserName,
Receiver = transfer.ToUser.UserName,
TimeStamp = transfer.Timestamp
});
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> GetWithdrawals(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.Withdraw
.AsNoTracking()
.Where(x => x.CurrencyId == Cryptopia.Enums.Constant.NZDT_ID)
.Select(x => new
{
Id = x.Id,
UserName = x.User.UserName,
Amount = x.Amount,
Status = x.Status.ToString(),
Timestamp = x.TimeStamp,
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
/// <summary>
/// Display infomation Sale project list by customer
/// </summary>
/// <param name="model">model</param>
/// <param name="condition">condition</param>
/// <param name="TAB_ID">Tab id</param>
/// <returns>Json Sale Project List By Customer</returns>
public ActionResult SaleProjectListByCustomer(DataTablesModel model, ConditionSaleProject condition, string TAB_ID)
{
if (Request.IsAjaxRequest())
{
var pageInfo = this.service.SearchProjectByCustomer(model, GetLoginUser().CompanyCode, condition);
Session[Constant.SESSION_SEARCH_RESULT + TAB_ID] = pageInfo.Items;
decimal totalSales = 0;
decimal totalProfit = 0;
foreach (var data in pageInfo.Items)
{
totalSales += data.total_sales;
totalProfit += data.gross_profit;
}
var result = Json(
new
{
sEcho = model.sEcho,
iTotalRecords = pageInfo.TotalItems,
iTotalDisplayRecords = pageInfo.TotalItems,
aaData = (from t in pageInfo.Items
select new object[]
{
t.project_sys_id,
t.peta_rn,
HttpUtility.HtmlEncode(t.display_name),
HttpUtility.HtmlEncode(t.contract_type),
t.total_sales.ToString("#,##0") + "円",
(totalSales > 0 ? (t.total_sales / totalSales * 100) : 0).ToString("#,##0.00") + "%",
t.gross_profit.ToString("#,##0") + "円",
t.total_sales == 0 ? "0.00%" : (t.gross_profit_rate * 100).ToString("#,##0.00") + "%"
}).ToList(),
totalSales = totalSales.ToString("#,##0") + "円",
totalProfit = totalProfit.ToString("#,##0") + "円"
},
JsonRequestBehavior.AllowGet);
return(result);
}
return(new EmptyResult());
}
public async Task <DataTablesResponse> GetMarketHistory(string userId, DataTablesModel model)
{
try
{
var currentUser = new Guid(userId);
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = from marketItem in context.MarketItem
from winningBid in
context.MarketItemBid.Where(b => b.MarketItemId == marketItem.Id && b.IsWinningBid).DefaultIfEmpty()
from sellerfeedback in
context.MarketFeedback.Where(b => b.MarketItemId == marketItem.Id && b.ReceiverUserId == currentUser)
.DefaultIfEmpty()
from buyerfeedback in
context.MarketFeedback.Where(b => b.MarketItemId == marketItem.Id && b.ReceiverUserId == winningBid.UserId)
.DefaultIfEmpty()
where
marketItem.Status == Enums.MarketItemStatus.Complete &&
(marketItem.UserId == currentUser || winningBid.UserId == currentUser)
orderby marketItem.Id descending
select new
{
Id = marketItem.Id,
Title = marketItem.Title,
Type = marketItem.Type,
Buyer = winningBid.User.UserName,
BuyersRating = buyerfeedback != null?buyerfeedback.Rating.ToString() : string.Empty,
Seller = marketItem.User.UserName,
SellersRating = sellerfeedback != null?sellerfeedback.Rating.ToString() : string.Empty,
Status = marketItem.Status,
CloseDate = marketItem.CloseDate,
Created = marketItem.Created
};
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
catch (Exception)
{
return(model.GetEmptyDataTableResult());
}
}
public async Task <DataTablesResponse> GetClosedTickets(DataTablesModel model)
{
using (var context = DataContextFactory.CreateReadOnlyContext())
{
var query = context.SupportTicket
.AsNoTracking()
.Where(t => t.Status == Enums.SupportTicketStatus.Closed)
.Select(ticket => new
{
Id = ticket.Id,
UserName = ticket.User.UserName,
Category = ticket.Category,
Title = ticket.Title,
Status = ticket.Status,
LastUpdate = ticket.LastUpdate,
Opened = ticket.Created
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetUserTradePairTradeHistoryDataTable(DataTablesModel model, int tradePairId, string userId)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.TradeHistory
.Where(x => x.TradePairId == tradePairId && x.UserId == userId)
.Select(x => new TradeHistoryModel
{
Amount = x.Amount,
Fee = x.Fee,
Id = x.Id,
IsApi = x.IsApi,
Rate = x.Rate,
Timestamp = x.Timestamp,
TradeHistoryType = x.ToUserId == userId ? TradeType.Sell : TradeType.Buy,
TradePair = x.TradePair.Currency1.Symbol + "/" + x.TradePair.Currency2.Symbol
}).OrderByDescending(x => x.Id);
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public static DataTablesParam ToDataTablesParam(this DataTablesModel model)
{
return(new DataTablesParam
{
iDisplayStart = model.iDisplayStart,
iDisplayLength = model.iDisplayLength,
iColumns = model.iColumns,
sSearch = model.sSearch,
bEscapeRegex = model.bEscapeRegex,
iSortingCols = model.iSortingCols,
sEcho = model.sEcho,
sColumnNames = model.sColumnNames,
bSortable = model.bSortable,
bSearchable = model.bSearchable,
sSearchValues = model.sSearchValues,
iSortCol = model.iSortCol,
sSortDir = model.sSortDir,
bEscapeRegexColumns = model.bEscapeRegexColumns
});
}
public async Task <DataTablesResponse> GetDepositDataTable(DataTablesModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.Deposit
.Select(deposit =>
new DepositModel
{
Amount = deposit.Amount,
Confirmations = deposit.Confirmations,
Currency = deposit.Currency.Name,
Id = deposit.Id,
Symbol = deposit.Currency.Symbol,
TimeStamp = deposit.TimeStamp,
Txid = deposit.Txid,
DepositStatus = deposit.DepositStatus
});
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> GetApprovals(DataTablesModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.ApprovalQueue
.Select(x => new
{
Id = x.Id,
Type = x.Type,
User = x.DataUser.UserName,
RequestBy = x.RequestUser.UserName,
Requested = x.Created,
Status = x.Status,
Approved = x.Approved,
ApprovedBy = x.ApproveUser == null ? string.Empty : x.ApproveUser.UserName,
}).OrderByDescending(x => x.Id);
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> AdminGetSupportTicketDataTable(DataTablesModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.SupportTicket
.Include(s => s.User)
.Include(s => s.Category)
.Select(ticket => new SupportTicketDataModel
{
Category = ticket.Category.Name,
Id = ticket.Id,
Status = ticket.Status,
Title = ticket.Title,
UserName = ticket.User.UserName,
Created = ticket.Created,
LastUpdate = ticket.LastUpdate
});
return(await query.GetDataTableResultNoLockAsync(model));
}
}
//[PrincipalPermission(SecurityAction.Demand, Role = SecurityRoles.Administrator)]
public async Task <DataTablesResponse> GetUserDataTable(DataTablesModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.Users
.Select(x => new UserModel
{
UserId = x.Id,
UserName = x.UserName,
Email = x.Email,
IsLocked = x.LockoutEndDateUtc.HasValue && x.LockoutEndDateUtc > DateTime.UtcNow,
IsEnabled = x.IsEnabled,
IsTradeEnabled = x.IsTradeEnabled,
IsWithdrawEnabled = x.IsWithdrawEnabled,
IsTransferEnabled = x.IsTransferEnabled
});
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> GetTradeHistoryDataTable(DataTablesModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var query = context.TradeHistory
.Where(x => x.TradePair.Status != TradePairStatus.Closed)
.Select(x => new TradeHistoryModel
{
Amount = x.Amount,
Fee = x.Fee,
Id = x.Id,
IsApi = x.IsApi,
Rate = x.Rate,
Timestamp = x.Timestamp,
TradeHistoryType = x.TradeHistoryType,
TradePair = x.TradePair.Currency1.Symbol + "/" + x.TradePair.Currency2.Symbol
});
return(await query.GetDataTableResultNoLockAsync(model));
}
}
public async Task <DataTablesResponse> AdminGetTransfers(string userId, DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.Transfer
.AsNoTracking()
.Where(x => x.TransferType != TransferType.Reward && x.TransferType != TransferType.Tip)
.Select(transfer => new
{
Id = transfer.Id,
Currency = transfer.Currency.Symbol,
Amount = transfer.Amount,
Sender = transfer.User.UserName,
Receiver = transfer.ToUser.UserName,
Type = transfer.TransferType,
Timestamp = transfer.Timestamp
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> GetDeposits(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.Deposit
.AsNoTracking()
.Select(x => new
{
Id = x.Id,
UserName = x.User.UserName,
Amount = x.Amount,
Status = x.Status,
Type = x.Type.ToString(),
TxId = x.Txid,
Conf = x.Confirmations,
Timestamp = x.TimeStamp
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
public async Task <DataTablesResponse> AdminGetHistory(DataTablesModel model)
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var query = context.ReferralInfo
.AsNoTracking()
.Select(x => new
{
x.Id,
x.RoundId,
x.User.UserName,
x.RefCount,
x.TradeFeeAmount,
x.Status,
x.TransferId,
x.LastUpdate
});
return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false));
}
}
