ui/go/ui/gcd.go

package ui

import (
	"cwtch.im/cwtch/app"
	"cwtch.im/cwtch/event"
	"cwtch.im/cwtch/model"
	"cwtch.im/cwtch/model/attr"
	"cwtch.im/cwtch/protocol/connections"
	"cwtch.im/ui/go/constants"
	"github.com/therecipe/qt/qml"
	"sync"

	"cwtch.im/ui/go/the"
	"encoding/base32"
	"git.openprivacy.ca/openprivacy/log"
	"github.com/therecipe/qt/core"
	"strings"
	"time"
)

type GrandCentralDispatcher struct {
	core.QObject

	QMLEngine                    *qml.QQmlApplicationEngine
	Translator, OpaqueTranslator *core.QTranslator

	uIManagers map[string]Manager // profile-onion : Manager

	GlobalSettings *GlobalSettings

	profileLock      sync.Mutex
	conversationLock sync.Mutex

	m_selectedProfile      string
	m_selectedConversation string

	_ string  `property:"os"`
	_ float32 `property:"themeScale,auto,changed"`
	_ string  `property:"theme,auto,changed`
	_ string  `property:"locale,auto,changed"`
	_ string  `property:"version"`
	_ string  `property:"buildDate"`
	_ string  `property:"assetPath"`
	_ string  `property:"selectedProfile,auto"`
	_ string  `property:"selectedConversation,auto"`

	// profile management stuff
	_ func()                                       `signal:"Loaded"`
	_ func(handle, displayname, image, tag string) `signal:"AddProfile"`
	_ func()                                       `signal:"ErrorLoaded0"`
	_ func()                                       `signal:"ResetProfile"`
	_ func()                                       `signal:"ResetProfileList"`
	_ func(failed bool)                            `signal:"ChangePasswordResponse"`

	// contact list stuff
	_ func(handle, displayName, image string, badge, status int, authorization string, loading bool, lastMsgTime int) `signal:"AddContact"`
	_ func(handle, displayName string)                                                                                `signal:"UpdateContactDisplayName"`
	_ func(handle, image string)                                                                                      `signal:"UpdateContactPicture"`
	_ func(handle string, status int, loading bool)                                                                   `signal:"UpdateContactStatus"`
	_ func(handle string)                                                                                             `signal:"IncContactUnreadCount"`
	_ func(handle string)                                                                                             `signal:"RemoveContact"`
	_ func(handle, key, value string)                                                                                 `signal:"UpdateContactAttribute"`

	// messages pane stuff
	_ func(handle, from, displayName, message, image string, mID string, fromMe bool, ts string, ackd bool, error bool) `signal:"AppendMessage"`
	_ func(handle, from, displayName, message, image string, mID string, fromMe bool, ts string, ackd bool, error bool) `signal:"PrependMessage"`
	_ func()                                                                                                            `signal:"ClearMessages"`
	_ func()                                                                                                            `signal:"ResetMessagePane"`
	_ func(mID string)                                                                                                  `signal:"Acknowledged"`
	_ func(title string)                                                                                                `signal:"SetToolbarTitle"`
	_ func(signature string, err string)                                                                                `signal:"GroupSendError"`
	_ func(loading bool)                                                                                                `signal:"SetLoadingState"`

	// profile-area stuff
	_ func(name, onion, image, tag, showBlocked string) `signal:"UpdateMyProfile"`
	_ func(status int)                                  `signal:"TorStatus"`

	// settings helpers
	_ func(str string)                                                                                     `signal:"InvokePopup"`
	_ func(locale string, zoom float32, theme string)                                                      `signal:"SupplySettings"`
	_ func(groupID, name, server, invitation string, accepted bool, addrbooknames, addrbookaddrs []string) `signal:"SupplyGroupSettings"`
	_ func(onion, nick string, authorization string)                                                       `signal:"SupplyPeerSettings"`

	// signals emitted from the ui (written in go, below)
	// ui
	_ func() `signal:"onActivate,auto"`
	// profile managemenet
	_ func(onion, nick string)                                           `signal:"updateNick,auto"`
	_ func(handle string)                                                `signal:"loadProfile,auto"`
	_ func(nick string, defaultPass bool, password string)               `signal:"createProfile,auto"`
	_ func(password string)                                              `signal:"unlockProfiles,auto"`
	_ func()                                                             `signal:"reloadProfileList,auto"`
	_ func(onion string)                                                 `signal:"deleteProfile,auto"`
	_ func(onion, currentPassword, newPassword string, defaultPass bool) `signal:"changePassword,auto""`
	_ func(key, val string)                                              `signal:"storeSetting,auto"`
	// operating a profile
	_ func(message string, mid string) `signal:"sendMessage,auto"`
	_ func(onion string, auth string)  `signal:"setPeerAuthorization,auto"`
	_ func(onion string)               `signal:"loadMessagesPane,auto"`
	_ func(signal string)              `signal:"broadcast,auto"` // convenience relay signal
	_ func(str string)                 `signal:"importString,auto"`
	_ func(str string)                 `signal:"createContact,auto"`
	_ func(str string)                 `signal:"popup,auto"`
	_ func(server, groupName string)   `signal:"createGroup,auto"`
	_ func(groupID string)             `signal:"leaveGroup,auto"`
	_ func(groupID string)             `signal:"acceptGroup,auto"`
	_ func()                           `signal:"requestSettings,auto"`
	_ func(groupID string)             `signal:"requestGroupSettings,auto"`
	_ func(groupID, nick string)       `signal:"saveGroupSettings,auto"`
	_ func()                           `signal:"requestPeerSettings,auto"`
	_ func(onion, nick string)         `signal:"savePeerSettings,auto"`
	_ func(onion, groupID string)      `signal:"inviteToGroup,auto"`
	_ func(onion string)               `signal:"deleteContact,auto"`
	_ func()                           `signal:"allowUnknownPeers,auto"`
	_ func()                           `signal:"blockUnknownPeers,auto"`

	_ func() `constructor:"init"`
}

func (this *GrandCentralDispatcher) init() {
	this.uIManagers = make(map[string]Manager)
	this.GlobalSettings = ReadGlobalSettings()
	this.SetThemeScale(this.GlobalSettings.Zoom)
	this.SetTheme(this.GlobalSettings.Theme)
}

// GetUiManager gets (and creates if required) a ui Manager for the supplied profile id
func (this *GrandCentralDispatcher) GetUiManager(profile string) Manager {
	this.profileLock.Lock()
	defer this.profileLock.Unlock()

	if manager, exists := this.uIManagers[profile]; exists {
		return manager
	} else {
		this.uIManagers[profile] = NewManager(profile, this)
		return this.uIManagers[profile]
	}
}

func (this *GrandCentralDispatcher) selectedProfile() string {
	this.profileLock.Lock()
	defer this.profileLock.Unlock()

	return this.m_selectedProfile
}

func (this *GrandCentralDispatcher) setSelectedProfile(onion string) {
	this.profileLock.Lock()
	defer this.profileLock.Unlock()

	this.m_selectedProfile = onion
}

func (this *GrandCentralDispatcher) selectedProfileChanged(onion string) {
	this.SelectedProfileChanged(onion)
}

// DoIfProfile performs a gcd action for a profile IF it is the currently selected profile in the UI
// otherwise it does nothing. it also locks profile switching for the duration of the action
func (this *GrandCentralDispatcher) DoIfProfile(profile string, fn func()) {
	this.profileLock.Lock()
	defer this.profileLock.Unlock()

	if this.m_selectedProfile == profile {
		fn()
	}
}

func (this *GrandCentralDispatcher) selectedConversation() string {
	this.conversationLock.Lock()
	defer this.conversationLock.Unlock()

	return this.m_selectedConversation
}

func (this *GrandCentralDispatcher) setSelectedConversation(handle string) {
	this.conversationLock.Lock()
	defer this.conversationLock.Unlock()

	this.m_selectedConversation = handle
}

func (this *GrandCentralDispatcher) selectedConversationChanged(handle string) {
	this.SelectedConversationChanged(handle)
}

// DoIfConversation performs a gcd action for a conversation IF it is the currently selected conversation in the UI
// otherwise it does nothing. it also locks conversation switching for the duration of the action
func (this *GrandCentralDispatcher) DoIfConversation(conversation string, fn func()) {
	this.conversationLock.Lock()
	defer this.conversationLock.Unlock()

	if this.m_selectedConversation == conversation {
		fn()
	}
}

func (this *GrandCentralDispatcher) sendMessage(message string, mID string) {
	if len(message) > 65530 {
		this.InvokePopup("message is too long")
		return
	}

	if this.SelectedConversation() == "" {
		this.InvokePopup("ui error")
		return
	}

	if isGroup(this.SelectedConversation()) {
		if !the.Peer.GetGroup(this.SelectedConversation()).Accepted {
			err := the.Peer.AcceptInvite(this.SelectedConversation())
			if err != nil {
				log.Errorf("tried to mark a nonexistent group as existed. bad!")
				return
			}
		}

		var err error
		mID, err = the.Peer.SendMessageToGroupTracked(this.SelectedConversation(), message)

		this.GetUiManager(this.selectedProfile()).AddMessage(this.SelectedConversation(), "me", message, true, mID, time.Now(), false)

		if err != nil {
			this.InvokePopup("failed to send message " + err.Error())
			return
		}
	} else {
		to := this.SelectedConversation()
		mID = the.Peer.SendMessageToPeer(to, message)

		this.GetUiManager(this.selectedProfile()).AddMessage(to, "me", message, true, mID, time.Now(), false)
	}

}

func (this *GrandCentralDispatcher) loadMessagesPane(handle string) {
	go this.loadMessagesPaneHelper(handle)
}

func (this *GrandCentralDispatcher) loadMessagesPaneHelper(handle string) {
	if handle == the.Peer.GetOnion() {
		return
	}
	this.ClearMessages()
	this.SetSelectedConversation(handle)

	if isGroup(handle) { // LOAD GROUP
		group := the.Peer.GetGroup(handle)

		loading := false
		state := connections.ConnectionStateToType[group.State]
		if state == connections.AUTHENTICATED {
			loading = true
		}
		this.UpdateContactStatus(group.GroupID, int(state), loading)

		tl := group.GetTimeline()
		nick := getNick(handle)
		updateLastReadTime(group.GroupID)
		if nick == "" {
			this.SetToolbarTitle(handle)
		} else {
			this.SetToolbarTitle(nick)
		}

		for i := len(tl) - 1; i >= 0; i-- {
			if tl[i].PeerID == the.Peer.GetOnion() {
				handle = "me"
			} else {
				handle = tl[i].PeerID
			}

			name := getNick(tl[i].PeerID)
			image := getProfilePic(tl[i].PeerID)

			this.PrependMessage(
				handle,
				tl[i].PeerID,
				name,
				tl[i].Message,
				image,
				string(tl[i].Signature),
				tl[i].PeerID == the.Peer.GetOnion(),
				tl[i].Timestamp.Format(constants.TIME_FORMAT),
				tl[i].Received.Equal(time.Unix(0, 0)) == false, // If the received timestamp is epoch, we have not yet received this message through an active server
				false,
			)
		}
		return
	} // ELSE LOAD CONTACT

	contact := the.Peer.GetContact(handle)

	this.UpdateContactStatus(handle, int(connections.ConnectionStateToType[contact.State]), false)

	var nick string
	if contact != nil {
		nick = getNick(contact.Onion)
	}
	updateLastReadTime(contact.Onion)
	this.SetToolbarTitle(nick)

	peer := the.Peer.GetContact(handle)
	messages := peer.Timeline.GetMessages()
	for i := range messages {
		from := messages[i].PeerID
		fromMe := messages[i].PeerID == the.Peer.GetOnion()
		if fromMe {
			from = "me"
		}

		displayname := getNick(messages[i].PeerID)
		image := getProfilePic(messages[i].PeerID)

		this.AppendMessage(
			from,
			messages[i].PeerID,
			displayname,
			messages[i].Message,
			image,
			string(messages[i].Signature),
			fromMe,
			messages[i].Timestamp.Format(constants.TIME_FORMAT),
			messages[i].Acknowledged,
			messages[i].Error != "",
		)
	}
}

func (this *GrandCentralDispatcher) requestSettings() {
	this.SupplySettings(this.GlobalSettings.Locale, this.GlobalSettings.Zoom, this.GlobalSettings.Theme)
}

func (this *GrandCentralDispatcher) saveSettings(zoom, locale string) {

}

func (this *GrandCentralDispatcher) requestPeerSettings() {
	contact := the.Peer.GetContact(this.SelectedConversation())
	if contact == nil {
		log.Errorf("error: requested settings for unknown contact %v?", this.SelectedConversation())
		this.SupplyPeerSettings(this.SelectedConversation(), this.SelectedConversation(), string(contact.Authorization))
		return
	}

	name := getNick(contact.Onion)

	// Todo: Move to profile settings
	//blockunkownpeers, _ := the.Peer.GetAttribute(attr.GetPeerScope(constants.BlockUnknownPeersSetting))

	this.SupplyPeerSettings(contact.Onion, name, string(contact.Authorization))
}

func (this *GrandCentralDispatcher) savePeerSettings(onion, nick string) {
	the.Peer.SetContactAttribute(onion, attr.GetLocalScope(constants.Name), nick)
	this.UpdateContactDisplayName(onion, nick)
}

func (this *GrandCentralDispatcher) requestGroupSettings(groupID string) {
	group := the.Peer.GetGroup(groupID)

	if group == nil {
		log.Errorf("couldn't find group %v", groupID)
		return
	}

	nick := getNick(groupID)
	invite, _ := the.Peer.ExportGroup(groupID)

	contactaddrs := the.Peer.GetContacts()
	contactnames := make([]string, len(contactaddrs))
	for i, contact := range contactaddrs {
		contactnames[i] = getNick(contact)

	}

	this.SupplyGroupSettings(group.GroupID, nick, group.GroupServer, invite, group.Accepted, contactnames, contactaddrs)
}

func (this *GrandCentralDispatcher) saveGroupSettings(groupID, nick string) {
	the.Peer.SetGroupAttribute(groupID, attr.GetLocalScope(constants.Name), nick)
	this.UpdateContactDisplayName(groupID, nick)
}

func (this *GrandCentralDispatcher) broadcast(signal string) {
	switch signal {
	default:
		log.Debugf("unhandled broadcast signal: %v", signal)
	case "ResetMessagePane":
		this.ResetMessagePane()
	case "ResetProfile":
		this.ResetProfile()
	}
}

func (this *GrandCentralDispatcher) createContact(onion string) {
	if contact := the.Peer.GetContact(onion); contact != nil {
		return
	}
	the.Peer.AddContact(onion, onion, model.AuthApproved)
	the.Peer.PeerWithOnion(onion)
}

func (this *GrandCentralDispatcher) importString(str string) {
	if len(str) < 5 {
		log.Debugf("ignoring short string")
		return
	}

	log.Debugf("importing: %s\n", str)
	onion := str
	name := onion
	str = strings.TrimSpace(str)

	//eg: torv3JFDWkXExBsZLkjvfkkuAxHsiLGZBk0bvoeJID9ItYnU=EsEBCiBhOWJhZDU1OTQ0NWI3YmM2N2YxYTM5YjkzMTNmNTczNRIgpHeNaG+6jy750eDhwLO39UX4f2xs0irK/M3P6mDSYQIaOTJjM2ttb29ibnlnaGoyenc2cHd2N2Q1N3l6bGQ3NTNhdW8zdWdhdWV6enB2ZmFrM2FoYzRiZHlkCiJAdVSSVgsksceIfHe41OJu9ZFHO8Kwv3G6F5OK3Hw4qZ6hn6SiZjtmJlJezoBH0voZlCahOU7jCOg+dsENndZxAA==
	if str[0:5] == "torv3" { // GROUP INVITE
		err := the.Peer.ImportGroup(str)
		if err != nil {
			this.InvokePopup("not a valid group invite")
			return
		}
		return
	}

	if strings.Contains(str, " ") { // usually people prepend spaces and we don't want it going into the name (use ~ for that)
		parts := strings.Split(strings.TrimSpace(str), " ")
		str = parts[len(parts)-1]
	}

	if strings.Contains(str, "~") {
		parts := strings.Split(str, "~")
		onion = parts[len(parts)-1]
		name = strings.Join(parts[:len(parts)-1], " ")
	}

	if len(onion) != 56 {
		this.InvokePopup("invalid format")
		return
	}

	name = strings.TrimSpace(name)
	if name == "" {
		this.InvokePopup("empty name")
		return
	}

	if len(name) > 32 {
		name = name[:32] //TODO: better strategy for long names?
	}

	_, err := base32.StdEncoding.DecodeString(strings.ToUpper(onion[:56]))
	if err != nil {
		log.Debugln(err)
		this.InvokePopup("bad format. missing handlers?")
		return
	}

	checkc := the.Peer.GetContact(onion)
	if checkc != nil {
		this.InvokePopup("already have this contact")
		return //TODO: bring them to the duplicate
	} else {
		the.Peer.AddContact(name, onion, model.AuthApproved)
		the.Peer.PeerWithOnion(onion)
	}

	this.GetUiManager(this.selectedProfile()).AddContact(onion)
}

func (this *GrandCentralDispatcher) popup(str string) {
	this.InvokePopup(str)
}

func (this *GrandCentralDispatcher) updateNick(onion, nick string) {
	p := the.CwtchApp.GetPeer(onion)
	if p != nil {
		p.SetName(nick)
		p.SetAttribute(attr.GetPublicScope(constants.Name), nick)
		the.CwtchApp.GetEventBus(onion).Publish(event.NewEvent(event.SetProfileName, map[event.Field]string{
			event.ProfileName: nick,
		}))
	}
}

func (this *GrandCentralDispatcher) createGroup(server, groupName string) {
	groupID, _, err := the.Peer.StartGroup(server)
	if err != nil {
		this.popup("group creation failed :(")
		return
	}

	this.GetUiManager(this.selectedProfile()).AddContact(groupID)

	the.Peer.SetGroupAttribute(groupID, attr.GetLocalScope(constants.Name), groupName)

	the.Peer.JoinServer(server)
}

func (this *GrandCentralDispatcher) setPeerAuthorization(onion string, authorization string) {
	log.Debugf("Setting peer auth level to %v for %v\n", authorization, onion)
	err := the.Peer.SetContactAuthorization(onion, model.Authorization(authorization))
	if err != nil {
		log.Errorf("Could not set peer authorization %v to %v\n", onion, authorization)
		return
	}
	this.RemoveContact(onion)
	this.GetUiManager(this.selectedProfile()).AddContact(onion)
	if model.Authorization(authorization) == model.AuthApproved {
		the.Peer.PeerWithOnion(onion)
	}
}

func (this *GrandCentralDispatcher) inviteToGroup(onion, groupID string) {
	err := the.Peer.InviteOnionToGroup(onion, groupID)
	if err != nil {
		log.Errorf("inviting %v to %v: %v", onion, groupID, err)
	}
}

func (this *GrandCentralDispatcher) leaveGroup(groupID string) {
	the.Peer.DeleteGroup(groupID)
	this.RemoveContact(groupID)
}

func (this *GrandCentralDispatcher) deleteContact(onion string) {
	the.Peer.DeleteContact(onion)
	this.RemoveContact(onion)
}

func (this *GrandCentralDispatcher) acceptGroup(groupID string) {
	if the.Peer.GetGroup(groupID) != nil {
		the.Peer.AcceptInvite(groupID)
	}
}

func (this *GrandCentralDispatcher) blockUnknownPeers() {
	the.Peer.SetAttribute(attr.GetSettingsScope(constants.BlockUnknownPeersSetting), "true")
	the.EventBus.Publish(event.NewEvent(event.BlockUnknownPeers, map[event.Field]string{}))
}

func (this *GrandCentralDispatcher) allowUnknownPeers() {
	the.Peer.SetAttribute(attr.GetSettingsScope(constants.BlockUnknownPeersSetting), "false")
	the.EventBus.Publish(event.NewEvent(event.AllowUnknownPeers, map[event.Field]string{}))
}

func (this *GrandCentralDispatcher) localeChanged(locale string) {
	this.GlobalSettings.Locale = locale
	WriteGlobalSettings(this.GlobalSettings)
	this.setLocaleHelper(locale)
}

func (this *GrandCentralDispatcher) setLocaleHelper(locale string) {
	log.Debugf("Loading translators for '%v'\n", locale)
	newTranslator := core.NewQTranslator(nil)
	success := newTranslator.Load("translation_"+locale, ":/i18n/", "", "")
	if success {
		core.QCoreApplication_RemoveTranslator(this.Translator)
		this.Translator = newTranslator
		core.QCoreApplication_InstallTranslator(this.Translator)
	} else {
		log.Errorf("Could not load translator for '%v'\n", locale)
	}

	newOpaqueTranslator := core.NewQTranslator(nil)
	success = newOpaqueTranslator.Load("translation_"+locale, ":/qml/opaque/i18n/", "", "")
	if success {
		core.QCoreApplication_RemoveTranslator(this.OpaqueTranslator)
		this.OpaqueTranslator = newOpaqueTranslator
		core.QCoreApplication_InstallTranslator(this.OpaqueTranslator)
	} else {
		log.Errorf("Could not load opaque translator for '%v'\n", locale)
	}

	this.QMLEngine.Retranslate()
}

func (this *GrandCentralDispatcher) themeScaleChanged(newThemeScale float32) {
	// TODO: solve why themeScale > 2.0 halts app launch - related task - solve all the qml launch warnings around anchors/layouts
	if this.Os() != "android" {
		if newThemeScale > 1.99 {
			this.SetThemeScale(1.99)
		}
	}
	this.GlobalSettings.Zoom = newThemeScale
	WriteGlobalSettings(this.GlobalSettings)
}

func (this *GrandCentralDispatcher) themeChanged(newTheme string) {
	this.GlobalSettings.Theme = newTheme
	WriteGlobalSettings(this.GlobalSettings)
}

func (this *GrandCentralDispatcher) onActivate() {
	log.Debugln("onActivate")
	if the.CwtchApp != nil {
		go the.CwtchApp.QueryACNStatus()
	}
}

func (this *GrandCentralDispatcher) unlockProfiles(password string) {
	the.CwtchApp.LoadProfiles(password)
}

func (this *GrandCentralDispatcher) loadProfile(onion string) {
	the.Peer = the.CwtchApp.GetPeer(onion)
	if the.Peer == nil {
		return
	}
	the.EventBus = the.CwtchApp.GetEventBus(onion)

	picVal, exists := the.Peer.GetAttribute(attr.GetPublicScope(constants.Picture))
	if !exists {
		picVal = ImageToString(NewImage(RandomProfileImage(onion), TypeImageDistro))
		the.Peer.SetAttribute(attr.GetPublicScope(constants.Picture), picVal)
	}
	pic, err := StringToImage(picVal)
	if err != nil {
		pic = NewImage(RandomProfileImage(onion), TypeImageDistro)
		the.Peer.SetAttribute(attr.GetPublicScope(constants.Picture), ImageToString(pic))
	}
	tag, _ := the.Peer.GetAttribute(app.AttributeTag)
	showBlocked, exists := the.Peer.GetAttribute(attr.GetSettingsScope(constants.ShowBlocked))
	if !exists {
		showBlocked = "false"
		the.Peer.SetAttribute(attr.GetSettingsScope(constants.ShowBlocked), showBlocked)
	}
	this.UpdateMyProfile(the.Peer.GetName(), the.Peer.GetOnion(), getPicturePath(pic), tag, showBlocked)

	contacts := the.Peer.GetContacts()
	for i := range contacts {
		this.GetUiManager(this.selectedProfile()).AddContact(contacts[i])
	}

	groups := the.Peer.GetGroups()
	for i := range groups {
		// Only join servers for active and explicitly accepted groups.
		this.GetUiManager(this.selectedProfile()).AddContact(groups[i])
	}
}

func (this *GrandCentralDispatcher) createProfile(nick string, defaultPass bool, password string) {
	if defaultPass {
		the.CwtchApp.CreateTaggedPeer(nick, the.AppPassword, constants.ProfileTypeV1DefaultPassword)
	} else {
		the.CwtchApp.CreateTaggedPeer(nick, password, constants.ProfileTypeV1Password)
	}
}

func (this *GrandCentralDispatcher) changePassword(onion, currentPassword, newPassword string, defaultPass bool) {
	tag, _ := the.CwtchApp.GetPeer(onion).GetAttribute(app.AttributeTag)

	if tag == constants.ProfileTypeV1DefaultPassword {
		currentPassword = the.AppPassword
	}

	if defaultPass {
		newPassword = the.AppPassword
	}

	the.CwtchApp.ChangePeerPassword(onion, currentPassword, newPassword)
}

func (this *GrandCentralDispatcher) storeSetting(key, val string) {
	the.Peer.SetAttribute(attr.GetSettingsScope(key), val)
}

func (this *GrandCentralDispatcher) reloadProfileList() {
	this.ResetProfileList()

	for onion, _ := range the.CwtchApp.ListPeers() {
		AddProfile(this, onion)
	}
}

func (this *GrandCentralDispatcher) deleteProfile(onion string) {
	log.Infof("deleteProfile %v\n", onion)
	the.CwtchApp.DeletePeer(onion)
}