// Insert inserts the TestLog into the database
func (self *TestLog) Insert() error {
	self.Id = bson.NewObjectId().Hex()
	if err := self.Validate(); err != nil {
		return fmt.Errorf("cannot insert invalid test log: %v", err)
	}
	return db.Insert(TestLogCollection, self)
}

// TryInsert writes the manifest to the database if possible.
// If the document already exists, it returns true and the error
// If it does not it will return false and the error
func (m *Manifest) TryInsert() (bool, error) {
	err := db.Insert(Collection, m)
	if mgo.IsDup(err) {
		return true, nil
	}
	return false, err
}

// Inserts the task into the old_tasks collection
func (t *Task) Archive() error {
	var update bson.M
	// only increment restarts if have a current restarts
	// this way restarts will never be set for new tasks but will be
	// maintained for old ones
	if t.Restarts > 0 {
		update = bson.M{"$inc": bson.M{
			TaskExecutionKey: 1,
			TaskRestartsKey:  1,
		}}
	} else {
		update = bson.M{
			"$inc": bson.M{TaskExecutionKey: 1},
		}
	}
	err := UpdateOneTask(
		bson.M{TaskIdKey: t.Id},
		update)
	if err != nil {
		return fmt.Errorf("task.Archive() failed: %v", err)
	}
	archive_task := *t
	archive_task.Id = fmt.Sprintf("%v_%v", t.Id, t.Execution)
	archive_task.OldTaskId = t.Id
	archive_task.Archived = true
	err = db.Insert(OldTasksCollection, &archive_task)
	if err != nil {
		return fmt.Errorf("task.Archive() failed: %v", err)
	}
	return nil
}

func (u *DBUser) Insert() error {
	u.CreatedAt = time.Now()
	return db.Insert(Collection, u)
}

// Insert writes the distro to the database.
func (d *Distro) Insert() error {
	return db.Insert(Collection, d)
}

func (ar *AlertRecord) Insert() error {
	return db.Insert(Collection, ar)
}

// Inserts the task into the tasks collection, and logs an event that the task
// was created.
func (t *Task) Insert() error {
	event.LogTaskCreated(t.Id)
	return db.Insert(TasksCollection, t)
}

func (self *NotificationHistory) Insert() error {
	return db.Insert(NotifyHistoryCollection, self)
}

// Insert writes the b to the db.
func (t *Task) Insert() error {
	return db.Insert(Collection, t)
}

func (projectRef *ProjectRef) Insert() error {
	return db.Insert(ProjectRefCollection, projectRef)
}

func (self *PushLog) Insert() error {
	return db.Insert(PushlogCollection, self)
}

// Insert inserts the patch into the db, returning any errors that occur
func (p *Patch) Insert() error {
	return db.Insert(Collection, p)
}

func EnqueueAlertRequest(a *AlertRequest) error {
	a.QueueStatus = Pending
	return db.Insert(Collection, a)
}

func (self *Host) Insert() error {
	event.LogHostCreated(self.Id)
	return db.Insert(Collection, self)
}

func (self *Version) Insert() error {
	return db.Insert(Collection, self)
}

// Insert writes the b to the db.
func (b *Build) Insert() error {
	return db.Insert(Collection, b)
}

func (self *DBEventLogger) LogEvent(event Event) error {
	return db.Insert(self.collection, event)
}