func()

in app/cluster/view.go [17:122]
88 lines of code
17 McCabe index (conditional complexity)

func (a *App) view(ctx *gin.Context) (router.Response, error) {
	userCtx := router.ContextWithUserAccessToken(ctx)
	k8sService, err := a.Services.K8S.ServiceForContext(userCtx)
	if err != nil {
		return nil, errors.Wrap(err, "unable to init k8s service for user")
	}

	canUpdateCluster, err := k8sService.CanI("v2.edp.epam.com", "codebases", "update", a.Config.CodebaseName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to check access to cluster codebase")
	}

	cbService, err := a.Services.Codebase.ServiceForContext(userCtx)
	if err != nil {
		return nil, errors.Wrap(err, "unable to init codebase service for user")
	}

	cb, err := cbService.Get(a.Config.CodebaseName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to get cluster codebase")
	}

	branches, err := cbService.GetBranchesByCodebase(ctx, cb.Name)
	if err != nil {
		return nil, errors.Wrap(err, "unable to get registry branches")
	}
	cb.Branches = branches

	jenkinsComponent, err := a.Services.EDPComponent.Get(userCtx, "jenkins")
	if err != nil {
		return nil, errors.Wrap(err, "unable to get jenkins edp component")
	}

	gerritComponent, err := a.Services.EDPComponent.Get(userCtx, "gerrit")
	if err != nil {
		return nil, errors.Wrap(err, "unable to get gerrit edp component")
	}

	namespacedEDPComponents, err := a.Services.EDPComponent.GetAllNamespace(userCtx, cb.Name, true)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list namespaced edp components")
	}

	clusterValues, err := registry.GetValuesFromGit(a.ClusterRepo, registry.MasterBranch, a.Gerrit)
	if err != nil {
		return nil, fmt.Errorf("unable to get cluster values, %w", err)
	}

	categories, err := a.Services.EDPComponent.GetAllCategoryPlatform(userCtx)
	if err != nil {
		return nil, fmt.Errorf("unable to get edp components categories")
	}

	adminsStr, err := a.displayAdmins(clusterValues)
	if err != nil {
		return nil, errors.Wrap(err, "unable to get admins")
	}

	cidr, err := a.displayCIDR(clusterValues)
	if err != nil {
		return nil, errors.Wrap(err, "unable to get cidr")
	}

	emrs, err := a.ClusterGetMergeRequests(userCtx)
	if err != nil {
		return nil, errors.Wrap(err, "unable to load gerrit merge requests")
	}

	clusterProject, err := a.Gerrit.GetProject(userCtx, a.CodebaseName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to get cluster gerrit project")
	}

	hasUpdate, _, _, err := registry.HasUpdate(userCtx, a.Services.Gerrit, cb, registry.MRTargetClusterUpdate)
	if err != nil {
		return nil, errors.Wrap(err, "unable to check for updates")
	}

	rspParams := gin.H{
		"hasUpdate":        hasUpdate,
		"branches":         branches,
		"codebase":         cb,
		"jenkinsURL":       jenkinsComponent.Spec.Url,
		"gerritURL":        gerritComponent.Spec.Url,
		"edpComponents":    namespacedEDPComponents,
		"canUpdateCluster": canUpdateCluster,
		"admins":           adminsStr,
		"cidr":             cidr,
		"version":          a.getClusterVersion(clusterProject.Status.Branches, emrs),
		"mergeRequests":    emrs,
	}

	rspParams["platformOperationalComponents"] = categories[edpcomponent.PlatformOperationalZone]
	rspParams["platformAdministrationComponents"] = categories[edpcomponent.PlatformAdministrationZone]
	rspParams["platformCentralComponents"] = categories[edpcomponent.PlatformCentralZone]

	templateArgs, err := json.Marshal(rspParams)
	if err != nil {
		return nil, errors.Wrap(err, "unable to encode template arguments")
	}

	return router.MakeHTMLResponse(200, "cluster/view.html", gin.H{
		"page":         "cluster",
		"templateArgs": string(templateArgs),
	}), nil
}