func Get()

in traffic_ops/traffic_ops_golang/deliveryservice/request/requests.go [165:311]
130 lines of code
32 McCabe index (conditional complexity)

func Get(w http.ResponseWriter, r *http.Request) {
	inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil)
	tx := inf.Tx.Tx
	if userErr != nil || sysErr != nil {
		api.HandleErr(w, r, tx, errCode, userErr, sysErr)
		return
	}
	defer inf.Close()

	// Middleware should've already handled this, so idk why this is a pointer at all tbh
	version := inf.Version
	if version == nil {
		middleware.NotImplementedHandler().ServeHTTP(w, r)
		return
	}

	queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{
		"assignee":   {Column: "s.username"},
		"assigneeId": {Column: "r.assignee_id", Checker: api.IsInt},
		"author":     {Column: "a.username"},
		"authorId":   {Column: "r.author_id", Checker: api.IsInt},
		"changeType": {Column: "r.change_type"},
		"createdAt":  {Column: "r.created_at"},
		"id":         {Column: "r.id", Checker: api.IsInt},
		"status":     {Column: "r.status"},
	}
	if _, ok := inf.Params["orderby"]; !ok {
		inf.Params["orderby"] = "xmlId"
	}

	where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(inf.Params, queryParamsToQueryCols)
	if len(errs) > 0 {
		api.HandleErr(w, r, tx, http.StatusBadRequest, util.JoinErrs(errs), nil)
		return
	}

	// TODO: add this functionality to the query builder in dbhelpers
	if xmlID, ok := inf.Params["xmlId"]; ok {
		where = dbhelpers.AppendWhere(where, "((r.deliveryservice->>'xmlId' = :xmlId) OR (r.original->>'xmlId' = :xmlId))")
		queryValues["xmlId"] = xmlID
	}

	var maxTime *time.Time
	if inf.UseIMS() {
		maxTime = new(time.Time)
		var runSecond bool
		runSecond, *maxTime = ims.TryIfModifiedSinceQuery(inf.Tx, r.Header, queryValues, selectMaxLastUpdatedQuery(where))
		if !runSecond {
			log.Debugln("IMS HIT")
			api.WriteIMSHitResp(w, r, *maxTime)
			return
		}
		log.Debugln("IMS MISS")
	} else {
		log.Debugln("Non IMS request")
	}

	tenantIDs, err := tenant.GetUserTenantIDListTx(tx, inf.User.TenantID)
	if err != nil {
		sysErr = fmt.Errorf("dsr getting tenant list: %w", err)
		api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, sysErr)
		return
	}

	where = dbhelpers.AppendWhere(where, customTenancyCheck)
	queryValues["accessibleTenants"] = pq.Array(tenantIDs)

	query := selectQuery + where + orderBy + pagination
	log.Debugln("Query is ", query)

	rows, err := inf.Tx.NamedQuery(query, queryValues)
	if err != nil {
		sysErr = fmt.Errorf("dsr querying: %w", err)
		api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, sysErr)
		return
	}
	defer log.Close(rows, "getting DSRs")

	dsrs := []tc.DeliveryServiceRequestV5{}
	needOriginals := map[int][]*tc.DeliveryServiceRequestV5{}
	var originalIDs []int
	for rows.Next() {
		var dsr tc.DeliveryServiceRequestV5
		if err = rows.StructScan(&dsr); err != nil {
			api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("dsr scanning: %w", err))
			return
		}
		dsrs = append(dsrs, dsr)

		if dsr.IsOpen() && dsr.ChangeType != tc.DSRChangeTypeCreate {
			if dsr.ChangeType == tc.DSRChangeTypeUpdate && dsr.Requested != nil && dsr.Requested.ID != nil {
				id := *dsr.Requested.ID
				if _, ok := needOriginals[id]; !ok {
					needOriginals[id] = []*tc.DeliveryServiceRequestV5{&dsrs[len(dsrs)-1]}
				} else {
					needOriginals[id] = append(needOriginals[id], &dsrs[len(dsrs)-1])
				}
				originalIDs = append(originalIDs, id)
			} else if dsr.ChangeType == tc.DSRChangeTypeDelete && dsr.Original != nil && dsr.Original.ID != nil {
				id := *dsr.Original.ID
				if _, ok := needOriginals[id]; !ok {
					needOriginals[id] = []*tc.DeliveryServiceRequestV5{&dsrs[len(dsrs)-1]}
				} else {
					needOriginals[id] = append(needOriginals[id], &dsrs[len(dsrs)-1])
				}
				originalIDs = append(originalIDs, id)
			}
		}
	}

	if maxTime != nil {
		w.Header().Set(rfc.LastModified, maxTime.Format(rfc.LastModifiedFormat))
	}

	if version.Major >= 4 {
		errCode, userErr, sysErr = getOriginals(originalIDs, inf.Tx, needOriginals)
		if userErr != nil || sysErr != nil {
			api.HandleErr(w, r, tx, errCode, userErr, sysErr)
			return
		}
		if version.Major >= 5 {
			api.WriteResp(w, r, dsrs)
			return
		}
		if version.Minor >= 1 {
			downgraded := make([]tc.DeliveryServiceRequestV4, 0, len(dsrs))
			for _, dsr := range dsrs {
				downgraded = append(downgraded, dsr.Downgrade())
			}
			api.WriteResp(w, r, downgraded)
			return
		}
		downgraded := make([]tc.DeliveryServiceRequestV40, 0, len(dsrs))
		for _, dsr := range dsrs {
			downgraded = append(downgraded, dsr.Downgrade().Downgrade())
		}
		api.WriteResp(w, r, downgraded)
		return
	}

	downgraded := make([]tc.DeliveryServiceRequestNullable, 0, len(dsrs))
	for _, dsr := range dsrs {
		downgraded = append(downgraded, dsr.Downgrade().Downgrade().Downgrade())
	}

	api.WriteResp(w, r, downgraded)
}