contoh skrip code

package cronjobs

import (
    "fmt"
    "github.com/bwmarrin/discordgo"
    "github.com/go-zoox/fetch"
    "github.com/gopxl/beep"
    "github.com/gopxl/beep/mp3"
    "github.com/gopxl/beep/speaker"
    "github.com/lactobasilusprotectus/go-discord/internal/sporact"
    "github.com/lactobasilusprotectus/go-discord/internal/util/JsonParser"
    config2 "github.com/lactobasilusprotectus/go-discord/pkg/config"
    "log"
    "net/url"
    "os"
    "time"
)

var (
    //Mendefinisikan mapping antara ID tenant dengan nama mereka. Ini digunakan untuk mengidentifikasi tenant dalam notifikasi.
    mapTenatID = map[int]string{
        6:  "Kementerian Komunikasi dan Informatika",
        10: "Mandiri Investasi",
        5:  "Mandiri Sekuritas",
        17: "Pelindo",
        20: "PT Samuel Sekuritas Indonesia",
        21: "PT Bukit Asam",
        22: "ASDP Indonesia Ferry",
    }

    //ctx = context.Background()
)

// GetAlertSporact Struct yang digunakan untuk mengatur sesi Discord, informasi klien API untuk mengambil peringatan, dan beberapa konfigurasi lainnya.
type GetAlertSporact struct {
    Session      *discordgo.Session
    ChannelID    string
    Scheduler    string
    AccessToken  string
    RefreshToken string
    LastAccessID int
    Client       *sporact.Client
}

// Response Struct untuk menampung respons dari API peringatan, termasuk detail kasus seperti ID, judul, deskripsi, dan lainnya.
type Response struct {
    Id          int    `json:"id"`
    CaseID      string `json:"case_id"`
    Title       string `json:"title"`
    Description string `json:"description"`
    Status      string `json:"status"`
    Priority    string `json:"priority"`
    Impact      string `json:"impact"`
    Tenant      string `json:"tenant"`
}

// initJsonManager Menginisialisasi manajer JSON untuk membaca dan menulis konfigurasi.
func (job *GetAlertSporact) initJsonManager() *JsonParser.JSONManager {
    //get file config.json
    getwd, err := os.Getwd()

    if err != nil {
        return nil
    }

    return JsonParser.NewJSONManager(getwd + "/config.json")
}

// NewGetAlertSporact Membuat instance GetAlertSporact baru dengan menginisialisasi sesi Discord, ID channel, scheduler, token akses, dan klien API berdasarkan konfigurasi yang dibaca dari config.json.
func NewGetAlertSporact(session *discordgo.Session, channelID string, scheduler string) *GetAlertSporact {
    var config config2.Config

    //init json manager
    manager := new(GetAlertSporact).initJsonManager()

    //read config.json
    jsonConfig, err := manager.Read(config)
    if err != nil {
        log.Printf("line 67 error: %v", err)
        return nil
    }

    //return jsonConfig map[access_key: last_case_id:0 refresh_key:]
    mapConfig, ok := jsonConfig.(map[string]interface{})
    if !ok {
        log.Printf("line 74 error: %v", err)
        return nil
    }

    //get access key
    accessKeyValue, ok := mapConfig["access_key"].(string)
    if !ok {
        log.Printf("error: %v", err)
        return nil
    }

    //get refresh key
    refreshKeyValue, ok := mapConfig["refresh_key"].(string)
    if !ok {
        log.Printf("error: %v", err)
        return nil
    }

    //get last case id
    lastCaseIDValue, ok := mapConfig["last_case_id"].(float64)

    //set config
    config.AccessKey = accessKeyValue
    config.RefreshKey = refreshKeyValue
    config.LastCaseID = int(lastCaseIDValue)

    //new http sporact
    client := sporact.NewClient(config.AccessKey)

    //return GetAlertSporact
    return &GetAlertSporact{
        Session:      session,
        ChannelID:    channelID,
        Scheduler:    scheduler,
        AccessToken:  config.AccessKey,
        RefreshToken: config.RefreshKey,
        Client:       client,
        LastAccessID: config.LastCaseID,
    }
}

// Schedule mendefinisikan waktu berjalannya cron job
func (job *GetAlertSporact) Schedule() string {
    return job.Scheduler
}

// Task adalah fungsi yang akan dijalankan oleh cron job. Fungsi ini akan memproses data dari API peringatan, mengirim notifikasi ke Discord, dan memainkan alarm jika ada kasus baru yang masuk.
func (job *GetAlertSporact) Task() {
    data, err := job.ProcessData()

    if err != nil {
        log.Printf("line 119 error: %v", err)
        return
    }

    if data.Id == job.LastAccessID {
        log.Printf("cron job success")
        return
    }

    title := fmt.Sprintf("🚨 **Aktivitas Mencurigakan Terdeteksi** 🚨\n\n")
    title += fmt.Sprintf("Case ID: %s - %s\n", data.CaseID, data.Tenant)
    title += fmt.Sprintf("Workbench: %s\n", data.Title)

    if err != nil {
        log.Printf("line 141 error: %v", err)
        return
    }

    embeb := &discordgo.MessageEmbed{
        Title:       title,
        Description: fmt.Sprintf("Ini merupakan notifikasi untuk case baru yang masuk ke sporact"),
        Fields: []*discordgo.MessageEmbedField{

            {
                Name:   "Status",
                Value:  data.Status,
                Inline: false,
            },

            {
                Name:   "Prioritas",
                Value:  fmt.Sprintf("%s - %s", data.Priority, data.Impact),
                Inline: false,
            },

            {
                Name:  "Link",
                Value: fmt.Sprintf("https://sporact.mii.co.id/cases/%s", data.CaseID),
            },
        },
        Color: getColorByPriority(data.Impact),
    }

    _, err = job.Session.ChannelMessageSendComplex(job.ChannelID, &discordgo.MessageSend{
        Embed: embeb,
    })

    if err != nil {
        log.Printf("line 178 error: %v", err)
    }

    job.LastAccessID = data.Id

    //write config.json
    err = job.WriteJson(data)

    if err != nil {
        log.Printf(err.Error())
        return
    }

    log.Printf("cron job success")

    err = job.PlayAlarm()
    if err != nil {
        log.Printf("line 186 error: %v", err)
        return
    }

    return
}

// PlayAlarm memainkan alarm jika ada kasus baru yang masuk.
func (job *GetAlertSporact) PlayAlarm() (err error) {
    //get file config.json
    getwd, err := os.Getwd()

    if err != nil {
        return err
    }

    f, err := os.Open(getwd + "/etc/1.mp3")

    if err != nil {
        return err
    }

    streamer, format, err := mp3.Decode(f)

    if err != nil {
        return err
    }

    defer streamer.Close()

    speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10))

    done := make(chan bool)
    speaker.Play(beep.Seq(streamer, beep.Callback(func() {
        done <- true
    })))

    <-done

    return err
}

// ProcessData memproses data dari API Sporact.
func (job *GetAlertSporact) ProcessData() (Response, error) {
    res, err := job.GetAlertCaseApi()

    if err != nil {
        return Response{}, fmt.Errorf("error: %v", err)
    }

    mapData := res.Get("results.0")

    respStruct := Response{
        Id:          int(mapData.Get("id").Int()),
        CaseID:      mapData.Get("uid").String(),
        Title:       mapData.Get("title").String(),
        Description: mapData.Get("description").String(),
        Status:      mapData.Get("status_display").String(),
        Priority:    mapData.Get("priority.name").String(),
        Impact:      mapData.Get("impact_details.name").String(),
        Tenant:      mapTenatID[int(mapData.Get("tenant_id").Int())],
    }

    return respStruct, nil
}

// GetAlertCaseApi gets the alert case from Sporact MII API.
func (job *GetAlertSporact) GetAlertCaseApi() (*fetch.Response, error) {
    // Get current time and yesterday
    now := time.Now()
    yesterday := now.Add(-24 * time.Hour)

    // Formatting the times in the required format
    nowFormatted := now.Format("2006-01-02T15:04:05.000Z")
    yesterdayFormatted := yesterday.Format("2006-01-02T15:04:05.000Z")

    //construct url
    // Base URL
    baseURL := "/cases/case/"

    // Parameters
    params := url.Values{}
    params.Add("date[]", yesterdayFormatted)
    params.Add("date[]", nowFormatted)
    params.Add("range_type", "created___range")
    params.Add("status", "Open")
    params.Add("tenant", "6,10,5,17,20,21,22")
    params.Add("expand", "priority")

    // Constructing the URL
    fullURL := baseURL + "?" + params.Encode()

    res, err := job.Client.MakeGetRequest(fullURL)

    if err != nil {
        return nil, fmt.Errorf("error: %v", err)
    }

    if res.StatusCode() == 401 {
        err = job.refreshToken()
        if err != nil {
            return nil, fmt.Errorf("error: %v", err)
        }

        job.Client = sporact.NewClient(job.AccessToken)

        log.Printf("refresh token success")

        return job.GetAlertCaseApi()
    }

    if res.StatusCode() != 200 {
        return nil, fmt.Errorf("http status code: %d message: %s", res.StatusCode(), res.Get("message").String())
    }

    return res, nil
}

// refreshToken refreshes the access token if expired.
func (job *GetAlertSporact) refreshToken() error {
    body := map[string]interface{}{
        "refresh": job.RefreshToken,
    }

    resp, err := job.Client.MakePostRequest("/auth/token/refresh/", body)

    if err != nil {
        return fmt.Errorf("error: %v", err)
    }

    if resp.StatusCode() != 200 {
        return fmt.Errorf("http status code: %d message: %s", resp.StatusCode(), resp.Get("message").String())
    }

    //set new access token
    job.AccessToken = resp.Get("access").String()

    return nil
}

// WriteJson writes the response to the config.json file.
func (job *GetAlertSporact) WriteJson(response Response) error {
    jsonManager := job.initJsonManager()

    config := config2.Config{
        AccessKey:  job.AccessToken,
        RefreshKey: job.RefreshToken,
        LastCaseID: response.Id,
    }

    //write config.json
    return jsonManager.Write(config)
}

// getColorByPriority returns the color code based on the priority.
func getColorByPriority(priority string) int {
    switch priority {
    case "High":
        return 0xFF0000 // Merah
    case "Medium":
        return 0xFFFF00 // Kuning
    case "Low":
        return 0x00FF00 // Hijau
    default:
        return 0x808080 // Abu-abu untuk prioritas tidak dikenal
    }
}