diff --git a/base/000hexya.go b/base/000hexya.go
index f3266ed..60a1da1 100644
--- a/base/000hexya.go
+++ b/base/000hexya.go
@@ -35,7 +35,10 @@ func init() {
 		Name: MODULE_NAME,
 		PostInit: func() {
 			err := models.ExecuteInNewEnvironment(security.SuperUserID, func(env models.Environment) {
+				threadsChanMap = make(map[string]chan bool)
 				h.Group().NewSet(env).ReloadGroups()
+				h.Worker().NewSet(env).LoadWorkers()
+				h.Cron().NewSet(env).StartScheduler()
 			})
 			if err != nil {
 				log.Panic("Error while initializing", "error", err)
diff --git a/base/cron.go b/base/cron.go
new file mode 100644
index 0000000..d35cbd9
--- /dev/null
+++ b/base/cron.go
@@ -0,0 +1,417 @@
+package base
+
+import (
+	"fmt"
+
+	"github.com/hexya-erp/hexya/hexya/models"
+
+	"time"
+
+	"encoding/json"
+
+	"strings"
+
+	"strconv"
+
+	"sort"
+
+	"github.com/hexya-erp/hexya/hexya/models/security"
+	"github.com/hexya-erp/hexya/hexya/models/types"
+	"github.com/hexya-erp/hexya/hexya/models/types/dates"
+	"github.com/hexya-erp/hexya/pool/h"
+	"github.com/hexya-erp/hexya/pool/q"
+)
+
+var schedulerUpdateChan chan bool
+
+func init() {
+	h.Cron().DeclareModel()
+	h.Cron().AddFields(map[string]models.FieldDefinition{
+		"Name": models.CharField{
+			String:     "Cron",
+			Unique:     true,
+			Required:   true,
+			Default:    models.DefaultValue("Scheduled Func"),
+			Constraint: h.Cron().Methods().ConstraintCronCreation()},
+		"ModelMethodStr": models.CharField{
+			String:  "Method",
+			Compute: h.Cron().Methods().ComputeModelMethodStr()},
+		"Status": models.BooleanField{
+			Default: models.DefaultValue(true)},
+		"ExecuteCount": models.IntegerField{
+			ReadOnly: true},
+		"ExecuteNET": models.CharField{
+			Compute:  h.Cron().Methods().ComputeExecuteNET(),
+			ReadOnly: true},
+		/* ---------------------------------------------------------------------------------------------------------- */
+		"TargetWorker": models.Many2OneField{
+			Required:      true,
+			RelationModel: h.Worker()},
+		"TargetModel": models.CharField{
+			String:   "Model",
+			Required: true},
+		"TargetMethod": models.CharField{
+			String:   "Method",
+			Required: true},
+		"TargetParams": models.TextField{
+			String:  "Parameters",
+			Default: models.DefaultValue("[]")},
+		/* ---------------------------------------------------------------------------------------------------------- */
+		"TimeAtDate": models.DateTimeField{
+			Default: models.DefaultValue(dates.Now())},
+		"Catchup": models.BooleanField{},
+		/* ---------------------------------------------------------------------------------------------------------- */
+		"RepeatBool": models.BooleanField{},
+		"RepeatLapseAmmount": models.IntegerField{
+			Default: models.DefaultValue(2)},
+		"RepeatLapseSelection": models.SelectionField{
+			Selection: types.Selection{
+				`month`:  `Months`,
+				`day`:    `Days`,
+				`hour`:   `Hours`,
+				`minute`: `Minutes`,
+				`second`: `Seconds`,
+			},
+			Default:  models.DefaultValue("minute"),
+			Required: true},
+		"RepeatAmmountBool": models.BooleanField{},
+		"RepeatAmmount": models.IntegerField{
+			Default: models.DefaultValue(5)},
+		/* ---------------------------------------------------------------------------------------------------------- */
+		"MaskBool": models.BooleanField{},
+		"Mask": models.Many2OneField{
+			RelationModel: h.CronTimeMask(),
+		},
+	})
+
+	h.Cron().Methods().ConstraintCronCreation().DeclareMethod(
+		`ConstrantCronCreation verifies Cron's field to be valid`,
+		func(rs h.CronSet) {
+			var out string
+			if h.Worker().NewSet(rs.Env()).GetWorker(rs.TargetWorker().Name()).Len() == 0 {
+				out += fmt.Sprintf("No Worker found with name '%s'\n", rs.TargetWorker())
+			}
+			model, ok := models.Registry.Get(rs.TargetModel())
+			if !ok {
+				out += fmt.Sprintf("No Model found with name '%s'\n", rs.TargetModel())
+			} else if _, ok := model.Methods().Get(rs.TargetMethod()); !ok {
+				out += fmt.Sprintf("No Method found in '%s' as '%s'\n", rs.TargetModel(), rs.TargetMethod())
+			}
+			var js interface{}
+			if err := json.Unmarshal([]byte(rs.TargetParams()), &js); err != nil {
+				out += fmt.Sprintf("Parameters could not be Unmarshalled: %v\n", err)
+			}
+			if rs.RepeatBool() {
+				if rs.RepeatLapseAmmount() < 0 {
+					out += fmt.Sprintln("Lapse ammount can't be negative")
+				}
+				if rs.RepeatAmmount() < 0 {
+					out += fmt.Sprintln("Repeat ammount can't be negative")
+				}
+			}
+			if out != "" {
+				panic(out)
+			}
+		})
+
+	h.Cron().Methods().ComputeModelMethodStr().DeclareMethod(
+		`ComputeModelMethodStr returns a string with format "<Model> - <Method>". Mainly Used in Cron views`,
+		func(rs h.CronSet) h.CronData {
+			return h.CronData{ModelMethodStr: fmt.Sprintf("%s - %s", rs.TargetModel(), rs.TargetMethod())}
+		})
+
+	h.Cron().Methods().ComputeExecuteNET().DeclareMethod(
+		`ComputeExecuteNET calculates when the Cron will be called next and
+				returns a CronData with its ExecuteNET filled with result string`,
+		func(rs h.CronSet) h.CronData {
+			etaDateTime := rs.TimeAtDate().Sub(dates.Now())
+			if etaDateTime.Seconds() == 0 {
+				return h.CronData{ExecuteNET: "ASAP"}
+			}
+			days := etaDateTime / (24 * time.Hour)
+			etaDateTime = etaDateTime % (24 * time.Hour)
+			hours := etaDateTime / time.Hour
+			etaDateTime = etaDateTime % time.Hour
+			minutes := etaDateTime / time.Minute
+			etaDateTime = etaDateTime % time.Minute
+			seconds := etaDateTime / time.Second
+			o := []rune(fmt.Sprintf("%dd %dh %dm %ds", days, hours, minutes, seconds))
+			var out []rune
+			var switc bool
+			for _, c := range o {
+				if c >= '1' && c <= '9' {
+					switc = true
+				}
+				if switc {
+					out = append(out, c)
+				} else {
+					out = append(out, ' ')
+				}
+			}
+			outStr := strings.TrimSpace(string(out))
+			if outStr == "" || strings.Contains(outStr, "-") {
+				outStr = "Now"
+			}
+			return h.CronData{ExecuteNET: string(outStr)}
+		})
+
+	h.Cron().Methods().ButtonResume().DeclareMethod(
+		`ButtonResume sets rs status as active and syncronize`,
+		func(rs h.CronSet) {
+			rs.SetStatus(true)
+			rs.ButtonRefresh()
+		})
+
+	h.Cron().Methods().ButtonSuspend().DeclareMethod(
+		`ButtonSuspend sets rs status as inactive and syncronize`,
+		func(rs h.CronSet) {
+			rs.SetStatus(false)
+			rs.ButtonRefresh()
+		})
+
+	h.Cron().Methods().ButtonRun().DeclareMethod(
+		`ButtonRun pushes the pointed job it's worker's queue`,
+		func(rs h.CronSet) {
+			var param interface{}
+			json.Unmarshal([]byte(rs.TargetParams()), &param)
+			params := interfaceSlice(param)
+			h.Worker().NewSet(rs.Env()).WithWorker(rs.TargetWorker().Name()).WithParams(params...).Enqueue(models.Registry.MustGet(rs.TargetModel()).Methods().MustGet(rs.TargetMethod()))
+		})
+
+	h.Cron().Methods().ButtonRefresh().DeclareMethod(
+		`ButtonRefresh syncronizes the cron`,
+		func(rs h.CronSet) {
+			go func() {
+				time.Sleep(50 * time.Millisecond)
+				schedulerUpdateChan <- true
+			}()
+		})
+
+	h.Cron().Methods().Create().Extend(
+		`Create creates a new Cron entry`,
+		func(rs h.CronSet, data *h.CronData, namer ...models.FieldNamer) h.CronSet {
+			out := rs.Super().Create(data, namer...)
+			rs.ButtonRefresh()
+			return out
+		})
+
+	h.Cron().Methods().StartScheduler().DeclareMethod(
+		`StartScheduler starts the Cron. Meant to be used once after server init`,
+		func(rs h.CronSet) {
+			if h.Cron().Search(rs.Env(), q.Cron().Name().Equals("Removal of old finished Jobs")).IsEmpty() {
+				h.Cron().Create(rs.Env(), &h.CronData{
+					Name:                 "Removal of old finished Jobs",
+					TargetWorker:         h.Worker().NewSet(rs.Env()).GetWorker("Main"),
+					TargetModel:          "Worker",
+					TargetMethod:         "CleanJobHistory",
+					TargetParams:         "[]",
+					TimeAtDate:           dates.ParseDateTime("2000-01-01 00:00:00"),
+					RepeatBool:           true,
+					RepeatLapseAmmount:   1,
+					RepeatLapseSelection: "day",
+				})
+			}
+			go rs.SchedulerLoop(15 * time.Minute)
+			time.Sleep(50 * time.Millisecond)
+			schedulerUpdateChan <- true
+		})
+
+	h.Cron().Methods().SchedulerLoop().DeclareMethod(
+		`SchedulerLoop starts the cron main loop. Shouldn't be directly called. Use StartScheduler instead'`,
+		func(rs h.CronSet, next time.Duration) {
+			def := next
+			schedulerUpdateChan = make(chan bool)
+			for {
+				select {
+				case <-time.After(next):
+					next = h.Cron().NewSet(rs.Env()).Sync()
+				case <-schedulerUpdateChan:
+					next = h.Cron().NewSet(rs.Env()).Sync()
+				case <-time.After(def):
+					next = h.Cron().NewSet(rs.Env()).Sync()
+				}
+			}
+		})
+
+	h.Cron().Methods().CheckTimeMask().DeclareMethod(
+		`CheckTimeMask returns true if the given cron entry's next call follows the entry's time mask`,
+		func(rs h.CronSet, data h.CronData) bool {
+			if data.MaskBool {
+				if data.Mask.MonthBool() {
+					curMonth := string([]byte(data.TimeAtDate.Month().String()))[:3]
+					if !data.Mask.Get(curMonth).(bool) {
+						return false
+					}
+				}
+				if data.Mask.WeekDayBool() {
+					curWD := string([]byte(data.TimeAtDate.Weekday().String()))[:3]
+					if !data.Mask.Get(curWD).(bool) {
+						return false
+					}
+				}
+				if data.Mask.DayBool() {
+					str := "," + data.Mask.DayStr() + ","
+					if !strings.Contains(str, ","+strconv.Itoa(data.TimeAtDate.Day())+",") {
+						return false
+					}
+				}
+				if data.Mask.HourBool() {
+					str := "," + data.Mask.HourStr() + ","
+					if !strings.Contains(str, ","+strconv.Itoa(data.TimeAtDate.Hour())+",") {
+						return false
+					}
+				}
+				if data.Mask.MinuteBool() {
+					str := "," + data.Mask.MinuteStr() + ","
+					if !strings.Contains(str, ","+strconv.Itoa(data.TimeAtDate.Minute())+",") {
+						return false
+					}
+				}
+			}
+			return true
+		})
+
+	h.Cron().Methods().Sync().DeclareMethod(
+		`Sync launches all entries running late and calculates the next sync call time`,
+		func(rs h.CronSet) time.Duration {
+			out := float64(15 * 60)
+			models.ExecuteInNewEnvironment(security.SuperUserID, func(env models.Environment) {
+				for _, rec := range h.Cron().Search(env, q.Cron().Status().Equals(true)).Records() {
+					data := rec.First()
+					funcExecuted := false
+					for (data.TimeAtDate.LowerEqual(dates.Now().Add(time.Second)) || !rs.CheckTimeMask(data)) && data.Status {
+						if !funcExecuted && rs.CheckTimeMask(data) {
+							var param interface{}
+							json.Unmarshal([]byte(data.TargetParams), &param)
+							params := interfaceSlice(param)
+							h.Worker().NewSet(env).WithWorker(data.TargetWorker.Name()).WithParams(params...).Enqueue(models.Registry.MustGet(data.TargetModel).Methods().MustGet(data.TargetMethod))
+							if !data.RepeatBool {
+								data.Status = false
+							}
+							if !data.Catchup {
+								funcExecuted = true
+							}
+							data.ExecuteCount += 1
+							if data.RepeatAmmountBool {
+								data.RepeatAmmount -= 1
+								if data.RepeatAmmount == 0 {
+									data.Status = false
+								}
+							}
+						}
+						switch data.RepeatLapseSelection {
+						case `month`:
+							data.TimeAtDate = data.TimeAtDate.AddDate(0, int(data.RepeatLapseAmmount), 0)
+						case `day`:
+							data.TimeAtDate = data.TimeAtDate.AddDate(0, 0, int(data.RepeatLapseAmmount))
+						case `hour`:
+							data.TimeAtDate = data.TimeAtDate.Add(time.Duration(data.RepeatLapseAmmount) * time.Hour)
+						case `minute`:
+							data.TimeAtDate = data.TimeAtDate.Add(time.Duration(data.RepeatLapseAmmount) * time.Minute)
+						case `second`:
+							data.TimeAtDate = data.TimeAtDate.Add(time.Duration(data.RepeatLapseAmmount) * time.Second)
+						}
+					}
+					lapse := data.TimeAtDate.Sub(dates.Now()).Seconds()
+					if lapse < out {
+						out = lapse
+					}
+					rec.Write(&h.CronData{
+						TimeAtDate:    data.TimeAtDate,
+						ExecuteCount:  data.ExecuteCount,
+						RepeatAmmount: data.RepeatAmmount,
+						Status:        data.Status},
+						h.Cron().Status())
+				}
+			})
+			return time.Duration(out) * time.Second
+		})
+
+	h.CronTimeMask().DeclareModel()
+
+	h.CronTimeMask().AddFields(map[string]models.FieldDefinition{
+		"Name": models.CharField{
+			Required: true,
+			Unique:   true},
+		"MonthBool":   models.BooleanField{},
+		"Jan":         models.BooleanField{},
+		"Feb":         models.BooleanField{},
+		"Mar":         models.BooleanField{},
+		"Apr":         models.BooleanField{},
+		"May":         models.BooleanField{},
+		"Jun":         models.BooleanField{},
+		"Jul":         models.BooleanField{},
+		"Aug":         models.BooleanField{},
+		"Sep":         models.BooleanField{},
+		"Oct":         models.BooleanField{},
+		"Nov":         models.BooleanField{},
+		"Dec":         models.BooleanField{},
+		"WeekDayBool": models.BooleanField{},
+		"Mon":         models.BooleanField{},
+		"Tue":         models.BooleanField{},
+		"Wed":         models.BooleanField{},
+		"Thu":         models.BooleanField{},
+		"Fri":         models.BooleanField{},
+		"Sat":         models.BooleanField{},
+		"Sun":         models.BooleanField{},
+		"DayBool":     models.BooleanField{},
+		"DayStr":      models.CharField{},
+		"HourBool":    models.BooleanField{},
+		"HourStr":     models.CharField{},
+		"MinuteBool":  models.BooleanField{},
+		"MinuteStr":   models.CharField{},
+	})
+
+	h.CronTimeMask().Methods().Create().Extend(
+		`Create creates a new CronTimeMask`,
+		func(rs h.CronTimeMaskSet, data *h.CronTimeMaskData, namer ...models.FieldNamer) h.CronTimeMaskSet {
+			data.DayStr = rs.CompileNbStr(data.DayStr, 1, 31)
+			data.HourStr = rs.CompileNbStr(data.HourStr, 0, 23)
+			data.MinuteStr = rs.CompileNbStr(data.MinuteStr, 0, 59)
+			out := rs.Super().Create(data, namer...)
+			return out
+		})
+
+	h.CronTimeMask().Methods().CompileNbStr().DeclareMethod(
+		`CompuleNbStr transforms the given NbStr to a generic readable one. errors poorly handled`,
+		func(rs h.CronTimeMaskSet, str string, min, max int) string {
+			spl := strings.Split(str, ",")
+			intSl := []int{}
+			for _, s := range spl {
+				s = strings.TrimSpace(s)
+				if strings.ContainsRune(s, '-') {
+					sp := strings.Split(s, "-")
+					int1, err1 := strconv.Atoi(sp[0])
+					int2, err2 := strconv.Atoi(sp[1])
+					if err1 != nil || err2 != nil {
+						continue
+					}
+					if int2 < int1 {
+						int2 = int2 + max + 1
+					}
+					for ; int1 <= int2; int1++ {
+						if int1 > min {
+							intSl = append(intSl, int1%(max+1))
+						}
+					}
+				} else {
+					i, err := strconv.Atoi(s)
+					if err == nil && i > min {
+						intSl = append(intSl, i%(max+1))
+					}
+				}
+			}
+			sort.Ints(intSl)
+			var out []byte
+			for i, n := range intSl {
+				if n >= min {
+					if i != 0 {
+						out = append(out, ',')
+					}
+					out = append(out, []byte(strconv.Itoa(n))...)
+				}
+			}
+			return string(out)
+		})
+
+}
diff --git a/base/model_mixin.go b/base/model_mixin.go
index aee150c..ad11dd1 100644
--- a/base/model_mixin.go
+++ b/base/model_mixin.go
@@ -4,6 +4,8 @@
 package base
 
 import (
+	"encoding/json"
+
 	"github.com/hexya-erp/hexya/hexya/models"
 	"github.com/hexya-erp/hexya/pool/h"
 	"github.com/hexya-erp/hexya/pool/q"
@@ -51,4 +53,37 @@ func init() {
 			}
 			return rs.Search(activeCond)
 		})
+
+	h.CommonMixin().Methods().WithWorker().DeclareMethod(
+		`WithWorker sets the JobsArgs' Worker to a worker corresponding to the given name. ('Main' by default)`,
+		func(rs h.CommonMixinSet, workerName string) h.JobArgsSet {
+			out := h.JobArgs().NewSet(rs.Env()).Create(&h.JobArgsData{})
+			out.SetModelName(rs.Collection().ModelName())
+			out.SetWorkerName(workerName)
+			return out
+		})
+
+	h.CommonMixin().Methods().WithParams().DeclareMethod(
+		`WithParams gives the current JobArg some parameters. (no parameters by default)`,
+		func(rs h.CommonMixinSet, params ...interface{}) h.JobArgsSet {
+			out := h.JobArgs().NewSet(rs.Env()).Create(&h.JobArgsData{})
+			out.SetModelName(rs.Collection().ModelName())
+			json, _ := json.Marshal(params)
+			out.SetParams(string(json))
+			return out
+		})
+
+	h.CommonMixin().Methods().Enqueue().DeclareMethod(
+		`Enqueue creates and pushes to queue the given JobArg created using WithParams and WithWorker or a default one`,
+		func(rs h.CommonMixinSet, method models.Methoder) {
+			out := h.JobArgs().NewSet(rs.Env()).Create(&h.JobArgsData{})
+			out.SetModelName(rs.Collection().ModelName())
+			out.Enqueue(method)
+		})
+
+	h.CommonMixin().Methods().PollCancel().DeclareMethod(
+		`PollCancel panics if rs was called to be canceled. Meant to be used in methods called by a Worker`,
+		func(rs h.CommonMixinSet) {
+			h.Worker().NewSet(rs.Env()).PollCancel()
+		})
 }
diff --git a/base/resources/cron.xml b/base/resources/cron.xml
new file mode 100644
index 0000000..85ab8c6
--- /dev/null
+++ b/base/resources/cron.xml
@@ -0,0 +1,351 @@
+<?xml version="1.0" encoding="utf-8"?>
+<hexya>
+    <data>
+        <view id="base_view_cron_tree" model="Cron">
+            <tree string="Workers">
+                <field name="Name"/>
+                <field name="ModelMethodStr"/>
+                <field name="ExecuteNET"/>
+                <field name="Status" invisible="1"/>
+                <button name="ButtonRefresh" string="Syncronize crons" type="object" icon="fa-refresh"/>
+                <button name="ButtonRun" string="Manual Run" type="object" icon="fa-share"/>
+                <button name="ButtonSuspend" string="Suspend" type="object" icon="fa-pause text-danger" attrs="{'invisible': [('status', '=', False)]}"/>
+                <button name="ButtonResume" string="Resume" type="object" icon="fa-eject fa-rotate-90 text-success" attrs="{'invisible': [('status', '=', True)]}"/>
+            </tree>
+        </view>
+
+        <view id="base_view_cron_form" model="Cron" delete="false">
+            <form string="Crons">
+                <sheet>
+                    <h1>
+                        <field name="Name" class="oe_inline"/>
+                    </h1>
+                    <group>
+                        <group>
+                            <field name="TargetWorker"/>
+                            <field name="TargetModel"/>
+                            <field name="TargetMethod"/>
+                            <field name="TargetParams"/>
+                        </group>
+                        <group>
+                            <field name="ExecuteNET"/>
+                            <field name="ExecuteCount"/>
+                        </group>
+                    </group>
+                    <group>
+                        <div style="display:flex;">
+                            <div style="width: 25%;  float:left">
+                                <div style="width:10%; float:left">
+                                    <label string="At"/>
+                                </div>
+                                <div style="width:60%; float:left">
+                                    <field nolabel="1" name="TimeAtDate"/>
+                                </div>
+                            </div>
+                            <div style="width: 25%; float:left">
+                                <div style="float: left;margin-left: 40px">
+                                    <field name="RepeatBool"/>
+                                    <label string="Repeat"/>
+                                </div>
+                                <div style="float: left; margin-left: 10px; width; 200px" attrs="{'invisible': [('repeat_bool', '=', False)]}">
+                                    <div>
+                                        <label string="Every"/>
+                                        <field name="RepeatLapseAmmount" style="width:30px"/>
+                                        <field name="RepeatLapseSelection" style="width:53%"/>
+                                    </div>
+                                    <div>
+                                        <field name="RepeatAmmountBool"/>
+                                        <label string="Only"/>
+                                        <field name="RepeatAmmount" style="width:30px"/>
+                                        <label string="Times"/>
+                                    </div>
+                                </div>
+                            </div>
+                            <div style="width: 25%; float:left">
+                                <div style="float: left;">
+                                    <field name="Catchup"/>
+                                    <label string="Catch-up"/>
+                                </div>
+                            </div>
+                            <div style="width: 25%; float:left">
+                                <div style="margin-left: 10px; width: 100%">
+                                    <label string="With Mask"/>
+                                    <field name="MaskBool"/>
+                                </div>
+                                <div style=" margin-left: 10px; width: 100%">
+                                    <field name="Mask" attrs="{'invisible': [('mask_bool', '=', False)]}"/>
+                                </div>
+                            </div>
+                        </div>
+                    </group>
+                </sheet>
+            </form>
+        </view>
+
+<!--
+<notebook colspan="4">
+<page string="Schedule" autofocus="autofocus">
+    <div style="width:700px">
+        <div style="width:260px">
+            <div style="width:60px;float: left;padding:20px">
+                <label string="At"/>
+            </div>
+            <div style="width:170px; float: left">
+                <div style="padding: 20px">
+                    <field nolabel="1" name="TimeAtDate"/>
+                </div>
+            </div>
+        </div>
+        <div>
+            <div style="float: left;margin-left: 40px;margin-top:20px">
+                <field name="RepeatBool"/>
+                <label string="Repeat"/>
+            </div>
+            <div style="float: left;margin-top: 18px; margin-left: 10px; width; 200px" attrs="{'invisible': [('repeat_bool', '=', False)]}">
+                <div>
+                    <label string="Every"/>
+                    <field name="RepeatLapseAmmount" style="width:30px"/>
+                    <field name="RepeatLapseSelection" style="width:53%"/>
+                </div>
+                <div>
+                    <field name="RepeatAmmountBool"/>
+                    <label string="Only"/>
+                    <field name="RepeatAmmount" style="width:30px"/>
+                    <label string="Times"/>
+                </div>
+            </div>
+        </div>
+        <div>
+            <div style="float: left;padding:20px">
+                <field name="Catchup"/>
+                <label string="Catch-up"/>
+            </div>
+        </div>
+    </div>
+</page>
+<page string="Time Masks">
+    <div style="margin-top: 18px; margin-left: 10px; width: 100%">
+        <label string="With Mask"/>
+        <field name="MaskBool"/>
+    </div>
+    <div style=" margin-left: 10px; width: 100%">
+        <field name="Masks" attrs="{'invisible': [('mask_bool', '=', False)]}"/>
+    </div>
+</page>
+</notebook>
+        </sheet>
+        </form>
+        </view>-->
+
+        <view id="base_view_cron_time_mask_form" model="CronTimeMask">
+            <form string="TimeMaskCreation">
+                <h1>
+                    <field name="Name" class="oe_inline"/>
+                </h1>
+                <div style="margin-bottom: 18px; margin-top: 18px; width:100%; float: left">
+                    ≡
+                    <field name="MonthBool"/>
+                    <label string="Month"/>
+                </div>
+                <div style="magin-left: 18px;margin-top: 18px; margin-bottom: 18px; width: 100%" attrs="{'invisible': [('month_bool', '=', False)]}">
+                    <div style="margin-top: 9px; width: 100%">
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="January"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Jan"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="Febuary"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Feb"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="March"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Mar"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="April"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Apr"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="May"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="May"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="June"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Jun"/>
+                            </div>
+                        </div>
+                    </div>
+                    <div style="margin-top: 9px; width: 100%">
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="July"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Jul"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="August"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Aug"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="September"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Sep"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="October"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Oct"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="November"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Nov"/>
+                            </div>
+                        </div>
+                        <div style=" width: 16%; float: left">
+                            <div style="width:100%">
+                                <label string="December"/>
+                            </div>
+                            <div style="width:100%">
+                                <field name="Dec"/>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div style="margin-bottom: 18px; margin-top: 18px; width:100%; float: left">
+                    ≡
+                    <field name="WeekDayBool"/>
+                    <label string="Week Day"/>
+                </div>
+                <div style="magin-left: 18px margin-top: 18px; margin-bottom: 18px; width: 100%" attrs="{'invisible': [('week_day_bool', '=', False)]}">
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Monday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="Mon"/>
+                        </div>
+                    </div>
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Tuesday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="Tue"/>
+                        </div>
+                    </div>
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Wednesday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="Wed"/>
+                        </div>
+                    </div>
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Thursday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="Thu"/>
+                        </div>
+                    </div>
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Friday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="fri"/>
+                        </div>
+                    </div>
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Saturday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="Sat"/>
+                        </div>
+                    </div>
+                    <div style=" width: 14%; float: left">
+                        <div style="width:100%">
+                            <label string="Sunday"/>
+                        </div>
+                        <div style="width:100%">
+                            <field name="Sun"/>
+                        </div>
+                    </div>
+                </div>
+                <div style="margin-bottom: 18px; margin-top: 18px; width:100%; float: left">
+                    ≡
+                    <field name="DayBool"/>
+                    <label string="Day"/>
+                </div>
+                <div style="margin-bottom: 18px;margin-top: 18px; width: 100%" attrs="{'invisible': [('day_bool', '=', False)]}">
+                    <label string="Day Number list"/>
+                    <field name="DayStr"/>
+                </div>
+                <div style="margin-bottom: 18px; margin-top: 18px; width:100%; float: left">
+                    ≡
+                    <field name="HourBool"/>
+                    <label string="Hour"/>
+                </div>
+                <div style="margin-bottom: 18px;margin-top: 18px; width: 100%" attrs="{'invisible': [('hour_bool', '=', False)]}">
+                    <label string="Hour Number List"/>
+                    <field name="HourStr"/>
+                </div>
+
+                <div style="margin-bottom: 18px; margin-top: 18px; width:100%; float: left">
+                    ≡
+                    <field name="MinuteBool"/>
+                    <label string="Minute"/>
+                </div>
+                <div style=" margin-bottom: 18px;margin-top: 18px; width: 100%" attrs="{'invisible': [('minute_bool', '=', False)]}">
+                    <label string="Minute Number list"/>
+                    <field name="MinuteStr"/>
+                </div>
+            </form>
+        </view>
+
+        <action id="base_action_cron" name="Crons" type="ir.actions.act_window" model="Cron"
+                view_mode="tree, form"/>
+        <menuitem id="base_menu_action_cron" name="Crons" sequence="6" action="base_action_cron"
+                  parent="base_menu_crons_and_workers"/>
+    </data>
+</hexya>
\ No newline at end of file
diff --git a/base/resources/menus.xml b/base/resources/menus.xml
index 52cd0a1..bd17348 100644
--- a/base/resources/menus.xml
+++ b/base/resources/menus.xml
@@ -27,6 +27,7 @@
 
         <menuitem id="base_menu_custom" name="Technical" parent="base_menu_administration" sequence="110"
                   groups="base.group_no_one"/>
+        <menuitem id="base_menu_crons_and_workers" name="Crons &amp; Workers" parent="base_menu_custom" sequence="20"/>
         <menuitem id="base_menu_user_interface" name="User Interface" parent="base_menu_custom"/>
         <menuitem id="base_menu_database_structure" name="Database Structure" parent="base_menu_custom"/>
 
diff --git a/base/resources/worker.xml b/base/resources/worker.xml
new file mode 100644
index 0000000..ec5ae71
--- /dev/null
+++ b/base/resources/worker.xml
@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<hexya>
+    <data>
+        <view id="base_view_workers_tree" model="Worker">
+            <tree string="Workers">
+                <field name="Name"/>
+                <field name="JobsInQueue"/>
+                <field name="MaxThreads"/>
+            </tree>
+        </view>
+
+        <view id="vase_view_workers_form" model="Worker">
+            <form string="Workers">
+                <sheet>
+                    <h1>
+                        <field name="Name" class="oe_inline"/>
+                    </h1>
+                    <group>
+                        <field name="MaxThreads"/>
+                        <field name="MaxHistoryEntries"/>
+                        <field name="PauseTime"/>
+                    </group>
+                    <group>
+                        <div>
+                            <label string="Max History Date"/>
+                            <field name="MaxHistoryAmmount" style="width:30px"/>
+                            <field name="MaxHistorySelection" style="width:53%"/>
+                        </div>
+                    </group>
+                </sheet>
+            </form>
+        </view>
+
+        <view id="base_view_jobs_history_tree" model="WorkerJobHistory">
+            <tree   string="Job History"
+                    decoration-success="status=='done'"
+                    decoration-warning="status=='pending'"
+                    decoration-danger="status=='fail'"
+                    decoration-bf="status=='fail'"
+                    decoration-primary="status=='running'"
+                    decoration-muted="status=='cancel', status=='abort'"
+                    decoration-it="status=='cancel', status=='abort'">
+                <field name="Name"/>
+                <field name="StartDate"/>
+                <field name="ReturnDate"/>
+                <field name="Status"/>
+                <button name="ButtonCancel" type="object" string="Cancel / Abort" icon="fa-times-circle text-danger" attrs="{'invisible': [('status', 'not in', ['pending', 'running'])]}"/>
+                <button name="Requeue" type="object" string="Requeue" icon="fa-share text-primary" attrs="{'invisible': [('status', 'not in', ['done', 'cancel', 'abort', 'fail'])]}"/>
+                <button name="ButtonDone" type="object" string="Mark as Done" icon="fa-check-square text-success" attrs="{'invisible': [('status', 'not in', ['cancel', 'abort', 'fail'])]}"/>
+            </tree>
+        </view>
+
+        <view id="base_view_jobs_history_form" model="WorkerJobHistory" delete="false">
+            <form   string="Job History">
+                <header>
+                    <field name="Status" widget="statusbar"
+                           statusbar_visible="pending,running"/>
+                    <button name="requeue" class="oe_highlight" string="Requeue Job" type="object"/>
+                    <button name="button_done" class="oe_highlight" string="Set to 'Done'" type="object"/>
+                </header>
+                <sheet>
+                    <h1>
+                        <field name="Name" class="oe_inline"/>
+                    </h1>
+                    <group>
+                        <field name="WorkerName"/>
+                        <field name="ModelName"/>
+                        <field name="MethodName"/>
+                        <field name="ParamsJson"/>
+                    </group>
+                    <group>
+                        <group>
+                            <field name="TaskUUID"/>
+                        </group>
+                        <group>
+                            <field name="CreateDate"/>
+                            <field name="QueuedDate"/>
+                            <field name="StartDate"/>
+                            <field name="ReturnDate"/>
+                        </group>
+                    </group>
+                    <group name="method_output" string="Method Result" attrs="{'invisible': [('method_output', '=', False)]}">
+                        <field nolabel="1" name="MethodOutput"/>
+                    </group>
+                    <group name="exc_info" string="Exception Information" attrs="{'invisible': [('exc_info', '=', False)]}">
+                        <field nolabel="1" name="ExcInfo"/>
+                    </group>
+                </sheet>
+            </form>
+        </view>
+
+        <view id="base_view_jobs_history_search" model="WorkerJobHistory">
+            <search>
+                <filter string="All Jobs not marked as Done" name="jobs_not_done" domain="[('Status', '!=', 'done')]"/>
+            </search>
+        </view>
+
+        <action id="base_action_workers" name="Workers" type="ir.actions.act_window" model="Worker"
+                view_mode="tree, form"/>
+
+        <action id="base_action_jobs_history" name="Jobs" type="ir.actions.act_window" model="WorkerJobHistory"
+                view_mode="tree, form" context="{&quot;search_default_jobs_not_done&quot;: 1}"/>
+
+        <menuitem id="base_menu_action_workers" name="Workers" sequence="3" action="base_action_workers"
+                  parent="base_menu_crons_and_workers"/>
+        <menuitem id="base_menu_action_jobs_history" name="Jobs" sequence="5" action="base_action_jobs_history"
+                  parent="base_menu_crons_and_workers"/>
+    </data>
+</hexya>
\ No newline at end of file
diff --git a/base/worker.go b/base/worker.go
new file mode 100644
index 0000000..7c81156
--- /dev/null
+++ b/base/worker.go
@@ -0,0 +1,418 @@
+package base
+
+import (
+	"fmt"
+	"time"
+
+	"reflect"
+
+	"encoding/json"
+
+	"strings"
+
+	"github.com/hexya-erp/hexya/hexya/models"
+	"github.com/hexya-erp/hexya/hexya/models/security"
+	"github.com/hexya-erp/hexya/hexya/models/types"
+	"github.com/hexya-erp/hexya/hexya/models/types/dates"
+	"github.com/hexya-erp/hexya/pool/h"
+	"github.com/hexya-erp/hexya/pool/q"
+
+	"github.com/google/uuid"
+)
+
+func init() {
+	h.Worker().DeclareModel()
+	h.Worker().AddFields(map[string]models.FieldDefinition{
+		"Name": models.CharField{
+			String:   "Worker",
+			Unique:   true,
+			Required: true},
+		"MaxThreads": models.IntegerField{
+			String:   "Threads",
+			Required: true,
+			Default:  models.DefaultValue(1)},
+		"JobsInQueue": models.IntegerField{
+			String:   "Jobs in Queue",
+			Compute:  h.Worker().Methods().GetJobsInQueueCount(),
+			ReadOnly: true},
+		"PauseTime": models.IntegerField{
+			Default:  models.DefaultValue(1),
+			Required: true},
+		"IsRunning": models.BooleanField{
+			ReadOnly: true},
+		"MaxHistoryEntries": models.IntegerField{
+			Default:  models.DefaultValue(500),
+			Required: true},
+		"MaxHistoryAmmount": models.IntegerField{
+			Default:  models.DefaultValue(3),
+			Required: true},
+		"MaxHistorySelection": models.SelectionField{
+			Selection: types.Selection{
+				`month`: `Months`,
+				`day`:   `Days`,
+				`hour`:  `Hours`},
+			Default:  models.DefaultValue("days"),
+			Required: true},
+	})
+
+	h.Worker().Methods().CleanJobHistory().DeclareMethod(
+		`CleanJobHistory goes though the job list and removes any entries marked as done and following the Worker rules.
+				If worker rules as default: removes all jobs marked as done, older than 3 days or until the total ammount is below 500`,
+		func(rs h.WorkerSet) string {
+			var deleteLen int
+			for _, workerData := range h.Worker().NewSet(rs.Env()).SearchAll().All() {
+				query := q.WorkerJobHistory().Status().Equals("done").And().WorkerName().Equals(workerData.Name)
+				set := h.WorkerJobHistory().Search(rs.Env(), query).Sorted(func(rs1, rs2 h.WorkerJobHistorySet) bool {
+					if rs1.CreateDate().LowerEqual(rs2.CreateDate()) {
+						return true
+					}
+					return false
+				})
+				rs.PollCancel()
+				deltaDur := time.Duration(workerData.MaxHistoryAmmount)
+				switch workerData.MaxHistorySelection {
+				case "month":
+					deltaDur = deltaDur * 30 * 24 * time.Hour
+				case "day":
+					deltaDur = deltaDur * 24 * time.Hour
+				case "hour":
+					deltaDur = deltaDur * time.Hour
+				}
+				setLen := set.Len()
+				i := -1
+				toDelete := set.Filtered(func(set h.WorkerJobHistorySet) bool {
+					i++
+					if int64(setLen-i) > workerData.MaxHistoryEntries || set.CreateDate().Add(deltaDur).LowerEqual(dates.Now()) {
+						return true
+					}
+					return false
+				})
+				deleteLen += toDelete.Len()
+				rs.PollCancel()
+				toDelete.Unlink()
+			}
+			return fmt.Sprintf("%d Records Unlinked.", deleteLen)
+		})
+
+	h.Worker().Methods().GetJobsInQueueCount().DeclareMethod(
+		`GetJobsInQueueCount returns the ammount of jobs currently in a worker's queue`,
+		func(rs h.WorkerSet) *h.WorkerData {
+			QSize := h.WorkerJobHistory().Search(rs.Env(), q.WorkerJobHistory().WorkerName().Equals(rs.Name()).And().Status().Equals("pending")).Len()
+			return &h.WorkerData{JobsInQueue: int64(QSize)}
+		})
+
+	h.Worker().Methods().Create().Extend(
+		`Create creates and initialize a new Worker`,
+		func(set h.WorkerSet, data *h.WorkerData, namer ...models.FieldNamer) h.WorkerSet {
+			rs := set.Super().Create(data, namer...)
+			rs.StartWorker()
+			return rs
+		})
+
+	h.Worker().Methods().StartWorker().DeclareMethod(
+		`StartWorker starts the goroutine of a specified worker`,
+		func(rs h.WorkerSet) {
+			models.ExecuteInNewEnvironment(rs.Env().Uid(), func(env models.Environment) {
+				w := rs.First()
+				go rs.WorkerLoop(&w)
+				if _, ok := threadsChanMap[w.Name]; !ok {
+					threadsChanMap[w.Name] = make(chan bool, w.MaxThreads)
+				}
+				for i := 0; i < int(w.MaxThreads); i++ {
+					threadsChanMap[w.Name] <- true
+				}
+			})
+		})
+
+	h.Worker().Methods().GetWorker().DeclareMethod(
+		`GetWorker returns the worker correspoding to the given name`,
+		func(rs h.WorkerSet, str string) h.WorkerSet {
+			return h.Worker().Search(rs.Env(), q.Worker().Name().Equals(str))
+		})
+
+	h.Worker().Methods().LoadWorkers().DeclareMethod(
+		`LoadWorkers reads into database and starts every worker. it also creates the Main worker if it doesn't exist
+				Meant to be called only once after server start`,
+		func(rs h.WorkerSet) {
+			set := h.Worker().Search(rs.Env(), q.Worker().ID().Greater(-1))
+			for _, s := range set.Records() {
+				s.StartWorker()
+			}
+			if rs.GetWorker("Main").Len() == 0 {
+				rs.Create(&h.WorkerData{
+					Name: "Main",
+				})
+			}
+			cancelChans = make(map[string]chan bool)
+		})
+
+	h.Worker().Methods().WorkerLoop().DeclareMethod(
+		`WorkerLoop is the neverending loop of a worker's goroutine. Should not be directly called. Usage of StartWorker is advised`,
+		func(rs h.WorkerSet, w *h.WorkerData) bool {
+			for {
+				select {
+				case <-threadsChanMap[w.Name]:
+					var hadJob bool
+					models.ExecuteInNewEnvironment(security.SuperUserID, func(env2 models.Environment) {
+						set := h.WorkerJobHistory().Search(env2, q.WorkerJobHistory().WorkerName().Equals(w.Name).And().Status().Equals("pending"))
+						hadJob = set.Len() > 0
+						if hadJob {
+							res := set.Sorted(func(rs1, rs2 h.WorkerJobHistorySet) bool {
+								if rs1.CreateDate().LowerEqual(rs2.CreateDate()) {
+									return true
+								}
+								return false
+							}).Records()[0]
+							h.Worker().NewSet(env2).Execute(w, res)
+						}
+					})
+					if !hadJob {
+						threadsChanMap[w.Name] <- true
+						time.Sleep(time.Duration(w.PauseTime) * time.Second)
+					}
+				default:
+					time.Sleep(time.Duration(w.PauseTime) * time.Second)
+				}
+			}
+		})
+
+	h.Worker().Methods().Execute().DeclareMethod(
+		`Execute launches a Worker method specified by the given res`,
+		func(rs h.WorkerSet, w *h.WorkerData, res h.WorkerJobHistorySet) {
+			writeIn := h.WorkerJobHistoryData{
+				StartDate: dates.Now(),
+				Status:    "running"}
+
+			if _, ok := models.Registry.Get(res.ModelName()); !ok {
+				writeIn.Status = "fail"
+				writeIn.MethodOutput = fmt.Sprintf("error: no Model known as '%s'", res.ModelName())
+				res.Write(&writeIn)
+				threadsChanMap[w.Name] <- true
+				return
+			}
+			rc := res.Env().Pool(res.ModelName())
+			method, ok := rc.Model().Methods().Get(res.MethodName())
+			if !ok {
+				writeIn.Status = "fail"
+				writeIn.MethodOutput = fmt.Sprintf("error: no method known as '%s' in model '%s'", res.MethodName(), res.ModelName)
+				res.Write(&writeIn)
+				threadsChanMap[w.Name] <- true
+				return
+			}
+			res.Write(&writeIn)
+			go models.ExecuteInNewEnvironment(security.SuperUserID, func(env2 models.Environment) {
+				json.Unmarshal([]byte(res.MethodName()), &method)
+				var params interface{}
+				json.Unmarshal([]byte(res.ParamsJson()), &params)
+				var out []interface{}
+				cancelChans[res.TaskUUID()] = make(chan bool)
+				err := models.ExecuteInNewEnvironment(security.SuperUserID, func(env3 models.Environment) {
+					if params == nil {
+						out = method.CallMulti(env3.Pool(res.ModelName()).WithContext("cancelChanId", res.TaskUUID()))
+					} else {
+						out = method.CallMulti(env3.Pool(res.ModelName()).WithContext("cancelChanId", res.TaskUUID()), interfaceSlice(params)...)
+					}
+				})
+				delete(cancelChans, res.TaskUUID())
+				writeOut := h.WorkerJobHistoryData{ReturnDate: dates.Now()}
+				if err != nil {
+					writeOut.Status = "fail"
+					split := strings.Split(err.Error(), "\n----------------------------------\n")
+					if split[0] == "ABORT" {
+						writeOut.Status = "abort"
+					} else {
+						writeOut.MethodOutput = fmt.Sprintf("error: %s", split[0])
+						writeOut.ExcInfo = split[1]
+					}
+				} else {
+					writeOut.Status = "done"
+					outStr := ""
+					for _, o := range out {
+						outStr += fmt.Sprintf("%v\n", o)
+					}
+					writeOut.MethodOutput = outStr
+				}
+				h.WorkerJobHistory().Browse(env2, []int64{res.ID()}).Write(&writeOut)
+				threadsChanMap[w.Name] <- true
+			})
+		})
+
+	h.WorkerJobHistory().DeclareModel()
+	h.WorkerJobHistory().AddFields(map[string]models.FieldDefinition{
+		"Name": models.CharField{
+			String:   "Method Name",
+			Default:  models.DefaultValue("Custom Job"),
+			Required: true,
+		},
+		"WorkerName": models.CharField{
+			String:  "Worker",
+			Default: models.DefaultValue("Main"),
+		},
+		"ModelName": models.CharField{
+			String:   "Model",
+			Required: true,
+		},
+		"MethodName": models.CharField{
+			String:   "Method",
+			Required: true,
+		},
+		"ParamsJson": models.TextField{
+			String: "Parameters",
+			Help:   "The parameters given to the method. With JSON formating.",
+		},
+		"MethodOutput": models.TextField{
+			String:   "Return Value",
+			ReadOnly: true,
+		},
+		"ExcInfo": models.TextField{
+			String:   "Exception Information",
+			ReadOnly: true,
+		},
+		"Status": models.SelectionField{
+			String: "Job Status",
+			Selection: types.Selection{
+				"pending": "Pending",
+				"cancel":  "Canceled",
+				"running": "Running",
+				"abort":   "Aborted",
+				"done":    "Done",
+				"fail":    "Failed",
+			},
+			ReadOnly: true,
+		},
+		"QueuedDate": models.DateTimeField{
+			String:   "Queued at",
+			ReadOnly: true,
+		},
+		"StartDate": models.DateTimeField{
+			String:   "Started at",
+			ReadOnly: true,
+		},
+		"ReturnDate": models.DateTimeField{
+			String:   "finished at",
+			ReadOnly: true,
+		},
+		"TaskUUID": models.CharField{
+			ReadOnly: true,
+		},
+	})
+	h.WorkerJobHistory().Fields().CreateDate().SetReadOnly(true)
+
+	h.WorkerJobHistory().Methods().ButtonDone().DeclareMethod(
+		`ButtonDone Sets the current rs as done`,
+		func(rs h.WorkerJobHistorySet) {
+			switch rs.Status() {
+			case "":
+				panic("Please finish creating the job before trying to mark it as done")
+			case "done":
+				panic("The Job is already marked as done")
+			case "pending":
+				panic("You can't mark a pending job as done. please cancel it first")
+			default:
+				//confirmation box
+				rs.SetStatus("done")
+			}
+		})
+
+	h.WorkerJobHistory().Methods().Requeue().DeclareMethod(
+		`Requeue pushes the given rs back to the worker queue`,
+		func(rs h.WorkerJobHistorySet) {
+			if rs.Status() == "pending" {
+				panic("You can't requeue a job that is already queued")
+			} else if rs.Status() == "" {
+				panic("Please finish creating the job before trying to requeue it")
+			}
+			rs.Write(&h.WorkerJobHistoryData{
+				Status:     "pending",
+				QueuedDate: dates.Now(),
+				ExcInfo:    "",
+			})
+		})
+
+	h.WorkerJobHistory().Methods().ButtonCancel().DeclareMethod(
+		`ButtonCancel cancels the given job`,
+		func(rs h.WorkerJobHistorySet) {
+			switch rs.Status() {
+			case "pending":
+				rs.SetStatus("cancel")
+			case "running":
+				rs.CancelJob()
+			}
+		})
+
+	h.WorkerJobHistory().Methods().CancelJob().DeclareMethod(
+		`CancelJob marks the given rs to be cancelled. Usage of method h.Worker.PollCancel is required in the worker method`,
+		func(rs h.WorkerJobHistorySet) {
+			cancelChans[rs.TaskUUID()] <- true
+		})
+
+	h.WorkerJobHistory().Methods().Create().Extend(
+		`Create creates a new Job entry`,
+		func(set h.WorkerJobHistorySet, data *h.WorkerJobHistoryData, namer ...models.FieldNamer) h.WorkerJobHistorySet {
+			if data.TaskUUID == "" {
+				data.TaskUUID = uuid.New().String()
+			}
+			if data.WorkerName == "" {
+				data.WorkerName = "Main"
+			}
+			data.Status = "pending"
+			data.QueuedDate = dates.Now()
+			return set.Super().Create(data, namer...)
+		})
+
+	h.JobArgs().DeclareModel()
+	h.JobArgs().AddFields(map[string]models.FieldDefinition{
+		"WorkerName": models.CharField{},
+		"ModelName":  models.CharField{},
+		"Methoder":   models.CharField{},
+		"Params":     models.CharField{},
+	})
+
+	h.JobArgs().Methods().WithParams().DeclareMethod(
+		`WithParams gives the current JobArg some parameters. (no parameters by default)`,
+		func(rs h.JobArgsSet, params ...interface{}) h.JobArgsSet {
+			paramsJson, _ := json.Marshal(params)
+			rs.SetParams(string(paramsJson))
+			return rs
+		})
+
+	h.JobArgs().Methods().WithWorker().DeclareMethod(
+		`WithWorker sets the JobsArgs' Worker to a worker corresponding to the given name. ('Main' by default)`,
+		func(rs h.JobArgsSet, workerName string) h.JobArgsSet {
+			rs.SetWorkerName(workerName)
+			return rs
+		})
+
+	h.JobArgs().Methods().Enqueue().DeclareMethod(
+		`Enqueue creates and pushes to queue the given JobArg created using WithParams and WithWorker`,
+		func(rs h.JobArgsSet, method models.Methoder) {
+			h.WorkerJobHistory().Create(rs.Env(), &h.WorkerJobHistoryData{
+				Name:       method.Underlying().Name(),
+				Status:     "pending",
+				WorkerName: rs.WorkerName(),
+				ModelName:  rs.ModelName(),
+				MethodName: method.Underlying().Name(),
+				ParamsJson: rs.Params(),
+				QueuedDate: dates.Now(),
+			})
+		})
+}
+
+var cancelChans map[string]chan bool
+
+var threadsChanMap map[string]chan bool
+
+func interfaceSlice(slice interface{}) []interface{} {
+	s := reflect.ValueOf(slice)
+	if s.Kind() != reflect.Slice {
+		panic("interfaceSlice() given a non-slice type")
+	}
+
+	ret := make([]interface{}, s.Len())
+
+	for i := 0; i < s.Len(); i++ {
+		ret[i] = s.Index(i).Interface()
+	}
+
+	return ret
+}