added some more tables for weight and goal to be more flexible and fixed some minor UI issues

app/controllers/database.go

    DbMap.AddTable(models.Account{}).SetKeys(true, "Id")
    DbMap.AddTable(models.History{}).SetKeys(true, "Id")
    DbMap.AddTable(models.Goal{}).SetKeys(true, "Id")
    DbMap.AddTable(models.Weight{}).SetKeys(true, "Id")
    DbMap.TraceOn("[db]", revel.INFO)
    DbMap.CreateTables()
    DbMap.CreateTablesIfNotExists()
}
type DatabaseController struct {

app/controllers/profile.go

    return history
}
func (c Profile) getGoal(account *models.Account) (goal int64) {
    goal = 2000
    if account == nil {
        return goal
    }
    results := models.Goal{}
    err := c.Transaction.SelectOne(
        &results,
        `select * from Goal where AccountId = ? order by Date desc limit 1`,
        account.Id)
    if err != nil {
        return goal
    }
    goal = results.Calories
    return goal
}
func (c Profile) setGoal(account *models.Account, calories int64) {
    goals, err := c.Transaction.Select(
        models.Goal{},
        `select * from Goal where AccountId = ? order by Date desc limit 1`,
        account.Id)
    if err != nil {
        revel.INFO.Println(err)
        return
    }
    now := time.Now().Local()
    if len(goals) > 0 {
        goal := goals[0].(*models.Goal)
        local := goal.Date.Local()
        if now.Day() == local.Day() && now.Month() == local.Month() && now.Year() == local.Year() {
            goal.Calories = calories
            c.Transaction.Update(goal)
        } else {
            newGoal := models.Goal{ AccountId: account.Id, Calories: calories, Date: now }
            c.Transaction.Insert(&newGoal)
        }
    } else {
        newGoal := models.Goal{ AccountId: account.Id, Calories: calories, Date: now }
        c.Transaction.Insert(&newGoal)
    }
}
func (c Profile) getCaloriesForDate(history []*models.History, date time.Time) (current int64) {
    current = 0
}
func (c Profile) Index() revel.Result {
    return c.Render()
    account := c.Connected()
    return c.Render(account)
}
func (c Profile) Logon(id string) revel.Result {
        revel.INFO.Println("Creating account.")
        account = &models.Account{}
        account.Profile = id
        account.Goal = 2000
        account.Created = now
        account.LastVisit = now
        c.Transaction.Insert(account)
        return c.RenderJson(nil)
    }
    goal := c.getGoal(account)
    history := c.getHistory(account)
    response := models.ResponseStatistics {
        Goal: account.Goal,
        Goal: goal,
        Current: c.getCaloriesForDate(history, time.Now()),
        Streak: c.getStreak(history, account.Goal),
        Streak: c.getStreak(history, goal),
    }
    return c.RenderJson(response)
        return c.RenderJson(nil)
    }
    account.Goal = calories
    c.Transaction.Update(account)
    c.setGoal(account, calories)
    return c.RenderJson(true)
}

app/models/account.go

type Account struct {
    Id              int64
    Profile         string
    Goal            int64
    Created         time.Time
    LastVisit       time.Time
}

app/models/goal.go

package models
import "time"
type Goal struct {
    Id              int64
    AccountId       int64
    Calories        int64
    Date            time.Time
}

app/models/weight.go

package models
import "time"
type Weight struct {
    Id              int64
    AccountId       int64
    Weight          float64
    Date            time.Time
}

app/routes/routes.go

}
type tTestRunner struct {}
var TestRunner tTestRunner
func (_ tTestRunner) Index(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("TestRunner.Index", args).Url
}
func (_ tTestRunner) Run(
		suite string,
		test string,
		) string {
	args := make(map[string]string)
	
	revel.Unbind(args, "suite", suite)
	revel.Unbind(args, "test", test)
	return revel.MainRouter.Reverse("TestRunner.Run", args).Url
}
func (_ tTestRunner) List(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("TestRunner.List", args).Url
}
type tStatic struct {}
var Static tStatic
}
type tTestRunner struct {}
var TestRunner tTestRunner
type tApplication struct {}
var Application tApplication
func (_ tTestRunner) Index(
type tHome struct {}
var Home tHome
func (_ tHome) Index(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("TestRunner.Index", args).Url
	return revel.MainRouter.Reverse("Home.Index", args).Url
}
func (_ tTestRunner) Run(
		suite string,
		test string,
func (_ tHome) About(
		) string {
	args := make(map[string]string)
	
	revel.Unbind(args, "suite", suite)
	revel.Unbind(args, "test", test)
	return revel.MainRouter.Reverse("TestRunner.Run", args).Url
	return revel.MainRouter.Reverse("Home.About", args).Url
}
func (_ tTestRunner) List(
func (_ tHome) Overview(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("TestRunner.List", args).Url
	return revel.MainRouter.Reverse("Home.Overview", args).Url
}
type tApplication struct {}
var Application tApplication
type tProfile struct {}
var Profile tProfile
}
type tHome struct {}
var Home tHome
func (_ tHome) Index(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("Home.Index", args).Url
}
func (_ tHome) About(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("Home.About", args).Url
}
func (_ tHome) Overview(
		) string {
	args := make(map[string]string)
	
	return revel.MainRouter.Reverse("Home.Overview", args).Url
}

app/tmp/main.go

	"reflect"
	"github.com/revel/revel"
	_ "github.com/mattn/go-sqlite3"
	controllers0 "github.com/revel/revel/modules/static/app/controllers"
	controllers1 "github.com/revel/revel/modules/static/app/controllers"
	_ "github.com/revel/revel/modules/testrunner/app"
	controllers1 "github.com/revel/revel/modules/testrunner/app/controllers"
	controllers0 "github.com/revel/revel/modules/testrunner/app/controllers"
	_ "github.com/revolvingcow/grassfed/app"
	controllers "github.com/revolvingcow/grassfed/app/controllers"
	tests "github.com/revolvingcow/grassfed/tests"
			
		})
	
	revel.RegisterController((*controllers0.Static)(nil),
	revel.RegisterController((*controllers0.TestRunner)(nil),
		[]*revel.MethodType{
			&revel.MethodType{
				Name: "Index",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
					46: []string{ 
						"testSuites",
					},
				},
			},
			&revel.MethodType{
				Name: "Run",
				Args: []*revel.MethodArg{ 
					&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil)) },
					&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil)) },
				},
				RenderArgNames: map[int][]string{ 
					69: []string{ 
						"error",
					},
				},
			},
			&revel.MethodType{
				Name: "List",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
				},
			},
			
		})
	
	revel.RegisterController((*controllers1.Static)(nil),
		[]*revel.MethodType{
			&revel.MethodType{
				Name: "Serve",
			
		})
	
	revel.RegisterController((*controllers1.TestRunner)(nil),
	revel.RegisterController((*controllers.Application)(nil),
		[]*revel.MethodType{
			
		})
	
	revel.RegisterController((*controllers.Home)(nil),
		[]*revel.MethodType{
			&revel.MethodType{
				Name: "Index",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
					46: []string{ 
						"testSuites",
					31: []string{ 
					},
				},
			},
			&revel.MethodType{
				Name: "Run",
				Name: "About",
				Args: []*revel.MethodArg{ 
					&revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil)) },
					&revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil)) },
				},
				RenderArgNames: map[int][]string{ 
					69: []string{ 
						"error",
					35: []string{ 
					},
				},
			},
			&revel.MethodType{
				Name: "List",
				Name: "Overview",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
			
		})
	
	revel.RegisterController((*controllers.Application)(nil),
		[]*revel.MethodType{
			
		})
	
	revel.RegisterController((*controllers.Profile)(nil),
		[]*revel.MethodType{
			&revel.MethodType{
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
					497: []string{ 
					1449: []string{ 
						"account",
					},
				},
			},
			
		})
	
	revel.RegisterController((*controllers.Home)(nil),
		[]*revel.MethodType{
			&revel.MethodType{
				Name: "Index",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
					31: []string{ 
					},
				},
			},
			&revel.MethodType{
				Name: "About",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
					35: []string{ 
					},
				},
			},
			&revel.MethodType{
				Name: "Overview",
				Args: []*revel.MethodArg{ 
				},
				RenderArgNames: map[int][]string{ 
				},
			},
			
		})
	
	revel.DefaultValidationKeys = map[string]map[int]string{ 
		"github.com/revolvingcow/grassfed/app/controllers.Profile.Add": { 
			168: "product",
			169: "calories",
			220: "product",
			221: "calories",
		},
		"github.com/revolvingcow/grassfed/app/controllers.Profile.Logon": { 
			102: "id",
			154: "id",
		},
	}
	revel.TestSuites = []interface{}{ 

app/views/Home/Index.html

    <h1></h1>
    
    <div class="row">
        <div class="col-md-4 text-center">
        <div class="col-md-6 text-center">
            <h3 class="accounts">0</h3>
            <h3>Accounts</h3>
        </div>
        <div class="col-md-4 text-center">
        <div class="col-md-6 text-center">
            <h3 class="calories">0</h3>
            <h3>Calories</h3>
        </div>

app/views/Profile/Index.html

{{append . "moreScripts" "/public/js/googleplus.js"}}
{{append . "moreScripts" "/public/js/grassfed.js"}}
<div id="authentication" class="row" style="padding: 50px 15px; display: none;">
{{if not .account}}
<div id="authentication" class="row" style="padding: 50px 15px;">
    <div class="col-md-offset-4 col-md-4 text-center">
        <h1></h1>
        </p>
    </div>
</div>
{{end}}
{{if not .account}}
<div id="profile" class="row" style="padding: 50px 15px; display: none;">
{{else}}
<div id="profile" class="row" style="padding: 50px 15px;">
{{end}}
    <h1></h1>
    <div class="col-md-8">

public/js/grassfed.js

})(jQuery);
$(function () {
    // Bring the authentication down slowly...
    // this is in case they already have a valid sign-on.
    $('div#authentication').delay(1000).fadeIn();
    var chart = $("#goalChart")[0];
    var doughnutChart;
        $('input[name="products"][type="text"]').focus();
    }
    $('div#profile').on('show', function () {
    // Check to see if the profile is not hidden. If it is not then start your engines!
    if (!$('div#profile').is(':hidden')) {
        startEngine();
    });
    }
    else {
        $('div#profile').on('show', function () {
            startEngine();
        });
    }
    $('form#entry').on('submit', function (e) {
        e.preventDefault();