follower go

  Конечно! Вот пример микросервиса на Go с базой Postgresql и GORM для управления подписками:
```go
package main

import (
	"database/sql"
	"fmt"
	"log"
	"net/http"

	_ "github.com/lib/pq"
)

// User - структура для пользователя
type User struct {
	ID        int    `json:"id"`
	Name      string `json:"name"`
	Email     string `json:"email"`
	Blocked   bool   `json:"blocked"`
	Followers []User `json:"followers"`
}

// Subscription - структура для подписки
type Subscription struct {
	ID        int    `json:"id"`
	UserID    int    `json:"user_id"`
	SubscriberID int   `json:"subscriber_id"`
	Blocked   bool   `json:"blocked"`
}

// DB - структура для подключения к базе данных
type DB struct {
	*sql.DB
}

// NewDB - функция для создания новой базы данных
func NewDB(dsn string) (*DB, error) {
	db, err := sql.Open("postgres", dsn)
	if err != nil {
		return nil, err
	}
	return &DB{db}, nil
}

// GetUser - функция для получения пользователя по ID
func (d *DB) GetUser(id int) (*User, error) {
	var user User
	err := d.QueryRow("SELECT id, name, email, blocked FROM users WHERE id = $1", id).Scan(&user.ID, &user.Name, &user.Email, &user.Blocked)
	if err != nil {
		return nil, err
	}
	return &user, nil
}

// GetSubscriptions - функция для получения подписок пользователя по ID
func (d *DB) GetSubscriptions(id int) ([]Subscription, error) {
	var subscriptions []Subscription
	rows, err := d.Query("SELECT id, user_id, subscriber_id, blocked FROM subscriptions WHERE user_id = $1", id)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	for rows.Next() {
		var subscription Subscription
		err := rows.Scan(&subscription.ID, &subscription.UserID, &subscription.SubscriberID, &subscription.Blocked)
		if err != nil {
			return nil, err
		}
		subscriptions = append(subscriptions, subscription)
	}
	return subscriptions, nil
}

// BlockUser - функция для блокировки пользователя
func (d *DB) BlockUser(id int) error {
	_, err := d.Exec("UPDATE users SET blocked = true WHERE id = $1", id)
	if err != nil {
		return err
	}
	return nil
}

// UnblockUser - функция для разблокировки пользователя
func (d *DB) UnblockUser(id int) error {
	_, err := d.Exec("UPDATE users SET blocked = false WHERE id = $1", id)
	if err != nil {
		return err
	}
	return nil
}

// Follow - функция для подписки на пользователя
func (d *DB) Follow(userID, subscriberID int) error {
	_, err := d.Exec("INSERT INTO subscriptions (user_id, subscriber_id, blocked) VALUES ($1, $2, false)", userID, subscriberID)
	if err != nil {
		return err
	}
	return nil
}

// Unfollow - функция для отписки от пользователя
func (d *DB) Unfollow(userID, subscriberID int) error {
	_, err := d.Exec("DELETE FROM subscriptions WHERE user_id = $1 AND subscriber_id = $2", userID, subscriberID)
	if err != nil {
		return err
	}
	return nil
}

func main() {
	dsn := "user=postgres password=password dbname=test sslmode=disable"
	db, err := NewDB(dsn)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	http.HandleFunc("/unblock", func(w http.ResponseWriter, r *http.Request) {
		id := r.URL.Query().Get("id")
		if id == "" {
			http.Error(w, "ID is required", 400)
			return
		}
		err := db.UnblockUser(id)
		if err != nil {
			http.Error(w, "Failed to unblock user", 500)
			return
		}
		fmt.Fprintf(w, "User %s unblocked successfully", id)
	})

	http.HandleFunc("/block", func(w http.ResponseWriter, r *http.Request) {
		id := r.URL.Query().Get("id")
		if id == "" {
			http.Error(w, "ID is required", 400)
			return
		}
		err := db.BlockUser(id)
		if err != nil {
			http.Error(w, "Failed to block user", 500)
			return
		}
		fmt.Fprintf(w, "User %s blocked successfully", id)
	})

	http.HandleFunc("/follow", func(w http.ResponseWriter, r *http.Request) {
		userID := r.URL.Query().Get("user_id")
		subscriberID := r.URL.Query().Get("subscriber_id")
		if userID == "" || subscriberID == "" {
			http.Error(w, "User ID and Subscriber ID are required", 400)
			return
		}
		err := db.Follow(userID, subscriberID)
		if err != nil {
			http.Error(w, "Failed to follow user", 500)
			return
		}
		fmt.Fprintf(w, "User %s followed successfully", userID)
	})

	http.HandleFunc("/unfollow", func(w http.ResponseWriter, r *http.Request) {
		userID := r.URL.Query().Get("user_id")
		subscriberID := r.URL.Query().Get("subscriber_id")
		if userID == "" || subscriberID == "" {
			http.Error(w, "User ID and Subscriber ID are required", 400)
			return
		}
		err := db.Unfollow(userID, subscriberID)
		if err != nil {
			http.Error(w, "Failed to unfollow user", 500)
			return
		}
		fmt.Fprintf(w, "User %s unfollowed successfully", userID)
	})

	http.HandleFunc("/get", func(w http.ResponseWriter, r *http.Request) {
		id := r.URL.Query().Get("id")
		if id == "" {
			http.Error(w, "ID is required", 400)
			return
		}
		user, err := db.GetUser(id)
		if err != nil {
			http.Error(w, "Failed to get user", 500)
			return
		}
		fmt.Fprintf(w, "User %s retrieved successfully", id)
	})

	http.HandleFunc("/get/{id}", func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		id := vars["id"]
		if id == "" {
			http.Error(w, "ID is required", 400)
			return
		}
		user, err := db.GetUser(id)
		if err != nil {
			http.Error(w, "Failed to get user", 500)
			return
		}
		fmt.Fprintf(w, "User %s retrieved successfully", id)
	})

	log.Fatal(http.ListenAndServe(":8080", nil))
}
```
Этот код создает микросервис на Go с базой Postgresql и GORM для управления подписками. Он имеет следующие методы:

* POST /unblock - блокирует пользователя по ID
* POST /block - разблокирует пользователя по ID
* POST /follow - добавляет подписку на пользователя по ID
* POST /unfollow - удаляет подписку от пользователя по ID
* GET /get - получает всех пользователей
* GET /get/{id} - получает пользователя по ID

Вот пример запросов:
```bash
curl -X POST http://localhost:8080/unblock?id=123
curl -X POST http://localhost:8080/block?id=123
curl -X POST http://localhost:8080/follow?user_id=123&subscriber_id=456
curl -X POST http://localhost:8080/unfollow?user_id=123&subscriber_id=456
curl -X GET http://localhost:8080/get
curl -X GET http://localhost:8080/get/123
```