profile.go

package models

import (
	"time"

	"github.com/elos/data"
	"github.com/elos/data/builtin/mongo"
	"github.com/elos/metis"
	"gopkg.in/mgo.v2/bson"
)

// THIS FILE GENERATED BY METIS

// this type def generated by metis
type Profile struct {
	ActionsIds            []string  `json:"actions_ids" bson:"actions_ids"`
	CalendarId            string    `json:"calendar_id" bson:"calendar_id"`
	CreatedAt             time.Time `json:"created_at" bson:"created_at"`
	CurrentActionId       string    `json:"current_action_id" bson:"current_action_id"`
	CurrentActionableId   string    `json:"current_actionable_id" bson:"current_actionable_id"`
	CurrentActionableKind string    `json:"current_actionable_kind" bson:"current_actionable_kind"`
	DataIds               []string  `json:"data_ids" bson:"data_ids"`
	DeletedAt             time.Time `json:"deleted_at" bson:"deleted_at"`
	Email                 string    `json:"email" bson:"email"`
	EventsIds             []string  `json:"events_ids" bson:"events_ids"`
	Id                    string    `json:"id" bson:"_id,omitempty"`
	LocationId            string    `json:"location_id" bson:"location_id"`
	Name                  string    `json:"name" bson:"name"`
	OntologyId            string    `json:"ontology_id" bson:"ontology_id"`
	OwnerId               string    `json:"owner_id" bson:"owner_id"`
	Phone                 string    `json:"phone" bson:"phone"`
	RoutinesIds           []string  `json:"routines_ids" bson:"routines_ids"`
	TasksIds              []string  `json:"tasks_ids" bson:"tasks_ids"`
	UpdatedAt             time.Time `json:"updated_at" bson:"updated_at"`
}

func NewProfile() *Profile {
	return &Profile{}
}

func FindProfile(db data.DB, id data.ID) (*Profile, error) {

	profile := NewProfile()
	profile.SetID(id)

	return profile, db.PopulateByID(profile)

}

// Kind is derived from the models package and is
// defined in type.go, shared among implementations
func (profile *Profile) Kind() data.Kind {
	return ProfileKind
}

// just returns itself for now
func (profile *Profile) Concerned() []data.ID {
	foo := make([]data.ID, 1)
	foo[0] = profile.ID()
	return foo
}

func (profile *Profile) SetID(id data.ID) {
	profile.Id = id.String()
}

func (profile *Profile) ID() data.ID {
	return data.ID(profile.Id)
}

func (profile *Profile) IncludeAction(action *Action) {
	otherID := action.ID().String()
	for i := range profile.ActionsIds {
		if profile.ActionsIds[i] == otherID {
			return
		}
	}
	profile.ActionsIds = append(profile.ActionsIds, otherID)
}

func (profile *Profile) ExcludeAction(action *Action) {
	tmp := make([]string, 0)
	id := action.ID().String()
	for _, s := range profile.ActionsIds {
		if s != id {
			tmp = append(tmp, s)
		}
	}
	profile.ActionsIds = tmp
}

func (profile *Profile) ActionsIter(db data.DB) (data.Iterator, error) {
	// not yet completely general
	return mongo.NewIDIter(mongo.NewIDSetFromStrings(profile.ActionsIds), db), nil
}

func (profile *Profile) Actions(db data.DB) (actions []*Action, err error) {
	actions = make([]*Action, len(profile.ActionsIds))
	action := NewAction()
	for i, id := range profile.ActionsIds {
		action.Id = id
		if err = db.PopulateByID(action); err != nil {
			return
		}

		actions[i] = action
		action = NewAction()
	}

	return
}

func (profile *Profile) SetCalendar(calendarArgument *Calendar) error {
	profile.CalendarId = calendarArgument.ID().String()
	return nil
}

func (profile *Profile) Calendar(db data.DB) (*Calendar, error) {
	if profile.CalendarId == "" {
		return nil, ErrEmptyLink
	}

	calendarArgument := NewCalendar()
	id, _ := db.ParseID(profile.CalendarId)
	calendarArgument.SetID(id)
	return calendarArgument, db.PopulateByID(calendarArgument)

}

func (profile *Profile) CalendarOrCreate(db data.DB) (*Calendar, error) {
	calendar, err := profile.Calendar(db)

	if err == ErrEmptyLink {
		calendar := NewCalendar()
		calendar.SetID(db.NewID())
		if err := profile.SetCalendar(calendar); err != nil {
			return nil, err
		}

		if err := db.Save(calendar); err != nil {
			return nil, err
		}

		if err := db.Save(profile); err != nil {
			return nil, err
		}

		return calendar, nil
	} else {
		return calendar, err
	}
}

func (profile *Profile) SetCurrentAction(actionArgument *Action) error {
	profile.CurrentActionId = actionArgument.ID().String()
	return nil
}

func (profile *Profile) CurrentAction(db data.DB) (*Action, error) {
	if profile.CurrentActionId == "" {
		return nil, ErrEmptyLink
	}

	actionArgument := NewAction()
	id, _ := db.ParseID(profile.CurrentActionId)
	actionArgument.SetID(id)
	return actionArgument, db.PopulateByID(actionArgument)

}

func (profile *Profile) CurrentActionOrCreate(db data.DB) (*Action, error) {
	action, err := profile.CurrentAction(db)

	if err == ErrEmptyLink {
		action := NewAction()
		action.SetID(db.NewID())
		if err := profile.SetCurrentAction(action); err != nil {
			return nil, err
		}

		if err := db.Save(action); err != nil {
			return nil, err
		}

		if err := db.Save(profile); err != nil {
			return nil, err
		}

		return action, nil
	} else {
		return action, err
	}
}

func (profile *Profile) SetCurrentActionable(actionableArgument Actionable) error {
	profile.CurrentActionableId = actionableArgument.ID().String()
	return nil
}

func (profile *Profile) CurrentActionable(db data.DB) (Actionable, error) {
	if profile.CurrentActionableId == "" {
		return nil, ErrEmptyLink
	}

	m := ModelFor(data.Kind(profile.CurrentActionableKind))
	actionable := m.(Actionable)

	id, _ := db.ParseID(profile.CurrentActionableId)

	actionable.SetID(id)
	return actionable, db.PopulateByID(actionable)

}

func (profile *Profile) IncludeDatum(datum *Datum) {
	otherID := datum.ID().String()
	for i := range profile.DataIds {
		if profile.DataIds[i] == otherID {
			return
		}
	}
	profile.DataIds = append(profile.DataIds, otherID)
}

func (profile *Profile) ExcludeDatum(datum *Datum) {
	tmp := make([]string, 0)
	id := datum.ID().String()
	for _, s := range profile.DataIds {
		if s != id {
			tmp = append(tmp, s)
		}
	}
	profile.DataIds = tmp
}

func (profile *Profile) DataIter(db data.DB) (data.Iterator, error) {
	// not yet completely general
	return mongo.NewIDIter(mongo.NewIDSetFromStrings(profile.DataIds), db), nil
}

func (profile *Profile) Data(db data.DB) (data []*Datum, err error) {
	data = make([]*Datum, len(profile.DataIds))
	datum := NewDatum()
	for i, id := range profile.DataIds {
		datum.Id = id
		if err = db.PopulateByID(datum); err != nil {
			return
		}

		data[i] = datum
		datum = NewDatum()
	}

	return
}

func (profile *Profile) IncludeEvent(event *Event) {
	otherID := event.ID().String()
	for i := range profile.EventsIds {
		if profile.EventsIds[i] == otherID {
			return
		}
	}
	profile.EventsIds = append(profile.EventsIds, otherID)
}

func (profile *Profile) ExcludeEvent(event *Event) {
	tmp := make([]string, 0)
	id := event.ID().String()
	for _, s := range profile.EventsIds {
		if s != id {
			tmp = append(tmp, s)
		}
	}
	profile.EventsIds = tmp
}

func (profile *Profile) EventsIter(db data.DB) (data.Iterator, error) {
	// not yet completely general
	return mongo.NewIDIter(mongo.NewIDSetFromStrings(profile.EventsIds), db), nil
}

func (profile *Profile) Events(db data.DB) (events []*Event, err error) {
	events = make([]*Event, len(profile.EventsIds))
	event := NewEvent()
	for i, id := range profile.EventsIds {
		event.Id = id
		if err = db.PopulateByID(event); err != nil {
			return
		}

		events[i] = event
		event = NewEvent()
	}

	return
}

func (profile *Profile) SetLocation(locationArgument *Location) error {
	profile.LocationId = locationArgument.ID().String()
	return nil
}

func (profile *Profile) Location(db data.DB) (*Location, error) {
	if profile.LocationId == "" {
		return nil, ErrEmptyLink
	}

	locationArgument := NewLocation()
	id, _ := db.ParseID(profile.LocationId)
	locationArgument.SetID(id)
	return locationArgument, db.PopulateByID(locationArgument)

}

func (profile *Profile) LocationOrCreate(db data.DB) (*Location, error) {
	location, err := profile.Location(db)

	if err == ErrEmptyLink {
		location := NewLocation()
		location.SetID(db.NewID())
		if err := profile.SetLocation(location); err != nil {
			return nil, err
		}

		if err := db.Save(location); err != nil {
			return nil, err
		}

		if err := db.Save(profile); err != nil {
			return nil, err
		}

		return location, nil
	} else {
		return location, err
	}
}

func (profile *Profile) SetOntology(ontologyArgument *Ontology) error {
	profile.OntologyId = ontologyArgument.ID().String()
	return nil
}

func (profile *Profile) Ontology(db data.DB) (*Ontology, error) {
	if profile.OntologyId == "" {
		return nil, ErrEmptyLink
	}

	ontologyArgument := NewOntology()
	id, _ := db.ParseID(profile.OntologyId)
	ontologyArgument.SetID(id)
	return ontologyArgument, db.PopulateByID(ontologyArgument)

}

func (profile *Profile) OntologyOrCreate(db data.DB) (*Ontology, error) {
	ontology, err := profile.Ontology(db)

	if err == ErrEmptyLink {
		ontology := NewOntology()
		ontology.SetID(db.NewID())
		if err := profile.SetOntology(ontology); err != nil {
			return nil, err
		}

		if err := db.Save(ontology); err != nil {
			return nil, err
		}

		if err := db.Save(profile); err != nil {
			return nil, err
		}

		return ontology, nil
	} else {
		return ontology, err
	}
}

func (profile *Profile) SetOwner(userArgument *User) error {
	profile.OwnerId = userArgument.ID().String()
	return nil
}

func (profile *Profile) Owner(db data.DB) (*User, error) {
	if profile.OwnerId == "" {
		return nil, ErrEmptyLink
	}

	userArgument := NewUser()
	id, _ := db.ParseID(profile.OwnerId)
	userArgument.SetID(id)
	return userArgument, db.PopulateByID(userArgument)

}

func (profile *Profile) OwnerOrCreate(db data.DB) (*User, error) {
	user, err := profile.Owner(db)

	if err == ErrEmptyLink {
		user := NewUser()
		user.SetID(db.NewID())
		if err := profile.SetOwner(user); err != nil {
			return nil, err
		}

		if err := db.Save(user); err != nil {
			return nil, err
		}

		if err := db.Save(profile); err != nil {
			return nil, err
		}

		return user, nil
	} else {
		return user, err
	}
}

func (profile *Profile) IncludeRoutine(routine *Routine) {
	otherID := routine.ID().String()
	for i := range profile.RoutinesIds {
		if profile.RoutinesIds[i] == otherID {
			return
		}
	}
	profile.RoutinesIds = append(profile.RoutinesIds, otherID)
}

func (profile *Profile) ExcludeRoutine(routine *Routine) {
	tmp := make([]string, 0)
	id := routine.ID().String()
	for _, s := range profile.RoutinesIds {
		if s != id {
			tmp = append(tmp, s)
		}
	}
	profile.RoutinesIds = tmp
}

func (profile *Profile) RoutinesIter(db data.DB) (data.Iterator, error) {
	// not yet completely general
	return mongo.NewIDIter(mongo.NewIDSetFromStrings(profile.RoutinesIds), db), nil
}

func (profile *Profile) Routines(db data.DB) (routines []*Routine, err error) {
	routines = make([]*Routine, len(profile.RoutinesIds))
	routine := NewRoutine()
	for i, id := range profile.RoutinesIds {
		routine.Id = id
		if err = db.PopulateByID(routine); err != nil {
			return
		}

		routines[i] = routine
		routine = NewRoutine()
	}

	return
}

func (profile *Profile) IncludeTask(task *Task) {
	otherID := task.ID().String()
	for i := range profile.TasksIds {
		if profile.TasksIds[i] == otherID {
			return
		}
	}
	profile.TasksIds = append(profile.TasksIds, otherID)
}

func (profile *Profile) ExcludeTask(task *Task) {
	tmp := make([]string, 0)
	id := task.ID().String()
	for _, s := range profile.TasksIds {
		if s != id {
			tmp = append(tmp, s)
		}
	}
	profile.TasksIds = tmp
}

func (profile *Profile) TasksIter(db data.DB) (data.Iterator, error) {
	// not yet completely general
	return mongo.NewIDIter(mongo.NewIDSetFromStrings(profile.TasksIds), db), nil
}

func (profile *Profile) Tasks(db data.DB) (tasks []*Task, err error) {
	tasks = make([]*Task, len(profile.TasksIds))
	task := NewTask()
	for i, id := range profile.TasksIds {
		task.Id = id
		if err = db.PopulateByID(task); err != nil {
			return
		}

		tasks[i] = task
		task = NewTask()
	}

	return
}

// BSON {{{
func (profile *Profile) GetBSON() (interface{}, error) {

	return struct {
		CreatedAt time.Time `json:"created_at" bson:"created_at"`

		DeletedAt time.Time `json:"deleted_at" bson:"deleted_at"`

		Email string `json:"email" bson:"email"`

		Id string `json:"id" bson:"_id,omitempty"`

		Name string `json:"name" bson:"name"`

		Phone string `json:"phone" bson:"phone"`

		UpdatedAt time.Time `json:"updated_at" bson:"updated_at"`

		ActionsIds []string `json:"actions_ids" bson:"actions_ids"`

		CalendarId string `json:"calendar_id" bson:"calendar_id"`

		CurrentActionId string `json:"current_action_id" bson:"current_action_id"`

		CurrentActionableId string `json:"current_actionable_id" bson:"current_actionable_id"`

		CurrentActionableKind string `json:"current_actionable_kind" bson:"current_actionable_kind"`

		DataIds []string `json:"data_ids" bson:"data_ids"`

		EventsIds []string `json:"events_ids" bson:"events_ids"`

		LocationId string `json:"location_id" bson:"location_id"`

		OntologyId string `json:"ontology_id" bson:"ontology_id"`

		OwnerId string `json:"owner_id" bson:"owner_id"`

		RoutinesIds []string `json:"routines_ids" bson:"routines_ids"`

		TasksIds []string `json:"tasks_ids" bson:"tasks_ids"`
	}{

		CreatedAt: profile.CreatedAt,

		DeletedAt: profile.DeletedAt,

		Email: profile.Email,

		Name: profile.Name,

		Phone: profile.Phone,

		UpdatedAt: profile.UpdatedAt,

		ActionsIds: profile.ActionsIds,

		CalendarId: profile.CalendarId,

		CurrentActionId: profile.CurrentActionId,

		CurrentActionableId: profile.CurrentActionableId,

		CurrentActionableKind: profile.CurrentActionableKind,

		DataIds: profile.DataIds,

		EventsIds: profile.EventsIds,

		LocationId: profile.LocationId,

		OntologyId: profile.OntologyId,

		OwnerId: profile.OwnerId,

		RoutinesIds: profile.RoutinesIds,

		TasksIds: profile.TasksIds,
	}, nil

}

func (profile *Profile) SetBSON(raw bson.Raw) error {

	tmp := struct {
		CreatedAt time.Time `json:"created_at" bson:"created_at"`

		DeletedAt time.Time `json:"deleted_at" bson:"deleted_at"`

		Email string `json:"email" bson:"email"`

		Id bson.ObjectId `json:"id" bson:"_id,omitempty"`

		Name string `json:"name" bson:"name"`

		Phone string `json:"phone" bson:"phone"`

		UpdatedAt time.Time `json:"updated_at" bson:"updated_at"`

		ActionsIds []string `json:"actions_ids" bson:"actions_ids"`

		CalendarId string `json:"calendar_id" bson:"calendar_id"`

		CurrentActionId string `json:"current_action_id" bson:"current_action_id"`

		CurrentActionableId string `json:"current_actionable_id" bson:"current_actionable_id"`

		CurrentActionableKind string `json:"current_actionable_kind" bson:"current_actionable_kind"`

		DataIds []string `json:"data_ids" bson:"data_ids"`

		EventsIds []string `json:"events_ids" bson:"events_ids"`

		LocationId string `json:"location_id" bson:"location_id"`

		OntologyId string `json:"ontology_id" bson:"ontology_id"`

		OwnerId string `json:"owner_id" bson:"owner_id"`

		RoutinesIds []string `json:"routines_ids" bson:"routines_ids"`

		TasksIds []string `json:"tasks_ids" bson:"tasks_ids"`
	}{}

	err := raw.Unmarshal(&tmp)
	if err != nil {
		return err
	}

	profile.CreatedAt = tmp.CreatedAt

	profile.DeletedAt = tmp.DeletedAt

	profile.Email = tmp.Email

	profile.Id = tmp.Id.Hex()

	profile.Name = tmp.Name

	profile.Phone = tmp.Phone

	profile.UpdatedAt = tmp.UpdatedAt

	profile.ActionsIds = tmp.ActionsIds

	profile.CalendarId = tmp.CalendarId

	profile.CurrentActionId = tmp.CurrentActionId

	profile.CurrentActionableId = tmp.CurrentActionableId

	profile.CurrentActionableKind = tmp.CurrentActionableKind

	profile.DataIds = tmp.DataIds

	profile.EventsIds = tmp.EventsIds

	profile.LocationId = tmp.LocationId

	profile.OntologyId = tmp.OntologyId

	profile.OwnerId = tmp.OwnerId

	profile.RoutinesIds = tmp.RoutinesIds

	profile.TasksIds = tmp.TasksIds

	return nil

}

// BSON }}}

func (profile *Profile) FromStructure(structure map[string]interface{}) {

	if val, ok := structure["id"]; ok {
		profile.Id = val.(string)
	}

	if val, ok := structure["created_at"]; ok {
		profile.CreatedAt = val.(time.Time)
	}

	if val, ok := structure["updated_at"]; ok {
		profile.UpdatedAt = val.(time.Time)
	}

	if val, ok := structure["deleted_at"]; ok {
		profile.DeletedAt = val.(time.Time)
	}

	if val, ok := structure["name"]; ok {
		profile.Name = val.(string)
	}

	if val, ok := structure["phone"]; ok {
		profile.Phone = val.(string)
	}

	if val, ok := structure["email"]; ok {
		profile.Email = val.(string)
	}

	if val, ok := structure["events_ids"]; ok {
		profile.EventsIds = val.([]string)
	}

	if val, ok := structure["current_action_id"]; ok {
		profile.CurrentActionId = val.(string)
	}

	if val, ok := structure["calendar_id"]; ok {
		profile.CalendarId = val.(string)
	}

	if val, ok := structure["owner_id"]; ok {
		profile.OwnerId = val.(string)
	}

	if val, ok := structure["data_ids"]; ok {
		profile.DataIds = val.([]string)
	}

	if val, ok := structure["actions_ids"]; ok {
		profile.ActionsIds = val.([]string)
	}

	if val, ok := structure["tasks_ids"]; ok {
		profile.TasksIds = val.([]string)
	}

	if val, ok := structure["routines_ids"]; ok {
		profile.RoutinesIds = val.([]string)
	}

	if val, ok := structure["ontology_id"]; ok {
		profile.OntologyId = val.(string)
	}

	if val, ok := structure["current_actionable_id"]; ok {
		profile.CurrentActionableId = val.(string)
	}

	if val, ok := structure["current_actionable_kind"]; ok {
		profile.CurrentActionableKind = val.(string)
	}

	if val, ok := structure["location_id"]; ok {
		profile.LocationId = val.(string)
	}

}

var ProfileStructure = map[string]metis.Primitive{

	"name": 3,

	"phone": 3,

	"email": 3,

	"id": 9,

	"created_at": 4,

	"updated_at": 4,

	"deleted_at": 4,

	"tasks_ids": 10,

	"routines_ids": 10,

	"ontology_id": 9,

	"current_actionable_id": 9,

	"current_actionable_kind": 3,

	"calendar_id": 9,

	"owner_id": 9,

	"data_ids": 10,

	"actions_ids": 10,

	"location_id": 9,

	"events_ids": 10,

	"current_action_id": 9,
}