Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

func MetricReadStatusMapper(sReference interface{}, dataOld string, dataNew string)…

  1. User

    func MetricReadStatusMapper(sReference interface{}, dataOld string, dataNew string) string {

    var sReferences []map[string]interface{}
    json.Unmarshal([]byte(sReference.(string)), &sReferences)
    userReadStatus := "true,true,true,true,true,true,true,true,true"
    
    split := strings.Split(userReadStatus, ",")
    for _, value := range sReferences{
    	key := ShrimpEstateMetricKey[value["key"].(string)]
    
    	statusDataOld := "good"
    	statusDataNew := "wary"
    
    	keyIndex := key.(int)
    	splitDataOld := strings.Split(dataOld, ",")[keyIndex]
    	for _, sReference := range sReferences {
    		if key == sReference["key"].(string) {
    			var reference []map[string]interface{}
    			byteReference, _ := json.Marshal(sReference["reference"])
    			json.Unmarshal(byteReference, &reference)
    
    			checker := false
    			for _, refValue := range reference {
    				var parameter []map[string]interface{}
    				byteParameter, _ := json.Marshal(refValue["parameter"])
    				json.Unmarshal(byteParameter, &parameter)
    
    				for _, parValue := range parameter {
    					convRaw, _ := strconv.ParseFloat(splitDataOld, 64)
    					if !checker {
    						statusDataOld = refValue["status"].(string)
    						switch parValue["type"] {
    						case "greater-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv < convRaw {
    								checker = true
    								break
    							}
    						case "lower-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv > convRaw {
    								checker = true
    								break
    							}
    						case "between":
    							splitVal := strings.Split(parValue["value"].(string), "-")
    							fConv, _ := strconv.ParseFloat(splitVal[0], 64)
    							sConv, _ := strconv.ParseFloat(splitVal[1], 64)
    							if fConv <= convRaw && sConv >= convRaw {
    								checker = true
    								break
    							}
    						}
    					}
    				}
    			}
    		}
    	}
    
    	splitDataNew := strings.Split(dataNew, ",")[keyIndex]
    	for _, sReference := range sReferences {
    		if key == sReference["key"].(string) {
    			var reference []map[string]interface{}
    			byteReference, _ := json.Marshal(sReference["reference"])
    			json.Unmarshal(byteReference, &reference)
    
    			checker := false
    			for _, refValue := range reference {
    				var parameter []map[string]interface{}
    				byteParameter, _ := json.Marshal(refValue["parameter"])
    				json.Unmarshal(byteParameter, &parameter)
    
    				for _, parValue := range parameter {
    					convRaw, _ := strconv.ParseFloat(splitDataNew, 64)
    					if !checker {
    						statusDataNew = refValue["status"].(string)
    						switch parValue["type"] {
    						case "greater-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv < convRaw {
    								checker = true
    								break
    							}
    						case "lower-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv > convRaw {
    								checker = true
    								break
    							}
    						case "between":
    							splitVal := strings.Split(parValue["value"].(string), "-")
    							fConv, _ := strconv.ParseFloat(splitVal[0], 64)
    							sConv, _ := strconv.ParseFloat(splitVal[1], 64)
    							if fConv <= convRaw && sConv >= convRaw {
    								checker = true
    								break
    							}
    						}
    					}
    				}
    			}
    		}
    	}
    
    	if statusDataOld != statusDataNew {
    		split[keyIndex] = "false"
    	}
    }
    
    join := strings.Join(split, ",")
    userReadStatus = join
    return userReadStatus
    

    }

    bagaimana mengubah bagian statusDataOld := "good" statusDataNew := "wary". menjadi dinamis. seperti flow dibawah ini: Jadi value dri data baru itu di compare dlu sma sReferences buat dapet nilai good/wary/bad dulu, nah value dari data lama dicompare juga buat dapet good/wary/bad. Klo nilai ny beda, misalny data baru good, trus data lama wary/bad, user_read_status itu nnti berubah dri true ke false

  2. Assistant

    Anda dapat membuat sebuah fungsi terpisah untuk menjadikan proses komparasi tersebut menjadi dinamis. Berikut ini merupakan contoh konkret cara mengubah kode yang ada agar menjadi lebih dinamis:

    func getStatusData(sReference map[string]interface{}, data string) string {
    	var reference []map[string]interface{}
    	byteReference, _ := json.Marshal(sReference["reference"])
    	json.Unmarshal(byteReference, &reference)
    
    	for _, refValue := range reference {
    		var parameter []map[string]interface{}
    		byteParameter, _ := json.Marshal(refValue["parameter"])
    		json.Unmarshal(byteParameter, &parameter)
    
    		checker := true
    		for _, parValue := range parameter {
    			convRaw, _ := strconv.ParseFloat(data, 64)
    			switch parValue["type"] {
    			case "greater-than":
    				conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    				checker = checker && (convRaw > conv)
    			case "lower-than":
    				conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    				checker = checker && (convRaw < conv)
    			case "between":
    				splitVal := strings.Split(parValue["value"].(string), "-")
    				fConv, _ := strconv.ParseFloat(splitVal[0], 64)
    				sConv, _ := strconv.ParseFloat(splitVal[1], 64)
    				checker = checker && (fConv <= convRaw && sConv >= convRaw)
    			}
    		}
    
    		if checker {
    			return refValue["status"].(string)
    		}
    	}
    
    	return "unknown"
    }
    
    func MetricReadStatusMapper(sReference interface{}, dataOld string, dataNew string) string {
    	var sReferences []map[string]interface{}
    	json.Unmarshal([]byte(sReference.(string)), &sReferences)
    	userReadStatus := "true,true,true,true,true,true,true,true,true"
    
    	dataOldSplit := strings.Split(dataOld, ",")
    	dataNewSplit := strings.Split(dataNew, ",")
    	statusSplit := strings.Split(userReadStatus, ",")
    
    	for index, value := range sReferences {
    		key := ShrimpEstateMetricKey[value["key"].(string)]
    		keyIndex := key.(int)
    
    		statusDataOld := getStatusData(value, dataOldSplit[keyIndex])
    		statusDataNew := getStatusData(value, dataNewSplit[keyIndex])
    
    		if statusDataOld != statusDataNew {
    			statusSplit[keyIndex] = "false"
    		}
    	}
    
    	join := strings.Join(statusSplit, ",")
    	userReadStatus = join
    	return userReadStatus
    }
    

    Dalam kode di atas, saya membuat fungsi getStatusData() yang menerima sReference dan data sebagai input. Fungsi ini akan mengembalikan status data berdasarkan referensi yang diberikan. Kemudian, saya menggantikan bagian kode yang sebelumnya menggunakan nilai statis dengan memanggil fungsi getStatusData() ini.

    Dengan cara ini, kode Anda akan menjadi lebih dinamis dan mudah untuk diubah nantinya jika perlu.

  3. User

    func MetricReadStatusMapper(sReference interface{}, dataOld string, dataNew string) string {

    var sReferences []map[string]interface{}
    json.Unmarshal([]byte(sReference.(string)), &sReferences)
    userReadStatus := "true,true,true,true,true,true,true,true,true"
    
    split := strings.Split(userReadStatus, ",")
    for _, value := range sReferences{
    	key := ShrimpEstateMetricKey[value["key"].(string)]
    
    	statusDataOld := "good"
    	statusDataNew := "wary"
    
    	keyIndex := key.(int)
    	splitDataOld := strings.Split(dataOld, ",")[keyIndex]
    	for _, sReference := range sReferences {
    		if key == sReference["key"].(string) {
    			var reference []map[string]interface{}
    			byteReference, _ := json.Marshal(sReference["reference"])
    			json.Unmarshal(byteReference, &reference)
    
    			checker := false
    			for _, refValue := range reference {
    				var parameter []map[string]interface{}
    				byteParameter, _ := json.Marshal(refValue["parameter"])
    				json.Unmarshal(byteParameter, &parameter)
    
    				for _, parValue := range parameter {
    					convRaw, _ := strconv.ParseFloat(splitDataOld, 64)
    					if !checker {
    						statusDataOld = refValue["status"].(string)
    						switch parValue["type"] {
    						case "greater-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv < convRaw {
    								checker = true
    								break
    							}
    						case "lower-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv > convRaw {
    								checker = true
    								break
    							}
    						case "between":
    							splitVal := strings.Split(parValue["value"].(string), "-")
    							fConv, _ := strconv.ParseFloat(splitVal[0], 64)
    							sConv, _ := strconv.ParseFloat(splitVal[1], 64)
    							if fConv <= convRaw && sConv >= convRaw {
    								checker = true
    								break
    							}
    						}
    					}
    				}
    			}
    		}
    	}
    
    	splitDataNew := strings.Split(dataNew, ",")[keyIndex]
    	for _, sReference := range sReferences {
    		if key == sReference["key"].(string) {
    			var reference []map[string]interface{}
    			byteReference, _ := json.Marshal(sReference["reference"])
    			json.Unmarshal(byteReference, &reference)
    
    			checker := false
    			for _, refValue := range reference {
    				var parameter []map[string]interface{}
    				byteParameter, _ := json.Marshal(refValue["parameter"])
    				json.Unmarshal(byteParameter, &parameter)
    
    				for _, parValue := range parameter {
    					convRaw, _ := strconv.ParseFloat(splitDataNew, 64)
    					if !checker {
    						statusDataNew = refValue["status"].(string)
    						switch parValue["type"] {
    						case "greater-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv < convRaw {
    								checker = true
    								break
    							}
    						case "lower-than":
    							conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    							if conv > convRaw {
    								checker = true
    								break
    							}
    						case "between":
    							splitVal := strings.Split(parValue["value"].(string), "-")
    							fConv, _ := strconv.ParseFloat(splitVal[0], 64)
    							sConv, _ := strconv.ParseFloat(splitVal[1], 64)
    							if fConv <= convRaw && sConv >= convRaw {
    								checker = true
    								break
    							}
    						}
    					}
    				}
    			}
    		}
    	}
    
    	if statusDataOld != statusDataNew {
    		split[keyIndex] = "false"
    	}
    }
    
    join := strings.Join(split, ",")
    userReadStatus = join
    return userReadStatus
    

    }

    var ShrimpEstateMetricKey = map[string]interface{}{ "water-temperature": 0, "dissolved-oxygen": 1, "turbidity": 2, "water-ph": 3, "air-temperature": 4, "air-humidity": 5, "tds": 8, }

    func (u commandUsecase) Create(ctx context.Context, payload map[string]interface{}) utils.Result { var result utils.Result

    var data = make(map[string]interface{})
    var dataReadStatus string
    
    if payload["platform"] == "antares" {
    	if payload["m2m:sgn"].(map[string]interface{})["m2m:nev"] != nil {
    		con := payload["m2m:sgn"].(map[string]interface{})["m2m:nev"].(map[string]interface{})["m2m:rep"].(map[string]interface{})["m2m:cin"].(map[string]interface{})["con"].(string)
    		json.Unmarshal([]byte(con), &data)
    	}
    } else if payload["platform"] == "itdri" {
    	queryDeviceRes := <-u.postgreQuery.FindOne(&queries.QueryPayload{
    		Table:  "smartfarm_partner_devices",
    		Select: "id",
    		Where: map[string]interface{}{
    			"integration_id": payload["deviceId"],
    		},
    	})
    	if queryDeviceRes.Error != nil {
    		errObj := httpError.NewNotFound()
    		errObj.Message = "Device tidak terdaftar pada database"
    		result.Error = errObj
    		return result
    	}
    	if payload["payload"] != nil {
    		data = payload["payload"].(map[string]interface{})
    	}
    	payload["device_id"] = queryDeviceRes.Data.(map[string]interface{})["id"]
    
    	query := <-u.postgreQuery.FindOne(&queries.QueryPayload{
    		Table:  "smartfarm_partner_device_metrics",
    		Select: "smartfarm_partner_device_id, value->'data' AS value",
    		Where: map[string]interface{}{
    			"smartfarm_partner_device_id": payload["device_id"],
    		},
    		Order: "created_at desc",
    	})
    
    	if query.Data == nil {
    		dataReadStatus = strings.Repeat("false,", 9) + "false"
    	}
    
    	queryRes := <-u.postgreQuery.FindOne(&queries.QueryPayload{
    		Table: "smartfarm_partner_device_metrics spdm",
    		Select: `subvessels.commodity_variety_id,spdm.data->'user_read_status'->>'data' AS user_read_status_data,
    		cv.data->>'smartfarm_references' AS smartfarm_references`,
    		Join: `LEFT JOIN subvessel_devices sd ON spdm.smartfarm_partner_device_id  = sd.smartfarm_partner_device_id
    		LEFT JOIN subvessels ON sd.subvessel_id = subvessels.id 
    		LEFT JOIN commodity_varieties cv ON subvessels.commodity_variety_id = cv.id`,
    		Order: "spdm.created_at desc",
    		Where: map[string]interface{}{
    			"spdm.smartfarm_partner_device_id": payload["device_id"],
    		},
    	})
    
    	// fmt.Println(data["data"].(string))
    
    	if query.Data != nil {
    		dataOld := query.Data.(map[string]interface{})["value"].(string)
    		sReference := queryRes.Data.(map[string]interface{})
    		dataNew := payload["payload"].(map[string]interface{})["data"].(string)
    		// fmt.Println(payload["data"].(string))
    		fmt.Println(sReference)
    		// fmt.Println(sReference["smartfarm_references"])
    		// fmt.Println(dataOld["value"].(string))
    		fmt.Println(dataOld)
    		// compareData["smartfarm_references"] = helpers.MetricReadStatusMapper(compareData, compareData["smartfarm_references"], dataOld["value"].(string), dataReadStatus, dataNew)
    		dataReadStatus = helpers.MetricReadStatusMapper(sReference["smartfarm_references"], dataOld, dataNew)
    		// if len(schema) > 0 {
    		// 	dataReadStatus = schema[0]["user_read_status"].(string)
    		// 	fmt.Println(schema[0]["user_read_status"].(string))
    		// 	fmt.Println(dataReadStatus)
    		// }
    
    		// if query.Data != nil {
    		// 	hasData := query.Data.(map[string]interface{})
    		// 	compareData := queryRes.Data.(map[string]interface{})
    		// 	schema := helpers.MetricReadStatusMapper(compareData, compareData["smartfarm_references"], hasData["value"].(string), dataReadStatus, data["data"].(string))
    		// 	if len(schema) > 0 {
    		// 		dataReadStatus = schema[0]["user_read_status"].(string)
    		// 		fmt.Println(schema[0]["user_read_status"].(string))
    		// 	}
    		// fmt.Println(compareData["smartfarm_references"])
    		// fmt.Println(data)
    		// fmt.Println(schema)
    		// fmt.Println(dataReadStatus)
    		// fmt.Println(hasData["value"].(string))
    		// fmt.Println(data["data"].(string))
    	}
    
    	// fmt.Println(queryRes)       // old data status
    	// fmt.Println(query.Data)     // old data value
    	// fmt.Println(dataReadStatus) // new data status
    	// fmt.Println(payload["data"].(string))          // new data value
    
    } else {
    	for key, value := range payload {
    		if key != "connection" && key != "device_id" {
    			data[key] = value
    		}
    	}
    }
    
    commandPayload := commands.CommandPayload{
    	Table: "smartfarm_partner_device_metrics",
    	Document: map[string]interface{}{
    		"id":                          uuid.NewString(),
    		"name":                        "",
    		"type":                        "",
    		"timestamp":                   "",
    		"value":                       data,
    		"created_at":                  time.Now(),
    		"created_by":                  payload["connection"].(string),
    		"smartfarm_partner_device_id": payload["device_id"],
    		"data":                        map[string]interface{}{"user_read_status": map[string]interface{}{"data": dataReadStatus}},
    	},
    }
    
    commandResult := <-u.postgreCommand.InsertOne(&commandPayload)
    if commandResult.Error != nil {
    	errObj := httpError.NewInternalServerError()
    	errObj.Message = "Gagal menerima data device"
    	result.Error = errObj
    	return result
    }
    
    result.Data = commandResult.Data
    
    return result
    

    }

    kenapa saat create data hasilnya malah seperti ini: "data": { "user_read_status": { "data": "false,false,false,false,true,false,true,true,false" } },

    seharusnya false semua karena pada data baru tidak ada perubahan data, tapi jika ada data yang berubah maka data tersebut jika status di dataOldnya true, pada create data baru akan berubah menjadi false (perubahan data pada user_read_status bergantung pada statusDataOld := "good" statusDataNew := "wary" (ini harusnya dinamis dan terdapat 3 kondisi good/wary/bad seperti flow berikut: Jadi value dri data baru itu di compare dlu sma sReferences buat dapet nilai good/wary/bad dulu, nah value dari data lama dicompare juga buat dapet good/wary/bad. Klo nilai ny beda, misalny data baru good, trus data lama wary/bad, user_read_status itu nnti berubah dri true ke false)

  4. Assistant

    Berdasarkan kode yang Anda berikan, fungsi MetricReadStatusMapper tidak akan mengubah nilai userReadStatus menjadi false untuk semua elemen ketika tidak ada perubahan data. Perubahan hanya terjadi saat statusDataOld berbeda dari statusDataNew, jika keduanya sama, kode tidak akan mengubah nilai userReadStatus.

    Untuk memastikan bahwa semua elemen userReadStatus diatur menjadi false jika tidak ada perubahan data, Anda bisa mengubah pendekatan dalam membandingkan status. Anda bisa mencoba memodifikasi kode dari fungsi MetricReadStatusMapper yang telah saya berikan sebelumnya, dan sesuaikan dengan logika yang Anda inginkan.

    Berikut adalah kode yang telah dimodifikasi untuk menangani kondisi dimana tidak ada perubahan data:

    func getStatusData(sReference map[string]interface{}, data string) string {
    	var reference []map[string]interface{}
    	byteReference, _ := json.Marshal(sReference["reference"])
    	json.Unmarshal(byteReference, &reference)
    
    	for _, refValue := range reference {
    		var parameter []map[string]interface{}
    		byteParameter, _ := json.Marshal(refValue["parameter"])
    		json.Unmarshal(byteParameter, &parameter)
    
    		checker := true
    		for _, parValue := range parameter {
    			convRaw, _ := strconv.ParseFloat(data, 64)
    			switch parValue["type"] {
    			case "greater-than":
    				conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    				checker = checker && (convRaw > conv)
    			case "lower-than":
    				conv, _ := strconv.ParseFloat(parValue["value"].(string), 64)
    				checker = checker && (convRaw < conv)
    			case "between":
    				splitVal := strings.Split(parValue["value"].(string), "-")
    				fConv, _ := strconv.ParseFloat(splitVal[0], 64)
    				sConv, _ := strconv.ParseFloat(splitVal[1], 64)
    				checker = checker && (fConv <= convRaw && sConv >= convRaw)
    			}
    		}
    
    		if checker {
    			return refValue["status"].(string)
    		}
    	}
    
    	return "unknown"
    }
    
    func MetricReadStatusMapper(sReference interface{}, dataOld string, dataNew string) string {
    	var sReferences []map[string]interface{}
    	json.Unmarshal([]byte(sReference.(string)), &sReferences)
    	userReadStatus := "true,true,true,true,true,true,true,true,true"
    
    	dataOldSplit := strings.Split(dataOld, ",")
    	dataNewSplit := strings.Split(dataNew, ",")
    	statusSplit := strings.Split(userReadStatus, ",")
    
    	for index, value := range sReferences {
    		key := ShrimpEstateMetricKey[value["key"].(string)]
    		keyIndex := key.(int)
    
    		statusDataOld := getStatusData(value, dataOldSplit[keyIndex])
    		statusDataNew := getStatusData(value, dataNewSplit[keyIndex])
    
    		if statusDataOld != statusDataNew {
    			statusSplit[keyIndex] = "false"
    		} else if statusDataOld == statusDataNew && statusDataOld != "good" {
    			statusSplit[keyIndex] = "false"
    		}
    	}
    
    	join := strings.Join(statusSplit, ",")
    	userReadStatus = join
    	return userReadStatus
    }
    

    Kode ini akan mengubah elemen userReadStatus menjadi false jika status baik statusDataOld maupun statusDataNew sama dan tidak "good". Jika Anda ingin menggantinya dengan kondisi yang berbeda, Anda bisa mengubah bagian else if sesuai kebutuhan Anda.