Bug fix: SystemInfo Get method fix incase of no query parameter provided

	mutex.Lock()

	defer mutex.Unlock()

	// Validate query parameters

	// Parse query parameters

	u, _ := url.Parse(r.URL.String())

	q := u.Query()

	log.Debug("systeminfoGET: q: ", q)

	validParams := []string{"systemId", "systemName", "systemProvider"}

	// If no query parameters are provided, return all systemInfo

	if len(q) == 0 {

		log.Debug("systeminfoGET: No query parameters provided, returning all systemInfo")

		if len(systemInfopMap) == 0 {

			errHandlerProblemDetails(w, "No systemInfo registered", http.StatusNotFound)

			return

		}

		var systemInfos = []SystemInfo{}

		for _, val := range systemInfopMap {

			systemInfos = append(systemInfos, SystemInfo{

				SystemId:       val.SystemId,

				SystemName:     val.SystemName,

				SystemProvider: val.SystemProvider,

			})

		}

		jsonResponse, err := json.Marshal(systemInfos)

		if err != nil {

			http.Error(w, err.Error(), http.StatusInternalServerError)

			return

		}

		w.WriteHeader(http.StatusOK)

		fmt.Fprint(w, string(jsonResponse))

		return

	}

	// Validate query parameters

	err := validateQueryParams(q, validParams)

	if err != nil {

		errHandlerProblemDetails(w, err.Error(), http.StatusBadRequest)

		return

	}

	// Check if systemInfopMap is empty

	if len(systemInfopMap) == 0 {

		errHandlerProblemDetails(w, "No systemInfo registered", http.StatusNotFound)

		return

	}

	// Extract query parameter values

	systemId := q["systemId"]

	systemName := q["systemName"]

	systemProvider := q["systemProvider"]

	noFilter := len(systemId) != 0 && len(systemName) != 0 && len(systemProvider) != 0

	log.Debug("systeminfoGET: systemId: ", systemId)

	log.Debug("systeminfoGET: systemName: ", systemName)

	log.Debug("systeminfoGET: systemProvider: ", systemProvider)

	log.Debug("systeminfoGET: noFilter: ", noFilter)

	log.Debug("systeminfoGET: systemInfopMap: ", systemInfopMap)

	if len(systemInfopMap) == 0 {

		err = errors.New("No systemInfo registered")

		errHandlerProblemDetails(w, err.Error(), http.StatusNotFound)

		return

	} else {

		l := []sbi.SystemInfo{}

	// Filter systemInfo based on query parameters (AND logic)

	var filteredSystemInfos []sbi.SystemInfo

	for _, val := range systemInfopMap {

		log.Debug("systeminfoGET: processing ", val)

			if noFilter {

				l = append(l, val)

			} else {

				if len(systemId) != 0 {

					for _, v := range systemId {

						if v == val.SystemId {

		shouldInclude := true

		// Check systemId filter - must match if provided

		if len(systemId) > 0 {

			matchFound := false

			for _, id := range systemId {

				if id == val.SystemId {

					log.Debug("systeminfoGET: Apply filter on systemId")

							l = append(l, val)

					matchFound = true

					break

				}

			}

			if !matchFound {

				shouldInclude = false

			}

		}

				if len(systemName) != 0 {

					for _, v := range systemName {

						if v == val.SystemName {

		// Check systemName filter - must match if provided (AND logic)

		if shouldInclude && len(systemName) > 0 {

			matchFound := false

			for _, name := range systemName {

				if name == val.SystemName {

					log.Debug("systeminfoGET: Apply filter on systemName")

							l = append(l, val)

					matchFound = true

					break

				}

			}

			if !matchFound {

				shouldInclude = false

			}

		}

				if len(systemProvider) != 0 {

					for _, v := range systemProvider {

						if v == val.SystemProvider {

		// Check systemProvider filter - must match if provided (AND logic)

		if shouldInclude && len(systemProvider) > 0 {

			matchFound := false

			for _, provider := range systemProvider {

				if provider == val.SystemProvider {

					log.Debug("systeminfoGET: Apply filter on systemProvider")

							l = append(l, val)

					matchFound = true

					break

				}

			}

			if !matchFound {

				shouldInclude = false

			}

		}

		if shouldInclude {

			filteredSystemInfos = append(filteredSystemInfos, val)

		}

		if len(l) == 0 {

			err = errors.New("No systemInfo registered with applied filter")

			errHandlerProblemDetails(w, err.Error(), http.StatusBadRequest)

	}

	// Check if any results were found

	if len(filteredSystemInfos) == 0 {

		errHandlerProblemDetails(w, "No systemInfo found matching the specified criteria", http.StatusNotFound)

		return

	}

	// Convert to response format

	var systemInfos = []SystemInfo{}

		for _, val := range l {

	for _, val := range filteredSystemInfos {

		systemInfos = append(systemInfos, SystemInfo{

			SystemId:       val.SystemId,

			SystemName:     val.SystemName,

			SystemProvider: val.SystemProvider,

		})

	}

	// Marshal and send response

	jsonResponse, err := json.Marshal(systemInfos)

	if err != nil {

		http.Error(w, err.Error(), http.StatusInternalServerError)

		return

	}

		fmt.Fprint(w, string(jsonResponse))

	w.WriteHeader(http.StatusOK)

	}

	fmt.Fprint(w, string(jsonResponse))

}

func systeminfoPOST(w http.ResponseWriter, r *http.Request) {