cloudflare-manager/cloudflare_manager.go

package cloudflare_manager

import (
	"context"
	"log"
	"sync"

	dns "git.uoc.run.place/OxFF/dns-manager"

	cloudflare "github.com/cloudflare/cloudflare-go"
)

type Config struct {
	DOMAIN_NAME string
	API_TOKEN   string
	ZONE_ID     string
}

type client struct {
	Locker    sync.Mutex
	CF_Client *cloudflare.API
	Domain    string
	API_TOKEN string
	ZONE_ID   string
}

func (c *client) AddRecord(record *dns.Record) (error, *dns.Response) {
	proxied := false
	ctx := context.Background()

	cf_record := cloudflare.CreateDNSRecordParams{
		Type:      string(record.Type),
		Name:      record.Name,
		Content:   record.Content,
		TTL:       int(record.TTL),
		Proxiable: true,
		Proxied:   &proxied,
	}

	zone_id, err := c.CF_Client.ZoneIDByName(c.Domain)
	if err != nil {
		return err, nil
	}

	_, err = c.CF_Client.CreateDNSRecord(
		ctx,
		cloudflare.ZoneIdentifier(zone_id),
		cf_record,
	)

	if err != nil {
		return err, nil
	}

	return nil, &dns.Response{Message: "The entry was added successfully"}
}

func (c *client) UpdateRecord(record *dns.Record) (error, *dns.Response) {
	zone_id, err := c.CF_Client.ZoneIDByName(c.Domain)
	ctx := context.Background()
	var record_id string

	if err != nil {
		return err, nil
	}

	all_recs, _, err := c.CF_Client.ListDNSRecords(ctx, cloudflare.ZoneIdentifier(zone_id), cloudflare.ListDNSRecordsParams{})
	if err != nil {
		return err, nil
	}

	for _, rec := range *&all_recs {
		if rec.Name == record.Name {
			record_id = rec.ID
		}
	}

	updated_record := cloudflare.UpdateDNSRecordParams{
		Type:    string(record.Type),
		Content: record.Content,
		Name:    record.Name,
		TTL:     int(record.TTL),
		ID:      record_id,
	}

	_, err = c.CF_Client.UpdateDNSRecord(ctx, cloudflare.ZoneIdentifier(zone_id), updated_record)
	if err != nil {
		return err, nil
	}

	return nil, &dns.Response{Message: "Record was successfully updated"}
}

func (c *client) DeleteRecord(record *dns.Record) (error, *dns.Response) {
	zone_id, err := c.CF_Client.ZoneIDByName(c.Domain)
	ctx := context.Background()
	var domain_id string

	if err != nil {
		return err, nil
	}

	all_recs, _, err := c.CF_Client.ListDNSRecords(ctx, cloudflare.ZoneIdentifier(zone_id), cloudflare.ListDNSRecordsParams{})
	if err != nil {
		return err, nil
	}

	for _, rec := range *&all_recs {
		if rec.Name == record.Name {
			domain_id = rec.ID
		}
	}

	err = c.CF_Client.DeleteDNSRecord(ctx, cloudflare.ZoneIdentifier(zone_id), domain_id)
	if err != nil {
		return err, nil
	}

	return nil, &dns.Response{Message: "Record was deleted successfully"}
}

func (c *client) GetRecords() (error, *[]dns.Record) {
	var records []dns.Record

	ctx := context.Background()
	zone_id, err := c.CF_Client.ZoneIDByName(c.Domain)
	if err != nil {
		return err, nil
	}

	domains, _, err := c.CF_Client.ListDNSRecords(ctx, cloudflare.ZoneIdentifier(zone_id), cloudflare.ListDNSRecordsParams{})
	if err != nil {
		return err, nil
	}

	for _, domain := range domains {
		records = append(records, dns.Record{
			Name:    domain.Name,
			Content: domain.Content,
			TTL:     uint(domain.TTL),
			Type:    dns.RecordType(domain.Type),
		})
	}

	return nil, &records
}

func (conf Config) New() dns.Actions {
	api, err := cloudflare.NewWithAPIToken(conf.API_TOKEN)
	if err != nil {
		log.Fatal(err)
	}

	return &client{
		Locker:    sync.Mutex{},
		API_TOKEN: conf.API_TOKEN,
		CF_Client: api,
		ZONE_ID:   conf.ZONE_ID,
		Domain:    conf.DOMAIN_NAME,
	}
}