func TestSelectItem(t *testing.T) {
selectedItem := new(data.Item)
selectedItem.ID = item.ID
err := Select(selectedItem)
if err != nil {
t.Error(err)
}
t.Log(item.StartTime.UTC())
t.Log(selectedItem.StartTime.UTC())
t.Log(item.StopTime.UTC())
t.Log(selectedItem.StopTime.UTC())
selectedItem.StartTime = item.StartTime // hack
selectedItem.StopTime = item.StopTime // hack
structJSONCompare(t, item, selectedItem)
}
func Insert(val interface{}) error {
var (
res sql.Result
err error
)
now := time.Now().UTC()
switch v := val.(type) {
case *data.Item:
res, err = Exec(
"INSERT INTO Items (Type, Author, ThumbnailURI, ContentURI, UploadURI, ContentToken, HasHeading, Heading, HasGeo, Lat, Lng, Radius, Live, StartTime, StopTime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
v.Type,
v.Author,
v.ThumbnailURI,
v.ContentURI,
v.UploadURI,
v.ContentToken,
v.HasHeading,
v.Heading,
v.HasGeo,
v.Lat,
v.Lng,
v.Radius,
v.Live,
v.StartTime.UTC(),
v.StopTime.UTC(),
)
case *data.ItemComment:
res, err = Exec(
"INSERT INTO ItemComments (ItemID, Author, Body, UpdateTime) VALUES (?, ?, ?, ?)",
v.ItemID,
v.Author,
v.Body,
now,
)
case *data.Geolocation:
res, err = Exec(
"INSERT INTO Geolocations (ItemID, Lat, Lng, Heading, Radius, Timestamp) VALUES (?, ?, ?, ?, ?, ?)",
v.ItemID,
v.Lat,
v.Lng,
v.Heading,
v.Radius,
now,
)
case *data.Term:
// There is basically no danger with INSERT IGNORE there is nothing we would want to change if there is
// accidental remake of a term
res, err = Exec(
"INSERT IGNORE INTO Terms (Term, Automated, Author, UpdateTime) VALUES (?, ?, ?, ?)",
v.Term,
v.Automated,
v.Author,
now,
)
case *data.TermRelationship:
// Nothing can go wrong with INSERT IGNORE since the key is whole entry
res, err = Exec(
"INSERT IGNORE INTO TermRelationships (Term, ItemID) VALUES (?, ?)",
v.Term,
v.ItemID,
)
case *data.TermRanking:
// There is basically no danger with INSERT IGNORE there is nothing we would want to change if there is
// accidental remake of a term
res, err = Exec(
"INSERT IGNORE INTO TermRankings (Term, Ranking, UpdateTime) VALUES (?, ?, ?)",
v.Term,
v.Ranking,
now,
)
case *data.Role:
res, err = Exec(
"INSERT INTO Roles (Title, Permissions) VALUES (?, ?)",
v.Title,
v.Permissions,
)
case *data.User:
res, err = Exec(
"INSERT INTO Users (Username, Password, Salt, Role, TrustLevel, CreateTime) VALUES (?, ?, ?, ?, ?, ?)",
v.Username,
v.Password,
v.Salt,
v.Role,
v.TrustLevel,
now,
)
case *data.UserDirection:
res, err = Exec(
"INSERT INTO UserDirections (Username, LockUsername, Command, Heading, Lat, Lng, UpdateTime) VALUES (?, ?, ?, ?, ?, ?, ?)",
v.Username,
v.LockUsername,
v.Command,
v.Heading,
v.Lat,
v.Lng,
now,
)
default:
return ErrUnsupportedDataType
}
if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected < 1 {
return ErrZeroAffected
}
ID, err := res.LastInsertId()
if err != nil {
return err
}
switch v := val.(type) {
case *data.Item:
v.ID = ID
v.AddTerm("all", v.Author)
v.AddTerm("type:"+v.Type, v.Author)
v.AddTerm(v.Author, v.Author)
_, err = ReconcileTerms(v, &v.Terms)
case *data.ItemComment:
v.ID = ID
v.UpdateTime = now
case *data.Geolocation:
v.Timestamp = &now
item := new(data.Item)
item.ID = v.ItemID
err = Select(item)
if err != nil {
return err
}
listeners.NotifyUpdate(item)
case *data.Term:
v.UpdateTime = now
ranking := new(data.TermRanking)
ranking.Term = v.Term
err = Insert(ranking)
case *data.TermRanking:
v.UpdateTime = now
case *data.User:
v.CreateTime = now
direction := new(data.UserDirection)
direction.Username = v.Username
err = Insert(direction)
case *data.UserDirection:
v.UpdateTime = now
}
listeners.NotifyInsert(val)
return err
}