Refactoring von foreach Schleifen mit return statements

[LudwigBr]

Guten Abend liebe Community,

ich habe ein nicht Php-spezifisches Problem. Mein Code tut was er soll, aber er sieht grausam aus.
Kurzer Kontext, danach gibs Code. Ich habe ein Formular mit dem ein Fragebogen erstellt wird. Im Fragebogen können X Fragen sein die in Y Sets gruppiert sind. Wenn die Frage den Typ 2 (Multiple Choice) gibt es Z Antwortmöglichkeiten.

Die Codeblöcke sind alle nahezu identisch, aufgrund der return statements dadrin weiß ich allerdings nicht so recht wie ich das sinnvoll verschlankt bekomme.

Bisher sieht das ganze so aus:

//...
        // start transaction
        $this->db->begin();

        $questionnaire = $this->generateQuestionnaire($formData);
        if (!$questionnaire->save()) {
            $this->db->rollback();
            $response->setContent(json_encode("questionnaire save failed"));
            return $response;
        }

        foreach ($formData->sets as $setIndex => $formSet) {
            $set = $this->generateQuestionnaireSet($questionnaire, $formSet, $setIndex);
            if (!$set->save()) {
                $this->db->rollback();
                $response->setContent(json_encode("set save failed"));
                return $response;
            }

            foreach ($formSet->questions as $questionIndex => $formQuestion) {
                $question = $this->generateQuestion($set, $formQuestion);
                if (!$question->save()) {
                    $this->db->rollback();
                    $response->setContent(json_encode("question save failed"));
                    return $response;
                }

                // index 2 -> multiple choice question
                if ($formQuestion->type->index != 2) {
                    continue;
                }
                foreach ($formQuestion->possibilities as $possibilityIndex => $formPossibility) {
                    $possibility = $this->generatePossibility($question, $formPossibility);
                    if (!$possibility->save()) {
                        $this->db->rollback();
                        $response->setContent(json_encode("possibility save failed"));
                        return $response;
                    }
                }
            }
        }

        $this->db->commit();
//... 

Ich könnte die if's um 2 Zeilen verkleinern indem ich sowas in der Richtung baue:

// nur angedeutet!
    private function saveWithRollback($model, $response, $message) {
        if (!$model->save()) {
            $this->db->rollback();
            $response->setContent(json_encode($message));           
        }
        return $response;
    } 

In den Schleifen hätte ich dann je 2 Zeilen weniger, wirklich schön wirds davon aber nicht.

Kann mir jemand auf die Sprünge helfen wie ich das ein bisschen eleganter hinbekomme?

Liebe Grüße
Ludwig

[php1704]

Du teilst alles in einzelne Schritte auf.
Jeder Schritt für sich, ist dann recht überschaubar:

Auch nur angedeutet:

function saveForm($formData) {
    $questionnaire = $this->generateQuestionnaire($formData);
    if (!$questionnaire->save()) {
        throw new Exeption("questionnaire save failed");
    }
    saveFormSets($formData->sets, $questionnaire);
}

function saveFormSets($formSets, $questionnaire) {
    foreach ($formSets as $setIndex => $formSet) {
        $set = $this->generateQuestionnaireSet($questionnaire, $formSet, $setIndex);
        if (!$set->save()) {
            throw new Exeption("set save failed");
        }
        saveQuestions($formSet->questions, $set);
    }
}

function saveQuestions($formQuestions, $set) {
    foreach ($formQuestions as $questionIndex => $formQuestion) {
        $question = $this->generateQuestion($set, $formQuestion);
        if (!$question->save()) {
            throw new Exeption("question save failed");
        }      

        if ($formQuestion->type->index == 2) {
            savePossibilities($formQuestion);
        }
    }
}

function savePossibilities($formQuestions, $question) {
    foreach ($formQuestion->possibilities as $possibilityIndex => $formPossibility) {
        $possibility = $this->generatePossibility($question, $formPossibility);
        if (!$possibility->save()) {
            throw new Exeption("possibility save failed");
        }
    }          
} 

Und die Transaction mit commit und rollback wird dann auch recht einfach und übersichtlich.

$this->db->begin();
try {
    $this->saveForm($formData);
} catch (Exeption $e) {
    $this->db->rollback();
    return $response->setContent(json_encode($e->getMessage());
}
$this->db->commit(); 

Grüße.

[LudwigBr]

Vielen Dank für deinen Tipp, Exceptions schmeißen ist hier der springende Punkt für mich. Ich werde das in der Richtung umsetzen, das sieht doch bedeutend schöner aus

Liebe Grüße
Ludwig