func()

in app/registry/edit.go [30:129]
81 lines of code
17 McCabe index (conditional complexity)

func (a *App) editRegistryGet(ctx *gin.Context) (response router.Response, retErr error) {
	registryName := ctx.Param("name")

	mrExists, err := ProjectHasOpenMR(ctx, registryName, a.Gerrit)
	if err != nil {
		return nil, fmt.Errorf("unable to check MRs exists, %w", err)
	}

	if mrExists {
		return router.MakeHTMLResponse(200, "registry/edit-mr-exists.html", gin.H{
			"registryName": registryName,
			"page":         "registry",
		}), nil
	}

	userCtx := router.ContextWithUserAccessToken(ctx)
	cbService, err := a.Services.Codebase.ServiceForContext(userCtx)
	if err != nil {
		return nil, fmt.Errorf("unable to init service for user context, %w", err)
	}

	k8sService, err := a.Services.K8S.ServiceForContext(userCtx)
	if err != nil {
		return nil, fmt.Errorf("unable to init service for user context, %w", err)
	}

	if err := a.checkUpdateAccess(registryName, k8sService); err != nil {
		return nil, errors.New("access denied")
	}

	reg, err := cbService.Get(registryName)
	if err != nil {
		return nil, fmt.Errorf("unable to get registry, %w", err)
	}

	model := registry{KeyDeviceType: KeyDeviceTypeFile, Name: reg.Name}
	if reg.Spec.Description != nil {
		model.Description = *reg.Spec.Description
	}

	hwINITemplateContent, err := GetINITemplateContent(a.Config.HardwareINITemplatePath)
	if err != nil {
		return nil, fmt.Errorf("unable to get ini template data, %w", err)
	}

	hasUpdate, branches, registryVersion, err := HasUpdate(userCtx, a.Services.Gerrit, reg, MRTargetRegistryVersionUpdate)
	if err != nil {
		return nil, fmt.Errorf("unable to check for updates, %w", err)
	}

	if is, rsp := isVersionRedirect(ctx, "/admin/registry/edit", registryName, registryVersion); is {
		return rsp, nil
	}

	dnsManual, err := a.getDNSManualURL(ctx)
	if err != nil {
		return nil, fmt.Errorf("unable to get dns manual, %w", err)
	}

	valuesFromDefaultBranch, err := a.GetValuesFromBranch(a.Config.RegistryTemplateName, registryVersion.Original())
	if err != nil {
		return nil, fmt.Errorf("unable to get template content, %w", err)
	}

	responseParams := gin.H{
		"dnsManual":             dnsManual,
		"registry":              reg,
		"page":                  "registry",
		"updateBranches":        branches,
		"hasUpdate":             hasUpdate,
		"action":                "edit",
		"registryVersion":       MajorVersion(registryVersion.Core().Original()),
		"platformStatusType":    a.Config.CloudProvider,
		"isPlatformAdmin":       ctx.GetBool(router.CanViewClusterManagementSessionKey),
		"defaultRegistryValues": valuesFromDefaultBranch,
	}

	values, err := GetValuesFromGit(registryName, MasterBranch, a.Gerrit)
	if err != nil {
		return nil, fmt.Errorf("unable to get values from git, %w", err)
	}

	if err := a.loadValuesEditConfig(ctx, values, responseParams, &model); err != nil {
		return nil, fmt.Errorf("unable to load edit values from config, %w", err)
	}

	if err := a.viewDNSConfig(ctx, reg, values, responseParams); err != nil {
		return nil, fmt.Errorf("unable to load dns config, %w", err)
	}

	templateArgs, templateErr := json.Marshal(responseParams)
	if templateErr != nil {
		return nil, fmt.Errorf("unable to encode template arguments, %w", templateErr)
	}

	responseParams["templateArgs"] = string(templateArgs)
	responseParams["hwINITemplateContent"] = hwINITemplateContent

	return router.MakeHTMLResponse(200, "registry/edit.html", responseParams), nil
}