routeros_dns/dns.go

package main

import (
	// Standard
	"fmt"
	"maps"
	"slices"
	"strings"
)

type DNSRecord struct {
	ID          string `json:".id"`
	Disabled    string
	Dynamic     string
	Name        string
	TTL         string
	Type        string
	ParsedValue string // not from RouterOS, here to not having to have the value logics in frontend too.

	Address string
	CNAME   string
}

type DomainPart struct {
	Record   []DNSRecord
	Subparts map[string]*DomainPart `json:",omitempty"`
}

type RecordsTree struct {
	Children []RecordsTree
}

func SortDNSRecord(a, b DNSRecord) int {
	aComponents := strings.Split(a.Name, ".")
	bComponents := strings.Split(b.Name, ".")

	slices.Reverse(aComponents)
	slices.Reverse(bComponents)

	for i, aComp := range aComponents {
		if i >= len(bComponents) {
			return -1
		}

		bComp := bComponents[i]
		if aComp > bComp {
			return 1
		}

		if aComp < bComp {
			return -1
		}

	}

	return 0
}

func (r DNSRecord) String() string {
	switch r.Type {
	case "A", "AAAA":
		return r.Address
	case "CNAME":
		return r.CNAME
	}

	return fmt.Sprintf("Implement type '%s'", r.Type)
}

func (r DNSRecord) Parts() int {
	return len(strings.Split(r.Name, "."))
}

func (r DNSRecord) Part(numParts int) string {
	splitName := strings.Split(r.Name, ".")
	slices.Reverse(splitName)

	parts := []string{}
	for i := range numParts {
		if i >= len(splitName) {
			break
		}
		parts = append(parts, splitName[i])
	}

	slices.Reverse(parts)
	return strings.Join(parts, ".")
}

func (r DNSRecord) NameReversed() string {
	parts := strings.Split(r.Name, ".")
	slices.Reverse(parts)
	return strings.Join(parts, ".")
}

func BuildRecordsTree(records []DNSRecord) *DomainPart {
	topPart := new(DomainPart)
	topPart.Subparts = make(map[string]*DomainPart)

	for _, record := range records {
		curPart := topPart

		currentDomainNameSplit := strings.Split(record.Name, ".")
		slices.Reverse(currentDomainNameSplit)

		for _, part := range currentDomainNameSplit {
			if nextDomainPart, found := curPart.Subparts[part]; !found {
				newPart := new(DomainPart)
				newPart.Record = []DNSRecord{record}
				newPart.Subparts = make(map[string]*DomainPart)
				curPart.Subparts[strings.ToLower(part)] = newPart
				curPart = newPart
			} else {
				nextDomainPart.Record = append(nextDomainPart.Record, record)
				curPart = nextDomainPart
			}
		}
	}

	return topPart
}

type HTMLElement struct {
	Header bool
	HTML   string
}

func (dp *DomainPart) ToHTMLElements(parts []string) []HTMLElement {
	var lines []HTMLElement

	sortedParts := slices.Sorted(maps.Keys(dp.Subparts))

	for _, part := range sortedParts {
		subpart := dp.Subparts[part]
		newParts := append(parts, part)

		reversedParts := make([]string, len(newParts))
		copy(reversedParts, newParts)
		slices.Reverse(reversedParts)
		fqdn := strings.Join(reversedParts, ".")

		mostSpecificPart := reversedParts[0]
		restPart := ""
		if len(reversedParts) > 1 {
			restPart = strings.Join(reversedParts[1:], ".")
			mostSpecificPart += "."
		}

		if len(subpart.Subparts) != 0 {
			topmost := ""
			if len(newParts) == 1 {
				topmost = "top-most"
			}
			html := fmt.Sprintf(`
				<div class="top %s" data-top="%s" data-self="%s" style="padding-left: %dpx">
					<img class="folder closed" src="/images/%s/icon_folder.svg">
					<img class="folder open"   src="/images/%s/icon_folder_open.svg">
					<span>%s</span><span>%s</span>
				</div>
				<div class="type"></div>
				<div class="value"></div>
				`,
				topmost,              // .top-most
				restPart,             // data-top
				fqdn,                 // data-self
				(len(newParts)-1)*32, // margin-left
				VERSION,              // images/
				VERSION,              // images/
				mostSpecificPart,     // innerText
				restPart,
			)
			lines = append(lines, HTMLElement{Header: true, HTML: html})
			subLines := subpart.ToHTMLElements(newParts)
			lines = append(lines, subLines...)
		}

	}

	for _, part := range sortedParts {
		subpart := dp.Subparts[part]
		newParts := append(parts, part)

		reversedParts := make([]string, len(newParts))
		copy(reversedParts, newParts)
		slices.Reverse(reversedParts)
		//fqdn := strings.Join(reversedParts, ".")

		mostSpecificPart := reversedParts[0]
		restPart := ""
		if len(reversedParts) > 1 {
			restPart = strings.Join(reversedParts[1:], ".")
			mostSpecificPart += "."
		}

		if len(subpart.Subparts) == 0 {
			for _, rec := range subpart.Record {
				html := fmt.Sprintf(
					`
						<div class="record" style="padding-left: %dpx" data-top="%s"><div><span>%s</span><span>%s</span></div></div>
						<div class="type"><div>%s</div></div>
						<div class="value">%s</div>
					`,
					(len(newParts)-1)*32,
					restPart, // data-top
					mostSpecificPart,
					restPart,
					rec.Type,
					rec.String(),
				)
				lines = append(lines, HTMLElement{Header: false, HTML: html})
			}
		}

	}

	return lines
}