func (gkDbCon *GkDbConDef) getMaxChatId() (int32, *gkerr.GkErrDef) {
var stmt *sql.Stmt
var maxId int32 = 0
var err error
stmt, err = gkDbCon.sqlDb.Prepare("select max(id) from chat_archives")
if err != nil {
return 0, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query()
if err != nil {
return 0, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
if rows.Next() {
err = rows.Scan(&maxId)
if err != nil {
return 0, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
}
return maxId, nil
}
// this assumes that the space is called xlink for
// xmlns:xlink="http://www.w3.org/1999/xlink"
func substituteOneAttributeId(idMap map[string]string, space string, name string, value string) (string, *gkerr.GkErrDef) {
var returnValue string = value
var ok bool
var gkErr *gkerr.GkErrDef
switch name {
case "style":
if space == "" {
var id string
id, gkErr = getFillIdOutOfStyle(value)
if gkErr != nil {
return "", gkErr
}
if id != "" {
var newId string
newId, ok = idMap[id]
if !ok {
gkErr = gkerr.GenGkErr("could not find id in idMap "+id, nil, ERROR_ID_INTERNAL_ID_MAP)
return "", gkErr
}
returnValue = strings.Replace(returnValue, "fill:url(#"+id+")", "fill:url(#"+newId+")", 1)
}
id, gkErr = getFilterIdOutOfStyle(value)
if gkErr != nil {
return "", gkErr
}
if id != "" {
var newId string
newId, ok = idMap[id]
if !ok {
gkErr = gkerr.GenGkErr("could not find id in idMap "+id, nil, ERROR_ID_INTERNAL_ID_MAP)
return "", gkErr
}
returnValue = strings.Replace(returnValue, "filter:url(#"+id+")", "filter:url(#"+newId+")", 1)
}
}
case "href":
if space == "xlink" {
var id string
var newId string
id, gkErr = getIdOutOfHref(value)
if gkErr != nil {
return "", gkErr
}
newId, ok = idMap[id]
if !ok {
gkErr = gkerr.GenGkErr("could not find id in idMap "+id, nil, ERROR_ID_INTERNAL_ID_MAP)
return "", gkErr
}
returnValue = strings.Replace(value, "#"+id, "#"+newId, 1)
}
}
return returnValue, nil
}
// no error return if row is not found
func (gkDbCon *GkDbConDef) GetContextUser(userName string) (*DbContextUserDef, bool, *gkerr.GkErrDef) {
var stmt *sql.Stmt
var err error
var dbContextUser *DbContextUserDef = new(DbContextUserDef)
var rowFound bool
stmt, err = gkDbCon.sqlDb.Prepare("select context_users.id, context_users.last_position_x, context_users.last_position_y, context_users.last_position_z, context_users.last_pod from users, context_users where users.id = context_users.id and users.user_name = $1")
if err != nil {
return nil, false, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query(userName)
if err != nil {
return nil, false, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
if rows.Next() {
err = rows.Scan(&dbContextUser.id, &dbContextUser.LastPositionX, &dbContextUser.LastPositionY, &dbContextUser.LastPositionZ, &dbContextUser.LastPod)
if err != nil {
return nil, false, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
rowFound = true
} else {
rowFound = false
}
return dbContextUser, rowFound, nil
}
func (gkDbCon *GkDbConDef) getNextChatArchivesId() (int32, *gkerr.GkErrDef) {
var stmt *sql.Stmt
var err error
stmt, err = gkDbCon.sqlDb.Prepare("select nextval('chat_archives_seq')")
if err != nil {
return 0, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query()
if err != nil {
return 0, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
var id int32
if rows.Next() {
err = rows.Scan(&id)
if err != nil {
return 0, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
} else {
return 0, gkerr.GenGkErr("select users", nil, ERROR_ID_NO_ROWS_FOUND)
}
return id, nil
}
func GetFileContents(fileName string) ([]byte, *gkerr.GkErrDef) {
var file *os.File
var err error
var gkErr *gkerr.GkErrDef
var data []byte = make([]byte, 0, 0)
file, err = os.Open(fileName)
if err != nil {
gkErr = gkerr.GenGkErr("os.Open file: "+fileName, err, ERROR_ID_OPEN_FILE)
return nil, gkErr
}
defer file.Close()
buf := make([]byte, 1024, 1024)
var readCount int
for {
readCount, err = file.Read(buf)
if readCount > 0 {
data = append(data, buf[0:readCount]...)
}
if err != nil {
if err == io.EOF {
break
}
gkErr = gkerr.GenGkErr("file.Read file: "+fileName, err, ERROR_ID_READ_FILE)
return nil, gkErr
}
}
return data, nil
}
func (gkDbCon *GkDbConDef) GetPodsList() ([]DbPodDef, *gkerr.GkErrDef) {
var stmt *sql.Stmt
var err error
var dbPodsList []DbPodDef = make([]DbPodDef, 0, 0)
stmt, err = gkDbCon.sqlDb.Prepare("select id, pod_title from pods")
if err != nil {
return nil, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query()
if err != nil {
return nil, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
for rows.Next() {
var dbPod DbPodDef
err = rows.Scan(&dbPod.Id, &dbPod.Title)
if err != nil {
return nil, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
dbPodsList = append(dbPodsList, dbPod)
}
return dbPodsList, nil
}
// return error if row not found
func (gkDbCon *GkDbConDef) GetUser(userName string) (*DbUserDef, *gkerr.GkErrDef) {
var stmt *sql.Stmt
var err error
var dbUser *DbUserDef = new(DbUserDef)
stmt, err = gkDbCon.sqlDb.Prepare("select id, user_name, password_hash, password_salt, email, account_creation_date, last_login_date from users where user_name = $1")
if err != nil {
return nil, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query(userName)
if err != nil {
return nil, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
if rows.Next() {
err = rows.Scan(&dbUser.id, &dbUser.UserName, &dbUser.PasswordHash, &dbUser.PasswordSalt, &dbUser.Email, &dbUser.accountCreationDate, &dbUser.lastLoginDate)
if err != nil {
return nil, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
} else {
return nil, gkerr.GenGkErr("select users", nil, ERROR_ID_NO_ROWS_FOUND)
}
return dbUser, nil
}
func (gkDbCon *GkDbConDef) AddNewUser(userName string, passwordHash string, passwordSalt string, email string) *gkerr.GkErrDef {
var stmt *sql.Stmt
var err error
var id int64
var gkErr *gkerr.GkErrDef
id, gkErr = gkDbCon.getNextUsersId()
if gkErr != nil {
return gkErr
}
stmt, err = gkDbCon.sqlDb.Prepare("insert into users (id, user_name, password_hash, password_salt, email, account_creation_date, last_login_date) values ($1, $2, $3, $4, $5, $6, $7)")
if err != nil {
return gkerr.GenGkErr("stmt.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var accountCreationDate time.Time = time.Now()
var lastLoginDate time.Time = time.Now()
_, err = stmt.Exec(id, userName, passwordHash, passwordSalt, email, accountCreationDate, lastLoginDate)
if err != nil {
if isUniqueViolation(err) {
return gkerr.GenGkErr("stmt.Exec unique violation", err, ERROR_ID_UNIQUE_VIOLATION)
}
return gkerr.GenGkErr("stmt.Exec"+getDatabaseErrorMessage(err), err, ERROR_ID_EXECUTE)
}
return nil
}
func rebuildSvg(node *nodeDef, buf io.Writer) *gkerr.GkErrDef {
var gkErr *gkerr.GkErrDef
var result []byte = make([]byte, 0, 128)
var err error
result = append(result, '<')
if node.nameSpace != "" {
result = append(result, []byte(node.nameSpace)...)
result = append(result, ':')
}
result = append(result, []byte(node.nameLocal)...)
for _, attribute := range node.attributeList {
result = append(result, ' ')
if attribute.nameSpace != "" {
if attribute.nameSpace == "http://www.w3.org/XML/1998/namespace" {
result = append(result, []byte("xml")...)
} else {
result = append(result, []byte(attribute.nameSpace)...)
}
result = append(result, ':')
}
result = append(result, []byte(fmt.Sprintf("%s=\"%s\"", attribute.nameLocal, escapeXML([]byte(attribute.value))))...)
}
result = append(result, '>')
_, err = buf.Write(result)
if err != nil {
gkErr = gkerr.GenGkErr("write fix svg results", err, ERROR_ID_WRITE_SVG)
return gkErr
}
for _, childNode := range node.childList {
gkErr = rebuildSvg(childNode, buf)
}
result = make([]byte, 0, 16)
if !isCharDataAllWhiteSpace(node.charData) {
result = append(result, node.charData...)
}
result = append(result, []byte("</")...)
if node.nameSpace != "" {
result = append(result, []byte(node.nameSpace)...)
result = append(result, ':')
}
result = append(result, []byte(node.nameLocal)...)
result = append(result, '>')
_, err = buf.Write(result)
if err != nil {
gkErr = gkerr.GenGkErr("write fix svg results", err, ERROR_ID_WRITE_SVG)
return gkErr
}
return nil
}
func SendEmail(address string, from string, toArray []string, subject string, message []byte) (string, *gkerr.GkErrDef) {
var err error
var conn *smtp.Client
var dataWriter io.WriteCloser
var gkErr *gkerr.GkErrDef
var sendId string
conn, err = smtp.Dial(address)
if err != nil {
gkErr = gkerr.GenGkErr("smtp.Dial", err, ERROR_ID_SMTP_DIAL)
return "", gkErr
}
conn.Mail(from)
for _, adr := range toArray {
conn.Rcpt(adr)
}
dataWriter, err = conn.Data()
if err != nil {
gkErr = gkerr.GenGkErr("conn.Data", err, ERROR_ID_SMTP_DATA)
return "", gkErr
}
defer dataWriter.Close()
buf := bytes.NewBufferString("From: " + from + "\nTo: " + toArray[0] + "\nSubject: " + subject + "\n")
_, err = buf.WriteTo(dataWriter)
if err != nil {
gkErr = gkerr.GenGkErr("buf.WriteTo", err, ERROR_ID_SMTP_WRITE)
return "", gkErr
}
buf = bytes.NewBufferString(string(message))
_, err = buf.WriteTo(dataWriter)
if err != nil {
gkErr = gkerr.GenGkErr("buf.WriteTo", err, ERROR_ID_SMTP_WRITE)
return "", gkErr
}
err = conn.Quit()
if err != nil {
localError := fmt.Sprintf("%v", err)
if strings.Index(localError, "Ok") != -1 &&
strings.Index(localError, "queued as") != -1 {
sendId = localError
} else {
gkErr = gkerr.GenGkErr("conn.Quit", err, ERROR_ID_SMTP_QUIT)
//gklog.LogTrace(fmt.Sprintf("smtp quit %T [%v] %v",err, err, gkErr))
return "", gkErr
}
}
return sendId, nil
}
func NewTemplate(templateDir string, templateName string) (*TemplateDef, *gkerr.GkErrDef) {
var gkTemplate *TemplateDef = new(TemplateDef)
gkTemplate.tmpl = template.New(templateName)
var file *os.File
var templateListFileName string
var err error
templateListFileName = templateDir + string(os.PathSeparator) + templateName + ".txt"
file, err = os.Open(templateListFileName)
if err != nil {
return nil, gkerr.GenGkErr("os.Open", err, ERROR_ID_OPEN_TEMPLATE_LIST)
}
defer file.Close()
var br *bufio.Reader
localFileNames := make([]string, 0, 0)
br = bufio.NewReader(file)
for {
var line string
line, err = br.ReadString('\n')
line = strings.Trim(line, "\r\n\t ")
if line != "" {
localFileNames = append(localFileNames, templateDir+string(os.PathSeparator)+line)
}
if err != nil {
if err == io.EOF {
break
}
return nil, gkerr.GenGkErr("br.ReadString", err, ERROR_ID_READ_TEMPLATE_LIST)
}
}
// localFileNames = make([]string, len(fileNames), len(fileNames))
// for i := 0; i < len(fileNames); i++ {
// localFileNames[i] = templateDir + string(os.PathSeparator) + fileNames[i] + ".html"
// }
gklog.LogTrace(fmt.Sprintf("localFileNames: %+v", localFileNames))
_, err = gkTemplate.tmpl.ParseFiles(localFileNames...)
if err != nil {
return nil, gkerr.GenGkErr("tmpl.ParseFiles", err, ERROR_ID_PARSE_FILES)
}
return gkTemplate, nil
}
// return error if row not found
// this could be improved by saving recent "id" values
func (gkDbCon *GkDbConDef) GetLastChatArchiveEntries(count int) ([]LugChatArchiveDef, *gkerr.GkErrDef) {
var stmt *sql.Stmt
var err error
var results []LugChatArchiveDef = make([]LugChatArchiveDef, 0, count)
var gkErr *gkerr.GkErrDef
var maxId int32
var startId int32 = 0
maxId, gkErr = gkDbCon.getMaxChatId()
if gkErr != nil {
return nil, gkErr
}
stmt, err = gkDbCon.sqlDb.Prepare("select chat_archives.message_creation_date, chat_archives.chat_message, users.user_name from users, chat_archives where users.id = chat_archives.user_id and chat_archives.id > $1 order by chat_archives.message_creation_date desc")
if err != nil {
return nil, gkerr.GenGkErr("sql.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
if maxId > 0 {
startId = maxId - (int32(count) + 20)
}
rows, err = stmt.Query(startId)
if err != nil {
return nil, gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
for rows.Next() {
var lugChatArchive LugChatArchiveDef
err = rows.Scan(&lugChatArchive.MessageCreationDate, &lugChatArchive.ChatMessage, &lugChatArchive.UserName)
if err != nil {
return nil, gkerr.GenGkErr("rows.Scan"+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
results = append(results, lugChatArchive)
if len(results) >= count {
break
}
}
return results, nil
}
func NewGkRandContext() *GkRandContextDef {
var gkRandContext *GkRandContextDef = new(GkRandContextDef)
var seed int64
var err error
var gkErr *gkerr.GkErrDef
seed = time.Now().UnixNano()
buf := make([]byte, 6, 6)
_, err = c_rand.Read(buf)
if err != nil {
// log the error
// but this error is not fatal
gkErr = gkerr.GenGkErr("c_rand.Read", err, ERROR_ID_RAND_READ)
gklog.LogGkErr("", gkErr)
}
seed ^= int64(buf[0]) << 16
seed ^= int64(buf[1]) << 24
seed ^= int64(buf[2]) << 32
seed ^= int64(buf[3]) << 40
seed ^= int64(buf[4]) << 48
seed ^= int64(buf[5]) << 56
gkRandContext.mRandContext = m_rand.New(m_rand.NewSource(seed))
return gkRandContext
}
func (fieldContext *FieldContextDef) queueMessageToClient(sessionId string, messageToClient *message.MessageToClientDef) {
var websocketConnectionContext *websocketConnectionContextDef
var gkErr *gkerr.GkErrDef
gklog.LogTrace("queu up message " + messageToClient.Command)
websocketConnectionContext, gkErr =
fieldContext.getWebsocketConnectionContextById(sessionId)
if gkErr != nil {
gklog.LogGkErr("", gkErr)
} else {
var localSize int
websocketConnectionContext.toClientQueue.mutex.Lock()
localSize = websocketConnectionContext.toClientQueue.queueSize
websocketConnectionContext.toClientQueue.mutex.Unlock()
if localSize > MAX_MESSAGES_TO_CLIENT_QUEUE {
gkErr = gkerr.GenGkErr("messageToClient queue overflow, dropping message", nil, ERROR_ID_MESSAGE_TO_CLIENT_QUEUE_OVERFLOW)
gklog.LogGkErr("", gkErr)
} else {
websocketConnectionContext.toClientQueue.mutex.Lock()
websocketConnectionContext.toClientQueue.queueSize += 1
websocketConnectionContext.toClientQueue.mutex.Unlock()
websocketConnectionContext.toClientQueue.messagesChan <- messageToClient
}
}
}
func (messageToClient *MessageToClientDef) BuildSvgMessageToClient(svgDir string, command string, fileName string, svgJsonData *SvgJsonDataDef) *gkerr.GkErrDef {
var gkErr *gkerr.GkErrDef
if !validateSvgFileName(fileName) {
gkErr = gkerr.GenGkErr("invalid svg fileName", nil, ERROR_ID_INVALID_SVG_FILENAME)
return gkErr
}
messageToClient.Command = command
jsonFileName := svgDir + string(os.PathSeparator) + fileName + ".json"
svgFileName := svgDir + string(os.PathSeparator) + fileName + ".svg"
messageToClient.JsonData, gkErr = gkcommon.GetFileContents(jsonFileName)
if gkErr != nil {
return gkErr
}
messageToClient.Data, gkErr = gkcommon.GetFileContents(svgFileName)
if gkErr != nil {
return gkErr
}
messageToClient.Data, gkErr = gksvg.FixSvgData(messageToClient.Data, fileName)
if gkErr != nil {
return gkErr
}
if svgJsonData != nil {
messageToClient.JsonData, gkErr = templateTranslateJsonData(messageToClient.JsonData, svgJsonData)
if gkErr != nil {
return gkErr
}
}
return nil
}
func (gkTemplate *TemplateDef) GetBytes() ([]byte, *gkerr.GkErrDef) {
if gkTemplate.dataBuffer == nil {
return nil, gkerr.GenGkErr("missing call to Build", nil, ERROR_ID_MISSING_BUILD)
}
return gkTemplate.dataBuffer.Bytes(), nil
}
func loadConfigFile(fileName string) (loginConfigDef, *gkerr.GkErrDef) {
var err error
var loginConfig loginConfigDef
var file *os.File
file, err = os.Open(fileName)
if err != nil {
return loginConfig, gkerr.GenGkErr(fmt.Sprintf("os.Open file: %s", fileName), err, ERROR_ID_OPEN_CONFIG)
}
defer file.Close()
err = xml.NewDecoder(file).Decode(&loginConfig)
if err != nil {
return loginConfig, gkerr.GenGkErr(fmt.Sprintf("xml.NewDecoder file: %s", fileName), err, ERROR_ID_DECODE_CONFIG)
}
return loginConfig, nil
}
func (fieldContext *FieldContextDef) handleMessageFromClient(messageFromClient *message.MessageFromClientDef) *gkerr.GkErrDef {
var gkErr *gkerr.GkErrDef
switch messageFromClient.Command {
case message.GetAvatarSvgReq:
gkErr = fieldContext.handleGetAvatarSvgReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.DelAvatarSvgReq:
gkErr = fieldContext.handleDelAvatarSvgReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.MoveAvatarSvgReq:
gkErr = fieldContext.handleMoveAvatarSvgReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.SetAvatarSvgReq:
gkErr = fieldContext.handleSetAvatarSvgReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.PingReq:
gkErr = fieldContext.handlePingReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.ChatReq:
gkErr = fieldContext.handleChatReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.NewPodReq:
gkErr = fieldContext.handleNewPodReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.UserPrefSaveReq:
gkErr = fieldContext.handleUserPrefReq(messageFromClient)
if gkErr != nil {
return gkErr
}
case message.SaveTerrainEditReq:
gkErr = fieldContext.handleSaveTerrainEditReq(messageFromClient)
if gkErr != nil {
return gkErr
}
default:
gkErr = gkerr.GenGkErr("unknonwn websocket request: "+messageFromClient.Command, nil, ERROR_ID_UNKNOWN_WEBSOCKET_COMMAND)
return gkErr
}
return nil
}
func (gkDbCon *GkDbConDef) UpdateUserPref(id int32, prefName string, prefValue string) *gkerr.GkErrDef {
var stmt *sql.Stmt
var err error
stmt, err = gkDbCon.sqlDb.Prepare("update user_prefs set pref_value = $1 where user_id = $2 and pref_name = $3")
if err != nil {
return gkerr.GenGkErr("stmt.Prepare "+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
_, err = stmt.Exec(prefValue, id, prefName)
if err != nil {
return gkerr.GenGkErr("stmt.Exec "+getDatabaseErrorMessage(err), err, ERROR_ID_EXECUTE)
}
return nil
}
func (gkDbCon *GkDbConDef) InsertUserPref(id int32, prefName string, prefValue string) *gkerr.GkErrDef {
var stmt *sql.Stmt
var err error
stmt, err = gkDbCon.sqlDb.Prepare("insert into user_prefs (user_id, pref_value, pref_name) values ($1, $2, $3)")
if err != nil {
return gkerr.GenGkErr("stmt.Prepare "+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
_, err = stmt.Exec(id, prefValue, prefName)
if err != nil {
return gkerr.GenGkErr("stmt.Exec "+getDatabaseErrorMessage(err), err, ERROR_ID_EXECUTE)
}
return nil
}
func (fieldContext *FieldContextDef) handleGetAvatarSvgReq(messageFromClient *message.MessageFromClientDef) *gkerr.GkErrDef {
var messageToClient *message.MessageToClientDef = new(message.MessageToClientDef)
var getSvg getSvgDef
var gkErr *gkerr.GkErrDef
var err error
err = json.Unmarshal(messageFromClient.JsonData, &getSvg)
if err != nil {
gkErr = gkerr.GenGkErr("json.Unmarshal", err, ERROR_ID_JSON_UNMARSHAL)
return gkErr
}
var randomByte byte
randomByte = fieldContext.sessionContext.RandContext.GetRandomByte()
var svgJsonData *message.SvgJsonDataDef = new(message.SvgJsonDataDef)
svgJsonData.Id = fieldContext.getNextObjectId()
svgJsonData.IsoXYZ.X = int16((randomByte&0x07)*3) - 10
svgJsonData.IsoXYZ.Y = int16(((randomByte>>4)&0x07)*3) - 10
gkErr = messageToClient.BuildSvgMessageToClient(fieldContext.avatarSvgDir, message.GetAvatarSvgRes, getSvg.SvgName, svgJsonData)
if gkErr != nil {
return gkErr
}
var singleSession *ses.SingleSessionDef
singleSession = fieldContext.sessionContext.GetSessionFromId(messageFromClient.SessionId)
var podId int32 = singleSession.GetCurrentPodId()
fieldContext.queueMessageToClient(messageFromClient.SessionId, messageToClient)
var fieldObject *fieldObjectDef = new(fieldObjectDef)
fieldObject.id = svgJsonData.Id
fieldObject.fileName = getSvg.SvgName
fieldObject.isoXYZ = svgJsonData.IsoXYZ
fieldObject.sourceSessionId = messageFromClient.SessionId
fieldContext.addAvatarObject(podId, fieldObject)
var websocketConnectionContext *websocketConnectionContextDef
websocketConnectionContext, gkErr = fieldContext.getWebsocketConnectionContextById(messageFromClient.SessionId)
if gkErr != nil {
return gkErr
}
websocketConnectionContext.avatarId = fieldObject.id
gkErr = fieldContext.sendNewAvatarToAll(podId, messageFromClient.SessionId, fieldObject.id)
if gkErr != nil {
return gkErr
}
return nil
}
func (gkDbCon *GkDbConDef) SetUserPref(userName string, prefName string, prefValue string) *gkerr.GkErrDef {
var dbUser *DbUserDef
var gkErr *gkerr.GkErrDef
dbUser, gkErr = gkDbCon.GetUser(userName)
if gkErr != nil {
return gkErr
}
var stmt *sql.Stmt
var err error
stmt, err = gkDbCon.sqlDb.Prepare("select pref_value from user_prefs where user_id = $1 and pref_name = $2")
if err != nil {
return gkerr.GenGkErr("stmt.Prepare "+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query(dbUser.id, prefName)
if err != nil {
return gkerr.GenGkErr("stmt.Query"+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
if rows.Next() {
gkErr = gkDbCon.UpdateUserPref(dbUser.id, prefName, prefValue)
if gkErr != nil {
return gkErr
}
} else {
gkErr = gkDbCon.InsertUserPref(dbUser.id, prefName, prefValue)
if gkErr != nil {
return gkErr
}
}
return nil
}
func getIdOutOfHref(input string) (string, *gkerr.GkErrDef) {
if len(input) > 2 {
if input[0] == '#' {
var id string
id = input[1:]
return id, nil
}
}
return "", gkerr.GenGkErr("href id parse: "+input, nil, ERROR_ID_HREF_PARSE)
}
func (gkDbCon *GkDbConDef) ChangePassword(userName string, passwordHash string, passwordSalt string) *gkerr.GkErrDef {
var stmt *sql.Stmt
var err error
//var gkErr *gkerr.GkErrDef
stmt, err = gkDbCon.sqlDb.Prepare("update users set password_hash = $1, password_salt = $2 where user_name = $3")
if err != nil {
return gkerr.GenGkErr("stmt.Prepare"+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
_, err = stmt.Exec(passwordHash, passwordSalt, userName)
if err != nil {
return gkerr.GenGkErr("stmt.Exec"+getDatabaseErrorMessage(err), err, ERROR_ID_EXECUTE)
}
return nil
}
func (gkTemplate *TemplateDef) Send(res http.ResponseWriter, req *http.Request) *gkerr.GkErrDef {
var writeCount int
var err error
if gkTemplate.dataBuffer == nil {
return gkerr.GenGkErr("missing call to Build", nil, ERROR_ID_MISSING_BUILD)
}
writeCount, err = res.Write(gkTemplate.dataBuffer.Bytes())
if err != nil {
return gkerr.GenGkErr("res.Write", err, ERROR_ID_TEMPLATE_WRITE)
}
if writeCount != gkTemplate.dataBuffer.Len() {
return gkerr.GenGkErr("write count short", nil, ERROR_ID_SHORT_WRITE_COUNT)
}
gkTemplate.dataBuffer = nil
return nil
}
func (gkDbCon *GkDbConDef) GetUserPrefsList(userName string) ([]DbUserPrefDef, *gkerr.GkErrDef) {
var dbUser *DbUserDef
var gkErr *gkerr.GkErrDef
var stmt *sql.Stmt
var err error
var dbUserPrefsList []DbUserPrefDef = make([]DbUserPrefDef, 0, 0)
dbUser, gkErr = gkDbCon.GetUser(userName)
if gkErr != nil {
return nil, gkErr
}
stmt, err = gkDbCon.sqlDb.Prepare("select user_id, pref_name, pref_value from user_prefs where user_id = $1")
if err != nil {
return nil, gkerr.GenGkErr("sql.Prepare "+getDatabaseErrorMessage(err), err, ERROR_ID_PREPARE)
}
defer stmt.Close()
var rows *sql.Rows
rows, err = stmt.Query(dbUser.id)
if err != nil {
return nil, gkerr.GenGkErr("stmt.Query "+getDatabaseErrorMessage(err), err, ERROR_ID_QUERY)
}
defer rows.Close()
for rows.Next() {
var dbUserPref DbUserPrefDef
err = rows.Scan(&dbUserPref.Id, &dbUserPref.PrefName, &dbUserPref.PrefValue)
if err != nil {
return nil, gkerr.GenGkErr("rows.Scan "+getDatabaseErrorMessage(err), err, ERROR_ID_ROWS_SCAN)
}
dbUserPrefsList = append(dbUserPrefsList, dbUserPref)
}
return dbUserPrefsList, nil
}
func getSingleTerrainMap(jsonFileName string) (*terrainJsonDef, *gkerr.GkErrDef) {
var terrainJson *terrainJsonDef = new(terrainJsonDef)
var jsonFile *os.File
var err error
var jsonData []byte = make([]byte, 0, 256)
var gkErr *gkerr.GkErrDef
jsonFile, err = os.Open(jsonFileName)
if err != nil {
gkErr = gkerr.GenGkErr("could not open: "+jsonFileName, err, ERROR_ID_OPEN_TERRAIN_MAP)
return nil, gkErr
}
defer jsonFile.Close()
var buf []byte
var readCount int
for {
buf = make([]byte, 128, 128)
readCount, err = jsonFile.Read(buf)
if readCount > 0 {
jsonData = append(jsonData, buf[:readCount]...)
}
if err != nil {
if err == io.EOF {
break
}
gkErr = gkerr.GenGkErr("could not read "+jsonFileName, err, ERROR_ID_READ_TERRAIN_MAP)
return nil, gkErr
}
}
err = json.Unmarshal(jsonData, &terrainJson.jsonMapData)
if err != nil {
gkErr = gkerr.GenGkErr("json.Unmarshal", err, ERROR_ID_JSON_UNMARSHAL)
return nil, gkErr
}
return terrainJson, nil
}
func (messageFromClient *MessageFromClientDef) PopulateFromMessage(sessionId string, message []byte) *gkerr.GkErrDef {
var index1, index2 int
index1 = bytes.IndexByte(message, '~')
if index1 == -1 {
return gkerr.GenGkErr("missing ~ from websocket message", nil, ERROR_ID_UNKNOWN_WEBSOCKET_INPUT)
}
index2 = bytes.IndexByte(message[index1+1:], '~')
if index2 == -1 {
return gkerr.GenGkErr("missing second ~ from websocketMessage", nil, ERROR_ID_UNKNOWN_WEBSOCKET_INPUT)
}
index2 += index1 + 1
messageFromClient.SessionId = sessionId
messageFromClient.Command = string(message[0:index1])
messageFromClient.JsonData = message[index1+1 : index2]
messageFromClient.data = message[index2+1:]
return nil
}
func (gkTemplate *TemplateDef) Build(buildData interface{}) *gkerr.GkErrDef {
gkTemplate.dataBuffer = bytes.NewBuffer(make([]byte, 0, 0))
var err error
gklog.LogTrace(fmt.Sprintf("buildData: %+v", buildData))
err = gkTemplate.tmpl.ExecuteTemplate(gkTemplate.dataBuffer, "main", buildData)
if err != nil {
return gkerr.GenGkErr("tmpl.ExecuteTemplate", err, ERROR_ID_EXECUTE_TEMPLATE)
}
return nil
}
func (fieldContext *FieldContextDef) handleSetAvatarSvgReq(messageFromClient *message.MessageFromClientDef) *gkerr.GkErrDef {
var gkErr *gkerr.GkErrDef
var err error
var setSvg setSvgDef
gklog.LogTrace("json raw: " + string(messageFromClient.JsonData))
err = json.Unmarshal(messageFromClient.JsonData, &setSvg)
if err != nil {
gkErr = gkerr.GenGkErr("json.Unmarshal", err, ERROR_ID_JSON_UNMARSHAL)
return gkErr
}
var singleSession *ses.SingleSessionDef
singleSession = fieldContext.sessionContext.GetSessionFromId(messageFromClient.SessionId)
var podId int32 = singleSession.GetCurrentPodId()
var fieldObject *fieldObjectDef
var ok bool
fieldObject, ok = fieldContext.podMap[podId].avatarMap[setSvg.Id]
if ok {
var cord int
cord, _ = strconv.Atoi(setSvg.X)
fieldObject.isoXYZ.X = int16(cord)
cord, _ = strconv.Atoi(setSvg.Y)
fieldObject.isoXYZ.Y = int16(cord)
cord, _ = strconv.Atoi(setSvg.Z)
fieldObject.isoXYZ.Z = int16(cord)
gklog.LogTrace("one")
fieldContext.setAllAvatars(messageFromClient.SessionId, fieldObject)
} else {
gkErr = gkerr.GenGkErr("move object", nil, ERROR_ID_COULD_NOT_FIND_OBJECT_TO_MOVE)
gklog.LogGkErr("", gkErr)
}
return nil
}