сервис теперь решает задачи и отправляет их на проверку

main.go

@@ -3,15 +3,15 @@ package main
 import (
 	"fmt"
 	"gotest/solutions"
+	"io"
 	"net/http"
 )
 
 func main() {
-	fmt.Println("Live long and prosper")
+	fmt.Println("Engage!")
 	testHandler := func(w http.ResponseWriter, _ *http.Request) {
-		b, _ := solutions.ProcessTask(solutions.Rotation) //воткнул что бы не ругался на не использование
+		solutions.ProcessTask(solutions.FindUnique)
-		//io.WriteString(w, string(b))
+		io.WriteString(w, "я стану хокаге!!!")
-		fmt.Println(b)
 	}
 
 	http.HandleFunc("/status", testHandler)

solutions/service.go

@@ -1,55 +1,158 @@
 package solutions
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"gotest/consecutive"
+	"gotest/missing"
+	"gotest/rotation"
+	"gotest/unique"
 	"io"
 	"log"
 	"net/http"
+	"sync"
 )
 
+type taskElement struct {
+	a      []int
+	k      int
+	result []int
+}
+
 func ProcessTask(taskName string) ([]byte, error) {
 	//получаем условия для задач
-	var taskCases [10][]json.RawMessage
+	var taskCases []json.RawMessage
-	err := getCases(taskName, taskCases)
+	err := getCases(taskName, &taskCases)
 	if err != nil {
 		log.Fatalln(err)
-		return []byte{}, err
 	}
 	//решение задач
-	//
+	taskArray := [10]taskElement{}
-
+	err = solve(taskName, taskCases, &taskArray)
+	if err != nil {
+		log.Fatalln(err)
+	}
 	//сборка результата
-	//
+	var data []byte
-
+	data, err = requestReview(taskName, &taskCases, &taskArray)
-	//должен вернуть вывод решения
-	return nil, nil
-}
-
-func getCases(taskName string, taskCases [10][]json.RawMessage) error {
-
-	response, err := http.Get(fmt.Sprintf("%s/tasks/%s", SolutionURL, taskName))
-	if err != nil {
-		log.Fatalln(err)
-		return err
-	}
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
 	if err != nil {
 		log.Fatalln(err)
 	}
-	}(response.Body)
+
+	return data, nil
+}
+
+func getCases(taskName string, taskCases *[]json.RawMessage) error {
+
+	response, err := http.Get(fmt.Sprintf("%s/tasks/%s", SolutionURL, taskName)) //протягиваем руку за подоянием
+	if err != nil {
+		log.Fatalln(err)
+	}
+	defer response.Body.Close()
 
 	payload, err := io.ReadAll(response.Body)
 	if err != nil {
 		log.Fatalln(err)
-		return err
 	}
 
 	err = json.Unmarshal(payload, &taskCases)
 	if err != nil {
 		log.Fatalln(err)
-		return err
 	}
 	return nil
 }
+func solve(taskName string, taskCases []json.RawMessage, taskArray *[10]taskElement) error {
+	var wg sync.WaitGroup //ждёмс рутины
+	wg.Add(10)
+
+	for i, taskCase := range taskCases {
+		//парсим
+		var arguments []json.RawMessage
+		err := json.Unmarshal(taskCase, &arguments)
+		if err != nil {
+			log.Fatalln(err)
+		}
+
+		if taskName == Rotation { //ротация отличается от других массивов
+			json.Unmarshal(arguments[0], &taskArray[i].a)
+			json.Unmarshal(arguments[1], &taskArray[i].k)
+		} else {
+			err := json.Unmarshal(arguments[0], &taskArray[i].a)
+			if err != nil {
+				log.Fatalln(err)
+				return err
+			}
+		}
+		//отправляем входные данные в задачки
+		go func(i int) {
+			defer wg.Done() //дождались
+			switch taskName {
+			case Rotation:
+				taskArray[i].result = rotation.Rotation(taskArray[i].a, taskArray[i].k)
+			case FindUnique:
+				taskArray[i].result = append(taskArray[i].result, unique.FindUnique(taskArray[i].a))
+			case Cons:
+				taskArray[i].result = append(taskArray[i].result, consecutive.Consecutive(taskArray[i].a))
+			case Missing:
+				taskArray[i].result = append(taskArray[i].result, missing.FindNumber(taskArray[i].a))
+			default:
+			}
+		}(i)
+
+	}
+
+	wg.Wait() //ждёмс
+	return nil
+}
+
+func requestReview(taskName string, taskCases *[]json.RawMessage, taskArray *[10]taskElement) ([]byte, error) {
+	//собраем решения задач
+	var result []byte
+	var results []json.RawMessage
+	var err error
+
+	for _, element := range taskArray {
+		if taskName == Rotation {
+			result, err = json.Marshal(element.result)
+		} else {
+			result, err = json.Marshal(element.result[0])
+		}
+		if err != nil {
+			log.Fatalln(err)
+		}
+		results = append(results, result)
+
+	}
+
+	message := map[string]interface{}{
+		"user_name": userName,
+		"task":      taskName,
+		"results": map[string]interface{}{
+			"payload": taskCases,
+			"results": results,
+		},
+	}
+
+	packedMessage, err := json.Marshal(message)
+	if err != nil {
+		log.Fatalln()
+	}
+
+	request, err := http.Post(fmt.Sprintf("%s/tasks/solution", SolutionURL), "application/json", bytes.NewBuffer(packedMessage))
+
+	defer request.Body.Close()
+
+	var data []byte
+
+	if request.StatusCode != http.StatusOK {
+		data = []byte(request.Status)
+	} else {
+		data, err = io.ReadAll(request.Body)
+		if err != nil {
+			log.Fatalln(err)
+		}
+	}
+
+	return data, nil
+}