task.Task undefined (type entities.Task has no field or method Task)

package entities

type Task struct {
	Id       int64
	task     string
	assignee string
	deadline string
	action   string
}

package taskcontroller

import (
	"fmt"
	"html/template"
	"net/http"

	"github.com/jeypc/go-crud/config/entities"
)

func Index(response http.ResponseWriter, request *http.Request) {
	temp, err := template.ParseFiles("config/views/task/index.html")

	if err != nil {
		panic(err)
	}
	temp.Execute(response, nil)
}

func Add(response http.ResponseWriter, request *http.Request) {

	if request.Method == http.MethodGet {

		temp, err := template.ParseFiles("config/views/task/add.html")

		if err != nil {
			panic(err)
		}
		temp.Execute(response, nil)

	} else if request.Method == http.MethodPost {

		request.ParseForm()

		var task entities.Task

		task.Task = request.Form.Get("task")
		task.Assignee = request.Form.Get("assignee")
		task.Deadline = request.Form.Get("deadline")

		fmt.Println(task)

	}

}

OK, so this is probably going to get closed, as this is a simple typo, or just a case of RT(f)M. I'd recommend you walk through the golang tour. Exported names is something explained on page 3 of the basics, so pretty much at the start of the tour. If you haven't looked at the tour at all, the tour starts here

Still, I'll answer your question using your specific code:

In golang, capitalisation matters. In your case, you have a package called entities, in which you define the type Task, with a capital T. Because you're using a capital as the first character of the name, the type is exported. When you import the entities package in your taskcontroller package, you'll be able to use entities.Task. Had you written:

package entities
type task struct {}

you would not be able to write t := entities.task{}. To put it in conventional OOP terms: any name beginning with a lower-case character is private. If they start with an upper-case character, they are public.

Now looking at your type:

type Task struct {
Id       int64
task     string
assignee string
deadline string
action   string
}

You have a public type called Task, with 5 fields. One field (Id) is public, and can be accessed outside of the entities package. The other four fields are private, and can only be accessed from inside the entities package.

Now, you're trying to set fields like assignee, task, and so on in the taskcontroller package. You can't do that, because they are private. To be able to access these fields, the simplest way is to change the entities.Task type and make the fields public:

type Task struct {
Id       int64
Task     string
Assignee string
Deadline string
Action   string
}

Then, you'll be able to access all fields in other packages:

package taskcontroller
import "entities"
func someFunc() {
task := entities.Task{
Id:   123,
Task: "foo",
}
// or
task.Assignee = "bar"
}

Sometimes, though, you may want to limit/control access to fields like this, in which case you can use getters/setters. Again, the same rule applies WRT capitalisation:

package entities
// Task as you have it now, with unexported fields
type Task struct {
Id       int64
task     string
assignee string
deadline string
action   string
}
// SetAssignee starts with upper-case S, so can be called from other packages
// this method can be used for validation/normalisation/...
// you'll need to add SetX for each field
func (t *Task) SetAssignee(assignee string) error {
if len(assignee) > 255 {
return errors.New("assignee too long, max length is 255")
}
// assignee is not exported, but using this function its value can be set
t.assignee = assignee
return nil
}
// GetAssignee is exported, can be called everywhere
// again, you'll need to implement a GetX for each unexported field
// can be used to return default values, for example
func (t Task) GetAssignee() string {
if len(t.assignee) == 0 {
return "none"
}
return t.assignee
}
func (t *Task) ToMapAndClear() map[string]interface{} {
// create a map containing the data
r := map[string]interface{}{
"id":       t.Id,
"task":     t.task,
"assignee": t.assignee,
"deadline": t.deadline,
"action":   t.action,
}
// clear all fields. We can call reset from inside the package
t.reset()
return r
}
// ExtractMap same function as above, but with defer so it's less verbose
func (t *Task) ExtractMap() map[string]interface{} {
defer t.reset()
return map[string]interface{
"id":       t.Id,
"task":     t.task,
"assignee": t.assignee,
"deadline": t.deadline,
"action":   t.action,
}
}
// reset starts with lower-case s, so cannot be called outside of this package
func (t *Task) reset() {
*t = Task{}
}

With these methods, you can use the entities.Task type in other packages like so:

package main
import (
"fmt"
"entities"
)
func main() {
t := entities.Task{
Id: 123,
}
if err := t.SetAssignee("Benjamin"); err != nil {
fmt.Printf("Could not set assignee: %v\n", err)
return
}
fmt.Printf("Task assigned to %s\n", t.GetAssignee()) // works fine
// does not work
t.reset() // main package does not have access to reset method
// this does work - we get the values in a map, and reset gets called internally
data := t.ExtractMap()
}

As you can see, though I can't call reset directly outside of the main package, I can call exported methods that call reset internally.