func (c *Controller) Information() (string, error) {
var err error
alertMessages_, err := c.GetAll(`SELECT * FROM alert_messages ORDER BY id DESC`, -1)
var alertMessages []map[string]string
for _, v := range alertMessages_ {
show := false
if v["currency_list"] != "ALL" {
// проверим, есть ли у нас обещнные суммы с такой валютой
amounts, err := c.Single("SELECT id FROM promised_amount WHERE currency_id IN (" + v["currency_list"] + ")").Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if amounts > 0 {
show = true
}
} else {
show = true
}
if show {
alertMessages = append(alertMessages, map[string]string{"id": v["id"], "message": v["message"]})
}
}
TemplateStr, err := makeTemplate("information", "information", &InformationPage{
Lang: c.Lang,
AlertMessages: alertMessages})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) Upgrade5() (string, error) {
log.Debug("Upgrade5")
geolocationLat := ""
geolocationLon := ""
geolocation, err := c.Single("SELECT geolocation FROM " + c.MyPrefix + "my_table").String()
if err != nil {
return "", utils.ErrInfo(err)
}
if len(geolocation) > 0 {
x := strings.Split(geolocation, ", ")
if len(x) == 2 {
geolocationLat = x[0]
geolocationLon = x[1]
}
}
saveAndGotoStep := strings.Replace(c.Lang["save_and_goto_step"], "[num]", "7", -1)
upgradeMenu := utils.MakeUpgradeMenu(5)
TemplateStr, err := makeTemplate("upgrade_5", "upgrade5", &upgrade5Page{
Alert: c.Alert,
Lang: c.Lang,
SaveAndGotoStep: saveAndGotoStep,
UpgradeMenu: upgradeMenu,
GeolocationLat: geolocationLat,
GeolocationLon: geolocationLon,
UserId: c.SessUserId,
Mobile: utils.Mobile()})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) SaveNotifications() (string, error) {
if c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
c.r.ParseForm()
var data []map[string]interface{}
err := json.Unmarshal([]byte(c.r.PostFormValue("data")), &data)
if err != nil {
return "", utils.ErrInfo(err)
}
log.Debug("data:", data)
for k, _ := range data {
err := c.ExecSql(`
UPDATE `+c.MyPrefix+`my_notifications
SET email = ?,
sms = ?,
mobile = ?
WHERE name = ?
`, data[k]["email"].(float64), data[k]["sms"].(float64), data[k]["mobile"].(float64), data[k]["name"].(string))
if err != nil {
return "", utils.ErrInfo(err)
}
}
return `{"error":0}`, nil
}
func (a *AvailablekeyStruct) checkAvailableKey(key string) (int64, string, error) {
publicKeyAsn, err := utils.GetPublicFromPrivate(key)
if err != nil {
log.Debug("%v", err)
return 0, "", utils.ErrInfo(err)
}
log.Debug("publicKeyAsn: %s", publicKeyAsn)
userId, err := a.Single("SELECT user_id FROM users WHERE hex(public_key_0) = ?", publicKeyAsn).Int64()
if err != nil {
return 0, "", utils.ErrInfo(err)
}
log.Debug("userId: %s", userId)
if userId == 0 {
return 0, "", errors.New("null userId")
}
allTables, err := a.GetAllTables()
if err != nil {
return 0, "", utils.ErrInfo(err)
}
// может другой юзер уже начал смену ключа. актуально для пула
if utils.InSliceString(utils.Int64ToStr(userId)+"_my_table", allTables) {
return 0, "", errors.New("exists _my_table")
}
return userId, string(publicKeyAsn), nil
}
func Signals() {
SigChan = make(chan os.Signal, 1)
waitSig()
var Term os.Signal = syscall.SIGTERM
go func() {
signal.Notify(SigChan, os.Interrupt, os.Kill, Term)
<-SigChan
fmt.Println("KILL SIGNAL")
for _, ch := range utils.DaemonsChans {
fmt.Println("ch.ChBreaker<-true")
ch.ChBreaker <- true
}
for _, ch := range utils.DaemonsChans {
fmt.Println(<-ch.ChAnswer)
}
log.Debug("Daemons killed")
fmt.Println("Daemons killed")
if utils.DB != nil && utils.DB.DB != nil {
err := utils.DB.Close()
fmt.Println("DB Closed")
if err != nil {
log.Error("%v", utils.ErrInfo(err))
//panic(err)
}
}
err := os.Remove(*utils.Dir + "/dcoin.pid")
if err != nil {
log.Error("%v", utils.ErrInfo(err))
panic(err)
}
fmt.Println("removed " + *utils.Dir + "/dcoin.pid")
os.Exit(1)
}()
}
func (c *Controller) SaveUserCoords() (string, error) {
if c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
c.r.ParseForm()
coordsJson := c.r.FormValue("coords_json")
var coords [][2]int
err := json.Unmarshal([]byte(coordsJson), &coords)
if err != nil {
return "", err
}
coordsType := c.r.FormValue("type")
if coordsType != "face" && coordsType != "profile" {
return "", errors.New("Incorrect type")
}
coordsJson_, err := json.Marshal(coords)
if err != nil {
return "", err
}
err = c.ExecSql("UPDATE "+c.MyPrefix+"my_table SET "+coordsType+"_coords = ?", string(coordsJson_))
if err != nil {
return "", utils.ErrInfo(err)
}
return `{"success":"ok"}`, nil
}
func (c *Controller) SaveHost() (string, error) {
if c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
c.r.ParseForm()
http_host := c.r.FormValue("http_host")
if len(http_host) > 0 && http_host[len(http_host)-1:] != "/" {
http_host += "/"
}
tcp_host := c.r.FormValue("tcp_host")
if !utils.CheckInputData(http_host, "http_host") {
return `{"error":"1"}`, nil
}
if !utils.CheckInputData(tcp_host, "tcp_host") {
return `{"error":"1"}`, nil
}
err := c.ExecSql("UPDATE "+c.MyPrefix+"my_table SET http_host = ?, tcp_host = ?", http_host, tcp_host)
if err != nil {
return "", utils.ErrInfo(err)
}
return `{"error":"0"}`, nil
}
func (c *Controller) EData() (string, error) {
c.w.Header().Set("Access-Control-Allow-Origin", "*")
// сколько всего продается DC
eOrders, err := c.GetAll(`SELECT sell_currency_id, sum(amount) as amount FROM e_orders WHERE sell_currency_id < 1000 AND empty_time = 0 GROUP BY sell_currency_id`, 100)
if err != nil {
return "", utils.ErrInfo(err)
}
values := ""
for _, data := range eOrders {
values += utils.ClearNull(data["amount"], 0) + ` d` + c.CurrencyList[utils.StrToInt64(data["sell_currency_id"])] + `, `
}
if len(values) > 0 {
values = values[:len(values)-2]
}
ps, err := c.Single(`SELECT value FROM e_config WHERE name = 'ps'`).String()
if err != nil {
return "", utils.ErrInfo(err)
}
jsonData, err := json.Marshal(map[string]string{"values": values, "ps": ps})
if err != nil {
return "", utils.ErrInfo(err)
}
return string(jsonData), nil
}
func (c *Controller) CheckCfCurrency() (string, error) {
if c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
c.r.ParseForm()
projectCurrencyName := c.r.FormValue("project_currency_name")
if !utils.CheckInputData(projectCurrencyName, "cf_currency_name") {
return "", errors.New("incorrect project_currency_name")
}
// проверим, не занято ли имя валюты
currency, err := c.Single("SELECT id FROM cf_projects WHERE project_currency_name = ? AND close_block_id = 0 AND del_block_id = 0", projectCurrencyName).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if currency > 0 {
return `{"error":"` + c.Lang["currency_name_busy"] + `"}`, nil
}
// проверим, не занято ли имя валюты
currency, err = c.Single("SELECT id FROM cf_currency WHERE name = ?", projectCurrencyName).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if currency > 0 {
return `{"error":"` + c.Lang["currency_name_busy"] + `"}`, nil
}
return `{"success":"` + c.Lang["name_is_not_occupied"] + `"}`, nil
}
func (c *Controller) NewPhoto() (string, error) {
c.r.ParseForm()
userId := int64(utils.StrToFloat64(c.r.FormValue("user_id")))
data, err := c.OneRow("SELECT photo_block_id, photo_max_miner_id, miners_keepers FROM miners_data WHERE user_id = ?", userId).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)
// берем 1 случайный из 10-и ID майнеров
k := utils.RandInt(0, len(minersIds))
minerId := minersIds[k]
host, err := c.Single("SELECT http_host FROM miners_data WHERE miner_id = ?", minerId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
result, err := json.Marshal(map[string]string{"face": host + "public/face_" + utils.Int64ToStr(userId) + ".jpg", "profile": host + "public/profile_" + utils.Int64ToStr(userId) + ".jpg"})
if err != nil {
return "", utils.ErrInfo(err)
}
return string(result), nil
}
func (c *Controller) MoneyBackRequest() (string, error) {
txType := "MoneyBackRequest"
txTypeId := utils.TypeInt(txType)
timeNow := utils.Time()
orderId := int64(utils.StrToFloat64(c.Parameters["order_id"]))
order, err := c.OneRow("SELECT * FROM orders WHERE id = ?", orderId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
TemplateStr, err := makeTemplate("money_back_request", "moneyBackRequest", &moneyBackRequestPage{
Alert: c.Alert,
Lang: c.Lang,
ShowSignData: c.ShowSignData,
SignData: "",
UserId: c.SessUserId,
OrderId: orderId,
Order: order,
CountSignArr: c.CountSignArr,
TimeNow: timeNow,
TxType: txType,
TxTypeId: txTypeId})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (t *TcpServer) Type7() {
/* Выдаем тело указанного блока
* запрос шлет демон blocksCollection и queue_parser_blocks через p.GetBlocks()
*/
buf := make([]byte, 4)
_, err := t.Conn.Read(buf)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
blockId := utils.BinToDec(buf)
block, err := t.Single("SELECT data FROM block_chain WHERE id = ?", blockId).Bytes()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("blockId %x", blockId)
log.Debug("block %x", block)
err = utils.WriteSizeAndData(block, t.Conn)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
}
func (c *Controller) SaveEmailSms() (string, error) {
if !c.NodeAdmin || c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
c.r.ParseForm()
err := c.ExecSql(`
UPDATE `+c.MyPrefix+`my_table
SET email = ?,
smtp_server = ?,
use_smtp = ?,
smtp_port = ?,
smtp_ssl = ?,
smtp_auth = ?,
smtp_username = ?,
smtp_password = ?,
sms_http_get_request = ?
`, c.r.FormValue("email"), c.r.FormValue("smtp_server"), c.r.FormValue("use_smtp"), c.r.FormValue("smtp_port"), c.r.FormValue("smtp_ssl"), c.r.FormValue("smtp_auth"), c.r.FormValue("smtp_username"), c.r.FormValue("smtp_password"), c.r.FormValue("sms_http_get_request"))
if err != nil {
return "", utils.ErrInfo(err)
}
return "", nil
}
func (c *Controller) Chat() (string, error) {
myChatName := utils.Int64ToStr(c.SessUserId)
// возможно у отпарвителя есть ник
name, err := c.Single(`SELECT name FROM users WHERE user_id = ?`, c.SessUserId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
if len(name) > 0 {
myChatName = name
}
TemplateStr, err := makeTemplate("chat", "chat", &chatPage{
Community: c.Community,
CountSignArr: c.CountSignArr,
CountSign: c.CountSign,
Lang: c.Lang,
ShowSignData: c.ShowSignData,
SignData: "",
MyChatName: myChatName,
UserId: c.SessUserId,
IOS: utils.IOS(),
Mobile: utils.Mobile()})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) EPages() (string, error) {
var err error
var title, text string
if len(c.Parameters["page"]) > 0 {
if !utils.CheckInputData(c.Parameters["page"], "string") {
return "", utils.ErrInfo(err)
}
data, err := c.OneRow(`SELECT title, text from e_pages WHERE name = ? AND lang = ?`, c.Parameters["page"], c.LangInt).String()
if err != nil {
return "", utils.ErrInfo(err)
}
title = data["title"]
text = data["text"]
}
TemplateStr, err := makeTemplate("e_pages", "ePages", &ePages{
Lang: c.Lang,
Title: title,
Text: text})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) EncryptChatMessage() (string, error) {
var err error
c.r.ParseForm()
receiver := c.r.FormValue("receiver")
message := c.r.FormValue("message")
if len(message) > 5120 {
return "", errors.New("incorrect message")
}
publicKey, err := c.Single("SELECT public_key_0 FROM users WHERE user_id = ?", receiver).Bytes()
if err != nil {
return "", utils.ErrInfo(err)
}
if len(publicKey) > 0 {
pub, err := utils.BinToRsaPubKey(publicKey)
if err != nil {
return "", utils.ErrInfo(err)
}
enc_, err := rsa.EncryptPKCS1v15(rand.Reader, pub, []byte(message))
if err != nil {
return "", utils.ErrInfo(err)
}
return utils.JsonAnswer(string(utils.BinToHex(enc_)), "success").String(), nil
} else {
return utils.JsonAnswer("Incorrect user_id", "error").String(), nil
}
}
func (c *Controller) ELogin() (string, error) {
c.r.ParseForm()
email := c.r.FormValue("email")
password := c.r.FormValue("password")
if len(password) > 50 || len(password) < 1 {
return "", errors.New(c.Lang["invalid_pass"])
}
data, err := c.OneRow("SELECT id, salt FROM e_users WHERE email = ?", email).String()
if err != nil {
return "", utils.ErrInfo(err)
}
if len(data) == 0 {
return "", errors.New(c.Lang["email_is_not_registered"])
}
// проверяем, верный ли пароль
passAndSalt := utils.Sha256(password + data["salt"])
userId, err := utils.DB.Single("SELECT id FROM e_users WHERE id = ? AND password = ?", data["id"], passAndSalt).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if userId == 0 {
return "", errors.New(c.Lang["wrong_pass"])
}
c.sess.Set("e_user_id", userId)
return utils.JsonAnswer("success", "success").String(), nil
}
func (c *Controller) ERedirect() (string, error) {
c.r.ParseForm()
token := c.r.FormValue("FormToken")
amount := c.r.FormValue("FormExAmount")
buyCurrencyId := utils.StrToInt64(c.r.FormValue("FormDC"))
if !utils.CheckInputData(token, "string") {
return "", errors.New("incorrect data")
}
// order_id занесем когда поуступят деньги в платежной системе
err := c.ExecSql(`UPDATE e_tokens SET buy_currency_id = ?, amount_fiat = ? WHERE token = ?`, buyCurrencyId, utils.StrToFloat64(c.r.FormValue("FormExAmount")), token)
if err != nil {
return "", utils.ErrInfo(err)
}
tokenId, err := c.Single(`SELECT id FROM e_tokens WHERE token = ?`, token).String()
if err != nil {
return "", utils.ErrInfo(err)
}
TemplateStr, err := makeTemplate("e_redirect", "eRedirect", &ERedirectPage{
Lang: c.Lang,
EConfig: c.EConfig,
TokenId: tokenId,
EURL: c.EURL,
MDesc: base64.StdEncoding.EncodeToString([]byte("token-" + tokenId)),
Amount: amount})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) EMyHistory() (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
}
currencyList, err := utils.EGetCurrencyList()
if err != nil {
return "", utils.ErrInfo(err)
}
//fmt.Println("currencyList", currencyList)
var myHistory []*EmyHistory
rows, err := c.Query(c.FormatQuery(`
SELECT id, time, amount, sell_rate, sell_currency_id, buy_currency_id
FROM e_trade
WHERE user_id = ?
ORDER BY time DESC
LIMIT 40
`), c.SessUserId)
if err != nil {
return "", utils.ErrInfo(err)
}
defer rows.Close()
for rows.Next() {
myHist := new(EmyHistory)
err = rows.Scan(&myHist.Id, &myHist.Time, &myHist.Amount, &myHist.SellRate, &myHist.SellCurrencyId, &myHist.BuyCurrencyId)
if err != nil {
return "", utils.ErrInfo(err)
}
// определим тип ордера и пару
if myHist.SellCurrencyId < 1000 {
myHist.OrderType = "sell"
myHist.SellRate = 1 / myHist.SellRate
myHist.Total = myHist.Amount * myHist.SellRate
myHist.Amount = myHist.Amount
myHist.Pair = currencyList[myHist.SellCurrencyId] + "/" + currencyList[myHist.BuyCurrencyId]
} else {
myHist.OrderType = "buy"
myHist.Total = myHist.Amount
myHist.Amount = myHist.Amount * (1 / myHist.SellRate)
myHist.Pair = currencyList[myHist.BuyCurrencyId] + "/" + currencyList[myHist.SellCurrencyId]
}
myHistory = append(myHistory, myHist)
}
TemplateStr, err := makeTemplate("e_my_history", "eMyHistory", &eMyHistoryPage{
Lang: c.Lang,
UserId: c.SessUserId,
MyHistory: myHistory,
CurrencyList: currencyList})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) DelCfProject() (string, error) {
var err error
txType := "DelCfProject"
txTypeId := utils.TypeInt(txType)
timeNow := utils.Time()
delId := int64(utils.StrToFloat64(c.Parameters["del_id"]))
projectCurrencyName, err := c.Single("SELECT project_currency_name FROM cf_projects WHERE id = ?", delId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
TemplateStr, err := makeTemplate("del_cf_project", "delCfProject", &DelCfProjectPage{
Alert: c.Alert,
Lang: c.Lang,
CountSignArr: c.CountSignArr,
ShowSignData: c.ShowSignData,
SignData: fmt.Sprintf(`%d,%d,%d,%d`, txTypeId, timeNow, c.SessUserId, delId),
UserId: c.SessUserId,
TimeNow: timeNow,
TxType: txType,
TxTypeId: txTypeId,
DelId: delId,
ProjectCurrencyName: projectCurrencyName})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) ESignUp() (string, error) {
c.r.ParseForm()
email := c.r.FormValue("email")
password := c.r.FormValue("password")
if len(password) > 50 || len(password) < 1 {
return "", errors.New(c.Lang["invalid_pass"])
}
existsEmail, err := c.Single("SELECT id FROM e_users WHERE email = ?", email).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if existsEmail > 0 {
return "", errors.New(c.Lang["exists_email"])
}
salt := utils.RandSeq(32)
passAndSalt := utils.DSha256(password + salt)
userId, err := c.ExecSqlGetLastInsertId("INSERT INTO e_users ( email, password, ip, salt ) VALUES ( ?, ?, ?, ? )", "id", email, passAndSalt, c.r.RemoteAddr, salt)
if err != nil {
return "", utils.ErrInfo(err)
}
c.sess.Set("e_user_id", userId)
return utils.JsonAnswer("success", "success").String(), nil
}
func (c *Controller) CfCatalog() (string, error) {
var err error
log.Debug("CfCatalog")
categoryId := utils.Int64ToStr(int64(utils.StrToFloat64(c.Parameters["category_id"])))
log.Debug("categoryId", categoryId)
var curCategory string
addSql := ""
if categoryId != "0" {
addSql = `AND category_id = ` + categoryId
curCategory = c.Lang["cf_category_"+categoryId]
}
cfUrl := ""
projects := make(map[string]map[string]string)
cfProjects, err := c.GetAll(`
SELECT cf_projects.id, lang_id, blurb_img, country, city, currency_id, end_time, amount
FROM cf_projects
LEFT JOIN cf_projects_data ON cf_projects_data.project_id = cf_projects.id
WHERE del_block_id = 0 AND
end_time > ? AND
lang_id = ?
`+addSql+`
ORDER BY funders DESC
LIMIT 100
`, 100, utils.Time(), c.LangInt)
if err != nil {
return "", utils.ErrInfo(err)
}
for _, data := range cfProjects {
CfProjectData, err := c.GetCfProjectData(utils.StrToInt64(data["id"]), utils.StrToInt64(data["end_time"]), c.LangInt, utils.StrToFloat64(data["amount"]), cfUrl)
if err != nil {
return "", utils.ErrInfo(err)
}
for k, v := range CfProjectData {
data[k] = v
}
projects[data["id"]] = data
}
cfCategory := utils.MakeCfCategories(c.Lang)
TemplateStr, err := makeTemplate("cf_catalog", "cfCatalog", &cfCatalogPage{
Lang: c.Lang,
CfCategory: cfCategory,
CurrencyList: c.CurrencyList,
CurCategory: curCategory,
Projects: projects,
UserId: c.SessUserId,
CategoryId: categoryId,
CfUrl: cfUrl})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
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) ChangeHost() (string, error) {
txType := "ChangeHost"
txTypeId := utils.TypeInt(txType)
timeNow := utils.Time()
if !c.PoolAdmin || c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("access denied"))
}
data, err := c.OneRow("SELECT http_host, tcp_host, host_status FROM " + c.MyPrefix + "my_table").String()
if err != nil {
return "", utils.ErrInfo(err)
}
data2, err := c.OneRow("SELECT http_host, tcp_host, e_host FROM miners_data WHERE user_id = ?", c.SessUserId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
if len(data["http_host"]) == 0 {
data["http_host"] = data2["http_host"]
}
if len(data["tcp_host"]) == 0 {
data["tcp_host"] = data2["tcp_host"]
}
if len(data["e_host"]) == 0 {
data["e_host"] = data2["e_host"]
}
if data["e_host"] == "" {
data["e_host"] = "0"
}
statusArray := map[string]string{"my_pending": c.Lang["local_pending"], "approved": c.Lang["status_approved"]}
data["host_status"] = statusArray[data["host_status"]]
limitsText := strings.Replace(c.Lang["change_host_limits_text"], "[limit]", utils.Int64ToStr(c.Variables.Int64["limit_change_host"]), -1)
limitsText = strings.Replace(limitsText, "[period]", c.Periods[c.Variables.Int64["limit_change_host_period"]], -1)
TemplateStr, err := makeTemplate("change_host", "changeHost", &changeHostPage{
Alert: c.Alert,
UserId: c.SessUserId,
CountSignArr: c.CountSignArr,
Data: data,
TimeNow: timeNow,
TxType: txType,
TxTypeId: txTypeId,
LimitsText: limitsText,
ShowSignData: c.ShowSignData,
Community: c.Community,
SignData: "",
Lang: c.Lang})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (c *Controller) EGateIk() (string, error) {
c.r.ParseForm()
fmt.Println(c.r.Form)
var ikNames []string
for name, _ := range c.r.Form {
if name[:2] == "ik" && name != "ik_sign" {
ikNames = append(ikNames, name)
}
}
sort.Strings(ikNames)
fmt.Println(ikNames)
var ikValues []string
for _, names := range ikNames {
ikValues = append(ikValues, c.r.FormValue(names))
}
ikValues = append(ikValues, c.EConfig["ik_s_key"])
fmt.Println(ikValues)
sign := strings.Join(ikValues, ":")
fmt.Println(sign)
sign = base64.StdEncoding.EncodeToString(utils.HexToBin(utils.Md5(sign)))
fmt.Println(sign)
if sign != c.r.FormValue("ik_sign") {
return "", errors.New("Incorrect signature")
}
currencyId := int64(0)
if c.r.FormValue("ik_cur") == "USD" {
currencyId = 1001
}
if currencyId == 0 {
return "", errors.New("Incorrect currencyId")
}
amount := utils.StrToFloat64(c.r.FormValue("ik_am"))
pmId := utils.StrToInt64(c.r.FormValue("ik_inv_id"))
// проверим, не зачисляли ли мы уже это платеж
existsId, err := c.Single(`SELECT id FROM e_adding_funds_ik WHERE id = ?`, pmId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if existsId != 0 {
return "", errors.New("Incorrect ik_inv_id")
}
paymentInfo := c.r.FormValue("ik_desc")
txTime := utils.Time()
err = EPayment(paymentInfo, currencyId, txTime, amount, pmId, "ik", c.ECommission)
if err != nil {
return "", utils.ErrInfo(err)
}
return ``, nil
}
func (c *Controller) Upgrade4() (string, error) {
log.Debug("Upgrade4")
videoUrl := ""
// есть ли загруженное видео.
data, err := c.OneRow("SELECT video_url_id, video_type FROM " + c.MyPrefix + "my_table").String()
if err != nil {
return "", utils.ErrInfo(err)
}
switch data["video_type"] {
case "youtube":
videoUrl = "http://www.youtube.com/embed/" + data["video_url_id"]
case "vimeo":
videoUrl = "http://www.vimeo.com/embed/" + data["video_url_id"]
case "youku":
videoUrl = "http://www.youku.com/embed/" + data["video_url_id"]
}
saveAndGotoStep := strings.Replace(c.Lang["save_and_goto_step"], "[num]", "6", -1)
upgradeMenu := utils.MakeUpgradeMenu(4)
var userVideoMp4 string
path := *utils.Dir + "/public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.mp4"
if _, err := os.Stat(path); err == nil {
userVideoMp4 = "/public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.mp4"
}
var userVideoWebm string
path = *utils.Dir + "/public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.webm"
if _, err := os.Stat(path); err == nil {
userVideoWebm = "/public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.webm"
}
var userVideoOgg string
path = *utils.Dir + "/public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.ogg"
if _, err := os.Stat(path); err == nil {
userVideoOgg = "/public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.ogg"
}
TemplateStr, err := makeTemplate("upgrade_4", "upgrade4", &upgrade4Page{
Alert: c.Alert,
Lang: c.Lang,
SaveAndGotoStep: saveAndGotoStep,
UpgradeMenu: upgradeMenu,
VideoUrl: videoUrl,
UserVideoMp4: userVideoMp4,
UserVideoWebm: userVideoWebm,
UserVideoOgg: userVideoOgg,
Mobile: utils.Mobile(),
UserId: c.SessUserId})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, 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 (c *Controller) RestartDb() (string, error) {
if ok, _ := regexp.MatchString(`(\:\:)|(127\.0\.0\.1)`, c.r.RemoteAddr); ok {
err := daemons.ClearDb(nil, "")
if err != nil {
return "", utils.ErrInfo(err)
}
} else {
return "", utils.ErrInfo("Access denied for " + c.r.RemoteAddr)
}
return "", nil
}
func (c *Controller) RewritePrimaryKeySave() (string, error) {
if !c.NodeAdmin || c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
if len(c.r.FormValue("n")) > 0 {
c.r.ParseForm()
n := []byte(c.r.FormValue("n"))
e := []byte(c.r.FormValue("e"))
if !utils.CheckInputData(n, "hex") {
return "", utils.ErrInfo(errors.New("incorrect n"))
}
if !utils.CheckInputData(e, "hex") {
return "", utils.ErrInfo(errors.New("incorrect e"))
}
publicKey := utils.MakeAsn1(n, e)
// проверим, есть ли вообще такой публичный ключ
userId, err := c.Single("SELECT user_id FROM users WHERE hex(public_key_0) = ?", publicKey).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if userId == 0 {
return "", utils.ErrInfo(errors.New("incorrect public_key"))
}
// может быть юзер уже майнер?
minerId, err := c.GetMinerId(userId)
if err != nil {
return "", utils.ErrInfo(err)
}
status := ""
if minerId > 0 {
status = "miner"
} else {
status = "user"
}
err = c.ExecSql(`DELETE FROM my_keys`)
if err != nil {
return "", utils.ErrInfo(err)
}
err = c.ExecSql(`INSERT INTO `+c.MyPrefix+`my_keys (public_key, status) VALUES ([hex], ?)`, publicKey, "approved")
if err != nil {
return "", utils.ErrInfo(err)
}
err = c.ExecSql(`UPDATE `+c.MyPrefix+`my_table SET user_id = ?, miner_id = ?, status = ?`, userId, minerId, status)
if err != nil {
return "", utils.ErrInfo(err)
}
}
return `{"success":"success"}`, nil
}
func (p *Parser) NewAutoPaymentRollback() error {
//fmt.Println(p.TxMap)
affect, err := p.ExecSqlGetAffect("DELETE FROM auto_payments WHERE block_id = ? and sender = ?", p.BlockData.BlockId, p.TxUserID)
if err != nil {
return utils.ErrInfo(err)
}
err = p.rollbackAI("auto_payments", affect)
if err != nil {
return utils.ErrInfo(err)
}
return err
}