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 (db *DCDB) MakeFrontTest(transactionArray []string, time int64, dataForSign string, txType string, userId int64) error {
var err error
nodeArr := []string{"new_admin", "votes_node_new_miner"}
MY_PREFIX := utils.Int64ToStr(userId) + "_"
var binSign []byte
if utils.InSliceString(txType, nodeArr) {
k, err := db.GetNodePrivateKey(MY_PREFIX)
privateKey, err := MakePrivateKey(k)
if err != nil {
return ErrInfo(err)
}
binSign, err = rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA1, utils.HashSha1(dataForSign))
} else {
k, err := db.GetPrivateKey(MY_PREFIX)
privateKey, err := MakePrivateKey(k)
if err != nil {
return ErrInfo(err)
}
binSign, err = rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA1, utils.HashSha1(dataForSign))
binSign = EncodeLengthPlusData(binSign)
}
transactionArray = append(transactionArray, binSign)
parser := new(Parser)
parser.DCDB = db
parser.GoroutineName = "test"
parser.TxSlice = transactionArray
parser.BlockData = &utils.BlockData{BlockId: 190006, Time: time, UserId: userId}
parser.TxHash = "111111111111111"
err0 := utils.CallMethod(parser, txType+"Init")
if i, ok := err0.(error); ok {
fmt.Println(err0.(error), i)
return err0.(error)
}
err0 := utils.CallMethod(parser, txType+"Front")
if i, ok := err0.(error); ok {
fmt.Println(err0.(error), i)
return err0.(error)
}
err0 := utils.CallMethod(parser, txType+"RollbackFront")
if i, ok := err0.(error); ok {
fmt.Println(err0.(error), i)
return err0.(error)
}
return nil
}
func (c *Controller) BlockExplorer() (string, error) {
var err error
blockId := int64(utils.StrToFloat64(c.Parameters["blockId"]))
start := int64(utils.StrToFloat64(c.Parameters["start"]))
var data, sql string
if start > 0 || (start == 0 && blockId == 0) {
if start == 0 && blockId == 0 {
data += "<h3>Latest Blocks</h3>"
sql = ` SELECT data, hash
FROM block_chain
ORDER BY id DESC
LIMIT 15`
} else {
sql = ` SELECT data, hash
FROM block_chain
ORDER BY id ASC
LIMIT ` + utils.Int64ToStr(start-1) + `, 100`
}
data += `<table class="table"><tr><th>Block</th><th>Hash</th><th>Time</th><th><nobr>User id</nobr></th><th><nobr>Miner id</nobr></th><th>Level</th><th>Transactions</th></tr>`
blocksChain, err := c.GetAll(sql, -1)
if err != nil {
return "", utils.ErrInfo(err)
}
for _, blockData := range blocksChain {
hash := utils.BinToHex([]byte(blockData["hash"]))
binaryData := []byte(blockData["data"])
parser := new(dcparser.Parser)
parser.DCDB = c.DCDB
parser.BinaryData = binaryData
err = parser.ParseDataLite()
parser.BlockData.Sign = utils.BinToHex(parser.BlockData.Sign)
minerId, err := c.GetMinerId(parser.BlockData.UserId)
if err != nil {
return "", utils.ErrInfo(err)
}
data += fmt.Sprintf(`<tr><td><a href="#" onclick="dc_navigate('blockExplorer', {'blockId':%d})">%d</a></td><td>%s</td><td><nobr><span class='unixtime'>%d</span></nobr></td><td>%d</td><td>%d</td><td>%d</td><td>`, parser.BlockData.BlockId, parser.BlockData.BlockId, hash, parser.BlockData.Time, parser.BlockData.UserId, minerId, parser.BlockData.Level)
data += utils.IntToStr(len(parser.TxMapArr))
data += "</td></tr>"
}
data += "</table>"
} else if blockId > 0 {
data += `<table class="table">`
blockChain, err := c.OneRow("SELECT data, hash, cur_0l_miner_id, max_miner_id FROM block_chain WHERE id = ?", blockId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
binToHexArray := []string{"sign", "public_key", "encrypted_message", "comment", "bin_public_keys"}
hash := utils.BinToHex([]byte(blockChain["hash"]))
binaryData := blockChain["data"]
parser := new(dcparser.Parser)
parser.DCDB = c.DCDB
parser.BinaryData = []byte(binaryData)
err = parser.ParseDataLite()
if err != nil {
return "", utils.ErrInfo(err)
}
parser.BlockData.Sign = utils.BinToHex(parser.BlockData.Sign)
previous := parser.BlockData.BlockId - 1
next := parser.BlockData.BlockId + 1
levelsRange := utils.GetBlockGeneratorMinerIdRange(utils.StrToInt64(blockChain["cur_0l_miner_id"]), utils.StrToInt64(blockChain["max_miner_id"]))
minerId, err := c.GetMinerId(parser.BlockData.UserId)
if err != nil {
return "", utils.ErrInfo(err)
}
_, _, _, CurrentUserId, _, _, _ := c.TestBlock()
maxMinerId, err := c.Single("SELECT max(miner_id) FROM miners").Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
currentMinerId, err := c.Single("SELECT miner_id FROM miners_data WHERE user_id = ?", CurrentUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
NextBlockLevelsRange := utils.GetBlockGeneratorMinerIdRange(currentMinerId, maxMinerId)
data += fmt.Sprintf(`<tr><td><strong>Raw data</strong></td><td><a href='ajax?controllerName=getBlock&id=%d&download=1' target='_blank'>Download</a></td></tr>`, parser.BlockData.BlockId)
data += fmt.Sprintf(`<tr><td><strong>Block_id</strong></td><td>%d (<a href="#" onclick="dc_navigate('blockExplorer', {'blockId':%d})">Previous</a> / <a href="#" onclick="dc_navigate('blockExplorer', {'blockId':%d})">Next</a> )</td></tr>`, parser.BlockData.BlockId, previous, next)
data += fmt.Sprintf(`<tr><td><strong>Hash</strong></td><td>%s</td></tr>`, hash)
data += fmt.Sprintf(`<tr><td><strong>Time</strong></td><td><span class='unixtime'>%d</span> / %d</td></tr>`, parser.BlockData.Time, parser.BlockData.Time)
data += fmt.Sprintf(`<tr><td><strong>User_id</strong></td><td>%d</td></tr>`, parser.BlockData.UserId)
data += fmt.Sprintf(`<tr><td><strong>Miner_Id</strong></td><td>%d</td></tr>`, minerId)
data += fmt.Sprintf(`<tr><td><strong>Level</strong></td><td>%d (%v) next: %v</td></tr>`, parser.BlockData.Level, levelsRange, NextBlockLevelsRange)
data += fmt.Sprintf(`<tr><td><strong>Sign</strong></td><td>%s</td></tr>`, parser.BlockData.Sign)
if len(parser.TxMapArr) > 0 {
data += `<tr><td><strong>Transactions</strong></td><td><div><pre style='width: 700px'>`
for i := 0; i < len(parser.TxMapArr); i++ {
for k, data_ := range parser.TxMapArr[i] {
if utils.InSliceString(k, binToHexArray) {
parser.TxMapArr[i][k] = utils.BinToHex(data_)
}
if k == "file" {
parser.TxMapArr[i][k] = []byte("file size: " + utils.IntToStr(len(data_)))
} else if k == "code" {
parser.TxMapArr[i][k] = utils.DSha256(data_)
} else if k == "secret" {
parser.TxMapArr[i][k] = utils.BinToHex(data_)
}
data += fmt.Sprintf("%v : %s\n", k, parser.TxMapArr[i][k])
}
data += "\n\n"
}
data += "</pre></div></td></tr>"
}
data += "</table>"
}
// пока панель тут
myNotice := make(map[string]string)
if c.SessUserId > 0 {
myNotice, err = c.GetMyNoticeData(c.SessUserId, c.SessUserId, c.MyPrefix, c.Lang)
if err != nil {
return "", utils.ErrInfo(err)
}
}
TemplateStr, err := makeTemplate("block_explorer", "blockExplorer", &BlockExplorerPage{
Lang: c.Lang,
CurrencyList: c.CurrencyListCf,
MyNotice: myNotice,
Data: data,
Start: start,
BlockId: blockId,
PoolAdmin: c.PoolAdmin,
SessRestricted: c.SessRestricted,
UserId: c.SessUserId})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func (d *daemon) chatConnector() {
log.Debug("start chatConnector")
maxMinerId, err := d.Single("SELECT max(miner_id) FROM miners_data").Int64()
if err != nil {
log.Error("%v", err)
}
if maxMinerId == 0 {
maxMinerId = 1
}
q := ""
if d.ConfigIni["db_type"] == "postgresql" {
q = "SELECT DISTINCT ON (tcp_host) tcp_host, user_id FROM miners_data WHERE miner_id IN (" + strings.Join(utils.RandSlice(1, maxMinerId, consts.COUNT_CHAT_NODES), ",") + ")"
} else {
q = "SELECT tcp_host, user_id FROM miners_data WHERE miner_id IN (" + strings.Join(utils.RandSlice(1, maxMinerId, consts.COUNT_CHAT_NODES), ",") + ") GROUP BY tcp_host"
}
hosts, err := d.GetAll(q, consts.COUNT_CHAT_NODES)
if err != nil {
log.Error("%v", err)
}
// исключим себя
myTcpHost, err := d.Single(`SELECT tcp_host FROM miners_data WHERE user_id = ?`, myUserIdForChat).String()
if err != nil {
log.Error("%v", err)
}
fmt.Println("myTcpHost:", myTcpHost)
// исключим хосты, к которым уже подключены
var uids string
for userId, _ := range utils.ChatOutConnections {
uids += utils.Int64ToStr(userId) + ","
}
if len(uids) > 0 {
uids = uids[:len(uids)-1]
}
existsTcpHost, err := d.GetList(`SELECT tcp_host FROM miners_data WHERE user_id IN (` + uids + `)`).String()
if err != nil {
log.Error("%v", err)
}
log.Debug("hosts: %v", hosts)
for _, data := range hosts {
host := data["tcp_host"]
userId := utils.StrToInt64(data["user_id"])
if host == myTcpHost || utils.InSliceString(host, existsTcpHost) {
continue
}
go func(host string, userId int64) {
log.Debug("host: %v", host)
log.Debug("userId: %d", userId)
re := regexp.MustCompile(`(.*?):[0-9]+$`)
match := re.FindStringSubmatch(host)
log.Debug("match: %v", match)
if len(match) != 0 {
log.Debug("myUserIdForChat %v", myUserIdForChat)
log.Debug("chat host: %v", match[1]+":"+consts.CHAT_PORT)
chatHost := match[1] + ":" + consts.CHAT_PORT
//chatHost := "192.168.150.30:8087"
// проверим, нет ли уже созданных каналов для такого хоста
if _, ok := utils.ChatOutConnections[userId]; !ok {
// канал для приема тр-ий чата
conn, err := net.DialTimeout("tcp", chatHost, 5*time.Second)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
} else {
log.Debug(conn.RemoteAddr().String(), conn)
myUid := utils.DecToBin(myUserIdForChat, 4)
log.Debug("myUid %x", myUid)
n, err := conn.Write(myUid)
log.Debug("n: %d", n)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
n, err = conn.Write(utils.DecToBin(1, 1))
log.Debug("n: %d", n)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
fmt.Println("connector ChatInput", conn.RemoteAddr(), utils.Time())
log.Debug("connector ChatInput %s %v", conn.RemoteAddr(), utils.Time())
utils.ChatMutex.Lock()
utils.ChatInConnections[userId] = 1
utils.ChatMutex.Unlock()
go utils.ChatInput(conn, userId)
}
// канал для отправки тр-ий чата
conn2, err := net.DialTimeout("tcp", chatHost, 5*time.Second)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
} else {
log.Debug(conn2.RemoteAddr().String(), conn2)
n, err := conn2.Write(utils.DecToBin(myUserIdForChat, 4))
log.Debug("n: %d", n)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
n, err = conn2.Write(utils.DecToBin(0, 1))
log.Debug("n: %d", n)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
fmt.Println("connector ADD", userId, conn2.RemoteAddr(), utils.Time())
log.Debug("connector ADD %v %s %v", userId, conn2.RemoteAddr(), utils.Time())
connChan := make(chan *utils.ChatData, 100)
utils.ChatMutex.Lock()
utils.ChatOutConnections[userId] = &utils.ChatOutConnectionsType{MessIds: []int64{}, ConnectionChan: connChan}
utils.ChatMutex.Unlock()
fmt.Println("ChatOutConnections", utils.ChatOutConnections)
utils.ChatTxDisseminator(conn2, userId, connChan)
}
}
}
}(host, userId)
}
}
func (c *Controller) SaveDecryptComment() (string, error) {
if c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
c.r.ParseForm()
commentType := c.r.FormValue("type")
id := utils.StrToInt64(c.r.FormValue("id"))
comment := c.r.FormValue("comment")
if !utils.InSliceString(commentType, []string{"chat", "dc_transactions", "arbitrator", "seller", "cash_requests", "comments"}) {
return "", utils.ErrInfo(errors.New("incorrect type"))
}
// == если мы майнер и это dc_transactions, то сюда прислан зашифрованный коммент, который можно расшифровать только нод-кдючем
minerId, err := c.GetMinerId(c.SessUserId)
if err != nil {
return "", utils.ErrInfo(err)
}
if minerId > 0 && utils.InSliceString(commentType, []string{"dc_transactions", "arbitrator", "seller"}) {
nodePrivateKey, err := c.GetNodePrivateKey(c.MyPrefix)
// расшифруем коммент
rsaPrivateKey, err := utils.MakePrivateKey(nodePrivateKey)
if err != nil {
return "", utils.ErrInfo(err)
}
comment_, err := rsa.DecryptPKCS1v15(rand.Reader, rsaPrivateKey, utils.HexToBin([]byte(comment)))
if err != nil {
return "", utils.ErrInfo(err)
}
comment = string(comment_)
}
comment = template.HTMLEscapeString(comment)
if len(comment) > 0 {
if utils.InSliceString(commentType, []string{"arbitrator", "seller"}) {
err = c.ExecSql(`
UPDATE `+c.MyPrefix+`my_comments
SET comment = ?,
comment_status = ?
WHERE id = ? AND type = ?`, comment, "decrypted", id, commentType)
if err != nil {
return "", utils.ErrInfo(err)
}
} else if commentType == "chat" {
err = c.ExecSql(`
UPDATE chat
SET enc_message = message,
message = ?,
status = ?
WHERE id = ? AND receiver = ?`, comment, 2, id, c.SessUserId)
if err != nil {
return "", utils.ErrInfo(err)
}
} else {
err = c.ExecSql(`
UPDATE `+c.MyPrefix+`my_`+commentType+`
SET comment = ?,
comment_status = 'decrypted'
WHERE id = ?`, comment, id)
if err != nil {
return "", utils.ErrInfo(err)
}
}
} else {
comment = "NULL"
}
return comment, nil
}
func (c *Controller) PoolAdminControl() (string, error) {
if !c.PoolAdmin {
return "", utils.ErrInfo(errors.New("access denied"))
}
allTable, err := c.GetAllTables()
if err != nil {
return "", utils.ErrInfo(err)
}
// удаление юзера с пула
delId := int64(utils.StrToFloat64(c.Parameters["del_id"]))
if delId > 0 {
for _, table := range consts.MyTables {
if utils.InSliceString(utils.Int64ToStr(delId)+"_"+table, allTable) {
err = c.ExecSql("DROP TABLE " + utils.Int64ToStr(delId) + "_" + table)
if err != nil {
return "", utils.ErrInfo(err)
}
}
}
err = c.ExecSql("DELETE FROM community WHERE user_id = ?", delId)
if err != nil {
return "", utils.ErrInfo(err)
}
}
if _, ok := c.Parameters["pool_tech_works"]; ok {
poolTechWorks := int64(utils.StrToFloat64(c.Parameters["pool_tech_works"]))
poolMaxUsers := int64(utils.StrToFloat64(c.Parameters["pool_max_users"]))
commission := c.Parameters["commission"]
//if len(commission) > 0 && !utils.CheckInputData(commission, "commission") {
// return "", utils.ErrInfo(errors.New("incorrect commission"))
//}
err = c.ExecSql("UPDATE config SET pool_tech_works = ?, pool_max_users = ?, commission = ?", poolTechWorks, poolMaxUsers, commission)
if err != nil {
return "", utils.ErrInfo(err)
}
}
community, err := c.GetCommunityUsers() // получаем новые данные, т.к. выше было удаление
var users []map[int64]map[string]string
for _, uid := range community {
if uid != c.SessUserId {
if utils.InSliceString(utils.Int64ToStr(uid)+"_my_table", allTable) {
data, err := c.OneRow("SELECT miner_id, email FROM " + utils.Int64ToStr(uid) + "_my_table LIMIT 1").String()
if err != nil {
return "", utils.ErrInfo(err)
}
users = append(users, map[int64]map[string]string{uid: data})
}
}
}
log.Debug("users", users)
// лист ожидания попадания в пул
waitingList, err := c.GetAll("SELECT * FROM pool_waiting_list", -1)
config, err := c.GetNodeConfig()
TemplateStr, err := makeTemplate("pool_admin", "poolAdmin", &poolAdminPage{
Alert: c.Alert,
Lang: c.Lang,
ShowSignData: c.ShowSignData,
SignData: "",
Config: config,
Users: users,
UserId: c.SessUserId,
WaitingList: waitingList,
CountSignArr: c.CountSignArr})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
func Shop(chBreaker chan bool, chAnswer chan string) {
defer func() {
if r := recover(); r != nil {
log.Error("daemon Recovered", r)
panic(r)
}
}()
const GoroutineName = "Shop"
d := new(daemon)
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
d.goRoutineName = GoroutineName
d.chAnswer = chAnswer
d.chBreaker = chBreaker
if utils.Mobile() {
d.sleepTime = 3600
} else {
d.sleepTime = 120
}
if !d.CheckInstall(chBreaker, chAnswer, GoroutineName) {
return
}
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
BEGIN:
for {
log.Info(GoroutineName)
MonitorDaemonCh <- []string{GoroutineName, utils.Int64ToStr(utils.Time())}
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
myBlockId, err := d.GetMyBlockId()
blockId, err := d.GetBlockId()
if myBlockId > blockId {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
currencyList, err := d.GetCurrencyList(false)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
// нужно знать текущий блок, который есть у большинства нодов
blockId, err = d.GetConfirmedBlockId()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
// сколько должно быть подтверждений, т.е. кол-во блоков сверху
confirmations := int64(5)
// берем всех юзеров по порядку
community, err := d.GetCommunityUsers()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
for _, userId := range community {
privateKey := ""
myPrefix := utils.Int64ToStr(userId) + "_"
allTables, err := d.GetAllTables()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if !utils.InSliceString(myPrefix+"my_keys", allTables) {
continue
}
// проверим, майнер ли
minerId, err := d.GetMinerId(userId)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if minerId > 0 {
// наш приватный ключ нода, которым будем расшифровывать комменты
privateKey, err = d.GetNodePrivateKey(myPrefix)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// возможно, что комменты будут зашифрованы юзерским ключем
if len(privateKey) == 0 {
privateKey, err = d.GetMyPrivateKey(myPrefix)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// если это еще не майнер и админ ноды не указал его приватный ключ в табле my_keys, то $private_key будет пуст
if len(privateKey) == 0 {
continue
}
myData, err := d.OneRow("SELECT shop_secret_key, shop_callback_url FROM " + myPrefix + "my_table").String()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// Получаем инфу о входящих переводах и начисляем их на счета юзеров
dq := d.GetQuotes()
rows, err := d.Query(d.FormatQuery(`
SELECT id, block_id, type_id, currency_id, amount, to_user_id, comment_status, comment
FROM `+dq+myPrefix+`my_dc_transactions`+dq+`
WHERE type = 'from_user' AND
block_id < ? AND
merchant_checked = 0 AND
status = 'approved'
ORDER BY id DESC
`), blockId-confirmations)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var id, block_id, type_id, currency_id, to_user_id int64
var comment_status, comment string
var amount float64
err = rows.Scan(&id, &block_id, &type_id, ¤cy_id, &amount, &to_user_id, &comment_status, &comment)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if len(myData["shop_callback_url"]) == 0 {
// отметим merchant_checked=1, чтобы больше не брать эту тр-ию
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET merchant_checked = 1 WHERE id = ?", id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
continue
}
// вначале нужно проверить, точно ли есть такой перевод в блоке
binaryData, err := d.Single("SELECT data FROM block_chain WHERE id = ?", blockId).Bytes()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
p := new(dcparser.Parser)
p.DCDB = d.DCDB
p.BinaryData = binaryData
p.ParseDataLite()
for _, txMap := range p.TxMapArr {
// пропускаем все ненужные тр-ии
if utils.BytesToInt64(txMap["type"]) != utils.TypeInt("SendDc") {
continue
}
// сравнение данных из таблы my_dc_transactions с тем, что в блоке
if utils.BytesToInt64(txMap["user_id"]) == userId && utils.BytesToInt64(txMap["currency_id"]) == currency_id && utils.BytesToFloat64(txMap["amount"]) == amount && string(utils.BinToHex(txMap["comment"])) == comment && utils.BytesToInt64(txMap["to_user_id"]) == to_user_id {
decryptedComment := comment
// расшифруем коммент
if comment_status == "encrypted" {
block, _ := pem.Decode([]byte(privateKey))
if block == nil || block.Type != "RSA PRIVATE KEY" {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
private_key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
decryptedComment_, err := rsa.DecryptPKCS1v15(rand.Reader, private_key, []byte(comment))
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
decryptedComment = string(decryptedComment_)
// запишем расшифрованный коммент, чтобы потом можно было найти перевод в ручном режиме
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET comment = ?, comment_status = 'decrypted' WHERE id = ?", decryptedComment, id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// возможно, что чуть раньше было reduction, а это значит, что все тр-ии,
// которые мы ещё не обработали и которые были До блока с reduction нужно принимать с учетом reduction
// т.к. средства на нашем счете уже урезались, а вот те, что после reduction - остались в том виде, в котором пришли
lastReduction, err := d.OneRow("SELECT block_id, pct FROM reduction WHERE currency_id = ? ORDER BY block_id", currency_id).Int64()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if blockId <= lastReduction["block_id"] {
// сумму с учетом reduction
k0 := (100 - lastReduction["pct"]) / 100
amount = amount * float64(k0)
}
// делаем запрос к callback скрипту
r, _ := regexp.Compile(`(?i)\s*#\s*([0-9]+)\s*`)
order := r.FindStringSubmatch(decryptedComment)
orderId := 0
if len(order) > 0 {
orderId = utils.StrToInt(order[1])
}
txId := id
sign := fmt.Sprintf("%v:%v:%v:%v:%v:%v:%v:%v", amount, currencyList[currency_id], orderId, decryptedComment, txMap["user_id"], blockId, txId, myData["shop_secret_key"])
data := url.Values{}
data.Add("amount", utils.Float64ToStrPct(amount))
data.Add("currency", currencyList[currency_id])
data.Add("order_id", utils.IntToStr(orderId))
data.Add("message", decryptedComment)
data.Add("user_id", string(txMap["user_id"]))
data.Add("block_id", string(txMap["block_id"]))
data.Add("tx_id", utils.Int64ToStr(txId))
data.Add("sign", sign)
client := &http.Client{}
req, err := http.NewRequest("POST", myData["shop_callback_url"], bytes.NewBufferString(data.Encode()))
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
req.Header.Add("Content-Length", utils.IntToStr(len(data.Encode())))
resp, err := client.Do(req)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
//contents, _ := ioutil.ReadAll(resp.Body)
if resp.StatusCode == 200 {
// отметим merchant_checked=1, чтобы больше не брать эту тр-ию
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET merchant_checked = 1 WHERE id = ?", id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
}
}
}
rows.Close()
}
if d.dSleep(d.sleepTime) {
break BEGIN
}
}
log.Debug("break BEGIN %v", GoroutineName)
}
func MakeFrontTest(transactionArray [][]byte, time int64, dataForSign string, txType string, userId int64, MY_PREFIX string, blockId int64) error {
db := DbConn()
priv, pub := genKeys()
nodeArr := []string{"new_admin", "votes_node_new_miner", "NewPct"}
var binSign []byte
if utils.InSliceString(txType, nodeArr) {
err := db.ExecSql("UPDATE my_node_keys SET private_key = ?", priv)
if err != nil {
return utils.ErrInfo(err)
}
err = db.ExecSql("UPDATE miners_data SET node_public_key = [hex] WHERE user_id = ?", pub, userId)
if err != nil {
return utils.ErrInfo(err)
}
k, err := db.GetNodePrivateKey(MY_PREFIX)
if err != nil {
return utils.ErrInfo(err)
}
fmt.Println("k", k)
privateKey, err := utils.MakePrivateKey(k)
if err != nil {
return utils.ErrInfo(err)
}
//fmt.Println("privateKey.PublicKey", privateKey.PublicKey)
//fmt.Println("privateKey.D", privateKey.D)
//fmt.Printf("privateKey.N %x\n", privateKey.N)
//fmt.Println("privateKey.Public", privateKey.Public())
binSign, err = rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA1, utils.HashSha1(dataForSign))
//nodePublicKey, err := db.GetNodePublicKey(userId)
//fmt.Println("nodePublicKey", nodePublicKey)
//if err != nil {
// return utils.ErrInfo(err)
//}
//CheckSignResult, err := utils.CheckSign([][]byte{nodePublicKey}, dataForSign, binSign, true);
//fmt.Printf("binSign: %x\n", binSign)
//fmt.Println("err", err)
//fmt.Println("CheckSignResult", CheckSignResult)
} else {
err := db.ExecSql("UPDATE my_keys SET private_key = ?", priv)
if err != nil {
return utils.ErrInfo(err)
}
err = db.ExecSql("UPDATE users SET public_key_0 = [hex]", pub)
if err != nil {
return utils.ErrInfo(err)
}
k, err := db.GetPrivateKey(MY_PREFIX)
privateKey, err := utils.MakePrivateKey(k)
if err != nil {
return utils.ErrInfo(err)
}
binSign, err = rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA1, utils.HashSha1(dataForSign))
binSign = utils.EncodeLengthPlusData(binSign)
}
//fmt.Println("HashSha1", utils.HashSha1(dataForSign))
//fmt.Printf("binSign %x\n", binSign)
//fmt.Println("dataForSign", dataForSign)
transactionArray = append(transactionArray, binSign)
parser := new(dcparser.Parser)
parser.DCDB = db
parser.GoroutineName = "test"
parser.TxSlice = transactionArray
parser.BlockData = &utils.BlockData{BlockId: blockId, Time: time, UserId: userId}
parser.TxHash = []byte("111111111111111")
parser.Variables, _ = parser.DCDB.GetAllVariables()
err0 := utils.CallMethod(parser, txType+"Init")
if i, ok := err0.(error); ok {
fmt.Println(err0.(error), i)
return err0.(error)
}
err0 = utils.CallMethod(parser, txType+"Front")
if i, ok := err0.(error); ok {
fmt.Println(err0.(error), i)
return err0.(error)
}
err0 = utils.CallMethod(parser, txType+"RollbackFront")
if i, ok := err0.(error); ok {
fmt.Println(err0.(error), i)
return err0.(error)
}
return nil
}
func (c *Controller) PoolAddUsers() (string, error) {
if !c.NodeAdmin || c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
if !c.Community {
return "", utils.ErrInfo(errors.New("Single mode"))
}
c.r.ParseMultipartForm(32 << 20)
file, _, err := c.r.FormFile("file")
if err != nil {
return "", utils.ErrInfo(err)
}
buffer := new(bytes.Buffer)
_, err = io.Copy(buffer, file)
if err != nil {
return "", utils.ErrInfo(err)
}
defer file.Close()
//log.Debug("", buffer.String())
var mainMap map[string][]map[string]string
err = json.Unmarshal(buffer.Bytes(), &mainMap)
if err != nil {
return "", utils.ErrInfo(err)
}
log.Debug("mainMap %v", mainMap)
log.Debug("Unmarshal ok")
schema_ := &schema.SchemaStruct{}
schema_.DCDB = c.DCDB
schema_.DbType = c.ConfigIni["db_type"]
community := make(map[int64]int64)
re := regexp.MustCompile(`^([0-9]+)_`)
for table, _ := range mainMap {
log.Debug("table %v", table)
match := re.FindStringSubmatch(table)
if len(match) != 0 {
user_id := utils.StrToInt64(match[1])
community[user_id] = 1
}
}
for user_id, _ := range community {
schema_.PrefixUserId = int(user_id)
schema_.GetSchema()
c.ExecSql(`INSERT INTO community (user_id) VALUES (?)`, user_id)
log.Debug("mainMap.Community[i] %d", user_id)
}
allTables, err := c.GetAllTables()
for table, arr := range mainMap {
log.Debug("table %v", table)
if !utils.InSliceString(table, allTables) {
continue
}
//_ = c.ExecSql(`DROP TABLE `+table)
//if err != nil {
// return "", utils.ErrInfo(err)
//}
log.Debug(table)
var id bool
for i, data := range arr {
log.Debug("%v", i)
colNames := ""
values := []interface{}{}
qq := ""
for name, value := range data {
if name == "id" {
id = true
}
if ok, _ := regexp.MatchString("my_table", table); ok {
if name == "host" {
name = "http_host"
}
}
if name == "show_progressbar" {
name = "show_progress_bar"
}
colNames += name + ","
values = append(values, value)
if ok, _ := regexp.MatchString("(hash_code|public_key|encrypted)", name); ok {
qq += "[hex],"
} else {
qq += "?,"
}
}
colNames = colNames[0 : len(colNames)-1]
qq = qq[0 : len(qq)-1]
query := `INSERT INTO ` + table + ` (` + colNames + `) VALUES (` + qq + `)`
log.Debug("%v", query)
log.Debug("%v", values)
err = c.ExecSql(query, values...)
if err != nil {
return "", utils.ErrInfo(err)
}
}
if id {
maxId, err := c.Single(`SELECT max(id) FROM ` + table).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
err = c.SetAI(table, maxId+1)
if err != nil {
return "", utils.ErrInfo(err)
}
}
}
return "", nil
}
func (c *Controller) Check_sign() (string, error) {
var checkError bool
c.r.ParseForm()
n := []byte(c.r.FormValue("n"))
e := []byte(c.r.FormValue("e"))
sign := []byte(c.r.FormValue("sign"))
setupPassword := c.r.FormValue("setup_password")
private_key := c.r.FormValue("private_key")
if !utils.CheckInputData(n, "hex") {
return `{"result":"incorrect n"}`, nil
}
if !utils.CheckInputData(e, "hex") {
return `{"result":"incorrect e"}`, nil
}
if !utils.CheckInputData(string(sign), "hex_sign") {
return `{"result":"incorrect sign"}`, nil
}
allTables, err := c.DCDB.GetAllTables()
if err != nil {
return "{\"result\":0}", err
}
var hash []byte
log.Debug("configIni[sign_hash] %s", configIni["sign_hash"])
log.Debug("c.r.RemoteAddr %s", c.r.RemoteAddr)
log.Debug("c.r.Header.Get(User-Agent) %s", c.r.Header.Get("User-Agent"))
RemoteAddr := utils.RemoteAddrFix(c.r.RemoteAddr)
re := regexp.MustCompile(`(.*?):[0-9]+$`)
match := re.FindStringSubmatch(RemoteAddr)
if len(match) != 0 {
RemoteAddr = match[1]
}
log.Debug("RemoteAddr %s", RemoteAddr)
hash = utils.Md5(c.r.Header.Get("User-Agent") + RemoteAddr)
log.Debug("hash %s", hash)
if len(c.CommunityUsers) > 0 {
// в цикле проверяем, кому подойдет присланная подпись
for _, userId := range c.CommunityUsers {
myPrefix := utils.Int64ToStr(userId) + "_"
if !utils.InSliceString(myPrefix+"my_keys", allTables) {
continue
}
// получим открытый ключ юзера
publicKey, err := c.DCDB.GetMyPublicKey(myPrefix)
if err != nil {
return "{\"result\":0}", err
}
// получим данные для подписи
forSign, err := c.DCDB.GetDataAuthorization(hash)
log.Debug("publicKey: %x\n", publicKey)
log.Debug("myPrefix: ", myPrefix)
log.Debug("sign: %s\n", sign)
log.Debug("hash: %s\n", hash)
log.Debug("forSign: ", forSign)
// проверим подпись
resultCheckSign, err := utils.CheckSign([][]byte{publicKey}, forSign, utils.HexToBin(sign), true)
if err != nil {
continue
}
// если подпись верная, значит мы нашли юзера, который эту подпись смог сделать
if resultCheckSign {
myUserId := userId
// убираем ограниченный режим
c.sess.Delete("restricted")
c.sess.Set("user_id", myUserId)
log.Debug("c.sess.Set(user_id) %d", myUserId)
public_key, err := c.DCDB.GetUserPublicKey(myUserId)
if err != nil {
return "{\"result\":0}", err
}
// паблик кей в сессии нужен чтобы выбрасывать юзера, если ключ изменился
c.sess.Set("public_key", string(utils.BinToHex([]byte(public_key))))
log.Debug("string(utils.BinToHex([]byte(public_key))) %s", string(utils.BinToHex([]byte(public_key))))
adminUSerID, err := c.DCDB.GetAdminUserId()
if err != nil {
return "{\"result\":0}", err
}
if adminUSerID == myUserId {
c.sess.Set("admin", 1)
}
return "{\"result\":1}", nil
}
}
log.Debug("restricted test")
// если дошли досюда, значит ни один ключ не подошел и даем возможность войти в ограниченном режиме
publicKey := utils.MakeAsn1(n, e)
userId_, err := c.DCDB.GetUserIdByPublicKey(publicKey)
userId := utils.StrToInt64(userId_)
if err != nil {
return "{\"result\":0}", err
}
log.Debug("userId:", userId)
// юзер с таким ключем есть в БД
if userId > 0 {
// получим данные для подписи
forSign, err := c.DCDB.GetDataAuthorization(hash)
log.Debug("forSign", forSign)
log.Debug("publicKey %x\n", utils.HexToBin(publicKey))
log.Debug("sign_", string(sign))
// проверим подпись
resultCheckSign, err := utils.CheckSign([][]byte{utils.HexToBin(publicKey)}, forSign, utils.HexToBin(sign), true)
if err != nil {
return "{\"result\":0}", err
}
if resultCheckSign {
// если юзер смог подписать наш хэш, значит у него актуальный праймари ключ
c.sess.Set("user_id", userId)
log.Debug("c.sess.Set(user_id) %d", userId)
// паблик кей в сессии нужен чтобы выбрасывать юзера, если ключ изменился
c.sess.Set("public_key", string(publicKey))
// возможно в табле my_keys старые данные, но если эта табла есть, то нужно добавить туда ключ
if utils.InSliceString(utils.Int64ToStr(userId)+"_my_keys", allTables) {
curBlockId, err := c.DCDB.GetBlockId()
if err != nil {
return "{\"result\":0}", err
}
err = c.DCDB.InsertIntoMyKey(utils.Int64ToStr(userId)+"_", publicKey, utils.Int64ToStr(curBlockId))
if err != nil {
return "{\"result\":0}", err
}
c.sess.Delete("restricted")
} else {
c.sess.Set("restricted", int64(1))
log.Debug("c.sess.Set(restricted) 1")
}
return "{\"result\":1}", nil
} else {
return "{\"result\":0}", nil
}
}
} else {
// получим открытый ключ юзера
publicKey, err := c.DCDB.GetMyPublicKey("")
if err != nil {
return "{\"result\":0}", err
}
// Если ключ еще не успели установить
if len(publicKey) == 0 {
// пока не собрана цепочка блоков не даем ввести ключ
infoBlock, err := c.DCDB.GetInfoBlock()
if err != nil {
return "{\"result\":0}", err
}
// если последний блок не старше 2-х часов
wTime := int64(2)
if c.ConfigIni["test_mode"] == "1" {
wTime = 2 * 365 * 24
}
log.Debug("%v/%v/%v", time.Now().Unix(), utils.StrToInt64(infoBlock["time"]), wTime)
if (time.Now().Unix() - utils.StrToInt64(infoBlock["time"])) < 3600*wTime {
// проверим, верный ли установочный пароль, если он, конечно, есть
setupPassword_, err := c.Single("SELECT setup_password FROM config").String()
if err != nil {
return "{\"result\":0}", err
}
if len(setupPassword_) > 0 && setupPassword_ != string(utils.DSha256(setupPassword)) {
log.Debug(setupPassword_, string(utils.DSha256(setupPassword)), setupPassword)
return "{\"result\":0}", nil
}
publicKey := utils.MakeAsn1(n, e)
log.Debug("new key", string(publicKey))
userId, err := c.GetUserIdByPublicKey(publicKey)
if err != nil {
return "{\"result\":0}", err
}
// получим данные для подписи
forSign, err := c.DCDB.GetDataAuthorization(hash)
if err != nil {
return "{\"result\":0}", err
}
log.Debug("forSign", forSign)
log.Debug("publicKey %x\n", utils.HexToBin(publicKey))
log.Debug("sign_", string(sign))
// проверим подпись
resultCheckSign, err := utils.CheckSign([][]byte{utils.HexToBin(publicKey)}, forSign, utils.HexToBin(sign), true)
if err != nil {
return "{\"result\":0}", err
}
if !resultCheckSign {
return "{\"result\":0}", nil
}
if len(userId) > 0 {
err := c.InsertIntoMyKey("", publicKey, "0")
if err != nil {
return "{\"result\":0}", err
}
minerId, err := c.GetMinerId(utils.StrToInt64(userId))
if err != nil {
return "{\"result\":0}", err
}
//myUserId, err := c.GetMyUserId("")
//if myUserId > 0 {
if minerId > 0 {
err = c.ExecSql("UPDATE my_table SET user_id = ?, miner_id = ?, status = 'miner'", userId, minerId)
if err != nil {
return "{\"result\":0}", err
}
} else {
err = c.ExecSql("UPDATE my_table SET user_id = ?, status = 'user'", userId)
if err != nil {
return "{\"result\":0}", err
}
}
//} else {
// c.ExecSql("INSERT INTO my_table (user_id, status) VALUES (?, 'user')", userId)
//}
// возможно юзер хочет сохранить свой ключ
if len(private_key) > 0 {
c.ExecSql("UPDATE my_keys SET private_key = ? WHERE block_id = (SELECT max(block_id) FROM my_keys)", private_key)
}
} else {
checkError = true
}
} else {
checkError = true
}
} else {
log.Debug("RemoteAddr %s", RemoteAddr)
hash = utils.Md5(c.r.Header.Get("User-Agent") + RemoteAddr)
log.Debug("hash %s", hash)
// получим данные для подписи
forSign, err := c.DCDB.GetDataAuthorization(hash)
log.Debug("forSign", forSign)
log.Debug("publicKey %x\n", string(publicKey))
log.Debug("sign_", string(sign))
// проверим подпись
resultCheckSign, err := utils.CheckSign([][]byte{publicKey}, forSign, utils.HexToBin(sign), true)
if err != nil {
return "{\"result\":0}", err
}
if !resultCheckSign {
return "{\"result\":0}", nil
}
}
if checkError {
return "{\"result\":0}", nil
} else {
myUserId, err := c.DCDB.GetMyUserId("")
if myUserId == 0 {
myUserId = -1
}
if err != nil {
return "{\"result\":0}", err
}
c.sess.Delete("restricted")
c.sess.Set("user_id", myUserId)
// если уже пришел блок, в котором зареган ключ юзера
if myUserId != -1 {
public_key, err := c.DCDB.GetUserPublicKey(myUserId)
if err != nil {
return "{\"result\":0}", err
}
// паблик кей в сессии нужен чтобы выбрасывать юзера, если ключ изменился
c.sess.Set("public_key", string(utils.BinToHex(public_key)))
// возможно юзер хочет сохранить свой ключ
if len(private_key) > 0 {
c.ExecSql("UPDATE my_keys SET private_key = ? WHERE block_id = (SELECT max(block_id) FROM my_keys)", private_key)
}
AdminUserId, err := c.DCDB.GetAdminUserId()
if err != nil {
return "{\"result\":0}", err
}
if AdminUserId == myUserId {
c.sess.Set("admin", int64(1))
}
return "{\"result\":1}", nil
}
}
}
return "{\"result\":0}", nil
}
func (c *Controller) ProgressBar() (string, error) {
if !c.dbInit {
return "", nil
}
progressBarPct := make(map[string]int64)
progressBarPct["begin"] = 10
progressBarPct["change_key"] = 10
progressBarPct["my_table"] = 5
progressBarPct["upgrade_country"] = 3
progressBarPct["upgrade_face_hash"] = 3
progressBarPct["upgrade_profile_hash"] = 3
progressBarPct["upgrade_face_coords"] = 3
progressBarPct["upgrade_profile_coords"] = 3
progressBarPct["upgrade_video"] = 3
progressBarPct["upgrade_host"] = 3
progressBarPct["upgrade_geolocation"] = 3
progressBarPct["promised_amount"] = 5
progressBarPct["commission"] = 3
progressBarPct["tasks"] = 8
progressBarPct["vote"] = 5
progressBarPct["referral"] = 1
progressBar := make(map[string]int64)
// сменил ли юзер ключ
changeKey, err := c.Single("SELECT log_id FROM users WHERE user_id = ?", c.SessUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
last_tx, err := c.GetLastTx(c.SessUserId, utils.TypesToIds([]string{"ChangePrimaryKey"}), 1, c.TimeFormat)
if err != nil {
return "", utils.ErrInfo(err)
}
if (len(last_tx) > 0 && (len(last_tx[0]["queue_tx"]) > 0 || len(last_tx[0]["tx"]) > 0)) || changeKey > 0 {
progressBar["change_key"] = 1
}
// есть ли в БД личная юзерсая таблица
if c.Community {
tables, err := c.GetAllTables()
if err != nil {
return "", utils.ErrInfo(err)
}
if utils.InSliceString(utils.Int64ToStr(c.SessUserId)+"_my_table", tables) {
progressBar["my_table"] = 1
}
} else {
progressBar["my_table"] = 1
}
// апгрейд аккаунта
myMinersId, err := c.GetMinerId(c.SessUserId)
if myMinersId > 0 {
progressBar["upgrade_country"] = 1
progressBar["upgrade_face_hash"] = 1
progressBar["upgrade_profile_hash"] = 1
progressBar["upgrade_face_coords"] = 1
progressBar["upgrade_profile_coords"] = 1
progressBar["upgrade_video"] = 1
progressBar["upgrade_host"] = 1
progressBar["upgrade_geolocation"] = 1
} else if c.SessRestricted == 0 {
upgradeData, err := c.OneRow("SELECT user_id, race, country, geolocation, http_host as host, face_coords, profile_coords, video_url_id, video_type FROM " + c.MyPrefix + "my_table").String()
if err != nil {
return "", utils.ErrInfo(err)
}
if len(upgradeData["race"]) > 0 && len(upgradeData["country"]) > 0 {
progressBar["upgrade_country"] = 1
}
if len(upgradeData["face_hash"]) > 0 {
progressBar["upgrade_face_hash"] = 1
}
if len(upgradeData["profile_hash"]) > 0 {
progressBar["upgrade_profile_hash"] = 1
}
if len(upgradeData["face_coords"]) > 0 {
progressBar["upgrade_face_coords"] = 1
}
if len(upgradeData["profile_coords"]) > 0 {
progressBar["upgrade_profile_coords"] = 1
}
if _, err := os.Stat(*utils.Dir + "public/" + utils.Int64ToStr(c.SessUserId) + "_user_video.mp4"); os.IsExist(err) {
if len(upgradeData["video_url_id"]) > 0 {
progressBar["upgrade_video"] = 1
}
}
if len(upgradeData["host"]) > 0 {
progressBar["upgrade_host"] = 1
}
if len(upgradeData["latitude"]) > 0 && len(upgradeData["longitude"]) > 0 {
progressBar["upgrade_geolocation"] = 1
}
}
// добавлена ли обещанная сумма
promisedAmount, err := c.Single("SELECT id FROM promised_amount WHERE user_id = ?", c.SessUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
// возможно юзер уже отправил запрос на добавление обещенной суммы
last_tx, err = c.GetLastTx(c.SessUserId, utils.TypesToIds([]string{"NewPromisedAmount"}), 1, c.TimeFormat)
if (len(last_tx) > 0 && (len(last_tx[0]["queue_tx"]) > 0 || len(last_tx[0]["tx"]) > 0)) || promisedAmount > 0 {
progressBar["promised_amount"] = 1
}
// установлена ли комиссия
commission, err := c.Single("SELECT commission FROM commission WHERE user_id = ?", c.UserId).String()
if err != nil {
return "", utils.ErrInfo(err)
}
// возможно юзер уже отправил запрос на добавление комиссии
last_tx, err = c.GetLastTx(c.SessUserId, utils.TypesToIds([]string{"ChangeCommission"}), 1, c.TimeFormat)
if (len(last_tx) > 0 && (len(last_tx[0]["queue_tx"]) > 0 || len(last_tx[0]["tx"]) > 0)) || len(commission) > 0 {
progressBar["commission"] = 1
}
// голосование за параметры валют. для простоты смотрим в голоса за реф %
vote, err := c.Single("SELECT user_id FROM votes_referral WHERE user_id = ?", c.SessUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
last_tx, err = c.GetLastTx(c.SessUserId, utils.TypesToIds([]string{"VotesComplex"}), 1, c.TimeFormat)
if (len(last_tx) > 0 && (len(last_tx[0]["queue_tx"]) > 0 || len(last_tx[0]["tx"]) > 0)) || vote > 0 {
progressBar["vote"] = 1
}
if c.SessRestricted == 0 {
// выполнялись ли задания
myTasks, err := c.Single("SELECT id FROM " + c.MyPrefix + "my_tasks").Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if myTasks > 0 {
progressBar["tasks"] = 1
}
}
// сколько майнеров зарегались по ключам данного юзера
progressBar["referral"], err = c.Single(`
SELECT count(miner_id)
FROM users
LEFT JOIN miners_data on miners_data.user_id = users.user_id
WHERE referral = ? AND
miner_id > 0
`, c.SessUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
// итог
progressPct := progressBarPct["begin"]
for name, result := range progressBar {
if name == "referral" {
progressPct += progressBarPct[name] * result
} else {
progressPct += progressBarPct[name]
}
}
progressBar["begin"] = 1
log.Debug("ProgressBar end")
if !c.ContentInc {
data, err := static.Asset("static/templates/progress_bar.html")
if err != nil {
return "", utils.ErrInfo(err)
}
t := template.Must(template.New("template").Parse(string(data)))
b := new(bytes.Buffer)
t.ExecuteTemplate(b, "progressBar", &progressBarPage{Lang: c.Lang, ProgressPct: progressPct})
return b.String(), nil
} else {
TemplateStr, err := makeTemplate("progress", "progress", &progressBarPage{
Lang: c.Lang,
ProgressBar: progressBar,
ProgressBarPct: progressBarPct,
ProgressPct: progressPct})
if err != nil {
return "", utils.ErrInfo(err)
}
return TemplateStr, nil
}
}
func (c *Controller) PoolDataBaseDump() (string, error) {
if !c.NodeAdmin || c.SessRestricted != 0 {
return "", utils.ErrInfo(errors.New("Permission denied"))
}
allTables, err := c.GetAllTables()
if err != nil {
return "", utils.ErrInfo(err)
}
c.r.ParseForm()
dumpUserId := utils.StrToInt64(c.r.FormValue("dump_user_id"))
mainMap := make(map[string][]map[string]string)
if dumpUserId > 0 {
for _, table := range consts.MyTables {
data, err := c.GetAll(`SELECT * FROM `+table, -1)
if err != nil {
return "", utils.ErrInfo(err)
}
mainMap[table] = data
}
} else {
for i := 0; i < len(c.CommunityUsers); i++ {
for _, table := range consts.MyTables {
table = utils.Int64ToStr(c.CommunityUsers[i]) + "_" + table
if utils.InSliceString(table, allTables) {
data, err := c.GetAll(`SELECT * FROM `+table, -1)
for k, arr := range data {
for name, value := range arr {
if ok, _ := regexp.MatchString("(hash_code|public_key|encrypted)", name); ok {
data[k][name] = string(utils.BinToHex([]byte(value)))
}
}
}
if err != nil {
return "", utils.ErrInfo(err)
}
mainMap[table] = data
}
}
}
}
jsonData, _ := json.Marshal(mainMap)
log.Debug(string(jsonData))
c.w.Header().Set("Content-Type", "text/plain")
c.w.Header().Set("Content-Length", utils.IntToStr(len(jsonData)))
t := time.Unix(utils.Time(), 0)
c.w.Header().Set("Content-Disposition", `attachment; filename="dcoin_users_backup-`+t.Format(c.TimeFormat)+`.txt`)
if _, err := c.w.Write(jsonData); err != nil {
return "", utils.ErrInfo(errors.New("unable to write text"))
}
err = json.Unmarshal(jsonData, &mainMap)
if err != nil {
return "", utils.ErrInfo(err)
}
// для теста
for table, arr := range mainMap {
log.Debug(table)
for i, data := range arr {
log.Debug("%v", i)
colNames := ""
values := []string{}
qq := ""
for name, value := range data {
colNames += name + ","
values = append(values, value)
if ok, _ := regexp.MatchString("(hash_code|public_key|encrypted)", name); ok {
qq += "[hex],"
} else {
qq += "?,"
}
}
colNames = colNames[0 : len(colNames)-1]
qq = qq[0 : len(qq)-1]
query := `INSERT INTO ` + table + ` (` + colNames + `) VALUES (` + qq + `)`
log.Debug("%v", query)
log.Debug("%v", values)
}
}
return "", nil
}
func Content(w http.ResponseWriter, r *http.Request) {
defer func() {
if r := recover(); r != nil {
log.Error("Content Recovered", r)
fmt.Println("Content Recovered", r)
}
}()
var err error
w.Header().Set("Content-type", "text/html")
sess, err := globalSessions.SessionStart(w, r)
if err != nil {
log.Error("%v", err)
}
defer sess.SessionRelease(w)
sessUserId := GetSessUserId(sess)
sessRestricted := GetSessRestricted(sess)
sessPublicKey := GetSessPublicKey(sess)
sessAdmin := GetSessAdmin(sess)
log.Debug("sessUserId", sessUserId)
log.Debug("sessRestricted", sessRestricted)
log.Debug("sessPublicKey", sessPublicKey)
log.Debug("user_id: %v", sess.Get("user_id"))
c := new(Controller)
c.r = r
c.w = w
c.sess = sess
c.SessRestricted = sessRestricted
c.SessUserId = sessUserId
if sessAdmin == 1 {
c.Admin = true
}
c.ContentInc = true
var installProgress, configExists string
var lastBlockTime int64
dbInit := false
if len(configIni["db_user"]) > 0 || (configIni["db_type"] == "sqlite") {
dbInit = true
}
if dbInit {
var err error
//c.DCDB, err = utils.NewDbConnect(configIni)
c.DCDB = utils.DB
if c.DCDB.DB == nil {
log.Error("utils.DB == nil")
dbInit = false
}
if dbInit {
// отсутвие таблы выдаст ошибку, значит процесс инсталяции еще не пройден и надо выдать 0-й шаг
_, err = c.DCDB.Single("SELECT progress FROM install").String()
if err != nil {
log.Error("%v", err)
dbInit = false
}
}
}
c.dbInit = dbInit
if dbInit {
var err error
installProgress, err = c.DCDB.Single("SELECT progress FROM install").String()
if err != nil {
log.Error("%v", err)
}
configExists, err = c.DCDB.Single("SELECT first_load_blockchain_url FROM config").String()
if err != nil {
log.Error("%v", err)
}
c.Variables, err = c.GetAllVariables()
// Инфа о последнем блоке
blockData, err := c.DCDB.GetLastBlockData()
if err != nil {
log.Error("%v", err)
}
//время последнего блока
lastBlockTime = blockData["lastBlockTime"]
log.Debug("installProgress", installProgress, "configExists", configExists, "lastBlockTime", lastBlockTime)
// валюты
currencyListCf, err := c.GetCurrencyList(true)
if err != nil {
log.Error("%v", err)
}
c.CurrencyListCf = currencyListCf
currencyList, err := c.GetCurrencyList(false)
if err != nil {
log.Error("%v", err)
}
c.CurrencyList = currencyList
confirmedBlockId, err := c.GetConfirmedBlockId()
if err != nil {
log.Error("%v", err)
}
c.ConfirmedBlockId = confirmedBlockId
c.MinerId, err = c.GetMinerId(c.SessUserId)
if err != nil {
log.Error("%v", err)
}
paymentSystems, err := c.GetPaymentSystems()
if err != nil {
log.Error("%v", err)
}
c.PaymentSystems = paymentSystems
}
r.ParseForm()
tplName := r.FormValue("tpl_name")
c.Parameters, err = c.GetParameters()
log.Debug("parameters=", c.Parameters)
log.Debug("tpl_name=", tplName)
// если в параметрах пришел язык, то установим его
newLang := utils.StrToInt(c.Parameters["lang"])
if newLang > 0 {
log.Debug("newLang", newLang)
SetLang(w, r, newLang)
}
// уведомления
//if utils.CheckInputData(parameters["alert"], "alert") {
c.Alert = c.Parameters["alert"]
//}
lang := GetLang(w, r, c.Parameters)
log.Debug("lang", lang)
c.Lang = globalLangReadOnly[lang]
c.LangInt = int64(lang)
if lang == 42 {
c.TimeFormat = "2006-01-02 15:04:05"
} else {
c.TimeFormat = "2006-02-01 15:04:05"
}
c.Periods = map[int64]string{86400: "1 " + c.Lang["day"], 604800: "1 " + c.Lang["week"], 31536000: "1 " + c.Lang["year"], 2592000: "1 " + c.Lang["month"], 1209600: "2 " + c.Lang["weeks"]}
c.Races = map[int64]string{1: c.Lang["race_1"], 2: c.Lang["race_2"], 3: c.Lang["race_3"]}
var status string
var communityUsers []int64
if dbInit {
communityUsers, err = c.DCDB.GetCommunityUsers()
if err != nil {
log.Error("%v", err)
}
c.CommunityUsers = communityUsers
if len(communityUsers) == 0 {
c.MyPrefix = ""
} else {
c.MyPrefix = utils.Int64ToStr(sessUserId) + "_"
c.Community = true
}
log.Debug("c.MyPrefix %s", c.MyPrefix)
// нужна мин. комиссия на пуле для перевода монет
config, err := c.GetNodeConfig()
if err != nil {
log.Error("%v", err)
}
configCommission_ := make(map[string][]float64)
if len(config["commission"]) > 0 {
err = json.Unmarshal([]byte(config["commission"]), &configCommission_)
if err != nil {
log.Error("%v", err)
}
}
configCommission := make(map[int64][]float64)
for k, v := range configCommission_ {
configCommission[utils.StrToInt64(k)] = v
}
c.NodeConfig = config
c.ConfigCommission = configCommission
c.NodeAdmin, err = c.NodeAdminAccess(c.SessUserId, c.SessRestricted)
if err != nil {
log.Error("%v", err)
}
status, err = c.DCDB.Single("SELECT status FROM " + c.MyPrefix + "my_table").String()
if err != nil {
log.Error("%v", err)
}
}
log.Debug("dbInit", dbInit)
setupPassword := c.NodeConfig["setup_password"]
match, _ := regexp.MatchString("^(installStep[0-9_]+)|(blockExplorer)$", tplName)
// CheckInputData - гарантирует, что tplName чист
if tplName != "" && utils.CheckInputData(tplName, "tpl_name") && (sessUserId > 0 || match) {
tplName = tplName
} else if dbInit && installProgress == "complete" && len(configExists) == 0 {
// первый запуск, еще не загружен блокчейн
tplName = "updatingBlockchain"
} else if dbInit && installProgress == "complete" && sessUserId > 0 {
if status == "waiting_set_new_key" {
tplName = "setPassword"
} else if status == "waiting_accept_new_key" {
tplName = "waitingAcceptNewKey"
}
} else if dbInit && installProgress == "complete" && !c.Community && sessUserId == 0 && status == "waiting_set_new_key" && setupPassword != "" {
tplName = "setupPassword"
} else if dbInit && installProgress == "complete" && sessUserId == 0 && status == "waiting_accept_new_key" {
tplName = "waitingAcceptNewKey"
} else if dbInit && installProgress == "complete" {
tplName = "login"
} else {
tplName = "installStep0" // самый первый запуск
}
log.Debug("dbInit", dbInit, "installProgress", installProgress, "configExists", configExists)
log.Debug("tplName>>>>>>>>>>>>>>>>>>>>>>", tplName)
// идет загрузка блокчейна
wTime := int64(2)
if configIni != nil && configIni["test_mode"] == "1" {
wTime = 2 * 365 * 86400
log.Debug("%v", wTime)
log.Debug("%v", lastBlockTime)
}
if dbInit && tplName != "installStep0" && (utils.Time()-lastBlockTime > 3600*wTime) && len(configExists) > 0 {
if len(communityUsers) > 0 {
// исключение - админ пула
poolAdminUserId, err := c.DCDB.Single("SELECT pool_admin_user_id FROM config").String()
if err != nil {
log.Error("%v", err)
}
if sessUserId != utils.StrToInt64(poolAdminUserId) {
tplName = "updatingBlockchain"
}
} else {
tplName = "updatingBlockchain"
}
}
if tplName == "installStep0" {
log.Debug("ConfigInit monitor")
if _, err := os.Stat(*utils.Dir + "/config.ini"); err == nil {
configIni_, err := config.NewConfig("ini", *utils.Dir+"/config.ini")
if err != nil {
log.Error("%v", utils.ErrInfo(err))
}
configIni, err = configIni_.GetSection("default")
if err != nil {
log.Error("%v", utils.ErrInfo(err))
}
if len(configIni["db_type"]) > 0 {
tplName = "updatingBlockchain"
}
}
}
log.Debug("tplName2=", tplName)
// кол-во ключей=подписей у юзера
var countSign int
var userId int64
// var myUserId int64
if sessUserId > 0 && dbInit && installProgress == "complete" {
userId = sessUserId
//myUserId = sessUserId
countSign = 1
log.Debug("userId: %d", userId)
pk, err := c.OneRow("SELECT hex(public_key_1) as public_key_1, hex(public_key_2) as public_key_2 FROM users WHERE user_id = ?", userId).String()
if err != nil {
log.Error("%v", err)
}
log.Debug("pk: %v", pk)
if len(pk["public_key_1"]) > 0 {
log.Debug("public_key_1: %x", pk["public_key_1"])
countSign = 2
}
if len(pk["public_key_2"]) > 0 {
log.Debug("public_key_2: %x", pk["public_key_2"])
countSign = 3
}
} else {
userId = 0
//myUserId = 0
}
log.Debug("countSign: %v", countSign)
c.UserId = userId
var CountSignArr []int
for i := 0; i < countSign; i++ {
CountSignArr = append(CountSignArr, i)
}
c.CountSign = countSign
c.CountSignArr = CountSignArr
if tplName == "" {
tplName = "login"
}
log.Debug("tplName::", tplName, sessUserId, installProgress)
if ok, _ := regexp.MatchString(`^(?i)delAutoPayment|newAutoPayment|autoPayments|holidaysList|adminVariables|exchangeAdmin|votesExchange|chat|firstSelect|PoolAdminLogin|setupPassword|waitingAcceptNewKey|SetPassword|CfPagePreview|CfCatalog|AddCfProjectData|CfProjectChangeCategory|NewCfProject|MyCfProjects|DelCfProject|DelCfFunding|CfStart|PoolAdminControl|Credits|Home|WalletsList|Information|Notifications|Interface|MiningMenu|Upgrade5|NodeConfigControl|Upgrade7|Upgrade6|Upgrade5|Upgrade4|Upgrade3|Upgrade2|Upgrade1|Upgrade0|StatisticVoting|ProgressBar|MiningPromisedAmount|CurrencyExchangeDelete|CurrencyExchange|ChangeCreditor|ChangeCommission|CashRequestOut|ArbitrationSeller|ArbitrationBuyer|ArbitrationArbitrator|Arbitration|InstallStep2|InstallStep1|InstallStep0|DbInfo|ChangeHost|Assignments|NewUser|NewPhoto|Voting|VoteForMe|RepaymentCredit|PromisedAmountList|PromisedAmountActualization|NewPromisedAmount|Login|ForRepaidFix|DelPromisedAmount|DelCredit|ChangePromisedAmount|ChangePrimaryKey|ChangeNodeKey|ChangeAvatar|BugReporting|Abuse|UpgradeResend|UpdatingBlockchain|Statistic|RewritePrimaryKey|RestoringAccess|PoolTechWorks|Points|NewHolidays|NewCredit|MoneyBackRequest|MoneyBack|ChangeMoneyBack|ChangeKeyRequest|ChangeKeyClose|ChangeGeolocation|ChangeCountryRace|ChangeArbitratorConditions|CashRequestIn|BlockExplorer$`, tplName); !ok {
w.Write([]byte("Access denied 0"))
} else if len(tplName) > 0 && sessUserId > 0 && installProgress == "complete" {
// если ключ юзера изменился, то выбрасываем его
userPublicKey, err := c.DCDB.GetUserPublicKey(userId)
if err != nil {
log.Error("%v", err)
}
// но возможно у юзера включено сохранение приватного ключа
// тогда, чтобы не получилось зацикливания, нужно проверить и my_keys
myPrivateKey, err := c.GetMyPrivateKey(c.MyPrefix)
if err != nil {
log.Error("%v", err)
}
myPublicKey, err := c.GetMyPublicKey(c.MyPrefix)
if err != nil {
log.Error("%v", err)
}
countUsers, err := c.Single(`SELECT count(*) FROM users`).Int64()
if err != nil {
log.Error("%v", err)
}
if (string(utils.BinToHex(userPublicKey)) != sessPublicKey && len(myPrivateKey) == 0) || (countUsers > 0 && len(myPrivateKey) > 0 && !bytes.Equal(myPublicKey, []byte(userPublicKey))) {
log.Debug("userPublicKey!=sessPublicKey %s!=%s / userId: %d", utils.BinToHex(userPublicKey), sessPublicKey, userId)
log.Debug("len(myPrivateKey) = %d && %x!=%x", len(myPrivateKey), string(myPublicKey), userPublicKey)
sess.Delete("user_id")
sess.Delete("private_key")
sess.Delete("public_key")
log.Debug("window.location.href = /")
if len(userPublicKey) > 0 {
w.Write([]byte("<script language=\"javascript\">window.location.href = \"/\"</script>If you are not redirected automatically, follow the <a href=\"/\">/</a>"))
return
} else {
c.sess.Delete("user_id")
c.sess.Delete("public_key")
c.sess.Delete("private_key")
}
}
if tplName == "login" {
tplName = "home"
}
if tplName == "home" && c.Parameters["first_select"] != "1" {
data, err := c.OneRow(`SELECT first_select, miner_id from ` + c.MyPrefix + `my_table`).Int64()
if err != nil {
log.Error("%v", err)
}
if data["first_select"] == 0 && data["miner_id"] == 0 && c.SessRestricted == 0 {
tplName = "firstSelect"
}
}
c.TplName = tplName
log.Debug("communityUsers:", communityUsers)
if dbInit && len(communityUsers) > 0 {
poolAdminUserId, err := c.GetPoolAdminUserId()
if err != nil {
log.Error("%v", err)
}
c.PoolAdminUserId = poolAdminUserId
if c.SessUserId == poolAdminUserId {
c.PoolAdmin = true
}
} else {
c.PoolAdmin = true
}
if dbInit {
// проверим, не идут ли тех. работы на пуле
config, err := c.DCDB.OneRow("SELECT pool_admin_user_id, pool_tech_works FROM config").String()
if err != nil {
log.Error("%v", err)
}
if len(config["pool_admin_user_id"]) > 0 && utils.StrToInt64(config["pool_admin_user_id"]) != sessUserId && config["pool_tech_works"] == "1" && c.Community {
tplName = "login"
}
// Если у юзера только 1 праймари ключ, то выдавать форму, где показываются данные для подписи и форма ввода подписи не нужно.
// Только если он сам не захочет, указав это в my_table
showSignData := false
if sessRestricted == 0 { // у незареганных в пуле юзеров нет MyPrefix, поэтому сохранять значение show_sign_data им негде
showSignData_, err := c.DCDB.Single("SELECT show_sign_data FROM " + c.MyPrefix + "my_table").String()
if err != nil {
log.Error("%v", err)
}
if showSignData_ == "1" {
showSignData = true
} else {
showSignData = false
}
}
if showSignData || countSign > 1 {
c.ShowSignData = true
} else {
c.ShowSignData = false
}
}
// писать в чат можно и при апдейте блокчейна
if r.FormValue("tpl_name") == "chat" && tplName == "updatingBlockchain" {
tplName = "chat"
}
if dbInit && tplName != "updatingBlockchain" && tplName != "setPassword" && tplName != "waitingAcceptNewKey" {
html, err := CallController(c, "AlertMessage")
if err != nil {
log.Error("%v", err)
}
w.Write([]byte(html))
}
w.Write([]byte("<input type='hidden' id='tpl_name' value='" + tplName + "'>"))
myNotice, err := c.DCDB.GetMyNoticeData(sessRestricted, sessUserId, c.MyPrefix, globalLangReadOnly[lang])
if err != nil {
log.Error("%v", err)
}
c.MyNotice = myNotice
log.Debug("tplName==", tplName)
// подсвечиваем красным номер блока, если идет процесс обновления
var blockJs string
blockId, err := c.GetBlockId()
if err != nil {
log.Error("%v", err)
}
if myNotice["main_status_complete"] != "1" {
blockJs = "$('#block_id').html(" + utils.Int64ToStr(blockId) + ");$('#block_id').css('color', '#ff0000');"
} else {
blockJs = "$('#block_id').html(" + utils.Int64ToStr(blockId) + ");$('#block_id').css('color', '#428BCA');"
}
w.Write([]byte(`<script>
$( document ).ready(function() {
$('.lng_1').attr('href', '#` + tplName + `/lang=1');
$('.lng_42').attr('href', '#` + tplName + `/lang=42');
` + blockJs + `
});
</script>`))
skipRestrictedUsers := []string{"cashRequestIn", "cashRequestOut", "upgrade", "notifications"}
// тем, кто не зареган на пуле не выдаем некоторые страницы
if sessRestricted == 0 || !utils.InSliceString(tplName, skipRestrictedUsers) {
// вызываем контроллер в зависимости от шаблона
html, err := CallController(c, tplName)
if err != nil {
log.Error("%v", err)
}
w.Write([]byte(html))
}
} else if len(tplName) > 0 {
log.Debug("tplName", tplName)
html := ""
if ok, _ := regexp.MatchString(`^(?i)blockExplorer|waitingAcceptNewKey|SetupPassword|CfCatalog|CfPagePreview|CfStart|Check_sign|CheckNode|GetBlock|GetMinerData|GetMinerDataMap|GetSellerData|Index|IndexCf|InstallStep0|InstallStep1|InstallStep2|Login|SignLogin|SynchronizationBlockchain|UpdatingBlockchain|Menu$`, tplName); !ok && c.SessUserId <= 0 {
html = "Access denied 1"
} else {
// если сессия обнулилась в процессе навигации по админке, то вместо login шлем на /, чтобы очистилось меню
if len(r.FormValue("tpl_name")) > 0 && tplName == "login" {
log.Debug("window.location.href = /")
w.Write([]byte("<script language=\"javascript\">window.location.href = \"/\"</script>If you are not redirected automatically, follow the <a href=\"/\">/</a>"))
return
}
// вызываем контроллер в зависимости от шаблона
html, err = CallController(c, tplName)
if err != nil {
log.Error("%v", err)
}
}
w.Write([]byte(html))
} else {
html, err := CallController(c, "login")
if err != nil {
log.Error("%v", err)
}
w.Write([]byte(html))
}
//sess.Set("username", 11111)
}
func (c *Controller) AlertMessage() (string, error) {
if c.SessRestricted != 0 {
return "", nil
}
c.r.ParseForm()
if ok, _ := regexp.MatchString(`install`, c.r.FormValue("tpl_name")); ok {
return "", nil
}
show := false
// проверим, есть ли сообщения от админа
data, err := c.OneRow("SELECT * FROM alert_messages WHERE close = 0 ORDER BY id DESC").String()
if err != nil {
return "", utils.ErrInfo(err)
}
var message map[string]string
var adminMessage string
if len(data["message"]) > 0 {
err = json.Unmarshal([]byte(data["message"]), &message)
if err != nil {
return "", utils.ErrInfo(err)
}
if len(message[utils.Int64ToStr(c.LangInt)]) > 0 {
adminMessage = message[utils.Int64ToStr(c.LangInt)]
} else {
adminMessage = message["gen"]
}
if data["currency_list"] != "ALL" {
// проверим, есть ли у нас обещанные суммы с такой валютой
promisedAmount, err := c.Single("SELECT id FROM promised_amount WHERE currency_id IN (" + data["currency_list"] + ")").Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if promisedAmount > 0 {
show = true
}
} else {
show = true
}
}
result := ""
if show {
result += `<script>
$('#close_alert').bind('click', function () {
$.post( 'ajax?controllerName=closeAlert', {
'id' : '` + data["id"] + `'
} );
});
</script>
<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>Warning!</h4>
` + adminMessage + `
</div>`
}
// сообщение о новой версии движка
myVer, err := c.Single("SELECT current_version FROM info_block").String()
if err != nil {
return "", utils.ErrInfo(err)
}
// возможны 2 сценария:
// 1. информация о новой версии есть в блоках
newVer, err := c.GetList("SELECT version FROM new_version WHERE alert = 1").String()
if err != nil {
return "", utils.ErrInfo(err)
}
newMaxVer := "0"
for i := 0; i < len(newVer); i++ {
if utils.VersionOrdinal(newVer[i]) > utils.VersionOrdinal(myVer) && newMaxVer == "0" {
newMaxVer = newVer[i]
}
if utils.VersionOrdinal(newVer[i]) > utils.VersionOrdinal(newMaxVer) && newMaxVer != "0" {
newMaxVer = newVer[i]
}
}
var newVersion string
if newMaxVer != "0" {
newVersion = strings.Replace(c.Lang["new_version"], "[ver]", newMaxVer, -1)
}
// для пулов и ограниченных юзеров выводим сообщение без кнопок
if (c.Community || c.SessRestricted != 0) && newMaxVer != "0" {
newVersion = strings.Replace(c.Lang["new_version_pulls"], "[ver]", newMaxVer, -1)
}
if newMaxVer != "0" && len(myVer) > 0 {
result += `<script>
$('#btn_install').bind('click', function () {
$('#new_version_text').text('Please wait');
$.post( 'ajax?controllerName=installNewVersion', {}, function(data) {
$('#new_version_text').text(data);
});
});
$('#btn_upgrade').bind('click', function () {
$('#new_version_text').text('Please wait');
$.post( 'ajax?controllerName=upgradeToNewVersion', {}, function(data) {
$('#new_version_text').text(data);
});
});
</script>
<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>Warning!</h4>
<div id='new_version_text'>` + newVersion + `</div>
</div>`
}
if c.SessRestricted == 0 && (!c.Community || c.PoolAdmin) {
myMinerId, err := c.GetMinerId(c.SessUserId)
if err != nil {
return "", utils.ErrInfo(err)
}
// если юзер уже майнер, то у него должно быть настроено точное время
if myMinerId > 0 {
networkTime, err := utils.GetNetworkTime()
if err != nil {
return "", utils.ErrInfo(err)
}
diff := int64(math.Abs(float64(utils.Time() - networkTime.Unix())))
if diff > c.Variables.Int64["alert_error_time"] {
alertTime := strings.Replace(c.Lang["alert_time"], "[sec]", utils.Int64ToStr(diff), -1)
result += `<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>Warning!</h4>
<div>` + alertTime + `</div>
</div>`
}
}
}
if c.SessRestricted == 0 {
// после обнуления таблиц my_node_key будет пуст
// получим время из последнего блока
myNodePrivateKey, err := c.GetNodePrivateKey(c.MyPrefix)
if err != nil {
return "", utils.ErrInfo(err)
}
minerId, err := c.GetMinerId(c.SessUserId)
if err != nil {
return "", utils.ErrInfo(err)
}
// возможно юзер новенький на пуле и у него разные нод-ключи
nodePublicKey, err := c.GetNodePublicKey(c.SessUserId)
if err != nil {
return "", utils.ErrInfo(err)
}
myNodePublicKey, err := c.GetMyNodePublicKey(c.MyPrefix)
if err != nil {
return "", utils.ErrInfo(err)
}
if (len(myNodePrivateKey) == 0 && minerId > 0) || (string(nodePublicKey) != myNodePublicKey && len(nodePublicKey) > 0) {
result += `<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>Warning!</h4>
<div>` + c.Lang["alert_change_node_key"] + `</div>
</div>`
}
}
// просто информируем, что в данном разделе у юзера нет прав
skipCommunity := []string{"nodeConfig", "nulling", "startStop"}
skipRestrictedUsers := []string{"nodeConfig", "changeNodeKey", "nulling", "startStop", "cashRequestIn", "cashRequestOut", "upgrade", "notifications", "interface"}
if (!c.NodeAdmin && utils.InSliceString(c.TplName, skipCommunity)) || (c.SessRestricted != 0 && utils.InSliceString(c.TplName, skipRestrictedUsers)) {
result += `<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>Warning!</h4>
<div>` + c.Lang["permission_denied"] + `</div>
</div>`
}
// информируем, что у юзера нет прав и нужно стать майнером
minersOnly := []string{"myCfProjects", "newCfProject", "cashRequestIn", "cashRequestOut", "changeNodeKey", "voting", "geolocation", "promisedAmountList", "promisedAmountAdd", "holidaysList", "newHolidays", "points", "tasks", "changeHost", "newUser", "changeCommission"}
if utils.InSliceString(c.TplName, minersOnly) {
minerId, err := c.Single("SELECT miner_id FROM users LEFT JOIN miners_data ON users.user_id = miners_data.user_id WHERE users.user_id = ?", c.SessUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if minerId == 0 {
result += `<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>Warning!</h4>
<div>` + c.Lang["only_for_miners"] + `</div>
</div>`
}
}
// информируем, что необходимо вначале сменить праймари-ключ
logId, err := c.Single("SELECT log_id FROM users WHERE user_id = ?", c.SessUserId).Int64()
if err != nil {
return "", utils.ErrInfo(err)
}
if logId == 0 {
text := ""
// проверим, есть ли запросы на смену в тр-ях
lastTx, err := c.GetLastTx(c.SessUserId, utils.TypesToIds([]string{"ChangePrimaryKey"}), 1, c.TimeFormat)
if err != nil {
return "", utils.ErrInfo(err)
}
if len(lastTx) == 0 { // юзер еще не начинал смену ключа
text = c.Lang["alert_change_primary_key"]
} else if len(lastTx[0]["error"]) > 0 || len(lastTx[0]["queue_tx"]) > 0 || len(lastTx[0]["tx"]) > 0 || utils.Time()-utils.StrToInt64(lastTx[0]["time_int"]) > 3600 {
text = c.Lang["please_try_again_change_key"]
} else {
text = c.Lang["please_wait_changing_key"]
}
result += `<div class="alert alert-danger alert-dismissable" style='margin-top: 30px'><button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4>` + c.Lang["warning"] + `</h4>
<div>` + text + `</div>
</div>`
}
return result, nil
}
func (t *TcpServer) Type5() {
// данные присылает демон connector
buf := make([]byte, 5)
_, err := t.Conn.Read(buf)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
userId := utils.BinToDec(buf)
log.Debug("userId: %d", userId)
// если работаем в режиме пула, то нужно проверить, верный ли у юзера нодовский ключ
community, err := t.GetCommunityUsers()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
t.Conn.Write(utils.DecToBin(0, 1))
return
}
if len(community) > 0 {
allTables, err := t.GetAllTables()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
t.Conn.Write(utils.DecToBin(0, 1))
return
}
keyTable := utils.Int64ToStr(userId) + "_my_node_keys"
if !utils.InSliceString(keyTable, allTables) {
log.Error("incorrect user_id %d", userId)
t.Conn.Write(utils.DecToBin(0, 1))
return
}
myBlockId, err := t.GetMyBlockId()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
t.Conn.Write(utils.DecToBin(0, 1))
return
}
myNodeKey, err := t.Single(`
SELECT public_key
FROM `+keyTable+`
WHERE block_id = (SELECT max(block_id) FROM `+keyTable+`) AND
block_id < ?
`, myBlockId).String()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
t.Conn.Write(utils.DecToBin(0, 1))
return
}
if len(myNodeKey) == 0 {
log.Error("len(myNodeKey) userId %d", userId)
t.Conn.Write(utils.DecToBin(0, 1))
return
}
nodePublicKey, err := t.GetNodePublicKey(userId)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
t.Conn.Write(utils.DecToBin(0, 1))
return
}
if myNodeKey != string(nodePublicKey) {
log.Error("%v", utils.ErrInfo("myNodeKey != nodePublicKey"))
t.Conn.Write(utils.DecToBin(0, 1))
return
}
// всё норм, шлем 1
_, err = t.Conn.Write(utils.DecToBin(1, 1))
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
} else {
// всё норм, шлем 1
_, err = t.Conn.Write(utils.DecToBin(1, 1))
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
}
}
