Protobuf

//Using it 
address := basic.Address{
    Street:     "Street",
    City:       "City",
    PostalCode: "PSTCD3",
    Coordinate: &basic.Address_Coordinate{
        Lattitude: 40.705152254,
        Longitude: -74.52515425,
    },
    }

import (
	"log"
	"github.com/pvsnp9/example/pkg/protogen/basic"
	"google.golang.org/protobuf/encoding/protojson"
)

func ProtoToJsonUser() {
	u := basic.User{
		Id:       2,
		Username: "Bravo",
		IsActive: true,
		Password: []byte("adfasfas"),
		Emails:   []string{"test@mai.com", "test2@mail.com"},
		Gender:   basic.Gender_GENDER_MALE,
	}
	jsonBytes, err := protojson.Marshal(&u)
	if err != nil {
		log.Println("error", err)
	}
	log.Println(string(jsonBytes))
}

func JsonToProto() {
	json := `{
		"id": 5,
		"username":"delta",
		"is_active":true,
		"password":"YWRmYXNmYXM=",
		"emails":["test@mai.com", "test2@mail.com"],
		"gender":"GENDER_MALE"
	}`

	var user basic.User
	err := protojson.Unmarshal([]byte(json), &user)
	if err != nil {
		log.Println("Err:", err)
	}
	log.Println(&user)
}

//examples 
func randomCommunicationChanel() anypb.Any {
	paper_mail := basic.Papermail{
		PaperMailAddress: "Mailing address !!",
	}
	social_media := basic.SocialMedia{
		SocialMediaPlatform: "insta",
		SocialMediaUsername: "rango",
	}

	instant_messaging := basic.InstantMessaging{
		InstantMessagingProduct:  "whatsapp",
		InstantMessagingUsername: "Rango",
	}

	var any anypb.Any

	switch r := rand.Intn(20) % 3; r {
	case 0:
		anypb.MarshalFrom(&any, &paper_mail, proto.MarshalOptions{})
	case 1:
		anypb.MarshalFrom(&any, &social_media, proto.MarshalOptions{})
	default:
		anypb.MarshalFrom(&any, &instant_messaging, proto.MarshalOptions{})
	}
	return any
}

// if we know which message type it is.
func BasicUnMarshallAnyToKnown() {
	sm := basic.SocialMedia{
		SocialMediaPlatform: "Fb",
		SocialMediaUsername: "tt",
	}
	var a anypb.Any
	anypb.MarshalFrom(&a, &sm, proto.MarshalOptions{})
	smedia := basic.SocialMedia{}

	if err := a.UnmarshalTo(&smedia); err != nil {
		return
	}
	json, _ := protojson.Marshal(&sm)
	log.Print(string(json))
}

//if we do not know message type
func BasicUnMarshallAnyToUnknown() {
	anon := randomCommunicationChanel()

	var anonUnmarshalled protoreflect.ProtoMessage

	anonUnmarshalled, err := anon.UnmarshalNew()
	if err != nil {
		return
	}
	log.Print("Unmarshall as a ", anonUnmarshalled.ProtoReflect().Descriptor().Name())
	json, _ := protojson.Marshal(anonUnmarshalled)
	log.Print(string(json))
}

// oneof example
func BasicOneof() {
	sm := basic.SocialMedia{
		SocialMediaPlatform: "X",
		SocialMediaUsername: "Charlie",
	}

	ecom_chan := basic.User_SocialMedia{
		SocialMedia: &sm,
	}

	user := basic.User{
		Id:                    11,
		Username:              "LaLa",
		IsActive:              true,
		Password:              []byte("Rango"),
		Gender:                basic.Gender_GENDER_MALE,
		Emails:                []string{"test@mai.com", "test2@mail.com"},
		ElectronicCommChannel: &ecom_chan,
	}
	json, _ := protojson.Marshal(&user)
	log.Println(string(json))
}

skill_rating := map[string]uint32{"swim": 8, "fly": 9, "drive": 10}
user := User{
    SkillRating: skill_rating,
}

// write to file
func WriteUserToFile(user proto.Message, filename string) {
	bytes, _ := proto.Marshal(user)
	if err := ioutil.WriteFile(filename, bytes, 0644); err != nil {
		log.Fatalln("Error writing to file", err)
	}
	log.Println("writing to file completed")
}

//Reading from file
func ReadUserFromDisk(dest proto.Message, filename string) {

	log.Println("Reading file ", filename)
	bytes, err := ioutil.ReadFile(filename)
	if err != nil {
		log.Fatalln("Errot reading file", err)
		return
	}
	// var user basic.User
	if err := proto.Unmarshal(bytes, dest); err != nil {
		log.Fatalln("Error on unmarshalling user", err)
	}

	json, _ := protojson.Marshal(dest)
	log.Print(string(json))
}

//write as a json
func WriteAsJson(msg proto.Message, filename string) {
	jsonBytes, _ := protojson.Marshal(msg)
	if err := ioutil.WriteFile(filename, jsonBytes, 0644); err != nil {
		log.Fatalln("could not write to file ", err)
		return
	}
	log.Print("Writing file is completed.")
}

//read as jsom and print
func ReadAsJson(dest proto.Message, filename string) {
	bytes, err := ioutil.ReadFile(filename)
	if err != nil {
		log.Fatalln("Could not read file ", err)
		return
	}
	if err := protojson.Unmarshal(bytes, dest); err != nil {
		log.Fatalln("Unmarshalling failed ", err)
		return
	}
	json, _ := protojson.Marshal(dest)
	log.Println(string(json))
}

//read and write content in v1 
user_content := basic.UserContent{
UserContentId: 12,
    Slug:          "slug12",
    Title:         "Test content",
    HtmlContent:   "<h1>Heading 1</h1>",
    AuthorId:      32,
}

var dest basic.UserContent

services.WriteUserToFile(&user_content, "user_content_v1.bin")
services.ReadUserFromDisk(&dest, "user_content_v1.bin")

//readung and writing in V3
user_content := basic.UserContent{
    UserContentId: 12,
    Slug:          "slug12",
    HtmlContent:   "<h1>Heading 1</h1>",
    Category:      "S",
    SubCategory:   "AA",
}

var dest basic.UserContent

services.WriteUserToFile(&user_content, "user_content_v3.bin")
services.ReadUserFromDisk(&dest, "user_content_v3.bin")

import "pkg/pb/google/type/date.proto";
import "pkg/pb/google/type/latlng.proto";

message User {
    google.type.Date birth_date  = 24 [json_name = "birth_date"];
    google.type.LatLng last_known_location = 25 [json_name = "last_known_location"];
}

//usage
user := basic.User{
    Id:                    11,
    Username:              "LaLa",
    SkillRating:           skill_rating,
    LastLogin:             timestamppb.Now(),
    BirthDate:             &date.Date{Year: 2000, Month: 5, Day: 27},
    LastKnownLocation: &latlng.LatLng{
        Latitude:  -6.29847717,
        Longitude: 106.8290577,
    },
}