├── src
    ├── requirements.txt
    ├── uss_config.py
    ├── static
    │   ├── style.css
    │   ├── ajaxfileupload.js
    │   ├── index.html
    │   └── scripts.js
    ├── uss_runtime.py
    ├── uss_database.py
    └── UniSkinServer.py
├── .gitignore
├── README.md
└── doc
    ├── UniSkinAPI_zh-CN.md
    ├── UniSkinServerAPI.txt
    └── UniSkinAPI_en.md


/src/requirements.txt:
--------------------------------------------------------------------------------
1 | bsddb3==6.1.1
2 | tornado==4.3
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.bak
2 | test.py
3 | src/runtime
4 | __pycache__
5 | src/*.db
6 | src/*.json
7 | src/textures
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Universal Skin API 计划
 2 | 相关描述请见MCBBS[Universal Skin API 计划](http://www.mcbbs.net/thread-366248-1-1.html)
 3 | 
 4 | ### Universal Skin API
 5 | 具体文档请见`doc`目录
 6 | 
 7 | Documents under `doc` folder
 8 | 
 9 | **如对API有意见，请先发Issue，尽量避免直接Pull Request**
10 | 
11 | **Open an issue first if you have any concerns about the API**
12 | 
13 | ### Universal Skin Server
14 | 位于`src`目录下
15 | 
16 | 以GPLv2协议发布
17 | 
18 | 网页API请见`doc/UniSkinServerAPI.txt`
19 | 
20 | Source under `src` folder. Licensed under GPLv2
21 | 
22 | For the website API, see `doc/UniSkinServerAPI.txt`
23 | 
24 | **注意：密码现在是明文传输，你可能需要HTTPS保证安全**
25 | 
26 | **Warning: Passwords are transmitted in plain-text. You may need HTTPS to secure the connection.**
27 | 
28 | ### Universal Skin Mod
29 | 请见[UniSkinMod](https://github.com/RecursiveG/UniSkinMod)
30 | 
31 | 


--------------------------------------------------------------------------------
/src/uss_config.py:
--------------------------------------------------------------------------------
 1 | DEFAULT_CONFIG='''{
 2 |     "port": "12345",
 3 |     "allow-reg": true,
 4 |     "texture-folder": "textures/",
 5 |     "database-path": "data.db",
 6 |     "admin-passphrase": "",
 7 |     "session-time": 600,
 8 |     "max-file-size": 1048576
 9 | }
10 | '''
11 | 
12 | def get_config(file_path="server_config.json"):
13 |     try:
14 |         import os
15 |         import json
16 |         if not os.path.exists(file_path):
17 |             f=open(file_path,"w")
18 |             f.write(DEFAULT_CONFIG)
19 |             f.close()
20 | 
21 |         f=open(file_path)
22 |         config=json.loads(f.read())
23 |         if not os.path.exists(config["texture-folder"]):
24 |             os.mkdir(config["texture-folder"])
25 |     except Exception as e:
26 |         print(e)
27 |         return None
28 |     return config
29 | 


--------------------------------------------------------------------------------
/src/static/style.css:
--------------------------------------------------------------------------------
  1 | #main-div{
  2 |   width: 50%;
  3 |   margin-right: auto;
  4 |   margin-left: auto;
  5 | }
  6 | 
  7 | .panel{
  8 |   border: 1px solid transparent;
  9 |   border-radius: 6px;
 10 |   border-color: #ddd;
 11 |   margin-bottom: 20px;
 12 |   box-shadow: 0 1px 1px rgba(0,0,0,0.05);
 13 |   width: 30em;
 14 | }
 15 | 
 16 | .panel-head{
 17 |   padding: 10px 15px;
 18 |   border-bottom: 1px solid transparent;
 19 |   border-color: #ddd;
 20 |   background-color: #F5F5F5;
 21 | }
 22 | 
 23 | .panel-title{
 24 |   padding: 0;
 25 |   margin: 0;
 26 |   font-size: 16px;
 27 | }
 28 | 
 29 | .panel-body{
 30 |   padding: 15px;
 31 |   padding-bottom: 5px;
 32 | }
 33 | 
 34 | 
 35 | .panel-btn{
 36 |   color: #333;
 37 |   background-color: #fff;
 38 |   display: inline-block;
 39 |   margin-right: 15px;
 40 |   padding: 6px 12px;
 41 |   margin-bottom: 0;
 42 |   font-size: 14px;
 43 |   font-weight: 400;
 44 |   line-height: 1;
 45 |   text-align: center;
 46 |   white-space: nowrap;
 47 |   vertical-align: middle;
 48 |   cursor: pointer;
 49 |   background-image: none;
 50 |   border: 1px solid transparent;
 51 |   border-color: #ccc;
 52 |   border-radius: 4px;
 53 | }
 54 | 
 55 | .panel-line{
 56 |   margin-bottom: 10px;
 57 |   display: table;
 58 | }
 59 | 
 60 | .line-start{
 61 |   white-space: nowrap;
 62 |   margin-right: 0;
 63 |   padding: 6px 12px;
 64 |   font-size: 14px;
 65 |   font-weight: 400;
 66 |   line-height: 1;
 67 |   color: #555;
 68 |   text-align: center;
 69 |   background-color: #eee;
 70 |   border: 1px solid #ccc;
 71 |   border-right: 0;
 72 |   border-radius: 4px 0 0 4px;
 73 |   display: table-cell;
 74 |   width: 1%;
 75 | }
 76 | 
 77 | .line-mid{
 78 |   margin-right: 0;
 79 |   padding: 6px 12px;
 80 |   font-size: 14px;
 81 |   font-weight: 400;
 82 |   line-height: 1;
 83 |   border: 1px solid #ccc;
 84 |   border-right: 0;
 85 |   display: table-cell;
 86 |   width: 100%;
 87 | }
 88 | 
 89 | .line-end{
 90 |   padding: 6px 12px;
 91 |   font-size: 14px;
 92 |   font-weight: 400;
 93 |   line-height: 1;
 94 |   border: 1px solid #ccc;
 95 |   border-radius: 0 4px 4px 0;
 96 |   display: table-cell;
 97 |   width: 100%;
 98 | }
 99 | 
100 | .error-msg{
101 |   color: red;
102 | }
103 | 
104 | #preview-img{
105 |   max-width: 100%;
106 |   margin-bottom: 10px;
107 | }
108 | 


--------------------------------------------------------------------------------
/doc/UniSkinAPI_zh-CN.md:
--------------------------------------------------------------------------------
  1 | ## 根地址
  2 | 根地址是每个URL请求的开始部分，每个请求的URL均由
  3 | 根地址与Endpoint连接而成，根地址也唯一地标识了一台服务器
  4 | 所有请求都是不带参数的GET请求
  5 | 假设一个服务器的根地址是
  6 | 
  7 |     http://127.0.0.1:8000/skinserver/
  8 | 
  9 | 获取玩家Profile的Endpoint是
 10 | 
 11 |     /{玩家名}.json
 12 | 
 13 | 那么，从该服务器获取玩家`XiaoMing`的皮肤的请求即为
 14 | 
 15 |     http://127.0.0.1:8000/skinserver/XiaoMing.json
 16 | 
 17 | 一个实现了UniSkinAPI的服务端应当实现所有Endpoint
 18 | 
 19 | ## 材质文件链接
 20 | Endpoint:
 21 | 
 22 |     /textures/{材质文件唯一标识符}
 23 | 
 24 | 返回值:
 25 | 
 26 | - 200: 返回材质文件
 27 | - 404: 材质未找到
 28 | 
 29 | 唯一标识符应当与文件一一对应
 30 | 我推荐使用文件的SHA-256作为唯一标识符
 31 | 
 32 | ## 获得玩家信息:
 33 | Endpoint:
 34 | 
 35 |     /{玩家名}.json
 36 | 
 37 | 该处玩家名大小写可随意
 38 | 如果玩家名包含非ASCII字符，请使用UTF-8编码的[URL编码](https://en.wikipedia.org/wiki/Percent-encoding)
 39 | 例如：`%E5%B0%8F%E6%98%8E.json`
 40 | 
 41 | 返回值:
 42 | 
 43 | - 200: 返回玩家信息(UserProfile)
 44 | - 400: 不可接受的字符编码
 45 | - 404: 该玩家不存在
 46 | 
 47 | ## UserProfile:
 48 | UserProfile代表了一个玩家的信息
 49 | 
 50 |     {
 51 |       "player_name": {字符串，大小写正确的玩家名},
 52 |       "last_update": {整数，玩家最后一次修改个人信息的时间，UNIX时间戳, 秒},
 53 |       "model_preference": {字符串数组，按顺序存储玩家需要加载的模型名称},
 54 |       "skins": {模型名称到对应材质UID的字典}
 55 |       "cape": {披风的UID} (已弃用)
 56 |     }
 57 | 
 58 | 一个完整的样例是:
 59 | 
 60 |     {
 61 |       "player_name": "XiaoMing",
 62 |       "last_update": 1416300800,
 63 |       "model_preference": ["slim","default","cape","default_dynamic"],
 64 |       "skins": {
 65 |         "slim": "67cbc70720c4666e9a12384d041313c7bb9154630d7647eb1e8fba0c461275c6",
 66 |         "default": "6d342582972c5465b5771033ccc19f847a340b76d6131129666299eb2d6ce66e",
 67 |         "cape": "970a71c6a4fc81e83ae22c181703558d9346e0566390f06fb93d09fcc9783799"
 68 |         "default_dynamic": "1000,67cbc70720c4666e9a12384d041313c7bb9154630d7647eb1e8fba0c461275c6,6d342582972c5465b5771033ccc19f847a340b76d6131129666299eb2d6ce66e"
 69 |       }
 70 |       "cape": "970a71c6a4fc81e83ae22c181703558d9346e0566390f06fb93d09fcc9783799"
 71 |     }
 72 | 
 73 | 所有的成员都是可选的，一个支持UniSkinAPI的皮肤mod不应因缺少任何部分而崩溃。
 74 | 
 75 | 推荐启用压缩。
 76 | 
 77 | ## 模型名称约定
 78 | 
 79 | 模型名称是大小写敏感的
 80 | 
 81 | - `slim`: 细手臂/女性玩家模型
 82 | - `default`: 经典玩家模型
 83 | - `cape`: 为披风材质使用
 84 | - `elytron`: 为滑翔翅材质使用
 85 | 
 86 | ## 加载顺序约定
 87 | 
 88 | - 对于`slim`和`default`，在前的皮肤被加载
 89 | - 对于`cape`和`elytron`，若存在则加载
 90 | - 对于不支持`slim`/`cape`/`elytron`模型的客户端，对应材质被忽略
 91 | - 当存在两个`cape`字段时，以`skins`字典中的为准
 92 | 
 93 | ## UniSkinMod 扩展模型
 94 | 
 95 | UniSkinMod正考虑加入动态皮肤功能，占用以下四个模型：
 96 | 
 97 | - slim_dynamic
 98 | - default_dynamic
 99 | - cape_dynamic
100 | - elytron_dynamic
101 | 
102 | 依然是在前面的被加载，若不存在或不支持则忽略。
103 | texture字符串为由`,`分隔的多个代表每帧图片的UID，第一项是例外。是一个正整数，表示多长时间循环一遍，单位millisecond。
104 | 所有图片等间隔播放。
105 | 
106 | ## 错误回应:
107 | 当某个请求出错时(返回值不为200时)，服务器可以返回空，也可以返回如下JSON
108 | 
109 |     {
110 |       "errno": {整数，错误代号},
111 |       "msg": {字符串，人类可读的信息}
112 |     }
113 | 
114 | 目前定义的错误代号有:
115 | - 0: 没有错误发生
116 | - 1: 玩家不存在
117 | 


--------------------------------------------------------------------------------
/doc/UniSkinServerAPI.txt:
--------------------------------------------------------------------------------
  1 | # UniSkinServer API Document
  2 | This file is not a part of `UniSkinAPI`
  3 | 
  4 | ## Register: `/register`
  5 |     POST: LOGIN={username}&PASSWD={password}
  6 |     RETN: {"errno":0,"msg":"success"}
  7 |             1: already registered
  8 |             2: passwd not satisfied request(too short)
  9 |             3: invalid name or passwd
 10 | 
 11 | ## Login: `/login`
 12 |     POST: same as register
 13 |     RETN: {"errno":0,"msg":"{sessionToken}"}
 14 |             1: invalid login
 15 |             2: attempt blocked
 16 | 
 17 | ## Logout: `/logout`
 18 |     POST: token={}
 19 |     RETN: {"errno":0,"msg":"{sessionToken}"}
 20 | 
 21 | ## Get Full User Data: `/userdata`
 22 |     GET  :token={sessionToken}
 23 |     RETN :Same as UniSkinAPI
 24 | 
 25 | ## Delete Account: `/delete_account`
 26 |     POST: token={}
 27 |           current_passwd={}
 28 |           login={}
 29 |     RETN: {"errno":0,"msg":"success"}
 30 | 
 31 | ## Change Password: `/chpwd`
 32 |     POST: token={}
 33 |           current_passwd={}
 34 |           new_passwd={}
 35 |           login={}
 36 |     RETN: {"errno":0,"msg":"success"}
 37 | 
 38 | ## Set Skin Model preference: `/model_preference`
 39 |     POST: token={}
 40 |           prefered_model={slim|default}
 41 |     RETN: {"errno":0,"msg":"success"}
 42 | 
 43 | ## Set Static/Dynamic preference: `/type_preference`
 44 |     POST: token={}
 45 |           type={skin|cape|elytra}
 46 |           preference={dynamic|static|off}
 47 |     RETN: {"errno":0,"msg":"success"}
 48 | 
 49 | ## Set Dynamic Interval: `/dynamic_interval`
 50 |     POST: token={}
 51 |           type={skin_slim|skin_default|cape|elytra}
 52 |           interval={positive integer}
 53 |     RETN: {"errno":0,"msg":"success"}
 54 | 
 55 | ## Upload Texture: `/upload_texture`
 56 |     POST: token={}
 57 |           model={skin_slim|skin_default|cape|elytra}
 58 |           type={static|dynamic}
 59 |           file={}
 60 |     RETN: {"errno":0,"msg":"success"}
 61 | 
 62 | ## Delete Texture: `/delete_texture`
 63 |     POST: token={}
 64 |           model={skin_slim|skin_default|cape|elytra}
 65 |           type={static|dynamic}
 66 |     RETN: {"errno":0,"msg":"success"}
 67 | 
 68 | ## `errno` definitions:
 69 |     0: success
 70 |     1: invalid credential
 71 |     2: bad password
 72 |     3: bad username
 73 |     4: attempt blocked
 74 |     5: already registered
 75 |     6: argument not acceptable
 76 |     7: register not allowed
 77 |     8: internal server error
 78 |     9: file too large
 79 | 
 80 | # Database: `bsddb3`
 81 | 
 82 |     {
 83 |       "username": "{string}",
 84 |       "password": "{string}",
 85 |       "last_update": "{unix timestamp in s}",
 86 |       "textures": {
 87 |         "skin_default_static": {string, hash},
 88 |         "skin_default_dynamic": {
 89 |           "interval": "{int, ms}",
 90 |           "hashes": ["{ordered list of string}"]
 91 |         },
 92 |         "skin_slim_static": {},
 93 |         "skin_slim_dynamic": {},
 94 |         "cape_static": {},
 95 |         "cape_dynamic": {},
 96 |         "elytra_static": {},
 97 |         "elytra_dynamic": {}
 98 |       },
 99 |       "type_preference": {
100 |         "skin": "{string, static|dynamic|off}",
101 |         "cape": "{string, static|dynamic|off}",
102 |         "elytra": "{string, static|dynamic|off}",
103 |       },
104 |       "model_preference": {string,slim|default}
105 |     }
106 | 


--------------------------------------------------------------------------------
/doc/UniSkinAPI_en.md:
--------------------------------------------------------------------------------
  1 | ## "The Root"
  2 | "The Root" is the start part of every request.
  3 | Every Request URL is by connecting The Root and the Endpoint
  4 | For example, The Root of a server is
  5 | 
  6 |     http://127.0.0.1:8000/skinserver/
  7 | 
  8 | and the Endpoint for getting the profile is
  9 | 
 10 |     /{PlayerName}.json
 11 | 
 12 | if a client want the profile for player `John`, the request will be
 13 | 
 14 |     http://127.0.0.1:8000/skinserver/John.json
 15 | 
 16 | A compatible server should implements all the endpoints.
 17 | 
 18 | ## Texture Files Link:
 19 | Endpoint:
 20 | 
 21 |     /textures/{unique identifier to the file}
 22 | 
 23 | Response:
 24 | 
 25 | - 200: Return the texture
 26 | - 404: Not found
 27 | 
 28 | UID should be always different for different file
 29 | Even they belongs to the same player or even in different servers
 30 | I recommend using SHA-256 of the file as the UID
 31 | 
 32 | ## Get user profile:
 33 | Endpoint:
 34 | 
 35 |     /{PlayerName}.json
 36 | 
 37 | The `{PlayerName}` here is not case-sensitive
 38 | If non-ASCII character is needed. They should be encoded as UTF-8 and use [Precent-Encoding](https://en.wikipedia.org/wiki/Percent-encoding) notation.
 39 | e.g. `%E5%B0%8F%E6%98%8E.json`
 40 | 
 41 | Response:
 42 | 
 43 | - 200: Return the UserProfile json
 44 | - 400: If the encoding is not acceptable
 45 | - 404: PlayerName not registered
 46 | 
 47 | ## UserProfile:
 48 | UserProfile is a JSON string, the format is:
 49 | 
 50 |     {
 51 |       "player_name": {string, Case-Corrected player name},
 52 |       "last_update": {int, the time the player made the last change, in unix timestamp, seconds},
 53 |       "model_preference": {array of string, the name of the models are listed in order of preference},
 54 |       "skins": {Map<String,String>, map of model name to texture hash}
 55 |       "cape": {hash of cape texture}(Deprecated)
 56 |     }
 57 | 
 58 | And An Example Could Be:
 59 | 
 60 |     {
 61 |       "player_name": "John",
 62 |       "last_update": 1416300800,
 63 |       "model_preference": ["slim","default","cape","default_dynamic"],
 64 |       "skins": {
 65 |         "slim": "67cbc70720c4666e9a12384d041313c7bb9154630d7647eb1e8fba0c461275c6",
 66 |         "default": "6d342582972c5465b5771033ccc19f847a340b76d6131129666299eb2d6ce66e",
 67 |         "cape": "970a71c6a4fc81e83ae22c181703558d9346e0566390f06fb93d09fcc9783799"
 68 |         "default_dynamic": "1000,67cbc70720c4666e9a12384d041313c7bb9154630d7647eb1e8fba0c461275c6,6d342582972c5465b5771033ccc19f847a340b76d6131129666299eb2d6ce66e"
 69 |       }
 70 |       "cape": "970a71c6a4fc81e83ae22c181703558d9346e0566390f06fb93d09fcc9783799"
 71 |     }
 72 | 
 73 | All the fields are optional, and a compatible client should automatically skip
 74 | any missing information.
 75 | 
 76 | Compression is recommended.
 77 | 
 78 | ## Model Name Convention
 79 | 
 80 | Model names are case-sensitive.
 81 | 
 82 | - `slim`: The slim-arm or female player model
 83 | - `default`: The triditional player model
 84 | - `cape`: Reserved for cape texture use
 85 | - `elytron`: Reserved for elytron texture use
 86 | 
 87 | ## Model load order
 88 | 
 89 | - For `slim` and default, the front one is used
 90 | - For `cape` and elytron, if exists then use
 91 | - For clients which not support `slim`/`cape`/`elytron`, they are ignored
 92 | - When `cape` exists both inside and outside, the one *in* the `skins` dictonary is used.
 93 | 
 94 | ## Entended Model for UniSkinMod
 95 | 
 96 | UniSkinMod may support dynamic skins in the future.
 97 | So these four model names are reserved.
 98 | 
 99 | - slim_dynamic
100 | - default_dynamic
101 | - cape_dynamic
102 | - elytron_dynamic
103 | 
104 | Still, the ones in front are loaded. If not supported then ignore.
105 | The `texture` string for dynamic skins is a comma-seperated string consists of all UID of every frame.
106 | Except the first one, which is a positive integer represents how many milliseconds it plays for one time.
107 | All the frames are played in equal time interval.
108 | 
109 | ## Response for Errors:
110 | For any response other than 2** & 3**,
111 | the body could be either empty or a json.
112 | Returning an empty body would be fine in most case
113 | 
114 |     {
115 |       "errno": {int},
116 |       "msg": {human readable string and can be anything you like}
117 |     }
118 | 
119 | Defined errnos are:
120 | - 0: No Error Occurred
121 | - 1: User not registered
122 |      No such player in the database at all.
123 | 


--------------------------------------------------------------------------------
/src/uss_runtime.py:
--------------------------------------------------------------------------------
  1 | import time
  2 | 
  3 | class SessionManager():
  4 |     '''track the accessToken, no interaction with database
  5 |        session: {
  6 |          'token1': {
  7 |            'time': expire time
  8 |            'name': playername
  9 |          },
 10 |          ...
 11 |        }
 12 |     '''
 13 | 
 14 |     def __init__(self, expire_time: int):
 15 |         self.__sessions=dict()
 16 |         self.__lastcheck=time.time()
 17 |         self.expire=expire_time
 18 |     def valid(self,token):
 19 |         if token in self.__sessions:
 20 |             if self.__sessions[token]['time']>time.time():
 21 |                 return True
 22 |             else:
 23 |                 del(self.__sessions[token])
 24 |                 return False
 25 |         else:
 26 |             return False
 27 |     def get_name(self,token):
 28 |         return self.__sessions[token]['name'] if self.valid(token) else None
 29 |     def login(self,name):
 30 |         if self.__lastcheck + 3600 < time.time():
 31 |             self.__lastcheck=time.time()
 32 |             for t in [x for x in self.__sessions if self.__sessions[x]['time']<time.time()]:
 33 |                 del(self.__sessions[t])
 34 |         import uuid
 35 |         get_uuid=(lambda: str(uuid.uuid4()).replace('-',''))
 36 |         uid=get_uuid()
 37 |         i={'name':name,'time':time.time()+self.expire}
 38 |         self.__sessions[uid]=i
 39 |         return uid
 40 |     def logout(self,token):
 41 |         if token in self.__sessions:
 42 |             del(self.__sessions[token])
 43 |             return True
 44 |         else:
 45 |             return False
 46 | 
 47 | 
 48 | class TextureManager():
 49 |     '''remove files when startup or file no more used, need info from database at startup time'''
 50 |     __textures=dict()
 51 |     __path='./textures/'
 52 | 
 53 |     def __init__(self, folder_path):
 54 |         self.__path=folder_path
 55 | 
 56 |     def inc_hash(self,h):
 57 |         if h==None or h=="": return
 58 |         if h in self.__textures:
 59 |             self.__textures[h]+=1
 60 |         else:
 61 |             self.__textures[h]=1
 62 | 
 63 |     def dec_hash(self,h):
 64 |         import os
 65 |         if h==None or h=="": return
 66 |         if not h in self.__textures: return
 67 |         self.__textures[h]-=1
 68 |         if self.__textures[h]==0:
 69 |             del(self.__textures[h])
 70 |             os.remove(self.__path+h)
 71 | 
 72 |     def force_clean(self):
 73 |         import os
 74 |         for f in os.listdir(self.__path):
 75 |             if not f in self.__textures:
 76 |                 os.remove(self.__path+f)
 77 | 
 78 | def UniSkinAPIFormatter(record):
 79 |     import json
 80 |     data = dict(player_name=record["username"],
 81 |                 last_update=record["last_update"])
 82 |     perf_list=list()
 83 |     if record["type_preference"]["skin"]=='static':
 84 |         if record["model_preference"]=="slim":
 85 |             perf_list=["slim", "default", "slim_dynamic", "default_dynamic"]
 86 |         else:
 87 |             perf_list=["default", "slim", "default_dynamic", "slim_dynamic"]
 88 |     elif record["type_preference"]["skin"]=='dynamic':
 89 |         if record["model_preference"]=="slim":
 90 |             perf_list=["slim_dynamic", "default_dynamic", "slim", "default"]
 91 |         else:
 92 |             perf_list=["default_dynamic", "slim_dynamic", "default", "slim"]
 93 |     if record["type_preference"]["cape"]=="static":
 94 |         perf_list.append("cape")
 95 |     elif record["type_preference"]["cape"]=="dynamic":
 96 |         perf_list.append("cape_dynamic")
 97 |     if record["type_preference"]["elytra"]=="static":
 98 |         perf_list.append("elytra")
 99 |     elif record["type_preference"]["elytra"]=="dynamic":
100 |         perf_list.append("elytra_dynamic")
101 |     data["model_preference"]=perf_list
102 | 
103 |     good = (lambda x: x is not None and x!="")
104 |     skins = dict()
105 |     s = record["textures"]["skin_default_static"]
106 |     if good(s): skins["default"]=s
107 |     s = record["textures"]["skin_slim_static"]
108 |     if good(s): skins["slim"]=s
109 |     s = record["textures"]["cape_static"]
110 |     if good(s):
111 |         skins["cape"]=s
112 |         data["cape"]=s
113 |     s = record["textures"]["elytra_static"]
114 |     if good(s): skins["elytra"]=s
115 | 
116 |     good = (lambda x: len(x["hashes"])>0 and x["interval"]>0)
117 |     join = (lambda x: str(x["interval"])+","+",".join(x["hashes"]))
118 |     s = record["textures"]["skin_default_dynamic"]
119 |     if good(s): skins["default_dynamic"]=join(s)
120 |     s = record["textures"]["skin_slim_dynamic"]
121 |     if good(s): skins["slim_dynamic"]=join(s)
122 |     s = record["textures"]["cape_dynamic"]
123 |     if good(s): skins["cape_dynamic"]=join(s)
124 |     s = record["textures"]["elytra_dynamic"]
125 |     if good(s): skins["elytra_dynamic"]=join(s)
126 | 
127 |     data["skins"] = skins
128 |     return json.dumps(data)
129 | 
130 | def WebDataFormatter(database_record):
131 |     import json
132 |     del database_record["password"]
133 |     return json.dumps(database_record)
134 | 


--------------------------------------------------------------------------------
/src/uss_database.py:
--------------------------------------------------------------------------------
  1 | from bsddb3 import dbshelve
  2 | import time as time_library
  3 | time=(lambda: int(time_library.time()))
  4 | 
  5 | def pwdhash(name,pwd):
  6 |     import hashlib
  7 |     m1=hashlib.sha1()
  8 |     m2=hashlib.sha1()
  9 |     m3=hashlib.sha512()
 10 |     m1.update(name.encode("utf8"))
 11 |     m2.update(pwd.encode("utf8"))
 12 |     m3.update(m1.digest())
 13 |     m3.update(m2.digest())
 14 |     return m3.hexdigest()
 15 | 
 16 | class uss_database:
 17 |     ''' this class will do what is instructed to do
 18 |     the caller is responsible for data validation '''
 19 |     db = None # dbshelve.DBShelf
 20 | 
 21 |     def __init__(self, database_path: str):
 22 |         self.db = dbshelve.open(database_path)
 23 |     def close(self):
 24 |         self.db.close()
 25 |         self.db = None
 26 | 
 27 |     def _get_user(self, username: str):
 28 |         try:
 29 |             return self.db[username.lower().encode("UTF-8")]
 30 |         except:
 31 |             return None
 32 |     def _set_user(self, username: str, data):
 33 |         self.db[username.lower().encode("UTF-8")] = data
 34 |         self.db.sync()
 35 | 
 36 |     def has_user(self, username: str):
 37 |         return self._get_user(username) is not None
 38 | 
 39 |     @staticmethod
 40 |     def _get_dynmic_default(): return {"interval": -1, "hashes": []}
 41 |     def create_user(self, username: str, passwd: str):
 42 |         hashed_passwd=pwdhash(username, passwd)
 43 |         if (self.has_user(username)): return
 44 |         gdd=self._get_dynmic_default
 45 |         data = dict(username=username, password=hashed_passwd, last_update=time(),
 46 |                     type_preference=dict(skin="off", cape="off", elytra="off"),
 47 |                     model_preference="default",
 48 |                     textures=dict(skin_default_static="", skin_default_dynamic=gdd(),
 49 |                                      skin_slim_static="",    skin_slim_dynamic=gdd(),
 50 |                                           cape_static="",         cape_dynamic=gdd(),
 51 |                                         elytra_static="",       elytra_dynamic=gdd()))
 52 |         self._set_user(username, data)
 53 | 
 54 |     def delete_user(self, username:str):
 55 |         if (not self.has_user(username)): return
 56 |         del self.db[username.encode("UTF-8")]
 57 |         self.db.sync();
 58 | 
 59 |     def change_pwd(self, username: str, passwd: str):
 60 |         hashed_passwd=pwdhash(username, passwd)
 61 |         data = self._get_user(username)
 62 |         if data is None: return
 63 |         data["password"]=hashed_passwd
 64 |         self._set_user(username, data)
 65 | 
 66 |     def is_passwd_match(self, username: str, passwd: str):
 67 |         data = self._get_user(username)
 68 |         if data is None: return False
 69 |         hashed_passwd=pwdhash(username, passwd)
 70 |         return data["password"]==hashed_passwd
 71 | 
 72 |     def set_skin_model_preference(self, username: str, model: str):
 73 |         data = self._get_user(username)
 74 |         if data is None: return
 75 |         data["model_preference"]=model
 76 |         self._set_user(username, data)
 77 | 
 78 |     def set_type_preference(self, username: str, type: str, preference: str):
 79 |         data = self._get_user(username)
 80 |         if data is None: return
 81 |         data["type_preference"][type]=preference
 82 |         self._set_user(username, data)
 83 | 
 84 |     def set_dynamic_interval(self, username:str, type:str,interval:int):
 85 |         data = self._get_user(username)
 86 |         if data is None: return
 87 |         data["textures"][type+"_dynamic"]["interval"]=interval
 88 |         self._set_user(username, data)
 89 | 
 90 |     def set_texture_hash(self, username: str, type: str, is_dynamic: bool, hash: str):
 91 |         data = self._get_user(username)
 92 |         if data is None: return
 93 |         key=type + ("_dynamic" if is_dynamic else "_static")
 94 |         if is_dynamic:
 95 |             data['textures'][key]['hashes'].append(hash)
 96 |         else:
 97 |             data['textures'][key]=hash
 98 |         self._set_user(username, data)
 99 | 
100 |     def del_texture_hash(self, username: str, type: str, is_dynamic: bool, hash_delete_callback):
101 |         data = self._get_user(username)
102 |         if data is None: return
103 |         key=type + ("_dynamic" if is_dynamic else "_static")
104 |         if is_dynamic:
105 |             for hash in data['textures'][key]['hashes']: hash_delete_callback(hash)
106 |             data['textures'][key]['hashes']=[]
107 |             data['textures'][key]['interval']=-1
108 |         else:
109 |             hash_delete_callback(data['textures'][key])
110 |             data['textures'][key]=""
111 |         self._set_user(username, data)
112 | 
113 |     def scan_hashes(self, hash_callback):
114 |         '''used for TextureManager on startup'''
115 |         for key in self.db:
116 |             rec = self.db[key]
117 |             hash_callback(rec["textures"]["skin_default_static"])
118 |             hash_callback(rec["textures"]["skin_slim_static"])
119 |             hash_callback(rec["textures"]["cape_static"])
120 |             hash_callback(rec["textures"]["elytra_static"])
121 |             for hash in rec["textures"]["skin_default_dynamic"]["hashes"]: hash_callback(hash)
122 |             for hash in rec["textures"]["skin_slim_dynamic"]["hashes"]: hash_callback(hash)
123 |             for hash in rec["textures"]["cape_dynamic"]["hashes"]: hash_callback(hash)
124 |             for hash in rec["textures"]["elytra_dynamic"]["hashes"]: hash_callback(hash)
125 | 
126 |     def scan_user_hash(self, username: str, hash_callback):
127 |         rec = self._get_user(username)
128 |         if rec is None: return
129 |         hash_callback(rec["textures"]["skin_default_static"])
130 |         hash_callback(rec["textures"]["skin_slim_static"])
131 |         hash_callback(rec["textures"]["cape_static"])
132 |         hash_callback(rec["textures"]["elytra_static"])
133 |         for hash in rec["textures"]["skin_default_dynamic"]["hashes"]: hash_callback(hash)
134 |         for hash in rec["textures"]["skin_slim_dynamic"]["hashes"]: hash_callback(hash)
135 |         for hash in rec["textures"]["cape_dynamic"]["hashes"]: hash_callback(hash)
136 |         for hash in rec["textures"]["elytra_dynamic"]["hashes"]: hash_callback(hash)
137 | 
138 |     def get_formatted(self, username, formatter):
139 |         return formatter(self._get_user(username))
140 | 


--------------------------------------------------------------------------------
/src/static/ajaxfileupload.js:
--------------------------------------------------------------------------------
  1 | 
  2 | jQuery.extend({
  3 | 	
  4 | 
  5 |     createUploadIframe: function(id, uri)
  6 | 	{
  7 | 			//create frame
  8 |             var frameId = 'jUploadFrame' + id;
  9 |             var iframeHtml = '<iframe id="' + frameId + '" name="' + frameId + '" style="position:absolute; top:-9999px; left:-9999px"';
 10 | 			if(window.ActiveXObject)
 11 | 			{
 12 |                 if(typeof uri== 'boolean'){
 13 | 					iframeHtml += ' src="' + 'javascript:false' + '"';
 14 | 
 15 |                 }
 16 |                 else if(typeof uri== 'string'){
 17 | 					iframeHtml += ' src="' + uri + '"';
 18 | 
 19 |                 }	
 20 | 			}
 21 | 			iframeHtml += ' />';
 22 | 			jQuery(iframeHtml).appendTo(document.body);
 23 | 
 24 |             return jQuery('#' + frameId).get(0);			
 25 |     },
 26 |     createUploadForm: function(id, fileElementId, data)
 27 | 	{
 28 | 		//create form	
 29 | 		var formId = 'jUploadForm' + id;
 30 | 		var fileId = 'jUploadFile' + id;
 31 | 		var form = jQuery('<form  action="" method="POST" name="' + formId + '" id="' + formId + '" enctype="multipart/form-data"></form>');	
 32 | 		if(data)
 33 | 		{
 34 | 			for(var i in data)
 35 | 			{
 36 | 				jQuery('<input type="hidden" name="' + i + '" value="' + data[i] + '" />').appendTo(form);
 37 | 			}			
 38 | 		}		
 39 | 		var oldElement = jQuery('#' + fileElementId);
 40 | 		var newElement = jQuery(oldElement).clone();
 41 | 		jQuery(oldElement).attr('id', fileId);
 42 | 		jQuery(oldElement).before(newElement);
 43 | 		jQuery(oldElement).appendTo(form);
 44 | 
 45 | 
 46 | 		
 47 | 		//set attributes
 48 | 		jQuery(form).css('position', 'absolute');
 49 | 		jQuery(form).css('top', '-1200px');
 50 | 		jQuery(form).css('left', '-1200px');
 51 | 		jQuery(form).appendTo('body');		
 52 | 		return form;
 53 |     },
 54 | 
 55 |     ajaxFileUpload: function(s) {
 56 |         // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout		
 57 |         s = jQuery.extend({}, jQuery.ajaxSettings, s);
 58 |         var id = new Date().getTime()        
 59 | 		var form = jQuery.createUploadForm(id, s.fileElementId, (typeof(s.data)=='undefined'?false:s.data));
 60 | 		var io = jQuery.createUploadIframe(id, s.secureuri);
 61 | 		var frameId = 'jUploadFrame' + id;
 62 | 		var formId = 'jUploadForm' + id;		
 63 |         // Watch for a new set of requests
 64 |         if ( s.global && ! jQuery.active++ )
 65 | 		{
 66 | 			jQuery.event.trigger( "ajaxStart" );
 67 | 		}            
 68 |         var requestDone = false;
 69 |         // Create the request object
 70 |         var xml = {}   
 71 |         if ( s.global )
 72 |             jQuery.event.trigger("ajaxSend", [xml, s]);
 73 |         // Wait for a response to come back
 74 |         var uploadCallback = function(isTimeout)
 75 | 		{			
 76 | 			var io = document.getElementById(frameId);
 77 |             try 
 78 | 			{				
 79 | 				if(io.contentWindow)
 80 | 				{
 81 | 					 xml.responseText = io.contentWindow.document.body?io.contentWindow.document.body.innerHTML:null;
 82 |                 	 xml.responseXML = io.contentWindow.document.XMLDocument?io.contentWindow.document.XMLDocument:io.contentWindow.document;
 83 | 					 
 84 | 				}else if(io.contentDocument)
 85 | 				{
 86 | 					 xml.responseText = io.contentDocument.document.body?io.contentDocument.document.body.innerHTML:null;
 87 |                 	xml.responseXML = io.contentDocument.document.XMLDocument?io.contentDocument.document.XMLDocument:io.contentDocument.document;
 88 | 				}						
 89 |             }catch(e)
 90 | 			{
 91 | 				jQuery.handleError(s, xml, null, e);
 92 | 			}
 93 |             if ( xml || isTimeout == "timeout") 
 94 | 			{				
 95 |                 requestDone = true;
 96 |                 var status;
 97 |                 try {
 98 |                     status = isTimeout != "timeout" ? "success" : "error";
 99 |                     // Make sure that the request was successful or notmodified
100 |                     if ( status != "error" )
101 | 					{
102 |                         // process the data (runs the xml through httpData regardless of callback)
103 |                         var data = jQuery.uploadHttpData( xml, s.dataType );    
104 |                         // If a local callback was specified, fire it and pass it the data
105 |                         if ( s.success )
106 |                             s.success( data, status );
107 |     
108 |                         // Fire the global callback
109 |                         if( s.global )
110 |                             jQuery.event.trigger( "ajaxSuccess", [xml, s] );
111 |                     } else
112 |                         jQuery.handleError(s, xml, status);
113 |                 } catch(e) 
114 | 				{
115 |                     status = "error";
116 |                     jQuery.handleError(s, xml, status, e);
117 |                 }
118 | 
119 |                 // The request was completed
120 |                 if( s.global )
121 |                     jQuery.event.trigger( "ajaxComplete", [xml, s] );
122 | 
123 |                 // Handle the global AJAX counter
124 |                 if ( s.global && ! --jQuery.active )
125 |                     jQuery.event.trigger( "ajaxStop" );
126 | 
127 |                 // Process result
128 |                 if ( s.complete )
129 |                     s.complete(xml, status);
130 | 
131 |                 jQuery(io).unbind()
132 | 
133 |                 setTimeout(function()
134 | 									{	try 
135 | 										{
136 | 											jQuery(io).remove();
137 | 											jQuery(form).remove();	
138 | 											
139 | 										} catch(e) 
140 | 										{
141 | 											jQuery.handleError(s, xml, null, e);
142 | 										}									
143 | 
144 | 									}, 100)
145 | 
146 |                 xml = null
147 | 
148 |             }
149 |         }
150 |         // Timeout checker
151 |         if ( s.timeout > 0 ) 
152 | 		{
153 |             setTimeout(function(){
154 |                 // Check to see if the request is still happening
155 |                 if( !requestDone ) uploadCallback( "timeout" );
156 |             }, s.timeout);
157 |         }
158 |         try 
159 | 		{
160 | 
161 | 			var form = jQuery('#' + formId);
162 | 			jQuery(form).attr('action', s.url);
163 | 			jQuery(form).attr('method', 'POST');
164 | 			jQuery(form).attr('target', frameId);
165 |             if(form.encoding)
166 | 			{
167 | 				jQuery(form).attr('encoding', 'multipart/form-data');      			
168 |             }
169 |             else
170 | 			{	
171 | 				jQuery(form).attr('enctype', 'multipart/form-data');			
172 |             }			
173 |             jQuery(form).submit();
174 | 
175 |         } catch(e) 
176 | 		{			
177 |             jQuery.handleError(s, xml, null, e);
178 |         }
179 | 		
180 | 		jQuery('#' + frameId).load(uploadCallback	);
181 |         return {abort: function () {}};	
182 | 
183 |     },
184 | 
185 |     uploadHttpData: function( r, type ) {
186 |         var data = !type;
187 |         data = type == "xml" || data ? r.responseXML : r.responseText;
188 |         // If the type is "script", eval it in global context
189 |         if ( type == "script" )
190 |             jQuery.globalEval( data );
191 |         // Get the JavaScript object, if JSON is used.
192 |         if ( type == "json" )
193 |             eval( "data = " + data );
194 |         // evaluate scripts within html
195 |         if ( type == "html" )
196 |             jQuery("<div>").html(data).evalScripts();
197 | 
198 |         return data;
199 |     }
200 | })
201 | 
202 | 


--------------------------------------------------------------------------------
/src/static/index.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 | <head>
  3 |   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  4 |   <title>Universal Skin Management System</title>
  5 |   <script src="http://libs.baidu.com/jquery/2.0.3/jquery.min.js"></script>
  6 |   <script src="/static/ajaxfileupload.js"></script>
  7 |   <script src="/static/scripts.js"></script>
  8 |   <link rel="stylesheet" type="text/css" href="/static/style.css" />
  9 | </head>
 10 | 
 11 | <body>
 12 |   <div id="main-div">
 13 |     <h1>Universal Skin Server</h1>
 14 |     <div id="login-div" class="panel">
 15 |       <div class="panel-head">
 16 |         <h3 class="panel-title">Register and Login</h3>
 17 |       </div>
 18 |       <div class="panel-body">
 19 |         <div class="panel-line">
 20 |           <span class="line-start">Login</span>
 21 |           <input type="text" id="login-name" class="line-end" />
 22 |         </div>
 23 |         <div class="panel-line">
 24 |           <span class="line-start">Password</span>
 25 |           <input type="password" id="pwd" class="line-end" />
 26 |         </div>
 27 |         <div class="panel-line">
 28 |           <input class="panel-btn" type="button" id="regBtn" value="Register" />
 29 |           <input class="panel-btn" type="button" id="logBtn" value="Login" />
 30 |           <span class="error-msg" id="login-error"></span>
 31 |         </div>
 32 |       </div>
 33 |     </div>
 34 | 
 35 |     <div id="info-div" class="panel" style="display: none;">
 36 |       <div class="panel-head">
 37 |         <h3 class="panel-title">Basic Information</h3>
 38 |       </div>
 39 |       <div class="panel-body">
 40 |         <div class="panel-line">
 41 |           <span class="line-start">Player Name</span>
 42 |           <span class="line-end" id="player-name"></span>
 43 |         </div>
 44 |         <div class="panel-line">
 45 |           <span class="line-start">Steve Model</span>
 46 |           <span class="line-mid" id="steve-model-hash">Not Set</span>
 47 |           <input class="panel-btn line-end" type="button" id="remove-steve-model" value="Remove"/>
 48 |           <input class="panel-btn line-end" type="button" id="upload-steve-model" value="Upload"/>
 49 |           <input class="panel-btn line-end" type="button" id="switch-steve-model" value="Switch"/>
 50 |         </div>
 51 |         <div class="panel-line">
 52 |           <span class="line-start">Alex Model</span>
 53 |           <span class="line-mid" id="alex-model-hash">Not Set</span>
 54 |           <input class="panel-btn line-end" type="button" id="remove-alex-model" value="Remove"/>
 55 |           <input class="panel-btn line-end" type="button" id="upload-alex-model" value="Upload"/>
 56 |           <input class="panel-btn line-end" type="button" id="switch-alex-model" value="Switch"/>
 57 |         </div>
 58 |         <div class="panel-line">
 59 |           <span class="line-start">Cape Model</span>
 60 |           <span class="line-mid" id="cape-model-hash">Not Set</span>
 61 |           <input class="panel-btn line-end" type="button" id="remove-cape-model" value="Remove"/>
 62 |           <input class="panel-btn line-end" type="button" id="upload-cape-model" value="Upload"/>
 63 |           <input class="panel-btn line-end" type="button" id="switch-cape-model" value="Switch"/>
 64 |         </div>
 65 |         <div class="panel-line">
 66 |           <span class="line-start">Elytra Model</span>
 67 |           <span class="line-mid" id="elytra-model-hash">Not Set</span>
 68 |           <input class="panel-btn line-end" type="button" id="remove-elytra-model" value="Remove"/>
 69 |           <input class="panel-btn line-end" type="button" id="upload-elytra-model" value="Upload"/>
 70 |           <input class="panel-btn line-end" type="button" id="switch-elytra-model" value="Switch"/>
 71 |         </div>
 72 |         <div class="panel-line">
 73 |           <span class="line-start">Steve Dynamic Model</span>
 74 |           <span class="line-mid" id="steve-dynamic-model-hash">Not Set</span>
 75 |           <input class="panel-btn line-end" type="button" id="remove-steve-dynamic-model" value="Remove"/>
 76 |           <input class="panel-btn line-end" type="button" id="upload-steve-dynamic-model" value="Append"/>
 77 |           <input class="panel-btn line-end" type="button" id="interval-steve-dynamic-model" value="Interval"/>
 78 |         </div>
 79 |         <div class="panel-line">
 80 |           <span class="line-start">Alex Dynamic Model</span>
 81 |           <span class="line-mid" id="alex-dynamic-model-hash">Not Set</span>
 82 |           <input class="panel-btn line-end" type="button" id="remove-alex-dynamic-model" value="Remove"/>
 83 |           <input class="panel-btn line-end" type="button" id="upload-alex-dynamic-model" value="Append"/>
 84 |           <input class="panel-btn line-end" type="button" id="interval-alex-dynamic-model" value="Interval"/>
 85 |         </div>
 86 |         <div class="panel-line">
 87 |           <span class="line-start">Cape Dynamic Model</span>
 88 |           <span class="line-mid" id="cape-dynamic-model-hash">Not Set</span>
 89 |           <input class="panel-btn line-end" type="button" id="remove-cape-dynamic-model" value="Remove"/>
 90 |           <input class="panel-btn line-end" type="button" id="upload-cape-dynamic-model" value="Append"/>
 91 |           <input class="panel-btn line-end" type="button" id="interval-cape-dynamic-model" value="Interval"/>
 92 |         </div>
 93 |         <div class="panel-line">
 94 |           <span class="line-start">Elytra Dynamic Model</span>
 95 |           <span class="line-mid" id="elytra-dynamic-model-hash">Not Set</span>
 96 |           <input class="panel-btn line-end" type="button" id="remove-elytra-dynamic-model" value="Remove"/>
 97 |           <input class="panel-btn line-end" type="button" id="upload-elytra-dynamic-model" value="Append"/>
 98 |           <input class="panel-btn line-end" type="button" id="interval-elytra-dynamic-model" value="Interval"/>
 99 |         </div>
100 |         <div class="panel-line">
101 |           <span class="line-start">Prefered Model</span>
102 |           <span class="line-mid" id="prefered-model">Alex</span>
103 |           <input class="panel-btn line-end" type="button" id="switch-prefered-model" value="Switch"/>
104 |         </div>
105 |       </div>
106 |     </div>
107 | 
108 |     <div id="img-div" class="panel" style="display: none;">
109 |       <div class="panel-head">
110 |         <h3 class="panel-title">Texture Preview</h3>
111 |       </div>
112 |       <div class="panel-body">
113 |         <img id="preview-img" src="" />
114 |       </div>
115 |     </div>
116 | 
117 |     <div id="manage-div" class="panel" style="display: none;">
118 |       <div class="panel-head">
119 |         <h3 class="panel-title">Account Management</h3>
120 |       </div>
121 |       <div class="panel-body">
122 |         <div class="panel-line">
123 |           <span class="line-start">Current Password</span>
124 |           <input type="password" id="current-passwd" class="line-end" />
125 |         </div>
126 |         <div class="panel-line">
127 |           <span class="line-start">New Password</span>
128 |           <input type="password" id="new-passwd" class="line-end" />
129 |         </div>
130 |         <div class="panel-line">
131 |           <input class="panel-btn" type="button" id="change-passwd" value="Change Password" />
132 |           <input class="panel-btn" type="button" id="delete-account" value="Delete Account" />
133 |           <input class="panel-btn" type="button" id="logout" value="Logout" />
134 |         </div>
135 |         <div class="panel-line">
136 |           <span class="error-msg" id="mgr-error"></span>
137 |         </div>
138 |       </div>
139 |     </div>
140 |     <input type="file" name='file' id='filechoose' style="display: none;"/>
141 |   </div>
142 | </body>
143 | </html>
144 | 


--------------------------------------------------------------------------------
/src/UniSkinServer.py:
--------------------------------------------------------------------------------
  1 | import tornado.web
  2 | import tornado.options
  3 | import tornado.ioloop
  4 | from tornado.web import RequestHandler
  5 | import logging
  6 | 
  7 | def capture_post(*args, **args_with_default):
  8 |     def real_wrapper(wrapped_func):
  9 |         def new_func(handler):
 10 |             argument_dict=dict()
 11 |             for arg in args:
 12 |                 try:
 13 |                     x = handler.get_argument(arg)
 14 |                     argument_dict[arg]=x
 15 |                 except tornado.web.MissingArgumentError:
 16 |                     handler.write('{"errno": 6, "msg":"Missing argument: %s"}'%arg)
 17 |                     argument_dict = None
 18 |                 if (argument_dict is None): return;
 19 |             for arg in args_with_default:
 20 |                 try:
 21 |                     x = handler.get_argument(arg)
 22 |                     argument_dict[arg]=x
 23 |                 except tornado.web.MissingArgumentError:
 24 |                     argument_dict[arg]=args_with_default[arg]
 25 |             ret = wrapped_func(handler, **argument_dict)
 26 |             if type(ret) is tuple and len(ret)==2 and type(ret[0]) is int and type(ret[1]) is str:
 27 |                 handler.write('{"errno":%d,"msg":"%s"}'%ret)
 28 |             else:
 29 |                 return ret
 30 |         return new_func
 31 |     return real_wrapper
 32 | 
 33 | def check_token(orig_func):
 34 |     def new_func(handler, **args):
 35 |         if "token" in args:
 36 |             name = sessionManager.get_name(args["token"])
 37 |             if name is not None:
 38 |                 args["name_by_token"] = name
 39 |                 return orig_func(handler, **args)
 40 |         handler.write('{"errno":1,"msg":"Bad token"}')
 41 |     return new_func
 42 | 
 43 | 
 44 | class TexturesHandler(tornado.web.StaticFileHandler):
 45 |     def set_extra_headers(self,path):
 46 |         self.set_header("Content-Type", "image/png")
 47 | 
 48 | class UserProfileHandler(RequestHandler):
 49 |     def get(self, player_name):
 50 |         if (not db.has_user(player_name)):
 51 |             self.set_status(404)
 52 |             return
 53 |         self.write(db.get_formatted(player_name, uss_runtime.UniSkinAPIFormatter))
 54 | 
 55 | class WebRegisterHandler(RequestHandler):
 56 |     @capture_post("login","passwd")
 57 |     def post(self, login, passwd):
 58 |         if not cfg["allow-reg"]:
 59 |             self.write('{"errno":7,"msg":"reg not allowed"}')
 60 |             return
 61 |         name = login
 62 |         if db.has_user(name):
 63 |             self.write('{"errno":5,"msg":"already registered"}')
 64 |             return
 65 |         if len(name)<=0:
 66 |             self.write('{"errno":3,"msg":"invalid name"}')
 67 |             return
 68 |         if len(passwd)<4:
 69 |             self.write('{"errno":2,"msg":"invalid pwd"}')
 70 |             return
 71 |         db.create_user(name,passwd)
 72 |         self.write('{"errno":0,"msg":""}')
 73 | 
 74 | class WebLoginHandler(RequestHandler):
 75 |     @capture_post("login","passwd")
 76 |     def post(self, login, passwd):
 77 |         if not db.is_passwd_match(login,passwd):
 78 |             self.write('{"errno":1,"msg":"invalid login"}')
 79 |         else:
 80 |             token=sessionManager.login(login)
 81 |             self.write('{"errno":0,"msg":"%s"}'%token)
 82 | 
 83 | class WebLogoutHandler(RequestHandler):
 84 |     @capture_post("token")
 85 |     @check_token
 86 |     def post(self, token, name_by_token):
 87 |         sessionManager.logout(token)
 88 |         self.write('{"errno":0,"msg":""}')
 89 | 
 90 | class WebDataAccessHandler(RequestHandler):
 91 |     @capture_post("token")
 92 |     @check_token
 93 |     def post(self, token, name_by_token):
 94 |         self.write(db.get_formatted(name_by_token, uss_runtime.WebDataFormatter))
 95 | 
 96 | class WebAccountDelHandler(RequestHandler):
 97 |     @capture_post("token","current_passwd","login")
 98 |     @check_token
 99 |     def post(self, token, current_passwd, login, name_by_token):
100 |         if not name_by_token==login:
101 |             return 6, "login not match"
102 |         if not db.is_passwd_match(name_by_token, current_passwd):
103 |             return 1, "bad password"
104 |         db.scan_user_hash(name_by_token, (lambda x: texture_cache.dec_hash(x)))
105 |         db.delete_user(name_by_token)
106 |         return 0,""
107 | 
108 | class WebChangePasswordHandler(RequestHandler):
109 |     @capture_post("token","current_passwd","login","new_passwd")
110 |     @check_token
111 |     def post(self, token, current_passwd, login, new_passwd, name_by_token):
112 |         if not name_by_token==login:
113 |             return 6, "login not match"
114 |         if not db.is_passwd_match(name_by_token, current_passwd):
115 |             return 1, "bad password"
116 |         if len(new_passwd)<4:
117 |             return 2, "invalid pwd"
118 |         db.change_pwd(name_by_token, new_passwd)
119 |         return 0,""
120 | 
121 | class WebModelPreferenceHandler(RequestHandler):
122 |     @capture_post("token","prefered_model")
123 |     @check_token
124 |     def post(self, token, name_by_token, prefered_model):
125 |         if prefered_model!='slim' and prefered_model!="default":
126 |             return 6,"invalid model"
127 |         else:
128 |             db.set_skin_model_preference(name_by_token, prefered_model)
129 |         return 0,""
130 | 
131 | class WebTypePreferenceHandler(RequestHandler):
132 |     @capture_post("token","type","preference")
133 |     @check_token
134 |     def post(self, token, name_by_token, type, preference):
135 |         if type!="skin" and type!="cape" and type!="elytra":
136 |             return 6, "invalid type"
137 |         if preference!="dynamic" and preference!="static" and preference!="off":
138 |             return 6, "invalid preference"
139 |         db.set_type_preference(name_by_token, type, preference)
140 |         return 0,""
141 | 
142 | class WebSetDynamicIntervalHandler(RequestHandler):
143 |     @capture_post("token","type","interval")
144 |     @check_token
145 |     def post(self, token, name_by_token, type, interval):
146 |         if type!="skin_slim" and type!="skin_default" and type!="cape" and type!="elytra":
147 |             return 6, "invalid type"
148 |         i=None
149 |         try:
150 |             i=int(interval)
151 |         except:
152 |             pass
153 |         if i is None or i<=0:
154 |             return 6, "invalid interval"
155 |         db.set_dynamic_interval(name_by_token, type, i)
156 |         return 0,""
157 | 
158 | class WebSkinModificationHandler(RequestHandler):
159 |     @capture_post("token","model","type")
160 |     @check_token
161 |     def post(self,token,name_by_token,model,type):
162 |         if model!="skin_slim" and model!="skin_default" and model!="cape" and model!="elytra":
163 |             return 6, "invalid model"
164 |         if type!="static" and type!="dynamic":
165 |             return 6, "invalid type"
166 |         import hashlib
167 |         skin_file=self.request.files.get('file')[0]
168 |         file_bin=skin_file['body']
169 |         if len(file_bin) > cfg["max-file-size"]:
170 |             return 9, "file too large"
171 |         m=hashlib.sha256()
172 |         m.update(file_bin)
173 |         hex_name=m.hexdigest()
174 |         texture_cache.inc_hash(hex_name)
175 |         open(cfg["texture-folder"]+hex_name,'wb').write(file_bin)
176 |         db.set_texture_hash(name_by_token, model, type=="dynamic", hex_name)
177 |         return 0,""
178 | 
179 | class WebSkinDeleteHandler(RequestHandler):
180 |     @capture_post("token","model","type")
181 |     @check_token
182 |     def post(self,token,name_by_token,model,type):
183 |         if model!="skin_slim" and model!="skin_default" and model!="cape" and model!="elytra":
184 |             return 6, "invalid model"
185 |         if type!="static" and type!="dynamic":
186 |             return 6, "invalid type"
187 |         db.del_texture_hash(name_by_token, model, type=="dynamic", (lambda x: texture_cache.dec_hash(x)))
188 |         return 0,""
189 | 
190 | def stop_server():
191 |     db.close()
192 |     tornado.ioloop.IOLoop.instance().stop()
193 |     logging.info('exit success')
194 | 
195 | def run_server():
196 |     handlers=[(r"/textures/(.*)",    TexturesHandler,{"path":cfg["texture-folder"]}),
197 |               (r"/(.*).json",        UserProfileHandler),
198 | 
199 |               (r"/",                 tornado.web.RedirectHandler,  {"url" :"/index.html"}),
200 |               (r"/(index\.html)",    tornado.web.StaticFileHandler,{"path":"static"}),
201 |               (r"/(favicon\.png)",   tornado.web.StaticFileHandler,{"path":"static"}),
202 |               (r"/static/(.*)",      tornado.web.StaticFileHandler,{"path":"static"}),
203 | 
204 |               (r"/register",         WebRegisterHandler),
205 |               (r"/login",            WebLoginHandler),
206 |               (r"/logout",           WebLogoutHandler),
207 |               (r"/userdata",         WebDataAccessHandler),
208 |               (r"/delete_account",   WebAccountDelHandler),
209 |               (r"/chpwd",            WebChangePasswordHandler),
210 |               (r"/model_preference", WebModelPreferenceHandler),
211 |               (r"/type_preference",  WebTypePreferenceHandler),
212 |               (r"/dynamic_interval", WebSetDynamicIntervalHandler),
213 |               (r"/upload_texture",   WebSkinModificationHandler),
214 |               (r"/delete_texture",   WebSkinDeleteHandler),
215 |               #(r"/adm_action",       WebAdministrationHandler),
216 | 
217 |               (r".*",                tornado.web.ErrorHandler,{"status_code":404})]
218 |     try:
219 |         import signal
220 |         tornado.options.parse_command_line()
221 |         on_signal=(lambda sig, frame: tornado.ioloop.IOLoop.instance().add_callback_from_signal(stop_server))
222 |         signal.signal(signal.SIGINT, on_signal)
223 |         signal.signal(signal.SIGTERM, on_signal)
224 |         application=tornado.web.Application(handlers,debug=True,compress_response=True)
225 |         application.listen(cfg["port"])
226 |         print("Starting UniSkinServer on port:",cfg["port"])
227 |         tornado.ioloop.IOLoop.instance().start()
228 |     except Exception as e:
229 |         print(e)
230 |         print("Now server quit.")
231 | 
232 | import uss_config
233 | from uss_database import uss_database
234 | import uss_runtime
235 | 
236 | if __name__=="__main__":
237 |     global cfg, db, texture_cache, sessionManager
238 |     cfg=uss_config.get_config()
239 |     if cfg is None:
240 |         print("Error Occurred, check your config please.")
241 |     else:
242 |         db=uss_database(cfg["database-path"])
243 |         texture_cache=uss_runtime.TextureManager(cfg["texture-folder"])
244 |         db.scan_hashes((lambda hash: texture_cache.inc_hash(hash)))
245 |         texture_cache.force_clean()
246 |         sessionManager=uss_runtime.SessionManager(cfg["session-time"])
247 |         run_server()
248 | 


--------------------------------------------------------------------------------
/src/static/scripts.js:
--------------------------------------------------------------------------------
  1 | var session_token="";
  2 | var target_model="";
  3 | var local_data={};
  4 | 
  5 | if (typeof String.prototype.endsWith != 'function') {
  6 |   String.prototype.endsWith = function(suffix) {
  7 |     return this.indexOf(suffix, this.length - suffix.length) !== -1;
  8 |   };
  9 | }
 10 | 
 11 | function fillModelStatus(n1,l,n2){
 12 |   if(n1 in l){
 13 |     var ll='<a href="#'+l[n1]+'" class="texture-preview">Display Texture</a>';
 14 |     $('#remove'+n2+'Model').show();
 15 |     $('#upload'+n2+'Model').hide();
 16 |     $('#'+n2+'model').html("");
 17 |     $('#'+n2+'model').append(ll);
 18 |   }else{
 19 |     $('#'+n2+'model').html("Not Uploaded");
 20 |     $('#remove'+n2+'Model').hide();
 21 |     $('#upload'+n2+'Model').show();
 22 |   }
 23 | }
 24 | 
 25 | function fillPair(model, isOff, isDyn, dynHash, staticHash) {
 26 |   if (isOff) {
 27 |     $('#remove-'+model+'-model').hide();
 28 |     $('#upload-'+model+'-model').hide();
 29 |     $('#switch-'+model+'-model').show();
 30 |     $('#'+model+'-model-hash').html('Model off');
 31 |     $('#remove-'+model+'-dynamic-model').hide();
 32 |     $('#upload-'+model+'-dynamic-model').hide();
 33 |     $('#interval-'+model+'-dynamic-model').hide();
 34 |     $('#'+model+'-dynamic-model-hash').html('Model off');
 35 |     return
 36 |   }
 37 |   if (isDyn == true) {
 38 |     $('#remove-'+model+'-model').hide();
 39 |     $('#upload-'+model+'-model').hide();
 40 |     $('#switch-'+model+'-model').show();
 41 |     $('#'+model+'-model-hash').html('Using dynamic skin.');
 42 | 
 43 |     $("#upload-"+model+"-dynamic-model").show();
 44 |     if (dynHash == undefined || dynHash.hashes == undefined || dynHash.hashes.length == 0) {
 45 |       $("#"+model+"-dynamic-model-hash").html('Not Uploaded');
 46 |       $("#interval-"+model+"-dynamic-model").hide();
 47 |       $("#remove-"+model+"-dynamic-model").hide();
 48 |     } else {
 49 |       var str = "Interval: "+dynHash.interval;
 50 |       for (var i=0; i< dynHash.hashes.length; i++) {
 51 |         str += '<br/>\n'+dynHash.hashes[i];
 52 |       }
 53 |       $("#"+model+"-dynamic-model-hash").html(str);
 54 |       $("#interval-"+model+"-dynamic-model").show();
 55 |       $("#remove-"+model+"-dynamic-model").show();
 56 |     }
 57 |   } else {
 58 |     $("#upload-"+model+"-dynamic-model").hide();
 59 |     $("#interval-"+model+"-dynamic-model").hide();
 60 |     $("#remove-"+model+"-dynamic-model").hide();
 61 |     $("#"+model+"-dynamic-model-hash").html('Using static skin.');
 62 | 
 63 |     $('#switch-'+model+'-model').show();
 64 |     if(staticHash != undefined && staticHash != ""){
 65 |       $('#'+model+'-model-hash').html(staticHash);
 66 |       $('#remove-'+model+'-model').show();
 67 |       $('#upload-'+model+'-model').hide();
 68 |     } else {
 69 |       $('#'+model+'-model-hash').html("Not Uploaded");
 70 |       $('#remove-'+model+'-model').hide();
 71 |       $('#upload-'+model+'-model').show();
 72 |     }
 73 |   }
 74 | }
 75 | 
 76 | $(document).ready(function(){
 77 |   refresh=(function(){
 78 |     $("#login-error").html('');
 79 |     $("#mgr-error").html('');
 80 |     $.ajax({
 81 |       url: "/userdata",
 82 |       type: "POST",
 83 |       data: {"token": session_token},
 84 |       dataType: "json",
 85 |       success: (function(data,stat){
 86 |         if(stat!="success"){
 87 |           alert("Server Down. Please try later");
 88 |           return;
 89 |         }
 90 |         if('errno' in data){
 91 |           alert('Failed to refresh data');
 92 |           return;
 93 |         }
 94 |         local_data=data;
 95 |         $("#player-name").html(data.username);
 96 | 
 97 |         fillPair("steve", data.type_preference.skin=="off", data.type_preference.skin=="dynamic", data.textures.skin_default_dynamic, data.textures.skin_default_static)
 98 |         fillPair("alex", data.type_preference.skin=="off", data.type_preference.skin=="dynamic", data.textures.skin_slim_dynamic, data.textures.skin_slim_static)
 99 |         fillPair("cape", data.type_preference.cape=="off", data.type_preference.cape=="dynamic", data.textures.cape_dynamic, data.textures.cape_static)
100 |         fillPair("elytra", data.type_preference.elytra=="off", data.type_preference.elytra=="dynamic", data.textures.elytra_dynamic, data.textures.elytra_static)
101 | 
102 |         $("#prefered-model").html(data.model_preference=='slim'?"Alex":"Steve");
103 | 
104 |         $('#login-name').val('');
105 |         $('#pwd').val('');
106 |         $('#current-passwd').val('');
107 |         $('#new-passwd').val('');
108 |         $('#mgr-error').html('');
109 |         $("#login-div").slideUp();
110 |         $("#info-div").slideDown();
111 |         $("#img-div").slideUp();
112 |         $("#manage-div").slideDown();
113 |       })
114 |     });
115 |   });
116 | 
117 |   doLogin=(function(login,pwd){
118 |     //console.log("Ready to login with "+login+"/"+pwd);
119 |     $.ajax({
120 |       url: "/login",
121 |       type: "POST",
122 |       data: {
123 |         "login": login,
124 |         "passwd": pwd
125 |       },
126 |       dataType: "json",
127 |       success: (function(data,stat){
128 |         if(stat!="success"){
129 |           $("#login-error").html("Login fail. Please try later.");
130 |           return;
131 |         }
132 |         var result=data.errno;
133 |         if(result==0){
134 |           token=data.msg;
135 |           //console.log("Login Success with token: "+token);
136 |           session_token=token;
137 |           setTimeout(refresh,500);
138 |         }else{
139 |           $("#login-error").html("Invalid Login");
140 |         }
141 |       })
142 |     });
143 |   });
144 | 
145 |   $("#regBtn").click(function(){
146 |     $("#login-error").html('');
147 |     var login=$("#login-name").val();
148 |     var pwd=$("#pwd").val();
149 |     $.ajax({
150 |       url: "/register",
151 |       type: "POST",
152 |       data: {
153 |         "login": login,
154 |         "passwd": pwd
155 |       },
156 |       dataType: "json",
157 |       success: (function(data,stat){
158 |         if(stat!="success"){
159 |           $("#login-error").html("Register fail. Please try later.");
160 |           return;
161 |         }
162 |         if(data.errno==0){
163 |           //console.log("Register Success, ready to login with "+login+"/"+pwd);
164 |           setTimeout(function(){doLogin(login,pwd);},1000);
165 |         }else{
166 |           $("#login-error").html(data.msg);
167 |         }
168 |       })
169 |     });
170 |   });
171 | 
172 |   $("#logBtn").click(function(){
173 |     $("#login-error").html('');
174 |     var login=$("#login-name").val();
175 |     var pwd=$("#pwd").val();
176 |     doLogin(login,pwd);
177 |   });
178 | 
179 |   $("#logout").click(function(){
180 |     $.ajax({
181 |       url: "/logout",
182 |       type: "POST",
183 |       data: {'token': session_token},
184 |       complete: (function(a,b){
185 |         $('#login-error').html('');
186 |         $("#login-div").slideDown();
187 |         $("#info-div").slideUp();
188 |         $("#manage-div").slideUp();
189 |         $("#img-div").slideUp();
190 |         $('#login-name').val('');
191 |         $('#pwd').val('');
192 |       })
193 |     });
194 |   });
195 | 
196 |   $("#change-passwd").click(function(){
197 |     $('#mgr-error').html('');
198 |     var old_pwd=$("#current-passwd").val();
199 |     var new_pwd=$("#new-passwd").val();
200 |     $.ajax({
201 |       url: '/chpwd',
202 |       type: "POST",
203 |       data: {
204 |         'token': session_token,
205 |         'new_passwd': new_pwd,
206 |         'current_passwd': old_pwd,
207 |         'login': $('#player-name').html()
208 |       },
209 |       dataType: 'json',
210 |       success: (function(a,b){
211 |         if (a.errno==0){
212 |           $('#mgr-error').html('Success');
213 |         }else{
214 |           $('#mgr-error').html(a.msg);
215 |         }
216 |       })
217 |     });
218 |   });
219 | 
220 |   function set_dynamic_prefer(model) {
221 |     var t= ""
222 |     if (local_data.type_preference[model]=="static") t = "dynamic";
223 |     if (local_data.type_preference[model]=="dynamic") t = "off";
224 |     if (local_data.type_preference[model]=="off") t = "static";
225 |     $.ajax({
226 |       url: '/type_preference',
227 |       type: "POST",
228 |       data: {
229 |         'token': session_token,
230 |         'type': model,
231 |         'preference': t,
232 |       },
233 |       dataType: 'json',
234 |       success: (function(a,b){
235 |         if(a.errno!=0)
236 |           alert("Error: "+a.msg);
237 |         else
238 |           setTimeout(refresh,500);
239 |       })
240 |     });
241 |   }
242 |   $("#switch-steve-model").click(function(){set_dynamic_prefer("skin")});
243 |   $("#switch-alex-model").click(function(){set_dynamic_prefer("skin")});
244 |   $("#switch-cape-model").click(function(){set_dynamic_prefer("cape")});
245 |   $("#switch-elytra-model").click(function(){set_dynamic_prefer("elytra")});
246 | 
247 |   $(document).on('change','#filechoose',function(e){
248 |     e.preventDefault();
249 |     //console.log('changed');
250 |     if(target_model=="")return;
251 |     var f=$('#filechoose')[0].files[0];
252 |     var m=target_model;target_model="";
253 |     if(!f.name.endsWith('.png')){
254 |       alert("Only png files are acceptable");
255 |       $('#filechoose').val(null);
256 |       return;
257 |     }
258 |     if(f.size>1024*1024){
259 |       alert("File too large. Max: 1MB");
260 |       $('#filechoose').val(null);
261 |       return;
262 |     }
263 |     $.ajaxFileUpload({
264 |       url: "/upload_texture",
265 |       secureurl: false,
266 |       fileElementId: "filechoose",
267 |       data: {
268 |         "token": session_token,
269 |         'model': m.model,
270 |         "type": m.type
271 |       },
272 |       dataType: "json",
273 |       success: function(data,stat){
274 |         //alert(data.msg);
275 |         $('#filechoose').val(null);
276 |         if(data.errno!=0)
277 |           alert("Error Happened: "+data.msg);
278 |         else
279 |           setTimeout(refresh,500);
280 |       }
281 |     });
282 |     return false;
283 |   });
284 |   uploadModel=(function(model, type){
285 |     target_model={'model':model, 'type': type};
286 |     $('#filechoose').val(null);
287 |     $('#filechoose').click();
288 |   });
289 |   $('#upload-steve-model').click(function(){uploadModel('skin_default','static')});
290 |   $('#upload-alex-model').click(function(){uploadModel('skin_slim','static')});
291 |   $('#upload-cape-model').click(function(){uploadModel('cape','static')});
292 |   $('#upload-elytra-model').click(function(){uploadModel('elytra','static')});
293 |   $('#upload-steve-dynamic-model').click(function(){uploadModel('skin_default','dynamic')});
294 |   $('#upload-alex-dynamic-model').click(function(){uploadModel('skin_slim','dynamic')});
295 |   $('#upload-cape-dynamic-model').click(function(){uploadModel('cape','dynamic')});
296 |   $('#upload-elytra-dynamic-model').click(function(){uploadModel('elytra','dynamic')});
297 | 
298 |   removeModel=(function(model, type){
299 |     //console.log("Model Remove "+modelName);
300 |     var token=$("#token").val()
301 |     $.ajax({
302 |       url: "/delete_texture",
303 |       type: "POST",
304 |       data: {
305 |         "model": model,
306 |         "token": session_token,
307 |         "type": type
308 |       },
309 |       dataType: "json",
310 |       success: function(data,stat){
311 |         if (data.errno==0){
312 |           setTimeout(refresh,500);
313 |         } else {
314 |           alert("Error: " +data.msg);
315 |         }
316 |       }
317 |     });
318 |   });
319 |   $('#remove-steve-model').click(function(){removeModel('skin_default','static')});
320 |   $('#remove-alex-model').click(function(){removeModel('skin_slim','static')});
321 |   $('#remove-cape-model').click(function(){removeModel('cape','static')});
322 |   $('#remove-elytra-model').click(function(){removeModel('elytra','static')});
323 |   $('#remove-steve-dynamic-model').click(function(){removeModel('skin_default','dynamic')});
324 |   $('#remove-alex-dynamic-model').click(function(){removeModel('skin_slim','dynamic')});
325 |   $('#remove-cape-dynamic-model').click(function(){removeModel('cape','dynamic')});
326 |   $('#remove-elytra-dynamic-model').click(function(){removeModel('elytra','dynamic')});
327 | 
328 |   setInter=(function(model){
329 |     var token=$("#token").val()
330 |     var new_interval = prompt("New Interval?");
331 |     if (new_interval==null) return;
332 |     $.ajax({
333 |       url: "/dynamic_interval",
334 |       type: "POST",
335 |       data: {
336 |         "token": session_token,
337 |         "type": model,
338 |         "interval": new_interval
339 |       },
340 |       dataType: "json",
341 |       success: function(data,stat){
342 |         if (data.errno==0){
343 |           setTimeout(refresh,500);
344 |         } else {
345 |           alert("Error: " +data.msg);
346 |         }
347 |       }
348 |     });
349 |   });
350 |   $('#interval-steve-dynamic-model').click(function(){setInter('skin_default')});
351 |   $('#interval-alex-dynamic-model').click(function(){setInter('skin_slim')});
352 |   $('#interval-cape-dynamic-model').click(function(){setInter('cape')});
353 |   $('#interval-elytra-dynamic-model').click(function(){setInter('elytra')});
354 | 
355 |   $('#switch-prefered-model').click(function(){
356 |     var x=$('#prefered-model').html();
357 |     $.ajax({
358 |       url: "/model_preference",
359 |       type: "POST",
360 |       data: {
361 |         "prefered_model": x=="Alex"?"default":"slim",
362 |         "token": session_token
363 |       },
364 |       dataType: "json",
365 |       success: function(data,stat){
366 |         //alert(data.msg);
367 |         if(data.errno!=0)
368 |           alert("Error: "+data.msg);
369 |         else
370 |           setTimeout(refresh,500);
371 |       }
372 |     });
373 |   });
374 | 
375 |   $(document).on('click','.texture-preview',function(e){
376 |     s=e.currentTarget.getAttribute('href').substr(1);
377 |     $("#img-div").slideUp('normal',function(){
378 |       document.getElementById("preview-img").setAttribute("src","/textures/"+s);
379 |       $("#img-div").slideDown('normal');
380 |     });
381 |   });
382 | 
383 |   $("#delete-account").click(function(){
384 |     $('#mgr-error').html('');
385 |     if(confirm('Do you really want to delete your account?')){
386 |       $.ajax({
387 |         url: "/delete_account",
388 |         type: "POST",
389 |         data: {
390 |           "current_passwd": $("#current-passwd").val(),
391 |           "token": session_token,
392 |           'login': $('#player-name').html()
393 |         },
394 |         dataType: "json",
395 |         success: function(data,stat){
396 |           //alert(data.msg);
397 |           if(data.errno==0){
398 |             setTimeout(function(){$('#logout').click();},500);
399 |           }else{
400 |             $('#mgr-error').html('Account not deleted');
401 |           }
402 |         }
403 |       });
404 |     }
405 |   });
406 | });
407 | 


--------------------------------------------------------------------------------