isogen/MessageDefinition.go at master · fgrid/isogen · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package main

import (
	"fmt"
	"log"
	"os"
	"strings"
	"text/template"
)

type MessageDefinition struct {
	XMIId                       string                      `xml:"http://www.omg.org/XMI id,attr"`
	Definition                  string                      `xml:"definition,attr"`
	Name                        string                      `xml:"name,attr"`
	XMLTag                      string                      `xml:"xmlTag,attr"`
	MessageBuildingBlock        []*MessageElement           `xml:"messageBuildingBlock"`
	MessageDefinitionIdentifier MessageDefinitionIdentifier `xml:"messageDefinitionIdentifier"`
	BasePackagePath             string
	BasePackageName             string
}

const _Template = `package {{.MessageDefinitionIdentifier.BusinessArea}}

import (
	"encoding/xml"

	"{{.BasePackagePath}}"
)

type {{.DocumentType}} struct {
	XMLName xml.Name {{.DocumentName}}
	Message *{{.Name}} {{.XMLName}}
}

func (d *{{.DocumentType}}) AddMessage() *{{.Name}} {
	d.Message = new({{.Name}})
	return d.Message
}

// {{replace .Definition "\n" "\n// " -1}}
type {{.Name}} struct {
{{range .MessageBuildingBlock}}
	{{.DeclarationOut $.BasePackageName}}
{{end}}
}

{{range .MessageBuildingBlock}}{{.Access $.BasePackageName $.Name}}{{end}}
`

var _tmpl *template.Template

func init() {
	funcMap := template.FuncMap{
		"replace": strings.Replace,
	}
	var err error
	if _tmpl, err = template.New("complexType").Funcs(funcMap).Parse(_Template); err != nil {
		log.Fatalf("could not compile template - %s", err.Error())
	}
}

func (md *MessageDefinition) Analyse() {
	for _, mbb := range md.MessageBuildingBlock {
		mbb.Analyse()
	}
}

func (md *MessageDefinition) Generate(packageName string) {
	if md.Name == "RequestToModifyPaymentV03" {
		log.Printf("skipping amigous message definition %s", md.Name)
		return
	}
	md.BasePackagePath = packageName
	parts := strings.Split(packageName, "/")
	md.BasePackageName = parts[len(parts)-1]
	if err := os.MkdirAll(md.MessageDefinitionIdentifier.BusinessArea, 0770); err != nil {
		log.Printf("could not create subdirectory %s - %s",
			md.MessageDefinitionIdentifier.BusinessArea, err.Error())
		return
	}
	fileName := fmt.Sprintf("%s/%s.go",
		md.MessageDefinitionIdentifier.BusinessArea,
		md.Name,
	)
	f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0660)
	if err != nil {
		log.Fatalf("can not create file %s - %s", fileName, err.Error())
	}
	defer f.Close()
	_tmpl.Execute(f, md)
}

func (md *MessageDefinition) XMLName() string {
	return "`xml:\"" + md.XMLTag + "\"`"
}

func (md *MessageDefinition) DocumentType() string {
	return "Document" + md.MessageDefinitionIdentifier.MessageFunctionality + md.MessageDefinitionIdentifier.Flavour + md.MessageDefinitionIdentifier.Version
}

func (md *MessageDefinition) DocumentName() string {
	return "`xml:\"urn:iso:std:iso:20022:tech:xsd:" + md.MessageDefinitionIdentifier.String() + " Document\"`"
}