Example #1
0
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
}
Example #2
0
// 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)
	}
}
Example #3
0
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)
	}
}
Example #4
0
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
}
Example #5
0
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)
	}
}
Example #6
0
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
}
Example #7
0
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
}
Example #8
0
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)
	}
}
Example #9
0
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)))
	}
}
Example #10
0
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)
	}
}
Example #11
0
// 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
}