anpi @ a1bddb6

···
        1
        1
         package main

      
        2
        2
         

      
        3
        3
         import (

      
        4
        
        -	"fmt"

      
        5
        4
         	"log/slog"

      
        6
        5
         	"os"

      
        7
        6
         

      ···
        25
        24
         	data, err := parser.Parse(f)

      
        26
        25
         	slog.Info("parsing data", "err", err)

      
        27
        26
         

      
        28
        
        -	for _, deck := range data {

      
        29
        
        -		fmt.Printf("\nDeck: %s\n", deck.Deck)

      
        30
        
        -		fmt.Printf("Type: %s\n", deck.Type)

      
        31
        
        -		fmt.Printf("Global Tags: %v\n", deck.Tags)

      
        32
        
        -		fmt.Println("Fields mapping:")

      
        33
        
        -		for internalName, anki := range deck.Fields {

      
        34
        
        -			fmt.Printf("  %s -> %s\n", internalName, anki)

      
        35
        
        -		}

      
        
        27
        +	lookup := "front"

      
        
        28
        +	ankiField := data[1].FieldLookUp(lookup)

      
        
        29
        +	slog.Info("looking up anki note field", "field", ankiField, "lookup", lookup)

      
        36
        30
         

      
        37
        
        -		fmt.Println("Notes:")

      
        38
        
        -		for _, note := range deck.Notes {

      
        39
        
        -			fmt.Println("  Note fields:")

      
        40
        
        -			for internalName, value := range note.Fields {

      
        41
        
        -				fmt.Printf("    %s: %s\n", internalName, value)

      
        42
        
        -			}

      
        43
        
        -			if len(note.Tags) > 0 {

      
        44
        
        -				fmt.Printf("    Local Tags: %v\n", note.Tags)

      
        45
        
        -			}

      
        46
        
        -		}

      
        47
        
        -	}

      
        
        31
        +	// for _, deck := range data {

      
        
        32
        +	// 	fmt.Printf("\nDeck: %s\n", deck.Deck)

      
        
        33
        +	// 	fmt.Printf("Type: %s\n", deck.Type)

      
        
        34
        +	// 	fmt.Printf("Global Tags: %v\n", deck.Tags)

      
        
        35
        +	// 	fmt.Println("Fields mapping:")

      
        
        36
        +	// 	for internalName, anki := range deck.Fields {

      
        
        37
        +	// 		fmt.Printf("  %s -> %s\n", internalName, anki)

      
        
        38
        +	// 	}

      
        
        39
        +	//

      
        
        40
        +	// 	fmt.Println("Notes:")

      
        
        41
        +	// 	for _, note := range deck.Notes {

      
        
        42
        +	// 		fmt.Println("  Note fields:")

      
        
        43
        +	// 		for internalName, value := range note.Fields {

      
        
        44
        +	// 			fmt.Printf("    %s: %s\n", internalName, value)

      
        
        45
        +	// 		}

      
        
        46
        +	// 		if len(note.Tags) > 0 {

      
        
        47
        +	// 			fmt.Printf("    Local Tags: %v\n", note.Tags)

      
        
        48
        +	// 		}

      
        
        49
        +	// 	}

      
        
        50
        +	// }

      
        48
        51
         }

      

···
        12
        12
         	Tags   []string          `yaml:"tags"`

      
        13
        13
         	Fields map[string]string `yaml:"fields"`

      
        14
        14
         	Notes  []Note            `yaml:"notes"`

      
        
        15
        +

      
        
        16
        +	// fieldLookUp internal reserve mapping of [Fields]

      
        
        17
        +	fieldLookUp map[string]string

      
        
        18
        +}

      
        
        19
        +

      
        
        20
        +func (d *DeckImport) FieldLookUp(field string) string {

      
        
        21
        +	// TODO: use ok notation here

      
        
        22
        +

      
        
        23
        +	val := d.fieldLookUp[field]

      
        
        24
        +	return val

      
        
        25
        +}

      
        
        26
        +

      
        
        27
        +func (d *DeckImport) Validate() error {

      
        
        28
        +	return nil

      
        
        29
        +}

      
        
        30
        +

      
        
        31
        +func (d *DeckImport) buildLookUpTable() {

      
        
        32
        +	d.fieldLookUp = make(map[string]string)

      
        
        33
        +	for k, v := range d.Fields {

      
        
        34
        +		d.fieldLookUp[k] = v

      
        
        35
        +	}

      
        15
        36
         }

      
        16
        37
         

      
        17
        38
         type Note struct {

      ···
        41
        62
         	return nil

      
        42
        63
         }

      
        43
        64
         

      
        44
        
        -func (d *DeckImport) Validate() error {

      
        45
        
        -	return nil

      
        46
        
        -}

      
        47
        
        -

      
        48
        65
         func Parse(inp []byte) ([]DeckImport, error) {

      
        49
        66
         	var listRes []DeckImport

      
        50
        67
         	if err := yaml.Unmarshal(inp, &listRes); err == nil {

      
        
        68
        +		for i := range listRes {

      
        
        69
        +			listRes[i].buildLookUpTable()

      
        
        70
        +		}

      
        51
        71
         		return listRes, nil

      
        52
        72
         	}

      
        53
        73
         

      
        54
        74
         	var single DeckImport

      
        55
        75
         	if err := yaml.Unmarshal(inp, &single); err == nil {

      
        
        76
        +		single.buildLookUpTable()

      
        56
        77
         		return []DeckImport{single}, nil

      
        57
        78
         	}

      
        58
        79