func SaveAPIKey(tx *db.ModelTx, apiKey *APIKey) *APIKey {
_, err := tx.Exec(
`INSERT INTO auth_api_key (`+APIKeyModel.FieldsInsert+`)
VALUES (`+APIKeyModel.Placeholders+`)`,
apiKey,
)
if err != nil {
panic(err)
}
return apiKey
}
// NOTE: This should be called in a serializable transaction to ensure that
// the user's balance gets updated in a safe manner.
func UpdateDepositSetStatus(tx *db.ModelTx, depositId int64, status int32) {
updated := time.Now().Unix()
_, err := tx.Exec(
`UPDATE account_deposit
SET status=?, updated=?
WHERE id=?`,
status, updated, depositId,
)
if err != nil {
panic(err)
}
}
func UpdatePriceLog(tx *db.ModelTx, plog *PriceLog) {
_, err := tx.Exec(
`UPDATE exchange_price_log
SET low=?, high=?, close=?, ask_volume=?, bid_volume=?
WHERE market=? AND interval=? AND time=?`,
plog.Low, plog.High, plog.Close, plog.AskVolume, plog.BidVolume,
plog.Market, plog.Interval, plog.Time,
)
if err != nil {
panic(err)
}
}
func SavePriceLog(tx *db.ModelTx, plog *PriceLog) *PriceLog {
err := tx.QueryRow(
`INSERT INTO exchange_price_log (`+PriceLogModel.FieldsInsert+`)
VALUES (`+PriceLogModel.Placeholders+`)
RETURNING id`,
plog,
).Scan(&plog.Id)
if err != nil {
panic(err)
}
return plog
}
func UpdateOrder(tx *db.ModelTx, order *Order) {
order.Updated = time.Now().Unix()
_, err := tx.Exec(
`UPDATE exchange_order
SET status=?, filled=?, basis_filled=?, updated=?
WHERE id=?`,
order.Status, order.Filled, order.BasisFilled, order.Updated, order.Id,
)
if err != nil {
panic(err)
}
}
func SaveTrade(tx *db.ModelTx, trade *Trade) *Trade {
if trade.Time == 0 {
trade.Time = time.Now().Unix()
}
err := tx.QueryRow(
`INSERT INTO exchange_trade (`+TradeModel.FieldsInsert+`)
VALUES (`+TradeModel.Placeholders+`)
RETURNING id`,
trade,
).Scan(&trade.Id)
if err != nil {
panic(err)
}
return trade
}
func SaveOrder(tx *db.ModelTx, order *Order) *Order {
if order.Time == 0 {
order.Time = time.Now().Unix()
}
err := tx.QueryRow(
`INSERT INTO exchange_order (`+OrderModel.FieldsInsert+`)
VALUES (`+OrderModel.Placeholders+`)
RETURNING id`,
order,
).Scan(&order.Id)
if err != nil {
panic(err)
}
return order
}
func SaveOrUpdatePriceLog(tx *db.ModelTx, plog *PriceLog) {
var exists int
err := tx.QueryRow(
`SELECT 1 FROM exchange_price_log
WHERE market=? AND interval=? AND time=?`,
plog.Market, plog.Interval, plog.Time,
).Scan(&exists)
switch db.GetErrorType(err) {
case sql.ErrNoRows:
SavePriceLog(tx, plog)
case nil:
UpdatePriceLog(tx, plog)
default:
panic(err)
}
}
func UpdateWithdrawals(tx *db.ModelTx, wthIds []interface{}, oldStatus, newStatus int, wtxId int64) {
if len(wthIds) == 0 {
return
}
res, err := tx.Exec(
`UPDATE account_withdrawal
SET status=?, wtx_id=?, updated=?
WHERE status=? AND id IN (`+Placeholders(len(wthIds))+`)`,
append([]interface{}{newStatus, wtxId, time.Now().Unix(), oldStatus}, wthIds...)...,
)
if err != nil {
panic(err)
}
count, err := res.RowsAffected()
if err != nil {
panic(err)
}
if int(count) != len(wthIds) {
panic(NewError("Unexpected affected rows count: %v Expected %v", count, len(wthIds)))
}
}
func UpdatePaymentsSpent(tx *db.ModelTx, paymentIds []interface{}, oldStatus, newStatus int, wtxId int64) {
if len(paymentIds) == 0 {
return
}
now := time.Now().Unix()
res, err := tx.Exec(
`UPDATE payment
SET spent=?, wtx_id=?, updated=?
WHERE spent=? AND id IN (`+Placeholders(len(paymentIds))+`)`,
append([]interface{}{newStatus, wtxId, now, oldStatus}, paymentIds...)...,
)
if err != nil {
panic(err)
}
count, err := res.RowsAffected()
if int(count) != len(paymentIds) {
panic(NewError("Unexpected affected rows count: %v Expected %v", count, len(paymentIds)))
}
if err != nil {
panic(err)
}
}
// Adds or subtracts an amount to a user's wallet.
// nonnegative: panics with INSUFFICIENT_FUNDS_ERROR if resulting balance is negative.
// Returns the new balance
func UpdateBalanceByWallet(tx *db.ModelTx, userId int64, wallet string, coin string, diff int64, nonnegative bool) *Balance {
var balance Balance
// Get existing balance.
err := tx.QueryRow(
`SELECT `+BalanceModel.FieldsSimple+`
FROM account_balance WHERE
user_id=? AND wallet=? AND coin=?`,
userId, wallet, coin,
).Scan(&balance)
// Ensure nonnegative
if nonnegative && balance.Amount+diff < 0 {
panic(INSUFFICIENT_FUNDS_ERROR)
}
// First time balance?
if err == sql.ErrNoRows {
// Create new balance
balance := Balance{UserId: userId, Wallet: wallet, Coin: coin, Amount: diff}
SaveBalance(tx, &balance)
return &balance
}
// Update balance
balance.Amount += diff
_, err = tx.Exec(
`UPDATE account_balance
SET amount=?
WHERE user_id=? AND wallet=? AND coin=?`,
balance.Amount, userId, wallet, coin,
)
if err != nil {
panic(err)
}
return &balance
}