With this requirement, please verify output, and improve it if needed

<requirement start>
You are a Generative AI Software Engineer expert. Your tech stack is Golang, Java, ReactJS Build an flight agency application follow Clean Architecture, Microservice, Echo Framework for Golang Backend, Java Spring Boot for Java Back end, ReactJS follow Micro FrontEnd architecture. Application should have register, login, logout features, and all needed flight agency business Application deploy on openshift Application have jenkin as CICD tool Output as Markdown, step by step guideline, and a final script to create project structures & files
Create a complete script to build this project
<requirement end>

<output start>
`setup.sh`

#!/bin/bash

# Function to check for installed software
check_dependencies() {
  command -v go >/dev/null 2>&1 || { echo >&2 "Golang is not installed. Aborting."; exit 1; }
  command -v mvn >/dev/null 2>&1 || { echo >&2 "Maven is not installed. Aborting."; exit 1; }
  command -v node >/dev/null 2>&1 || { echo >&2 "Node.js is not installed. Aborting."; exit 1; }
  command -v npm >/dev/null 2>&1 || { echo >&2 "npm is not installed. Aborting."; exit 1; }
  command -v oc >/dev/null 2>&1 || { echo >&2 "OpenShift CLI is not installed. Aborting."; exit 1; }
}

# Function to create the Golang backend service
create_golang_backend() {
  echo "Creating Golang Backend..."
  mkdir -p flight-agency-golang/{cmd,internal/{handlers,models,repositories,services,routes},config}

  # Create main.go for Golang service
  cat <<EOL > flight-agency-golang/cmd/main.go
package main

import (
  "flight-agency/internal/routes"
  "github.com/labstack/echo/v4"
)

func main() {
  e := echo.New()
  routes.InitRoutes(e)
  e.Logger.Fatal(e.Start(":8080"))
}
EOL

  # Create the routes file for Golang service
  mkdir -p flight-agency-golang/internal/routes
  cat <<EOL > flight-agency-golang/internal/routes/routes.go
package routes

import (
  "github.com/labstack/echo/v4"
)

func InitRoutes(e *echo.Echo) {
  // Define your routes here
  e.GET("/flights", func(c echo.Context) error {
    return c.String(200, "List of flights")
  })
}
EOL

  # Create Dockerfile for Golang service
  cat <<EOL > flight-agency-golang/Dockerfile
FROM golang:1.18-alpine
WORKDIR /app
COPY . .
RUN go mod init flight-agency && go mod tidy && go build -o main .
CMD ["./main"]
EOL

  echo "Golang backend created successfully."
}

# Function to create the Java backend service
create_java_backend() {
  echo "Creating Java Spring Boot Backend..."

  mkdir -p flight-agency-java/src/main/java/com/flightagency/{controllers,services,repositories}
  mkdir -p flight-agency-java/src/main/resources

  # Create the main Spring Boot application file
  cat <<EOL > flight-agency-java/src/main/java/com/flightagency/Application.java
package com.flightagency;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
EOL

  # Create a simple BookingController file
  cat <<EOL > flight-agency-java/src/main/java/com/flightagency/controllers/BookingController.java
package com.flightagency.controllers;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/bookings")
public class BookingController {

    @PostMapping("/book")
    public String bookFlight() {
        // Dummy response
        return "Flight booked successfully!";
    }
}
EOL

  # Create Dockerfile for Java Spring Boot service
  cat <<EOL > flight-agency-java/Dockerfile
FROM openjdk:17-jdk-alpine
WORKDIR /app
COPY target/flight-agency-java.jar flight-agency-java.jar
ENTRYPOINT ["java","-jar","/app/flight-agency-java.jar"]
EOL

  # Create Maven POM file
  cat <<EOL > flight-agency-java/pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.flightagency</groupId>
    <artifactId>flight-agency-java</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
EOL

  echo "Java backend created successfully."
}

# Function to create the React micro frontend
create_react_frontend() {
  echo "Creating ReactJS Micro Frontend..."

  mkdir -p frontend/{auth-app,flights-app,booking-app}/src/{components,services}

  # Initialize React apps
  npx create-react-app frontend/auth-app
  npx create-react-app frontend/flights-app
  npx create-react-app frontend/booking-app

  # Create a simple login component in the auth-app
  cat <<EOL > frontend/auth-app/src/components/Login.js
import React, { useState } from "react";
import axios from "axios";

function Login() {
  const [email, setEmail] = useState("");
  const [password, setPassword] = useState("");

  const handleLogin = async () => {
    try {
      const response = await axios.post("/api/auth/login", { email, password });
      console.log("Login success", response.data);
    } catch (error) {
      console.error("Login failed", error);
    }
  };

  return (
    <div>
      <h1>Login</h1>
      <input type="email" placeholder="Email" onChange={(e) => setEmail(e.target.value)} />
      <input type="password" placeholder="Password" onChange={(e) => setPassword(e.target.value)} />
      <button onClick={handleLogin}>Login</button>
    </div>
  );
}

export default Login;
EOL

  echo "ReactJS frontend created successfully."
}

# Function to create the Jenkinsfile for CI/CD
create_jenkins_pipeline() {
  echo "Creating Jenkins Pipeline..."

  cat <<EOL > Jenkinsfile
pipeline {
    agent any
    stages {
        stage('Build Java Backend') {
            steps {
                sh 'mvn clean package -f flight-agency-java/pom.xml'
            }
        }
        stage('Build Go Backend') {
            steps {
                sh 'cd flight-agency-golang && go build -o main .'
            }
        }
        stage('Build React Frontend') {
            steps {
                sh 'cd frontend/auth-app && npm install && npm run build'
                sh 'cd frontend/flights-app && npm install && npm run build'
                sh 'cd frontend/booking-app && npm install && npm run build'
            }
        }
        stage('Deploy to OpenShift') {
            steps {
                sh 'oc new-app --name=flight-agency-java -f openshift/java-backend.yaml'
                sh 'oc new-app --name=flight-agency-golang -f openshift/go-backend.yaml'
                sh 'oc new-app --name=auth-frontend -f openshift/auth-frontend.yaml'
                sh 'oc new-app --name=flights-frontend -f openshift/flights-frontend.yaml'
                sh 'oc new-app --name=booking-frontend -f openshift/booking-frontend.yaml'
            }
        }
    }
}
EOL

  echo "Jenkinsfile created successfully."
}

# Function to create OpenShift templates
create_openshift_templates() {
  echo "Creating OpenShift Templates..."

  mkdir -p openshift

  # OpenShift Template for Golang backend
  cat <<EOL > openshift/go-backend.yaml
apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
metadata:
  name: flight-agency-golang
spec:
  replicas: 1
  selector:
    app: flight-agency-golang
  template:
    metadata:
      labels:
        app: flight-agency-golang
    spec:
      containers:
      - name: flight-agency-golang
        image: flight-agency-golang
        ports:
        - containerPort: 8080
EOL

  # OpenShift Template for Java backend
  cat <<EOL > openshift/java-backend.yaml
apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
metadata:
  name: flight-agency-java
spec:
  replicas: 1
  selector:
    app: flight-agency-java
  template:
    metadata:
      labels:
        app: flight-agency-java
    spec:
      containers:
      - name: flight-agency-java
        image: flight-agency-java
        ports:
        - containerPort: 8080
EOL

  # OpenShift Template for React frontend
  cat <<EOL > openshift/auth-frontend.yaml
apiVersion: apps.openshift.io/v1
kind: DeploymentConfig
metadata:
  name: auth-frontend
spec:
  replicas: 1
  selector:
    app: auth-frontend
  template:
    metadata:
      labels:
        app: auth-frontend
    spec:
      containers:
      - name: auth-frontend
        image: auth-frontend
        ports:
        - containerPort: 3000
EOL

  echo "OpenShift templates created successfully."
}

# Main function to run the script
main() {
  echo "Starting Flight Agency project setup..."
  check_dependencies
  create_golang_backend
  create_java_backend
  create_react_frontend
  create_jenkins_pipeline
  create_openshift_templates
  echo "Project setup completed successfully!"
}

# Run the main function
main

<output end>