func (c *Controller) EWithdraw() (string, error) { if c.SessUserId == 0 { return "", errors.New(c.Lang["sign_up_please"]) } c.r.ParseForm() currencyId := utils.StrToInt64(c.r.FormValue("currency_id")) if !utils.CheckInputData(c.r.FormValue("amount"), "amount") { return "", fmt.Errorf("incorrect amount") } method := c.r.FormValue("method") if !utils.CheckInputData(method, "method") { return "", fmt.Errorf("incorrect method") } account := c.r.FormValue("account") if !utils.CheckInputData(account, "account") { return "", fmt.Errorf("incorrect account") } amount := utils.StrToFloat64(c.r.FormValue("amount")) curTime := utils.Time() // нужно проверить, есть ли нужная сумма на счету юзера userAmount := utils.EUserAmountAndProfit(c.SessUserId, currencyId) if userAmount < amount { return "", fmt.Errorf("%s (%f<%f)", c.Lang["not_enough_money"], userAmount, amount) } if method != "Dcoin" && currencyId < 1000 { return "", fmt.Errorf("incorrect method") } err := userLock(c.SessUserId) if err != nil { return "", utils.ErrInfo(err) } err = c.ExecSql(`UPDATE e_wallets SET amount = ?, last_update = ? WHERE user_id = ? AND currency_id = ?`, userAmount-amount, curTime, c.SessUserId, currencyId) if err != nil { return "", utils.ErrInfo(err) } var commission float64 if method == "Dcoin" { commission = utils.StrToFloat64(c.EConfig["dc_commission"]) } else if method == "Perfect-money" { commission = utils.StrToFloat64(c.EConfig["pm_commission"]) } wdAmount := utils.ClearNull(utils.Float64ToStr(amount*(1-commission/100)), 2) err = c.ExecSql(`INSERT INTO e_withdraw (open_time, user_id, currency_id, account, amount, wd_amount, method) VALUES (?, ?, ?, ?, ?, ?, ?)`, curTime, c.SessUserId, currencyId, account, amount, wdAmount, method) if err != nil { return "", utils.ErrInfo(err) } userUnlock(c.SessUserId) return utils.JsonAnswer(c.Lang["request_is_created"], "success").String(), nil }
func (c *Controller) ESaveOrder() (string, error) { if c.SessUserId == 0 { return "", errors.New(c.Lang["sign_up_please"]) } c.r.ParseForm() sellCurrencyId := utils.StrToInt64(c.r.FormValue("sell_currency_id")) buyCurrencyId := utils.StrToInt64(c.r.FormValue("buy_currency_id")) amount := utils.StrToFloat64(c.r.FormValue("amount")) sellRate := utils.StrToFloat64(c.r.FormValue("sell_rate")) orderType := c.r.FormValue("type") // можно ли торговать такими валютами checkCurrency, err := c.Single("SELECT count(id) FROM e_currency WHERE id IN (?, ?)", sellCurrencyId, buyCurrencyId).Int64() if err != nil { return "", utils.ErrInfo(err) } if checkCurrency != 2 { return "", errors.New("Currency error") } if orderType != "sell" && orderType != "buy" { return "", errors.New("Type error") } if amount == 0 { return "", errors.New(c.Lang["amount_error"]) } if amount < 0.001 && sellCurrencyId < 1000 { return "", errors.New(strings.Replace(c.Lang["save_order_min_amount"], "[amount]", "0.001", -1)) } if sellRate < 0.0001 { return "", errors.New(strings.Replace(c.Lang["save_order_min_price"], "[price]", "0.0001", -1)) } reductionLock, err := utils.EGetReductionLock() if err != nil { return "", utils.ErrInfo(err) } if reductionLock > 0 { return "", errors.New(strings.Replace(c.Lang["creating_orders_unavailable"], "[minutes]", "30", -1)) } // нужно проверить, есть ли нужная сумма на счету юзера userAmountAndProfit := utils.EUserAmountAndProfit(c.SessUserId, sellCurrencyId) if userAmountAndProfit < amount { return "", errors.New(c.Lang["not_enough_money"] + " (" + utils.Float64ToStr(userAmountAndProfit) + "<" + utils.Float64ToStr(amount) + ")" + strings.Replace(c.Lang["add_funds_link"], "[currency]", "USD", -1)) } err = NewForexOrder(c.SessUserId, amount, sellRate, sellCurrencyId, buyCurrencyId, orderType, utils.StrToMoney(c.EConfig["commission"])) if err != nil { return "", utils.ErrInfo(err) } else { return utils.JsonAnswer(c.Lang["order_created"], "success").String(), nil } return ``, nil }
func (p *Parser) NewPromisedAmount() error { addSqlNames := "" addSqlValues := "" if p.BlockData.BlockId > 27134 { paymentSystemsIds := strings.Split(string(p.TxMaps.String["payment_systems_ids"]), ",") for i, v := range paymentSystemsIds { addSqlNames += fmt.Sprintf("ps%d,", (i + 1)) addSqlValues += fmt.Sprintf("%s,", v) } } //добавляем promised_amount в БД err := p.ExecSql(` INSERT INTO promised_amount ( user_id, amount, currency_id, ` + addSqlNames + ` video_type, video_url_id, votes_start_time ) VALUES ( ` + utils.Int64ToStr(p.TxMaps.Int64["user_id"]) + `, ` + utils.Float64ToStr(p.TxMaps.Money["amount"]) + `, ` + utils.Int64ToStr(p.TxMaps.Int64["currency_id"]) + `, ` + addSqlValues + ` '` + p.TxMaps.String["video_type"] + `', '` + p.TxMaps.String["video_url_id"] + `', ` + utils.Int64ToStr(p.BlockData.Time) + ` )`) if err != nil { return p.ErrInfo(err) } // проверим, не наш ли это user_id myUserId, myBlockId, myPrefix, _, err := p.GetMyUserId(p.TxMaps.Int64["user_id"]) if err != nil { return err } if p.TxUserID == myUserId && myBlockId <= p.BlockData.BlockId { // Удалим, т.к. попало в блок err = p.ExecSql("DELETE FROM "+myPrefix+"my_promised_amount WHERE amount = ? AND currency_id = ?", p.TxMaps.Money["amount"], p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } } return nil }
func (c *Controller) getMyWallets() ([]map[string]string, error) { var myWallets []map[string]string eCurrency, err := c.GetAll(`SELECT name as currency_name, id FROM e_currency ORDER BY sort_id ASC`, -1) if err != nil { return myWallets, utils.ErrInfo(err) } for _, data := range eCurrency { wallet, err := c.OneRow("SELECT * FROM e_wallets WHERE user_id = ? AND currency_id = ?", c.SessUserId, data["id"]).String() if err != nil { return myWallets, utils.ErrInfo(err) } if len(wallet) > 0 { amount := utils.StrToFloat64(wallet["amount"]) profit, err := utils.DB.CalcProfitGen(utils.StrToInt64(wallet["currency_id"]), amount, 0, utils.StrToInt64(wallet["last_update"]), utils.Time(), "wallet") if err != nil { return myWallets, utils.ErrInfo(err) } myWallets = append(myWallets, map[string]string{"amount": utils.ClearNull(utils.Float64ToStr(amount+profit), 2), "currency_name": data["currency_name"], "last_update": wallet["last_update"]}) } } return myWallets, nil }
func (c *Controller) EMain() (string, error) { var err error dcCurrencyId := utils.StrToInt64(c.Parameters["dc_currency_id"]) currencyId := utils.StrToInt64(c.Parameters["currency_id"]) if dcCurrencyId == 0 { dcCurrencyId = 72 } if currencyId == 0 { currencyId = 1001 } // все валюты, с которыми работаем currencyList, err := utils.EGetCurrencyList() if err != nil { return "", utils.ErrInfo(err) } log.Debug("%v", currencyList) // работаем только с теми валютами, которые есть у нас в списке if len(currencyList[dcCurrencyId]) == 0 || len(currencyList[currencyId]) == 0 { return "", utils.ErrInfo("incorrect currency") } // пары валют для меню currencyListPair, err := eGetCurrencyPair() if err != nil { return "", utils.ErrInfo(err) } dcCurrency := currencyList[dcCurrencyId] currency := currencyList[currencyId] // история сделок var tradeHistory []map[string]string rows, err := c.Query(c.FormatQuery(` SELECT sell_currency_id, sell_rate, amount, time FROM e_trade WHERE ((sell_currency_id = ? AND buy_currency_id = ?) OR (sell_currency_id = ? AND buy_currency_id = ?)) AND main = 1 ORDER BY time DESC LIMIT 40 `), dcCurrencyId, currencyId, currencyId, dcCurrencyId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var sellCurrencyId, eTime int64 var sellRate, amount float64 err = rows.Scan(&sellCurrencyId, &sellRate, &amount, &eTime) if err != nil { return "", utils.ErrInfo(err) } var eType string var eAmount float64 var eTotal float64 if sellCurrencyId == dcCurrencyId { eType = "sell" sellRate = 1 / sellRate eAmount = amount eTotal = amount * sellRate } else { eType = "buy" eAmount = amount * (1 / sellRate) eTotal = amount } t := time.Unix(eTime, 0) tradeHistory = append(tradeHistory, map[string]string{"Time": t.Format(c.TimeFormat), "Type": eType, "SellRate": utils.ClearNull(utils.Float64ToStr(sellRate), 4), "Amount": utils.ClearNull(utils.Float64ToStr(eAmount), 4), "Total": utils.ClearNull(utils.Float64ToStr(eTotal), 4)}) } // активные ордеры на продажу var orders eOrders rows, err = c.Query(c.FormatQuery(` SELECT sell_rate, amount FROM e_orders WHERE (sell_currency_id = ? AND buy_currency_id = ?) AND empty_time = 0 AND del_time = 0 AND amount > 0 ORDER BY sell_rate DESC LIMIT 100 `), dcCurrencyId, currencyId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() // мин. цена покупки var buyMin float64 for rows.Next() { var sellRate, amount float64 err = rows.Scan(&sellRate, &amount) if err != nil { return "", utils.ErrInfo(err) } if orders.Sell == nil { orders.Sell = make(map[float64]float64) } sellRate = utils.ClearNullFloat64(1/sellRate, 6) orders.Sell[sellRate] = utils.ClearNullFloat64(orders.Sell[sellRate]+amount, 6) if buyMin == 0 { buyMin = sellRate } else if sellRate < buyMin { buyMin = sellRate } } keys := []float64{} for k := range orders.Sell { keys = append(keys, k) } sort.Float64s(keys) var eOrdersSell []map[string]float64 for _, k := range keys { eOrdersSell = append(eOrdersSell, map[string]float64{"sell_rate": k, "amount": orders.Sell[k]}) } // активные ордеры на покупку rows, err = c.Query(c.FormatQuery(` SELECT sell_rate, amount FROM e_orders WHERE (sell_currency_id = ? AND buy_currency_id = ?) AND empty_time = 0 AND del_time = 0 AND amount > 0 ORDER BY sell_rate ASC LIMIT 100 `), currencyId, dcCurrencyId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() // мин. цена продажи var sellMax float64 for rows.Next() { var sellRate, amount float64 err = rows.Scan(&sellRate, &amount) if err != nil { return "", utils.ErrInfo(err) } if orders.Buy == nil { orders.Buy = make(map[float64]float64) } sellRate = utils.ClearNullFloat64(sellRate, 6) orders.Buy[sellRate] = utils.ClearNullFloat64(orders.Buy[sellRate]+amount*(1/sellRate), 6) if sellMax == 0 { sellMax = sellRate } else if sellRate < sellMax { sellMax = sellRate } } var keysR sort.Float64Slice for k := range orders.Buy { keysR = append(keysR, k) } sort.Sort(sort.Reverse(keysR)) var eOrdersBuy []map[string]float64 for _, k := range keysR { eOrdersBuy = append(eOrdersBuy, map[string]float64{"sell_rate": k, "amount": orders.Buy[k]}) } // комиссия commission := c.EConfig["commission"] commissionText := strings.Replace(c.Lang["commission_text"], "[commission]", commission, -1) // кол-во юзеров members, err := c.Single(`SELECT count(*) FROM e_users`).Int64() if err != nil { return "", utils.ErrInfo(err) } TemplateStr, err := makeTemplate("e_main", "eMain", &eMainPage{ Lang: c.Lang, Commission: commission, Members: members, SellMax: sellMax, BuyMin: buyMin, EOrdersSell: eOrdersSell, EOrdersBuy: eOrdersBuy, DcCurrency: dcCurrency, Currency: currency, DcCurrencyId: dcCurrencyId, UserId: c.SessUserId, TradeHistory: tradeHistory, CurrencyId: currencyId, CommissionText: commissionText, CurrencyListPair: currencyListPair, CurrencyList: currencyList}) if err != nil { return "", utils.ErrInfo(err) } return TemplateStr, nil }
func (c *Controller) EMyFinance() (string, error) { var err error if c.SessUserId == 0 { return `<script language="javascript"> window.location.href = "` + c.EURL + `"</script>If you are not redirected automatically, follow the <a href="` + c.EURL + `">` + c.EURL + `</a>`, nil } confirmations := c.EConfig["confirmations"] currencyList, err := utils.EGetCurrencyList() // счет, куда юзеры должны слать DC mainDcAccount := c.EConfig["main_dc_account"] currency := make(map[string]map[string]string) // валюты, по которым идут торги на бирже //var myWallets []map[string]string eCurrency, err := c.GetAll(`SELECT name, id FROM e_currency ORDER BY sort_id ASC`, -1) if err != nil { return "", utils.ErrInfo(err) } for _, data := range eCurrency { wallet, err := c.OneRow("SELECT * FROM e_wallets WHERE user_id = ? AND currency_id = ?", c.SessUserId, data["id"]).String() if err != nil { return "", utils.ErrInfo(err) } if len(wallet) > 0 { amount := utils.StrToFloat64(wallet["amount"]) profit, err := utils.DB.CalcProfitGen(utils.StrToInt64(wallet["currency_id"]), amount, 0, utils.StrToInt64(wallet["last_update"]), utils.Time(), "wallet") if err != nil { return "", utils.ErrInfo(err) } wallet["amount"] = utils.Float64ToStr(amount + profit) } else { wallet["amount"] = "0" } currency[data["id"]] = make(map[string]string) currency[data["id"]]["amount"] = wallet["amount"] currency[data["id"]]["name"] = data["name"] if utils.StrToInt64(data["id"]) < 1000 { //DC currency[data["id"]]["input"] = strings.Replace(c.Lang["dc_deposit_text"], "[dc_currency]", data["name"], -1) currency[data["id"]]["input"] = strings.Replace(currency[data["id"]]["input"], "[account]", mainDcAccount, -1) currency[data["id"]]["input"] = strings.Replace(currency[data["id"]]["input"], "[user_id]", utils.Int64ToStr(c.SessUserId), -1) currency[data["id"]]["input"] = strings.Replace(currency[data["id"]]["input"], "[confirmations]", confirmations, -1) } currency[data["id"]]["output"] = `<div class="pull-left"><h4>` + c.Lang["withdraw0"] + ` ` + data["name"] + `</h4> <table class="table_out"> <tbody> <tr> <td>` + c.Lang["your_dcoin_account"] + `:</td> <td class="form-inline"><input id="account-` + data["id"] + `" class="form-control col-xs-3" type="text"></td> </tr> <tr> <td>` + c.Lang["amount_to_withdrawal"] + `:</td> <td class="form-inline" style="line-height: 35px"><input id="amount-` + data["id"] + `" class="form-control col-xs-3" maxlength="15" type="text" onkeyup="calc_withdraw_amount(` + data["id"] + `, '0.1')" onchange="calc_withdraw_amount(` + data["id"] + `, '0.1')" style="margin-right:5px"> ` + data["name"] + `</td> </tr> <tr> <td>` + c.Lang["you_will_receive"] + `:</td> <td class="form-inline" style="line-height: 35px"><input disabled="" id="withdraw_amount-` + data["id"] + `" class="form-control col-xs-3" maxlength="15" type="text" style="margin-right:5px"> ` + data["name"] + `</td> </tr> </tbody></table><div id="alerts-` + data["id"] + `"></div><button class="btn btn-outline btn-primary" onclick="withdraw(` + data["id"] + `, 'Dcoin')">` + c.Lang["withdrawal"] + `</button> </div><div class="pull-left" style="margin-left:30px; margin-top:43px; border-left: 4px solid #ccc; padding:7px 7px; width:400px">` dcWithdrawText := strings.Replace(c.Lang["dc_withdraw_text"], "[min_amount]", "5", -1) dcWithdrawText = strings.Replace(dcWithdrawText, "[currency]", data["name"], -1) currency[data["id"]]["output"] += dcWithdrawText + `</div>` } if currency["1001"] == nil { currency["1001"] = make(map[string]string) } currency["1001"]["name"] = "USD" currency["1001"]["input"] = `<div class="pull-left"><h4>` + c.Lang["deposit0"] + ` USD</h4> <select id="ps_select" class="form-control"> <option value="pm">Perfect Money</option> <option value="ik">Mobile, Yandex</option> <option value="payeer">BTC</option> </select> <div style="display:block" id="pm_form"> <form action="https://perfectmoney.is/api/step1.asp" method="POST"> <input type="hidden" name="PAYEE_ACCOUNT" value="` + c.EConfig["pm_id"] + `"> <input type="hidden" name="PAYEE_NAME" value="Dcoin"> <input type="hidden" name="PAYMENT_ID" value="` + utils.Int64ToStr(c.SessUserId) + `"> <input type="hidden" name="PAYMENT_UNITS" value="USD"> <input type="hidden" name="STATUS_URL" value="` + c.EURL + `ajax?controllerName=EGatePm"> <input type="hidden" name="PAYMENT_URL" value="` + c.EURL + `ajax?controllerName=ESuccess"> <input type="hidden" name="PAYMENT_URL_METHOD" value="LINK"> <input type="hidden" name="NOPAYMENT_URL" value="` + c.EURL + `ajax?controllerName=EFailure"> <input type="hidden" name="NOPAYMENT_URL_METHOD" value="LINK"> <input type="hidden" name="SUGGESTED_MEMO" value="Dcoins"> <input type="hidden" name="BAGGAGE_FIELDS" value=""> <table class="table_out"> <tbody> <tr> <td>` + c.Lang["amount_to_pay"] + `</td> <td class="form-inline" style="line-height: 35px;"><input name="PAYMENT_AMOUNT" class="form-control" type="text" style="margin-right:5px; width:120px"><input type="submit" value="` + c.Lang["deposit"] + `" class="btn btn-outline btn-success" name="PAYMENT_METHOD"></td> </tr> <tr> </tbody> </table> </form> </div> <div style="display:none" id="ik_form"> <form id="payment" name="payment" method="post" action="https://sci.interkassa.com/" enctype="utf-8"> <input type="hidden" name="ik_co_id" value="` + c.EConfig["ik_id"] + `" /> <input type="hidden" name="ik_pm_no" value="ik_pm_no" /> <input type="hidden" name="ik_cur" value="USD" /> <input type="hidden" name="ik_ia_u" value="` + c.EURL + `ajax?controllerName=EGateIk" /> <input type="hidden" name="ik_suc_u" value=""` + c.EURL + `ajax?controllerName=ESuccess" /> <input type="hidden" name="ik_fal_u" value="` + c.EURL + `ajax?controllerName=EFailure" /> <input type="hidden" name="ik_desc" value="` + utils.Int64ToStr(c.SessUserId) + `" /> <table class="table_out"> <tbody> <tr> <td>` + c.Lang["amount_to_pay"] + `</td> <td class="form-inline" style="line-height: 35px;"><input name="ik_am" class="form-control" type="text" style="margin-right:5px; width:120px"><input type="submit" value="` + c.Lang["deposit"] + `" class="btn btn-outline btn-success"></td> </tr> <tr> </tbody> </table> </form> </div> <script> $('#payeer_sign').bind('click', function () { $.post( 'ajax?controllerName=EPayeerSign', { m_orderid: $('input[name=m_orderid]').val(), m_desc: $('input[name=m_desc]').val(), m_amount: $('input[name=m_amount]').val() }, function (data) { console.log("data", data) $('input[name=m_sign]').val(data); $("#payeer_form_data").submit(); }); }); </script> <div style="display:none" id="payeer_form"> <form id="payeer_form_data" name="payment" method="post" action="https://payeer.com/merchant/" enctype="utf-8"> <input type="hidden" id="m_shop" name="m_shop" value="` + c.EConfig["payeer_id"] + `"> <input type="hidden" id="m_orderid" name="m_orderid" value="1234"> <input type="hidden" id="m_curr" name="m_curr" value="USD"> <input type="hidden" id="m_desc" name="m_desc" value="` + base64.StdEncoding.EncodeToString(utils.Int64ToByte(c.SessUserId)) + `"> <input type="hidden" id="m_sign" name="m_sign" value=""> <table class="table_out"> <tbody> <tr> <td>` + c.Lang["amount_to_pay"] + `</td> <td class="form-inline" style="line-height: 35px;"><input id="m_amount" name="m_amount" class="form-control" type="text" style="margin-right:5px; width:120px"><input id="payeer_sign" type="button" value="` + c.Lang["deposit"] + `" class="btn btn-outline btn-success"></td> </tr> <tr> </tbody> </table> </form> </div> </div>` currency["1001"]["output"] = `<div class="pull-left"><h4>` + c.Lang["withdraw0"] + ` USD</h4> <table class="table_out"> <tbody> <tr> <td>` + c.Lang["withdrawal_on_the_purse"] + `:</td> <td class="form-inline"><div class="form-group"><select class="form-control" style="width:300px"><option>Perfect Money [1.5%] [min 10 USD]</option></select></div></td> </tr> <tr> <td>` + c.Lang["purse"] + `:</td> <td class="form-inline" style="line-height: 35px;"><input id="account-1001" class="form-control" type="text" style="margin-right:5px; width:300px"></td> </tr> <tr> <td>` + c.Lang["amount_to_withdrawal"] + `:</td> <td class="form-inline" style="line-height: 35px;"><input id="amount-1001" class="form-control" type="text" onkeyup="calc_withdraw_amount(1001, '1.5')" onchange="calc_withdraw_amount(1001, '1.5')" style="margin-right:5px; width:300px"></td> </tr> <tr> <td>` + c.Lang["you_will_receive"] + `:</td> <td class="form-inline" style="line-height: 35px"><input disabled="" id="withdraw_amount-1001" class="form-control" type="text" style="margin-right:5px; width:300px"> </td> </tr> </tbody></table><div id="alerts-1001"></div><button class="btn btn-outline btn-primary" onclick="withdraw(1001, 'Perfect-money')">` + c.Lang["withdrawal"] + `</button> </div><div class="pull-left" style="margin-left:30px; margin-top:43px; border-left: 4px solid #ccc; padding:7px 7px; width:350px">` + c.Lang["withdrawal_within_hours"] + `</div>` types := map[string]string{"withdraw": c.Lang["withdraw0"], "adding_funds": c.Lang["deposit0"]} // история вывода средств myFinanceHistory_ := make(map[int64][]*EmyFinanceType) rows, err := c.Query(c.FormatQuery(` SELECT id, amount, wd_amount, close_time, currency_id, method, open_time FROM e_withdraw WHERE user_id = ? ORDER BY open_time DESC LIMIT 40 `), c.SessUserId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { Finance := new(EmyFinanceType) err = rows.Scan(&Finance.Id, &Finance.Amount, &Finance.WdAmount, &Finance.CloseTime, &Finance.CurrencyId, &Finance.Method, &Finance.OpenTime) if err != nil { return "", utils.ErrInfo(err) } Finance.Ftype = types["withdraw"] Finance.Amount = Finance.WdAmount Finance.AddTime = Finance.OpenTime if Finance.CloseTime == 0 { Finance.Status = c.Lang["in_process"] } else { t := time.Unix(Finance.CloseTime, 0) timeFormated := t.Format(c.TimeFormat) Finance.Status = `<span class="text-success"><strong>` + c.Lang["ready"] + `</strong></span> (` + timeFormated + `)` } Finance.Method = Finance.Method + ` (` + currencyList[Finance.CurrencyId] + `)` myFinanceHistory_[Finance.OpenTime] = append(myFinanceHistory_[Finance.OpenTime], Finance) } // история ввода средств rows, err = c.Query(c.FormatQuery(` SELECT id, amount, time, currency_id FROM e_adding_funds WHERE user_id = ? ORDER BY time DESC LIMIT 40 `), c.SessUserId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { Finance := new(EmyFinanceType) err = rows.Scan(&Finance.Id, &Finance.Amount, &Finance.AddTime, &Finance.CurrencyId) if err != nil { return "", utils.ErrInfo(err) } Finance.Ftype = types["adding_funds"] Finance.Status = `<span class="text-success"><strong>` + c.Lang["ready"] + `</strong></span>` Finance.Method = `Dcoin (` + currencyList[Finance.CurrencyId] + `)` myFinanceHistory_[Finance.AddTime] = append(myFinanceHistory_[Finance.AddTime], Finance) } // история ввода средств IK rows, err = c.Query(c.FormatQuery(` SELECT id, amount, time, currency_id FROM e_adding_funds_ik WHERE user_id = ? ORDER BY time DESC LIMIT 40 `), c.SessUserId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { Finance := new(EmyFinanceType) err = rows.Scan(&Finance.Id, &Finance.Amount, &Finance.AddTime, &Finance.CurrencyId) if err != nil { return "", utils.ErrInfo(err) } Finance.Ftype = types["adding_funds"] Finance.Status = `<span class="text-success"><strong>` + c.Lang["ready"] + `</strong></span>` Finance.Method = `Interkassa (` + currencyList[Finance.CurrencyId] + `)` myFinanceHistory_[Finance.AddTime] = append(myFinanceHistory_[Finance.AddTime], Finance) } // история ввода средств PM rows, err = c.Query(c.FormatQuery(` SELECT id, amount, time, currency_id FROM e_adding_funds_pm WHERE user_id = ? ORDER BY time DESC LIMIT 40 `), c.SessUserId) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { Finance := new(EmyFinanceType) err = rows.Scan(&Finance.Id, &Finance.Amount, &Finance.AddTime, &Finance.CurrencyId) if err != nil { return "", utils.ErrInfo(err) } Finance.Ftype = types["adding_funds"] Finance.Status = `<span class="text-success"><strong>` + c.Lang["ready"] + `</strong></span>` Finance.Method = `PerfectMoney (` + currencyList[Finance.CurrencyId] + `)` myFinanceHistory_[Finance.AddTime] = append(myFinanceHistory_[Finance.AddTime], Finance) } //map[int64][]*EmyFinanceType var keys []int for k := range myFinanceHistory_ { keys = append(keys, int(k)) } sort.Ints(keys) var my_finance_history []*EmyFinanceType for _, k := range keys { for _, data := range myFinanceHistory_[int64(k)] { my_finance_history = append(my_finance_history, data) } } ///home/z/go-projects/src/github.com/c-darwin/dcoin-go/packages/controllers/e_my_finance.go:275: cannot use myFinanceHistory_[k] (type []*EmyFinanceType) as type *EmyFinanceType in append collapse := c.Parameters["collapse"] TemplateStr, err := makeTemplate("e_my_finance", "eMyFinance", &eMyFinancePage{ Lang: c.Lang, UserId: c.SessUserId, MyFinanceHistory: my_finance_history, Collapse: collapse, Currency: currency, CurrencyList: currencyList}) if err != nil { return "", utils.ErrInfo(err) } return TemplateStr, nil }
func (c *Controller) CfPagePreview() (string, error) { var err error txType := "CfComment" txTypeId := utils.TypeInt(txType) timeNow := time.Now().Unix() cfUrl, err := c.GetCfUrl() if err != nil { return "", utils.ErrInfo(err) } showHeaders := false if len(c.r.FormValue("blurb_img")) > 0 { showHeaders = true } page := c.Parameters["page"] if len(page) > 0 { if ok, _ := regexp.MatchString(`^(?i)[a-z]{0,10}$`, page); !ok { return "", errors.New("incorrect page") } } cfCurrencyName := c.Parameters["onlyCfCurrencyName"] if len(page) == 0 { page = "home" } langId := int64(utils.StrToFloat64(c.Parameters["lang_id"])) projectId := int64(utils.StrToFloat64(c.Parameters["onlyProjectId"])) log.Debug("projectId:", projectId) var blurbImg, headImg, descriptionImg, picture, videoType, videoUrlId, newsImg string imgBlank := cfUrl + "static/img/blank.png" var links [][]string if projectId > 0 || len(cfCurrencyName) > 0 { if projectId == 0 { projectId, err = c.Single("SELECT id FROM cf_projects WHERE project_currency_name = ?", cfCurrencyName).Int64() if err != nil { return "", utils.ErrInfo(err) } } data := make(map[string]string) if langId > 0 { data, err = c.OneRow("SELECT * FROM cf_projects_data WHERE project_id = ? AND lang_id = ?", projectId, langId).String() if err != nil { return "", utils.ErrInfo(err) } } else { // Если язык не указан, то просто берем первое добавленное описание data, err = c.OneRow("SELECT * FROM cf_projects_data WHERE project_id = ? ORDER BY id ASC", projectId).String() if err != nil { return "", utils.ErrInfo(err) } langId = utils.StrToInt64(data["lang_id"]) } blurbImg = data["blurb_img"] headImg = data["head_img"] descriptionImg = data["description_img"] picture = data["picture"] videoType = data["video_type"] videoUrlId = data["video_url_id"] newsImg = data["news_img"] if len(data["links"]) > 0 && data["links"] != "0" { var links_ [][]interface{} err = json.Unmarshal([]byte(data["links"]), &links_) if err != nil { log.Debug("data links:", data["links"]) return "", utils.ErrInfo(err) } for _, v := range links_ { var l []string for _, v2 := range v { str := utils.InterfaceToStr(v2) if len(str) == 0 { return "", utils.ErrInfo(errors.New("Incorrect links")) } l = append(l, str) } links = append(links, l) } } } else { log.Debug("FormValue", c.r.Form) blurbImg = c.r.FormValue("blurb_img") headImg = c.r.FormValue("head_img") descriptionImg = c.r.FormValue("description_img") picture = c.r.FormValue("blurb_img") videoType = c.r.FormValue("video_type") videoUrlId = c.r.FormValue("video_url_id") newsImg = c.r.FormValue("news_img") if !utils.CheckInputData(c.r.FormValue("project_id"), "int") { return "", errors.New("Incorrect project_id") } if !utils.CheckInputData(blurbImg, "img_url") { blurbImg = imgBlank } if !utils.CheckInputData(headImg, "img_url") { headImg = imgBlank } if !utils.CheckInputData(descriptionImg, "img_url") { descriptionImg = imgBlank } if !utils.CheckInputData(picture, "img_url") { picture = imgBlank } if !utils.CheckInputData(newsImg, "img_url") { newsImg = imgBlank } if !utils.CheckInputData(videoType, "video_type") { videoType = "" } if !utils.CheckInputData(videoUrlId, "video_url_id") { videoUrlId = "" } if len(c.Parameters["links"]) > 0 { var links_ [][]interface{} err = json.Unmarshal([]byte(c.Parameters["links"]), &links_) if err != nil { return "", utils.ErrInfo(err) } for _, v := range links_ { var l []string for _, v2 := range v { str := utils.InterfaceToStr(v2) if len(str) == 0 { return "", utils.ErrInfo(errors.New("Incorrect links")) } l = append(l, str) } links = append(links, l) } } } project, err := c.OneRow("SELECT * FROM cf_projects WHERE id = ?", projectId).String() if err != nil { return "", utils.ErrInfo(err) } // сколько дней осталось days := utils.Round((utils.StrToFloat64(project["end_time"])-float64(utils.Time()))/86400, 0) if days <= 0 { days = 0 } project["days"] = utils.Float64ToStr(days) if project["close_block_id"] != "0" || project["del_block_id"] != "0" { project["ended"] = "1" } else { project["ended"] = "0" } // дата старта t := time.Unix(utils.StrToInt64(project["start_time"]), 0) project["start_date"] = t.Format(c.TimeFormat) // в какой валюте идет сбор project["currency"] = c.CurrencyList[utils.StrToInt64(project["currency_id"])] // на каких языках есть описание // для home/news можно скрыть язык addSql := "" if page == "home" || page == "news" { addSql = " AND hide = 0 " } projectLang, err := c.GetMap(`SELECT id, lang_id FROM cf_projects_data WHERE project_id = ? `+addSql, "id", "lang_id", projectId) // сколько собрано средств projectFunding, err := c.Single("SELECT sum(amount) FROM cf_funding WHERE project_id = ? AND del_block_id = 0", projectId).Float64() if err != nil { return "", utils.ErrInfo(err) } // сколько всего фундеров projectCountFunders, err := c.Single("SELECT count(id) FROM cf_funding WHERE project_id = ? AND del_block_id = 0 GROUP BY user_id", projectId).Int64() if err != nil { return "", utils.ErrInfo(err) } // список фундеров var q string if c.ConfigIni["db_type"] == "postgresql" { q = `SELECT DISTINCT cf_funding.user_id, sum(amount) as amount, time, name, avatar FROM cf_funding LEFT JOIN users ON users.user_id = cf_funding.user_id WHERE project_id = ? AND del_block_id = 0 GROUP BY cf_funding.user_id, time, name, avatar ORDER BY time DESC LIMIT 100` } else { q = `SELECT cf_funding.user_id, sum(amount) as amount, time, name, avatar FROM cf_funding LEFT JOIN users ON users.user_id = cf_funding.user_id WHERE project_id = ? AND del_block_id = 0 GROUP BY cf_funding.user_id ORDER BY time DESC LIMIT 100` } projectFunders, err := c.GetAll(q, 100, projectId) if err != nil { return "", utils.ErrInfo(err) } for k, v := range projectFunders { t := time.Unix(utils.StrToInt64(v["time"]), 0) projectFunders[k]["time"] = t.Format(c.TimeFormat) if len(v["avatar"]) == 0 { projectFunders[k]["avatar"] = cfUrl + "static/img/noavatar.png" } if len(v["name"]) == 0 { projectFunders[k]["name"] = "Noname" } } // список комментов var projectComments []map[string]string if langId > 0 { projectComments, err = c.GetAll(` SELECT users.user_id, comment, time, name, avatar FROM cf_comments LEFT JOIN users ON users.user_id = cf_comments.user_id WHERE project_id = ? AND lang_id = ? ORDER BY time DESC LIMIT 100 `, 100, projectId, langId) if err != nil { return "", utils.ErrInfo(err) } for k, v := range projectComments { t := time.Unix(utils.StrToInt64(v["time"]), 0) projectComments[k]["time"] = t.Format(c.TimeFormat) if len(v["avatar"]) == 0 { projectComments[k]["avatar"] = cfUrl + "static/img/noavatar.png" } if len(v["name"]) == 0 { projectComments[k]["name"] = "Noname" } } } // сколько всего комментов на каждом языке if c.ConfigIni["db_type"] == "postgresql" { q = `SELECT DISTINCT lang_id, count(id) as count FROM cf_comments WHERE project_id = ? GROUP BY lang_id` } else { q = `SELECT lang_id, count(id) as count FROM cf_comments WHERE project_id = ?` } langComments, err := c.GetMap(q, "lang_id", "count", projectId) if err != nil { return "", utils.ErrInfo(err) } var projectCountComments int64 for _, v := range langComments { projectCountComments += utils.StrToInt64(v) } cfLng, err := c.GetAllCfLng() // инфа об авторе проекта authorInfo, err := c.GetCfAuthorInfo(project["user_id"], cfUrl) // возможно наш юзер фундер project["funder"] = "" if c.SessUserId > 0 { project["funder"], err = c.Single("SELECT id FROM cf_funding WHERE project_id = ? AND user_id = ? AND del_block_id = 0", projectId, c.SessUserId).String() if err != nil { return "", utils.ErrInfo(err) } } pagesArray := []string{"home", "news", "funders", "comments"} configCfPs := make(map[string][]string) if len(c.NodeConfig["cf_ps"]) > 0 { //{"1":["Credit card"],"2":["ik","MTS, Megafon, W1, Paxum"],"3":["pm","Perfect Money"]} err = json.Unmarshal([]byte(c.NodeConfig["cf_ps"]), &configCfPs) if err != nil { return "", utils.ErrInfo(err) } } // узнаем, какие платежные системы доступны данному проекту projectPs, err := c.OneRow("SELECT * FROM cf_projects_ps WHERE project_id = ?", projectId).String() if err != nil { return "", utils.ErrInfo(err) } // узнаем, не в блек-листе ли проект black, err := c.Single("SELECT project_id FROM cf_blacklist WHERE project_id = ?", projectId).Int64() if err != nil { return "", utils.ErrInfo(err) } if black > 0 { return "", errors.New("Black project") } TemplateStr, err := makeTemplate("cf_page_preview", "cfPagePreview", &CfPagePreviewPage{ Alert: c.Alert, Lang: c.Lang, CountSignArr: c.CountSignArr, ShowSignData: c.ShowSignData, UserId: c.SessUserId, TimeNow: timeNow, TxType: txType, TxTypeId: txTypeId, SignData: "", CfLng: cfLng, CurrencyList: c.CurrencyList, CfUrl: cfUrl, ShowHeaders: showHeaders, Page: page, CfCurrencyName: cfCurrencyName, LangId: langId, ProjectId: projectId, BlurbImg: blurbImg, HeadImg: headImg, DescriptionImg: descriptionImg, Picture: picture, VideoType: videoType, VideoUrlId: videoUrlId, NewsImg: newsImg, Links: links, ImgBlank: imgBlank, Project: project, ProjectLang: projectLang, ProjectFunding: projectFunding, ProjectCountFunders: projectCountFunders, ProjectFunders: projectFunders, ProjectComments: projectComments, LangComments: langComments, ProjectCountComments: projectCountComments, AuthorInfo: authorInfo, PagesArray: pagesArray, ConfigCfPs: configCfPs, ProjectPs: projectPs, Black: black}) if err != nil { return "", utils.ErrInfo(err) } return TemplateStr, nil }
func (c *Controller) Statistic() (string, error) { var err error sumWallets := make(map[int64]float64) // получаем кол-во DC на кошельках rows, err := c.Query(` SELECT currency_id, sum(amount) as sum_amount FROM wallets GROUP BY currency_id `) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var currency_id int64 var sum_amount float64 err = rows.Scan(¤cy_id, &sum_amount) if err != nil { return "", utils.ErrInfo(err) } sumWallets[currency_id] = sum_amount } // получаем кол-во TDC на обещанных суммах rows, err = c.Query(` SELECT currency_id, sum(tdc_amount) as sum_amount FROM promised_amount GROUP BY currency_id `) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var currency_id int64 var sum_amount float64 err = rows.Scan(¤cy_id, &sum_amount) if err != nil { return "", utils.ErrInfo(err) } if sumWallets[currency_id] > 0 { sumWallets[currency_id] += sum_amount } else { sumWallets[currency_id] = sum_amount } } // получаем суммы обещанных сумм sumPromisedAmount, err := c.GetMap(` SELECT currency_id, sum(amount) as sum_amount FROM promised_amount WHERE status = 'mining' AND del_block_id = 0 AND (cash_request_out_time = 0 OR cash_request_out_time > ?) GROUP BY currency_id`, "currency_id", "sum_amount", utils.Time()-c.Variables.Int64["cash_request_time"]) // получаем кол-во майнеров по валютам promisedAmountMiners, err := c.GetMap(` SELECT currency_id, count(user_id) as count FROM ( SELECT currency_id, user_id FROM promised_amount WHERE del_block_id = 0 AND del_mining_block_id = 0 AND status IN ('mining', 'repaid') GROUP BY user_id, currency_id ) as t1 GROUP BY currency_id`, "currency_id", "count") // получаем кол-во анонимных юзеров по валютам walletsUsers, err := c.GetMap(` SELECT currency_id, count(user_id) as count FROM wallets WHERE amount > 0 GROUP BY currency_id`, "currency_id", "count") refPhotos := make(map[int64][]string) // таблица обмена на наличные cashRequests, err := c.GetAll(` SELECT * FROM cash_requests ORDER BY id DESC LIMIT 5`, 5) for i := 0; i < len(cashRequests); i++ { if cashRequests[i]["del_block_id"] != "0" { cashRequests[i]["status"] = "reduction closed" } else if utils.Time()-utils.StrToInt64(cashRequests[i]["time"]) > c.Variables.Int64["cash_request_time"] && cashRequests[i]["status"] != "approved" { cashRequests[i]["status"] = "rejected" } t := time.Unix(utils.StrToInt64(cashRequests[i]["time"]), 0) cashRequests[i]["time"] = t.Format(c.TimeFormat) // ### from_user_id для фоток data, err := c.OneRow("SELECT * FROM miners_data WHERE user_id = ?", cashRequests[i]["from_user_id"]).String() if err != nil { return "", utils.ErrInfo(err) } // получим ID майнеров, у которых лежат фото нужного нам юзера minersIds := utils.GetMinersKeepers(data["photo_block_id"], data["photo_max_miner_id"], data["miners_keepers"], true) hosts, err := c.GetList("SELECT http_host FROM miners_data WHERE miner_id IN (" + utils.JoinInts(minersIds, ",") + ")").String() if err != nil { return "", utils.ErrInfo(err) } refPhotos[utils.StrToInt64(cashRequests[i]["from_user_id"])] = hosts // ### to_user_id для фоток data, err = c.OneRow("SELECT * FROM miners_data WHERE user_id = ?", cashRequests[i]["to_user_id"]).String() if err != nil { return "", utils.ErrInfo(err) } // получим ID майнеров, у которых лежат фото нужного нам юзера minersIds = utils.GetMinersKeepers(data["photo_block_id"], data["photo_max_miner_id"], data["miners_keepers"], true) hosts, err = c.GetList("SELECT http_host FROM miners_data WHERE miner_id IN (" + utils.JoinInts(minersIds, ",") + ")").String() if err != nil { return "", utils.ErrInfo(err) } refPhotos[utils.StrToInt64(cashRequests[i]["to_user_id"])] = hosts } var userInfoWallets []utils.DCAmounts var promisedAmountListAccepted []utils.PromisedAmounts var credits map[string]string // поиск инфы о юзере userInfoId := int64(utils.StrToFloat64(c.Parameters["user_info_id"])) if userInfoId > 0 { userInfoWallets, err = c.GetBalances(userInfoId) if err != nil { return "", utils.ErrInfo(err) } // обещанные суммы юзера _, promisedAmountListAccepted, _, err = c.GetPromisedAmounts(userInfoId, c.Variables.Int64["cash_request_time"]) // кредиты credits, err = c.GetMap(` SELECT sum(amount) as amount, currency_id FROM credits WHERE from_user_id = ? AND del_block_id = 0 GROUP BY currency_id`, "amount", "currency_id", userInfoId) } /* * Кол-во юзеров, сменивших ключ * */ countUsers, err := c.Single("SELECT count(user_id) FROM users WHERE log_id > 0").Int64() if err != nil { return "", utils.ErrInfo(err) } /* * %/год * */ currencyPct := make(map[int64]map[string]string) for currencyId, name := range c.CurrencyList { pct, err := c.OneRow("SELECT * FROM pct WHERE currency_id = ? ORDER BY block_id DESC", currencyId).Float64() if err != nil { return "", utils.ErrInfo(err) } currencyPct[currencyId] = make(map[string]string) currencyPct[currencyId]["name"] = name currencyPct[currencyId]["miner"] = utils.Float64ToStr(utils.Round((math.Pow(1+pct["miner"], 120)-1)*100, 6)) currencyPct[currencyId]["user"] = utils.Float64ToStr(utils.Round((math.Pow(1+pct["user"], 120)-1)*100, 6)) } /* * Произошедшие сокращения * */ reduction, err := c.GetAll(` SELECT * FROM reduction ORDER BY time DESC LIMIT 20`, 20) for i := 0; i < len(reduction); i++ { if reduction[i]["type"] != "auto" { reduction[i]["type"] = "voting" } t := time.Unix(utils.StrToInt64(reduction[i]["time"]), 0) reduction[i]["time"] = t.Format(c.TimeFormat) } TemplateStr, err := makeTemplate("statistic", "statistic", &StatisticPage{ Lang: c.Lang, CurrencyList: c.CurrencyListCf, UserInfoId: userInfoId, SumWallets: sumWallets, SumPromisedAmount: sumPromisedAmount, PromisedAmountMiners: promisedAmountMiners, WalletsUsers: walletsUsers, CashRequests: cashRequests, UserInfoWallets: userInfoWallets, Credits: credits, PromisedAmountListAccepted: promisedAmountListAccepted, CountUsers: countUsers, CurrencyPct: currencyPct, Reduction: reduction, RefPhotos: refPhotos, UserId: c.SessUserId}) if err != nil { return "", utils.ErrInfo(err) } return TemplateStr, nil }
func (p *Parser) ChangeCreditPart() error { return p.selectiveLoggingAndUpd([]string{"credit_part"}, []interface{}{utils.Float64ToStr(p.TxMaps.Float64["pct"])}, "users", []string{"user_id"}, []string{utils.Int64ToStr(p.TxUserID)}) }
func (c *Controller) StatisticVoting() (string, error) { var err error js := "" var divs []string /* * Голосование за размер обещанной суммы */ rows, err := c.Query(c.FormatQuery(`SELECT currency_id, amount, count(user_id) as votes FROM votes_max_promised_amount GROUP BY currency_id, amount`)) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() maxPromisedAmountVotes := make(map[int64][]map[int64]int64) for rows.Next() { var currency_id, votes, amount int64 err = rows.Scan(¤cy_id, &amount, &votes) if err != nil { return "", utils.ErrInfo(err) } maxPromisedAmountVotes[currency_id] = append(maxPromisedAmountVotes[currency_id], map[int64]int64{amount: votes}) } for currencyId, arr := range maxPromisedAmountVotes { js += fmt.Sprintf("var max_promised_amounts_%d = [", currencyId) for _, data := range arr { for k, v := range data { js += fmt.Sprintf("[%v, %v],", k, v) } } js = js[:len(js)-1] + "];\n" divs = append(divs, fmt.Sprintf("max_promised_amounts_%d", currencyId)) } totalCountCurrencies, err := c.Single("SELECT count(id) FROM currency").Int64() if err != nil { return "", utils.ErrInfo(err) } newMaxPromisedAmounts := make(map[int64]int64) //array []map[int64]int64, min, max, step int64 for currencyId, data := range maxPromisedAmountVotes { newMaxPromisedAmounts[currencyId] = utils.GetMaxVote(data, 0, totalCountCurrencies, 10) } /* * Голосование за кол-во валют в обещанных суммах */ rows, err = c.Query(c.FormatQuery(`SELECT currency_id, count, count(user_id) as votes FROM votes_max_other_currencies GROUP BY currency_id, count`)) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() maxOtherCurrenciesVotes := make(map[int64][]map[int64]int64) for rows.Next() { var currency_id, count, votes int64 err = rows.Scan(¤cy_id, &count, &votes) if err != nil { return "", utils.ErrInfo(err) } maxOtherCurrenciesVotes[currency_id] = append(maxOtherCurrenciesVotes[currency_id], map[int64]int64{count: votes}) } log.Debug("maxOtherCurrenciesVotes", maxOtherCurrenciesVotes) newMaxOtherCurrencies := make(map[int64]int64) for currencyId, arr := range maxOtherCurrenciesVotes { newMaxOtherCurrencies[currencyId] = utils.GetMaxVote(arr, 0, totalCountCurrencies, 10) js += fmt.Sprintf("var max_other_currencies_votes_%d = [", currencyId) for _, data := range arr { log.Debug("data", data) for k, v := range data { js += fmt.Sprintf("[%v, %v],", k, v) } } js = js[:len(js)-1] + "];\n" log.Debug("js", js) divs = append(divs, fmt.Sprintf("max_other_currencies_votes_%d", currencyId)) } /* * Голосование за ручное сокращение объема монет * */ // получаем кол-во обещанных сумм у разных юзеров по каждой валюте. start_time есть только у тех, у кого статус mining/repaid promisedAmount_, err := c.GetAll(` SELECT currency_id, count(user_id) as count FROM ( SELECT currency_id, user_id FROM promised_amount WHERE start_time < ? AND del_block_id = 0 AND del_mining_block_id = 0 AND status IN ('mining', 'repaid') GROUP BY user_id, currency_id ) as t1 GROUP BY currency_id `, -1, utils.Time()-c.Variables.Int64["min_hold_time_promise_amount"]) if err != nil { return "", utils.ErrInfo(err) } promisedAmount := make(map[string]string) for _, data := range promisedAmount_ { promisedAmount[data["currency_id"]] = data["count"] } // берем все голоса юзеров по данной валюте votesReduction := make(map[string]map[string]string) votesReduction_, err := c.GetAll(` SELECT currency_id, pct, count(currency_id) as votes FROM votes_reduction WHERE time > ? AND pct > 0 GROUP BY currency_id, pct `, -1, utils.Time()-c.Variables.Int64["reduction_period"]) if err != nil { return "", utils.ErrInfo(err) } for _, data := range votesReduction_ { votesReduction[data["currency_id"]] = make(map[string]string) votesReduction[data["currency_id"]][data["pct"]] = data["votes"] } /* * Голосование за реф. бонусы * */ refLevels := []string{"first", "second", "third"} newReferralPct := make(map[string]int64) votesReferral := make(map[string][]map[int64]int64) for i := 0; i < len(refLevels); i++ { level := refLevels[i] // берем все голоса votesReferral_, err := c.GetAll(` SELECT `+level+`, count(user_id) as votes FROM votes_referral GROUP BY `+level+` `, -1) if err != nil { return "", utils.ErrInfo(err) } for _, data := range votesReferral_ { votesReferral[level] = append(votesReferral[level], map[int64]int64{utils.StrToInt64(data[level]): utils.StrToInt64(data["votes"])}) } newReferralPct[level] = utils.GetMaxVote(votesReferral[level], 0, 30, 10) } for level, arr := range votesReferral { js += "var votes_referral_" + level + " = [" for _, data := range arr { for k, v := range data { js += fmt.Sprintf("[%v, %v],", k, v) } } js = js[:len(js)-1] + "];\n" divs = append(divs, "votes_referral_"+level) } /* * Голосоваие за майнеркие и юзерские % * */ // берем все голоса miner_pct pctVotes := make(map[int64]map[string]map[string]int64) rows, err = c.Query("SELECT currency_id, pct, count(user_id) as votes FROM votes_miner_pct GROUP BY currency_id, pct ORDER BY currency_id, pct ASC") if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var currency_id, votes int64 var pct string err = rows.Scan(¤cy_id, &pct, &votes) if err != nil { return "", utils.ErrInfo(err) } log.Debug("newpctcurrency_id", currency_id, "pct", pct, "votes", votes) if len(pctVotes[currency_id]) == 0 { pctVotes[currency_id] = make(map[string]map[string]int64) } if len(pctVotes[currency_id]["miner_pct"]) == 0 { pctVotes[currency_id]["miner_pct"] = make(map[string]int64) } pctVotes[currency_id]["miner_pct"][pct] = votes } // берем все голоса user_pct rows, err = c.Query("SELECT currency_id, pct, count(user_id) as votes FROM votes_user_pct GROUP BY currency_id, pct ORDER BY currency_id, pct ASC") if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var currency_id, votes int64 var pct string err = rows.Scan(¤cy_id, &pct, &votes) if err != nil { return "", utils.ErrInfo(err) } log.Debug("currency_id", currency_id, "pct", pct, "votes", votes) if len(pctVotes[currency_id]) == 0 { pctVotes[currency_id] = make(map[string]map[string]int64) } if len(pctVotes[currency_id]["user_pct"]) == 0 { pctVotes[currency_id]["user_pct"] = make(map[string]int64) } pctVotes[currency_id]["user_pct"][pct] = votes } log.Debug("pctVotes", pctVotes) for currencyId, data := range pctVotes { currencyIdStr := utils.Int64ToStr(currencyId) divs = append(divs, "miner_pct_"+currencyIdStr) divs = append(divs, "user_pct_"+currencyIdStr) js += "var miner_pct_" + currencyIdStr + " = [" for k, v := range data["miner_pct"] { pctY := utils.Round((math.Pow(1+utils.StrToFloat64(k), 3600*24*365)-1)*100, 2) js += fmt.Sprintf("[%v, %v],", pctY, v) } js = js[:len(js)-1] + "];\n" js += "var user_pct_" + currencyIdStr + " = [" for k, v := range data["user_pct"] { pctY := utils.Round((math.Pow(1+utils.StrToFloat64(k), 3600*24*365)-1)*100, 2) js += fmt.Sprintf("[%v, %v],", pctY, v) } js = js[:len(js)-1] + "];\n" } newPct := make(map[string]map[string]string) newPctTpl := make(map[string]map[string]float64) var userMaxKey int64 PctArray := utils.GetPctArray() log.Debug("pctVotes", pctVotes) for currencyId, data := range pctVotes { currencyIdStr := utils.Int64ToStr(currencyId) // определяем % для майнеров pctArr := utils.MakePctArray(data["miner_pct"]) log.Debug("currencyIdStr:", currencyIdStr) log.Debug("miner_pct:", data["miner_pct"]) log.Debug("pctArr:", pctArr) key := utils.GetMaxVote(pctArr, 0, 390, 100) log.Debug("key:", key) if len(newPct[currencyIdStr]) == 0 { newPct[currencyIdStr] = make(map[string]string) } newPct[currencyIdStr]["miner_pct"] = utils.GetPctValue(key) if len(newPctTpl[currencyIdStr]) == 0 { newPctTpl[currencyIdStr] = make(map[string]float64) } newPctTpl[currencyIdStr]["miner_pct"] = utils.Round((math.Pow(1+utils.StrToFloat64(utils.GetPctValue(key)), 3600*24*365)-1)*100, 2) // определяем % для юзеров pctArr = utils.MakePctArray(data["user_pct"]) pctY := utils.ArraySearch(newPct[currencyIdStr]["miner_pct"], PctArray) maxUserPctY := utils.Round(utils.StrToFloat64(pctY)/2, 2) userMaxKey = utils.FindUserPct(int(maxUserPctY)) // отрезаем лишнее, т.к. поиск идет ровно до макимального возможного, т.е. до miner_pct/2 pctArr = utils.DelUserPct(pctArr, userMaxKey) key = utils.GetMaxVote(pctArr, 0, userMaxKey, 100) newPct[currencyIdStr]["user_pct"] = utils.GetPctValue(key) newPctTpl[currencyIdStr]["user_pct"] = utils.Round((math.Pow(1+utils.StrToFloat64(utils.GetPctValue(key)), 3600*24*365)-1)*100, 2) } log.Debug("newPct", newPct) log.Debug("newPctTpl", newPctTpl) /* * %/год * */ currencyPct := make(map[int64]map[string]string) for currencyId, name := range c.CurrencyList { pct, err := c.OneRow("SELECT * FROM pct WHERE currency_id = ? ORDER BY block_id DESC", currencyId).String() if err != nil { return "", utils.ErrInfo(err) } currencyPct[currencyId] = make(map[string]string) currencyPct[currencyId]["name"] = name currencyPct[currencyId]["miner"] = utils.Float64ToStr(utils.Round((math.Pow(1+utils.StrToFloat64(pct["miner"]), 120)-1)*100, 6)) currencyPct[currencyId]["user"] = utils.Float64ToStr(utils.Round((math.Pow(1+utils.StrToFloat64(pct["user"]), 120)-1)*100, 6)) } TemplateStr, err := makeTemplate("statistic_voting", "statisticVoting", &StatisticVotingPage{ Lang: c.Lang, CurrencyList: c.CurrencyListCf, Js: template.JS(js), Divs: divs, CurrencyPct: currencyPct, NewPctTpl: newPctTpl, PctVotes: pctVotes, VotesReferral: votesReferral, VotesReduction: votesReduction, PromisedAmount: promisedAmount, NewMaxOtherCurrencies: newMaxOtherCurrencies, MaxOtherCurrenciesVotes: maxOtherCurrenciesVotes, MaxPromisedAmountVotes: maxPromisedAmountVotes, NewMaxPromisedAmounts: newMaxPromisedAmounts, NewReferralPct: newReferralPct, UserId: c.SessUserId}) if err != nil { return "", utils.ErrInfo(err) } return TemplateStr, nil }
func (p *Parser) NewReduction() error { d := (100 - utils.StrToFloat64(p.TxMaps.String["pct"])) / 100 if utils.StrToFloat64(p.TxMaps.String["pct"]) > 0 { // т.к. невозможо 2 отката подряд из-за промежутка в 2 дня между reduction, // то можем использовать только бекап на 1 уровень назад вместо _log // но для теста полного роллбека до 1-го блока нужно бекапить данные data, err := p.DCDB.GetMap("SELECT user_id, amount FROM wallets WHERE currency_id = ?", "user_id", "amount", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } jsonDataWallets, err := json.Marshal(data) if err != nil { return p.ErrInfo(err) } err = p.ExecSql("UPDATE wallets SET amount_backup = amount, amount = round(amount*"+utils.Float64ToStr(d)+"+"+utils.Float64ToStr(consts.ROUND_FIX)+", 2) WHERE currency_id = ?", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } // если бы не урезали amount, то пришлось бы делать пересчет tdc по всем, у кого есть данная валюта // после 87826 блока убрано amount_backup = amount, amount = amount*({$d}) т.к. теряется смысл в reduction c type=promised_amount data, err = p.DCDB.GetMap("SELECT user_id, tdc_amount FROM promised_amount WHERE currency_id = ?", "user_id", "tdc_amount", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } jsonDataPromisedAmountTdc, err := json.Marshal(data) if err != nil { return p.ErrInfo(err) } err = p.ExecSql("UPDATE promised_amount SET tdc_amount_backup = tdc_amount, tdc_amount = round(tdc_amount*"+utils.Float64ToStr(d)+"+"+utils.Float64ToStr(consts.ROUND_FIX)+", 2) WHERE currency_id = ?", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } // все свежие cash_request_out_time отменяем data, err = p.DCDB.GetMap("SELECT user_id, cash_request_out_time FROM promised_amount WHERE currency_id = ?", "user_id", "cash_request_out_time", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } jsonDataPromisedAmountTime, err := json.Marshal(data) if err != nil { return p.ErrInfo(err) } err = p.ExecSql("UPDATE promised_amount SET cash_request_out_time_backup = cash_request_out_time, cash_request_out_time = 0 WHERE currency_id = ? AND cash_request_out_time > ?", p.TxMaps.Int64["currency_id"], (p.BlockData.Time - p.Variables.Int64["cash_request_time"])) if err != nil { return p.ErrInfo(err) } // все текущие cash_requests, т.е. по которым не прошло 2 суток err = p.ExecSql("UPDATE cash_requests SET del_block_id = ? WHERE currency_id = ? AND status = 'pending' AND time > ?", p.BlockData.BlockId, p.TxMaps.Int64["currency_id"], (p.BlockData.Time - p.Variables.Int64["cash_request_time"])) if err != nil { return p.ErrInfo(err) } // форeкс-ордеры data, err = p.DCDB.GetMap("SELECT user_id, amount FROM forex_orders WHERE sell_currency_id = ?", "user_id", "amount", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } jsonDataPromisedAmountForex, err := json.Marshal(data) if err != nil { return p.ErrInfo(err) } err = p.ExecSql("UPDATE forex_orders SET amount_backup = amount, amount = round(amount*"+utils.Float64ToStr(d)+"+"+utils.Float64ToStr(consts.ROUND_FIX)+", 2) WHERE sell_currency_id = ?", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } // крауд-фандинг data, err = p.DCDB.GetMap("SELECT user_id, amount FROM cf_funding WHERE currency_id = ?", "user_id", "amount", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } jsonDataPromisedAmountCF, err := json.Marshal(data) if err != nil { return p.ErrInfo(err) } err = p.ExecSql("UPDATE cf_funding SET amount_backup = amount, amount = round(amount*"+utils.Float64ToStr(d)+"+"+utils.Float64ToStr(consts.ROUND_FIX)+", 2) WHERE currency_id = ?", p.TxMaps.Int64["currency_id"]) if err != nil { return p.ErrInfo(err) } log.Error(`INSERT INTO reduction_backup (block_id, currency_id, cf_funding, forex_orders, promised_amount_cash_request_out_time, promised_amount_tdc_amount, wallets) VALUES (%v, %v, %v, %v, %v, %v, %v) `, p.BlockData.BlockId, p.TxMaps.Int64["currency_id"], jsonDataPromisedAmountCF, jsonDataPromisedAmountForex, jsonDataPromisedAmountTime, jsonDataPromisedAmountTdc, jsonDataWallets) err = p.ExecSql(`INSERT INTO reduction_backup (block_id, currency_id, cf_funding, forex_orders, promised_amount_cash_request_out_time, promised_amount_tdc_amount, wallets) VALUES (?, ?, ?, ?, ?, ?, ?)`, p.BlockData.BlockId, p.TxMaps.Int64["currency_id"], jsonDataPromisedAmountCF, jsonDataPromisedAmountForex, jsonDataPromisedAmountTime, jsonDataPromisedAmountTdc, jsonDataWallets) if err != nil { return p.ErrInfo(err) } } rType := "" if p.TxMaps.String["reduction_type"] == "manual" { rType = "manual" } else { rType = "auto" } err := p.ExecSql("INSERT INTO reduction ( time, currency_id, type, pct, block_id ) VALUES ( ?, ?, ?, ?, ? )", p.BlockData.Time, p.TxMaps.Int64["currency_id"], rType, p.TxMaps.String["pct"], p.BlockData.BlockId) if err != nil { return p.ErrInfo(err) } return nil }
func NewForexOrder(userId int64, amount, sellRate float64, sellCurrencyId, buyCurrencyId int64, orderType string, eCommission float64) error { log.Debug("userId: %v / amount: %v / sellRate: %v / sellCurrencyId: %v / buyCurrencyId: %v / orderType: %v ", userId, amount, sellRate, sellCurrencyId, buyCurrencyId, orderType) curTime := utils.Time() err := userLock(userId) if err != nil { return utils.ErrInfo(err) } commission := utils.StrToFloat64(utils.ClearNull(utils.Float64ToStr(amount*(eCommission/100)), 6)) newAmount := utils.StrToFloat64(utils.ClearNull(utils.Float64ToStr(amount-commission), 6)) if newAmount < commission { commission = 0 newAmount = amount } log.Debug("newAmount: %v / commission: %v ", newAmount, commission) if commission > 0 { userAmount := utils.EUserAmountAndProfit(1, sellCurrencyId) newAmount_ := userAmount + commission // наисляем комиссию системе err = utils.UpdEWallet(1, sellCurrencyId, utils.Time(), newAmount_, true) if err != nil { return utils.ErrInfo(err) } // и сразу вычитаем комиссию с кошелька юзера userAmount = utils.EUserAmountAndProfit(userId, sellCurrencyId) err = utils.DB.ExecSql("UPDATE e_wallets SET amount = ?, last_update = ? WHERE user_id = ? AND currency_id = ?", userAmount-commission, utils.Time(), userId, sellCurrencyId) if err != nil { return utils.ErrInfo(err) } } // обратный курс. нужен для поиска по ордерам reverseRate := utils.StrToFloat64(utils.ClearNull(utils.Float64ToStr(1/sellRate), 6)) log.Debug("sellRate %v", sellRate) log.Debug("reverseRate %v", reverseRate) var totalBuyAmount, totalSellAmount float64 if orderType == "buy" { totalBuyAmount = newAmount * reverseRate } else { totalSellAmount = newAmount } var debit float64 var prevUserId int64 // берем из БД только те ордеры, которые удовлетворяют нашим требованиям rows, err := utils.DB.Query(utils.DB.FormatQuery(` SELECT id, user_id, amount, sell_rate, buy_currency_id, sell_currency_id FROM e_orders WHERE buy_currency_id = ? AND sell_rate >= ? AND sell_currency_id = ? AND del_time = 0 AND empty_time = 0 ORDER BY sell_rate DESC `), sellCurrencyId, reverseRate, buyCurrencyId) if err != nil { return utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var rowId, rowUserId, rowBuyCurrencyId, rowSellCurrencyId int64 var rowAmount, rowSellRate float64 err = rows.Scan(&rowId, &rowUserId, &rowAmount, &rowSellRate, &rowBuyCurrencyId, &rowSellCurrencyId) if err != nil { return utils.ErrInfo(err) } log.Debug("rowId: %v / rowUserId: %v / rowAmount: %v / rowSellRate: %v / rowBuyCurrencyId: %v / rowSellCurrencyId: %v", rowId, rowUserId, rowAmount, rowSellRate, rowBuyCurrencyId, rowSellCurrencyId) // чтобы ордеры одного и тоже юзера не вызывали стопор, пропускаем все его оредера if rowUserId == prevUserId { continue } // блокируем юзера, чей ордер взяли, кроме самого себя if rowUserId != userId { lockErr := userLock(rowUserId) if lockErr != nil { log.Error("%v", utils.ErrInfo(err)) prevUserId = rowUserId continue } } if orderType == "buy" { // удовлетворит ли данный ордер наш запрос целиком if rowAmount >= totalBuyAmount { debit = totalBuyAmount log.Debug("order ENDED") } else { debit = rowAmount } } else { // удовлетворит ли данный ордер наш запрос целиком if rowAmount/rowSellRate >= totalSellAmount { debit = totalSellAmount * rowSellRate } else { debit = rowAmount } } log.Debug("totalBuyAmount: %v / debit: %v", totalBuyAmount, debit) if rowAmount-debit < 0.01 { // ордер опустошили err = utils.DB.ExecSql("UPDATE e_orders SET amount = 0, empty_time = ? WHERE id = ?", curTime, rowId) if err != nil { return utils.ErrInfo(err) } } else { // вычитаем забранную сумму из ордера err = utils.DB.ExecSql("UPDATE e_orders SET amount = amount - ? WHERE id = ?", debit, rowId) if err != nil { return utils.ErrInfo(err) } } mySellRate := utils.ClearNull(utils.Float64ToStr(1/rowSellRate), 6) myAmount := debit * utils.StrToFloat64(mySellRate) eTradeSellCurrencyId := sellCurrencyId eTradeBuyCurrencyId := buyCurrencyId // для истории сделок err = utils.DB.ExecSql("INSERT INTO e_trade ( user_id, sell_currency_id, sell_rate, amount, buy_currency_id, time, main ) VALUES ( ?, ?, ?, ?, ?, ?, 1 )", userId, eTradeSellCurrencyId, mySellRate, myAmount, eTradeBuyCurrencyId, curTime) if err != nil { return utils.ErrInfo(err) } // тот, чей ордер обрабатываем err = utils.DB.ExecSql("INSERT INTO e_trade ( user_id, sell_currency_id, sell_rate, amount, buy_currency_id, time ) VALUES ( ?, ?, ?, ?, ?, ? )", rowUserId, eTradeBuyCurrencyId, rowSellRate, debit, eTradeSellCurrencyId, curTime) if err != nil { return utils.ErrInfo(err) } // ==== Продавец валюты (тот, чей ордер обработали) ==== // сколько продавец данного ордера продал валюты sellerSellAmount := debit // сколько продавец получил buy_currency_id с продажи суммы $seller_sell_amount по его курсу sellerBuyAmount := sellerSellAmount * (1 / rowSellRate) // начисляем валюту, которую продавец получил (R) userAmount := utils.EUserAmountAndProfit(rowUserId, rowBuyCurrencyId) newAmount_ := userAmount + sellerBuyAmount err = utils.UpdEWallet(rowUserId, rowBuyCurrencyId, utils.Time(), newAmount_, true) if err != nil { return utils.ErrInfo(err) } // ====== Покупатель валюты (наш юзер) ====== // списываем валюту, которую мы продали (R) userAmount = utils.EUserAmountAndProfit(userId, rowBuyCurrencyId) newAmount_ = userAmount - sellerBuyAmount err = utils.UpdEWallet(userId, rowBuyCurrencyId, utils.Time(), newAmount_, true) if err != nil { return utils.ErrInfo(err) } // начисляем валюту, которую мы получили (U) userAmount = utils.EUserAmountAndProfit(userId, rowSellCurrencyId) newAmount_ = userAmount + sellerSellAmount err = utils.UpdEWallet(userId, rowSellCurrencyId, utils.Time(), newAmount_, true) if err != nil { return utils.ErrInfo(err) } if orderType == "buy" { totalBuyAmount -= rowAmount if totalBuyAmount <= 0 { userUnlock(rowUserId) log.Debug("total_buy_amount == 0 break") break // проход по ордерам прекращаем, т.к. наш запрос удовлетворен } } else { totalSellAmount -= rowAmount / rowSellRate if totalSellAmount <= 0 { userUnlock(rowUserId) log.Debug("total_sell_amount == 0 break") break // проход по ордерам прекращаем, т.к. наш запрос удовлетворен } } if rowUserId != userId { userUnlock(rowUserId) } } log.Debug("totalBuyAmount: %v / orderType: %v / sellRate: %v / reverseRate: %v", totalBuyAmount, orderType, sellRate, reverseRate) // если после прохода по всем имеющимся ордерам мы не набрали нужную сумму, то создаем свой ордер if totalBuyAmount > 0 || totalSellAmount > 0 { var newOrderAmount float64 if orderType == "buy" { newOrderAmount = totalBuyAmount * sellRate } else { newOrderAmount = totalSellAmount } log.Debug("newOrderAmount: %v", newOrderAmount) if newOrderAmount >= 0.000001 { err = utils.DB.ExecSql("INSERT INTO e_orders ( time, user_id, sell_currency_id, sell_rate, begin_amount, amount, buy_currency_id ) VALUES ( ?, ?, ?, ?, ?, ?, ? )", curTime, userId, sellCurrencyId, sellRate, newOrderAmount, newOrderAmount, buyCurrencyId) if err != nil { return utils.ErrInfo(err) } // вычитаем с баланса сумму созданного ордера userAmount := utils.EUserAmountAndProfit(userId, sellCurrencyId) err = utils.DB.ExecSql("UPDATE e_wallets SET amount = ?, last_update = ? WHERE user_id = ? AND currency_id = ?", userAmount-newOrderAmount, utils.Time(), userId, sellCurrencyId) if err != nil { return utils.ErrInfo(err) } } } userUnlock(userId) return nil }
func makeTemplate(html, name string, tData interface{}) (string, error) { defer func() { if r := recover(); r != nil { log.Error("makeTemplate Recovered", r) fmt.Println(r) } }() data, err := static.Asset("static/templates/" + html + ".html") if err != nil { return "", utils.ErrInfo(err) } signatures, err := static.Asset("static/templates/signatures.html") if err != nil { return "", utils.ErrInfo(err) } alert_success, err := static.Asset("static/templates/alert_success.html") if err != nil { return "", utils.ErrInfo(err) } funcMap := template.FuncMap{ "makeCurrencyName": func(currencyId int64) string { if currencyId >= 1000 { return "" } else { return "d" } }, "div": func(a, b interface{}) float64 { return utils.InterfaceToFloat64(a) / utils.InterfaceToFloat64(b) }, "mult": func(a, b interface{}) float64 { return utils.InterfaceToFloat64(a) * utils.InterfaceToFloat64(b) }, "round": func(a interface{}, num int) float64 { return utils.Round(utils.InterfaceToFloat64(a), num) }, "len": func(s []map[string]string) int { return len(s) }, "lenMap": func(s map[string]string) int { return len(s) }, "sum": func(a, b interface{}) float64 { return utils.InterfaceToFloat64(a) + utils.InterfaceToFloat64(b) }, "minus": func(a, b interface{}) float64 { return utils.InterfaceToFloat64(a) - utils.InterfaceToFloat64(b) }, "noescape": func(s string) template.HTML { return template.HTML(s) }, "js": func(s string) template.JS { return template.JS(s) }, "join": func(s []string, sep string) string { return strings.Join(s, sep) }, "strToInt64": func(text string) int64 { return utils.StrToInt64(text) }, "strToInt": func(text string) int { return utils.StrToInt(text) }, "bin2hex": func(text string) string { return string(utils.BinToHex([]byte(text))) }, "int64ToStr": func(text int64) string { return utils.Int64ToStr(text) }, "rand": func() int { return utils.RandInt(0, 99999999) }, "append": func(args ...interface{}) string { var result string for _, value := range args { switch value.(type) { case int64: result += utils.Int64ToStr(value.(int64)) case float64: result += utils.Float64ToStr(value.(float64)) case string: result += value.(string) } } return result }, "replaceCurrency": func(text, name string) string { return strings.Replace(text, "[currency]", name, -1) }, "replaceCurrencyName": func(text, name string) string { return strings.Replace(text, "[currency]", "D"+name, -1) }, "cfCategoryLang": func(lang map[string]string, name string) string { return lang["cf_category_"+name] }, "progressBarLang": func(lang map[string]string, name string) string { return lang["progress_bar_pct_"+name] }, "checkProjectPs": func(ProjectPs map[string]string, id string) bool { if len(ProjectPs["ps"+id]) > 0 { return true } else { return false } }, "cfPageTypeLang": func(lang map[string]string, name string) string { return lang["cf_"+name] }, "notificationsLang": func(lang map[string]string, name string) string { return lang["notifications_"+name] }, } t := template.Must(template.New("template").Funcs(funcMap).Parse(string(data))) t = template.Must(t.Parse(string(alert_success))) t = template.Must(t.Parse(string(signatures))) b := new(bytes.Buffer) err = t.ExecuteTemplate(b, name, tData) if err != nil { return "", utils.ErrInfo(err) } return b.String(), nil }
func (c *Controller) Assignments() (string, error) { var randArr []int64 // Нельзя завершить голосование юзеров раньше чем через сутки, даже если набрано нужное кол-во голосов. // В голосовании нодов ждать сутки не требуется, т.к. там нельзя поставить поддельных нодов // Модерация новых майнеров // берем тех, кто прошел проверку нодов (type='node_voting') num, err := c.Single("SELECT count(id) FROM votes_miners WHERE votes_end = 0 AND type = 'user_voting'").Int64() if err != nil { return "", utils.ErrInfo(err) } if num > 0 { randArr = append(randArr, 1) } // Модерация promised_amount // вначале получим ID валют, которые мы можем проверять. currency, err := c.GetList("SELECT currency_id FROM promised_amount WHERE status IN ('mining', 'repaid') AND user_id = ?", c.SessUserId).String() if err != nil { return "", utils.ErrInfo(err) } addSql := "" currencyIds := strings.Join(currency, ",") if len(currencyIds) > 0 || c.SessUserId == 1 { if c.SessUserId != 1 { addSql = "AND currency_id IN (" + currencyIds + ")" } num, err := c.Single("SELECT count(id) FROM promised_amount WHERE status = 'pending' AND del_block_id = 0 " + addSql + "").Int64() if err != nil { return "", utils.ErrInfo(err) } if num > 0 { randArr = append(randArr, 2) } } log.Debug("randArr %v", randArr) var AssignType int64 if len(randArr) > 0 { AssignType = randArr[utils.RandInt(0, len(randArr))] } cloneHosts := make(map[int64][]string) var photoHosts []string examplePoints := make(map[string]string) tplName := "assignments" tplTitle := "assignments" var txType string var txTypeId int64 var timeNow int64 var myRace, myCountry, mainQuestion, newPromiseAmount, videoHost string var promisedAmountData, userInfo map[string]string switch AssignType { case 1: // *********************************** // задания по модерации новых майнеров // *********************************** txType = "VotesMiner" txTypeId = utils.TypeInt(txType) timeNow = utils.Time() userInfo, err = c.OneRow(` SELECT miners_data.user_id, votes_miners.id as vote_id, face_coords, profile_coords, video_type, video_url_id, photo_block_id, photo_max_miner_id, miners_keepers, http_host FROM votes_miners LEFT JOIN miners_data ON miners_data.user_id = votes_miners.user_id LEFT JOIN `+c.MyPrefix+`my_tasks ON `+c.MyPrefix+`my_tasks.id = votes_miners.id WHERE votes_end = 0 AND votes_miners.type = 'user_voting' AND (`+c.MyPrefix+`my_tasks.time IS NULL OR (`+c.MyPrefix+`my_tasks.time < ? AND `+c.MyPrefix+`my_tasks.type = 'miner')) `, utils.Time()-consts.ASSIGN_TIME).String() if err != nil { return "", utils.ErrInfo(err) } if len(userInfo) == 0 { tplName = "assignments" break } examplePoints, err = c.GetPoints(c.Lang) if err != nil { return "", utils.ErrInfo(err) } // получим ID майнеров, у которых лежат фото нужного нам юзера minersIds := utils.GetMinersKeepers(userInfo["photo_block_id"], userInfo["photo_max_miner_id"], userInfo["miners_keepers"], true) if len(minersIds) > 0 { photoHosts, err = c.GetList("SELECT http_host FROM miners_data WHERE miner_id IN (" + utils.JoinInts(minersIds, ",") + ")").String() if err != nil { return "", utils.ErrInfo(err) } } // отрезки майнера, которого проверяем relations, err := c.OneRow("SELECT * FROM faces WHERE user_id = ?", userInfo["user_id"]).String() if err != nil { return "", utils.ErrInfo(err) } // получим допустимые расхождения между точками и совместимость версий data_, err := c.OneRow("SELECT tolerances, compatibility FROM spots_compatibility").String() if err != nil { return "", utils.ErrInfo(err) } tolerances := make(map[string]map[string]string) if err := json.Unmarshal([]byte(data_["tolerances"]), &tolerances); err != nil { return "", utils.ErrInfo(err) } var compatibility []int if err := json.Unmarshal([]byte(data_["compatibility"]), &compatibility); err != nil { return "", utils.ErrInfo(err) } // формируем кусок SQL-запроса для соотношений отрезков addSqlTolerances := "" typesArr := []string{"face", "profile"} for i := 0; i < len(typesArr); i++ { for j := 1; j <= len(tolerances[typesArr[i]]); j++ { currentRelations := utils.StrToFloat64(relations[typesArr[i][:1]+utils.IntToStr(j)]) diff := utils.StrToFloat64(tolerances[typesArr[i]][utils.IntToStr(j)]) * currentRelations if diff == 0 { continue } min := currentRelations - diff max := currentRelations + diff addSqlTolerances += typesArr[i][:1] + utils.IntToStr(j) + ">" + utils.Float64ToStr(min) + " AND " + typesArr[i][:1] + utils.IntToStr(j) + " < " + utils.Float64ToStr(max) + " AND " } } addSqlTolerances = addSqlTolerances[:len(addSqlTolerances)-4] // формируем кусок SQL-запроса для совместимости версий addSqlCompatibility := "" for i := 0; i < len(compatibility); i++ { addSqlCompatibility += fmt.Sprintf(`%d,`, compatibility[i]) } addSqlCompatibility = addSqlCompatibility[:len(addSqlCompatibility)-1] // получаем из БД похожие фото rows, err := c.Query(c.FormatQuery(` SELECT miners_data.user_id, photo_block_id, photo_max_miner_id, miners_keepers FROM faces LEFT JOIN miners_data ON miners_data.user_id = faces.user_id WHERE `+addSqlTolerances+` AND version IN (`+addSqlCompatibility+`) AND faces.status = 'used' AND miners_data.user_id != ? LIMIT 100 `), userInfo["user_id"]) if err != nil { return "", utils.ErrInfo(err) } defer rows.Close() for rows.Next() { var photo_block_id, photo_max_miner_id, miners_keepers string var user_id int64 err = rows.Scan(&user_id, &photo_block_id, &photo_max_miner_id, &miners_keepers) if err != nil { return "", utils.ErrInfo(err) } // майнеры, у которых можно получить фото нужного нам юзера minersIds := utils.GetMinersKeepers(photo_block_id, photo_max_miner_id, miners_keepers, true) if len(minersIds) > 0 { photoHosts, err = c.GetList("SELECT http_host FROM miners_data WHERE miner_id IN (" + utils.JoinInts(minersIds, ",") + ")").String() if err != nil { return "", utils.ErrInfo(err) } } cloneHosts[user_id] = photoHosts } data, err := c.OneRow("SELECT race, country FROM " + c.MyPrefix + "my_table").Int64() myRace = c.Races[data["race"]] myCountry = consts.Countries[int(data["country"])] tplName = "assignments_new_miner" tplTitle = "assignmentsNewMiner" case 2: promisedAmountData, err = c.OneRow(` SELECT id, currency_id, amount, user_id, video_type, video_url_id FROM promised_amount WHERE status = 'pending' AND del_block_id = 0 ` + addSql + ` `).String() if err != nil { return "", utils.ErrInfo(err) } promisedAmountData["currency_name"] = c.CurrencyList[utils.StrToInt64(promisedAmountData["currency_id"])] // проверим, не голосовали ли мы за это в последние 30 минут repeated, err := c.Single("SELECT id FROM "+c.MyPrefix+"my_tasks WHERE type = 'promised_amount' AND id = ? AND time > ?", promisedAmountData["id"], utils.Time()-consts.ASSIGN_TIME).Int64() if err != nil { return "", utils.ErrInfo(err) } if repeated > 0 { tplName = "assignments" tplTitle = "assignments" break } // если нету видео на ютубе, то получаем host юзера, где брать видео if promisedAmountData["video_url_id"] == "null" { videoHost, err = c.Single("SELECT http_host FROM miners_data WHERE user_id = ?", promisedAmountData["user_id"]).String() if err != nil { return "", utils.ErrInfo(err) } } // каждый раз обязательно проверяем, где находится юзер userInfo, err = c.OneRow(` SELECT latitude, user_id, longitude, photo_block_id, photo_max_miner_id, miners_keepers, http_host FROM miners_data WHERE user_id = ? `, promisedAmountData["user_id"]).String() if err != nil { return "", utils.ErrInfo(err) } // получим ID майнеров, у которых лежат фото нужного нам юзера minersIds := utils.GetMinersKeepers(userInfo["photo_block_id"], userInfo["photo_max_miner_id"], userInfo["miners_keepers"], true) if len(minersIds) > 0 { photoHosts, err = c.GetList("SELECT http_host FROM miners_data WHERE miner_id IN (" + utils.JoinInts(minersIds, ",") + ")").String() if err != nil { return "", utils.ErrInfo(err) } } txType = "VotesPromisedAmount" txTypeId = utils.TypeInt(txType) timeNow = utils.Time() newPromiseAmount = strings.Replace(c.Lang["new_promise_amount"], "[amount]", promisedAmountData["amount"], -1) newPromiseAmount = strings.Replace(newPromiseAmount, "[currency]", promisedAmountData["currency_name"], -1) mainQuestion = strings.Replace(c.Lang["main_question"], "[amount]", promisedAmountData["amount"], -1) mainQuestion = strings.Replace(mainQuestion, "[currency]", promisedAmountData["currency_name"], -1) tplName = "assignments_promised_amount" tplTitle = "assignmentsPromisedAmount" default: tplName = "assignments" tplTitle = "assignments" } TemplateStr, err := makeTemplate(tplName, tplTitle, &AssignmentsPage{ Alert: c.Alert, Lang: c.Lang, CountSignArr: c.CountSignArr, ShowSignData: c.ShowSignData, UserId: c.SessUserId, TimeNow: timeNow, TxType: txType, TxTypeId: txTypeId, SignData: "", CurrencyList: c.CurrencyList, MainQuestion: mainQuestion, NewPromiseAmount: newPromiseAmount, MyRace: myRace, MyCountry: myCountry, ExamplePoints: examplePoints, VideoHost: videoHost, PhotoHosts: photoHosts, PromisedAmountData: promisedAmountData, UserInfo: userInfo, CloneHosts: cloneHosts}) if err != nil { return "", utils.ErrInfo(err) } return TemplateStr, nil }
func (c *Controller) GetMinerData() (string, error) { c.r.ParseForm() secs := float64(3600 * 24 * 365) userId := utils.StrToInt64(c.r.FormValue("userId")) if !utils.CheckInputData(userId, "int") { return `{"result":"incorrect userId"}`, nil } minersData, err := c.OneRow("SELECT * FROM miners_data WHERE user_id = ?", userId).String() if err != nil { return "", err } // получим ID майнеров, у которых лежат фото нужного нам юзера minersIds := utils.GetMinersKeepers(minersData["photo_block_id"], minersData["photo_max_miner_id"], minersData["miners_keepers"], false) hosts, err := c.GetList("SELECT http_host as host FROM miners_data WHERE miner_id IN (" + utils.JoinIntsK(minersIds, ",") + ")").String() if err != nil { return "", err } currencyList, err := c.GetCurrencyList(false) if err != nil { return "", err } _, _, promisedAmountListGen, err := c.GetPromisedAmounts(userId, c.Variables.Int64["cash_request_time"]) log.Debug("promisedAmountListGen: %v", promisedAmountListGen) var data utils.DCAmounts if promisedAmountListGen[72].Amount > 0 { data = promisedAmountListGen[72] } else if promisedAmountListGen[23].Amount > 0 { data = promisedAmountListGen[23] } else { data = utils.DCAmounts{} } log.Debug("data: %v", data) promisedAmounts := "" prognosis := make(map[int64]float64) if data.Amount > 1 { promisedAmounts += RoundStr(utils.Float64ToStr(utils.Round(data.Amount, 0)), 0) + " " + currencyList[(data.CurrencyId)] + "<br>" prognosis[int64(data.CurrencyId)] += (math.Pow(1+data.PctSec, secs) - 1) * data.Amount } if len(promisedAmounts) > 0 { promisedAmounts = "<strong>" + promisedAmounts[:len(promisedAmounts)-4] + "</strong><br>" + c.Lang["promised"] + "<hr>" } /* * На кошельках * */ balances, err := c.GetBalances(userId) if err != nil { return "", err } walletsByCurrency := make(map[int]utils.DCAmounts) for _, data := range balances { walletsByCurrency[int(data.CurrencyId)] = data } log.Debug("walletsByCurrency[72].Amount: %v", walletsByCurrency[72].Amount) if walletsByCurrency[72].Amount > 0 { data = walletsByCurrency[72] } else if walletsByCurrency[23].Amount > 0 { data = walletsByCurrency[23] } else { data = utils.DCAmounts{} } log.Debug("data: %v", data) wallets := "" var countersIds []string var pctSec float64 if data.Amount > 0 { counterId := "map-" + utils.Int64ToStr(userId) + "-" + utils.Int64ToStr(data.CurrencyId) countersIds = append(countersIds, counterId) wallets = "<span class='dc_amount' id='" + counterId + "'>" + RoundStr(utils.Float64ToStr(data.Amount), 8) + "</span> d" + currencyList[(data.CurrencyId)] + "<br>" // прогноз prognosis[int64(data.CurrencyId)] += (math.Pow(1+data.PctSec, secs) - 1) * data.Amount pctSec = data.PctSec } if len(wallets) > 0 { wallets = wallets[:len(wallets)-4] + "<br>" + c.Lang["on_the_account"] + "<hr>" } /* * Годовой прогноз * */ prognosisHtml := "" for currencyId, amount := range prognosis { if amount < 0.01 { continue } else if amount < 1 { amount = utils.Round(amount, 2) } else { amount = amount } prognosisHtml += "<span class='amount_1year'>" + RoundStr(utils.Float64ToStr(amount), 2) + " d" + currencyList[(currencyId)] + "</span><br>" } if len(prognosisHtml) > 0 { prognosisHtml = prognosisHtml[:len(prognosisHtml)-4] + "<br> " + c.Lang["profit_forecast"] + " " + c.Lang["after_1_year"] } prognosisHtml = "" result_ := minersDataType{Hosts: hosts, Lnglat: map[string]string{"lng": minersData["longitude"], "lat": minersData["latitude"]}, Html: promisedAmounts + wallets + "<div style=\"clear:both\"></div>" + prognosisHtml + "</p>", Counters: countersIds, PctSec: pctSec} log.Debug("result_", result_) result, err := json.Marshal(result_) if err != nil { return "", err } log.Debug(string(result)) return string(result), nil }
func (p *Parser) VotesComplex() error { currencyVotes := make(map[string][]float64) if p.BlockData.BlockId > 77951 { vComplex, err := makeVcomplex(p.TxMap["json_data"]) if err != nil { return p.ErrInfo(err) } currencyVotes = vComplex.Currency // голоса за реф. % p.selectiveLoggingAndUpd([]string{"first", "second", "third"}, []interface{}{vComplex.Referral["first"], vComplex.Referral["second"], vComplex.Referral["third"]}, "votes_referral", []string{"user_id"}, []string{string(p.TxMap["user_id"])}) // раньше не было выборов админа if p.BlockData.BlockId >= 153750 && vComplex.Admin > 0 { p.selectiveLoggingAndUpd([]string{"admin_user_id", "time"}, []interface{}{vComplex.Admin, p.TxTime}, "votes_admin", []string{"user_id"}, []string{string(p.TxMap["user_id"])}) } } else { // раньше не было рефских и выбора админа vComplex := make(map[string][]float64) err := json.Unmarshal(p.TxMap["json_data"], &vComplex) if err != nil { return p.ErrInfo(err) } currencyVotes = vComplex } var currencyIds []int for k := range currencyVotes { currencyIds = append(currencyIds, utils.StrToInt(k)) } sort.Ints(currencyIds) //sort.Sort(sort.Reverse(sort.IntSlice(keys))) for _, currencyId := range currencyIds { data := currencyVotes[utils.IntToStr(currencyId)] currencyIdStr := utils.IntToStr(currencyId) UserIdStr := string(p.TxMap["user_id"]) // miner_pct err := p.selectiveLoggingAndUpd([]string{"pct", "time"}, []interface{}{utils.Float64ToStr(data[0]), p.TxTime}, "votes_miner_pct", []string{"user_id", "currency_id"}, []string{UserIdStr, currencyIdStr}) if err != nil { return p.ErrInfo(err) } // user_pct err = p.selectiveLoggingAndUpd([]string{"pct"}, []interface{}{utils.Float64ToStr(data[1])}, "votes_user_pct", []string{"user_id", "currency_id"}, []string{UserIdStr, currencyIdStr}) if err != nil { return p.ErrInfo(err) } // max_promised_amount err = p.selectiveLoggingAndUpd([]string{"amount"}, []interface{}{int64(data[2])}, "votes_max_promised_amount", []string{"user_id", "currency_id"}, []string{UserIdStr, currencyIdStr}) if err != nil { return p.ErrInfo(err) } // max_other_currencies err = p.selectiveLoggingAndUpd([]string{"count"}, []interface{}{int64(data[3])}, "votes_max_other_currencies", []string{"user_id", "currency_id"}, []string{UserIdStr, currencyIdStr}) if err != nil { return p.ErrInfo(err) } // reduction err = p.selectiveLoggingAndUpd([]string{"pct", "time"}, []interface{}{int64(data[4]), p.TxTime}, "votes_reduction", []string{"user_id", "currency_id"}, []string{UserIdStr, currencyIdStr}) if err != nil { return p.ErrInfo(err) } // проверим, не наш ли это user_id myUserId, myBlockId, myPrefix, _, err := p.GetMyUserId(p.TxUserID) if err != nil { return p.ErrInfo(err) } if p.TxUserID == myUserId && myBlockId <= p.BlockData.BlockId { // отметимся, что голосовали, чтобы не пришло уведомление о необходимости голосовать раз в 2 недели // может быть дубль, поэтому ошибки не проверяем p.ExecSql("INSERT INTO "+myPrefix+"my_complex_votes ( last_voting ) VALUES ( ? )", p.BlockData.Time) } } return nil }