예제 #1
0
func createSchedule(w http.ResponseWriter, r *http.Request) {
	var schedule *models.Schedule
	var valve *models.Valve
	var err error

	valve, err = models.GetValveById(helpers.Int32ValueFrom(r.PostFormValue("valve"), -1))

	if err != nil {
		goto Error
	}

	schedule = &models.Schedule{
		ValveId: valve.Id,
		Active:  true,
	}

	err = schedule.SetInterval(
		r.PostFormValue("interval[multiplicator]"),
		r.PostFormValue("interval[denominator]"))

	if err != nil {
		goto Error
	}

	err = schedule.SetLength(
		r.PostFormValue("length[multiplicator]"),
		r.PostFormValue("length[denominator]"))

	if err != nil {
		goto Error
	}

	err = schedule.SetStart(r.PostFormValue("date"))
	if err != nil {
		goto Error
	}

	err = db.Orm().Insert(schedule)
	if err != nil {
		goto Error
	}

	http.Redirect(w, r, "/", 302)
	return

Error:
	tmpl_err := templates["error"].Execute(w, err)
	if tmpl_err != nil {
		log.Panicln(err)
	}

}
예제 #2
0
func TestSchedulesCreation(t *testing.T) {
	valve, _ := models.GetValveByRelayId(17)
	schedule := &models.Schedule{
		ValveId:  valve.Id,
		Length:   3,
		Interval: 2,
		Active:   true,
	}

	schedule.SetStart(time.Now().Add(time.Second * 5).String())

	db.Orm().Insert(schedule)
}
예제 #3
0
func TestValvesAreUnique(t *testing.T) {
	query := "select v.RelayId, v.Name " +
		"from valves v " +
		"where v.RelayId = 17"
	valves, err := db.Orm().Select(models.Valve{}, query)

	if err != nil || len(valves) != 1 {
		t.Fail()
		t.Log(valves)
		t.Log(err)
	}

}
예제 #4
0
func FirstValveOrCreate(relay int) *Valve {
	var valve *Valve
	query := "select v.Id, v.RelayId, v.Name " +
		"from valves v " +
		"where v.RelayId = ?"

	instances, err := db.Orm().Select(Valve{}, query, relay)

	if err != nil {
		log.Fatalln(err)
	}

	if len(instances) == 0 {
		valve = &Valve{
			RelayId: relay,
		}
		db.Orm().Insert(valve)
	} else {
		valve = instances[0].(*Valve)
	}

	return valve
}
예제 #5
0
func GetValveByRelayId(id int) (valve *Valve, err error) {
	query := "select v.Id, v.RelayId, v.Name " +
		"from valves v " +
		"where v.RelayId = ?"
	instances, err := db.Orm().Select(Valve{}, query, id)

	if err != nil {
		return nil, err
	}

	if len(instances) == 0 {
		return nil, nil
	} else {
		return instances[0].(*Valve), nil
	}
}
예제 #6
0
func updateValve(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.Atoi(r.URL.Query().Get(":valveId"))
	if err != nil {
		log.Println(err)
		http.Redirect(w, r, "/", 302)
	}

	valve, err := models.GetValveById(int32(id))

	if err == nil {
		valve.Name = r.PostFormValue("name")
		db.Orm().Update(valve)
	}

	http.Redirect(w, r, "/", 302)
	return
}
예제 #7
0
func GetSchedulesForValve(valve *Valve) (schedules []*Schedule, err error) {
	query := "select * " +
		"from schedules s " +
		"where s.ValveId = ?"
	instances, err := db.Orm().Select(Schedule{}, query, valve.Id)

	if err != nil {
		return nil, err
	}

	schedules = make([]*Schedule, len(instances))
	for i := range instances {
		schedules[i] = instances[i].(*Schedule)
	}

	return schedules, err
}
예제 #8
0
func updateSchedule(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.Atoi(r.URL.Query().Get(":scheduleId"))
	if err != nil {
		log.Println(err)
	}

	schedule, err := models.GetScheduleById(int32(id))

	err = schedule.SetInterval(
		r.PostFormValue("interval[multiplicator]"),
		r.PostFormValue("interval[denominator]"))

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

	err = schedule.SetLength(
		r.PostFormValue("length[multiplicator]"),
		r.PostFormValue("length[denominator]"))

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

	err = schedule.SetStart(r.PostFormValue("date"))
	if err != nil {
		log.Println(err)
	}

	schedule.SetActive(r.PostFormValue("status"))

	db.Orm().Update(schedule)

	valve, err := schedule.Valve()
	if err != nil {
		http.Redirect(w, r, "/", 302)
		return
	}

	http.Redirect(w, r, "/valves/"+strconv.Itoa(int(valve.Id)), 302)
	return
}
예제 #9
0
func scheduledToLaunch() []*models.Schedule {
	active_at := time.Now().Truncate(time.Second).Unix()
	query := "select *" +
		"from schedules s " +
		"where s.Active = 1 and " +
		"( s.Start = ? OR ( (strftime('%s', 'now') - strftime(s.Start)) % s.Interval) = 0)"
	instances, err := db.Orm().Select(models.Schedule{}, query, active_at)

	if err != nil {
		log.Fatalln(err)
	}

	schedules := make([]*models.Schedule, len(instances))

	for i, instance := range instances {
		schedules[i] = instance.(*models.Schedule)
	}

	return schedules
}
예제 #10
0
func TestSchedulerManageSchedules(t *testing.T) {

	query := "select s.Id, s.ValveId, s.Active, s.Start, s.Interval, s.Length " +
		"from schedules s " +
		"where s.Active = 1 "

	instances, err := db.Orm().Select(models.Schedule{}, query)

	if err != nil {
		t.Fail()
		t.Log(err)
	}

	schedules := make([]*models.Schedule, len(instances))

	for i, instance := range instances {
		schedules[i] = instance.(*models.Schedule)
	}

	time.Sleep(20 * time.Second)
}
예제 #11
0
func LaunchScheduledEntries(list []*models.Schedule) {
	for i := 0; i < len(list); i++ {
		schedule := list[i]
		valve, err := schedule.Valve()

		if err != nil {
			log.Fatalln(err)
		}

		entry := &models.Entry{
			Length:  schedule.Length,
			ValveId: valve.Id,
		}

		err = db.Orm().Insert(entry)

		if err != nil {
			log.Fatalln(err)
		}
	}
}
예제 #12
0
func GetScheduleById(id int32) (schedule *Schedule, err error) {
	query := "select * " +
		"from schedules s " +
		"where s.Id = ?"

	instances, err := db.Orm().Select(Schedule{}, query, id)

	if err != nil {
		return nil, err
	}

	schedules := make([]*Schedule, len(instances))
	for i := range instances {
		schedules[i] = instances[i].(*Schedule)
	}

	if len(schedules) > 0 {
		return schedules[0], err
	} else {
		return nil, err
	}
}
예제 #13
0
func RegisterEntry() {
	db.Orm().AddTableWithName(Entry{}, "entries").SetKeys(true, "Id")
}
예제 #14
0
func RegisterSchedule() {
	db.Orm().AddTableWithName(Schedule{}, "schedules").SetKeys(true, "Id")
}
예제 #15
0
func RegisterValve() {
	db.Orm().AddTableWithName(Valve{}, "valves").SetKeys(true, "Id")
}