Альтернативный сервис оплаты в приложениях и играх

1GET http://127.0.0.1:8081/api/collections/products/records?filter=(application='2ipc3erqkokl5kv' && enabled=true)
2Content-Type: application/json

 1{
 2  "page": 1,
 3  "perPage": 30,
 4  "totalItems": 2,
 5  "totalPages": 1,
 6  "items": [
 7    {
 8      "application": "2ipc3erqkokl5kv",
 9      "collectionId": "pkvh6fhkcoe8kk0",
10      "collectionName": "products",
11      "created": "2024-08-26 21:00:32.354Z",
12      "description": "example product",
13      "enabled": true,
14      "id": "4t0uvrhoyqqgpxk",
15      "name": "example",
16      "price": 10,
17      "updated": "2024-08-26 21:00:32.354Z"
18    },
19    {
20      "application": "2ipc3erqkokl5kv",
21      "collectionId": "pkvh6fhkcoe8kk0",
22      "collectionName": "products",
23      "created": "2024-08-26 21:13:47.641Z",
24      "description": "example2",
25      "enabled": true,
26      "id": "k9u6largvm5esjy",
27      "name": "example2",
28      "price": 3.2,
29      "updated": "2024-08-26 21:14:02.704Z"
30    }
31  ]
32}

 1func (h *Users) Send(c echo.Context) error {
 2	data := struct {
 3		Email string `json:"email" form:"email"`
 4	}{}
 5	if err := c.Bind(&data); err != nil {
 6		return err
 7	}
 8
 9	record, err := h.app.Dao().FindFirstRecordByData("users", "email", data.Email)
10	if err != nil && !errors.Is(err, sql.ErrNoRows) {
11		return err
12	}
13
14	if record == nil {
15		users, err := h.app.Dao().FindCollectionByNameOrId("users")
16		if err != nil {
17			return err
18		}
19
20		record = models.NewRecord(users)
21		record.Set("email", data.Email)
22		record.Set("username", data.Email)
23
24	}
25
26	password := utils.RandomString(6, true, false, true)
27
28	// TODO: send to email
29
30	record.SetPassword(password)
31
32	if err := h.app.Dao().SaveRecord(record); err != nil {
33		return err
34	}
35
36	html, err := h.registry.LoadFS(views.FS,
37		"layout.html",
38		"users/code.html",
39	).Render(map[string]any{
40		"email":   data.Email,
41	})
42
43	if err != nil {
44		return err
45	}
46
47	return c.HTML(http.StatusOK, html)
48}

 1package utils
 2
 3import (
 4	"golang.org/x/exp/rand"
 5)
 6
 7const (
 8	letterBytes  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 9	specialBytes = "!@#$%^&*()_+-=[]{}\\|;':\",.<>/?`~"
10	numBytes     = "0123456789"
11)
12
13func RandomString(length int, useLetters bool, useSpecial bool, useNum bool) string {
14	b := make([]byte, length)
15	for i := range b {
16		if useLetters {
17			b[i] = letterBytes[rand.Intn(len(letterBytes))]
18		} else if useSpecial {
19			b[i] = specialBytes[rand.Intn(len(specialBytes))]
20		} else if useNum {
21			b[i] = numBytes[rand.Intn(len(numBytes))]
22		}
23	}
24	return string(b)
25}

1password := utils.RandomString(6, true, false, true)

 1type Config struct {
 2	Password string
 3	Out      string
 4	In       string
 5	Port     int
 6	Username string
 7}
 8
 9type Mailer struct {
10	config Config
11}
12
13func New(config Config) *Mailer {
14	return &Mailer{
15		config: config,
16	}
17}
18
19type Message struct {
20	From    string `json:"from_email"`
21	Name    string `json:"from_name"`
22	To      string `json:"to"`
23	Subject string `json:"subject"`
24	Html    string `json:"html"`
25}
26
27func (m *Mailer) Send(message Message) error {
28	msg := gomail.NewMessage()
29	msg.SetHeader("From", message.From)
30	msg.SetHeader("To", message.To)
31	msg.SetHeader("Subject", message.Subject)
32	msg.SetBody("text/html", message.Html)
33
34	n := gomail.NewDialer(m.config.Out, m.config.Port, m.config.Username, m.config.Password)
35
36	if err := n.DialAndSend(msg); err != nil {
37		return err
38	}
39
40	return nil
41}

 1smtp := h.app.Settings().Smtp
 2mailer := mail.New(mail.Config{
 3    Password: smtp.Password,
 4    Out:      smtp.Host,
 5    Port:     smtp.Port,
 6    Username: smtp.Username,
 7})
 8
 9err = mailer.Send(mail.Message{
10    From:    h.app.Settings().Meta.SenderAddress,
11    Name:    h.app.Settings().Meta.SenderName,
12    To:      data.Email,
13    Subject: "Billing password",
14    Html:    "<p>Password: <b>" + password + "</b><p>",
15})

1// payments
2v1.GET("/:app/:product/payments/purchase", payments.Purchase, apis.RequireRecordAuth("users"))
3v1.GET("/:app/:product/payments/success", payments.Success, apis.RequireRecordAuth("users"))

 1<form method="POST" action="https://yoomoney.ru/quickpay/confirm">
 2    <input type="hidden" name="receiver" value="{{.wallet}}"/>
 3    <input type="hidden" name="label" value="{{.label}}"/>
 4    <input type="hidden" name="quickpay-form" value="button"/>
 5    <input type="hidden" name="sum" value="{{.amount}}" data-type="number"/>
 6    <input type="hidden" name="paymentType" value="AC">
 7    <input type="hidden" name="successURL"
 8            value="{{.base}}/v1/{{.app}}/{{.product}}/payments/success?payment={{.payment}}"/>
 9    <div style="height: 50px;">
10    </div>
11    <div class="form-row">
12        <button type="submit" class="btn btn-primary">Купить</button>
13    </div>
14</form>

1label := record.Id + ":" + record.GetString("product") + ":" + product.GetString("application")

 1id := c.QueryParam("payment")
 2
 3payment, err := h.app.Dao().FindFirstRecordByFilter(
 4    "payments",
 5    "id = {:id}",
 6    dbx.Params{"id": id},
 7)
 8
 9if err != nil {
10    return err
11}
12
13if payment.GetString("status") == StatusCreated {
14    payment.Set("status", StatusPaid)
15
16    if err := h.app.Dao().SaveRecord(payment); err != nil {
17        return err
18    }
19}

 1data := struct {
 2    NotificationType string  `json:"notification_type" form:"notification_type"`
 3    BillId           string  `json:"bill_id" form:"bill_id"`
 4    Amount           float64 `json:"amount" form:"amount"`
 5    DateTime         string  `json:"datetime" form:"datetime"`
 6    Codepro          bool    `json:"codepro" form:"codepro"`
 7    Sender           string  `json:"sender" form:"sender"`
 8    Sha1Hash         string  `json:"sha1_hash" form:"sha1_hash"`
 9    OperationLabel   string  `json:"operation_label" form:"operation_label"`
10    OperationId      string  `json:"operation_id" form:"operation_id"`
11    Currency         int     `json:"currency" form:"currency"`
12    Label            string  `json:"label" form:"label"`
13}{}

 1token := app.GetString("secret")
 2
 3check := data.NotificationType +
 4    "&" + data.OperationId +
 5    "&" + fmt.Sprintf("%.2f", data.Amount) +
 6    "&" + fmt.Sprintf("%d", data.Currency) +
 7    "&" + data.DateTime +
 8    "&" + data.Sender +
 9    "&" + fmt.Sprintf("%t", data.Codepro) +
10    "&" + token +
11    "&" + data.Label
12
13hash := sha1.New()
14hash.Write([]byte(check))
15sha := hex.EncodeToString(hash.Sum(nil))
16
17if sha != data.Sha1Hash {
18    h.app.Logger().Error("error on check hash", "counted", sha, "income", data.Sha1Hash)
19
20    return errors.New("error on check hash")
21}

 1type Label struct {
 2	Payment string
 3	Product string
 4	App     string
 5}
 6
 7func (l Label) Parse(in string) (Label, error) {
 8	parts := strings.Split(in, ":")
 9
10	if len(parts) < 3 {
11		return l, errors.New("invalid input")
12	}
13
14	l.Payment = parts[0]
15	l.Product = parts[1]
16	l.App = parts[2]
17
18	return l, nil
19}
20
21func (l Label) Format() string {
22	return l.Payment + ":" + l.Product + ":" + l.App
23}

 1ecord, err := h.app.Dao().FindRecordById("payments", label.Payment)
 2if err != nil {
 3    h.app.Logger().Error("error on find payment", "err", err, "id", label.Payment)
 4
 5    return err
 6}
 7
 8record.Set("status", StatusConfirm)
 9
10if err := h.app.Dao().SaveRecord(record); err != nil {
11    return err
12}

1GET http://127.0.0.1:8081/api/collections/payments/records
2Content-Type: application/json
3Authorization: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MjcyNTc5NTYsImlkIjoiaHo0MjlpZjQ2MjFlaDdkIiwidHlwZSI6ImFkbWluIn0.AK2X3ny17U5hXVPyXGTnUpNiOEwWDQVOteZNzFBu7Vw

 1{
 2  "page": 1,
 3  "perPage": 30,
 4  "totalItems": 18,
 5  "totalPages": 1,
 6  "items": [
 7    {
 8      "amount": 3.2,
 9      "collectionId": "m8pbua5mie8cf29",
10      "collectionName": "payments",
11      "created": "2024-09-01 17:24:30.308Z",
12      "description": "",
13      "id": "u0ms2ok05m41a8w",
14      "name": "example2",
15      "product": "k9u6largvm5esjy",
16      "status": "confirm",
17      "updated": "2024-09-01 17:40:38.854Z",
18      "user": "ymxbvnqubr7klio"
19    },
20    {
21      "amount": 3.2,
22      "collectionId": "m8pbua5mie8cf29",
23      "collectionName": "payments",
24      "created": "2024-09-01 17:30:51.403Z",
25      "description": "",
26      "id": "2lnteevff3r5lnt",
27      "name": "example2",
28      "product": "k9u6largvm5esjy",
29      "status": "created",
30      "updated": "2024-09-01 17:30:51.403Z",
31      "user": "ymxbvnqubr7klio"
32    },
33    {
34      "amount": 3.2,
35      "collectionId": "m8pbua5mie8cf29",
36      "collectionName": "payments",
37      "created": "2024-09-01 17:32:50.690Z",
38      "description": "",
39      "id": "i0si9e5dll7d4hx",
40      "name": "example2",
41      "product": "k9u6largvm5esjy",
42      "status": "created",
43      "updated": "2024-09-01 17:32:50.690Z",
44      "user": "ymxbvnqubr7klio"
45    }
46  ]
47}

 1private fun auth(handler: AuthHandler) {
 2    // TODO: можно использовать хранилище. 
 3    // Сейчас токен храниться только в памяти
 4    if (savedToken != "") {
 5        handler.onSuccess(AuthResponse(token = savedToken))
 6        return
 7    }
 8
 9    val dialog = Dialog(context = context, url = "${api}/v1/user/login")
10    dialog.client = object : WebViewClient() {
11        override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest?): WebResourceResponse? {
12            return super.shouldInterceptRequest(view, request)
13        }
14
15        override fun shouldOverrideUrlLoading(w: WebView, u: String): Boolean {
16            w.loadUrl(u)
17            return true
18        }
19
20        override fun onPageFinished(view: WebView?, url: String?) {
21            if (url?.contains("success?token=") ?: false) {
22                // сохраняем токен для последующих запросов
23                val token = URL(url).param("token").orEmpty()
24
25                dialog.close()
26
27                savedToken = token
28                handler.onSuccess(AuthResponse(token = token))
29            }
30
31            Log.d(TAG, url.orEmpty())
32        }
33    }
34
35    dialog.open()
36}

 1fun products(handler: ProductsHandler) {
 2    val request = Request.Builder()
 3        .url("${api}/api/collections/products/records?filter=${URLEncoder.encode("(application='${app}' && enabled=true)", "utf-8")}")
 4        .build()
 5
 6    client.newCall(request).enqueue(object : Callback {
 7        override fun onFailure(call: Call, e: IOException) {
 8            handler.onFailure(e)
 9        }
10
11        override fun onResponse(call: Call, response: Response) {
12            response.use {
13                if (!response.isSuccessful) {
14                    if (response.code == 403) {
15                        savedToken = ""
16                    }
17
18                    handler.onFailure(IOException("Unexpected code $response"))
19                    return
20                }
21
22                val body = response.body?.string().orEmpty()
23                val resp: ProductsResponse
24
25                try {
26                    resp = Gson().fromJson(body, ProductsResponse::class.java)
27                } catch (e: Exception) {
28                    Log.d(TAG, e.message.orEmpty())
29                    handler.onFailure(e)
30                    return
31                }
32
33                handler.onSuccess(resp)
34            }
35        }
36    })
37}

 1object : WebViewClient() {
 2    override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest?): WebResourceResponse? {
 3        return super.shouldInterceptRequest(view, request)
 4    }
 5
 6    override fun shouldOverrideUrlLoading(w: WebView, u: String): Boolean {
 7        w.loadUrl(u)
 8        return true
 9    }
10
11    override fun onPageFinished(view: WebView?, url: String?) {
12        // тут получаем нужную информацию
13    }
14}

1data class Product(
2    val id: String, 
3    val name: String, 
4    val description: String, 
5    val price: Float
6)
7
8data class ProductsResponse(val items: List<Product>)

 1fun purchase(id: String, handler: PurchaseHandler) {
 2    // показываем диалог аторизации если нет сохраненного токена
 3    auth(object : AuthHandler {
 4        override fun onFailure(e: Throwable) {
 5            handler.onFailure(e)
 6        }
 7
 8        override fun onSuccess(resp: AuthResponse) {
 9            val token = resp.token
10
11            // показываем диалог с запросом оплаты
12            val dialog = Dialog(context = context, url = "${api}/v1/${app}/${id}/payments/purchase")
13            dialog.client = object : WebViewClient() {
14                override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest?): WebResourceResponse? {
15                    val url = request!!.url.toString()
16                    return if (url.contains("${api}/v1/${app}/${id}/payments")) {
17                        // устанавливаем token в заголовок для авторизации
18                        // ...
19                    } else {
20                        super.shouldInterceptRequest(view, request)
21                    }
22                }
23
24                override fun shouldOverrideUrlLoading(w: WebView, u: String): Boolean {
25                    w.loadUrl(u)
26                    return true
27                }
28
29                override fun onPageFinished(view: WebView?, url: String?) {
30                    if (url?.contains("success?payment=") ?: false) {
31                        // проверяем платеж после редиректа на successURL
32                        // ...
33
34                        dialog.close()
35                    }
36                }
37            }
38
39            dialog.open()
40        }
41    })
42}

1val request = Request.Builder()
2    .url(url.trim())
3    .addHeader("Authorization", "${token}")
4    .build()

1interface PurchaseHandler {
2    fun onFailure(e: Throwable)
3    fun onSuccess(resp: PurchaseResponse)
4}

1data class PurchaseResponse(
2    val id: String,
3    val status: String,
4    val product: String,
5    val name: String,
6    val description: String,
7    val amount: Float,
8)

 1fun restore(handler: RestoreHandler) {
 2    auth(object : AuthHandler {
 3        override fun onFailure(e: Throwable) {
 4            handler.onFailure(e)
 5        }
 6
 7        override fun onSuccess(resp: AuthResponse) {
 8            val token = resp.token
 9
10            val request = Request.Builder()
11                .url("${api}/api/collections/payments/records?sort=-created")
12                .addHeader("Authorization", "${token}")
13                .build()
14
15            client.newCall(request).enqueue(object : Callback {
16                override fun onFailure(call: Call, e: IOException) {
17                    handler.onFailure(e)
18                }
19
20                override fun onResponse(call: Call, response: Response) {
21                    response.use {
22                        // ...
23
24                        handler.onSuccess(resp)
25                    }
26                }
27            })
28        }
29    })
30}

 1data class Payment(
 2    val id: String,
 3    val status: String,
 4    val product: String,
 5    val name: String,
 6    val description: String,
 7    val amount: Float,
 8)
 9
10data class RestoreResponse(val items: List<Payment>)

1docker run -v /home/user/data:/data  -p 8080:8080 registry.gitflic.ru/project/kovardin/payments/payments:latest --dir /data --dev  --http :8080 serve 

1repositories {
2    maven {
3        name = "depot"
4        url = "https://depot.kovardin.ru/packages"
5    }
6}

1dependencies {
2    implementation 'ru.kovardin:billing:0.1.3'
3}

1Billing.init(
2    context = this,
3    app = "xxxxxx",
4    api = "http://10.0.2.2:8080",
5)