Skip to content

Latest commit

 

History

History
230 lines (157 loc) · 7.01 KB

README.md

File metadata and controls

230 lines (157 loc) · 7.01 KB
Raw

Toolkit Package

Version Built with GoLang License Go Report Card Tests Go Coverage

This toolkit package provides a set of utilities designed for the Go programming language to handle common tasks like generating random strings and handling file uploads in web applications.

Features

The included tools are:

  • Read JSON
  • Write JSON
  • Produce a JSON encoded error response
  • Write XML
  • Read XML
  • Produce XML encoded error response
  • Upload files via HTTP requests with optional renaming and file type validation.
  • Download a static file
  • Get a random string of length n
  • Post JSON to a remote service
  • Create a directory, including all parent directories, if it does not already exist
  • Create a URL-safe slug from a string

Installation

To install the package, use the following command:

go get github.com/rozdolsky33/toolkit

Usage

Importing the Package

Before using the package, import it in your Go project:

import "github.com/rozdolsky33/toolkit"

Initializing the Tools

Create an instance of the Tools type to access its methods:

tools := toolkit.Tools{
    MaxFileSize:      1024 * 1024 * 1024, // 1 GB
    AllowedFileTypes: []string{"image/jpeg", "image/png"},
}

Generating Random Strings

Use the RandomString method to generate a random string of specified length:

randomStr := tools.RandomString(16)
fmt.Println("Random String:", randomStr)

Uploading Files

Use the UploadFiles method to handle file uploads from HTTP requests. You can also specify whether to rename the uploaded files or not:

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    uploadDir := "./uploads"

    uploadedFiles, err := tools.UploadFiles(r, uploadDir, true)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    for _, file := range uploadedFiles {
        fmt.Fprintf(w, "Uploaded File: %s (original: %s), Size: %d bytes\n",
            file.NewFileName, file.OriginalFileName, file.FileSize)
    }
}

In your main function, set up the HTTP server to use this handler:

http.HandleFunc("/upload", uploadHandler)
http.ListenAndServe(":8080, nil)

Structs

Tools

The Tools struct is used to instantiate the toolkit. This struct holds configuration for file uploads and JSON operations.

  • MaxFileSize int: Maximum allowed file size for uploads (in bytes).
  • AllowedFileTypes []string: List of allowed file MIME types for validation.
  • MaxJSONSize int: Maximum allowed JSON size in bytes.
  • AllowUnknownFields bool: Flag to allow unknown JSON fields.

UploadedFile

The UploadedFile struct holds information about the uploaded files.

  • NewFileName string: The name of the file saved on the server.
  • OriginalFileName string: The original name of the uploaded file.
  • FileSize int64: The size of the uploaded file in bytes.

JSONResponse

The JSONResponse struct is used to format JSON responses.

  • Error bool: Indicates if the response is an error.
  • Message string: The message to be included in the response.
  • Data interface{}: Optional data payload.

Methods

RandomString

Generates a random string of specified length n.

func (t *Tools) RandomString(n int) string

UploadFiles

Handles file uploads from HTTP requests, validates file type and optionally renames files.

func (t *Tools) UploadFiles(r *http.Request, uploadDir string, rename ...bool) ([]*UploadedFile, error)
  • r *http.Request: The HTTP request object.
  • uploadDir string: Directory path where files will be uploaded.
  • rename ...bool: Optional boolean to specify whether to rename uploaded files.

CreateDirIfNotExist

Creates a directory if it does not exist.

func (t *Tools) CreateDirIfNotExist(dir string) error
  • dir string: The directory path.

Slugify

Transforms an input string into a URL-friendly slug.

func (t *Tools) Slugify(s string) (string, error)
  • s string: The input string to be slugified.

DownloadStaticFile

Downloads a file and tries to force the browser to avoid displaying it in the browser window by setting content disposition.

func (t *Tools) DownloadStaticFile(w http.ResponseWriter, r *http.Request, p, file, displayName string)
  • w http.ResponseWriter: The HTTP response writer.
  • r *http.Request: The HTTP request.
  • p string: The file path.
  • file string: The filename.
  • displayName string: The display name.

ReadJSON

Reads and decodes JSON from a request body.

func (t *Tools) ReadJSON(w http.ResponseWriter, r *http.Request, data interface{}) error
  • w http.ResponseWriter: The HTTP response writer.
  • r *http.Request: The HTTP request.
  • data interface{}: The target data structure.

WriteJSON

Encodes data as JSON and writes it to the response.

func (t *Tools) WriteJSON(w http.ResponseWriter, status int, data interface{}, headers ...http.Header) error
  • w http.ResponseWriter: The HTTP response writer.
  • status int: The HTTP status code.
  • data interface{}: The payload to be encoded as JSON.
  • headers ...http.Header: Optional headers.

ErrorJSON

Generates and sends a JSON error response.

func (t *Tools) ErrorJSON(w http.ResponseWriter, err error, status ...int) error
  • w http.ResponseWriter: The HTTP response writer.
  • err error: The error to be included in the response.
  • status ...int: Optional HTTP status code.

PushJSONToRemote

Sends the given data as a JSON payload to a specified URI via HTTP POST using an optional custom HTTP client.

func (t *Tools) PushJSONToRemote(uri string, data interface{}, client ...*http.Client) (*http.Response, int, error)
  • uri string: The target URI.
  • data interface{}: The data to be sent as JSON.
  • client ...*http.Client: Optional custom HTTP client.