Bump golang.org/x/net from 0.0.0-20210324205630-d1beb07c2056 to 0.7.0

Bumps [golang.org/x/net](https://github.com/golang/net) from 0.0.0-20210324205630-d1beb07c2056 to 0.7.0.
- [Release notes](https://github.com/golang/net/releases)
- [Commits](https://github.com/golang/net/commits/v0.7.0)

---
updated-dependencies:
- dependency-name: golang.org/x/net
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

.gitignore

@@ -1,15 +1,16 @@
+test-results/
+tmp/
+routes/
+/none
 /src
 pkg
 bin2
 bin/i18n
-bin/leanote-linux
-bin/leanote-mac
+bin/leanote*
 bin/release
+bin/test.sh
 bin/tmp
 bin/test
-bin/src
-conf/app.conf
-conf/routes
 public/upload
 app/routes/routes.go
 app/tmp/main.go
@@ -17,4 +18,11 @@ app/tmp/main.go
 .settings
 .project
 public/config.codekit
-files
+files/
+/node_modules
+.idea
+*.iml
+target/
+package/leanote.tar.gz
+package/leanote/
+leanote.log

.project

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>leanote2</name>
-	<comment>leanote, your own cloud note!</comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.googlecode.goclipse.goBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>goclipse.goNature</nature>
-	</natures>
-</projectDescription>

.travis.yml

@@ -0,0 +1,47 @@
+language: go
+go: 1.15
+
+services:
+  - mongodb # 2.4.12
+
+install:
+  - go version
+  - export PATH=$PATH:$HOME/gopath/bin
+  # - go get -v github.com/leanote/leanote/app
+  - go get -u github.com/revel/cmd/revel
+  # - ls $GOPATH/src/github.com/revel/
+  # - go get github.com/revel/moudle/revel
+  # - go install github.com/revel/cmd/revel
+  - revel version
+  - pwd
+  - ls
+
+script:
+  - wget https://github.com/leanote/leanote/archive/refs/heads/master.zip
+  - unzip master.zip
+  - mv leanote-master leanote
+  - cd leanote
+
+  - mongo --version
+  - mongorestore -h localhost -d leanote --dir ./mongodb_backup/leanote_install_data/
+
+  - cd ./sh
+  # - cd $GOPATH/src/github.com/leanote/leanote/sh
+  - sh run.sh &
+
+  # gen tmp/main.go, routes/routes.go
+  #- go run app/cmd/main.go
+  # build
+  #- go build -o leanote github.com/leanote/leanote/app/tmp
+  # run with port 9000
+  #- ./leanote -importPath=github.com/leanote/leanote -runMode=dev -port=9000 &
+
+  - sleep 10s;
+  # test
+  - curl http://localhost:9000
+  - curl http://localhost:9000/blog
+  - curl http://localhost:9000/login
+  - curl http://localhost:9000/demo
+
+  # - revel build github.com/leanote/leanote tmp
+  # OK

Gulpfile.js

@@ -0,0 +1,409 @@
+var gulp = require('gulp');
+var clean = require('gulp-clean');
+var uglify = require('gulp-uglify');
+var rename = require('gulp-rename');
+var minifyHtml = require("gulp-minify-html");
+var concat = require('gulp-concat');
+var replace = require('gulp-replace');
+var inject = require('gulp-inject');
+var gulpSequence = require('gulp-sequence');
+
+var fs = require('fs');
+
+var leanoteBase = './';
+var base = leanoteBase + '/public'; // public base
+var noteDev = leanoteBase + '/app/views/note/note-dev.html';
+var noteProBase = leanoteBase + '/app/views/note';
+
+var messagesPath = leanoteBase + 'messages';
+
+// 合并Js, 这些js都是不怎么修改, 且是依赖
+// 840kb, 非常耗时!!
+gulp.task('concatDepJs', function() {
+    var jss = [
+        'js/jquery-1.9.0.min.js',
+        'js/jquery.ztree.all-3.5-min.js',
+        // 'tinymce/tinymce.full.min.js', // 使用打成的包, 加载速度快
+        // 'libs/ace/ace.js',
+        'js/jQuery-slimScroll-1.3.0/jquery.slimscroll-min.js',
+        'js/contextmenu/jquery.contextmenu-min.js',
+        'js/bootstrap-min.js',
+        'js/object_id.js',
+    ];
+
+    for(var i in jss) {
+        jss[i] = base + '/' + jss[i];
+    }
+
+    return gulp
+        .src(jss)
+        // .pipe(uglify()) // 压缩
+        .pipe(concat('dep.min.js'))
+        .pipe(gulp.dest(base + '/js'));
+});
+
+// 合并app js 这些js会经常变化 90kb
+gulp.task('concatAppJs', function() {
+    var jss = [
+        'js/common.js',
+        'js/app/note.js',
+        'js/app/page.js', // 写作模式下, page依赖note
+        'js/app/tag.js',
+        'js/app/notebook.js',
+        'js/app/share.js',
+    ];
+
+    for(var i in jss) {
+        jss[i] = base + '/' + jss[i];
+    }
+
+    return gulp
+        .src(jss)
+        .pipe(uglify()) // 压缩
+        .pipe(concat('app.min.js'))
+        .pipe(gulp.dest(base + '/js'));
+});
+
+// plugins压缩
+gulp.task('plugins', function() {
+    // gulp.src(base + '/js/plugins/libs/*.js')
+    //     .pipe(uglify()) // 压缩
+    //     // .pipe(concat('main.min.js'))
+    //     .pipe(gulp.dest(base + '/js/plugins/libs-min'));
+
+    // 所有js合并成一个
+     var jss = [
+        'note_info',
+        'tips',
+        'history',
+        'attachment_upload',
+        'editor_drop_paste',
+        'main'
+    ];
+
+    for(var i in jss) {
+        jss[i] = base + '/js/plugins/' + jss[i] + '.js';
+    }
+    jss.push(base + '/js/plugins/libs-min/fileupload.js');
+
+    return gulp.src(jss)
+        .pipe(uglify()) // 压缩
+        .pipe(concat('main.min.js'))
+        .pipe(gulp.dest(base + '/js/plugins'));
+});
+
+// 合并requirejs和markdown为一个文件
+gulp.task('concatMarkdownJs', function() {
+    var jss = [
+        'js/require.js',
+        'md/main.min.js',
+    ];
+
+    for(var i in jss) {
+        jss[i] = base + '/' + jss[i];
+    }
+
+    return gulp
+        .src(jss)
+        .pipe(uglify()) // 压缩
+        .pipe(concat('markdown.min.js'))
+        .pipe(gulp.dest(base + '/js'));
+});
+
+// / 合并requirejs和markdown为一个文件
+gulp.task('concatMarkdownJsV2', function() {
+    var jss = [
+        'js/require.js',
+        'md/main-v2.min.js',
+    ];
+
+    for(var i in jss) {
+        jss[i] = base + '/' + jss[i];
+    }
+
+    return gulp
+        .src(jss)
+        .pipe(uglify()) // 压缩
+        .pipe(concat('markdown-v2.min.js'))
+        .pipe(gulp.dest(base + '/js'));
+});
+
+// note-dev.html -> note.html, 替换css, js
+// TODO 加?t=2323232, 强制浏览器更新, 一般只需要把app.min.js上加
+gulp.task('devToProHtml', function() {
+    return gulp
+        .src(noteDev)
+        .pipe(replace(/<!-- dev -->[.\s\S]+?<!-- \/dev -->/g, '')) // 把dev 去掉
+        .pipe(replace(/<!-- pro_dep_js -->/, '<script src="/js/dep.min.js"></script>')) // 替换
+        .pipe(replace(/<!-- pro_app_js -->/, '<script src="/js/app.min.js"></script>')) // 替换
+        // .pipe(replace(/<!-- pro_markdown_js -->/, '<script src="/js/markdown.min.js"></script>')) // 替换
+        .pipe(replace(/<!-- pro_markdown_js -->/, '<script src="/js/markdown-v2.min.js"></script>')) // 替换
+        .pipe(replace('/tinymce/tinymce.js', '/tinymce/tinymce.full.min.js')) // 替换
+        .pipe(replace(/<!-- pro_tinymce_init_js -->/, "var tinyMCEPreInit = {base: '/public/tinymce', suffix: '.min'};")) // 替换
+        .pipe(replace(/plugins\/main.js/, "plugins/main.min.js")) // 替换
+        // 连续两个空行换成一个空行
+        .pipe(replace(/\r\n\r\n/g, '\r\n'))
+        .pipe(replace(/\r\n\r\n/g, '\r\n'))
+        .pipe(replace(/\r\n\r\n/g, '\r\n'))
+        .pipe(replace(/\r\n\r\n/g, '\r\n'))
+        .pipe(replace(/\r\n\r\n/g, '\r\n'))
+        .pipe(replace(/\r\n\r\n/g, '\r\n'))
+        .pipe(replace('console.log(o);', ''))
+        .pipe(replace('console.trace(o);', ''))
+        // .pipe(minifyHtml()) // 不行, 压缩后golang报错
+        .pipe(rename('note.html'))
+        .pipe(gulp.dest(noteProBase));
+});
+
+// 只获取需要js i18n的key
+var path = require('path');
+gulp.task('i18n', function() {
+    var keys = {};
+    var reg = /getMsg\(["']+(.+?)["']+/g;
+    // {rule: "required", msg: "inputNewPassword"},
+    var reg2 = /msg: ?"?([0-9a-zA-Z]*)"?/g;
+    function getKey(data) {
+        while(ret = reg.exec(data)) {
+            keys[ret[1]] = 1;
+        }
+
+        while(ret2 = reg2.exec(data)) {
+            keys[ret2[1]] = 1;
+        }
+    }
+    // 先获取需要的key
+    function ls(ff) { 
+        var files = fs.readdirSync(ff);  
+        for(fn in files) {  
+            var fname = ff + path.sep + files[fn];  
+            var stat = fs.lstatSync(fname);  
+            if(stat.isDirectory() == true) {
+                ls(fname);
+            } 
+            else {
+                if ((fname.indexOf('.html') > 0 || fname.indexOf('.js') > 0)) {
+                    // console.log(fname);
+                    // if (fname.indexOf('min.js') < 0) {
+                        var data = fs.readFileSync(fname, "utf-8");
+                        // 得到getMsg里的key
+                        getKey(data);
+                    // }
+                }
+            }  
+        }  
+    }
+
+    console.log('parsing used keys');
+
+    ls(base + '/admin');
+    ls(base + '/blog');
+    ls(base + '/md');
+    ls(base + '/js');
+    ls(base + '/album');
+    ls(base + '/libs');
+    ls(base + '/member');
+    ls(base + '/tinymce');
+
+    ls(leanoteBase + '/app/views');
+
+    console.log('parsed');
+    var langs = {}; // zh-cn: 1
+
+    // msg.zh
+    function getAllMsgs(fname) {
+        var msg = {};
+
+        var data = fs.readFileSync(fname, "utf-8");
+        var lines = data.split('\n');
+        for (var i = 0; i < lines.length; ++i) {
+            var line = lines[i];
+            // 忽略注释
+            if (line[0] == '#' || line[1] == '#') {
+                continue;
+            }
+            var lineArr = line.split('=');
+            if (lineArr.length >= 2) {
+               var key = lineArr[0];
+               lineArr.shift();
+               msg[key] = lineArr.join('=');
+               // msg[lineArr[0]] = lineArr[1];
+            }
+        }
+        return msg;
+    }
+
+    // 得到所有的语言的后缀
+    // 返回{en-us: 1, }
+    function getAllLangs() {
+        var langs = {};
+        var files = fs.readdirSync(messagesPath);  
+        for(fn in files) {
+            var fname = files[fn]; 
+            if (fname.indexOf('-') > 0) {
+                langs[fname] = 1;
+            }
+        }
+        return langs;
+    }
+
+    // msg.zh, msg.js
+    function genI18nJsFile(targetFilename, lang, fromFilenames, keys) {
+        var msgs = {};
+        fromFilenames.forEach(function (name) {
+            var tmpMsgs = getAllMsgs(leanoteBase + '/messages/' + lang + '/' + name + '.conf');
+            for (var i in tmpMsgs) {
+                msgs[i] = tmpMsgs[i];
+            }
+        });
+
+        var toMsgs = {};
+        for (var i in msgs) {
+            // 只要需要的
+            if (i in keys) {
+                toMsgs[i] = msgs[i];
+            }
+        }
+        var str = 'var MSG=' + JSON.stringify(toMsgs) + ';';
+        str += 'function getMsg(key, data) {var msg = MSG[key];if(msg) {if(data) {if(!isArray(data)) {data = [data];}' + 
+                        'for(var i = 0; i < data.length; ++i) {' + 
+                            'msg = msg.replace("%s", data[i]);' + 
+                        '}' + 
+                    '}' + 
+                    'return msg;' + 
+                '}' + 
+                'return key;' + 
+            '}';
+
+        // 写入到文件中
+        var toFilename = targetFilename + '.' + lang + '.js';
+        fs.writeFile(base + '/js/i18n/' + toFilename, str);
+    }
+
+    function genTinymceLang(lang) {
+        var msgs = getAllMsgs(leanoteBase + 'messages/' + lang + '/tinymce_editor.conf');
+        var str = 'tinymce.addI18n("' + lang + '",' + JSON.stringify(msgs) + ');';
+        fs.writeFile(base + '/tinymce/langs/' + lang + '.js', str);
+    }
+
+    var langs = getAllLangs();
+    for (var lang in langs) {
+        genI18nJsFile('blog', lang, ['blog'], keys);
+        genI18nJsFile('msg', lang, ['msg', 'member', 'markdown', 'album'], keys);
+
+        genTinymceLang(lang);
+    }
+    
+});
+
+// 合并album需要的js
+gulp.task('concatAlbumJs', function() {
+    /*
+    gulp.src(base + '/album/js/main.js')
+        .pipe(uglify()) // 压缩
+        .pipe(rename({suffix: '.min'}))
+        .pipe(gulp.dest(base + '/album/js/'));
+    */
+
+    gulp.src(base + '/album/css/style.css')
+        .pipe(rename({suffix: '-min'}))
+        .pipe(minifycss())
+        .pipe(gulp.dest(base + '/album/css'));
+
+    var jss = [
+        'js/jquery-1.9.0.min.js',
+        'js/bootstrap-min.js',
+        'js/plugins/libs-min/fileupload.js',
+        'js/jquery.pagination.js',
+        'album/js/main.js',
+    ];
+
+    for(var i in jss) {
+        jss[i] = base + '/' + jss[i];
+    }
+
+    return gulp
+        .src(jss)
+        .pipe(uglify()) // 压缩
+        .pipe(concat('main.all.js'))
+        .pipe(gulp.dest(base + '/album/js'));
+});
+
+// tinymce
+// please set the right path on your own env
+var tinymceBase = '/Users/life/leanote/leanote-tools/tinymce_4.1.9_leanote_public';
+gulp.task('tinymce', function() {
+    // 先清理
+    fs.unlink(tinymceBase + '/js/tinymce/tinymce.dev.js');
+    fs.unlink(tinymceBase + '/js/tinymce/tinymce.jquery.dev.js');
+    fs.unlink(tinymceBase + '/js/tinymce/tinymce.full.js');
+    fs.unlink(tinymceBase + '/js/tinymce/tinymce.full.min.js');
+
+    var cp = require('child_process');
+
+    var bundleCmd = 'grunt bundle --themes leanote --plugins autolink,link,leaui_image,leaui_mindmap,lists,hr,paste,searchreplace,leanote_nav,leanote_code,tabfocus,table,directionality,textcolor';
+    // build
+    cp.exec('grunt minify', {cwd: tinymceBase}, function(err, stdout, stderr) {
+        console.log('stdout: ' + stdout);
+        console.log('stderr: ' + stderr);
+
+        // 将所有都合并成一起
+        cp.exec(bundleCmd, {cwd: tinymceBase}, function(err, stdout, stderr) {
+            console.log('stdout: ' + stdout);
+            console.log('stderr: ' + stderr);
+        });
+    });
+});
+
+// 合并css, 无用
+// Deprecated
+gulp.task('concatCss', function() {
+    return gulp
+        .src([markdownRaw + '/css/default.css', markdownRaw + '/css/md.css'])
+        .pipe(concat('all.css'))
+        .pipe(gulp.dest(markdownMin));
+});
+
+// mincss
+var minifycss = require('gulp-minify-css');
+gulp.task('minifycss', function() {
+    gulp.src(base + '/css/bootstrap.css')
+        .pipe(rename({suffix: '-min'}))
+        .pipe(minifycss())
+        .pipe(gulp.dest(base + '/css'));
+
+    gulp.src(base + '/css/font-awesome-4.2.0/css/font-awesome.css')
+        .pipe(rename({suffix: '-min'}))
+        .pipe(minifycss())
+        .pipe(gulp.dest(base + '/css/font-awesome-4.2.0/css'));
+
+    gulp.src(base + '/css/zTreeStyle/zTreeStyle.css')
+        .pipe(rename({suffix: '-min'}))
+        .pipe(minifycss())
+        .pipe(gulp.dest(base + '/css/zTreeStyle'));
+
+    gulp.src(base + '/md/themes/default.css')
+        .pipe(rename({suffix: '-min'}))
+        .pipe(minifycss())
+        .pipe(gulp.dest(base + '/md/themes'));
+
+    gulp.src(base + '/js/contextmenu/css/contextmenu.css')
+        .pipe(rename({suffix: '-min'}))
+        .pipe(minifycss())
+        .pipe(gulp.dest(base + '/js/contextmenu/css'));
+
+    // theme
+    // 用codekit
+    var as = ['default', 'simple', 'writting', /*'writting-overwrite', */ 'mobile'];
+    /*
+    for(var i = 0; i < as.length; ++i) {
+        gulp.src(base + '/css/theme/' + as[i] + '.css')
+            .pipe(minifycss())
+            .pipe(gulp.dest(base + '/css/theme'));
+    }
+    */
+});
+
+
+gulp.task('concat', ['concatDepJs', 'concatAppJs', /* 'concatMarkdownJs', */'concatMarkdownJsV2']);
+gulp.task('html', ['devToProHtml']);
+gulp.task('default', ['concat', 'plugins', 'minifycss', 'i18n', 'concatAlbumJs', 'html']);

LICENSE

@@ -1,359 +0,0 @@
-leanote - you own cloud note!
-
-Copyright 2014 by the contributors
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-leanote is licensed under the GPL v2.
-
-                       life(life@leanote.com, lifephp@gmail.com)
-
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
-                       GNU GENERAL PUBLIC LICENSE
-                           Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                            NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    {description}
-    Copyright (C) {year}  {fullname}
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  {signature of Ty Coon}, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.

README.md

@@ -1,194 +1,188 @@
-[中文](https://github.com/leanote/leanote#1-介绍)
+# Leanote
+
+[![Build Status](https://travis-ci.org/leanote/leanote.svg)](https://travis-ci.org/leanote/leanote)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/leanote/leanote?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 ## 1. Introduction
 
-Leanote, note just a notebook!
+Leanote, not just a notepad!
+![leanote.png](leanote.png "")
 
-**Some Features**
+**Highlighted Features**
 
-* Knowledge: Manage your knowledge in leanote. leanote contains the tinymce editor and a markdown editor, just enjoy yourself writing.
-* Share: Share your knowledge with your friends in leanote. You can invite your friends to join your notepad in the cloud so you can share knowledge.
-* Cooperation: Collaborate with friends to improve your skills.
-* Blog: Publish your knowledge and make leanote your blog.
+* Note-taking made easy: Leanote incorporates a clean and intuitive interface, the `tinymce` rich-text editor and a dedicated *markdown* editor, making your writing/typing more efficient and enjoyable. For more advanced users, we even offer `Vim` and `Emacs` writing modes to help boost your writing speed to another level. 
+* Knowledge management: The flexible and versatile notebook-note-tagging system of Leanote makes it an ideal tool for knowledge management.
+* Sharing: Share your knowledge, thoughts and experiences with friends via Leanote. Invite your friends to join your notepad in the cloud.
+* Cooperating: Collaborate with colleagues to improve skills, fertilize ideas and brainstorm on the fly.
+* Blogging: Publish your work and make Leanote your personal blog.
 
-## 2. Why we created leanote
-To be honest, our inspiration comes from Evernote. We use Evernote to manage our knowledge everyday. But we find that:
-* Evernote's editor can't meet our needs, it does not have document navigation, it does not render code properly (as a programmer, syntax highlighted code rendering is a basic need), it cannot resize images and so forth
-* We like markdown, but Evernote does not support it.
-* We want to share our knowledge, so all of us have our blogs (e.g. on Wordpress) and our Evernote accounts, but why can not those two be one!
+**Other Features**
+
+* Markdown syntax support
+* Distraction-free writing mode
+* `Vim` and `Emacs` editing mode
+* Export notes to PDFs
+* Batch note operation
+* Customizable themes for blogging
+
+## 2. Why we create Leanote
+
+We have been using the popular note-taking software/service `Evernote` as our knowledge management tool on a daily basis. Benefited from and inspired by `Evernote`, we decided to create a brand-new tool that provides everything `Evernote` has to offer, plus a bunch of new features that `Evernote` failed to deliver, such as:
+
+* A more powerful editor: `Evernote`'s editor lacks the functionalities of **document navigation**, **syntax based code rendering** (as a programmer, syntax highlighted code rendering is a necessity), **image resizing** and so forth.
+* Everybody loves *markdown*, however `Evernote` simply wouldn't add it despite of years' of requests from users. So we will do the favor and bring a *markdown* enabled editor to you, guess what, it is also rendered in real-time!
+* If you a developer and miss the `Vim` or `Emacs` ways of writing, we offer you the choice of `Vim` and `Emacs` editing modes. Equipped with *markdown* syntax for text formatting, you will never need to touch your mouse while writing.
+* We love managing knowledge and thoughts as much as sharing them, so everybody has their own note account (`Evernote`, `Onenote`, `Google doc`, `Wiz note` etc.) and social media account (`Facebook`, `Wordpress`, blogs, etc.). But why can’t those two be one? Leanote makes this first step to bridge the private note-taking and public knowledge sharing seamlessly.
+* A complete and all-platform (sorry Windows phone) covering software suite: that includes Leanote Web & Server (this repository), [Desktop app](https://github.com/leanote/desktop-app), [iOS](https://github.com/leanote/leanote-ios), [Android](https://github.com/leanote/leanote-android). And they are all open source!
 * ......
 
-## 3. How to install leanote
+## 3. How to get Leanote
 
-### 3.1. Download leanote
+The Leanote software suite contains: Leanote Web & Server (this repository), [Desktop app](https://github.com/leanote/desktop-app), [iOS](https://github.com/leanote/leanote-ios), [Android](https://github.com/leanote/leanote-android). 
 
-Leanote V1.0-beta has been released. Binaries:
+Interested in our product and want to try it out from your web browser? Welcome to sign up on https://leanote.com. 
 
-* Linux: [leanote-linux-x86_64.v1.0-beta.bin.tar.gz](https://github.com/leanote/leanote/releases/download/1.0-beta/leanote-linux-x86_64.v1.0-beta.bin.tar.gz)
-* MacOS X: [leanote-mac-x86_64.v1.0-beta.bin.tar.gz](https://github.com/leanote/leanote/releases/download/1.0-beta/leanote-mac-x86_64.v1.0-beta.bin.tar.gz)
+Feeling suspicious about how those note-taking companies treat your personal data? You can install Leanote on your server, and use Leanote App (Desktop, iOS, Android) to sync notes with your self-hosted server.
 
-### 3.2. Install MongoDB
+More information about how to install Leanote please see:
 
-Leanote is written in go using [revel](https://revel.github.io/) and [MongoDB](https://www.mongodb.org). Thus, you need to first install MongoDB.
+* Leanote binary installation tutorial:
+    * [Windows](https://github.com/leanote/leanote/wiki/leanote-source-installation-on-Windows-(En))
+    * [Mac and Linux](https://github.com/leanote/leanote/wiki/leanote-binary-installation-on-Mac-and-Linux-(En))
+* Leanote source installation tutorial:
+    <!-- * [Windows](https://github.com/leanote/leanote/wiki/leanote-source-installation-on-Windows-(En)) -->
+    * [Mac and Linux](https://github.com/leanote/leanote/wiki/Leanote-source-installation-on-Mac-and-Linux-(En))
 
-For more tips please have a look at [our wiki](https://github.com/leanote/leanote/wiki/Install-Mongodb)
+## 4. Documentation
 
-### 3.3. Import initial MongoDB data
-
-The mongodb data is in `[PATH_TO_LEANOTE]/mongodb_backup/leanote_install_data`
-
-```
-$> mongorestore -h localhost -d leanote --directoryperdb PATH_TO_LEANOTE/mongodb_backup/leanote_install_data
-```
-
-The initial database contains two users:
-
-```
-user2 username: admin, password: abc123 (administrator)
-user3 username: demo, password: demo@leanote.com (this user is for demo)
-```
-
-### 3.4. Configuration
-
-Modify `[PATH_TO_LEANOTE]/conf/app.conf`. Available configuration options are:
-
-``mongodb``  **required**
-
-```Shell
-db.host=localhost
-db.port=27017
-db.dbname=leanote
-db.username=
-db.password=
-```
-
-``app.secret`` **required** **important**
-The secret key used for cryptographic operations (revel.Sign).
-
-FOR SECURITY, YOU MUST CHANGE IT!!
-
-For more infomation please see `app/app.conf` and the [revel manuals](https://revel.github.io/)
-
-### 3.5. Run leanote
-
-```
-$> cd PATH_TO_LEANOTE/bin
-$> sudo sh run.sh
-```
-
-## 4. How to develop leanote
-
-Please see [How-to-develop-leanote](https://github.com/leanote/leanote/wiki/How-to-develop-leanote-%E5%A6%82%E4%BD%95%E5%BC%80%E5%8F%91leanote)
+Please see [wiki](https://github.com/leanote/leanote/wiki) for detailed instruction on how to install Leanote on various platforms, trouble shooting and configuration explanations.
 
 
-## 5. Contributors
-Thank you to all the [contributors](https://github.com/leanote/leanote/graphs/contributors) on
-this project. Your help is much appreciated.
+## 5. How to develop Leanote
 
-## 6. Contributing
+If you are a developer yourself and feel like to build on top of Leanote, please refer to [How-to-develop-leanote](https://github.com/leanote/leanote/wiki/How-to-develop-leanote-%E5%A6%82%E4%BD%95%E5%BC%80%E5%8F%91leanote).
 
-Please fork this repository and contribute back using [pull requests](https://github.com/leanote/leanote/pulls).
 
-## Discussion
-* [leanote bbs](http://bbs.leanote.com)
-* [leanote google group](https://groups.google.com/forum/#!forum/leanote)
-* QQ Group: 158716820
+## 6. Contributions
+
+Like or dislike Leanote, please leave your comments and suggestions to help us improve it.
+If you encounter any issue, we suggest you first search the issues section to see whether a solution already exists, or open up a new one otherwise.
+
+We’d like to acknowledge the contributions made by our [developers and contributors](https://github.com/leanote/leanote/graphs/contributors) to
+this project. Leanote won’t exist without your hard work. Your help is much appreciated.
+
+## 7. Join us
+
+Please feel free to fork this repository and contribute back using [pull requests](https://github.com/leanote/leanote/pulls).
+
+If you find any problems or have any good ideas, feature requests, please submit here [issues](https://github.com/leanote/leanote/issues).
+
+
+## 8. Donation
+
+If you like our product, consider supporting us via [donate us](http://leanote.org/#donate).
+We acknowledge the donations made by all the [donators](http://leanote.leanote.com/post/leanote-donation-list).
+
+## 9. Related projects
+
+* [Leanote Desktop App](https://github.com/leanote/desktop-app), [Download](http://app.leanote.com)
+* [Leanote iOS](https://github.com/leanote/leanote-ios), [Download From App Store](https://itunes.apple.com/app/leanote/id1022302858)
+* [Leanote Android](https://github.com/leanote/leanote-android), development phase
+
+You are welcome to join us.
+
+## 10. Contacts
+
+* Email: leanote@leanote.com
+* [Leanote BBS](http://bbs.leanote.com)
+* [Leanote Google Group](https://groups.google.com/forum/#!forum/leanote)
+* QQ Groups: 326073529, 256076853, 158716820
 
 -----------------------------------------------------------------------
 
+# Leanote
+
 ## 1. 介绍
 
 Leanote, 不只是笔记!
 
 **特性**
 
-* 知识管理: 通过leanote来管理知识, leanote有易操作的界面, 包含两款编辑器tinymce和markdown. 在leanote, 你可以尽情享受写作.
-* 分享: 你也可以通过分享知识给好友, 让好友拥有你的知识.
-* 协作: 在分享的同时也可以与好友一起协作知识.
-* 博客: leanote也可以作为你的博客, 将知识公开成博客, 让leanote把你的知识传播的更远!
+* 高效笔记：Leanote 有易操作的界面, 包含一款富文本编辑器和Markdown编辑器，让您的笔记记录更轻松和高效。对高阶用户，我们还提供`Vim` 和`Emacs` 编辑模式，助推你的写作速度更上层楼。
+* 知识管理:  Leanote 灵活而强大的“笔记本-笔记-标签”系统，让它成为你个人知识管理的利器。
+* 分享: 你可以通过Leanote同好友分享知识、想法和经历, 邀请好友加入你的笔记簿，通过云端交流信息。
+* 协作: Leanote协助你与同事之间相互协作，激荡新思路，随时随地头脑风暴。
+* 博客: Leanote也可以作为你的个人博客, 把你的知识传播的更远!
 
-## 2. 为什么我们要创建leanote?
-说实话, 我们曾是evernote的忠实粉丝, 但是我们也发现evernote的不足:
-* evernote的编辑器不能满足我们的需求, 不能贴代码(格式会乱掉, 作为程序员, 代码是我们的基本需求啊), 图片不能缩放.
-* 我们是markdown的爱好者, 可是evernote竟然没有.
-* 我们也想将知识公开, 所以我们有自己的博客, 如wordpress, 但为什么这两者不能合二为一呢?
+**其它特性**
+
+* 支持Markdown编辑
+* 写作模式
+* `Vim` 及 `Emacs` 编辑模式
+* 支持PDF导出
+* 支持批量操作
+* 博客自定义主题, 实现高度定制化
+
+## 2. 为什么我们要创建Leanote?
+我们都曾是`Evernote`的忠实粉丝, 一直以来`Evernote`都是我们日常知识管理的有效工具。于是我们决定重新创造一款工具，提供`Evernote`所能提供的功能，同时弥补`Evernote`的不足，比如：
+* 功能更强的文本编辑器：`Evernote`的编辑器不能满足我们的需求, 不能实现文档导航、不能贴代码(格式会乱掉, 作为程序员, 代码是我们的基本需求啊), 图片不能缩放等。
+* `Evernote` 不支持所有人都喜爱的markdown语法，于是我们为Leanote配备了一款可以实时渲染的markdown编辑器。
+* 如果你是一名开发者，觉得手指怀念`Vim` 或 `Emacs` 了，那么我们还提供给你`Vim` 和 `Emacs` 写作模式，配合*markdown*的格式编辑，写作的时候再也不用去碰鼠标了。
+* 知识积累和知识分享同样重要，因此大家都有自己的笔记账号和社交账号。但为什么这两者不能合二为一呢? Leanote 做到了将二者无缝衔接。
+* 一套完整的、全平台覆盖的软件套装，包括了web、桌面、安卓、IOS设备，而且全部开源！
 * 还有...
 
-## 3.安装leanote
-leanote是一款私有云笔记, 你可以下载它安装在自己的服务器上, 当然也可以在 http://leanote.com 上注册.
+## 3. 获取Leanote
 
-这里详细整理了leanote二进版和leanote开发版的安装教程, 请移步至:
-* [leanote二进制详细安装教程](https://github.com/leanote/leanote/wiki/leanote%E4%BA%8C%E8%BF%9B%E5%88%B6%E7%89%88%E8%AF%A6%E7%BB%86%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B)
-* [leanote开发版详细安装教程](https://github.com/leanote/leanote/wiki/leanote%E5%BC%80%E5%8F%91%E7%89%88%E8%AF%A6%E7%BB%86%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B)
+Leanote云笔记产品包括: Leanote Web & Server(即本仓库), 桌面客户端, IOS, android. 4端全部开源! 
 
-### 3.1. 下载leanote
+如果想试用我们的产品，欢迎在 https://leanote.com 上注册, Leanote团队为你提供稳定可靠的服务。
+担心服务厂商如何处理你的个人数据吗？你可以下载Leanote安装在自己的服务器上, 通过Leanote客户端连接与自建服务同步数据。
 
-Leanote V1.0-beta 已发布, 二进制文件(暂时没有windows版的):
+这里详细整理了Leanote二进版和Leanote开发版的安装教程, 请移步至:
 
-* Linux: [leanote-linux-x86_64.v1.0-beta.bin.tar.gz](https://github.com/leanote/leanote/releases/download/1.0-beta/leanote-linux-x86_64.v1.0-beta.bin.tar.gz)
-* MacOS X: [leanote-mac-x86_64.v1.0-beta.bin.tar.gz](https://github.com/leanote/leanote/releases/download/1.0-beta/leanote-mac-x86_64.v1.0-beta.bin.tar.gz)
+* Leanote二进制详细安装教程:
+    * [Windows](https://github.com/leanote/leanote/wiki/Leanote%E4%BA%8C%E8%BF%9B%E5%88%B6%E7%89%88%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B---Windows)
+    * [Mac, Linux](https://github.com/leanote/leanote/wiki/leanote%E4%BA%8C%E8%BF%9B%E5%88%B6%E7%89%88%E8%AF%A6%E7%BB%86%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B)
+* Leanote源码详细安装教程:
+    <!-- * [Windows](https://github.com/leanote/leanote/wiki/Leanote-%E6%BA%90%E7%A0%81%E7%89%88%E8%AF%A6%E7%BB%86%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B----Windows) -->
+    * [Mac, Linux](https://github.com/leanote/leanote/wiki/leanote%E5%BC%80%E5%8F%91%E7%89%88%E8%AF%A6%E7%BB%86%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B)
 
-### 3.2. 安装 MongodbDB
+## 4. 相关文档
 
-Leanote是由golang(使用[revel](https://revel.github.io/)框架 和 [MongoDB](https://www.mongodb.org)数据库), 你需要先安装Mongodb.
+更多详细的安装说明、问题处理和配置说明文档，请查看 [wiki](https://github.com/leanote/leanote/wiki)。
 
-安装MongodbDB, 导入数据更多细节请查看: [wiki](https://github.com/leanote/leanote/wiki/Install-Mongodb)
+## 5. 如何对Leanote进行二次开发
 
-### 3.3. 导入初始数据
+如果您有兴趣基于Leanote二次开发，请查看 [How-to-develop-Leanote](https://github.com/leanote/leanote/wiki/How-to-develop-leanote-%E5%A6%82%E4%BD%95%E5%BC%80%E5%8F%91leanote)。
 
-MongodbDB初始数据在 `[PATH_TO_LEANOTE]/mongodb_backup/leanote_install_data`
+## 6. 贡献者
 
-```
-$> mongorestore -h localhost -d leanote --directoryperdb PATH_TO_LEANOTE/mongodb_backup/leanote_install_data
-```
+在此对向Leanote贡献力量的[贡献者们](https://github.com/leanote/leanote/graphs/contributors) 表示感谢。Leanote因有你们而更完美!
 
-初始数据包含两个用户:
+## 7. 加入我们
 
-```
-user2 username: admin, password: abc123 (管理员, 重要!)
-user3 username: demo@leanote.com, password: demo@leanote.com (为体验使用)
-```
+欢迎提交[pull requests](https://github.com/leanote/leanote/pulls) 到Leanote。
 
-### 3.4. 配置
+有任何问题或建议, 请先搜索[issue](https://github.com/leanote/leanote/issues)区是否已经有解决方法。如果没有，欢迎提交新issue。
 
-修改 `[PATH_TO_LEANOTE]/conf/app.conf`. 有以下选项:
+Leanote还有很多问题, 如果你喜欢它, 欢迎加入我们一起完善Leanote。
 
-``mongodb``  **必须配置!**
+## 8. 捐赠
 
-```Shell
-db.host=localhost
-db.port=27017
-db.dbname=leanote
-db.username=
-db.password=
-```
+如果您喜欢我们的产品，请考虑支持我们, [捐赠Leanote](http://leanote.org/#donate)。
 
-``app.secret`` **重要**
-请随意修改一个, app的密钥, 不能使用默认的, 不然会有安全问题
+感谢[这些捐赠者](http://leanote.leanote.com/post/leanote-donation-list), 谢谢你们的鼓励, Leanote会一直坚持!
 
-更多配置请查看 `app/app.conf` 和 [revel 手册](https://revel.github.io/)
+## 9. 其它相关项目
+* [Leanote Desktop App](https://github.com/leanote/desktop-app), [下载地址](http://app.leanote.com)
+* [Leanote iOS](https://github.com/leanote/leanote-ios), [从App Store下载](https://itunes.apple.com/zn/app/leanote/id1022302858?mt=8)
+* [Leanote Android](https://github.com/leanote/leanote-android), 开发阶段
 
-### 3.5. 运行leanote
+欢迎加入我们!
 
-```
-$> cd PATH_TO_LEANOTE/bin
-$> sudo sh run.sh
-```
-
-## 4. 如何对leanote进行二次开发
-
-请查看 [How-to-develop-leanote](https://github.com/leanote/leanote/wiki/How-to-develop-leanote-%E5%A6%82%E4%BD%95%E5%BC%80%E5%8F%91leanote)
-
-## 5. 贡献者
-多谢 [贡献者](https://github.com/leanote/leanote/graphs/contributors) 的贡献, leanote因有你们而更完美!
-
-## 6. 加入我们
-
-欢迎提交[pull requests](https://github.com/leanote/leanote/pulls) 到leanote.
-
-leanote还有很多问题, 如果你喜欢它, 欢迎加入我们一起完善leanote.
-
-## 讨论
-* [leanote 社区](http://bbs.leanote.com)
-* QQ群: 158716820
-* [leanote google group](https://groups.google.com/forum/#!forum/leanote)
+## 联系&加入我们
+* Email: leanote@leanote.com
+* [Leanote 社区](http://bbs.leanote.com)
+* [QQ群](http://leanote.leanote.com/post/Leanote-groups)
+* [Leanote Google Group](https://groups.google.com/forum/#!forum/leanote)

app/cmd/README.md

@@ -0,0 +1,9 @@
+全部代码来自https://github.com/revel/cmd
+
+因为要改parse2, 所以改只要一点点代码
+harness/
+    build.go 只要gensource, 其它的先return
+main.go 改动很小
+build.go 改动很小
+parser2/
+    source_processors.go 改了 fsWalk 过滤掉 public, files, build 等文件夹

app/cmd/build.go

@@ -0,0 +1,270 @@
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"fmt"
+	"github.com/leanote/leanote/app/cmd/harness" // 只改了这个
+	"github.com/revel/cmd/model"
+	"github.com/revel/cmd/utils"
+)
+
+var cmdBuild = &Command{
+	UsageLine: "revel build [-r [run mode]] [import path] [target path] ",
+	Short:     "build a Revel application (e.g. for deployment)",
+	Long: `
+Build the Revel web application named by the given import path.
+This allows it to be deployed and run on a machine that lacks a Go installation.
+
+For example:
+
+    revel build github.com/revel/examples/chat /tmp/chat
+
+`,
+}
+
+func init() {
+	cmdBuild.RunWith = buildApp
+	cmdBuild.UpdateConfig = updateBuildConfig
+}
+
+// The update config updates the configuration command so that it can run
+func updateBuildConfig(c *model.CommandConfig, args []string) bool {
+	c.Index = model.BUILD
+	if c.Build.TargetPath == "" {
+		c.Build.TargetPath = "target"
+	}
+	if len(args) == 0 && c.Build.ImportPath != "" {
+		return true
+	}
+	// If arguments were passed in then there must be two
+	if len(args) < 2 {
+		fmt.Fprintf(os.Stderr, "%s\n%s", cmdBuild.UsageLine, cmdBuild.Long)
+		return false
+	}
+
+	c.Build.ImportPath = args[0]
+	c.Build.TargetPath = args[1]
+	if len(args) > 2 {
+		c.Build.Mode = args[2]
+	}
+	return true
+}
+
+// The main entry point to build application from command line
+func buildApp(c *model.CommandConfig) (err error) {
+
+	appImportPath, destPath, mode := c.ImportPath, c.Build.TargetPath, DefaultRunMode
+	if len(c.Build.Mode) > 0 {
+		mode = c.Build.Mode
+	}
+
+	// Convert target to absolute path
+	c.Build.TargetPath, _ = filepath.Abs(destPath)
+	c.Build.Mode = mode
+	c.Build.ImportPath = appImportPath
+
+	revel_paths, err := model.NewRevelPaths(mode, appImportPath, c.AppPath, model.NewWrappedRevelCallback(nil, c.PackageResolver))
+	if err != nil {
+		return
+	}
+
+	if err = buildSafetyCheck(destPath); err != nil {
+		return
+	}
+
+	// Ensure the application can be built, this generates the main file
+	app, err := harness.Build(c, revel_paths)
+	if err != nil {
+		return err
+	}
+	// Copy files
+	// Included are:
+	// - run scripts
+	// - binary
+	// - revel
+	// - app
+
+	return // 改了这里
+
+	packageFolders, err := buildCopyFiles(c, app, revel_paths)
+	if err != nil {
+		return
+	}
+	err = buildCopyModules(c, revel_paths, packageFolders, app)
+	if err != nil {
+		return
+	}
+	err = buildWriteScripts(c, app)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// Copy the files to the target
+func buildCopyFiles(c *model.CommandConfig, app *harness.App, revel_paths *model.RevelContainer) (packageFolders []string, err error) {
+	appImportPath, destPath := c.ImportPath, c.Build.TargetPath
+
+	// Revel and the app are in a directory structure mirroring import path
+	srcPath := filepath.Join(destPath, "src")
+	destBinaryPath := filepath.Join(destPath, filepath.Base(app.BinaryPath))
+	tmpRevelPath := filepath.Join(srcPath, filepath.FromSlash(model.RevelImportPath))
+	if err = utils.CopyFile(destBinaryPath, filepath.Join(revel_paths.BasePath, app.BinaryPath)); err != nil {
+		return
+	}
+	utils.MustChmod(destBinaryPath, 0755)
+
+	// Copy the templates  from the revel
+	if err = utils.CopyDir(filepath.Join(tmpRevelPath, "conf"), filepath.Join(revel_paths.RevelPath, "conf"), nil); err != nil {
+		return
+	}
+	if err = utils.CopyDir(filepath.Join(tmpRevelPath, "templates"), filepath.Join(revel_paths.RevelPath, "templates"), nil); err != nil {
+		return
+	}
+
+	// Get the folders to be packaged
+	packageFolders = strings.Split(revel_paths.Config.StringDefault("package.folders", "conf,public,app/views"), ",")
+	for i, p := range packageFolders {
+		// Clean spaces, reformat slash to filesystem
+		packageFolders[i] = filepath.FromSlash(strings.TrimSpace(p))
+	}
+
+	if c.Build.CopySource {
+		err = utils.CopyDir(filepath.Join(srcPath, filepath.FromSlash(appImportPath)), revel_paths.BasePath, nil)
+		if err != nil {
+			return
+		}
+	} else {
+		for _, folder := range packageFolders {
+			err = utils.CopyDir(
+				filepath.Join(srcPath, filepath.FromSlash(appImportPath), folder),
+				filepath.Join(revel_paths.BasePath, folder),
+				nil)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}
+
+// Based on the section copy over the build modules
+func buildCopyModules(c *model.CommandConfig, revel_paths *model.RevelContainer, packageFolders []string, app *harness.App) (err error) {
+	destPath := filepath.Join(c.Build.TargetPath, "src")
+	// Find all the modules used and copy them over.
+	config := revel_paths.Config.Raw()
+
+	// We should only copy over the section of options what the build is targeted for
+	// We will default to prod
+	moduleImportList := []string{}
+	for _, section := range config.Sections() {
+		// If the runmode is defined we will only import modules defined for that run mode
+		if c.Build.Mode != "" && c.Build.Mode != section {
+			continue
+		}
+		options, _ := config.SectionOptions(section)
+		for _, key := range options {
+			if !strings.HasPrefix(key, "module.") {
+				continue
+			}
+			moduleImportPath, _ := config.String(section, key)
+			if moduleImportPath == "" {
+				continue
+			}
+			moduleImportList = append(moduleImportList, moduleImportPath)
+
+		}
+	}
+
+	// Copy the the paths for each of the modules
+	for _, importPath := range moduleImportList {
+		fsPath := app.PackagePathMap[importPath]
+		utils.Logger.Info("Copy files ", "to", filepath.Join(destPath, importPath), "from", fsPath)
+		if c.Build.CopySource {
+			err = utils.CopyDir(filepath.Join(destPath, importPath), fsPath, nil)
+			if err != nil {
+				return
+			}
+		} else {
+			for _, folder := range packageFolders {
+				err = utils.CopyDir(
+					filepath.Join(destPath, importPath, folder),
+					filepath.Join(fsPath, folder),
+					nil)
+				if err != nil {
+					return
+				}
+			}
+		}
+	}
+
+	return
+}
+
+// Write the run scripts for the build
+func buildWriteScripts(c *model.CommandConfig, app *harness.App) (err error) {
+	tmplData := map[string]interface{}{
+		"BinName":    filepath.Base(app.BinaryPath),
+		"ImportPath": c.Build.ImportPath,
+		"Mode":       c.Build.Mode,
+	}
+
+	err = utils.GenerateTemplate(
+		filepath.Join(c.Build.TargetPath, "run.sh"),
+		PACKAGE_RUN_SH,
+		tmplData,
+	)
+	if err != nil {
+		return
+	}
+	utils.MustChmod(filepath.Join(c.Build.TargetPath, "run.sh"), 0755)
+	err = utils.GenerateTemplate(
+		filepath.Join(c.Build.TargetPath, "run.bat"),
+		PACKAGE_RUN_BAT,
+		tmplData,
+	)
+	if err != nil {
+		return
+	}
+
+	fmt.Println("Your application has been built in:", c.Build.TargetPath)
+
+	return
+}
+
+// Checks to see if the target folder exists and can be created
+func buildSafetyCheck(destPath string) error {
+
+	// First, verify that it is either already empty or looks like a previous
+	// build (to avoid clobbering anything)
+	if utils.Exists(destPath) && !utils.Empty(destPath) && !utils.Exists(filepath.Join(destPath, "run.sh")) {
+		return utils.NewBuildError("Abort: %s exists and does not look like a build directory.", "path", destPath)
+	}
+
+	if err := os.RemoveAll(destPath); err != nil && !os.IsNotExist(err) {
+		return utils.NewBuildIfError(err, "Remove all error", "path", destPath)
+	}
+
+	if err := os.MkdirAll(destPath, 0777); err != nil {
+		return utils.NewBuildIfError(err, "MkDir all error", "path", destPath)
+	}
+	return nil
+}
+
+const PACKAGE_RUN_SH = `#!/bin/sh
+
+SCRIPTPATH=$(cd "$(dirname "$0")"; pwd)
+"$SCRIPTPATH/{{.BinName}}" -importPath {{.ImportPath}} -srcPath "$SCRIPTPATH/src" -runMode {{.Mode}}
+`
+const PACKAGE_RUN_BAT = `@echo off
+
+{{.BinName}} -importPath {{.ImportPath}} -srcPath "%CD%\src" -runMode {{.Mode}}
+`

app/cmd/gen_tmp.sh

@@ -0,0 +1,4 @@
+SCRIPTPATH=$(cd "$(dirname "$0")"; pwd)
+cd $SCRIPTPATH
+go run . build -v ../../ ./tmptmp
+rm -rf ./tmptmp

app/cmd/harness/app.go

@@ -0,0 +1,219 @@
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package harness
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"time"
+	"sync"
+
+	"github.com/revel/cmd/model"
+	"github.com/revel/cmd/utils"
+	"runtime"
+)
+
+// App contains the configuration for running a Revel app.  (Not for the app itself)
+// Its only purpose is constructing the command to execute.
+type App struct {
+	BinaryPath     string            // Path to the app executable
+	Port           int               // Port to pass as a command line argument.
+	cmd            AppCmd            // The last cmd returned.
+	PackagePathMap map[string]string // Package to directory path map
+	Paths          *model.RevelContainer
+}
+
+// NewApp returns app instance with binary path in it
+func NewApp(binPath string, paths *model.RevelContainer, packagePathMap map[string]string) *App {
+	return &App{BinaryPath: binPath, Paths: paths, Port: paths.HTTPPort, PackagePathMap:packagePathMap}
+}
+
+// Cmd returns a command to run the app server using the current configuration.
+func (a *App) Cmd(runMode string) AppCmd {
+	a.cmd = NewAppCmd(a.BinaryPath, a.Port, runMode, a.Paths)
+	return a.cmd
+}
+
+// Kill the last app command returned.
+func (a *App) Kill() {
+	a.cmd.Kill()
+}
+
+// AppCmd manages the running of a Revel app server.
+// It requires revel.Init to have been called previously.
+type AppCmd struct {
+	*exec.Cmd
+}
+
+// NewAppCmd returns the AppCmd with parameters initialized for running app
+func NewAppCmd(binPath string, port int, runMode string, paths *model.RevelContainer) AppCmd {
+	cmd := exec.Command(binPath,
+		fmt.Sprintf("-port=%d", port),
+		fmt.Sprintf("-importPath=%s", paths.ImportPath),
+		fmt.Sprintf("-runMode=%s", runMode))
+	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	return AppCmd{cmd}
+}
+
+// Start the app server, and wait until it is ready to serve requests.
+func (cmd AppCmd) Start(c *model.CommandConfig) error {
+	listeningWriter := &startupListeningWriter{os.Stdout, make(chan bool), c, &bytes.Buffer{}}
+	cmd.Stdout = listeningWriter
+	utils.CmdInit(cmd.Cmd, !c.Vendored, c.AppPath)
+	utils.Logger.Info("Exec app:", "path", cmd.Path, "args", cmd.Args, "dir", cmd.Dir, "env", cmd.Env)
+	if err := cmd.Cmd.Start(); err != nil {
+		utils.Logger.Fatal("Error running:", "error", err)
+	}
+
+	select {
+	case exitState := <-cmd.waitChan():
+		fmt.Println("Startup failure view previous messages, \n Proxy is listening :", c.Run.Port)
+		err := utils.NewError("", "Revel Run Error", "starting your application there was an exception. See terminal output, " + exitState, "")
+	// TODO pretiffy command line output
+	// err.MetaError = listeningWriter.getLastOutput()
+		return err
+
+	case <-time.After(60 * time.Second):
+		println("Revel proxy is listening, point your browser to :", c.Run.Port)
+		utils.Logger.Error("Killing revel server process did not respond after wait timeout.", "processid", cmd.Process.Pid)
+		cmd.Kill()
+		return errors.New("revel/harness: app timed out")
+
+	case <-listeningWriter.notifyReady:
+		println("Revel proxy is listening, point your browser to :", c.Run.Port)
+		return nil
+	}
+
+}
+
+// Run the app server inline.  Never returns.
+func (cmd AppCmd) Run(c *model.CommandConfig) {
+	utils.CmdInit(cmd.Cmd, !c.Vendored, c.AppPath)
+	utils.Logger.Info("Exec app:", "path", cmd.Path, "args", cmd.Args)
+	if err := cmd.Cmd.Run(); err != nil {
+		utils.Logger.Fatal("Error running:", "error", err)
+	}
+}
+
+// Kill terminates the app server if it's running.
+func (cmd AppCmd) Kill() {
+
+	if cmd.Cmd != nil && (cmd.ProcessState == nil || !cmd.ProcessState.Exited()) {
+		// Windows appears to send the kill to all threads, shutting down the
+		// server before this can, this check will ensure the process is still running
+		if _, err := os.FindProcess(int(cmd.Process.Pid)); err != nil {
+			// Server has already exited
+			utils.Logger.Info("Server not running revel server pid", "pid", cmd.Process.Pid)
+			return
+		}
+
+		// Wait for the shutdown channel
+		waitMutex := &sync.WaitGroup{}
+		waitMutex.Add(1)
+		ch := make(chan bool, 1)
+		go func() {
+			waitMutex.Done()
+			s, err := cmd.Process.Wait()
+			defer func() {
+				ch <- true
+			}()
+			if err != nil {
+				utils.Logger.Info("Wait failed for process ", "error", err)
+			}
+			if s != nil {
+				utils.Logger.Info("Revel App exited", "state", s.String())
+			}
+		}()
+		// Wait for the channel to begin waiting
+		waitMutex.Wait()
+
+		// Send an interrupt signal to allow for a graceful shutdown
+		utils.Logger.Info("Killing revel server pid", "pid", cmd.Process.Pid)
+		var err error
+		if runtime.GOOS != "windows" {
+			// os.Interrupt is not available on windows
+			err = cmd.Process.Signal(os.Interrupt)
+		}
+
+		if err != nil {
+			utils.Logger.Info(
+				"Revel app already exited.",
+				"processid", cmd.Process.Pid, "error", err,
+				"killerror", cmd.Process.Kill())
+			return
+		}
+
+
+		// Use a timer to ensure that the process exits
+		utils.Logger.Info("Waiting to exit")
+		select {
+		case <-ch:
+			return
+		case <-time.After(60 * time.Second):
+		// Kill the process
+			utils.Logger.Error(
+				"Revel app failed to exit in 60 seconds - killing.",
+				"processid", cmd.Process.Pid,
+				"killerror", cmd.Process.Kill())
+		}
+
+		utils.Logger.Info("Done Waiting to exit")
+	}
+}
+
+// Return a channel that is notified when Wait() returns.
+func (cmd AppCmd) waitChan() <-chan string {
+	ch := make(chan string, 1)
+	go func() {
+		_ = cmd.Wait()
+		state := cmd.ProcessState
+		exitStatus := " unknown "
+		if state != nil {
+			exitStatus = state.String()
+		}
+
+		ch <- exitStatus
+	}()
+	return ch
+}
+
+// A io.Writer that copies to the destination, and listens for "Revel engine is listening on.."
+// in the stream.  (Which tells us when the revel server has finished starting up)
+// This is super ghetto, but by far the simplest thing that should work.
+type startupListeningWriter struct {
+	dest        io.Writer
+	notifyReady chan bool
+	c           *model.CommandConfig
+	buffer      *bytes.Buffer
+}
+
+// Writes to this output stream
+func (w *startupListeningWriter) Write(p []byte) (int, error) {
+	if w.notifyReady != nil && bytes.Contains(p, []byte("Revel engine is listening on")) {
+		w.notifyReady <- true
+		w.notifyReady = nil
+	}
+	if w.c.HistoricMode {
+		if w.notifyReady != nil && bytes.Contains(p, []byte("Listening on")) {
+			w.notifyReady <- true
+			w.notifyReady = nil
+		}
+	}
+	if w.notifyReady != nil {
+		w.buffer.Write(p)
+	}
+	return w.dest.Write(p)
+}
+
+// Returns the cleaned output from the response
+// TODO clean the response more
+func (w *startupListeningWriter) getLastOutput() string {
+	return w.buffer.String()
+}
+

app/cmd/harness/build.go

@@ -0,0 +1,566 @@
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package harness
+
+import (
+	"fmt"
+	"go/build"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/leanote/leanote/app/cmd/parser2"
+	"github.com/revel/cmd/model"
+	"github.com/revel/cmd/parser"
+	_ "github.com/revel/cmd/parser"
+	"github.com/revel/cmd/utils"
+)
+
+var importErrorPattern = regexp.MustCompile("cannot find package \"([^\"]+)\"")
+
+type ByString []*model.TypeInfo
+
+func (c ByString) Len() int {
+	return len(c)
+}
+func (c ByString) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}
+func (c ByString) Less(i, j int) bool {
+	return c[i].String() < c[j].String()
+}
+
+// Build the app:
+// 1. Generate the the main.go file.
+// 2. Run the appropriate "go build" command.
+// Requires that revel.Init has been called previously.
+// Returns the path to the built binary, and an error if there was a problem building it.
+func Build(c *model.CommandConfig, paths *model.RevelContainer) (_ *App, err error) {
+	// First, clear the generated files (to avoid them messing with ProcessSource).
+	cleanSource(paths, "tmp", "routes")
+
+	var sourceInfo *model.SourceInfo
+
+	if c.HistoricBuildMode {
+		sourceInfo, err = parser.ProcessSource(paths)
+	} else {
+		sourceInfo, err = parser2.ProcessSource(paths)
+	}
+	if err != nil {
+		return
+	}
+
+	// Add the db.import to the import paths.
+	if dbImportPath, found := paths.Config.String("db.import"); found {
+		sourceInfo.InitImportPaths = append(sourceInfo.InitImportPaths, strings.Split(dbImportPath, ",")...)
+	}
+
+	// Sort controllers so that file generation is reproducible
+	controllers := sourceInfo.ControllerSpecs()
+	sort.Stable(ByString(controllers))
+
+	// Generate two source files.
+	templateArgs := map[string]interface{}{
+		"ImportPath":     paths.ImportPath,
+		"Controllers":    controllers,
+		"ValidationKeys": sourceInfo.ValidationKeys,
+		"ImportPaths":    calcImportAliases(sourceInfo),
+		"TestSuites":     sourceInfo.TestSuites(),
+	}
+
+	// Generate code for the main, run and routes file.
+	// The run file allows external programs to launch and run the application
+	// without being the main thread
+	cleanSource(paths, "tmp", "routes")
+
+	if err = genSource(paths, "tmp", "main.go", RevelMainTemplate, templateArgs); err != nil {
+		return
+	}
+	if err = genSource(paths, filepath.Join("tmp", "run"), "run.go", RevelRunTemplate, templateArgs); err != nil {
+		return
+	}
+	if err = genSource(paths, "routes", "routes.go", RevelRoutesTemplate, templateArgs); err != nil {
+		return
+	}
+
+	utils.Logger.Warn("gen tmp/main.go, tmp/run/run.go, routes/routes.go success!!")
+
+	return // 改了这里
+
+	// Read build config.
+	buildTags := paths.Config.StringDefault("build.tags", "")
+
+	// Build the user program (all code under app).
+	// It relies on the user having "go" installed.
+	goPath, err := exec.LookPath("go")
+	if err != nil {
+		utils.Logger.Fatal("Go executable not found in PATH.")
+	}
+
+	// Binary path is a combination of target/app directory, app's import path and its name.
+	binName := filepath.Join("target", "app", paths.ImportPath, filepath.Base(paths.BasePath))
+
+	// Change binary path for Windows build
+	goos := runtime.GOOS
+	if goosEnv := os.Getenv("GOOS"); goosEnv != "" {
+		goos = goosEnv
+	}
+	if goos == "windows" {
+		binName += ".exe"
+	}
+
+	gotten := make(map[string]struct{})
+	contains := func(s []string, e string) bool {
+		for _, a := range s {
+			if a == e {
+				return true
+			}
+		}
+		return false
+	}
+
+	if len(c.GoModFlags) > 0 {
+		for _, gomod := range c.GoModFlags {
+			goModCmd := exec.Command(goPath, append([]string{"mod"}, strings.Split(gomod, " ")...)...)
+			utils.CmdInit(goModCmd, !c.Vendored, c.AppPath)
+			output, err := goModCmd.CombinedOutput()
+			utils.Logger.Info("Gomod applied ", "output", string(output))
+
+			// If the build succeeded, we're done.
+			if err != nil {
+				utils.Logger.Error("Gomod Failed continuing ", "error", err, "output", string(output))
+			}
+		}
+	}
+
+	for {
+		appVersion := getAppVersion(paths)
+		if appVersion == "" {
+			appVersion = "noVersionProvided"
+		}
+
+		buildTime := time.Now().UTC().Format(time.RFC3339)
+		versionLinkerFlags := fmt.Sprintf("-X '%s/app.AppVersion=%s' -X '%s/app.BuildTime=%s'",
+			paths.ImportPath, appVersion, paths.ImportPath, buildTime)
+
+		// Append any build flags specified, they will override existing flags
+		flags := []string{}
+		if len(c.BuildFlags) == 0 {
+			flags = []string{
+				"build",
+				"-ldflags", versionLinkerFlags,
+				"-tags", buildTags,
+				"-o", binName}
+		} else {
+			if !contains(c.BuildFlags, "build") {
+				flags = []string{"build"}
+			}
+			if !contains(flags, "-ldflags") {
+				ldflags := "-ldflags= " + versionLinkerFlags
+				// Add user defined build flags
+				for i := range c.BuildFlags {
+					ldflags += " -X '" + c.BuildFlags[i] + "'"
+				}
+				flags = append(flags, ldflags)
+			}
+			if !contains(flags, "-tags") && buildTags != "" {
+				flags = append(flags, "-tags", buildTags)
+			}
+			if !contains(flags, "-o") {
+				flags = append(flags, "-o", binName)
+			}
+		}
+
+		// Note: It's not applicable for filepath.* usage
+		flags = append(flags, path.Join(paths.ImportPath, "app", "tmp"))
+
+		buildCmd := exec.Command(goPath, flags...)
+		if !c.Vendored {
+			// This is Go main path
+			gopath := c.GoPath
+			for _, o := range paths.ModulePathMap {
+				gopath += string(filepath.ListSeparator) + o.Path
+			}
+
+			buildCmd.Env = append(os.Environ(),
+				"GOPATH=" + gopath,
+			)
+		}
+		utils.CmdInit(buildCmd, !c.Vendored, c.AppPath)
+
+		utils.Logger.Info("Exec:", "args", buildCmd.Args, "working dir", buildCmd.Dir)
+		output, err := buildCmd.CombinedOutput()
+
+		// If the build succeeded, we're done.
+		if err == nil {
+			utils.Logger.Info("Build successful continuing")
+			return NewApp(binName, paths, sourceInfo.PackageMap), nil
+		}
+
+		// Since there was an error, capture the output in case we need to report it
+		stOutput := string(output)
+		utils.Logger.Infof("Got error on build of app %s", stOutput)
+
+		// See if it was an import error that we can go get.
+		matches := importErrorPattern.FindAllStringSubmatch(stOutput, -1)
+		utils.Logger.Info("Build failed checking for missing imports", "message", stOutput, "missing_imports", len(matches))
+		if matches == nil {
+			utils.Logger.Info("Build failed no missing imports", "message", stOutput)
+			return nil, newCompileError(paths, output)
+		}
+		utils.Logger.Warn("Detected missing packages, importing them", "packages", len(matches))
+		for _, match := range matches {
+			// Ensure we haven't already tried to go get it.
+			pkgName := match[1]
+			utils.Logger.Info("Trying to import ", "package", pkgName)
+			if _, alreadyTried := gotten[pkgName]; alreadyTried {
+				utils.Logger.Error("Failed to import ", "package", pkgName)
+				return nil, newCompileError(paths, output)
+			}
+			gotten[pkgName] = struct{}{}
+			if err := c.PackageResolver(pkgName); err != nil {
+				utils.Logger.Error("Unable to resolve package", "package", pkgName, "error", err)
+				return nil, newCompileError(paths, []byte(err.Error()))
+			}
+		}
+
+		// Success getting the import, attempt to build again.
+	}
+
+	// TODO remove this unreachable code and document it
+	utils.Logger.Fatal("Not reachable")
+	return nil, nil
+}
+
+// Try to define a version string for the compiled app
+// The following is tried (first match returns):
+// - Read a version explicitly specified in the APP_VERSION environment
+//   variable
+// - Read the output of "git describe" if the source is in a git repository
+// If no version can be determined, an empty string is returned.
+func getAppVersion(paths *model.RevelContainer) string {
+	if version := os.Getenv("APP_VERSION"); version != "" {
+		return version
+	}
+
+	// Check for the git binary
+	if gitPath, err := exec.LookPath("git"); err == nil {
+		// Check for the .git directory
+		gitDir := filepath.Join(paths.BasePath, ".git")
+		info, err := os.Stat(gitDir)
+		if (err != nil && os.IsNotExist(err)) || !info.IsDir() {
+			return ""
+		}
+		gitCmd := exec.Command(gitPath, "--git-dir=" + gitDir, "--work-tree=" + paths.BasePath, "describe", "--always", "--dirty")
+		utils.Logger.Info("Exec:", "args", gitCmd.Args)
+		output, err := gitCmd.Output()
+
+		if err != nil {
+			utils.Logger.Error("Cannot determine git repository version:", "error", err)
+			return ""
+		}
+
+		return "git-" + strings.TrimSpace(string(output))
+	}
+
+	return ""
+}
+
+func cleanSource(paths *model.RevelContainer, dirs ...string) {
+	for _, dir := range dirs {
+		cleanDir(paths, dir)
+	}
+}
+
+func cleanDir(paths *model.RevelContainer, dir string) {
+	utils.Logger.Info("Cleaning dir ", "dir", dir)
+	tmpPath := filepath.Join(paths.AppPath, dir)
+	f, err := os.Open(tmpPath)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			utils.Logger.Error("Failed to clean dir:", "error", err)
+		}
+	} else {
+		defer func() {
+			_ = f.Close()
+		}()
+
+		infos, err := f.Readdir(0)
+		if err != nil {
+			if !os.IsNotExist(err) {
+				utils.Logger.Fatal("Failed to clean dir:", "error", err)
+			}
+		} else {
+			for _, info := range infos {
+				pathName := filepath.Join(tmpPath, info.Name())
+				if info.IsDir() {
+					err := os.RemoveAll(pathName)
+					if err != nil {
+						utils.Logger.Fatal("Failed to remove dir:", "error", err)
+					}
+				} else {
+					err := os.Remove(pathName)
+					if err != nil {
+						utils.Logger.Fatal("Failed to remove file:", "error", err)
+					}
+				}
+			}
+		}
+	}
+}
+
+// genSource renders the given template to produce source code, which it writes
+// to the given directory and file.
+func genSource(paths *model.RevelContainer, dir, filename, templateSource string, args map[string]interface{}) error {
+
+	return utils.GenerateTemplate(filepath.Join(paths.AppPath, dir, filename), templateSource, args)
+}
+
+// Looks through all the method args and returns a set of unique import paths
+// that cover all the method arg types.
+// Additionally, assign package aliases when necessary to resolve ambiguity.
+func calcImportAliases(src *model.SourceInfo) map[string]string {
+	aliases := make(map[string]string)
+	typeArrays := [][]*model.TypeInfo{src.ControllerSpecs(), src.TestSuites()}
+	for _, specs := range typeArrays {
+		for _, spec := range specs {
+			addAlias(aliases, spec.ImportPath, spec.PackageName)
+
+			for _, methSpec := range spec.MethodSpecs {
+				for _, methArg := range methSpec.Args {
+					if methArg.ImportPath == "" {
+						continue
+					}
+
+					addAlias(aliases, methArg.ImportPath, methArg.TypeExpr.PkgName)
+				}
+			}
+		}
+	}
+
+	// Add the "InitImportPaths", with alias "_"
+	for _, importPath := range src.InitImportPaths {
+		if _, ok := aliases[importPath]; !ok {
+			aliases[importPath] = "_"
+		}
+	}
+
+	return aliases
+}
+
+// Adds an alias to the map of alias names
+func addAlias(aliases map[string]string, importPath, pkgName string) {
+	alias, ok := aliases[importPath]
+	if ok {
+		return
+	}
+	alias = makePackageAlias(aliases, pkgName)
+	aliases[importPath] = alias
+}
+
+// Generates a package alias
+func makePackageAlias(aliases map[string]string, pkgName string) string {
+	i := 0
+	alias := pkgName
+	for containsValue(aliases, alias) || alias == "revel" {
+		alias = fmt.Sprintf("%s%d", pkgName, i)
+		i++
+	}
+	return alias
+}
+
+// Returns true if this value is in the map
+func containsValue(m map[string]string, val string) bool {
+	for _, v := range m {
+		if v == val {
+			return true
+		}
+	}
+	return false
+}
+
+// Parse the output of the "go build" command.
+// Return a detailed Error.
+func newCompileError(paths *model.RevelContainer, output []byte) *utils.SourceError {
+	errorMatch := regexp.MustCompile(`(?m)^([^:#]+):(\d+):(\d+:)? (.*)$`).
+		FindSubmatch(output)
+	if errorMatch == nil {
+		errorMatch = regexp.MustCompile(`(?m)^(.*?):(\d+):\s(.*?)$`).FindSubmatch(output)
+
+		if errorMatch == nil {
+			utils.Logger.Error("Failed to parse build errors", "error", string(output))
+			return &utils.SourceError{
+				SourceType:  "Go code",
+				Title:       "Go Compilation Error",
+				Description: "See console for build error.",
+			}
+		}
+
+		errorMatch = append(errorMatch, errorMatch[3])
+
+		utils.Logger.Error("Build errors", "errors", string(output))
+	}
+
+	findInPaths := func(relFilename string) string {
+		// Extract the paths from the gopaths, and search for file there first
+		gopaths := filepath.SplitList(build.Default.GOPATH)
+		for _, gp := range gopaths {
+			newPath := filepath.Join(gp, "src", paths.ImportPath, relFilename)
+			println(newPath)
+			if utils.Exists(newPath) {
+				return newPath
+			}
+		}
+		newPath, _ := filepath.Abs(relFilename)
+		utils.Logger.Warn("Could not find in GO path", "file", relFilename)
+		return newPath
+	}
+
+
+	// Read the source for the offending file.
+	var (
+		relFilename = string(errorMatch[1]) // e.g. "src/revel/sample/app/controllers/app.go"
+		absFilename = findInPaths(relFilename)
+		line, _ = strconv.Atoi(string(errorMatch[2]))
+		description = string(errorMatch[4])
+		compileError = &utils.SourceError{
+			SourceType:  "Go code",
+			Title:       "Go Compilation Error",
+			Path:        relFilename,
+			Description: description,
+			Line:        line,
+		}
+	)
+
+	errorLink := paths.Config.StringDefault("error.link", "")
+
+	if errorLink != "" {
+		compileError.SetLink(errorLink)
+	}
+
+	fileStr, err := utils.ReadLines(absFilename)
+	if err != nil {
+		compileError.MetaError = absFilename + ": " + err.Error()
+		utils.Logger.Info("Unable to readlines " + compileError.MetaError, "error", err)
+		return compileError
+	}
+
+	compileError.SourceLines = fileStr
+	return compileError
+}
+
+// RevelMainTemplate template for app/tmp/run/run.go
+const RevelRunTemplate = `// GENERATED CODE - DO NOT EDIT
+// This file is the run file for Revel.
+// It registers all the controllers and provides details for the Revel server engine to
+// properly inject parameters directly into the action endpoints.
+package run
+
+import (
+	"reflect"
+	"github.com/revel/revel"{{range $k, $v := $.ImportPaths}}
+	{{$v}} "{{$k}}"{{end}}
+	"github.com/revel/revel/testing"
+)
+
+var (
+	// So compiler won't complain if the generated code doesn't reference reflect package...
+	_ = reflect.Invalid
+)
+
+// Register and run the application
+func Run(port int) {
+	Register()
+	revel.Run(port)
+}
+
+// Register all the controllers
+func Register() {
+	revel.AppLog.Info("Running revel server")
+	{{range $i, $c := .Controllers}}
+	revel.RegisterController((*{{index $.ImportPaths .ImportPath}}.{{.StructName}})(nil),
+		[]*revel.MethodType{
+			{{range .MethodSpecs}}&revel.MethodType{
+				Name: "{{.Name}}",
+				Args: []*revel.MethodArg{ {{range .Args}}
+					&revel.MethodArg{Name: "{{.Name}}", Type: reflect.TypeOf((*{{index $.ImportPaths .ImportPath | .TypeExpr.TypeName}})(nil)) },{{end}}
+				},
+				RenderArgNames: map[int][]string{ {{range .RenderCalls}}
+					{{.Line}}: []string{ {{range .Names}}
+						"{{.}}",{{end}}
+					},{{end}}
+				},
+			},
+			{{end}}
+		})
+	{{end}}
+	revel.DefaultValidationKeys = map[string]map[int]string{ {{range $path, $lines := .ValidationKeys}}
+		"{{$path}}": { {{range $line, $key := $lines}}
+			{{$line}}: "{{$key}}",{{end}}
+		},{{end}}
+	}
+	testing.TestSuites = []interface{}{ {{range .TestSuites}}
+		(*{{index $.ImportPaths .ImportPath}}.{{.StructName}})(nil),{{end}}
+	}
+}
+`
+const RevelMainTemplate = `// GENERATED CODE - DO NOT EDIT
+// This file is the main file for Revel.
+// It registers all the controllers and provides details for the Revel server engine to
+// properly inject parameters directly into the action endpoints.
+package main
+
+import (
+	"flag"
+	"{{.ImportPath}}/app/tmp/run"
+	"github.com/revel/revel"
+)
+
+var (
+	runMode    *string = flag.String("runMode", "", "Run mode.")
+	port       *int    = flag.Int("port", 0, "By default, read from app.conf")
+	importPath *string = flag.String("importPath", "", "Go Import Path for the app.")
+	srcPath    *string = flag.String("srcPath", "", "Path to the source root.")
+
+)
+
+func main() {
+	flag.Parse()
+	revel.Init(*runMode, *importPath, *srcPath)
+	run.Run(*port)
+}
+`
+
+// RevelRoutesTemplate template for app/conf/routes
+const RevelRoutesTemplate = `// GENERATED CODE - DO NOT EDIT
+// This file provides a way of creating URL's based on all the actions
+// found in all the controllers.
+package routes
+
+import "github.com/revel/revel"
+
+{{range $i, $c := .Controllers}}
+type t{{.StructName}} struct {}
+var {{.StructName}} t{{.StructName}}
+
+{{range .MethodSpecs}}
+func (_ t{{$c.StructName}}) {{.Name}}({{range .Args}}
+		{{.Name}} {{if .ImportPath}}interface{}{{else}}{{.TypeExpr.TypeName ""}}{{end}},{{end}}
+		) string {
+	args := make(map[string]string)
+	{{range .Args}}
+	revel.Unbind(args, "{{.Name}}", {{.Name}}){{end}}
+	return revel.MainRouter.Reverse("{{$c.StructName}}.{{.Name}}", args).URL
+}
+{{end}}
+{{end}}
+`

app/cmd/harness/harness.go

@@ -0,0 +1,411 @@
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// Package harness for a Revel Framework.
+//
+// It has a following responsibilities:
+// 1. Parse the user program, generating a main.go file that registers
+//    controller classes and starts the user's server.
+// 2. Build and run the user program.  Show compile errors.
+// 3. Monitor the user source and re-build / restart the program when necessary.
+//
+// Source files are generated in the app/tmp directory.
+package harness
+
+import (
+	"crypto/tls"
+	"fmt"
+	"time"
+	"go/build"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+
+	"github.com/revel/cmd/model"
+	"github.com/revel/cmd/utils"
+	"github.com/revel/cmd/watcher"
+	"html/template"
+	"io/ioutil"
+	"sync"
+	"encoding/json"
+)
+
+var (
+	doNotWatch = []string{"tmp", "views", "routes"}
+
+	lastRequestHadError int32
+)
+
+// Harness reverse proxies requests to the application server.
+// It builds / runs / rebuilds / restarts the server when code is changed.
+type Harness struct {
+	app        *App                   // The application
+	useProxy   bool                   // True if proxy is in use
+	serverHost string                 // The proxy server host
+	port       int                    // The proxy serber port
+	proxy      *httputil.ReverseProxy // The proxy
+	watcher    *watcher.Watcher       // The file watched
+	mutex      *sync.Mutex            // A mutex to prevent concurrent updates
+	paths      *model.RevelContainer  // The Revel container
+	config     *model.CommandConfig   // The configuration
+	runMode    string                 // The runmode the harness is running in
+	isError    bool                   // True if harness is in error state
+	ranOnce    bool                   // True app compiled once
+}
+
+func (h *Harness) renderError(iw http.ResponseWriter, ir *http.Request, err error) {
+	// Render error here
+	// Grab the template from three places
+	// 1) Application/views/errors
+	// 2) revel_home/views/errors
+	// 3) views/errors
+	if err == nil {
+		utils.Logger.Panic("Caller passed in a nil error")
+	}
+	templateSet := template.New("__root__")
+	seekViewOnPath := func(view string) (path string) {
+		path = filepath.Join(h.paths.ViewsPath, "errors", view)
+		if !utils.Exists(path) {
+			path = filepath.Join(h.paths.RevelPath, "templates", "errors", view)
+		}
+
+		data, err := ioutil.ReadFile(path)
+		if err != nil {
+			utils.Logger.Error("Unable to read template file", path)
+		}
+		_, err = templateSet.New("errors/" + view).Parse(string(data))
+		if err != nil {
+			utils.Logger.Error("Unable to parse template file", path)
+		}
+		return
+	}
+	target := []string{seekViewOnPath("500.html"), seekViewOnPath("500-dev.html")}
+	if !utils.Exists(target[0]) {
+		fmt.Fprintf(iw, "Target template not found not found %s<br />\n", target[0])
+		fmt.Fprintf(iw, "An error ocurred %s", err.Error())
+		return
+	}
+	var revelError *utils.SourceError
+	switch e := err.(type) {
+	case *utils.SourceError:
+		revelError = e
+	case error:
+		revelError = &utils.SourceError{
+			Title:       "Server Error",
+			Description: e.Error(),
+		}
+	}
+
+	if revelError == nil {
+		panic("no error provided")
+	}
+	viewArgs := map[string]interface{}{}
+	viewArgs["RunMode"] = h.paths.RunMode
+	viewArgs["DevMode"] = h.paths.DevMode
+	viewArgs["Error"] = revelError
+
+	// Render the template from the file
+	err = templateSet.ExecuteTemplate(iw, "errors/500.html", viewArgs)
+	if err != nil {
+		utils.Logger.Error("Failed to execute", "error", err)
+	}
+}
+
+// ServeHTTP handles all requests.
+// It checks for changes to app, rebuilds if necessary, and forwards the request.
+func (h *Harness) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Don't rebuild the app for favicon requests.
+	if lastRequestHadError > 0 && r.URL.Path == "/favicon.ico" {
+		return
+	}
+
+	// Flush any change events and rebuild app if necessary.
+	// Render an error page if the rebuild / restart failed.
+	err := h.watcher.Notify()
+	if err != nil {
+		// In a thread safe manner update the flag so that a request for
+		// /favicon.ico does not trigger a rebuild
+		atomic.CompareAndSwapInt32(&lastRequestHadError, 0, 1)
+		h.renderError(w, r, err)
+		return
+	}
+
+	// In a thread safe manner update the flag so that a request for
+	// /favicon.ico is allowed
+	atomic.CompareAndSwapInt32(&lastRequestHadError, 1, 0)
+
+	// Reverse proxy the request.
+	// (Need special code for websockets, courtesy of bradfitz)
+	if strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
+		h.proxyWebsocket(w, r, h.serverHost)
+	} else {
+		h.proxy.ServeHTTP(w, r)
+	}
+}
+
+// NewHarness method returns a reverse proxy that forwards requests
+// to the given port.
+func NewHarness(c *model.CommandConfig, paths *model.RevelContainer, runMode string, noProxy bool) *Harness {
+	// Get a template loader to render errors.
+	// Prefer the app's views/errors directory, and fall back to the stock error pages.
+	//revel.MainTemplateLoader = revel.NewTemplateLoader(
+	//	[]string{filepath.Join(revel.RevelPath, "templates")})
+	//if err := revel.MainTemplateLoader.Refresh(); err != nil {
+	//	revel.RevelLog.Error("Template loader error", "error", err)
+	//}
+
+	addr := paths.HTTPAddr
+	port := paths.Config.IntDefault("harness.port", 0)
+	scheme := "http"
+
+	if paths.HTTPSsl {
+		scheme = "https"
+	}
+
+	// If the server is running on the wildcard address, use "localhost"
+	if addr == "" {
+		utils.Logger.Warn("No http.addr specified in the app.conf listening on localhost interface only. " +
+			"This will not allow external access to your application")
+		addr = "localhost"
+	}
+
+	if port == 0 {
+		port = getFreePort()
+	}
+
+	serverURL, _ := url.ParseRequestURI(fmt.Sprintf(scheme+"://%s:%d", addr, port))
+
+	serverHarness := &Harness{
+		port:       port,
+		serverHost: serverURL.String()[len(scheme+"://"):],
+		proxy:      httputil.NewSingleHostReverseProxy(serverURL),
+		mutex:      &sync.Mutex{},
+		paths:      paths,
+		useProxy:   !noProxy,
+		config:     c,
+		runMode:    runMode,
+	}
+
+	if paths.HTTPSsl {
+		serverHarness.proxy.Transport = &http.Transport{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		}
+	}
+	return serverHarness
+}
+
+// Refresh method rebuilds the Revel application and run it on the given port.
+// called by the watcher
+func (h *Harness) Refresh() (err *utils.SourceError) {
+	t  := time.Now();
+	fmt.Println("Changed detected, recompiling")
+	err = h.refresh()
+	if err!=nil && !h.ranOnce && h.useProxy {
+		addr := fmt.Sprintf("%s:%d", h.paths.HTTPAddr, h.paths.HTTPPort)
+
+		fmt.Printf("\nError compiling code, to view error details see proxy running on http://%s\n\n",addr)
+	}
+
+	h.ranOnce = true
+	fmt.Printf("\nTime to recompile %s\n",time.Now().Sub(t).String())
+	return
+}
+
+func (h *Harness) refresh() (err *utils.SourceError) {
+	// Allow only one thread to rebuild the process
+	// If multiple requests to rebuild are queued only the last one is executed on
+	// So before a build is started we wait for a second to determine if
+	// more requests for a build are triggered.
+	// Once no more requests are triggered the build will be processed
+	h.mutex.Lock()
+	defer h.mutex.Unlock()
+
+	if h.app != nil {
+		h.app.Kill()
+	}
+
+	utils.Logger.Info("Rebuild Called")
+	var newErr error
+	h.app, newErr = Build(h.config, h.paths)
+	if newErr != nil {
+		utils.Logger.Error("Build detected an error", "error", newErr)
+		if castErr, ok := newErr.(*utils.SourceError); ok {
+			return castErr
+		}
+		err = &utils.SourceError{
+			Title:       "App failed to start up",
+			Description: err.Error(),
+		}
+		return
+	}
+
+	if h.useProxy {
+		h.app.Port = h.port
+		runMode := h.runMode
+		if !h.config.HistoricMode {
+			// Recalulate run mode based on the config
+			var paths []byte
+			if len(h.app.PackagePathMap)>0 {
+				paths, _ = json.Marshal(h.app.PackagePathMap)
+			}
+			runMode = fmt.Sprintf(`{"mode":"%s", "specialUseFlag":%v,"packagePathMap":%s}`, h.app.Paths.RunMode, h.config.Verbose, string(paths))
+
+		}
+		if err2 := h.app.Cmd(runMode).Start(h.config); err2 != nil {
+			utils.Logger.Error("Could not start application", "error", err2)
+			if err,k :=err2.(*utils.SourceError);k {
+				return err
+			}
+			return &utils.SourceError{
+				Title:       "App failed to start up",
+				Description: err2.Error(),
+			}
+		}
+	} else {
+		h.app = nil
+	}
+
+	return
+}
+
+// WatchDir method returns false to file matches with doNotWatch
+// otheriwse true
+func (h *Harness) WatchDir(info os.FileInfo) bool {
+	return !utils.ContainsString(doNotWatch, info.Name())
+}
+
+// WatchFile method returns true given filename HasSuffix of ".go"
+// otheriwse false - implements revel.DiscerningListener
+func (h *Harness) WatchFile(filename string) bool {
+	return strings.HasSuffix(filename, ".go")
+}
+
+// Run the harness, which listens for requests and proxies them to the app
+// server, which it runs and rebuilds as necessary.
+func (h *Harness) Run() {
+	var paths []string
+	if h.paths.Config.BoolDefault("watch.gopath", false) {
+		gopaths := filepath.SplitList(build.Default.GOPATH)
+		paths = append(paths, gopaths...)
+	}
+	paths = append(paths, h.paths.CodePaths...)
+	h.watcher = watcher.NewWatcher(h.paths, false)
+	h.watcher.Listen(h, paths...)
+	go h.Refresh()
+	// h.watcher.Notify()
+
+	if h.useProxy {
+		go func() {
+			// Check the port to start on a random port
+			if h.paths.HTTPPort == 0 {
+				h.paths.HTTPPort = getFreePort()
+			}
+			addr := fmt.Sprintf("%s:%d", h.paths.HTTPAddr, h.paths.HTTPPort)
+			utils.Logger.Infof("Proxy server is listening on %s", addr)
+
+
+			var err error
+			if h.paths.HTTPSsl {
+				err = http.ListenAndServeTLS(
+					addr,
+					h.paths.HTTPSslCert,
+					h.paths.HTTPSslKey,
+					h)
+			} else {
+				err = http.ListenAndServe(addr, h)
+			}
+			if err != nil {
+				utils.Logger.Error("Failed to start reverse proxy:", "error", err)
+			}
+		}()
+
+	}
+
+	// Make a new channel to listen for the interrupt event
+	ch := make(chan os.Signal)
+	signal.Notify(ch, os.Interrupt, os.Kill)
+	<-ch
+	// Kill the app and exit
+	if h.app != nil {
+		h.app.Kill()
+	}
+	os.Exit(1)
+}
+
+// Find an unused port
+func getFreePort() (port int) {
+	conn, err := net.Listen("tcp", ":0")
+	if err != nil {
+		utils.Logger.Fatal("Unable to fetch a freee port address", "error", err)
+	}
+
+	port = conn.Addr().(*net.TCPAddr).Port
+	err = conn.Close()
+	if err != nil {
+		utils.Logger.Fatal("Unable to close port", "error", err)
+	}
+	return port
+}
+
+// proxyWebsocket copies data between websocket client and server until one side
+// closes the connection.  (ReverseProxy doesn't work with websocket requests.)
+func (h *Harness) proxyWebsocket(w http.ResponseWriter, r *http.Request, host string) {
+	var (
+		d   net.Conn
+		err error
+	)
+	if h.paths.HTTPSsl {
+		// since this proxy isn't used in production,
+		// it's OK to set InsecureSkipVerify to true
+		// no need to add another configuration option.
+		d, err = tls.Dial("tcp", host, &tls.Config{InsecureSkipVerify: true})
+	} else {
+		d, err = net.Dial("tcp", host)
+	}
+	if err != nil {
+		http.Error(w, "Error contacting backend server.", 500)
+		utils.Logger.Error("Error dialing websocket backend ", "host", host, "error", err)
+		return
+	}
+	hj, ok := w.(http.Hijacker)
+	if !ok {
+		http.Error(w, "Not a hijacker?", 500)
+		return
+	}
+	nc, _, err := hj.Hijack()
+	if err != nil {
+		utils.Logger.Error("Hijack error", "error", err)
+		return
+	}
+	defer func() {
+		if err = nc.Close(); err != nil {
+			utils.Logger.Error("Connection close error", "error", err)
+		}
+		if err = d.Close(); err != nil {
+			utils.Logger.Error("Dial close error", "error", err)
+		}
+	}()
+
+	err = r.Write(d)
+	if err != nil {
+		utils.Logger.Error("Error copying request to target", "error", err)
+		return
+	}
+
+	errc := make(chan error, 2)
+	cp := func(dst io.Writer, src io.Reader) {
+		_, err := io.Copy(dst, src)
+		errc <- err
+	}
+	go cp(d, nc)
+	go cp(nc, d)
+	<-errc
+}

app/cmd/parser2/source_info_processor.go

@@ -0,0 +1,427 @@
+package parser2
+
+import (
+	"github.com/revel/cmd/utils"
+	"golang.org/x/tools/go/packages"
+	"github.com/revel/cmd/model"
+	"go/ast"
+	"go/token"
+	"strings"
+	"path/filepath"
+	"github.com/revel/cmd/logger"
+)
+
+type (
+	SourceInfoProcessor struct {
+		sourceProcessor *SourceProcessor
+	}
+)
+
+func NewSourceInfoProcessor(sourceProcessor *SourceProcessor) *SourceInfoProcessor {
+	return &SourceInfoProcessor{sourceProcessor:sourceProcessor}
+}
+
+func (s *SourceInfoProcessor) processPackage(p *packages.Package) (sourceInfo *model.SourceInfo) {
+	sourceInfo = &model.SourceInfo{
+		ValidationKeys: map[string]map[int]string{},
+	}
+	var (
+		isController = strings.HasSuffix(p.PkgPath, "/controllers") ||
+			strings.Contains(p.PkgPath, "/controllers/")
+		isTest = strings.HasSuffix(p.PkgPath, "/tests") ||
+			strings.Contains(p.PkgPath, "/tests/")
+		methodMap = map[string][]*model.MethodSpec{}
+	)
+	localImportMap := map[string]string{}
+	log := s.sourceProcessor.log.New("package", p.PkgPath)
+	log.Info("Processing package")
+	for _, tree := range p.Syntax {
+		for _, decl := range tree.Decls {
+
+			s.sourceProcessor.packageMap[p.PkgPath] = filepath.Dir(p.Fset.Position(decl.Pos()).Filename)
+			if !s.addImport(decl, p, localImportMap, log) {
+				continue
+			}
+			spec, found := s.getStructTypeDecl(decl, p.Fset)
+			//log.Info("Checking file","filename", p.Fset.Position(decl.Pos()).Filename,"found",found)
+			if found {
+				if isController || isTest {
+					controllerSpec := s.getControllerSpec(spec, p, localImportMap)
+					sourceInfo.StructSpecs = append(sourceInfo.StructSpecs, controllerSpec)
+				}
+			} else {
+				// Not a type definition, this could be a method for a controller try to extract that
+				// Func declaration?
+				funcDecl, ok := decl.(*ast.FuncDecl)
+				if !ok {
+					continue
+				}
+				// This could be a controller action endpoint, check and add if needed
+				if isController &&
+					funcDecl.Recv != nil && // Must have a receiver
+					funcDecl.Name.IsExported() && // be public
+					funcDecl.Type.Results != nil && len(funcDecl.Type.Results.List) == 1 {
+					// return one result
+					if m, receiver := s.getControllerFunc(funcDecl, p, localImportMap); m != nil {
+						methodMap[receiver] = append(methodMap[receiver], m)
+						log.Info("Added method map to ", "receiver", receiver, "method", m.Name)
+					}
+				}
+				// Check for validation
+				if lineKeyMap := s.getValidation(funcDecl, p); len(lineKeyMap) > 1 {
+					sourceInfo.ValidationKeys[p.PkgPath + "." + s.getFuncName(funcDecl)] = lineKeyMap
+				}
+				if funcDecl.Name.Name == "init" {
+					sourceInfo.InitImportPaths = append(sourceInfo.InitImportPaths, p.PkgPath)
+				}
+			}
+		}
+	}
+
+	// Add the method specs to the struct specs.
+	for _, spec := range sourceInfo.StructSpecs {
+		spec.MethodSpecs = methodMap[spec.StructName]
+	}
+
+	return
+}
+// Scan app source code for calls to X.Y(), where X is of type *Validation.
+//
+// Recognize these scenarios:
+// - "Y" = "Validation" and is a member of the receiver.
+//   (The common case for inline validation)
+// - "X" is passed in to the func as a parameter.
+//   (For structs implementing Validated)
+//
+// The line number to which a validation call is attributed is that of the
+// surrounding ExprStmt.  This is so that it matches what runtime.Callers()
+// reports.
+//
+// The end result is that we can set the default validation key for each call to
+// be the same as the local variable.
+func (s *SourceInfoProcessor) getValidation(funcDecl *ast.FuncDecl, p *packages.Package) (map[int]string) {
+	var (
+		lineKeys = make(map[int]string)
+
+		// Check the func parameters and the receiver's members for the *revel.Validation type.
+		validationParam = s.getValidationParameter(funcDecl)
+	)
+
+	ast.Inspect(funcDecl.Body, func(node ast.Node) bool {
+		// e.g. c.Validation.Required(arg) or v.Required(arg)
+		callExpr, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+
+		// e.g. c.Validation.Required or v.Required
+		funcSelector, ok := callExpr.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+
+		switch x := funcSelector.X.(type) {
+		case *ast.SelectorExpr: // e.g. c.Validation
+			if x.Sel.Name != "Validation" {
+				return true
+			}
+
+		case *ast.Ident: // e.g. v
+			if validationParam == nil || x.Obj != validationParam {
+				return true
+			}
+
+		default:
+			return true
+		}
+
+		if len(callExpr.Args) == 0 {
+			return true
+		}
+
+		// Given the validation expression, extract the key.
+		key := callExpr.Args[0]
+		switch expr := key.(type) {
+		case *ast.BinaryExpr:
+			// If the argument is a binary expression, take the first expression.
+			// (e.g. c.Validation.Required(myName != ""))
+			key = expr.X
+		case *ast.UnaryExpr:
+			// If the argument is a unary expression, drill in.
+			// (e.g. c.Validation.Required(!myBool)
+			key = expr.X
+		case *ast.BasicLit:
+			// If it's a literal, skip it.
+			return true
+		}
+
+		if typeExpr := model.NewTypeExprFromAst("", key); typeExpr.Valid {
+			lineKeys[p.Fset.Position(callExpr.End()).Line] = typeExpr.TypeName("")
+		} else {
+			s.sourceProcessor.log.Error("Error: Failed to generate key for field validation. Make sure the field name is valid.", "file", p.PkgPath,
+				"line", p.Fset.Position(callExpr.End()).Line, "function", funcDecl.Name.String())
+		}
+		return true
+	})
+
+	return lineKeys
+
+}
+// Check to see if there is a *revel.Validation as an argument.
+func (s *SourceInfoProcessor)  getValidationParameter(funcDecl *ast.FuncDecl) *ast.Object {
+	for _, field := range funcDecl.Type.Params.List {
+		starExpr, ok := field.Type.(*ast.StarExpr) // e.g. *revel.Validation
+		if !ok {
+			continue
+		}
+
+		selExpr, ok := starExpr.X.(*ast.SelectorExpr) // e.g. revel.Validation
+		if !ok {
+			continue
+		}
+
+		xIdent, ok := selExpr.X.(*ast.Ident) // e.g. rev
+		if !ok {
+			continue
+		}
+
+		if selExpr.Sel.Name == "Validation" && s.sourceProcessor.importMap[xIdent.Name] == model.RevelImportPath {
+			return field.Names[0].Obj
+		}
+	}
+	return nil
+}
+func (s *SourceInfoProcessor) getControllerFunc(funcDecl *ast.FuncDecl, p *packages.Package, localImportMap map[string]string) (method *model.MethodSpec, recvTypeName string) {
+	selExpr, ok := funcDecl.Type.Results.List[0].Type.(*ast.SelectorExpr)
+	if !ok {
+		return
+	}
+	if selExpr.Sel.Name != "Result" {
+		return
+	}
+	if pkgIdent, ok := selExpr.X.(*ast.Ident); !ok || s.sourceProcessor.importMap[pkgIdent.Name] != model.RevelImportPath {
+		return
+	}
+	method = &model.MethodSpec{
+		Name: funcDecl.Name.Name,
+	}
+
+	// Add a description of the arguments to the method.
+	for _, field := range funcDecl.Type.Params.List {
+		for _, name := range field.Names {
+			var importPath string
+			typeExpr := model.NewTypeExprFromAst(p.Name, field.Type)
+			if !typeExpr.Valid {
+				utils.Logger.Warn("Warn: Didn't understand argument '%s' of action %s. Ignoring.", name, s.getFuncName(funcDecl))
+				return // We didn't understand one of the args.  Ignore this action.
+			}
+			// Local object
+			if typeExpr.PkgName == p.Name {
+				importPath = p.PkgPath
+			} else if typeExpr.PkgName != "" {
+				var ok bool
+				if importPath, ok = localImportMap[typeExpr.PkgName]; !ok {
+					if importPath, ok = s.sourceProcessor.importMap[typeExpr.PkgName]; !ok {
+						utils.Logger.Error("Unable to find import", "importMap", s.sourceProcessor.importMap, "localimport", localImportMap)
+						utils.Logger.Fatalf("Failed to find import for arg of type: %s , %s", typeExpr.PkgName, typeExpr.TypeName(""))
+					}
+				}
+			}
+			method.Args = append(method.Args, &model.MethodArg{
+				Name:       name.Name,
+				TypeExpr:   typeExpr,
+				ImportPath: importPath,
+			})
+		}
+	}
+
+	// Add a description of the calls to Render from the method.
+	// Inspect every node (e.g. always return true).
+	method.RenderCalls = []*model.MethodCall{}
+	ast.Inspect(funcDecl.Body, func(node ast.Node) bool {
+		// Is it a function call?
+		callExpr, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+
+		// Is it calling (*Controller).Render?
+		selExpr, ok := callExpr.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+
+		// The type of the receiver is not easily available, so just store every
+		// call to any method called Render.
+		if selExpr.Sel.Name != "Render" {
+			return true
+		}
+
+		// Add this call's args to the renderArgs.
+		pos := p.Fset.Position(callExpr.Lparen)
+		methodCall := &model.MethodCall{
+			Line:  pos.Line,
+			Names: []string{},
+		}
+		for _, arg := range callExpr.Args {
+			argIdent, ok := arg.(*ast.Ident)
+			if !ok {
+				continue
+			}
+			methodCall.Names = append(methodCall.Names, argIdent.Name)
+		}
+		method.RenderCalls = append(method.RenderCalls, methodCall)
+		return true
+	})
+
+	var recvType = funcDecl.Recv.List[0].Type
+	if recvStarType, ok := recvType.(*ast.StarExpr); ok {
+		recvTypeName = recvStarType.X.(*ast.Ident).Name
+	} else {
+		recvTypeName = recvType.(*ast.Ident).Name
+	}
+	return
+}
+func (s *SourceInfoProcessor) getControllerSpec(spec *ast.TypeSpec, p *packages.Package, localImportMap map[string]string) (controllerSpec *model.TypeInfo) {
+	structType := spec.Type.(*ast.StructType)
+
+	// At this point we know it's a type declaration for a struct.
+	// Fill in the rest of the info by diving into the fields.
+	// Add it provisionally to the Controller list -- it's later filtered using field info.
+	controllerSpec = &model.TypeInfo{
+		StructName:  spec.Name.Name,
+		ImportPath:  p.PkgPath,
+		PackageName: p.Name,
+	}
+	log := s.sourceProcessor.log.New("file", p.Fset.Position(spec.Pos()).Filename, "position", p.Fset.Position(spec.Pos()).Line)
+	for _, field := range structType.Fields.List {
+		// If field.Names is set, it's not an embedded type.
+		if field.Names != nil {
+			continue
+		}
+
+		// A direct "sub-type" has an ast.Field as either:
+		//   Ident { "AppController" }
+		//   SelectorExpr { "rev", "Controller" }
+		// Additionally, that can be wrapped by StarExprs.
+		fieldType := field.Type
+		pkgName, typeName := func() (string, string) {
+			// Drill through any StarExprs.
+			for {
+				if starExpr, ok := fieldType.(*ast.StarExpr); ok {
+					fieldType = starExpr.X
+					continue
+				}
+				break
+			}
+
+			// If the embedded type is in the same package, it's an Ident.
+			if ident, ok := fieldType.(*ast.Ident); ok {
+				return "", ident.Name
+			}
+
+			if selectorExpr, ok := fieldType.(*ast.SelectorExpr); ok {
+				if pkgIdent, ok := selectorExpr.X.(*ast.Ident); ok {
+					return pkgIdent.Name, selectorExpr.Sel.Name
+				}
+			}
+			return "", ""
+		}()
+
+		// If a typename wasn't found, skip it.
+		if typeName == "" {
+			continue
+		}
+
+		// Find the import path for this type.
+		// If it was referenced without a package name, use the current package import path.
+		// Else, look up the package's import path by name.
+		var importPath string
+		if pkgName == "" {
+			importPath = p.PkgPath
+		} else {
+			var ok bool
+			if importPath, ok = localImportMap[pkgName]; !ok {
+				log.Debug("Debug: Unusual, failed to find package locally ", "package", pkgName, "type", typeName, "map", s.sourceProcessor.importMap, "usedin", )
+				if importPath, ok = s.sourceProcessor.importMap[pkgName]; !ok {
+					log.Error("Error: Failed to find import path for ", "package", pkgName, "type", typeName, "map", s.sourceProcessor.importMap, "usedin", )
+					continue
+				}
+			}
+		}
+
+		controllerSpec.EmbeddedTypes = append(controllerSpec.EmbeddedTypes, &model.EmbeddedTypeName{
+			ImportPath: importPath,
+			StructName: typeName,
+		})
+	}
+	s.sourceProcessor.log.Info("Added controller spec", "name", controllerSpec.StructName, "package", controllerSpec.ImportPath)
+	return
+}
+func (s *SourceInfoProcessor) getStructTypeDecl(decl ast.Decl, fset *token.FileSet) (spec *ast.TypeSpec, found bool) {
+	genDecl, ok := decl.(*ast.GenDecl)
+	if !ok {
+		return
+	}
+
+	if genDecl.Tok != token.TYPE {
+		return
+	}
+
+	if len(genDecl.Specs) == 0 {
+		utils.Logger.Warn("Warn: Surprising: %s:%d Decl contains no specifications", fset.Position(decl.Pos()).Filename, fset.Position(decl.Pos()).Line)
+		return
+	}
+
+	spec = genDecl.Specs[0].(*ast.TypeSpec)
+	_, found = spec.Type.(*ast.StructType)
+
+	return
+
+}
+func (s *SourceInfoProcessor) getFuncName(funcDecl *ast.FuncDecl) string {
+	prefix := ""
+	if funcDecl.Recv != nil {
+		recvType := funcDecl.Recv.List[0].Type
+		if recvStarType, ok := recvType.(*ast.StarExpr); ok {
+			prefix = "(*" + recvStarType.X.(*ast.Ident).Name + ")"
+		} else {
+			prefix = recvType.(*ast.Ident).Name
+		}
+		prefix += "."
+	}
+	return prefix + funcDecl.Name.Name
+}
+func (s *SourceInfoProcessor) addImport(decl ast.Decl, p *packages.Package, localImportMap map[string]string, log logger.MultiLogger) (shouldContinue bool) {
+	shouldContinue = true
+	genDecl, ok := decl.(*ast.GenDecl)
+	if !ok {
+		return
+	}
+
+	if genDecl.Tok == token.IMPORT {
+		shouldContinue = false
+		for _, spec := range genDecl.Specs {
+			importSpec := spec.(*ast.ImportSpec)
+			//fmt.Printf("*** import specification %#v\n", importSpec)
+			var pkgAlias string
+			if importSpec.Name != nil {
+				pkgAlias = importSpec.Name.Name
+				if pkgAlias == "_" {
+					continue
+				}
+			}
+			quotedPath := importSpec.Path.Value           // e.g. "\"sample/app/models\""
+			fullPath := quotedPath[1 : len(quotedPath) - 1] // Remove the quotes
+			if pkgAlias == "" {
+				pkgAlias = fullPath
+				if index := strings.LastIndex(pkgAlias, "/"); index > 0 {
+					pkgAlias = pkgAlias[index + 1:]
+				}
+			}
+			localImportMap[pkgAlias] = fullPath
+		}
+
+	}
+	return
+}

app/cmd/parser2/source_processor.go

@@ -0,0 +1,310 @@
+package parser2
+
+import (
+	"github.com/revel/cmd/logger"
+	"github.com/revel/cmd/model"
+	"github.com/revel/cmd/utils"
+	"go/ast"
+	"go/parser"
+	"go/scanner"
+	"go/token"
+	"golang.org/x/tools/go/packages"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type (
+	SourceProcessor struct {
+		revelContainer      *model.RevelContainer
+		log                 logger.MultiLogger
+		packageList         []*packages.Package
+		importMap           map[string]string
+		packageMap          map[string]string
+		sourceInfoProcessor *SourceInfoProcessor
+		sourceInfo          *model.SourceInfo
+	}
+)
+
+func ProcessSource(revelContainer *model.RevelContainer) (sourceInfo *model.SourceInfo, compileError error) {
+	utils.Logger.Info("ProcessSource")
+	processor := NewSourceProcessor(revelContainer)
+	compileError = processor.parse()
+	sourceInfo = processor.sourceInfo
+	if compileError == nil {
+		processor.log.Infof("From parsers : Structures:%d InitImports:%d ValidationKeys:%d %v", len(sourceInfo.StructSpecs), len(sourceInfo.InitImportPaths), len(sourceInfo.ValidationKeys), sourceInfo.PackageMap)
+	}
+
+	return
+}
+
+func NewSourceProcessor(revelContainer *model.RevelContainer) *SourceProcessor {
+	s := &SourceProcessor{revelContainer:revelContainer, log:utils.Logger.New("parser", "SourceProcessor")}
+	s.sourceInfoProcessor = NewSourceInfoProcessor(s)
+	return s
+}
+
+func (s *SourceProcessor) parse() (compileError error) {
+	print("Parsing packages, (may require download if not cached)...")
+	if compileError = s.addPackages(); compileError != nil {
+		return
+	}
+	println(" Completed")
+	if compileError = s.addImportMap(); compileError != nil {
+		return
+	}
+	if compileError = s.addSourceInfo(); compileError != nil {
+		return
+	}
+
+	s.sourceInfo.PackageMap = map[string]string{}
+	getImportFromMap := func(packagePath string) string {
+		for path := range s.packageMap {
+			if strings.Index(path, packagePath) == 0 {
+				fullPath := s.packageMap[path]
+				return fullPath[:(len(fullPath) - len(path) + len(packagePath))]
+			}
+		}
+		return ""
+	}
+	s.sourceInfo.PackageMap[model.RevelImportPath] = getImportFromMap(model.RevelImportPath)
+	s.sourceInfo.PackageMap[s.revelContainer.ImportPath] = getImportFromMap(s.revelContainer.ImportPath)
+	for _, module := range s.revelContainer.ModulePathMap {
+		s.sourceInfo.PackageMap[module.ImportPath] = getImportFromMap(module.ImportPath)
+	}
+
+	return
+}
+
+// 这两个方法来自util
+
+// Shortcut to fsWalk
+func (s *SourceProcessor) Walk(root string, walkFn filepath.WalkFunc) error {
+	return s.fsWalk(root, root, walkFn)
+}
+
+// Walk the path tree using the function
+// Every file found will call the function
+func (s *SourceProcessor) fsWalk(fname string, linkName string, walkFn filepath.WalkFunc) error {
+	fsWalkFunc := func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		var name string
+		name, err = filepath.Rel(fname, path)
+		if err != nil {
+			return err
+		}
+
+		path = filepath.Join(linkName, name)
+
+		// 改了这里
+		if strings.Contains(path, "/leanote/public") ||
+			strings.Contains(path, "/leanote/files") ||
+			strings.Contains(path, "/leanote/doc") ||
+			strings.Contains(path, "/leanote/logs") ||
+			strings.Contains(path, "/leanote/build") ||
+			strings.Contains(path, "/leanote/target") {
+			s.log.Warn("public 或 files 不要处理", "path", path)
+			return filepath.SkipDir
+		}
+
+		if err == nil && info.Mode() & os.ModeSymlink == os.ModeSymlink {
+			var symlinkPath string
+			symlinkPath, err = filepath.EvalSymlinks(path)
+			if err != nil {
+				return err
+			}
+
+			// https://github.com/golang/go/blob/master/src/path/filepath/path.go#L392
+			info, err = os.Lstat(symlinkPath)
+
+			if err != nil {
+				return walkFn(path, info, err)
+			}
+
+			if info.IsDir() {
+				return s.fsWalk(symlinkPath, path, walkFn)
+			}
+		}
+
+		return walkFn(path, info, err)
+	}
+	err := filepath.Walk(fname, fsWalkFunc)
+	return err
+}
+
+// Using the packages.Load function load all the packages and type specifications (forces compile).
+// this sets the SourceProcessor.packageList         []*packages.Package
+func (s *SourceProcessor) addPackages() (err error) {
+	allPackages := []string{model.RevelImportPath + "/..."}
+	for _, module := range s.revelContainer.ModulePathMap {
+		allPackages = append(allPackages, module.ImportPath + "/...") // +"/app/controllers/...")
+	}
+	s.log.Info("Reading packages", "packageList", allPackages)
+	//allPackages = []string{s.revelContainer.ImportPath + "/..."} //+"/app/controllers/..."}
+
+	config := &packages.Config{
+		// ode: packages.NeedSyntax | packages.NeedCompiledGoFiles,
+		Mode:
+		packages.NeedTypes | // For compile error
+			packages.NeedDeps | // To load dependent files
+			packages.NeedName | // Loads the full package name
+			packages.NeedSyntax, // To load ast tree (for end points)
+		//Mode:	packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+		//	packages.NeedImports | packages.NeedDeps | packages.NeedExportsFile |
+		//	packages.NeedTypes | packages.NeedSyntax | packages.NeedTypesInfo |
+		//	packages.NeedTypesSizes,
+
+		//Mode: packages.NeedName | packages.NeedImports | packages.NeedDeps | packages.NeedExportsFile | packages.NeedFiles |
+		//	packages.NeedCompiledGoFiles | packages.NeedTypesSizes |
+		//	packages.NeedSyntax | packages.NeedCompiledGoFiles ,
+		//Mode:  packages.NeedSyntax | packages.NeedCompiledGoFiles |  packages.NeedName | packages.NeedFiles |
+		//	packages.LoadTypes | packages.NeedTypes | packages.NeedDeps,  //, // |
+		// packages.NeedTypes, // packages.LoadTypes | packages.NeedSyntax | packages.NeedTypesInfo,
+		//packages.LoadSyntax | packages.NeedDeps,
+		Dir:s.revelContainer.AppPath,
+	}
+	s.packageList, err = packages.Load(config, allPackages...)
+	s.log.Info("Loaded modules ", "len results", len(s.packageList), "error", err)
+
+	// Now process the files in the aap source folder	s.revelContainer.ImportPath + "/...",
+	err = s.Walk(s.revelContainer.BasePath, s.processPath)
+	s.log.Info("Loaded apps and modules ", "len results", len(s.packageList), "error", err)
+	return
+}
+
+// This callback is used to build the packages for the "app" package. This allows us to
+// parse the source files without doing a full compile on them
+// This callback only processes folders, so any files passed to this will return a nil
+func (s *SourceProcessor) processPath(path string, info os.FileInfo, err error) error {
+	if err != nil {
+		s.log.Error("Error scanning app source:", "error", err)
+		return nil
+	}
+
+	// Ignore files and folders not marked tmp (since those are generated)
+	if !info.IsDir() || info.Name() == "tmp" {
+		return nil
+	}
+
+	// Real work for processing the folder
+	pkgImportPath := s.revelContainer.ImportPath
+	appPath := s.revelContainer.BasePath
+	if appPath != path {
+		pkgImportPath = s.revelContainer.ImportPath + "/" + filepath.ToSlash(path[len(appPath) + 1:])
+	}
+	s.log.Info("Processing source package folder", "package", pkgImportPath, "path", path)
+
+	// Parse files within the path.
+	var pkgMap map[string]*ast.Package
+	fset := token.NewFileSet()
+	pkgMap, err = parser.ParseDir(
+		fset,
+		path,
+		func(f os.FileInfo) bool {
+			return !f.IsDir() && !strings.HasPrefix(f.Name(), ".") && strings.HasSuffix(f.Name(), ".go")
+		},
+		0)
+
+	if err != nil {
+		if errList, ok := err.(scanner.ErrorList); ok {
+			var pos = errList[0].Pos
+			newError := &utils.SourceError{
+				SourceType:  ".go source",
+				Title:       "Go Compilation Error",
+				Path:        pos.Filename,
+				Description: errList[0].Msg,
+				Line:        pos.Line,
+				Column:      pos.Column,
+				SourceLines: utils.MustReadLines(pos.Filename),
+			}
+
+			errorLink := s.revelContainer.Config.StringDefault("error.link", "")
+			if errorLink != "" {
+				newError.SetLink(errorLink)
+			}
+			return newError
+		}
+
+		// This is exception, err already checked above. Here just a print
+		ast.Print(nil, err)
+		s.log.Fatal("Failed to parse dir", "error", err)
+	}
+
+	// Skip "main" packages.
+	delete(pkgMap, "main")
+
+	// Ignore packages that end with _test
+	// These cannot be included in source code that is not generated specifically as a test
+	for i := range pkgMap {
+		if len(i) > 6 {
+			if string(i[len(i) - 5:]) == "_test" {
+				delete(pkgMap, i)
+			}
+		}
+	}
+
+	// If there is no code in this directory, skip it.
+	if len(pkgMap) == 0 {
+		return nil
+	}
+
+	// There should be only one package in this directory.
+	if len(pkgMap) > 1 {
+		for i := range pkgMap {
+			println("Found duplicate packages in single directory ", i)
+		}
+		utils.Logger.Fatal("Most unexpected! Multiple packages in a single directory:", "packages", pkgMap)
+	}
+
+	// At this point there is only one package in the pkgs map,
+	p := &packages.Package{}
+	p.PkgPath = pkgImportPath
+	p.Fset = fset
+	for _, pkg := range pkgMap {
+		p.Name = pkg.Name
+		s.log.Info("Found package", "pkg.Name", pkg.Name, "p.Name", p.PkgPath)
+		for filename, astFile := range pkg.Files {
+			p.Syntax = append(p.Syntax, astFile)
+			p.GoFiles = append(p.GoFiles, filename)
+		}
+	}
+	s.packageList = append(s.packageList, p)
+
+	return nil
+}
+
+// This function is used to populate a map so that we can lookup controller embedded types in order to determine
+// if a Struct inherits from from revel.Controller
+func (s *SourceProcessor) addImportMap() (err error) {
+	s.importMap = map[string]string{}
+	s.packageMap = map[string]string{}
+	for _, p := range s.packageList {
+
+		if len(p.Errors) > 0 {
+			// Generate a compile error
+			for _, e := range p.Errors {
+				s.log.Info("While reading packages encountered import error ignoring ", "PkgPath", p.PkgPath, "error", e)
+			}
+		}
+		for _, tree := range p.Syntax {
+			s.importMap[tree.Name.Name] = p.PkgPath
+		}
+	}
+	return
+}
+
+func (s *SourceProcessor) addSourceInfo() (err error) {
+	for _, p := range s.packageList {
+		if sourceInfo := s.sourceInfoProcessor.processPackage(p); sourceInfo != nil {
+			if s.sourceInfo != nil {
+				s.sourceInfo.Merge(sourceInfo)
+			} else {
+				s.sourceInfo = sourceInfo
+			}
+		}
+	}
+	return
+}

app/cmd/revel.go

@@ -0,0 +1,151 @@
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// The command line tool for running Revel apps.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"math/rand"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/jessevdk/go-flags"
+
+	"github.com/agtorre/gocolorize"
+	"github.com/revel/cmd/logger"
+	"github.com/revel/cmd/model"
+	"github.com/revel/cmd/utils"
+	"bytes"
+)
+
+const (
+	// RevelCmdImportPath Revel framework cmd tool import path
+	RevelCmdImportPath = "github.com/revel/cmd"
+
+	// RevelCmdImportPath Revel framework cmd tool import path
+	RevelSkeletonsImportPath = "github.com/revel/skeletons"
+
+	// DefaultRunMode for revel's application
+	DefaultRunMode = "dev"
+)
+
+// Command structure cribbed from the genius organization of the "go" command.
+type Command struct {
+	UpdateConfig           func(c *model.CommandConfig, args []string) bool
+	RunWith                func(c *model.CommandConfig) error
+	UsageLine, Short, Long string
+}
+
+// Name returns command name from usage line
+func (cmd *Command) Name() string {
+	name := cmd.UsageLine
+	i := strings.Index(name, " ")
+	if i >= 0 {
+		name = name[:i]
+	}
+	return name
+}
+
+// The commands
+var Commands = []*Command{
+	nil, // Safety net, prevent missing index from running
+
+	// 只改了这个
+	nil,
+	nil,
+	cmdBuild,
+}
+
+func main() {
+	if runtime.GOOS == "windows" {
+		gocolorize.SetPlain(true)
+	}
+	c := &model.CommandConfig{}
+	wd, _ := os.Getwd()
+
+	utils.InitLogger(wd, logger.LvlError)
+	parser := flags.NewParser(c, flags.HelpFlag | flags.PassDoubleDash)
+	if len(os.Args) < 2 {
+		parser.WriteHelp(os.Stdout)
+		os.Exit(1)
+	}
+
+	if err := ParseArgs(c, parser, os.Args[1:]); err != nil {
+		fmt.Fprint(os.Stderr, err.Error() + "\n")
+		os.Exit(1)
+	}
+
+	// Switch based on the verbose flag
+	if len(c.Verbose) > 1 {
+		utils.InitLogger(wd, logger.LvlDebug)
+	} else if len(c.Verbose) > 0 {
+		utils.InitLogger(wd, logger.LvlInfo)
+	} else {
+		utils.InitLogger(wd, logger.LvlWarn)
+	}
+
+	// Setup package resolver
+	c.InitPackageResolver()
+
+	if err := c.UpdateImportPath(); err != nil {
+		utils.Logger.Error(err.Error())
+		parser.WriteHelp(os.Stdout)
+		os.Exit(1)
+	}
+
+	command := Commands[c.Index]
+	println("Revel executing:", command.Short)
+
+	if err := command.RunWith(c); err != nil {
+		utils.Logger.Error("Unable to execute", "error", err)
+		os.Exit(1)
+	}
+}
+
+// Parse the arguments passed into the model.CommandConfig
+func ParseArgs(c *model.CommandConfig, parser *flags.Parser, args []string) (err error) {
+	var extraArgs []string
+	if ini := flag.String("ini", "none", ""); *ini != "none" {
+		if err = flags.NewIniParser(parser).ParseFile(*ini); err != nil {
+			return
+		}
+	} else {
+		if extraArgs, err = parser.ParseArgs(args); err != nil {
+			return
+		} else {
+			switch parser.Active.Name {
+			case "new":
+				c.Index = model.NEW
+			case "run":
+				c.Index = model.RUN
+			case "build":
+				c.Index = model.BUILD
+			case "package":
+				c.Index = model.PACKAGE
+			case "clean":
+				c.Index = model.CLEAN
+			case "test":
+				c.Index = model.TEST
+			case "version":
+				c.Index = model.VERSION
+			}
+		}
+	}
+
+	if !Commands[c.Index].UpdateConfig(c, extraArgs) {
+		buffer := &bytes.Buffer{}
+		parser.WriteHelp(buffer)
+		err = fmt.Errorf("Invalid command line arguements %v\n%s", extraArgs, buffer.String())
+	}
+
+	return
+}
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}

app/controllers/AlbumController.go

@@ -2,11 +2,11 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
+	//	"encoding/json"
 	"github.com/leanote/leanote/app/info"
 	"gopkg.in/mgo.v2/bson"
-//	. "github.com/leanote/leanote/app/lea"
-//	"io/ioutil"
+	//	. "github.com/leanote/leanote/app/lea"
+	//	"io/ioutil"
 )
 
 // Album controller
@@ -14,34 +14,39 @@ type Album struct {
 	BaseController
 }
 
+// 图片管理, iframe
+func (c Album) Index() revel.Result {
+	c.SetLocale()
+	return c.RenderTemplate("album/index.html")
+}
+
 // all albums by userId
 func (c Album) GetAlbums() revel.Result {
 	re := albumService.GetAlbums(c.GetUserId())
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
-
 func (c Album) DeleteAlbum(albumId string) revel.Result {
 	re, msg := albumService.DeleteAlbum(c.GetUserId(), albumId)
-	return c.RenderJson(info.Re{Ok: re, Msg: msg})
+	return c.RenderJSON(info.Re{Ok: re, Msg: msg})
 }
 
 // add album
 func (c Album) AddAlbum(name string) revel.Result {
 	album := info.Album{
 		AlbumId: bson.NewObjectId(),
-		Name: name,
-		Seq: -1,
-		UserId: c.GetObjectUserId()}
+		Name:    name,
+		Seq:     -1,
+		UserId:  c.GetObjectUserId()}
 	re := albumService.AddAlbum(album)
 
-	if(re) {
-		return c.RenderJson(album)
+	if re {
+		return c.RenderJSON(album)
 	} else {
-		return c.RenderJson(false)
+		return c.RenderJSON(false)
 	}
 }
 
 // update alnum name
 func (c Album) UpdateAlbum(albumId, name string) revel.Result {
-	return c.RenderJson(albumService.UpdateAlbum(albumId, c.GetUserId(), name))
-}
+	return c.RenderJSON(albumService.UpdateAlbum(albumId, c.GetUserId(), name))
+}

app/controllers/AttachController.go

@@ -2,17 +2,18 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-	"gopkg.in/mgo.v2/bson"
-	. "github.com/leanote/leanote/app/lea"
+	//	"encoding/json"
+	"archive/tar"
+	"compress/gzip"
+	"fmt"
 	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"gopkg.in/mgo.v2/bson"
+	"io"
 	"io/ioutil"
 	"os"
 	"strings"
 	"time"
-    "io"
-    "archive/tar"
-    "compress/gzip"
 )
 
 // 附件
@@ -23,61 +24,73 @@ type Attach struct {
 // 上传附件
 func (c Attach) UploadAttach(noteId string) revel.Result {
 	re := c.uploadAttach(noteId)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 func (c Attach) uploadAttach(noteId string) (re info.Re) {
 	var fileId = ""
 	var resultMsg = "error" // 错误信息
 	var Ok = false
 	var fileInfo info.Attach
-	
+
 	re = info.NewRe()
-	
+
 	defer func() {
 		re.Id = fileId // 只是id, 没有其它信息
 		re.Msg = resultMsg
 		re.Ok = Ok
 		re.Item = fileInfo
 	}()
-	
+
 	// 判断是否有权限为笔记添加附件
 	if !shareService.HasUpdateNotePerm(noteId, c.GetUserId()) {
 		return re
 	}
-	
-	file, handel, err := c.Request.FormFile("file")
-	if err != nil {
-		return re
-	}
-	defer file.Close()
-	
-	data, err := ioutil.ReadAll(file)
-	if err != nil {
+
+	var data []byte
+	c.Params.Bind(&data, "file")
+
+	// file, handel, err := c.Request.FormFile("file")
+	// if err != nil {
+	// 	return re
+	// }
+	// defer file.Close()
+
+	// data, err := ioutil.ReadAll(file)
+	if data == nil || len(data) == 0 {
 		return re
 	}
 	// > 5M?
-	if(len(data) > 5 * 1024 * 1024) {
-		resultMsg = "File is bigger than 5M"
+	maxFileSize := configService.GetUploadSize("uploadAttachSize")
+	if maxFileSize <= 0 {
+		maxFileSize = 1000
+	}
+	if float64(len(data)) > maxFileSize*float64(1024*1024) {
+		resultMsg = fmt.Sprintf("The file's size is bigger than %vM", maxFileSize)
 		return re
 	}
-	
+
 	// 生成上传路径
-	filePath := "files/" + c.GetUserId() + "/attachs"
-	dir := revel.BasePath + "/" +  filePath
-	err = os.MkdirAll(dir, 0755)
+	//	filePath := "files/" + c.GetUserId() + "/attachs"
+	newGuid := NewGuid()
+	filePath := "files/" + GetRandomFilePath(c.GetUserId(), newGuid) + "/attachs"
+	dir := revel.BasePath + "/" + filePath
+	err := os.MkdirAll(dir, 0755)
 	if err != nil {
 		return re
 	}
+
+	handel := c.Params.Files["file"][0]
+
 	// 生成新的文件名
 	filename := handel.Filename
 	_, ext := SplitFilename(filename) // .doc
-	filename = NewGuid() + ext
-	toPath := dir + "/" + filename;
+	filename = newGuid + ext
+	toPath := dir + "/" + filename
 	err = ioutil.WriteFile(toPath, data, 0777)
 	if err != nil {
 		return re
 	}
-	
+
 	// add File to db
 	fileType := ""
 	if ext != "" {
@@ -85,21 +98,25 @@ func (c Attach) uploadAttach(noteId string) (re info.Re) {
 	}
 	filesize := GetFilesize(toPath)
 	fileInfo = info.Attach{Name: filename,
-		Title: handel.Filename,
-		NoteId: bson.ObjectIdHex(noteId),
+		Title:        handel.Filename,
+		NoteId:       bson.ObjectIdHex(noteId),
 		UploadUserId: c.GetObjectUserId(),
-		Path: filePath + "/" + filename,
-		Type: fileType,
-		Size: filesize}
-		
-	id := bson.NewObjectId();
+		Path:         filePath + "/" + filename,
+		Type:         fileType,
+		Size:         filesize}
+
+	id := bson.NewObjectId()
 	fileInfo.AttachId = id
 	fileId = id.Hex()
-	Ok = attachService.AddAttach(fileInfo)
-	
-	fileInfo.Path = ""; // 不要返回
-	resultMsg = "success"
-	
+	Ok, resultMsg = attachService.AddAttach(fileInfo, false)
+	if resultMsg != "" {
+		resultMsg = c.Message(resultMsg)
+	}
+
+	fileInfo.Path = "" // 不要返回
+	if Ok {
+		resultMsg = "success"
+	}
 	return re
 }
 
@@ -107,7 +124,7 @@ func (c Attach) uploadAttach(noteId string) (re info.Re) {
 func (c Attach) DeleteAttach(attachId string) revel.Result {
 	re := info.NewRe()
 	re.Ok, re.Msg = attachService.DeleteAttach(attachId, c.GetUserId())
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 // get all attachs by noteId
@@ -115,21 +132,21 @@ func (c Attach) GetAttachs(noteId string) revel.Result {
 	re := info.NewRe()
 	re.Ok = true
 	re.List = attachService.ListAttachs(noteId, c.GetUserId())
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 // 下载附件
 // 权限判断
 func (c Attach) Download(attachId string) revel.Result {
-	attach := attachService.GetAttach(attachId, c.GetUserId()); // 得到路径
+	attach := attachService.GetAttach(attachId, c.GetUserId()) // 得到路径
 	path := attach.Path
 	if path == "" {
 		return c.RenderText("")
 	}
-	fn := revel.BasePath + "/" +  strings.TrimLeft(path, "/")
-    file, _ := os.Open(fn)
-    return c.RenderBinary(file, attach.Title, revel.Attachment, time.Now()) // revel.Attachment
-    // return c.RenderFile(file, revel.Attachment) // revel.Attachment
+	fn := revel.BasePath + "/" + strings.TrimLeft(path, "/")
+	file, _ := os.Open(fn)
+	return c.RenderBinary(file, attach.Title, revel.Attachment, time.Now()) // revel.Attachment
+	// return c.RenderFile(file, revel.Attachment) // revel.Attachment
 }
 
 func (c Attach) DownloadAll(noteId string) revel.Result {
@@ -142,69 +159,75 @@ func (c Attach) DownloadAll(noteId string) revel.Result {
 	if attachs == nil || len(attachs) == 0 {
 		return c.RenderText("")
 	}
-	
+
 	/*
-	dir := revel.BasePath + "/files/tmp"
-	err := os.MkdirAll(dir, 0755)
-	if err != nil {
-		return c.RenderText("")
-	}
+		dir := revel.BasePath + "/files/tmp"
+		err := os.MkdirAll(dir, 0755)
+		if err != nil {
+			return c.RenderText("")
+		}
 	*/
-	
+
 	filename := note.Title + ".tar.gz"
 	if note.Title == "" {
 		filename = "all.tar.gz"
 	}
-	
+
+	dir := revel.BasePath + "/files/attach_all"
+
+	if !MkdirAll(dir) {
+		return c.RenderText("error")
+	}
+
 	// file write
-    fw, err := os.Create(revel.BasePath + "/files/" + filename)
-    if err != nil {
-		return c.RenderText("")
-    }
-    // defer fw.Close() // 不需要关闭, 还要读取给用户下载
-  
-    // gzip write
-    gw := gzip.NewWriter(fw)
-    defer gw.Close()
-  
-    // tar write
-    tw := tar.NewWriter(gw)
-    defer tw.Close()
-    
-    // 遍历文件列表
-    for _, attach := range attachs {
-		fn := revel.BasePath + "/" +  strings.TrimLeft(attach.Path, "/")
-	    fr, err := os.Open(fn)
-	    fileInfo, _ := fr.Stat()
-        if err != nil {
+	fw, err := os.Create(dir + "/" + filename)
+	if err != nil {
+		return c.RenderText("error")
+	}
+	// defer fw.Close() // 不需要关闭, 还要读取给用户下载
+
+	// gzip write
+	gw := gzip.NewWriter(fw)
+	defer gw.Close()
+
+	// tar write
+	tw := tar.NewWriter(gw)
+	defer tw.Close()
+
+	// 遍历文件列表
+	for _, attach := range attachs {
+		fn := revel.BasePath + "/" + strings.TrimLeft(attach.Path, "/")
+		fr, err := os.Open(fn)
+		fileInfo, _ := fr.Stat()
+		if err != nil {
 			return c.RenderText("")
-        }
-        defer fr.Close()
-        
-        // 信息头
-        h := new(tar.Header)
-        h.Name = attach.Title
-        h.Size = fileInfo.Size()
-        h.Mode = int64(fileInfo.Mode())
-        h.ModTime = fileInfo.ModTime()
-  
-        // 写信息头
-        err = tw.WriteHeader(h)
-        if err != nil {
-            panic(err)
-        }
-  
-        // 写文件
-        _, err = io.Copy(tw, fr)
-        if err != nil {
-            panic(err)
-        }
-    } // for
-    
-//    tw.Close()
-//    gw.Close()
-//    fw.Close()
-//    file, _ := os.Open(dir + "/" + filename)
+		}
+		defer fr.Close()
+
+		// 信息头
+		h := new(tar.Header)
+		h.Name = attach.Title
+		h.Size = fileInfo.Size()
+		h.Mode = int64(fileInfo.Mode())
+		h.ModTime = fileInfo.ModTime()
+
+		// 写信息头
+		err = tw.WriteHeader(h)
+		if err != nil {
+			panic(err)
+		}
+
+		// 写文件
+		_, err = io.Copy(tw, fr)
+		if err != nil {
+			panic(err)
+		}
+	} // for
+
+	//    tw.Close()
+	//    gw.Close()
+	//    fw.Close()
+	//    file, _ := os.Open(dir + "/" + filename)
 	// fw.Seek(0, 0)
-    return c.RenderBinary(fw, filename, revel.Attachment, time.Now()) // revel.Attachment
-}
+	return c.RenderBinary(fw, filename, revel.Attachment, time.Now()) // revel.Attachment
+}

app/controllers/AuthController.go

@@ -1,10 +1,11 @@
 package controllers
 
 import (
-	"github.com/revel/revel"
 	"github.com/leanote/leanote/app/info"
 	. "github.com/leanote/leanote/app/lea"
-//	"strconv"
+	"github.com/revel/revel"
+	"strings"
+	//	"strconv"
 )
 
 // 用户登录/注销/找回密码
@@ -16,68 +17,69 @@ type Auth struct {
 //--------
 // 登录
 func (c Auth) Login(email, from string) revel.Result {
-	c.RenderArgs["title"] = c.Message("login")
-	c.RenderArgs["subTitle"] = c.Message("login")
-	c.RenderArgs["email"] = email
-	c.RenderArgs["from"] = from
-	c.RenderArgs["openRegister"] = configService.IsOpenRegister()
-	
-	sessionId := c.Session.Id()
+	c.ViewArgs["title"] = c.Message("login")
+	c.ViewArgs["subTitle"] = c.Message("login")
+	c.ViewArgs["email"] = email
+	c.ViewArgs["from"] = from
+	c.ViewArgs["openRegister"] = configService.IsOpenRegister()
+
+	sessionId := c.Session.ID()
 	if sessionService.LoginTimesIsOver(sessionId) {
-		c.RenderArgs["needCaptcha"] = true
+		c.ViewArgs["needCaptcha"] = true
 	}
-	
+
 	c.SetLocale()
-	
+
 	if c.Has("demo") {
-		c.RenderArgs["demo"] = true
-		c.RenderArgs["email"] = "demo@leanote.com"
+		c.ViewArgs["demo"] = true
+		c.ViewArgs["email"] = "demo@leanote.com"
 	}
 	return c.RenderTemplate("home/login.html")
 }
 
 // 为了demo和register
 func (c Auth) doLogin(email, pwd string) revel.Result {
-	sessionId := c.Session.Id()
+	sessionId := c.Session.ID()
 	var msg = ""
-	
-	userInfo := authService.Login(email, pwd)
-	if userInfo.Email != "" {
-		c.SetSession(userInfo)
-		sessionService.ClearLoginTimes(sessionId)
-		return c.RenderJson(info.Re{Ok: true})
-	} else {
+
+	userInfo, err := authService.Login(email, pwd)
+	if err != nil {
 		// 登录错误, 则错误次数++
 		msg = "wrongUsernameOrPassword"
+	} else {
+		c.SetSession(userInfo)
+		sessionService.ClearLoginTimes(sessionId)
+		return c.RenderJSON(info.Re{Ok: true})
 	}
-	
-	return c.RenderJson(info.Re{Ok: false, Item: sessionService.LoginTimesIsOver(sessionId) , Msg: c.Message(msg)})
+
+	return c.RenderJSON(info.Re{Ok: false, Item: sessionService.LoginTimesIsOver(sessionId), Msg: c.Message(msg)})
 }
 func (c Auth) DoLogin(email, pwd string, captcha string) revel.Result {
-	sessionId := c.Session.Id()
+	sessionId := c.Session.ID()
 	var msg = ""
-	
+
 	// > 5次需要验证码, 直到登录成功
 	if sessionService.LoginTimesIsOver(sessionId) && sessionService.GetCaptcha(sessionId) != captcha {
 		msg = "captchaError"
 	} else {
-		userInfo := authService.Login(email, pwd)
-		if userInfo.Email != "" {
-			c.SetSession(userInfo)
-			sessionService.ClearLoginTimes(sessionId)
-			return c.RenderJson(info.Re{Ok: true})
-		} else {
+		userInfo, err := authService.Login(email, pwd)
+		if err != nil {
 			// 登录错误, 则错误次数++
 			msg = "wrongUsernameOrPassword"
 			sessionService.IncrLoginTimes(sessionId)
+		} else {
+			c.SetSession(userInfo)
+			sessionService.ClearLoginTimes(sessionId)
+			return c.RenderJSON(info.Re{Ok: true})
 		}
 	}
-	
-	return c.RenderJson(info.Re{Ok: false, Item: sessionService.LoginTimesIsOver(sessionId) , Msg: c.Message(msg)})
+
+	return c.RenderJSON(info.Re{Ok: false, Item: sessionService.LoginTimesIsOver(sessionId), Msg: c.Message(msg)})
 }
+
 // 注销
 func (c Auth) Logout() revel.Result {
-	sessionId := c.Session.Id()
+	sessionId := c.Session.ID()
 	sessionService.Clear(sessionId)
 	c.ClearSession()
 	return c.Redirect("/login")
@@ -85,85 +87,101 @@ func (c Auth) Logout() revel.Result {
 
 // 体验一下
 func (c Auth) Demo() revel.Result {
-	c.doLogin(configService.GetGlobalStringConfig("demoUsername"), configService.GetGlobalStringConfig("demoPassword"))
-	return c.Redirect("/note")
+	email := configService.GetGlobalStringConfig("demoUsername")
+	pwd := configService.GetGlobalStringConfig("demoPassword")
+
+	userInfo, err := authService.Login(email, pwd)
+	if err != nil {
+		return c.RenderJSON(info.Re{Ok: false})
+	} else {
+		c.SetSession(userInfo)
+		return c.Redirect("/note")
+	}
+	return nil
 }
 
 //--------
 // 注册
-func (c Auth) Register(from string) revel.Result {
+func (c Auth) Register(from, iu string) revel.Result {
 	if !configService.IsOpenRegister() {
 		return c.Redirect("/index")
 	}
 	c.SetLocale()
-	c.RenderArgs["from"] = from
-	
-	c.RenderArgs["title"] = c.Message("register")
-	c.RenderArgs["subTitle"] = c.Message("register")
+	c.ViewArgs["from"] = from
+	c.ViewArgs["iu"] = iu
+
+	c.ViewArgs["title"] = c.Message("register")
+	c.ViewArgs["subTitle"] = c.Message("register")
 	return c.RenderTemplate("home/register.html")
 }
-func (c Auth) DoRegister(email, pwd string) revel.Result {
+func (c Auth) DoRegister(email, pwd, iu string) revel.Result {
 	if !configService.IsOpenRegister() {
 		return c.Redirect("/index")
 	}
-	
-	re := info.NewRe();
-	
+
+	re := info.NewRe()
+
 	if re.Ok, re.Msg = Vd("email", email); !re.Ok {
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
 	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
-	
+
+	email = strings.ToLower(email)
+
 	// 注册
-	re.Ok, re.Msg = authService.Register(email, pwd)
-	
+	re.Ok, re.Msg = authService.Register(email, pwd, iu)
+
 	// 注册成功, 则立即登录之
 	if re.Ok {
 		c.doLogin(email, pwd)
 	}
-	
+
 	return c.RenderRe(re)
 }
 
 //--------
 // 找回密码
 func (c Auth) FindPassword() revel.Result {
-	c.RenderArgs["title"] = c.Message("findPassword")
-	c.RenderArgs["subTitle"] = c.Message("findPassword")
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("findPassword")
+	c.ViewArgs["subTitle"] = c.Message("findPassword")
 	return c.RenderTemplate("home/find_password.html")
 }
 func (c Auth) DoFindPassword(email string) revel.Result {
 	pwdService.FindPwd(email)
 	re := info.NewRe()
 	re.Ok = true
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
+
 // 点击链接后, 先验证之
 func (c Auth) FindPassword2(token string) revel.Result {
-	c.RenderArgs["title"] = c.Message("findPassword")
-	c.RenderArgs["subTitle"] = c.Message("findPassword")
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("findPassword")
+	c.ViewArgs["subTitle"] = c.Message("findPassword")
 	if token == "" {
 		return c.RenderTemplate("find_password2_timeout.html")
 	}
-	ok, _, findPwd := tokenService.VerifyToken(token, info.TokenPwd);
+	ok, _, findPwd := tokenService.VerifyToken(token, info.TokenPwd)
 	if !ok {
 		return c.RenderTemplate("home/find_password2_timeout.html")
 	}
-	c.RenderArgs["findPwd"] = findPwd
-	
-	c.RenderArgs["title"] = c.Message("updatePassword")
-	c.RenderArgs["subTitle"] = c.Message("updatePassword")
-	
+	c.ViewArgs["findPwd"] = findPwd
+
+	c.ViewArgs["title"] = c.Message("updatePassword")
+	c.ViewArgs["subTitle"] = c.Message("updatePassword")
+
 	return c.RenderTemplate("home/find_password2.html")
 }
+
 // 找回密码修改密码
 func (c Auth) FindPasswordUpdate(token, pwd string) revel.Result {
-	re := info.NewRe();
+	re := info.NewRe()
 
 	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
 
 	// 修改之

app/controllers/BaseController.go

@@ -1,17 +1,18 @@
 package controllers
 
 import (
-	"github.com/revel/revel"
-	"gopkg.in/mgo.v2/bson"
 	"encoding/json"
 	"github.com/leanote/leanote/app/info"
-//	. "github.com/leanote/leanote/app/lea"
-//	"io/ioutil"
-//	"fmt"
+	"github.com/leanote/leanote/app/lea/i18n"
+	"github.com/revel/revel"
+	"gopkg.in/mgo.v2/bson"
+	//	. "github.com/leanote/leanote/app/lea"
+	//	"io/ioutil"
+	//	"fmt"
+	"bytes"
 	"math"
 	"strconv"
 	"strings"
-	"bytes"
 )
 
 // 公用Controller, 其它Controller继承它
@@ -19,9 +20,14 @@ type BaseController struct {
 	*revel.Controller
 }
 
+// 覆盖revel.Message
+func (c *BaseController) Message(message string, args ...interface{}) (value string) {
+	return i18n.Message(c.Request.Locale, message, args...)
+}
+
 func (c BaseController) GetUserId() string {
 	if userId, ok := c.Session["UserId"]; ok {
-		return userId
+		return userId.(string)
 	}
 	return ""
 }
@@ -41,56 +47,42 @@ func (c BaseController) GetObjectUserId() bson.ObjectId {
 
 func (c BaseController) GetEmail() string {
 	if email, ok := c.Session["Email"]; ok {
-		return email
+		return email.(string)
 	}
 	return ""
 }
 
 func (c BaseController) GetUsername() string {
 	if email, ok := c.Session["Username"]; ok {
-		return email
+		return email.(string)
 	}
 	return ""
 }
 
 // 得到用户信息
 func (c BaseController) GetUserInfo() info.User {
-	if userId, ok := c.Session["UserId"]; ok && userId != "" {
-		return userService.GetUserInfo(userId);
-		/*
-		notebookWidth, _ := strconv.Atoi(c.Session["NotebookWidth"])
-		noteListWidth, _ := strconv.Atoi(c.Session["NoteListWidth"])
-		mdEditorWidth, _ := strconv.Atoi(c.Session["MdEditorWidth"])
-		LogJ(c.Session)
-		user := info.User{UserId: bson.ObjectIdHex(userId), 
-			Email: c.Session["Email"], 
-			Logo: c.Session["Logo"], 
-			Username: c.Session["Username"], 
-			UsernameRaw: c.Session["UsernameRaw"], 
-			Theme: c.Session["Theme"], 
-			NotebookWidth: notebookWidth, 
-			NoteListWidth: noteListWidth,
-			MdEditorWidth: mdEditorWidth, 
-			}
-		if c.Session["Verified"] == "1" {
-			user.Verified = true
-		}
-		if c.Session["LeftIsMin"] == "1" {
-			user.LeftIsMin = true
-		}
-		return user
-		*/
+    userId := c.GetUserId()
+	if userId != "" {
+		return userService.GetUserInfo(userId)
 	}
 	return info.User{}
 }
 
+func (c BaseController) GetUserAndBlogUrl() info.UserAndBlogUrl {
+    userId := c.GetUserId()
+	if userId != "" {
+		return userService.GetUserAndBlogUrl(userId)
+	}
+	return info.UserAndBlogUrl{}
+}
+
 // 这里的session都是cookie中的, 与数据库session无关
 func (c BaseController) GetSession(key string) string {
 	v, ok := c.Session[key]
 	if !ok {
 		v = ""
 	}
-	return v
+	return v.(string)
 }
 func (c BaseController) SetSession(userInfo info.User) {
 	if userInfo.UserId.Hex() != "" {
@@ -100,16 +92,16 @@ func (c BaseController) SetSession(userInfo info.User) {
 		c.Session["UsernameRaw"] = userInfo.UsernameRaw
 		c.Session["Theme"] = userInfo.Theme
 		c.Session["Logo"] = userInfo.Logo
-		
+
 		c.Session["NotebookWidth"] = strconv.Itoa(userInfo.NotebookWidth)
 		c.Session["NoteListWidth"] = strconv.Itoa(userInfo.NoteListWidth)
-		
+
 		if userInfo.Verified {
 			c.Session["Verified"] = "1"
 		} else {
 			c.Session["Verified"] = "0"
 		}
-		
+
 		if userInfo.LeftIsMin {
 			c.Session["LeftIsMin"] = "1"
 		} else {
@@ -132,8 +124,8 @@ func (c BaseController) UpdateSession(key, value string) {
 
 // 返回json
 func (c BaseController) Json(i interface{}) string {
-//	b, _ := json.MarshalIndent(i, "", "	") 
-	b, _ := json.Marshal(i) 
+	//	b, _ := json.MarshalIndent(i, "", "	")
+	b, _ := json.Marshal(i)
 	return string(b)
 }
 
@@ -150,9 +142,9 @@ func (c BaseController) GetPage() int {
 // 判断是否含有某参数
 func (c BaseController) Has(key string) bool {
 	if _, ok := c.Params.Values[key]; ok {
-		return true;
+		return true
 	}
-	return false;
+	return false
 }
 
 /*
@@ -162,40 +154,48 @@ func (c Blog) GetPage(page, count int, list interface{}) info.Page {
 */
 
 func (c BaseController) GetTotalPage(page, count int) int {
-	return int(math.Ceil(float64(count)/float64(page)))
+	return int(math.Ceil(float64(count) / float64(page)))
 }
 
 //-------------
 func (c BaseController) E404() revel.Result {
-	c.RenderArgs["title"] = "404";
+	c.ViewArgs["title"] = "404"
 	return c.NotFound("", nil)
 }
 
 // 设置本地
 func (c BaseController) SetLocale() string {
 	locale := string(c.Request.Locale) // zh-CN
+	// lang := locale
+	// if strings.Contains(locale, "-") {
+	// 	pos := strings.Index(locale, "-")
+	// 	lang = locale[0:pos]
+	// }
+	// if lang != "zh" && lang != "en" {
+	// 	lang = "en"
+	// }
 	lang := locale
-	if strings.Contains(locale, "-") {
-		pos := strings.Index(locale, "-")
-		lang = locale[0:pos]
+	if !i18n.HasLang(locale) {
+		lang = i18n.GetDefaultLang()
 	}
-	if lang != "zh" && lang != "en" {
-		lang = "en";
-	}
-	c.RenderArgs["locale"] = lang;
-	c.RenderArgs["siteUrl"] = siteUrl;
-	
-	c.RenderArgs["blogUrl"] = configService.GetBlogUrl()
-	c.RenderArgs["leaUrl"] = configService.GetLeaUrl()
-	c.RenderArgs["noteUrl"] = configService.GetNoteUrl()
-	
+	c.ViewArgs["locale"] = lang
+	c.ViewArgs["siteUrl"] = configService.GetSiteUrl()
+
+	c.ViewArgs["blogUrl"] = configService.GetBlogUrl()
+	c.ViewArgs["leaUrl"] = configService.GetLeaUrl()
+	c.ViewArgs["noteUrl"] = configService.GetNoteUrl()
+
 	return lang
 }
 
 // 设置userInfo
-func (c BaseController) SetUserInfo() {
+func (c BaseController) SetUserInfo() info.User {
 	userInfo := c.GetUserInfo()
-	c.RenderArgs["userInfo"] = userInfo
+	c.ViewArgs["userInfo"] = userInfo
+	if userInfo.Username == configService.GetAdminUsername() {
+		c.ViewArgs["isAdmin"] = true
+	}
+	return userInfo
 }
 
 // life
@@ -209,20 +209,21 @@ func (c BaseController) RenderTemplateStr(templatePath string) string {
 
 	tpl := &revel.RenderTemplateResult{
 		Template:   template,
-		RenderArgs: c.RenderArgs, // 把args给它
+		ViewArgs: c.ViewArgs, // 把args给它
 	}
-	
+
 	var buffer bytes.Buffer
-	tpl.Template.Render(&buffer, c.RenderArgs)
-	return buffer.String();
+	tpl.Template.Render(&buffer, c.ViewArgs)
+	return buffer.String()
 }
 
 // json, result
 // 为了msg
 // msg-v1-v2-v3
 func (c BaseController) RenderRe(re info.Re) revel.Result {
+	oldMsg := re.Msg
 	if re.Msg != "" {
-		if(strings.Contains(re.Msg, "-")) {
+		if strings.Contains(re.Msg, "-") {
 			msgAndValues := strings.Split(re.Msg, "-")
 			if len(msgAndValues) == 2 {
 				re.Msg = c.Message(msgAndValues[0], msgAndValues[1])
@@ -238,5 +239,8 @@ func (c BaseController) RenderRe(re info.Re) revel.Result {
 			re.Msg = c.Message(re.Msg)
 		}
 	}
-	return c.RenderJson(re)
-}
+	if strings.HasPrefix(re.Msg, "???") {
+		re.Msg = oldMsg
+	}
+	return c.RenderJSON(re)
+}

app/controllers/CaptchaController.go

@@ -2,18 +2,19 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-//	"gopkg.in/mgo.v2/bson"
+	//	"encoding/json"
+	//	"gopkg.in/mgo.v2/bson"
 	. "github.com/leanote/leanote/app/lea"
 	"github.com/leanote/leanote/app/lea/captcha"
-//	"github.com/leanote/leanote/app/types"
-//	"io/ioutil"
-//	"fmt"
-//	"math"
-//	"os"
-//	"path"
-//	"strconv"
+	//	"github.com/leanote/leanote/app/types"
+	//	"io/ioutil"
+	//	"fmt"
+	//	"math"
+	//	"os"
+	//	"path"
+	//	"strconv"
 	"net/http"
+	"io"
 )
 
 // 验证码服务
@@ -22,22 +23,24 @@ type Captcha struct {
 }
 
 type Ca string
+
 func (r Ca) Apply(req *revel.Request, resp *revel.Response) {
-	resp.WriteHeader(http.StatusOK,  "image/png")
+	resp.WriteHeader(http.StatusOK, "image/png")
 }
 
 func (c Captcha) Get() revel.Result {
 	c.Response.ContentType = "image/png"
 	image, str := captcha.Fetch()
-	image.WriteTo(c.Response.Out)
-	
-	sessionId := c.Session["_ID"]
-//	LogJ(c.Session)
-//	Log("------")
-//	Log(str)
-//	Log(sessionId)
-Log("..")
+	out := io.Writer(c.Response.GetWriter())
+	image.WriteTo(out)
+
+	sessionId := c.GetSession("_ID")
+	//	LogJ(c.Session)
+	//	Log("------")
+	//	Log(str)
+	//	Log(sessionId)
+	Log("..")
 	sessionService.SetCaptcha(sessionId, str)
-	
+
 	return c.Render()
-}
+}

app/controllers/FileController.go

@@ -2,14 +2,15 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-	"gopkg.in/mgo.v2/bson"
+	//	"encoding/json"
+	"fmt"
+	"github.com/leanote/leanote/app/info"
 	. "github.com/leanote/leanote/app/lea"
 	"github.com/leanote/leanote/app/lea/netutil"
-	"github.com/leanote/leanote/app/info"
+	"gopkg.in/mgo.v2/bson"
 	"io/ioutil"
 	"os"
-	"strconv"
+	//	"strconv"
 	"strings"
 )
 
@@ -21,11 +22,11 @@ type File struct {
 // 上传的是博客logo
 // TODO logo不要设置权限, 另外的目录
 func (c File) UploadBlogLogo() revel.Result {
-	re := c.uploadImage("logo", "");
-	
-	c.RenderArgs["fileUrlPath"] = re.Id
-	c.RenderArgs["resultCode"] = re.Code
-	c.RenderArgs["resultMsg"] = re.Msg
+	re := c.uploadImage("blogLogo", "")
+
+	c.ViewArgs["fileUrlPath"] = re.Id
+	c.ViewArgs["resultCode"] = re.Code
+	c.ViewArgs["resultMsg"] = re.Msg
 
 	return c.RenderTemplate("file/blog_logo.html")
 }
@@ -33,49 +34,51 @@ func (c File) UploadBlogLogo() revel.Result {
 // 拖拉上传, pasteImage
 // noteId 是为了判断是否是协作的note, 如果是则需要复制一份到note owner中
 func (c File) PasteImage(noteId string) revel.Result {
-	re := c.uploadImage("pasteImage", "");
-	
-	userId := c.GetUserId()
-	note := noteService.GetNoteById(noteId)
-	if note.UserId != "" {
-		noteUserId := note.UserId.Hex()
-		if noteUserId != userId {
-			// 是否是有权限协作的
-			if shareService.HasUpdatePerm(noteUserId, userId, noteId) {
-				// 复制图片之, 图片复制给noteUserId
-				_, re.Id = fileService.CopyImage(userId, re.Id, noteUserId)				
-			} else {
-				// 怎么可能在这个笔记下paste图片呢?
-				// 正常情况下不会
+	re := c.uploadImage("pasteImage", "")
+
+	if noteId != "" {
+		userId := c.GetUserId()
+		note := noteService.GetNoteById(noteId)
+		if note.UserId != "" {
+			noteUserId := note.UserId.Hex()
+			if noteUserId != userId {
+				// 是否是有权限协作的
+				if shareService.HasUpdatePerm(noteUserId, userId, noteId) {
+					// 复制图片之, 图片复制给noteUserId
+					_, re.Id = fileService.CopyImage(userId, re.Id, noteUserId)
+				} else {
+					// 怎么可能在这个笔记下paste图片呢?
+					// 正常情况下不会
+				}
 			}
 		}
 	}
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 // 头像设置
 func (c File) UploadAvatar() revel.Result {
-	re := c.uploadImage("logo", "");
-	
-	c.RenderArgs["fileUrlPath"] = re.Id
-	c.RenderArgs["resultCode"] = re.Code
-	c.RenderArgs["resultMsg"] = re.Msg
-	
+	re := c.uploadImage("logo", "")
+
+	c.ViewArgs["fileUrlPath"] = re.Id
+	c.ViewArgs["resultCode"] = re.Code
+	c.ViewArgs["resultMsg"] = re.Msg
+
 	if re.Ok {
 		re.Ok = userService.UpdateAvatar(c.GetUserId(), re.Id)
 		if re.Ok {
-			c.UpdateSession("Logo", re.Id);
+			c.UpdateSession("Logo", re.Id)
 		}
 	}
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 // leaui image plugin upload image
 func (c File) UploadImageLeaui(albumId string) revel.Result {
-	re := c.uploadImage("", albumId);
-	return c.RenderJson(re)
+	re := c.uploadImage("", albumId)
+	return c.RenderJSON(re)
 }
 
 // 上传图片, 公用方法
@@ -83,62 +86,98 @@ func (c File) UploadImageLeaui(albumId string) revel.Result {
 func (c File) uploadImage(from, albumId string) (re info.Re) {
 	var fileUrlPath = ""
 	var fileId = ""
-	var resultCode = 0 // 1表示正常
-	var resultMsg = "内部错误" // 错误信息
+	var resultCode = 0      // 1表示正常
+	var resultMsg = "error" // 错误信息
 	var Ok = false
-	
+
 	defer func() {
 		re.Id = fileId // 只是id, 没有其它信息
 		re.Code = resultCode
 		re.Msg = resultMsg
 		re.Ok = Ok
 	}()
-	
-	file, handel, err := c.Request.FormFile("file")
-	if err != nil {
+
+	// file, handel, err := c.Request.FormFile("file")
+	// if err != nil {
+	// 	return re
+	// }
+	// defer file.Close()
+
+	var data []byte
+	c.Params.Bind(&data, "file")
+	handel := c.Params.Files["file"][0]
+	if data == nil || len(data) == 0 {
 		return re
 	}
-	defer file.Close()
+
+	// file, handel, err := c.Request.FormFile("file")
+	// if err != nil {
+	// 	return re
+	// }
+	// defer file.Close()
+
+	// data, err := ioutil.ReadAll(file)
+	
+
 	// 生成上传路径
-	if(from == "logo") {
-		fileUrlPath = "public/upload/" + c.GetUserId() + "/images/logo"
+	newGuid := NewGuid()
+
+	userId := c.GetUserId()
+
+	if from == "logo" || from == "blogLogo" {
+		fileUrlPath = "public/upload/" + Digest3(userId) + "/" + userId + "/images/logo"
 	} else {
-		fileUrlPath = "files/" + c.GetUserId() + "/images"
+		// fileUrlPath = "files/" + Digest3(userId) + "/" + userId + "/" + Digest2(newGuid) + "/images"
+		fileUrlPath = "files/" + GetRandomFilePath(userId, newGuid) + "/images"
 	}
-	dir := revel.BasePath + "/" +  fileUrlPath
-	err = os.MkdirAll(dir, 0755)
+
+	dir := revel.BasePath + "/" + fileUrlPath
+	err := os.MkdirAll(dir, 0755)
 	if err != nil {
 		return re
 	}
 	// 生成新的文件名
 	filename := handel.Filename
-	
-	var ext string;
+
+	var ext string
 	if from == "pasteImage" {
-		ext = ".png"; // TODO 可能不是png类型
+		handel.Filename = c.Message("unTitled")
+		ext = ".png" // TODO 可能不是png类型
 	} else {
 		_, ext = SplitFilename(filename)
-		if(ext != ".gif" && ext != ".jpg" && ext != ".png" && ext != ".bmp" && ext != ".jpeg") {
-			resultMsg = "不是图片"
+		if ext != ".gif" && ext != ".jpg" && ext != ".png" && ext != ".bmp" && ext != ".jpeg" {
+			resultMsg = "Please upload image"
 			return re
 		}
 	}
 
-	filename = NewGuid() + ext
-	data, err := ioutil.ReadAll(file)
-	if err != nil {
-		LogJ(err)
-		return re
+	filename = newGuid + ext
+	// data, err := ioutil.ReadAll(file)
+	// if err != nil {
+	// 	LogJ(err)
+	// 	return re
+	// }
+
+	var maxFileSize float64
+	if from == "logo" {
+		maxFileSize = configService.GetUploadSize("uploadAvatarSize")
+	} else if from == "blogLogo" {
+		maxFileSize = configService.GetUploadSize("uploadBlogLogoSize")
+	} else {
+		maxFileSize = configService.GetUploadSize("uploadImageSize")
 	}
-	
+	if maxFileSize <= 0 {
+		maxFileSize = 1000
+	}
+
 	// > 2M?
-	if(len(data) > 5 * 1024 * 1024) {
+	if float64(len(data)) > maxFileSize*float64(1024*1024) {
 		resultCode = 0
-		resultMsg = "图片大于2M"
+		resultMsg = fmt.Sprintf("The file Size is bigger than %vM", maxFileSize)
 		return re
 	}
-	
-	toPath := dir + "/" + filename;
+
+	toPath := dir + "/" + filename
 	err = ioutil.WriteFile(toPath, data, 0777)
 	if err != nil {
 		LogJ(err)
@@ -150,93 +189,47 @@ func (c File) uploadImage(from, albumId string) (re info.Re) {
 	filesize := GetFilesize(toPathGif)
 	fileUrlPath += "/" + filename
 	resultCode = 1
-	resultMsg = "上传成功!"
-	
+	resultMsg = "Upload Success!"
+
 	// File
 	fileInfo := info.File{Name: filename,
 		Title: handel.Filename,
-		Path: fileUrlPath,
-		Size: filesize}
-		
-	id := bson.NewObjectId();
+		Path:  fileUrlPath,
+		Size:  filesize}
+
+	id := bson.NewObjectId()
 	fileInfo.FileId = id
 	fileId = id.Hex()
-	if(from == "logo") {
-		fileId = "public/upload/" + c.GetUserId() + "/images/logo/" + filename
+
+	if from == "logo" || from == "blogLogo" {
+		fileId = fileUrlPath
 	}
-	
-	Ok = fileService.AddImage(fileInfo, albumId, c.GetUserId())
-	
-	fileInfo.Path = ""; // 不要返回
+
+	Ok, resultMsg = fileService.AddImage(fileInfo, albumId, c.GetUserId(), from == "" || from == "pasteImage")
+	resultMsg = c.Message(resultMsg)
+
+	fileInfo.Path = "" // 不要返回
 	re.Item = fileInfo
-	
+
 	return re
 }
 
 // get all images by userId with page
 func (c File) GetImages(albumId, key string, page int) revel.Result {
 	re := fileService.ListImagesWithPage(c.GetUserId(), albumId, key, page, 12)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 func (c File) UpdateImageTitle(fileId, title string) revel.Result {
 	re := info.NewRe()
 	re.Ok = fileService.UpdateImageTitle(c.GetUserId(), fileId, title)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 func (c File) DeleteImage(fileId string) revel.Result {
 	re := info.NewRe()
 	re.Ok, re.Msg = fileService.DeleteImage(c.GetUserId(), fileId)
-	return c.RenderJson(re)
-}
-
-// update image uploader to leaui image, 
-// scan all user's images and insert into db
-func (c File) UpgradeLeauiImage() revel.Result {
-	re := info.NewRe()
-	
-	if ok, _ := revel.Config.Bool("upgradeLeauiImage"); !ok {
-		re.Msg = "Not allowed"
-		return c.RenderJson(re)
-	}
-	
-	uploadPath := revel.BasePath + "/public/upload";
-	userIds := ListDir(uploadPath)
-	if userIds == nil {
-		re.Msg = "no user"
-		return c.RenderJson(re)
-	}
-	
-	msg := "";
-	
-	for _, userId := range userIds {
-		dirPath := uploadPath + "/" + userId +  "/images"
-		images := ListDir(dirPath)
-		if images == nil {
-			msg += userId + " no images "
-			continue;
-		}
-		
-		hadImages := fileService.GetAllImageNamesMap(userId)
-		
-		i := 0
-		for _, filename := range images {
-			if _, ok := hadImages[filename]; !ok {
-				fileUrlPath := "/upload/" + userId + "/images/" + filename
-				fileInfo := info.File{Name: filename,
-					Title: filename,
-					Path: fileUrlPath,
-					Size: GetFilesize(dirPath + "/" + filename)}
-				fileService.AddImage(fileInfo, "", userId)
-				i++
-			}
-		}
-		msg += userId + ": " + strconv.Itoa(len(images)) + " -- " + strconv.Itoa(i) + " images "
-	}
-	
-	re.Msg = msg
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 //-----------
@@ -244,74 +237,57 @@ func (c File) UpgradeLeauiImage() revel.Result {
 // 输出image
 // 权限判断
 func (c File) OutputImage(noteId, fileId string) revel.Result {
-	path := fileService.GetFile(c.GetUserId(), fileId); // 得到路径
+	path := fileService.GetFile(c.GetUserId(), fileId) // 得到路径
 	if path == "" {
 		return c.RenderText("")
 	}
-	fn := revel.BasePath + "/" +  strings.TrimLeft(path, "/")
-    file, _ := os.Open(fn)
-    return c.RenderFile(file, revel.Inline) // revel.Attachment
+	fn := revel.BasePath + "/" + strings.TrimLeft(path, "/")
+	file, _ := os.Open(fn)
+	return c.RenderFile(file, revel.Inline) // revel.Attachment
 }
 
 // 协作时复制图片到owner
+// 需要计算对方大小
 func (c File) CopyImage(userId, fileId, toUserId string) revel.Result {
 	re := info.NewRe()
-	
 	re.Ok, re.Id = fileService.CopyImage(userId, fileId, toUserId)
-	
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
-// 复制外网的图片, 成公共图片 放在/upload下
+// 复制外网的图片
+// 都要好好的计算大小
 func (c File) CopyHttpImage(src string) revel.Result {
 	re := info.NewRe()
-	fileUrlPath := "upload/" + c.GetUserId() + "/images"
-	dir := revel.BasePath + "/public/" +  fileUrlPath
+
+	// 生成上传路径
+	newGuid := NewGuid()
+	userId := c.GetUserId()
+	// fileUrlPath := "files/" + Digest3(userId) + "/" + userId + "/" + Digest2(newGuid) + "/images"
+	fileUrlPath := "files/" + GetRandomFilePath(userId, newGuid) + "/images"
+	dir := revel.BasePath + "/" + fileUrlPath
 	err := os.MkdirAll(dir, 0755)
 	if err != nil {
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
 	filesize, filename, _, ok := netutil.WriteUrl(src, dir)
-	
+
 	if !ok {
 		re.Msg = "copy error"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
+
 	// File
 	fileInfo := info.File{Name: filename,
 		Title: filename,
-		Path: fileUrlPath + "/" + filename,
-		Size: filesize}
-		
-	id := bson.NewObjectId();
+		Path:  fileUrlPath + "/" + filename,
+		Size:  filesize}
+
+	id := bson.NewObjectId()
 	fileInfo.FileId = id
-	
+
 	re.Id = id.Hex()
-	re.Item = fileInfo.Path
-	re.Ok = fileService.AddImage(fileInfo, "", c.GetUserId())
-	
-	return c.RenderJson(re)
+	//	re.Item = fileInfo.Path
+	re.Ok, re.Msg = fileService.AddImage(fileInfo, "", c.GetUserId(), true)
+
+	return c.RenderJSON(re)
 }
-
-//------------
-// 过时 已弃用!
-func (c File) UploadImage(renderHtml string) revel.Result {
-	if renderHtml == "" {
-		renderHtml = "file/image.html"
-	}
-	
-	re := c.uploadImage("", "");
-	
-	c.RenderArgs["fileUrlPath"] = siteUrl + re.Id
-	c.RenderArgs["resultCode"] = re.Code
-	c.RenderArgs["resultMsg"] = re.Msg
-
-	return c.RenderTemplate(renderHtml)
-}
-
-// 已弃用
-func (c File) UploadImageJson(from, noteId string) revel.Result {
-	re := c.uploadImage(from, "");
-	return c.RenderJson(re)
-}

app/controllers/IndexController.go

@@ -1,9 +1,9 @@
 package controllers
 
 import (
-	"github.com/revel/revel"
 	"github.com/leanote/leanote/app/info"
-//	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	//	. "github.com/leanote/leanote/app/lea"
 )
 
 // 首页
@@ -12,25 +12,33 @@ type Index struct {
 	BaseController
 }
 
+func (c Index) Default() revel.Result {
+	if configService.HomePageIsAdminsBlog() {
+		blog := Blog{c.BaseController}
+		return blog.Index(configService.GetAdminUsername())
+	}
+	return c.Index()
+}
+
 // leanote展示页, 没有登录的, 或已登录明确要进该页的
 func (c Index) Index() revel.Result {
 	c.SetUserInfo()
-	c.RenderArgs["title"] = "leanote"
-	c.RenderArgs["openRegister"] = configService.GlobalStringConfigs["openRegister"]
-	lang := c.SetLocale()
-	
-	return c.RenderTemplate("home/index_" + lang + ".html");
+	c.ViewArgs["title"] = "leanote"
+	c.ViewArgs["openRegister"] = configService.GlobalStringConfigs["openRegister"]
+	c.SetLocale()
+
+	return c.RenderTemplate("home/index.html")
 }
 
 // 建议
 func (c Index) Suggestion(addr, suggestion string) revel.Result {
 	re := info.NewRe()
 	re.Ok = suggestionService.AddSuggestion(info.Suggestion{Addr: addr, UserId: c.GetObjectUserId(), Suggestion: suggestion})
-	
+
 	// 发给我
 	go func() {
-		emailService.SendEmail("leanote@leanote.com", "建议", "UserId: " + c.GetUserId() + " <br /> Suggestions: " + suggestion)
-	}();
-	
-	return c.RenderJson(re)
-}
+		emailService.SendEmail("leanote@leanote.com", "建议", "UserId: "+c.GetUserId()+" <br /> Suggestions: "+suggestion)
+	}()
+
+	return c.RenderJSON(re)
+}

app/controllers/MobileController.go

@@ -1,44 +0,0 @@
-package controllers
-
-import (
-	"github.com/revel/revel"
-//	"github.com/leanote/leanote/app/info"
-)
-
-// 首页
-type Mobile struct {
-	BaseController
-}
-
-// leanote展示页, 没有登录的, 或已登录明确要进该页的
-func (c Mobile) Index() revel.Result {
-	c.SetLocale()
-	
-	userInfo := c.GetUserInfo()
-	userId := userInfo.UserId.Hex()
-	
-	// 没有登录
-	if userId == "" {
-		return c.RenderTemplate("mobile/login.html")
-	}
-	
-	/*
-	// 已登录了, 那么得到所有信息
-	notebooks := notebookService.GetNotebooks(userId)
-	shareNotebooks, sharedUserInfos := shareService.GetShareNotebooks(userId)
-	
-	c.RenderArgs["userInfo"] = userInfo
-	c.RenderArgs["userInfoJson"] = c.Json(userInfo)
-	c.RenderArgs["notebooks"] = c.Json(notebooks)
-	c.RenderArgs["shareNotebooks"] = c.Json(shareNotebooks)
-	c.RenderArgs["sharedUserInfos"] = c.Json(sharedUserInfos)
-	c.RenderArgs["tagsJson"] = c.Json(tagService.GetTags(c.GetUserId()))
-	*/
-	
-	return c.RenderTemplate("mobile/angular.html");
-}
-
-func (c Mobile) Logout() revel.Result {
-	c.ClearSession()
-	return c.RenderTemplate("mobile/login.html");
-}

app/controllers/NoteContentHistoryController.go

@@ -11,6 +11,6 @@ type NoteContentHistory struct {
 // 得到list
 func (c NoteContentHistory) ListHistories(noteId string) revel.Result {
 	histories := noteContentHistoryService.ListHistories(noteId, c.GetUserId())
-	
-	return c.RenderJson(histories)
-}
+
+	return c.RenderJSON(histories)
+}

app/controllers/NoteController.go

@@ -2,16 +2,21 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-	"gopkg.in/mgo.v2/bson"
-	. "github.com/leanote/leanote/app/lea"
+	//	"encoding/json"
 	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"gopkg.in/mgo.v2/bson"
+	"os"
 	"os/exec"
-//	"github.com/leanote/leanote/app/types"
-//	"io/ioutil"
-//	"fmt"
-//	"bytes"
-//	"os"
+	"regexp"
+	"strings"
+	"time"
+	"runtime"
+	//	"github.com/leanote/leanote/app/types"
+	//	"io/ioutil"
+	"fmt"
+	//	"bytes"
+	//	"os"
 )
 
 type Note struct {
@@ -21,52 +26,112 @@ type Note struct {
 // 笔记首页, 判断是否已登录
 // 已登录, 得到用户基本信息(notebook, shareNotebook), 跳转到index.html中
 // 否则, 转向登录页面
-func (c Note) Index() revel.Result {
+func (c Note) Index(noteId, online string) revel.Result {
 	c.SetLocale()
-	
-	userInfo := c.GetUserInfo()
-	
+	userInfo := c.GetUserAndBlogUrl()
+
 	userId := userInfo.UserId.Hex()
-	
+
 	// 没有登录
 	if userId == "" {
 		return c.Redirect("/login")
 	}
-	
-	c.RenderArgs["openRegister"] = configService.IsOpenRegister()
-	
+
+	c.ViewArgs["openRegister"] = configService.IsOpenRegister()
+
 	// 已登录了, 那么得到所有信息
 	notebooks := notebookService.GetNotebooks(userId)
 	shareNotebooks, sharedUserInfos := shareService.GetShareNotebooks(userId)
-	
+
 	// 还需要按时间排序(DESC)得到notes
 	notes := []info.Note{}
 	noteContent := info.NoteContent{}
+
 	if len(notebooks) > 0 {
-//		_, notes = noteService.ListNotes(c.GetUserId(), "", false, c.GetPage(), pageSize, defaultSortField, false, false);
-		// 变成最新
-		_, notes = noteService.ListNotes(c.GetUserId(), "", false, c.GetPage(), 50, defaultSortField, false, false);
-		if len(notes) > 0 {
-			noteContent = noteService.GetNoteContent(notes[0].NoteId.Hex(), userId)
+		// noteId是否存在
+		// 是否传入了正确的noteId
+		hasRightNoteId := false
+		if IsObjectId(noteId) {
+			note := noteService.GetNoteById(noteId)
+
+			if note.NoteId != "" {
+				var noteOwner = note.UserId.Hex()
+				noteContent = noteService.GetNoteContent(noteId, noteOwner)
+
+				hasRightNoteId = true
+				c.ViewArgs["curNoteId"] = noteId
+				c.ViewArgs["curNotebookId"] = note.NotebookId.Hex()
+
+				// 打开的是共享的笔记, 那么判断是否是共享给我的默认笔记
+				if noteOwner != c.GetUserId() {
+					if shareService.HasReadPerm(noteOwner, c.GetUserId(), noteId) {
+						// 不要获取notebook下的笔记
+						// 在前端下发请求
+						c.ViewArgs["curSharedNoteNotebookId"] = note.NotebookId.Hex()
+						c.ViewArgs["curSharedUserId"] = noteOwner
+						// 没有读写权限
+					} else {
+						hasRightNoteId = false
+					}
+				} else {
+					_, notes = noteService.ListNotes(c.GetUserId(), note.NotebookId.Hex(), false, c.GetPage(), 50, defaultSortField, false, false)
+
+					// 如果指定了某笔记, 则该笔记放在首位
+					lenNotes := len(notes)
+					if lenNotes > 1 {
+						notes2 := make([]info.Note, len(notes))
+						notes2[0] = note
+						i := 1
+						for _, note := range notes {
+							if note.NoteId.Hex() != noteId {
+								if i == lenNotes { // 防止越界
+									break
+								}
+								notes2[i] = note
+								i++
+							}
+						}
+						notes = notes2
+					}
+				}
+			}
+
+			// 得到最近的笔记
+			_, latestNotes := noteService.ListNotes(c.GetUserId(), "", false, c.GetPage(), 50, defaultSortField, false, false)
+			c.ViewArgs["latestNotes"] = latestNotes
+		}
+
+		// 没有传入笔记
+		// 那么得到最新笔记
+		if !hasRightNoteId {
+			_, notes = noteService.ListNotes(c.GetUserId(), "", false, c.GetPage(), 50, defaultSortField, false, false)
+			if len(notes) > 0 {
+				noteContent = noteService.GetNoteContent(notes[0].NoteId.Hex(), userId)
+				c.ViewArgs["curNoteId"] = notes[0].NoteId.Hex()
+			}
 		}
 	}
+
 	// 当然, 还需要得到第一个notes的content
 	//...
-	
-	c.RenderArgs["isAdmin"] = leanoteUserId == userInfo.Username
-	c.RenderArgs["userInfo"] = userInfo
-	c.RenderArgs["userInfoJson"] = c.Json(userInfo)
-	c.RenderArgs["notebooks"] = c.Json(notebooks)
-	c.RenderArgs["shareNotebooks"] = c.Json(shareNotebooks)
-	c.RenderArgs["sharedUserInfos"] = c.Json(sharedUserInfos)
-	
-	c.RenderArgs["notes"] = c.Json(notes)
-	c.RenderArgs["noteContentJson"] = c.Json(noteContent)
-	c.RenderArgs["noteContent"] = noteContent.Content
-	
-	c.RenderArgs["tagsJson"] = c.Json(tagService.GetTags(c.GetUserId()))
-	
-	if isDev, _ := revel.Config.Bool("mode.dev"); isDev {
+	c.ViewArgs["isAdmin"] = configService.GetAdminUsername() == userInfo.Username
+
+	c.ViewArgs["userInfo"] = userInfo
+	c.ViewArgs["notebooks"] = notebooks
+	c.ViewArgs["shareNotebooks"] = shareNotebooks // note信息在notes列表中
+	c.ViewArgs["sharedUserInfos"] = sharedUserInfos
+
+	c.ViewArgs["notes"] = notes
+	c.ViewArgs["noteContentJson"] = noteContent
+	c.ViewArgs["noteContent"] = noteContent.Content
+
+	c.ViewArgs["tags"] = tagService.GetTags(c.GetUserId())
+
+	c.ViewArgs["globalConfigs"] = configService.GetGlobalConfigForUser()
+
+	// return c.RenderTemplate("note/note.html")
+
+	if isDev, _ := revel.Config.Bool("mode.dev"); isDev && online == "" {
 		return c.RenderTemplate("note/note-dev.html")
 	} else {
 		return c.RenderTemplate("note/note.html")
@@ -77,137 +142,172 @@ func (c Note) Index() revel.Result {
 // 已登录, 得到用户基本信息(notebook, shareNotebook), 跳转到index.html中
 // 否则, 转向登录页面
 func (c Note) ListNotes(notebookId string) revel.Result {
-	_, notes := noteService.ListNotes(c.GetUserId(), notebookId, false, c.GetPage(), pageSize, defaultSortField, false, false);
-	return c.RenderJson(notes)
+	_, notes := noteService.ListNotes(c.GetUserId(), notebookId, false, c.GetPage(), pageSize, defaultSortField, false, false)
+	return c.RenderJSON(notes)
 }
 
 // 得到trash
 func (c Note) ListTrashNotes() revel.Result {
-	_, notes := noteService.ListNotes(c.GetUserId(), "", true, c.GetPage(), pageSize, defaultSortField, false, false);
-	return c.RenderJson(notes)
+	_, notes := noteService.ListNotes(c.GetUserId(), "", true, c.GetPage(), pageSize, defaultSortField, false, false)
+	return c.RenderJSON(notes)
 }
 
 // 得到note和内容
 func (c Note) GetNoteAndContent(noteId string) revel.Result {
-	return c.RenderJson(noteService.GetNoteAndContent(noteId, c.GetUserId()))
+	return c.RenderJSON(noteService.GetNoteAndContent(noteId, c.GetUserId()))
+}
+
+func (c Note) GetNoteAndContentBySrc(src string) revel.Result {
+	noteId, noteAndContent := noteService.GetNoteAndContentBySrc(src, c.GetUserId())
+	ret := info.Re{}
+	if noteId != "" {
+		ret.Ok = true
+		ret.Item = noteAndContent
+	}
+	return c.RenderJSON(ret)
 }
 
 // 得到内容
 func (c Note) GetNoteContent(noteId string) revel.Result {
 	noteContent := noteService.GetNoteContent(noteId, c.GetUserId())
-	return c.RenderJson(noteContent)
+	return c.RenderJSON(noteContent)
 }
 
-// 更新note或content
-// 肯定会传userId(谁的), NoteId
-// 会传Title, Content, Tags, 一种或几种
-type NoteOrContent struct {
-	NotebookId string
-	NoteId string
-	UserId string
-	Title string
-	Desc string
-	ImgSrc string
-	Tags []string
-	Content string
-	Abstract string
-	IsNew bool
-	IsMarkdown bool
-	FromUserId string // 为共享而新建
-	IsBlog bool // 是否是blog, 更新note不需要修改, 添加note时才有可能用到, 此时需要判断notebook是否设为Blog
-}
 // 这里不能用json, 要用post
-func (c Note) UpdateNoteOrContent(noteOrContent NoteOrContent) revel.Result {
+func (c Note) UpdateNoteOrContent(noteOrContent info.NoteOrContent) revel.Result {
 	// 新添加note
 	if noteOrContent.IsNew {
-		userId := c.GetObjectUserId();
-		myUserId := userId
+		userId := c.GetObjectUserId()
+		//		myUserId := userId
 		// 为共享新建?
 		if noteOrContent.FromUserId != "" {
 			userId = bson.ObjectIdHex(noteOrContent.FromUserId)
 		}
-		
-		note := info.Note{UserId: userId, 
-			NoteId: bson.ObjectIdHex(noteOrContent.NoteId), 
-			NotebookId: bson.ObjectIdHex(noteOrContent.NotebookId), 
-			Title: noteOrContent.Title, 
-			Tags: noteOrContent.Tags,
-			Desc: noteOrContent.Desc,
-			ImgSrc: noteOrContent.ImgSrc,
-			IsBlog: noteOrContent.IsBlog,
+
+		note := info.Note{UserId: userId,
+			NoteId:     bson.ObjectIdHex(noteOrContent.NoteId),
+			NotebookId: bson.ObjectIdHex(noteOrContent.NotebookId),
+			Title:      noteOrContent.Title,
+			Src: noteOrContent.Src, // 来源
+			Tags:       strings.Split(noteOrContent.Tags, ","),
+			Desc:       noteOrContent.Desc,
+			ImgSrc:     noteOrContent.ImgSrc,
+			IsBlog:     noteOrContent.IsBlog,
 			IsMarkdown: noteOrContent.IsMarkdown,
-		};
-		noteContent := info.NoteContent{NoteId: note.NoteId, 
-			UserId: userId, 
-			IsBlog: note.IsBlog,
-			Content: noteOrContent.Content, 
-			Abstract: noteOrContent.Abstract};
-		
-		note = noteService.AddNoteAndContent(note, noteContent, myUserId)
-		return c.RenderJson(note)
+		}
+		noteContent := info.NoteContent{NoteId: note.NoteId,
+			UserId:   userId,
+			IsBlog:   note.IsBlog,
+			Content:  noteOrContent.Content,
+			Abstract: noteOrContent.Abstract}
+
+		note = noteService.AddNoteAndContentForController(note, noteContent, c.GetUserId())
+		return c.RenderJSON(note)
 	}
-	
+
 	noteUpdate := bson.M{}
 	needUpdateNote := false
-	
+
 	// Desc前台传来
 	if c.Has("Desc") {
 		needUpdateNote = true
-		noteUpdate["Desc"] = noteOrContent.Desc;
+		noteUpdate["Desc"] = noteOrContent.Desc
 	}
 	if c.Has("ImgSrc") {
 		needUpdateNote = true
-		noteUpdate["ImgSrc"] = noteOrContent.ImgSrc;
+		noteUpdate["ImgSrc"] = noteOrContent.ImgSrc
 	}
 	if c.Has("Title") {
 		needUpdateNote = true
-		noteUpdate["Title"] = noteOrContent.Title;
+		noteUpdate["Title"] = noteOrContent.Title
 	}
-	
-	if c.Has("Tags[]") {
+
+	if c.Has("Tags") {
 		needUpdateNote = true
-		noteUpdate["Tags"] = noteOrContent.Tags;
+		noteUpdate["Tags"] = strings.Split(noteOrContent.Tags, ",")
 	}
-	
-	if needUpdateNote { 
-		noteService.UpdateNote(noteOrContent.UserId, c.GetUserId(), 
-			noteOrContent.NoteId, noteUpdate)
+
+	// web端不控制
+	if needUpdateNote {
+		noteService.UpdateNote(c.GetUserId(),
+			noteOrContent.NoteId, noteUpdate, -1)
 	}
-	
+
 	//-------------
-	
+	// afterContentUsn := 0
+	// contentOk := false
+	// contentMsg := ""
 	if c.Has("Content") {
-		noteService.UpdateNoteContent(noteOrContent.UserId, c.GetUserId(), 
-			noteOrContent.NoteId, noteOrContent.Content, noteOrContent.Abstract)
+		//		noteService.UpdateNoteContent(noteOrContent.UserId, c.GetUserId(),
+		//			noteOrContent.NoteId, noteOrContent.Content, noteOrContent.Abstract)
+		// contentOk, contentMsg, afterContentUsn = 
+		noteService.UpdateNoteContent(c.GetUserId(),
+			noteOrContent.NoteId, noteOrContent.Content, noteOrContent.Abstract,
+			needUpdateNote, -1, time.Now())
 	}
-	
-	return c.RenderJson(true)
+
+	// Log("usn", "afterContentUsn", afterContentUsn + "")
+	// Log(contentOk)
+	// Log(contentMsg)
+
+	return c.RenderJSON(true)
 }
 
 // 删除note/ 删除别人共享给我的笔记
 // userId 是note.UserId
-func (c Note) DeleteNote(noteId, userId string, isShared bool) revel.Result {
-	if(!isShared) {
-		return c.RenderJson(trashService.DeleteNote(noteId, c.GetUserId()));
+func (c Note) DeleteNote(noteIds []string, isShared bool) revel.Result {
+	if !isShared {
+		for _, noteId := range noteIds {
+			trashService.DeleteNote(noteId, c.GetUserId())
+		}
+		return c.RenderJSON(true)
 	}
-	
-	return c.RenderJson(trashService.DeleteSharedNote(noteId, userId, c.GetUserId()));
+
+	for _, noteId := range noteIds {
+		trashService.DeleteSharedNote(noteId, c.GetUserId())
+	}
+
+	return c.RenderJSON(true)
 }
-// 删除trash
+
+// 删除trash, 已弃用, 用DeleteNote
 func (c Note) DeleteTrash(noteId string) revel.Result {
-	return c.RenderJson(trashService.DeleteTrash(noteId, c.GetUserId()));
+	return c.RenderJSON(trashService.DeleteTrash(noteId, c.GetUserId()))
 }
+
 // 移动note
-func (c Note) MoveNote(noteId, notebookId string) revel.Result {
-	return c.RenderJson(noteService.MoveNote(noteId, notebookId, c.GetUserId()));
+func (c Note) MoveNote(noteIds []string, notebookId string) revel.Result {
+	userId := c.GetUserId()
+	for _, noteId := range noteIds {
+		noteService.MoveNote(noteId, notebookId, userId)
+	}
+	return c.RenderJSON(true)
 }
+
 // 复制note
-func (c Note) CopyNote(noteId, notebookId string) revel.Result {
-	return c.RenderJson(noteService.CopyNote(noteId, notebookId, c.GetUserId()));
+func (c Note) CopyNote(noteIds []string, notebookId string) revel.Result {
+	copyNotes := make([]info.Note, len(noteIds))
+	userId := c.GetUserId()
+	for i, noteId := range noteIds {
+		copyNotes[i] = noteService.CopyNote(noteId, notebookId, userId)
+	}
+	re := info.NewRe()
+	re.Ok = true
+	re.Item = copyNotes
+	return c.RenderJSON(re)
 }
+
 // 复制别人共享的笔记给我
-func (c Note) CopySharedNote(noteId, notebookId, fromUserId string) revel.Result {
-	return c.RenderJson(noteService.CopySharedNote(noteId, notebookId, fromUserId, c.GetUserId()));
+func (c Note) CopySharedNote(noteIds []string, notebookId, fromUserId string) revel.Result {
+	copyNotes := make([]info.Note, len(noteIds))
+	userId := c.GetUserId()
+	for i, noteId := range noteIds {
+		copyNotes[i] = noteService.CopySharedNote(noteId, notebookId, fromUserId, userId)
+	}
+	re := info.NewRe()
+	re.Ok = true
+	re.Item = copyNotes
+	return c.RenderJSON(re)
 }
 
 //------------
@@ -215,139 +315,200 @@ func (c Note) CopySharedNote(noteId, notebookId, fromUserId string) revel.Result
 // 通过title搜索
 func (c Note) SearchNote(key string) revel.Result {
 	_, blogs := noteService.SearchNote(key, c.GetUserId(), c.GetPage(), pageSize, "UpdatedTime", false, false)
-	return c.RenderJson(blogs)
+	return c.RenderJSON(blogs)
 }
+
 // 通过tags搜索
 func (c Note) SearchNoteByTags(tags []string) revel.Result {
 	_, blogs := noteService.SearchNoteByTags(tags, c.GetUserId(), c.GetPage(), pageSize, "UpdatedTime", false)
-	return c.RenderJson(blogs)
+	return c.RenderJSON(blogs)
 }
 
-//------------------
-// html2image
-// 判断是否有权限生成
-// 博客也可以调用
-// 这是脚本调用, 没有cookie, 不执行权限控制, 通过传来的appKey判断
-func (c Note) ToImage(noteId, appKey string) revel.Result {
+// 生成PDF
+func (c Note) ToPdf(noteId, appKey string) revel.Result {
 	// 虽然传了cookie但是这里还是不能得到userId, 所以还是通过appKey来验证之
 	appKeyTrue, _ := revel.Config.String("app.secret")
 	if appKeyTrue != appKey {
-		 return c.RenderText("")
+		return c.RenderText("auth error")
 	}
 	note := noteService.GetNoteById(noteId)
 	if note.NoteId == "" {
-		return c.RenderText("")
+		return c.RenderText("no note")
 	}
-	
-	c.SetLocale()
-	
+
 	noteUserId := note.UserId.Hex()
 	content := noteService.GetNoteContent(noteId, noteUserId)
-	userInfo := userService.GetUserInfo(noteUserId);
-	
-	c.RenderArgs["blog"] = note
-	c.RenderArgs["content"] = content.Content
-	c.RenderArgs["userInfo"] = userInfo
+	userInfo := userService.GetUserInfo(noteUserId)
+
+	//------------------
+	// 将content的图片转换为base64
+	contentStr := content.Content
+
+	siteUrlPattern := configService.GetSiteUrl()
+	if strings.Contains(siteUrlPattern, "https") {
+		siteUrlPattern = strings.Replace(siteUrlPattern, "https", "https*", 1)
+	} else {
+		siteUrlPattern = strings.Replace(siteUrlPattern, "http", "https*", 1)
+	}
+
+	siteUrlPattern = "(?:" + siteUrlPattern + ")*"
+
+	regImage, _ := regexp.Compile(`<img .*?(src=('|")` + siteUrlPattern + `/(file/outputImage|api/file/getImage)\?fileId=([a-z0-9A-Z]{24})("|'))`)
+
+	findsImage := regImage.FindAllStringSubmatch(contentStr, -1) // 查找所有的
+	//	[<img src="http://leanote.com/api/getImage?fileId=3354672e8d38f411286b000069" alt="" width="692" height="302" data-mce-src="http://leanote.com/file/outputImage?fileId=54672e8d38f411286b000069" src="http://leanote.com/file/outputImage?fileId=54672e8d38f411286b000069" " file/outputImage 54672e8d38f411286b000069 "]
+	for _, eachFind := range findsImage {
+		if len(eachFind) == 6 {
+			fileId := eachFind[4]
+			// 得到base64编码文件
+			fileBase64 := fileService.GetImageBase64(noteUserId, fileId)
+			if fileBase64 == "" {
+				continue
+			}
+
+			// 1
+			// src="http://leanote.com/file/outputImage?fileId=54672e8d38f411286b000069"
+			allFixed := strings.Replace(eachFind[0], eachFind[1], "src=\""+fileBase64+"\"", -1)
+			contentStr = strings.Replace(contentStr, eachFind[0], allFixed, -1)
+		}
+	}
+
+	// markdown
+	if note.IsMarkdown {
+		// ![enter image description here](url)
+		regImageMarkdown, _ := regexp.Compile(`!\[.*?\]\(` + siteUrlPattern + `/(file/outputImage|api/file/getImage)\?fileId=([a-z0-9A-Z]{24})\)`)
+		findsImageMarkdown := regImageMarkdown.FindAllStringSubmatch(contentStr, -1) // 查找所有的
+		for _, eachFind := range findsImageMarkdown {
+			if len(eachFind) == 3 {
+				fileId := eachFind[2]
+				// 得到base64编码文件
+				fileBase64 := fileService.GetImageBase64(noteUserId, fileId)
+				if fileBase64 == "" {
+					continue
+				}
+
+				// 1
+				// src="http://leanote.com/file/outputImage?fileId=54672e8d38f411286b000069"
+				allFixed := "![](" + fileBase64 + ")"
+				contentStr = strings.Replace(contentStr, eachFind[0], allFixed, -1)
+			}
+		}
+	}
+
+	if note.Tags != nil && len(note.Tags) > 0 && note.Tags[0] != "" {
+	} else {
+		note.Tags = nil
+	}
+	c.ViewArgs["blog"] = note
+	c.ViewArgs["content"] = contentStr
+	c.ViewArgs["userInfo"] = userInfo
 	userBlog := blogService.GetUserBlog(noteUserId)
-	c.RenderArgs["userBlog"] = userBlog
-	
-	return c.RenderTemplate("html2Image/index.html")
+	c.ViewArgs["userBlog"] = userBlog
+
+	return c.RenderTemplate("file/pdf.html")
 }
 
-func (c Note) Html2Image(noteId string) revel.Result {
+// 导出成PDF
+func (c Note) ExportPdf(noteId string) revel.Result {
 	re := info.NewRe()
 	userId := c.GetUserId()
 	note := noteService.GetNoteById(noteId)
 	if note.NoteId == "" {
 		re.Msg = "No Note"
-		return c.RenderJson(re)
+		return c.RenderText("error")
 	}
-	
+
 	noteUserId := note.UserId.Hex()
 	// 是否有权限
 	if noteUserId != userId {
 		// 是否是有权限协作的
 		if !note.IsBlog && !shareService.HasReadPerm(noteUserId, userId, noteId) {
 			re.Msg = "No Perm"
-			return c.RenderJson(re)
+			return c.RenderText("No Perm")
 		}
 	}
 
 	// path 判断是否需要重新生成之
-	fileUrlPath := "/upload/" + noteUserId + "/images/weibo"
-	dir := revel.BasePath + "/public/" + fileUrlPath
-	if !ClearDir(dir) {
-		re.Msg = "No Dir"
-		return c.RenderJson(re)
+	guid := NewGuid()
+	fileUrlPath := "files/export_pdf"
+	dir := revel.BasePath + "/" + fileUrlPath
+	if !MkdirAll(dir) {
+		return c.RenderText("error, no dir")
 	}
-	
-	filename := note.NoteId.Hex() + ".png";
+	filename := guid + ".pdf"
 	path := dir + "/" + filename
-	
-	// cookie
-	cookieName := revel.CookiePrefix + "_SESSION"
-	cookie, err := c.Request.Cookie(cookieName)
-	cookieStr := cookie.String()
-	cookieValue := ""
-	if err == nil && len(cookieStr) > len(cookieName) {
-		cookieValue = cookieStr[len(cookieName)+1:]
+
+	// leanote.com的secret
+	appKey, _ := revel.Config.String("app.secretLeanote")
+	if appKey == "" {
+		appKey, _ = revel.Config.String("app.secret")
 	}
-	
-	appKey, _ := revel.Config.String("app.secret")
-	cookieDomain, _ := revel.Config.String("cookie.domain")
+
 	// 生成之
-	url := siteUrl + "/note/toImage?noteId=" + noteId + "&appKey=" + appKey;
-	// /Users/life/Documents/bin/phantomjs/bin/phantomjs /Users/life/Desktop/test/b.js
-	binPath := configService.GetGlobalStringConfig("toImageBinPath")
+	binPath := configService.GetGlobalStringConfig("exportPdfBinPath")
+	// 默认路径
 	if binPath == "" {
-		return c.RenderJson(re);
+		if runtime.GOOS == "windows" {
+			binPath = `C:\Program Files\wkhtmltopdf\bin\wkhtmltopdf.exe`
+		} else {
+			binPath = "/usr/local/bin/wkhtmltopdf"
+		}
 	}
-	cc := binPath + " \"" + url + "\"  \"" + path + "\" \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
-	cmd := exec.Command("/bin/sh", "-c", cc)
-	Log(cc);
-	b, err := cmd.Output()
-    if err == nil {
-    	re.Ok = true
-		re.Id = fileUrlPath + "/" + filename
-    } else {
-    	re.Msg = string(b)
-    	Log("error:......")
-    	Log(string(b))
-    }
-    
-	return c.RenderJson(re)
-	
-    /*
-    // 这里速度慢, 生成不完全(图片和内容都不全)
-	content := noteService.GetNoteContent(noteId, noteUserId)
-	userInfo := userService.GetUserInfo(noteUserId);
-	
-	c.SetLocale()	
-    
-	c.RenderArgs["blog"] = note
-	c.RenderArgs["content"] = content.Content
-	c.RenderArgs["userInfo"] = userInfo
-	userBlog := blogService.GetUserBlog(noteUserId)
-	c.RenderArgs["userBlog"] = userBlog
-	
-	html := c.RenderTemplateStr("html2Image/index.html") // Result类型的
-	contentFile := dir + "/html";
-	fout, err := os.Create(contentFile)
-    if err != nil {
-		return c.RenderJson(re)
-    }
-    fout.WriteString(html);
-    fout.Close()
-    
-    cc := "/Users/life/Documents/bin/phantomjs/bin/phantomjs /Users/life/Desktop/test/c.js \"" + contentFile + "\"  \"" + path + "\""
-	cmd := exec.Command("/bin/sh", "-c", cc)
-	b, err := cmd.Output()
-    if err == nil {
-    	re.Ok = true
-		re.Id = fileUrlPath + "/" + filename
-    } else {
-    	Log(string(b))
-    }
-	*/
-	
-}
+
+	url := configService.GetSiteUrl() + "/note/toPdf?noteId=" + noteId + "&appKey=" + appKey
+	//	cc := binPath + " --no-stop-slow-scripts --javascript-delay 10000 \"" + url + "\"  \"" + path + "\"" //  \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
+	//	cc := binPath + " \"" + url + "\"  \"" + path + "\"" //  \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
+	// 等待--window-status为done的状态
+	// http://madalgo.au.dk/~jakobt/wkhtmltoxdoc/wkhtmltopdf_0.10.0_rc2-doc.html
+	// wkhtmltopdf参数大全
+	var cc string
+	// var cc []string
+	var ccWindows []string
+	if note.IsMarkdown {
+		cc = binPath + " --lowquality --window-status done \"" + url + "\"  \"" + path + "\"" //  \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
+		// cc = []string{binPath, "--lowquality", "--window-status", "done", "\"" + url + "\"", "\"" + path + "\""}
+		ccWindows = []string{"/C", binPath, "--lowquality", "--window-status", "done", url, path}
+	} else {
+		cc = binPath + " --lowquality \"" + url + "\"  \"" + path + "\"" //  \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
+		// cc = []string{binPath, "--lowquality", "\"" + url + "\"", "\"" + path + "\""}
+		ccWindows = []string{"/C", binPath, "--lowquality", url, path}
+	}
+
+	var cmd *exec.Cmd
+
+	// fmt.Println("-------1", runtime.GOOS, ccWindows)
+	if runtime.GOOS == "windows" {
+		fmt.Println(ccWindows)
+		// cmd = exec.Command("cmd", ccWindows...)
+		cmd = exec.Command(ccWindows[1], ccWindows[2:]...)
+	} else {
+		fmt.Println(cc)
+		cmd = exec.Command("/bin/sh", "-c", cc)
+	}
+	_, err := cmd.Output()
+	if err != nil {
+		return c.RenderText("export pdf error. " + fmt.Sprintf("%v", err))
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return c.RenderText("export pdf error. " + fmt.Sprintf("%v", err))
+	}
+	// http://stackoverflow.com/questions/8588818/chrome-pdf-display-duplicate-headers-received-from-the-server
+	//	filenameReturn = strings.Replace(filenameReturn, ",", "-", -1)
+	filenameReturn := note.Title
+	filenameReturn = FixFilename(filenameReturn)
+	if filenameReturn == "" {
+		filenameReturn = "Untitled.pdf"
+	} else {
+		filenameReturn += ".pdf"
+	}
+	return c.RenderBinary(file, filenameReturn, revel.Attachment, time.Now()) // revel.Attachment
+}
+
+// 设置/取消Blog; 置顶
+func (c Note) SetNote2Blog(noteIds []string, isBlog, isTop bool) revel.Result {
+	for _, noteId := range noteIds {
+		noteService.ToBlog(c.GetUserId(), noteId, isBlog, isTop)
+	}
+	return c.RenderJSON(true)
+}

app/controllers/NotebookController.go

@@ -1,12 +1,12 @@
 package controllers
 
 import (
-	"github.com/revel/revel"
 	"encoding/json"
 	"github.com/leanote/leanote/app/info"
+	"github.com/revel/revel"
 	"gopkg.in/mgo.v2/bson"
-//	. "github.com/leanote/leanote/app/lea"
-//	"io/ioutil"
+	//	. "github.com/leanote/leanote/app/lea"
+	//	"io/ioutil"
 )
 
 type Notebook struct {
@@ -14,58 +14,67 @@ type Notebook struct {
 }
 
 func (c Notebook) Index(notebook info.Notebook, i int, name string) revel.Result {
-	return c.RenderJson(notebook)
+	return c.RenderJSON(notebook)
 }
 
 // 得到用户的所有笔记本
 func (c Notebook) GetNotebooks() revel.Result {
 	re := notebookService.GetNotebooks(c.GetUserId())
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 func (c Notebook) DeleteNotebook(notebookId string) revel.Result {
 	re, msg := notebookService.DeleteNotebook(c.GetUserId(), notebookId)
-	return c.RenderJson(info.Re{Ok: re, Msg: msg})
+	return c.RenderJSON(info.Re{Ok: re, Msg: msg})
 }
 
 // 添加notebook
 func (c Notebook) AddNotebook(notebookId, title, parentNotebookId string) revel.Result {
-	notebook := info.Notebook{NotebookId: bson.ObjectIdHex(notebookId), 
-		Title: title,
-		Seq: -1,
+	notebook := info.Notebook{NotebookId: bson.ObjectIdHex(notebookId),
+		Title:  title,
+		Seq:    -1,
 		UserId: c.GetObjectUserId()}
-	if(parentNotebookId != "") {
+	if parentNotebookId != "" {
 		notebook.ParentNotebookId = bson.ObjectIdHex(parentNotebookId)
 	}
-	re := notebookService.AddNotebook(notebook)
-	
-	if(re) {
-		return c.RenderJson(notebook)
+
+	re, notebook := notebookService.AddNotebook(notebook)
+
+	if re {
+		return c.RenderJSON(notebook)
 	} else {
-		return c.RenderJson(false)
+		return c.RenderJSON(false)
 	}
 }
+
 // 修改标题
 func (c Notebook) UpdateNotebookTitle(notebookId, title string) revel.Result {
-	return c.RenderJson(notebookService.UpdateNotebookTitle(notebookId, c.GetUserId(), title))
+	return c.RenderJSON(notebookService.UpdateNotebookTitle(notebookId, c.GetUserId(), title))
 }
 
 // 排序
 // 无用
-func (c Notebook) SortNotebooks(notebookId2Seqs map[string]int) revel.Result {
-	return c.RenderJson(notebookService.SortNotebooks(c.GetUserId(), notebookId2Seqs))
-}
+// func (c Notebook) SortNotebooks(notebookId2Seqs map[string]int) revel.Result {
+// 	return c.RenderJSON(notebookService.SortNotebooks(c.GetUserId(), notebookId2Seqs))
+// }
 
 // 调整notebooks, 可能是排序, 可能是移动到其它笔记本下
 type DragNotebooksInfo struct {
-	CurNotebookId string
+	CurNotebookId    string
 	ParentNotebookId string
-	Siblings []string
+	Siblings         []string
 }
+
 // 传过来的data是JSON.stringfy数据
 func (c Notebook) DragNotebooks(data string) revel.Result {
 	info := DragNotebooksInfo{}
 	json.Unmarshal([]byte(data), &info)
-	
-	return c.RenderJson(notebookService.DragNotebooks(c.GetUserId(), info.CurNotebookId, info.ParentNotebookId, info.Siblings))
-}
+
+	return c.RenderJSON(notebookService.DragNotebooks(c.GetUserId(), info.CurNotebookId, info.ParentNotebookId, info.Siblings))
+}
+
+// 设置notebook <-> blog
+func (c Notebook) SetNotebook2Blog(notebookId string, isBlog bool) revel.Result {
+	re := notebookService.ToBlog(c.GetUserId(), notebookId, isBlog)
+	return c.RenderJSON(re)
+}

app/controllers/OauthController.go

@@ -1,70 +0,0 @@
-package controllers
-
-import (
-	"code.google.com/p/goauth2/oauth"
-	"github.com/revel/revel"
-	"github.com/leanote/leanote/app/lea/netutil"
-	. "github.com/leanote/leanote/app/lea"
-	"encoding/json"
-	"fmt"
-)
-
-type Oauth struct {
-	BaseController
-}
-
-var oauthCfg = &oauth.Config{
-	ClientId:     "3790fbf1fc14bc6c5d85",
-	ClientSecret: "e9dadfe601c7caa6df9b33db3e7539945c60dfa2",
-	AuthURL:      "https://github.com/login/oauth/authorize",
-	TokenURL:     "https://github.com/login/oauth/access_token",
-	RedirectURL:  "http://leanote.com/oauth/githubCallback",
-	Scope: "user",
-}
-
-// 用户允许后, github返回到leanote
-// 通过code得到token
-// https://github.com/login/oauth/authorize?access_type=&approval_prompt=&client_id=3790fbf1fc14bc6c5d85&redirect_uri=http%3A%2F%2F127.0.0.1%3A8080%2Foauth2callback&response_type=code&scope=user&state=
-func (c Oauth) GithubCallback(code string) revel.Result {
-	t := &oauth.Transport{Config: oauthCfg}
-
-	// Exchange the received code for a token
-	tok, err := t.Exchange(code)
-	token := tok.AccessToken
-	if err != nil || token == "" {
-		c.RenderArgs["title"] = "error"
-		return c.RenderTemplate("oauth/oauth_callback_error.html")
-	}
-
-	// 得到用户信息
-	profileInfoURL := "https://api.github.com/user"
-	url := fmt.Sprintf("%s?access_token=%s", profileInfoURL, token)
-	content, err2 := netutil.GetContent(url)
-	if err2 != nil {
-		c.RenderArgs["title"] = "error"
-		return c.RenderTemplate("oauth/oauth_callback_error.html")
-	}
-	// 转成map
-	profileInfo := map[string]interface{}{}
-	Log(string(content))
-	err2 = json.Unmarshal(content, &profileInfo)
-	if err2 != nil {
-		c.RenderArgs["title"] = "error"
-		return c.RenderTemplate("oauth/oauth_callback_error.html")
-	}
-
-	usernameI := profileInfo["login"]
-
-	username, _ := usernameI.(string)
-	userId := username
-
-	// 注册
-	isExists, userInfo := authService.ThirdRegister("github", userId, username)
-	c.RenderArgs["isExists"] = isExists
-	c.RenderArgs["userInfo"] = userInfo
-
-	// 登录之
-	c.SetSession(userInfo)
-
-	return c.Redirect("/note")
-}

app/controllers/PreviewController.go

@@ -0,0 +1,103 @@
+package controllers
+
+import (
+	"github.com/revel/revel"
+	//	"strings"
+	//	"time"
+	//	"encoding/json"
+	//	"github.com/leanote/leanote/app/info"
+	//	. "github.com/leanote/leanote/app/lea"
+	//	"github.com/leanote/leanote/app/lea/blog"
+	//	"gopkg.in/mgo.v2/bson"
+	//	"github.com/leanote/leanote/app/types"
+	//	"io/ioutil"
+	//	"math"
+	//	"os"
+	//	"path"
+)
+
+type Preview struct {
+	Blog
+}
+
+// 得到要预览的主题绝对路径
+func (c Preview) getPreviewThemeAbsolutePath(themeId string) bool {
+	if themeId != "" {
+		c.Session["themeId"] = themeId // 存到session中, 下次的url就不能带了, 待优化, 有时会取不到
+	} else {
+		themeId = c.GetSession("themeId") // 直接从session中获取
+	}
+	if themeId == "" {
+		return false
+	}
+	theme := themeService.GetTheme(c.GetUserId(), themeId)
+
+	c.ViewArgs["isPreview"] = true
+	c.ViewArgs["themeId"] = themeId
+	c.ViewArgs["themeInfoPreview"] = theme.Info
+	c.ViewArgs["themePath"] = theme.Path
+	if theme.Path == "" {
+		return false
+	}
+	return true
+}
+
+func (c Preview) Index(userIdOrEmail string, themeId string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath(themeId) {
+		return c.E404()
+	}
+	return c.Blog.Index(c.GetUserId())
+	//	return blog.RenderTemplate("index.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(themeId))
+}
+
+func (c Preview) Tag(userIdOrEmail, tag string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Tag(c.GetUserId(), tag)
+}
+func (c Preview) Tags(userIdOrEmail string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Tags(c.GetUserId())
+	//	if tag == "" {
+	//		return blog.RenderTemplate("tags.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+	//	}
+	//	return blog.RenderTemplate("tag_posts.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+}
+func (c Preview) Archives(userIdOrEmail string, notebookId string, year, month int) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Archives(c.GetUserId(), notebookId, year, month)
+	//	return blog.RenderTemplate("archive.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+}
+func (c Preview) Cate(userIdOrEmail, notebookId string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Cate(userIdOrEmail, notebookId)
+	//	return blog.RenderTemplate("cate.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+}
+func (c Preview) Post(userIdOrEmail, noteId string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Post(userIdOrEmail, noteId)
+	//	return blog.RenderTemplate("view.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+}
+func (c Preview) Single(userIdOrEmail, singleId string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Single(userIdOrEmail, singleId)
+	//	return blog.RenderTemplate("single.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+}
+func (c Preview) Search(userIdOrEmail, keywords string) revel.Result {
+	if !c.getPreviewThemeAbsolutePath("") {
+		return c.E404()
+	}
+	return c.Blog.Search(c.GetUserId(), keywords)
+	//	return blog.RenderTemplate("search.html", c.ViewArgs, c.getPreviewThemeAbsolutePath(""))
+}

app/controllers/ShareController.go

@@ -2,13 +2,13 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-//	"gopkg.in/mgo.v2/bson"
-//	. "github.com/leanote/leanote/app/lea"
+	//	"encoding/json"
+	//	"gopkg.in/mgo.v2/bson"
 	"github.com/leanote/leanote/app/info"
-//	"github.com/leanote/leanote/app/types"
-//	"io/ioutil"
-//	"fmt"
+	. "github.com/leanote/leanote/app/lea"
+	//	"github.com/leanote/leanote/app/types"
+	//	"io/ioutil"
+	//	"fmt"
 )
 
 type Share struct {
@@ -19,41 +19,41 @@ type Share struct {
 func (c Share) AddShareNote(noteId string, emails []string, perm int) revel.Result {
 	status := make(map[string]info.Re, len(emails))
 	// 自己不能给自己添加共享
-	myEmail := c.GetEmail();
+	myEmail := c.GetEmail()
 	for _, email := range emails {
 		if email == "" {
-			continue;
+			continue
 		}
-		if(myEmail != email) {
-			ok, msg, userId := shareService.AddShareNote(noteId, perm, c.GetUserId(), email);
+		if myEmail != email {
+			ok, msg, userId := shareService.AddShareNote(noteId, perm, c.GetUserId(), email)
 			status[email] = info.Re{Ok: ok, Msg: msg, Id: userId}
-			
+
 		} else {
 			status[email] = info.Re{Ok: false, Msg: "不能分享给自己"}
-		}	
+		}
 	}
-	
-	return c.RenderJson(status)
+
+	return c.RenderJSON(status)
 }
 
 // 添加共享notebook
 func (c Share) AddShareNotebook(notebookId string, emails []string, perm int) revel.Result {
 	status := make(map[string]info.Re, len(emails))
 	// 自己不能给自己添加共享
-	myEmail := c.GetEmail();
+	myEmail := c.GetEmail()
 	for _, email := range emails {
 		if email == "" {
-			continue;
+			continue
 		}
-		if(myEmail != email) {
-			ok, msg, userId := shareService.AddShareNotebook(notebookId, perm, c.GetUserId(), email);
+		if myEmail != email {
+			ok, msg, userId := shareService.AddShareNotebook(notebookId, perm, c.GetUserId(), email)
 			status[email] = info.Re{Ok: ok, Msg: msg, Id: userId}
 		} else {
 			status[email] = info.Re{Ok: false, Msg: "不能分享给自己"}
-		}	
+		}
 	}
-	
-	return c.RenderJson(status)
+
+	return c.RenderJSON(status)
 }
 
 // 得到notes
@@ -62,11 +62,11 @@ func (c Share) ListShareNotes(notebookId, userId string) revel.Result {
 	// 表示是默认笔记本, 不是某个特定notebook的共享
 	var notes []info.ShareNoteWithPerm
 	if notebookId == "" {
-		notes = shareService.ListShareNotes(c.GetUserId(), userId, c.GetPage(), pageSize, defaultSortField, false);
-		return c.RenderJson(notes)
+		notes = shareService.ListShareNotes(c.GetUserId(), userId, c.GetPage(), pageSize, defaultSortField, false)
+		return c.RenderJSON(notes)
 	} else {
 		// 有notebookId的
-		return c.RenderJson(shareService.ListShareNotesByNotebookId(notebookId, c.GetUserId(), userId, c.GetPage(), pageSize, defaultSortField, false));
+		return c.RenderJSON(shareService.ListShareNotesByNotebookId(notebookId, c.GetUserId(), userId, c.GetPage(), pageSize, defaultSortField, false))
 	}
 }
 
@@ -74,7 +74,7 @@ func (c Share) ListShareNotes(notebookId, userId string) revel.Result {
 // sharedUserId 是谁的笔记
 func (c Share) GetShareNoteContent(noteId, sharedUserId string) revel.Result {
 	noteContent := shareService.GetShareNoteContent(noteId, c.GetUserId(), sharedUserId)
-	return c.RenderJson(noteContent)
+	return c.RenderJSON(noteContent)
 }
 
 // 查看note的分享信息
@@ -83,60 +83,110 @@ func (c Share) GetShareNoteContent(noteId, sharedUserId string) revel.Result {
 // 还要查看该note的notebookId分享的信息
 func (c Share) ListNoteShareUserInfo(noteId string) revel.Result {
 	note := noteService.GetNote(noteId, c.GetUserId())
-	
+
 	noteShareUserInfos := shareService.ListNoteShareUserInfo(noteId, c.GetUserId())
-	c.RenderArgs["noteOrNotebookShareUserInfos"] = noteShareUserInfos 
-	
-	c.RenderArgs["isNote"] = true
-	c.RenderArgs["noteOrNotebookId"] = note.NoteId.Hex();
-	c.RenderArgs["title"] = note.Title
-	
+	c.ViewArgs["noteOrNotebookShareUserInfos"] = noteShareUserInfos
+
+	c.ViewArgs["noteOrNotebookShareGroupInfos"] = shareService.GetNoteShareGroups(noteId, c.GetUserId())
+
+	c.ViewArgs["isNote"] = true
+	c.ViewArgs["noteOrNotebookId"] = note.NoteId.Hex()
+	c.ViewArgs["title"] = note.Title
+
 	return c.RenderTemplate("share/note_notebook_share_user_infos.html")
 }
 func (c Share) ListNotebookShareUserInfo(notebookId string) revel.Result {
 	notebook := notebookService.GetNotebook(notebookId, c.GetUserId())
-	
+
 	notebookShareUserInfos := shareService.ListNotebookShareUserInfo(notebookId, c.GetUserId())
-	c.RenderArgs["noteOrNotebookShareUserInfos"] = notebookShareUserInfos 
-	
-	c.RenderArgs["isNote"] = false
-	c.RenderArgs["noteOrNotebookId"] = notebook.NotebookId.Hex();
-	c.RenderArgs["title"] = notebook.Title
-	
+	c.ViewArgs["noteOrNotebookShareUserInfos"] = notebookShareUserInfos
+
+	c.ViewArgs["noteOrNotebookShareGroupInfos"] = shareService.GetNotebookShareGroups(notebookId, c.GetUserId())
+	LogJ(c.ViewArgs["noteOrNotebookShareGroupInfos"])
+
+	c.ViewArgs["isNote"] = false
+	c.ViewArgs["noteOrNotebookId"] = notebook.NotebookId.Hex()
+	c.ViewArgs["title"] = notebook.Title
+
 	return c.RenderTemplate("share/note_notebook_share_user_infos.html")
 }
 
 //------------
 // 改变share note 权限
 func (c Share) UpdateShareNotePerm(noteId string, perm int, toUserId string) revel.Result {
-	return c.RenderJson(shareService.UpdateShareNotePerm(noteId, perm, c.GetUserId(), toUserId));
+	return c.RenderJSON(shareService.UpdateShareNotePerm(noteId, perm, c.GetUserId(), toUserId))
 }
 
 // 改变share notebook 权限
 func (c Share) UpdateShareNotebookPerm(notebookId string, perm int, toUserId string) revel.Result {
-	return c.RenderJson(shareService.UpdateShareNotebookPerm(notebookId, perm, c.GetUserId(), toUserId));
+	return c.RenderJSON(shareService.UpdateShareNotebookPerm(notebookId, perm, c.GetUserId(), toUserId))
 }
 
 //---------------
 // 删除share note
 func (c Share) DeleteShareNote(noteId string, toUserId string) revel.Result {
-	return c.RenderJson(shareService.DeleteShareNote(noteId, c.GetUserId(), toUserId));
+	return c.RenderJSON(shareService.DeleteShareNote(noteId, c.GetUserId(), toUserId))
 }
+
 // 删除share notebook
 func (c Share) DeleteShareNotebook(notebookId string, toUserId string) revel.Result {
-	return c.RenderJson(shareService.DeleteShareNotebook(notebookId, c.GetUserId(), toUserId));
+	return c.RenderJSON(shareService.DeleteShareNotebook(notebookId, c.GetUserId(), toUserId))
 }
 
 // 删除share note, 被共享方删除
 func (c Share) DeleteShareNoteBySharedUser(noteId string, fromUserId string) revel.Result {
-	return c.RenderJson(shareService.DeleteShareNote(noteId, fromUserId, c.GetUserId()));
+	return c.RenderJSON(shareService.DeleteShareNote(noteId, fromUserId, c.GetUserId()))
 }
+
 // 删除share notebook, 被共享方删除
 func (c Share) DeleteShareNotebookBySharedUser(notebookId string, fromUserId string) revel.Result {
-	return c.RenderJson(shareService.DeleteShareNotebook(notebookId, fromUserId, c.GetUserId()));
+	return c.RenderJSON(shareService.DeleteShareNotebook(notebookId, fromUserId, c.GetUserId()))
 }
 
 // 删除fromUserId分享给我的所有note, notebook
 func (c Share) DeleteUserShareNoteAndNotebook(fromUserId string) revel.Result {
-	return c.RenderJson(shareService.DeleteUserShareNoteAndNotebook(fromUserId, c.GetUserId()));
-}
+	return c.RenderJSON(shareService.DeleteUserShareNoteAndNotebook(fromUserId, c.GetUserId()))
+}
+
+//-------------
+// 用户组
+
+// 将笔记分享给分组
+func (c Share) AddShareNoteGroup(noteId, groupId string, perm int) revel.Result {
+	re := info.NewRe()
+	re.Ok = shareService.AddShareNoteGroup(c.GetUserId(), noteId, groupId, perm)
+	return c.RenderJSON(re)
+}
+
+// 删除
+func (c Share) DeleteShareNoteGroup(noteId, groupId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = shareService.DeleteShareNoteGroup(c.GetUserId(), noteId, groupId)
+	return c.RenderJSON(re)
+}
+
+// 更新, 也是一样, 先删后加
+func (c Share) UpdateShareNoteGroupPerm(noteId, groupId string, perm int) revel.Result {
+	return c.AddShareNoteGroup(noteId, groupId, perm)
+}
+
+//------
+
+// 将笔记分享给分组
+func (c Share) AddShareNotebookGroup(notebookId, groupId string, perm int) revel.Result {
+	re := info.NewRe()
+	re.Ok = shareService.AddShareNotebookGroup(c.GetUserId(), notebookId, groupId, perm)
+	return c.RenderJSON(re)
+}
+
+// 删除
+func (c Share) DeleteShareNotebookGroup(notebookId, groupId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = shareService.DeleteShareNotebookGroup(c.GetUserId(), notebookId, groupId)
+	return c.RenderJSON(re)
+}
+
+// 更新, 也是一样, 先删后加
+func (c Share) UpdateShareNotebookGroupPerm(notebookId, groupId string, perm int) revel.Result {
+	return c.AddShareNotebookGroup(notebookId, groupId, perm)
+}

app/controllers/TagController.go

@@ -0,0 +1,30 @@
+package controllers
+
+import (
+	"github.com/revel/revel"
+	//	"encoding/json"
+	//	"gopkg.in/mgo.v2/bson"
+	//	. "github.com/leanote/leanote/app/lea"
+	"github.com/leanote/leanote/app/info"
+	//	"os/exec"
+)
+
+type Tag struct {
+	BaseController
+}
+
+// 更新Tag
+func (c Tag) UpdateTag(tag string) revel.Result {
+	ret := info.NewRe()
+	ret.Ok = true
+	ret.Item = tagService.AddOrUpdateTag(c.GetUserId(), tag)
+	return c.RenderJSON(ret)
+}
+
+// 删除标签
+func (c Tag) DeleteTag(tag string) revel.Result {
+	ret := info.Re{}
+	ret.Ok = true
+	ret.Item = tagService.DeleteTag(c.GetUserId(), tag)
+	return c.RenderJSON(ret)
+}

app/controllers/UserController.go

@@ -2,16 +2,16 @@ package controllers
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-//	"gopkg.in/mgo.v2/bson"
-	. "github.com/leanote/leanote/app/lea"
+	//	"encoding/json"
+	//	"gopkg.in/mgo.v2/bson"
 	"github.com/leanote/leanote/app/info"
-//	"github.com/leanote/leanote/app/types"
-//	"io/ioutil"
-//	"fmt"
-//	"math"
-//	"os"
-//	"path"
+	. "github.com/leanote/leanote/app/lea"
+	//	"github.com/leanote/leanote/app/types"
+	//	"io/ioutil"
+	//	"fmt"
+	//	"math"
+	//	"os"
+	//	"path"
 	"strconv"
 )
 
@@ -21,67 +21,67 @@ type User struct {
 
 func (c User) Account(tab int) revel.Result {
 	userInfo := c.GetUserInfo()
-	c.RenderArgs["userInfo"] = userInfo
-	c.RenderArgs["tab"] = tab
+	c.ViewArgs["userInfo"] = userInfo
+	c.ViewArgs["tab"] = tab
 	c.SetLocale()
 	return c.RenderTemplate("user/account.html")
 }
 
 // 修改用户名, 需要重置session
 func (c User) UpdateUsername(username string) revel.Result {
-	re := info.NewRe();
-	if(c.GetUsername() == "demo") {
+	re := info.NewRe()
+	if c.GetUserId() == configService.GetGlobalStringConfig("demoUserId") {
 		re.Msg = "cannotUpdateDemo"
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
-	
+
 	if re.Ok, re.Msg = Vd("username", username); !re.Ok {
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
-	
+
 	re.Ok, re.Msg = userService.UpdateUsername(c.GetUserId(), username)
-	if(re.Ok) {
+	if re.Ok {
 		c.UpdateSession("Username", username)
 	}
-	return c.RenderRe(re);
+	return c.RenderRe(re)
 }
 
 // 修改密码
 func (c User) UpdatePwd(oldPwd, pwd string) revel.Result {
-	re := info.NewRe();
-	if(c.GetUsername() == "demo") {
+	re := info.NewRe()
+	if c.GetUserId() == configService.GetGlobalStringConfig("demoUserId") {
 		re.Msg = "cannotUpdateDemo"
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
 	if re.Ok, re.Msg = Vd("password", oldPwd); !re.Ok {
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
 	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
-		return c.RenderRe(re);
+		return c.RenderRe(re)
 	}
 	re.Ok, re.Msg = userService.UpdatePwd(c.GetUserId(), oldPwd, pwd)
-	return c.RenderRe(re);
+	return c.RenderRe(re)
 }
 
 // 更新主题
 func (c User) UpdateTheme(theme string) revel.Result {
-	re := info.NewRe();
+	re := info.NewRe()
 	re.Ok = userService.UpdateTheme(c.GetUserId(), theme)
 	if re.Ok {
 		c.UpdateSession("Theme", theme)
 	}
-	return c.RenderJson(re);
+	return c.RenderJSON(re)
 }
 
 // 发送邀请链接
 func (c User) SendRegisterEmail(content, toEmail string) revel.Result {
 	re := info.NewRe()
 	if content == "" || !IsEmail(toEmail) {
-		return c.RenderJson(re);
+		return c.RenderJSON(re)
 	}
-	
+
 	re.Ok = emailService.SendInviteEmail(c.GetUserInfo(), toEmail, content)
-	return c.RenderJson(re);
+	return c.RenderJSON(re)
 }
 
 //---------------------------
@@ -90,82 +90,46 @@ func (c User) SendRegisterEmail(content, toEmail string) revel.Result {
 func (c User) ReSendActiveEmail() revel.Result {
 	re := info.NewRe()
 	re.Ok = emailService.RegisterSendActiveEmail(c.GetUserInfo(), c.GetEmail())
-	return c.RenderJson(re)
-}
-
-// 修改Email发送激活邮箱
-func (c User) UpdateEmailSendActiveEmail(email string) revel.Result {
-	re := info.NewRe()
-	if(c.GetUsername() == "demo") {
-		re.Msg = "cannotUpdateDemo"
-		return c.RenderJson(re);
-	}
-	if re.Ok, re.Msg = Vd("email", email); !re.Ok {
-		return c.RenderRe(re);
-	}
-	
-	re.Ok, re.Msg = emailService.UpdateEmailSendActiveEmail(c.GetUserInfo(), email)
-	return c.RenderRe(re)
+	return c.RenderJSON(re)
 }
 
 // 通过点击链接
 // 修改邮箱
 func (c User) UpdateEmail(token string) revel.Result {
-	c.SetUserInfo();
-	
+	c.SetUserInfo()
+
 	ok, msg, email := userService.UpdateEmail(token)
-	
-	c.RenderArgs["title"] = "验证邮箱"
-	c.RenderArgs["ok"] = ok
-	c.RenderArgs["msg"] = msg
-	c.RenderArgs["email"] = email
-	
+
+	c.ViewArgs["title"] = "验证邮箱"
+	c.ViewArgs["ok"] = ok
+	c.ViewArgs["msg"] = msg
+	c.ViewArgs["email"] = email
+
 	// 修改session
 	if ok {
 		c.UpdateSession("Email", email)
 	}
-	
+
 	return c.RenderTemplate("user/update_email.html")
 }
 
 // 注册后激活邮箱
 func (c User) ActiveEmail(token string) revel.Result {
-	c.SetUserInfo();
-	
+	c.SetUserInfo()
+
 	ok, msg, email := userService.ActiveEmail(token)
-	
+
 	// 需要修改session
 	if ok {
-		c.UpdateSession("Verified", "1");
+		c.UpdateSession("Verified", "1")
 	}
-	
-	c.RenderArgs["title"] = "验证邮箱"
-	c.RenderArgs["ok"] = ok
-	c.RenderArgs["msg"] = msg
-	c.RenderArgs["email"] = email
-	
-	return c.RenderTemplate("user/active_email.html")
-}
 
-//------------
-// 第三方账号添加leanote账号
-func (c User) AddAccount(email, pwd string) revel.Result {
-	re := info.NewRe()
-	
-	if re.Ok, re.Msg = Vd("email", email); !re.Ok {
-		return c.RenderRe(re);
-	}
-	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
-		return c.RenderRe(re);
-	}
-	
-	re.Ok, re.Msg = userService.ThirdAddUser(c.GetUserId(), email, pwd)
-	
-	if re.Ok {
-		c.UpdateSession("Email", email);
-	}
-	
-	return c.RenderRe(re)
+	c.ViewArgs["title"] = "验证邮箱"
+	c.ViewArgs["ok"] = ok
+	c.ViewArgs["msg"] = msg
+	c.ViewArgs["email"] = email
+
+	return c.RenderTemplate("user/active_email.html")
 }
 
 //-----------------
@@ -174,23 +138,23 @@ func (c User) UpdateColumnWidth(notebookWidth, noteListWidth, mdEditorWidth int)
 	re := info.NewRe()
 	re.Ok = userService.UpdateColumnWidth(c.GetUserId(), notebookWidth, noteListWidth, mdEditorWidth)
 	if re.Ok {
-		c.UpdateSession("NotebookWidth", strconv.Itoa(notebookWidth));
-		c.UpdateSession("NoteListWidth", strconv.Itoa(noteListWidth)); 
-		c.UpdateSession("MdEditorWidth", strconv.Itoa(mdEditorWidth)); 
-		
+		c.UpdateSession("NotebookWidth", strconv.Itoa(notebookWidth))
+		c.UpdateSession("NoteListWidth", strconv.Itoa(noteListWidth))
+		c.UpdateSession("MdEditorWidth", strconv.Itoa(mdEditorWidth))
+
 		LogJ(c.Session)
 	}
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 func (c User) UpdateLeftIsMin(leftIsMin bool) revel.Result {
 	re := info.NewRe()
 	re.Ok = userService.UpdateLeftIsMin(c.GetUserId(), leftIsMin)
 	if re.Ok {
 		if leftIsMin {
-			c.UpdateSession("LeftIsMin", "1");
+			c.UpdateSession("LeftIsMin", "1")
 		} else {
-			c.UpdateSession("LeftIsMin", "0");
+			c.UpdateSession("LeftIsMin", "0")
 		}
 	}
-	return c.RenderJson(re)
-}
+	return c.RenderJSON(re)
+}

app/controllers/admin/AdminBaseController.go

@@ -1,15 +1,15 @@
 package admin
 
 import (
-//	"github.com/revel/revel"
-//	"gopkg.in/mgo.v2/bson"
-//	"encoding/json"
-	. "github.com/leanote/leanote/app/lea"
+	//	"github.com/revel/revel"
+	//	"gopkg.in/mgo.v2/bson"
+	//	"encoding/json"
 	"github.com/leanote/leanote/app/controllers"
-//	"io/ioutil"
-//	"fmt"
-//	"math"
-//	"strconv"
+	. "github.com/leanote/leanote/app/lea"
+	//	"io/ioutil"
+	//	"fmt"
+	//	"math"
+	//	"strconv"
 	"strings"
 )
 
@@ -20,34 +20,34 @@ type AdminBaseController struct {
 
 // 得到sorterField 和 isAsc
 // okSorter = ['email', 'username']
-func (c AdminBaseController) getSorter(sorterField string, isAsc bool, okSorter []string) (string, bool){
+func (c AdminBaseController) getSorter(sorterField string, isAsc bool, okSorter []string) (string, bool) {
 	sorter := ""
 	c.Params.Bind(&sorter, "sorter")
 	if sorter == "" {
-		return sorterField, isAsc;
+		return sorterField, isAsc
 	}
-	
+
 	// sorter形式 email-up, email-down
 	s2 := strings.Split(sorter, "-")
 	if len(s2) != 2 {
-		return sorterField, isAsc;
+		return sorterField, isAsc
 	}
-	
+
 	// 必须是可用的sorter
 	if okSorter != nil && len(okSorter) > 0 {
 		if !InArray(okSorter, s2[0]) {
-			return sorterField, isAsc;
+			return sorterField, isAsc
 		}
 	}
-	
+
 	sorterField = strings.Title(s2[0])
 	if s2[1] == "up" {
 		isAsc = true
 	} else {
 		isAsc = false
 	}
-	c.RenderArgs["sorter"] = sorter
-	return sorterField, isAsc;
+	c.ViewArgs["sorter"] = sorter
+	return sorterField, isAsc
 }
 
 func (c AdminBaseController) updateConfig(keys []string) {
@@ -56,4 +56,4 @@ func (c AdminBaseController) updateConfig(keys []string) {
 		v := c.Params.Values.Get(key)
 		configService.UpdateGlobalStringConfig(userId, key, v)
 	}
-}
+}

app/controllers/admin/AdminBlogController.go

@@ -2,7 +2,7 @@ package admin
 
 import (
 	"github.com/revel/revel"
-//	. "github.com/leanote/leanote/app/lea"
+	//	. "github.com/leanote/leanote/app/lea"
 	"github.com/leanote/leanote/app/info"
 )
 
@@ -15,16 +15,16 @@ type AdminBlog struct {
 // admin 主页
 func (c AdminBlog) Index(sorter, keywords string) revel.Result {
 	pageNumber := c.GetPage()
-	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"title", "userId", "isRecommed", "createdTime"});
-	pageInfo, blogs := blogService.ListAllBlogs("", keywords, false, pageNumber, userPageSize, sorterField, isAsc);
-	c.RenderArgs["pageInfo"] = pageInfo
-	c.RenderArgs["blogs"] = blogs
-	c.RenderArgs["keywords"] = keywords
-	return c.RenderTemplate("admin/blog/list.html");
+	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"title", "userId", "isRecommed", "createdTime"})
+	pageInfo, blogs := blogService.ListAllBlogs("", "", keywords, false, pageNumber, userPageSize, sorterField, isAsc)
+	c.ViewArgs["pageInfo"] = pageInfo
+	c.ViewArgs["blogs"] = blogs
+	c.ViewArgs["keywords"] = keywords
+	return c.RenderTemplate("admin/blog/list.html")
 }
 
 func (c AdminBlog) SetRecommend(noteId string, recommend bool) revel.Result {
 	re := info.NewRe()
-	re.Ok = blogService.SetRecommend(noteId, recommend);
-	return c.RenderJson(re)
-}
+	re.Ok = blogService.SetRecommend(noteId, recommend)
+	return c.RenderJSON(re)
+}

app/controllers/admin/AdminController.go

@@ -13,26 +13,27 @@ type Admin struct {
 // admin 主页
 func (c Admin) Index() revel.Result {
 	c.SetUserInfo()
-	
-	c.RenderArgs["title"] = "leanote"
+
+	c.ViewArgs["title"] = "leanote"
 	c.SetLocale()
-	
-	c.RenderArgs["countUser"] = userService.CountUser()
-	c.RenderArgs["countNote"] = noteService.CountNote()
-	c.RenderArgs["countBlog"] = noteService.CountBlog()
-	
-	return c.RenderTemplate("admin/index.html");
+
+	c.ViewArgs["countUser"] = userService.CountUser()
+	c.ViewArgs["countNote"] = noteService.CountNote("")
+	c.ViewArgs["countBlog"] = noteService.CountBlog("")
+
+	return c.RenderTemplate("admin/index.html")
 }
 
 // 模板
 func (c Admin) T(t string) revel.Result {
-	c.RenderArgs["str"] = configService.GlobalStringConfigs
-	c.RenderArgs["arr"] = configService.GlobalArrayConfigs
-	c.RenderArgs["map"] = configService.GlobalMapConfigs
-	c.RenderArgs["arrMap"] = configService.GlobalArrMapConfigs
+	c.ViewArgs["str"] = configService.GlobalStringConfigs
+	c.ViewArgs["arr"] = configService.GlobalArrayConfigs
+	c.ViewArgs["map"] = configService.GlobalMapConfigs
+	c.ViewArgs["arrMap"] = configService.GlobalArrMapConfigs
+	c.ViewArgs["version"] = configService.GetVersion()
 	return c.RenderTemplate("admin/" + t + ".html")
 }
 
 func (c Admin) GetView(view string) revel.Result {
-	return c.RenderTemplate("admin/" + view);
-}
+	return c.RenderTemplate("admin/" + view)
+}

app/controllers/admin/AdminData.go

@@ -1,14 +1,14 @@
 package admin
 
 import (
-	"github.com/revel/revel"
-	. "github.com/leanote/leanote/app/lea"
+	"archive/tar"
+	"compress/gzip"
 	"github.com/leanote/leanote/app/info"
-	 "archive/tar"
-    "compress/gzip"	
-    "os"
-    "io"
-    "time"
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	"io"
+	"os"
+	"time"
 )
 
 // 数据管理, 备份和恢复
@@ -22,93 +22,93 @@ func (c AdminData) Index() revel.Result {
 	// 逆序之
 	backups2 := make([]map[string]string, len(backups))
 	j := 0
-	for i := len(backups)-1; i >= 0; i-- {
+	for i := len(backups) - 1; i >= 0; i-- {
 		backups2[j] = backups[i]
 		j++
 	}
-	c.RenderArgs["backups"] = backups2
-	return c.RenderTemplate("admin/data/index.html");
+	c.ViewArgs["backups"] = backups2
+	return c.RenderTemplate("admin/data/index.html")
 }
 
 func (c AdminData) Backup() revel.Result {
 	re := info.NewRe()
 	re.Ok, re.Msg = configService.Backup("")
-    return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 // 还原
 func (c AdminData) Restore(createdTime string) revel.Result {
 	re := info.Re{}
 	re.Ok, re.Msg = configService.Restore(createdTime)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 func (c AdminData) Delete(createdTime string) revel.Result {
 	re := info.Re{}
 	re.Ok, re.Msg = configService.DeleteBackup(createdTime)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 func (c AdminData) UpdateRemark(createdTime, remark string) revel.Result {
 	re := info.Re{}
 	re.Ok, re.Msg = configService.UpdateBackupRemark(createdTime, remark)
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 func (c AdminData) Download(createdTime string) revel.Result {
 	backup, ok := configService.GetBackup(createdTime)
 	if !ok {
 		return c.RenderText("")
 	}
-	
+
 	dbname, _ := revel.Config.String("db.dbname")
 	path := backup["path"] + "/" + dbname
-    allFiles := ListDir(path)
-    
+	allFiles := ListDir(path)
+
 	filename := "backup_" + dbname + "_" + backup["createdTime"] + ".tar.gz"
-	
+
 	// file write
-    fw, err := os.Create(revel.BasePath + "/files/" + filename)
-    if err != nil {
+	fw, err := os.Create(revel.BasePath + "/files/" + filename)
+	if err != nil {
 		return c.RenderText("")
-    }
-    // defer fw.Close() // 不需要关闭, 还要读取给用户下载
-    // gzip write
-    gw := gzip.NewWriter(fw)
-    defer gw.Close()
-  
-    // tar write
-    tw := tar.NewWriter(gw)
-    defer tw.Close()
-    
-    // 遍历文件列表
-    for _, file := range allFiles {
+	}
+	// defer fw.Close() // 不需要关闭, 还要读取给用户下载
+	// gzip write
+	gw := gzip.NewWriter(fw)
+	defer gw.Close()
+
+	// tar write
+	tw := tar.NewWriter(gw)
+	defer tw.Close()
+
+	// 遍历文件列表
+	for _, file := range allFiles {
 		fn := path + "/" + file
-	    fr, err := os.Open(fn)
-	    fileInfo, _ := fr.Stat()
-        if err != nil {
+		fr, err := os.Open(fn)
+		fileInfo, _ := fr.Stat()
+		if err != nil {
 			return c.RenderText("")
-        }
-        defer fr.Close()
-        
-        // 信息头
-        h := new(tar.Header)
-        h.Name = file
-        h.Size = fileInfo.Size()
-        h.Mode = int64(fileInfo.Mode())
-        h.ModTime = fileInfo.ModTime()
-  
-        // 写信息头
-        err = tw.WriteHeader(h)
-        if err != nil {
-            panic(err)
-        }
-  
-        // 写文件
-        _, err = io.Copy(tw, fr)
-        if err != nil {
-            panic(err)
-        }
-    } // for
-    
-    return c.RenderBinary(fw, filename, revel.Attachment, time.Now()) // revel.Attachm
+		}
+		defer fr.Close()
+
+		// 信息头
+		h := new(tar.Header)
+		h.Name = file
+		h.Size = fileInfo.Size()
+		h.Mode = int64(fileInfo.Mode())
+		h.ModTime = fileInfo.ModTime()
+
+		// 写信息头
+		err = tw.WriteHeader(h)
+		if err != nil {
+			panic(err)
+		}
+
+		// 写文件
+		_, err = io.Copy(tw, fr)
+		if err != nil {
+			panic(err)
+		}
+	} // for
+
+	return c.RenderBinary(fw, filename, revel.Attachment, time.Now()) // revel.Attachm
 }

app/controllers/admin/AdminEmailController.go

@@ -1,11 +1,11 @@
 package admin
 
 import (
-	"github.com/revel/revel"
-	. "github.com/leanote/leanote/app/lea"
 	"github.com/leanote/leanote/app/info"
-	"strings"
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
 	"strconv"
+	"strings"
 )
 
 // admin 首页
@@ -23,67 +23,71 @@ func (c AdminEmail) Email() revel.Result {
 func (c AdminEmail) Blog() revel.Result {
 	recommendTags := configService.GetGlobalArrayConfig("recommendTags")
 	newTags := configService.GetGlobalArrayConfig("newTags")
-	c.RenderArgs["recommendTags"] = strings.Join(recommendTags, ",")
-	c.RenderArgs["newTags"] = strings.Join(newTags, ",")
-	return c.RenderTemplate("admin/setting/blog.html");
+	c.ViewArgs["recommendTags"] = strings.Join(recommendTags, ",")
+	c.ViewArgs["newTags"] = strings.Join(newTags, ",")
+	return c.RenderTemplate("admin/setting/blog.html")
 }
 func (c AdminEmail) DoBlogTag(recommendTags, newTags string) revel.Result {
 	re := info.NewRe()
-	
+
 	re.Ok = configService.UpdateGlobalArrayConfig(c.GetUserId(), "recommendTags", strings.Split(recommendTags, ","))
 	re.Ok = configService.UpdateGlobalArrayConfig(c.GetUserId(), "newTags", strings.Split(newTags, ","))
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 // demo
 // blog标签设置
 func (c AdminEmail) Demo() revel.Result {
-	c.RenderArgs["demoUsername"] = configService.GetGlobalStringConfig("demoUsername")
-	c.RenderArgs["demoPassword"] = configService.GetGlobalStringConfig("demoPassword")
-	return c.RenderTemplate("admin/setting/demo.html");
+	c.ViewArgs["demoUsername"] = configService.GetGlobalStringConfig("demoUsername")
+	c.ViewArgs["demoPassword"] = configService.GetGlobalStringConfig("demoPassword")
+	return c.RenderTemplate("admin/setting/demo.html")
 }
 func (c AdminEmail) DoDemo(demoUsername, demoPassword string) revel.Result {
 	re := info.NewRe()
-	
-	userInfo := authService.Login(demoUsername, demoPassword)
-	if userInfo.UserId == "" {
-		re.Msg = "The User is Not Exists";
-		return c.RenderJson(re)
+
+	userInfo, err := authService.Login(demoUsername, demoPassword)
+	if err != nil {
+		return c.RenderJSON(info.Re{Ok: false})
 	}
-	
+	if userInfo.UserId == "" {
+		re.Msg = "The User is Not Exists"
+		return c.RenderJSON(re)
+	}
+
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "demoUserId", userInfo.UserId.Hex())
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "demoUsername", demoUsername)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "demoPassword", demoPassword)
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 // ToImage
 // 长微博的bin路径phantomJs
 func (c AdminEmail) ToImage() revel.Result {
-	c.RenderArgs["toImageBinPath"] = configService.GetGlobalStringConfig("toImageBinPath")
-	return c.RenderTemplate("admin/setting/toImage.html");
+	c.ViewArgs["toImageBinPath"] = configService.GetGlobalStringConfig("toImageBinPath")
+	return c.RenderTemplate("admin/setting/toImage.html")
 }
 func (c AdminEmail) DoToImage(toImageBinPath string) revel.Result {
 	re := info.NewRe()
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "toImageBinPath", toImageBinPath)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
-func (c AdminEmail) Set(emailHost, emailPort, emailUsername, emailPassword string) revel.Result {
+func (c AdminEmail) Set(emailHost, emailPort, emailUsername, emailPassword, emailSSL string) revel.Result {
 	re := info.NewRe()
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "emailHost", emailHost)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "emailPort", emailPort)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "emailUsername", emailUsername)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "emailPassword", emailPassword)
-	
-	return c.RenderJson(re)
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "emailSSL", emailSSL)
+
+	return c.RenderJSON(re)
 }
 func (c AdminEmail) Template() revel.Result {
 	re := info.NewRe()
-	
-	keys := []string{"emailTemplateHeader", "emailTemplateFooter", 
+
+	keys := []string{"emailTemplateHeader", "emailTemplateFooter",
 		"emailTemplateRegisterSubject",
 		"emailTemplateRegister",
 		"emailTemplateFindPasswordSubject",
@@ -95,7 +99,7 @@ func (c AdminEmail) Template() revel.Result {
 		"emailTemplateCommentSubject",
 		"emailTemplateComment",
 	}
-	
+
 	userId := c.GetUserId()
 	for _, key := range keys {
 		v := c.Params.Values.Get(key)
@@ -104,130 +108,129 @@ func (c AdminEmail) Template() revel.Result {
 			if !ok {
 				re.Ok = false
 				re.Msg = "Error key: " + key + "<br />" + msg
-				return c.RenderJson(re)
+				return c.RenderJSON(re)
 			} else {
 				configService.UpdateGlobalStringConfig(userId, key, v)
 			}
 		}
 	}
-	
+
 	re.Ok = true
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 // 发送Email
 func (c AdminEmail) SendEmailToEmails(sendEmails, latestEmailSubject, latestEmailBody string, verified, saveAsOldEmail bool) revel.Result {
 	re := info.NewRe()
-	
+
 	c.updateConfig([]string{"sendEmails", "latestEmailSubject", "latestEmailBody"})
-	
+
 	if latestEmailSubject == "" || latestEmailBody == "" {
 		re.Msg = "subject or body is blank"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
+
 	if saveAsOldEmail {
 		oldEmails := configService.GetGlobalMapConfig("oldEmails")
 		oldEmails[latestEmailSubject] = latestEmailBody
-		configService.UpdateGlobalMapConfig(c.GetUserId(), "oldEmails", oldEmails);
+		configService.UpdateGlobalMapConfig(c.GetUserId(), "oldEmails", oldEmails)
 	}
-	
+
 	sendEmails = strings.Replace(sendEmails, "\r", "", -1)
 	emails := strings.Split(sendEmails, "\n")
-	
-	re.Ok, re.Msg = emailService.SendEmailToEmails(emails, latestEmailSubject, latestEmailBody);
-	return c.RenderJson(re)
+
+	re.Ok, re.Msg = emailService.SendEmailToEmails(emails, latestEmailSubject, latestEmailBody)
+	return c.RenderJSON(re)
 }
 
 // 发送Email
 func (c AdminEmail) SendToUsers2(emails, latestEmailSubject, latestEmailBody string, verified, saveAsOldEmail bool) revel.Result {
 	re := info.NewRe()
-	
+
 	c.updateConfig([]string{"sendEmails", "latestEmailSubject", "latestEmailBody"})
-	
+
 	if latestEmailSubject == "" || latestEmailBody == "" {
 		re.Msg = "subject or body is blank"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
+
 	if saveAsOldEmail {
 		oldEmails := configService.GetGlobalMapConfig("oldEmails")
 		oldEmails[latestEmailSubject] = latestEmailBody
-		configService.UpdateGlobalMapConfig(c.GetUserId(), "oldEmails", oldEmails);
+		configService.UpdateGlobalMapConfig(c.GetUserId(), "oldEmails", oldEmails)
 	}
-	
+
 	emails = strings.Replace(emails, "\r", "", -1)
 	emailsArr := strings.Split(emails, "\n")
-	
+
 	users := userService.ListUserInfosByEmails(emailsArr)
 	LogJ(emailsArr)
-	
-	
-	re.Ok, re.Msg = emailService.SendEmailToUsers(users, latestEmailSubject, latestEmailBody);
-	
-	return c.RenderJson(re)
+
+	re.Ok, re.Msg = emailService.SendEmailToUsers(users, latestEmailSubject, latestEmailBody)
+
+	return c.RenderJSON(re)
 }
 
 // send Email dialog
-func (c AdminEmail) SendEmailDialog(emails string) revel.Result{
+func (c AdminEmail) SendEmailDialog(emails string) revel.Result {
 	emailsArr := strings.Split(emails, ",")
 	emailsNl := strings.Join(emailsArr, "\n")
-	
-	c.RenderArgs["emailsNl"] = emailsNl
-	c.RenderArgs["str"] = configService.GlobalStringConfigs
-	c.RenderArgs["map"] = configService.GlobalMapConfigs
-	
-	return c.RenderTemplate("admin/email/emailDialog.html");
+
+	c.ViewArgs["emailsNl"] = emailsNl
+	c.ViewArgs["str"] = configService.GlobalStringConfigs
+	c.ViewArgs["map"] = configService.GlobalMapConfigs
+
+	return c.RenderTemplate("admin/email/emailDialog.html")
 }
 
 func (c AdminEmail) SendToUsers(userFilterEmail, userFilterWhiteList, userFilterBlackList, latestEmailSubject, latestEmailBody string, verified, saveAsOldEmail bool) revel.Result {
 	re := info.NewRe()
-	
+
 	c.updateConfig([]string{"userFilterEmail", "userFilterWhiteList", "userFilterBlackList", "latestEmailSubject", "latestEmailBody"})
-	
+
 	if latestEmailSubject == "" || latestEmailBody == "" {
 		re.Msg = "subject or body is blank"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
+
 	if saveAsOldEmail {
 		oldEmails := configService.GetGlobalMapConfig("oldEmails")
 		oldEmails[latestEmailSubject] = latestEmailBody
-		configService.UpdateGlobalMapConfig(c.GetUserId(), "oldEmails", oldEmails);
+		configService.UpdateGlobalMapConfig(c.GetUserId(), "oldEmails", oldEmails)
 	}
-	
+
 	users := userService.GetAllUserByFilter(userFilterEmail, userFilterWhiteList, userFilterBlackList, verified)
-	
-	if(users == nil || len(users) == 0) {
+
+	if users == nil || len(users) == 0 {
 		re.Ok = false
 		re.Msg = "no users"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
-	re.Ok, re.Msg = emailService.SendEmailToUsers(users, latestEmailSubject, latestEmailBody);
-	if(!re.Ok) {
-		return c.RenderJson(re)
+
+	re.Ok, re.Msg = emailService.SendEmailToUsers(users, latestEmailSubject, latestEmailBody)
+	if !re.Ok {
+		return c.RenderJSON(re)
 	}
-	
+
 	re.Ok = true
 	re.Msg = "users:" + strconv.Itoa(len(users))
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 // 删除emails
 func (c AdminEmail) DeleteEmails(ids string) revel.Result {
 	re := info.NewRe()
 	re.Ok = emailService.DeleteEmails(strings.Split(ids, ","))
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
 }
 
 func (c AdminEmail) List(sorter, keywords string) revel.Result {
 	pageNumber := c.GetPage()
-	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"email", "ok", "subject", "createdTime"});
-	pageInfo, emails := emailService.ListEmailLogs(pageNumber, userPageSize, sorterField, isAsc, keywords);
-	c.RenderArgs["pageInfo"] = pageInfo
-	c.RenderArgs["emails"] = emails
-	c.RenderArgs["keywords"] = keywords
-	return c.RenderTemplate("admin/email/list.html");
-}
+	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"email", "ok", "subject", "createdTime"})
+	pageInfo, emails := emailService.ListEmailLogs(pageNumber, userPageSize, sorterField, isAsc, keywords)
+	c.ViewArgs["pageInfo"] = pageInfo
+	c.ViewArgs["emails"] = emails
+	c.ViewArgs["keywords"] = keywords
+	return c.RenderTemplate("admin/email/list.html")
+}

app/controllers/admin/AdminSettingController.go

@@ -2,7 +2,8 @@ package admin
 
 import (
 	"github.com/revel/revel"
-//	. "github.com/leanote/leanote/app/lea"
+	//	. "github.com/leanote/leanote/app/lea"
+	"fmt"
 	"github.com/leanote/leanote/app/info"
 	"strings"
 )
@@ -22,92 +23,105 @@ func (c AdminSetting) Email() revel.Result {
 func (c AdminSetting) Blog() revel.Result {
 	recommendTags := configService.GetGlobalArrayConfig("recommendTags")
 	newTags := configService.GetGlobalArrayConfig("newTags")
-	c.RenderArgs["recommendTags"] = strings.Join(recommendTags, ",")
-	c.RenderArgs["newTags"] = strings.Join(newTags, ",")
-	return c.RenderTemplate("admin/setting/blog.html");
+	c.ViewArgs["recommendTags"] = strings.Join(recommendTags, ",")
+	c.ViewArgs["newTags"] = strings.Join(newTags, ",")
+	return c.RenderTemplate("admin/setting/blog.html")
 }
 func (c AdminSetting) DoBlogTag(recommendTags, newTags string) revel.Result {
 	re := info.NewRe()
-	
+
 	re.Ok = configService.UpdateGlobalArrayConfig(c.GetUserId(), "recommendTags", strings.Split(recommendTags, ","))
 	re.Ok = configService.UpdateGlobalArrayConfig(c.GetUserId(), "newTags", strings.Split(newTags, ","))
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 // 共享设置
-func (c AdminSetting) ShareNote(registerSharedUserId string, 
-	registerSharedNotebookPerms, registerSharedNotePerms []int, 
+func (c AdminSetting) ShareNote(registerSharedUserId string,
+	registerSharedNotebookPerms, registerSharedNotePerms []int,
 	registerSharedNotebookIds, registerSharedNoteIds, registerCopyNoteIds []string) revel.Result {
-	
+
 	re := info.NewRe()
-	re.Ok, re.Msg = configService.UpdateShareNoteConfig(registerSharedUserId, registerSharedNotebookPerms, registerSharedNotePerms, registerSharedNotebookIds, registerSharedNoteIds, registerCopyNoteIds);
-	return c.RenderJson(re)
+	re.Ok, re.Msg = configService.UpdateShareNoteConfig(registerSharedUserId, registerSharedNotebookPerms, registerSharedNotePerms, registerSharedNotebookIds, registerSharedNoteIds, registerCopyNoteIds)
+	return c.RenderJSON(re)
 }
 
 // demo
 // blog标签设置
 func (c AdminSetting) Demo() revel.Result {
-	c.RenderArgs["demoUsername"] = configService.GetGlobalStringConfig("demoUsername")
-	c.RenderArgs["demoPassword"] = configService.GetGlobalStringConfig("demoPassword")
-	return c.RenderTemplate("admin/setting/demo.html");
+	c.ViewArgs["demoUsername"] = configService.GetGlobalStringConfig("demoUsername")
+	c.ViewArgs["demoPassword"] = configService.GetGlobalStringConfig("demoPassword")
+	return c.RenderTemplate("admin/setting/demo.html")
 }
 func (c AdminSetting) DoDemo(demoUsername, demoPassword string) revel.Result {
 	re := info.NewRe()
-	
-	userInfo := authService.Login(demoUsername, demoPassword)
-	if userInfo.UserId == "" {
-		re.Msg = "The User is Not Exists";
-		return c.RenderJson(re)
+
+	userInfo, err := authService.Login(demoUsername, demoPassword)
+	if err != nil {
+		fmt.Println(err)
+		return c.RenderJSON(info.Re{Ok: false})
 	}
-	
+	if userInfo.UserId == "" {
+		re.Msg = "The User is Not Exists"
+		return c.RenderJSON(re)
+	}
+
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "demoUserId", userInfo.UserId.Hex())
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "demoUsername", demoUsername)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "demoPassword", demoPassword)
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
-// ToImage
-// 长微博的bin路径phantomJs
-func (c AdminSetting) ToImage() revel.Result {
-	c.RenderArgs["toImageBinPath"] = configService.GetGlobalStringConfig("toImageBinPath")
-	return c.RenderTemplate("admin/setting/toImage.html");
-}
-func (c AdminSetting) DoToImage(toImageBinPath string) revel.Result {
+func (c AdminSetting) ExportPdf(path string) revel.Result {
 	re := info.NewRe()
-	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "toImageBinPath", toImageBinPath)
-	return c.RenderJson(re)
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "exportPdfBinPath", path)
+	return c.RenderJSON(re)
+}
+
+func (c AdminSetting) DoSiteUrl(siteUrl string) revel.Result {
+	re := info.NewRe()
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "siteUrl", siteUrl)
+	return c.RenderJSON(re)
 }
 
 // SubDomain
 func (c AdminSetting) SubDomain() revel.Result {
-	c.RenderArgs["str"] = configService.GlobalStringConfigs
-	c.RenderArgs["arr"] = configService.GlobalArrayConfigs
-	
-	c.RenderArgs["noteSubDomain"] = configService.GetGlobalStringConfig("noteSubDomain")
-	c.RenderArgs["blogSubDomain"] = configService.GetGlobalStringConfig("blogSubDomain")
-	c.RenderArgs["leaSubDomain"] = configService.GetGlobalStringConfig("leaSubDomain")
-	
-	return c.RenderTemplate("admin/setting/subDomain.html");
+	c.ViewArgs["str"] = configService.GlobalStringConfigs
+	c.ViewArgs["arr"] = configService.GlobalArrayConfigs
+
+	c.ViewArgs["noteSubDomain"] = configService.GetGlobalStringConfig("noteSubDomain")
+	c.ViewArgs["blogSubDomain"] = configService.GetGlobalStringConfig("blogSubDomain")
+	c.ViewArgs["leaSubDomain"] = configService.GetGlobalStringConfig("leaSubDomain")
+
+	return c.RenderTemplate("admin/setting/subDomain.html")
 }
 func (c AdminSetting) DoSubDomain(noteSubDomain, blogSubDomain, leaSubDomain, blackSubDomains, allowCustomDomain, blackCustomDomains string) revel.Result {
 	re := info.NewRe()
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "noteSubDomain", noteSubDomain)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "blogSubDomain", blogSubDomain)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "leaSubDomain", leaSubDomain)
-	
+
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "allowCustomDomain", allowCustomDomain)
 	re.Ok = configService.UpdateGlobalArrayConfig(c.GetUserId(), "blackSubDomains", strings.Split(blackSubDomains, ","))
 	re.Ok = configService.UpdateGlobalArrayConfig(c.GetUserId(), "blackCustomDomains", strings.Split(blackCustomDomains, ","))
-	
-	return c.RenderJson(re)
+
+	return c.RenderJSON(re)
 }
 
 func (c AdminSetting) OpenRegister(openRegister string) revel.Result {
 	re := info.NewRe()
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "openRegister", openRegister)
-	return c.RenderJson(re)
+	return c.RenderJSON(re)
+}
+
+func (c AdminSetting) HomePage(homePage string) revel.Result {
+	re := info.NewRe()
+	if homePage == "0" {
+		homePage = ""
+	}
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "homePage", homePage)
+	return c.RenderJSON(re)
 }
 
 func (c AdminSetting) Mongodb(mongodumpPath, mongorestorePath string) revel.Result {
@@ -115,5 +129,14 @@ func (c AdminSetting) Mongodb(mongodumpPath, mongorestorePath string) revel.Resu
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "mongodumpPath", mongodumpPath)
 	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "mongorestorePath", mongorestorePath)
 
-	return c.RenderJson(re)
-}
+	return c.RenderJSON(re)
+}
+
+func (c AdminSetting) UploadSize(uploadImageSize, uploadAvatarSize, uploadBlogLogoSize, uploadAttachSize float64) revel.Result {
+	re := info.NewRe()
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "uploadImageSize", fmt.Sprintf("%v", uploadImageSize))
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "uploadAvatarSize", fmt.Sprintf("%v", uploadAvatarSize))
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "uploadBlogLogoSize", fmt.Sprintf("%v", uploadBlogLogoSize))
+	re.Ok = configService.UpdateGlobalStringConfig(c.GetUserId(), "uploadAttachSize", fmt.Sprintf("%v", uploadAttachSize))
+	return c.RenderJSON(re)
+}

app/controllers/admin/AdminUpgradeController.go

@@ -2,9 +2,9 @@ package admin
 
 import (
 	"github.com/revel/revel"
-//	"encoding/json"
-//	. "github.com/leanote/leanote/app/lea"
-//	"io/ioutil"
+	//	"encoding/json"
+	"github.com/leanote/leanote/app/info"
+	//	"io/ioutil"
 )
 
 // Upgrade controller
@@ -14,5 +14,17 @@ type AdminUpgrade struct {
 
 func (c AdminUpgrade) UpgradeBlog() revel.Result {
 	upgradeService.UpgradeBlog()
-	return nil;
-}
+	return nil
+}
+
+func (c AdminUpgrade) UpgradeBetaToBeta2() revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = upgradeService.UpgradeBetaToBeta2(c.GetUserId())
+	return c.RenderJSON(re)
+}
+
+func (c AdminUpgrade) UpgradeBeta3ToBeta4() revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = upgradeService.Api(c.GetUserId())
+	return c.RenderJSON(re)
+}

app/controllers/admin/AdminUserController.go

@@ -1,8 +1,10 @@
 package admin
 
 import (
+	. "github.com/leanote/leanote/app/lea"
 	"github.com/revel/revel"
-//	. "github.com/leanote/leanote/app/lea"
+	//	"time"
+	"github.com/leanote/leanote/app/info"
 )
 
 // admin 首页
@@ -13,16 +15,53 @@ type AdminUser struct {
 
 // admin 主页
 var userPageSize = 10
-func (c AdminUser) Index(sorter, keywords string) revel.Result {
+
+func (c AdminUser) Index(sorter, keywords string, pageSize int) revel.Result {
 	pageNumber := c.GetPage()
-	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"email", "username", "verified", "createdTime"});
-	pageInfo, users := userService.ListUsers(pageNumber, userPageSize, sorterField, isAsc, keywords);
-	c.RenderArgs["pageInfo"] = pageInfo
-	c.RenderArgs["users"] = users
-	c.RenderArgs["keywords"] = keywords
-	return c.RenderTemplate("admin/user/list.html");
+	if pageSize == 0 {
+		pageSize = userPageSize
+	}
+	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"email", "username", "verified", "createdTime", "accountType"})
+	pageInfo, users := userService.ListUsers(pageNumber, pageSize, sorterField, isAsc, keywords)
+	c.ViewArgs["pageInfo"] = pageInfo
+	c.ViewArgs["users"] = users
+	c.ViewArgs["keywords"] = keywords
+	return c.RenderTemplate("admin/user/list.html")
 }
 
 func (c AdminUser) Add() revel.Result {
-	return c.RenderTemplate("admin/user/add.html");
+	return c.RenderTemplate("admin/user/add.html")
+}
+
+// 添加
+func (c AdminUser) Register(email, pwd string) revel.Result {
+	re := info.NewRe()
+
+	if re.Ok, re.Msg = Vd("email", email); !re.Ok {
+		return c.RenderRe(re)
+	}
+	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
+		return c.RenderRe(re)
+	}
+
+	// 注册
+	re.Ok, re.Msg = authService.Register(email, pwd, "")
+
+	return c.RenderRe(re)
+}
+
+// 修改帐户
+func (c AdminUser) ResetPwd(userId string) revel.Result {
+	userInfo := userService.GetUserInfo(userId)
+	c.ViewArgs["userInfo"] = userInfo
+	return c.RenderTemplate("admin/user/reset_pwd.html")
+}
+
+func (c AdminUser) DoResetPwd(userId, pwd string) revel.Result {
+	re := info.NewRe()
+	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
+		return c.RenderRe(re)
+	}
+	re.Ok, re.Msg = userService.ResetPwd(c.GetUserId(), userId, pwd)
+	return c.RenderRe(re)
 }

app/controllers/admin/init.go

@@ -1,11 +1,11 @@
 package admin
 
 import (
-	"github.com/leanote/leanote/app/service"
 	"github.com/leanote/leanote/app/info"
-//	. "github.com/leanote/leanote/app/lea"
+	"github.com/leanote/leanote/app/service"
+	//	. "github.com/leanote/leanote/app/lea"
 	"github.com/revel/revel"
-//	"strings"
+	//	"strings"
 )
 
 var userService *service.UserService
@@ -19,44 +19,44 @@ var blogService *service.BlogService
 var tagService *service.TagService
 var pwdService *service.PwdService
 var tokenService *service.TokenService
-var suggestionService *service.SuggestionService 
-var albumService *service.AlbumService 
-var noteImageService *service.NoteImageService 
+var suggestionService *service.SuggestionService
+var albumService *service.AlbumService
+var noteImageService *service.NoteImageService
 var fileService *service.FileService
 var attachService *service.AttachService
 var configService *service.ConfigService
 var emailService *service.EmailService
 var upgradeService *service.UpgradeService
 
-var adminUsername = "admin"
 // 拦截器
 // 不需要拦截的url
 // Index 除了Note之外都不需要
-var commonUrl = map[string]map[string]bool{"Index": map[string]bool{"Index": true, 
-		"Login": true, 
-		"DoLogin": true,
-		"Logout": true,
-		"Register": true,
-		"DoRegister": true,
-		"FindPasswword": true,
-		"DoFindPassword": true,
-		"FindPassword2": true,
-		"FindPasswordUpdate": true,
-		"Suggestion": true,
-	},
+var commonUrl = map[string]map[string]bool{"Index": map[string]bool{"Index": true,
+	"Login":              true,
+	"DoLogin":            true,
+	"Logout":             true,
+	"Register":           true,
+	"DoRegister":         true,
+	"FindPasswword":      true,
+	"DoFindPassword":     true,
+	"FindPassword2":      true,
+	"FindPasswordUpdate": true,
+	"Suggestion":         true,
+},
 	"Blog": map[string]bool{"Index": true,
-		"View": true,
-		"AboutMe": true,
+		"View":       true,
+		"AboutMe":    true,
 		"SearchBlog": true,
-		},
+	},
 	// 用户的激活与修改邮箱都不需要登录, 通过链接地址
 	"User": map[string]bool{"UpdateEmail": true,
-		"ActiveEmail":true,
-		},
-	"Oauth": map[string]bool{"GithubCallback": true},
-	"File": map[string]bool{"OutputImage": true, "OutputFile": true},
+		"ActiveEmail": true,
+	},
+	"Oauth":  map[string]bool{"GithubCallback": true},
+	"File":   map[string]bool{"OutputImage": true, "OutputFile": true},
 	"Attach": map[string]bool{"Download": true, "DownloadAll": true},
 }
+
 func needValidate(controller, method string) bool {
 	// 在里面
 	if v, ok := commonUrl[controller]; ok {
@@ -67,33 +67,33 @@ func needValidate(controller, method string) bool {
 		return true
 	} else {
 		// controller不在这里的, 肯定要验证
-		return true;
+		return true
 	}
 }
 func AuthInterceptor(c *revel.Controller) revel.Result {
 	// 全部变成首字大写
 	/*
-	var controller = strings.Title(c.Name)
-	var method = strings.Title(c.MethodName)
-	// 是否需要验证?
-	if !needValidate(controller, method) {
-		return nil
-	}
+		var controller = strings.Title(c.Name)
+		var method = strings.Title(c.MethodName)
+		// 是否需要验证?
+		if !needValidate(controller, method) {
+			return nil
+		}
 	*/
-	
+
 	// 验证是否已登录
 	// 必须是管理员
-	if username, ok := c.Session["Username"]; ok && username == adminUsername {
+	if username, ok := c.Session["Username"]; ok && username.(string) == configService.GetAdminUsername() {
 		return nil // 已登录
 	}
-	
+
 	// 没有登录, 判断是否是ajax操作
 	if c.Request.Header.Get("X-Requested-With") == "XMLHttpRequest" {
 		re := info.NewRe()
 		re.Msg = "NOTLOGIN"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
+
 	return c.Redirect("/login")
 }
 
@@ -111,7 +111,7 @@ func InitService() {
 	tokenService = service.TokenS
 	noteImageService = service.NoteImageS
 	fileService = service.FileS
-	albumService= service.AlbumS
+	albumService = service.AlbumS
 	attachService = service.AttachS
 	pwdService = service.PwdS
 	suggestionService = service.SuggestionS
@@ -129,4 +129,4 @@ func init() {
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &AdminEmail{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &AdminUpgrade{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &AdminData{})
-}
+}

app/controllers/api/API列表-v0.1.md

@@ -0,0 +1,465 @@
+# API 列表
+
+## 前言
+
+### api url
+
+所有api的url前面带/api/, 如:
+
+`/api/user/info?userId=xxxx&token=xxxx`
+
+除了/auth/login, /auth/register外其它的都需要另外带参数token=xxxx
+
+### 文件目录结构
+* 所有API的Controller都在app/api文件夹下
+* 文件命名: Api功能Controller.go, 如ApiUserController.go
+* 结构体命名为 Api功能, 如ApiUser
+* API公用Controller: ApiBaseController
+* init.go 注入service和定义拦截器
+
+### 流程
+用户登录后返回一个token, 以后所有的请求都携带该token. 
+在init.go中的拦截器会得到token并调用sessionService判断是否登录了 
+
+## 返回值结构
+* 全部返回JSON, JSON, 除二进制文件(图片, 附件外), 如果返回其它非JSON格式的值, 肯定是出错了
+* 错误信息全部返回 {Ok: false, Msg: "相应的错误信息"}
+* 正确信息返回分两种:
+1. 一些操作型的api, 比如updateUsername, updateLogo之类的, 成功后返回 {Ok: true, Msg:""}
+2. 一些获取型api, 如getNote, 全部返回真实的返回数据, 如返回笔记:
+```
+{
+  "NoteId": "54bdc7e305fcd13ea3000000",
+  "NotebookId": "54bdc65599c37b0da9000003",
+  "UserId": "54bdc65599c37b0da9000002",
+  "Title": "笔记标题",
+  "Desc": "",
+  "Tags": null,
+  "Abstract": "",
+  "Content": "",
+  "IsMarkdown": false,
+  "IsBlog": false,
+  "IsTrash": true,
+  "IsDeleted": false,
+  "Usn": 15,
+  "Files": [],
+  "CreatedTime": "2015-01-20T11:13:41.34+08:00",
+  "UpdatedTime": "2015-01-20T11:13:41.34+08:00",
+  "PublicTime": "0001-01-01T00:00:00Z"
+}
+```
+* 时间类型全是返回如 "2015-01-20T11:13:41.34+08:00" 的格式, (因为golang的time转成Json就是这样, 历史原因)
+
+-----------------
+
+## Auth 登录与注册
+
+### /auth/login 登录 
+
+```
+参数: email, pwd
+Method: GET
+返回: 
+错误: {"Ok":false, "Msg":"用户名或密码有误"}
+正确: 比如:
+{
+	"Ok":true,
+	"Token":"5500830738f41138e90003232",
+	"UserId":"52d26b4e99c37b609a000001",
+	"Email":"leanote@leanote.com",
+	"Username":"leanote"
+}
+```
+
+登录成功后将使用token作为之后的请求
+
+### /auth/logout 注销
+```
+参数: token
+Method: GET
+返回:
+错误: {Ok: false, Msg: ""}
+成功: {Ok: true, Msg: ""}
+```
+
+### /auth/register 注册
+```
+参数: email, pwd
+Method: POST
+返回:
+错误: {Ok: false, Msg: ""}
+成功: {Ok: true, Msg: ""}
+```
+
+## User 用户
+### /user/info 获取用户信息
+```
+参数: userId
+Method: GET
+返回:
+错误: {Ok: false, Msg: ""}
+成功: type.User
+```
+
+### /user/updateUsername 修改用户名
+```
+参数: username(新用户名)
+Method: POST
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: {Ok: true, Msg: ""}
+```
+
+### /user/updatePwd 修改密码
+```
+参数: oldPwd(旧密码), pwd(新密码)
+Method: POST
+返回:
+错误: {Ok: false, Msg: ""}
+成功: {Ok: true, Msg: ""}
+```
+
+### /user/updateLogo 修改头像
+```
+参数: file(文件)
+Method: POST
+返回:
+错误: {Ok: false, Msg: ""}
+成功: {Ok: true, Msg: ""}
+```
+
+### /user/getSyncState 获取最新同步状态
+```
+参数: 无
+Method: POST
+返回:
+错误: {Ok: false, Msg: ""}
+成功: {LastSyncUsn: 3232, LastSyncTime: "上次同步时间"(暂时无用)}
+```
+
+-----
+
+## Notebook 笔记本
+
+### /notebook/getSyncNotebooks 得到需要同步的笔记本 
+```
+参数: afterUsn(int, 在此usn后的笔记本是需要同步的), maxEntry(int, 最大要同步的量)
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: [type.Notebook] 数组
+```
+
+### /notebook/getNotebooks 得到所有笔记本 
+```
+无参数
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: [type.Notebook] 数组
+```
+
+### /notebook/addNotebook 添加笔记本
+```
+参数: title(string), parentNotebookId(string, 父notebookId, 可空), seq(int) 排列
+Method: POST
+返回: 
+错误: {Ok: false, Msg:""}
+成功: type.Notebook
+```
+
+### /notebook/updateNotebook 修改笔记本
+```
+参数: notebookId, title, parentNotebookId, seq(int), usn(int)
+Method: POST
+返回: 
+错误: {Ok: false, msg: ""} msg == "conflict" 表示冲突
+成功: type.Notebook
+```
+
+### /notebook/deleteNotebook 删除笔记本
+```
+参数: notebookId, usn(int)
+Method: GET
+返回: 
+错误: {Ok: false, msg: ""} msg == "conflict" 表示冲突
+成功: {Ok: true}
+```
+
+----
+
+## Note 笔记
+
+
+### /note/getSyncNotes 获取需要同步的笔记
+```
+参数: afterUsn(int, 在此usn后的笔记是需要同步的), maxEntry(int, 最大要同步的量)
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: [type.Note] 数组, 笔记不包含Abstract和Content
+```
+
+
+### /note/getNotes 获得某笔记本下的笔记(无内容)
+```
+参数: notebookId
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: [type.Note] 数组, 笔记不包含Abstract和Content
+```
+
+### /note/getNoteAndContent 获得笔记与内容
+```
+参数: noteId
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: type.Note
+```
+
+### /note/getNoteContent 获得笔记内容
+```
+参数: noteId
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: type.NoteContent
+```
+
+### /note/addNote 添加笔记
+```
+参数: (注意首字大写)
+	NotebookId string 必传
+	Title string 必传
+	Tags []string 可选
+	Content string 必传
+	Abstract string 可选, 当是markdown笔记时必须传
+	IsMarkdown bool 可选
+	Files []type.NoteFiles 数组  可选
+Method: POST
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: type.Note, 不包含Abstract, Content
+```
+
+** 关于笔记中的图片/附件**
+客户端应该添加一个"图片/附件表"来存元数据, 图片应该要缓存到本地, 附件可在需要的时候再调用相应api获取.
+
+Content中的数据, 图片,附件在Leanote的链接是, 所以, 不管你在本地的笔记中是以什么形式来保存图片,附件的链接的,请addNote和updateNote时务必将链接修改成leanote服务器上的链接.
+http://leanote.com/api/file/getImage?fileId=xx
+单个附件: 
+http://leanote.com/api/file/getAttach?fileId=xx 
+所有附件:
+http://leanote.com/api/file/getAllAttachs?noteId=xxx 
+
+**注意:**
+addNote时必须要把Files, 和相关的图片/附件一起传到服务器中
+其中Files(文件的元数据)和其它字段以POST方式传出, 而真正数据则以http的multipart传入, 每个文件的name为"FileDatas[LocalFileId]"
+
+图片在笔记内的链接必须为: http://leanote.com/api/file/getImage?fileId=LocalFileId或FileId
+附件如果插入到了笔记内容内, 其链接必须为: http://leanote.com/api/file/getAttach?fileId=LocalFileId或FileId
+其中, fileId为文件在本地的LocalFileId或服务器上的FileId
+
+服务器端会生成FileId传给Client. Client在本地必须要建立LocalFileId与FileId的关联.
+
+如果笔记内容传了, 且笔记内有图片, 则必须要传Files 文件元数据, 因为Server端还要对内容内的图片, 附件链接进行修改, 可能你传过去的是LocalFileId, 服务器端会将LocalFileId替换成FileId存到数据库中.
+
+同样适用于 updateNote
+
+http://leanote.com 不绝对, 因为用户可以自建服务, 所以在开发时需要可配置
+
+### /note/updateNote 更新笔记
+
+当更新了笔记某个属性时, 只要传某个属性就行, 其它不用传, 比如把笔记拉入了trash, 那么就传IsTrash: true
+
+```
+参数: (注意首字大写)
+	NoteId string 必传
+	Usn int 必传
+	NotebookId string 可选
+	Title string 可选
+	Tags []string 可选
+	Content string 可选
+	Abstract string 可选, 当是markdown笔记时必须传
+	IsMarkdown bool 可选	
+	IsTrash bool 是否是trash 可选
+	Files []type.NoteFiles 数组  可选
+Method: POST
+返回: 
+错误: {Ok: false, msg: ''} msg == 'conflict' 表示冲突
+成功: type.Note, 不包含Abstract和Content
+```
+
+### /note/deleteTrash 彻底删除笔记
+```
+参数: noteId, usn
+Method: GET
+返回: 
+错误: {Ok: false, msg: ''} msg == 'conflict' 表示冲突
+成功: type.UpdateRet
+```
+
+-------
+
+## Tag 标签
+
+### /tag/getSyncTags 获取需要同步的标签
+```
+参数: afterUsn(int, 在此usn后的标签是需要同步的), maxEntry(int, 最大要同步的量)
+Method: GET
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: [type.Tag] 数组
+```
+
+### /tag/addTag 添加标签
+```
+参数: tag(string)
+Method: POST
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: type.Tag
+```
+
+### /tag/deleteTag 删除标签 
+```
+参数: tag(string)
+Method: POST
+返回: 
+错误: {Ok: false, Msg: ""}
+成功: type.UpdateRet
+```
+
+### File 文件(获取图片, 附件)
+
+### /file/getImage 获取图片
+```
+参数: fileId
+Method: GET
+返回: 
+错误: 非二进制文件数据
+成功: 二进制文件
+```
+
+### /file/getAttach 获取附件
+```
+参数: fileId
+Method: GET
+返回: 
+错误: 非二进制文件数据
+成功: 二进制文件
+```
+
+### /file/getAllAttachs 获取所有附件
+```
+参数: noteId
+Method: GET
+返回: 
+错误: 非二进制文件数据
+成功: 二进制文件
+```
+
+--------
+
+## 数据类型
+
+### type.User 用户信息
+
+```
+User {
+	UserId  string
+	Username string
+	Email string
+	Verified bool
+	Logo string
+}
+```
+
+### type.Notebook 笔记本
+
+```
+Notebook {
+	NotebookId        
+	UserId           
+	ParentNotebookId // 上级
+	Seq              int // 排序
+	Title            string 
+	IsBlog           bool  
+	IsDeleted	 bool
+	CreatedTime      time.Time   
+	UpdatedTime      time.Time 
+	
+	// 更新序号
+	Usn int  // UpdateSequenceNum 
+}
+```
+
+### type.Note 笔记
+```
+Note {
+	NoteId     string
+	NotebookId string
+	UserId     string
+	Title      string
+	Tags       []string
+	Content    string
+	IsMarkdown bool
+	IsBlog     bool 
+	IsTrash bool
+	Files []NoteFile // 图片, 附件
+	CreatedTime time.Time
+	UpdatedTime time.Time
+	PublicTime time.Time
+	
+	// 更新序号
+	Usn int
+}
+```
+
+### type.NoteContent 笔记内容
+```
+NoteContent {
+	NoteId string
+	UserId string
+	Content string
+}
+```
+
+### type.NoteFile 笔记文件(图片,附件)
+```
+NoteFile {
+	FileId string // 服务器端Id
+	LocalFileId string // 客户端Id
+	Type string // images/png, doc, xls, 根据fileName确定
+	Title string
+	HasBody bool // 传过来的值是否要更新内容, 如果有true, 则必须传文件
+	IsAttach bool // 是否是附件, 不是附件就是图片
+}
+```
+
+### type.Tag 标签
+```
+Tag {
+	TagId string
+	UserId string
+	Tag string 
+	CreatedTime
+	UpdatedTime
+	IsDeleted bool  // 删除位
+	// 更新序号
+	Usn 
+}
+```
+
+### type.UpdateRe 更新后返回的值, 包含Usn
+```
+ReUpdate {
+	Ok bool
+	Msg string
+	
+	// 更新序号
+	Usn int
+}
+```

app/controllers/api/API设计-v0.1.md

@@ -0,0 +1,47 @@
+# API设计
+
+By life (life@leanote.com)
+
+## api url
+
+所有api的url前面带/api/, 如:
+
+`/api/user/info?userId=xxxx&token=xxxx`
+
+## 文件目录结构
+* 所有API的Controller都在app/api文件夹下
+* 文件命名: Api功能Controller.go, 如ApiUserController.go
+* 结构体命名为 Api功能, 如ApiUser
+* API公用Controller: ApiBaseController
+* init.go 注入service和定义拦截器
+
+## 流程
+用户登录后返回一个token, 以后所有的请求都携带该token. 
+在init.go中的拦截器会得到token并调用sessionService判断是否登录了 
+
+## 返回值结构
+* 全部返回JSON, JSON, 除二进制文件(图片, 附件外), 如果返回其它非JSON格式的值, 肯定是出错了
+* 错误信息全部返回 {Ok: false, Msg: ""}
+* 正确信息全部返回真实的返回数据, 如返回笔记:
+```
+{
+  "NoteId": "54bdc7e305fcd13ea3000000",
+  "NotebookId": "54bdc65599c37b0da9000003",
+  "UserId": "54bdc65599c37b0da9000002",
+  "Title": "asdfads",
+  "Desc": "",
+  "Tags": null,
+  "Abstract": "",
+  "Content": "",
+  "IsMarkdown": false,
+  "IsBlog": false,
+  "IsTrash": true,
+  "IsDeleted": false,
+  "Usn": 15,
+  "Files": [],
+  "CreatedTime": "2015-01-20T11:13:41.34+08:00",
+  "UpdatedTime": "2015-01-20T11:13:41.34+08:00",
+  "PublicTime": "0001-01-01T00:00:00Z"
+}
+```
+* 时间类型全是返回如 "2015-01-20T11:13:41.34+08:00" 的格式, (因为golang的time转成Json就是这样, 历史原因)

app/controllers/api/ApiAuthController.go

@@ -0,0 +1,69 @@
+package api
+
+import (
+	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	"gopkg.in/mgo.v2/bson"
+	//	"strconv"
+)
+
+// 用户登录后生成一个token, 将这个token保存到session中
+// 以后每次的请求必须带这个token, 并从session中获取userId
+
+// 用户登录/注销/找回密码
+
+type ApiAuth struct {
+	ApiBaseContrller
+}
+
+// 登录
+// [ok]
+// 成功返回 {Ok: true, Item: token }
+// 失败返回 {Ok: false, Msg: ""}
+func (c ApiAuth) Login(email, pwd string) revel.Result {
+	var msg = ""
+
+	userInfo, err := authService.Login(email, pwd)
+	if err == nil {
+		token := bson.NewObjectId().Hex()
+		sessionService.SetUserId(token, userInfo.UserId.Hex())
+		return c.RenderJSON(info.AuthOk{Ok: true, Token: token, UserId: userInfo.UserId, Email: userInfo.Email, Username: userInfo.Username})
+	} else {
+		// 登录错误, 则错误次数++
+		msg = "wrongUsernameOrPassword"
+	}
+	return c.RenderJSON(info.ApiRe{Ok: false, Msg: c.Message(msg)})
+}
+
+// 注销
+// [Ok]
+func (c ApiAuth) Logout() revel.Result {
+	token := c.getToken()
+	sessionService.Clear(token)
+	re := info.NewApiRe()
+	re.Ok = true
+	return c.RenderJSON(re)
+}
+
+// 注册
+// [Ok]
+// 成功后并不返回用户ID, 需要用户重新登录
+func (c ApiAuth) Register(email, pwd string) revel.Result {
+	re := info.NewApiRe()
+	if !configService.IsOpenRegister() {
+		re.Msg = "notOpenRegister" // 未开放注册
+		return c.RenderJSON(re)
+	}
+
+	if re.Ok, re.Msg = Vd("email", email); !re.Ok {
+		return c.RenderJSON(re)
+	}
+	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
+		return c.RenderJSON(re)
+	}
+
+	// 注册
+	re.Ok, re.Msg = authService.Register(email, pwd, "")
+	return c.RenderJSON(re)
+}

app/controllers/api/ApiBaseController.go

@@ -0,0 +1,203 @@
+package api
+
+import (
+	"github.com/revel/revel"
+	"gopkg.in/mgo.v2/bson"
+	//	"encoding/json"
+	"github.com/leanote/leanote/app/controllers"
+	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"os"
+	//	"fmt"
+	"io/ioutil"
+	//	"fmt"
+	//	"math"
+	//	"strconv"
+	"strings"
+)
+
+// 公用Controller, 其它Controller继承它
+type ApiBaseContrller struct {
+	controllers.BaseController // 不能用*BaseController
+}
+
+// 得到token, 这个token是在AuthInterceptor设到Session中的
+func (c ApiBaseContrller) getToken() string {
+	return c.GetSession("_token")
+}
+
+// userId
+// _userId是在AuthInterceptor设置的
+func (c ApiBaseContrller) getUserId() string {
+	return c.GetSession("_userId")
+}
+
+// 得到用户信息
+func (c ApiBaseContrller) getUserInfo() info.User {
+	userId := c.GetSession("_userId")
+	if userId == "" {
+		return info.User{}
+	}
+	return userService.GetUserInfo(userId)
+}
+
+// 上传附件
+func (c ApiBaseContrller) uploadAttach(name string, noteId string) (ok bool, msg string, id string) {
+	userId := c.getUserId()
+
+	// 判断是否有权限为笔记添加附件
+	// 如果笔记还没有添加是不是会有问题
+	/*
+		if !shareService.HasUpdateNotePerm(noteId, userId) {
+			return
+		}
+	*/
+
+	var data []byte
+	c.Params.Bind(&data, name)
+	handel := c.Params.Files[name][0]
+	if data == nil || len(data) == 0 {
+		return
+	}
+
+	// file, handel, err := c.Request.FormFile(name)
+	// if err != nil {
+	// 	return
+	// }
+	// defer file.Close()
+
+	// data, err := ioutil.ReadAll(file)
+	// if err != nil {
+	// 	return
+	// }
+	// > 5M?
+	maxFileSize := configService.GetUploadSize("uploadAttachSize")
+	if maxFileSize <= 0 {
+		maxFileSize = 1000
+	}
+	if float64(len(data)) > maxFileSize*float64(1024*1024) {
+		msg = "fileIsTooLarge"
+		return
+	}
+
+	// 生成上传路径
+	newGuid := NewGuid()
+	//	filePath :=	"files/" + Digest3(userId) + "/" + userId + "/" + Digest2(newGuid) + "/attachs"
+	filePath := "files/" + GetRandomFilePath(userId, newGuid) + "/attachs"
+
+	dir := revel.BasePath + "/" + filePath
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		return
+	}
+	// 生成新的文件名
+	filename := handel.Filename
+	_, ext := SplitFilename(filename) // .doc
+	filename = newGuid + ext
+	toPath := dir + "/" + filename
+	err = ioutil.WriteFile(toPath, data, 0777)
+	if err != nil {
+		return
+	}
+
+	// add File to db
+	fileType := ""
+	if ext != "" {
+		fileType = strings.ToLower(ext[1:])
+	}
+	filesize := GetFilesize(toPath)
+	fileInfo := info.Attach{AttachId: bson.NewObjectId(),
+		Name:         filename,
+		Title:        handel.Filename,
+		NoteId:       bson.ObjectIdHex(noteId),
+		UploadUserId: bson.ObjectIdHex(userId),
+		Path:         filePath + "/" + filename,
+		Type:         fileType,
+		Size:         filesize}
+
+	ok, msg = attachService.AddAttach(fileInfo, true)
+	if !ok {
+		return
+	}
+
+	id = fileInfo.AttachId.Hex()
+	return
+}
+
+// 上传图片
+func (c ApiBaseContrller) upload(name string, noteId string, isAttach bool) (ok bool, msg string, id string) {
+	if isAttach {
+		return c.uploadAttach(name, noteId)
+	}
+	// file, handel, err := c.Request.FormFile(name)
+	// if err != nil {
+	// 	return
+	// }
+	// defer file.Close()
+
+	var data []byte
+	c.Params.Bind(&data, name)
+	handel := c.Params.Files[name][0]
+	if data == nil || len(data) == 0 {
+		return
+	}
+
+	newGuid := NewGuid()
+	// 生成上传路径
+	userId := c.getUserId()
+	// fileUrlPath := "files/" + Digest3(userId) + "/" + userId + "/" + Digest2(newGuid) + "/images"
+	fileUrlPath := "files/" + GetRandomFilePath(userId, newGuid) + "/images"
+
+	dir := revel.BasePath + "/" + fileUrlPath
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		return
+	}
+	// 生成新的文件名
+	filename := handel.Filename
+	_, ext := SplitFilename(filename)
+	// if ext != ".gif" && ext != ".jpg" && ext != ".png" && ext != ".bmp" && ext != ".jpeg" {
+	// 	msg = "notImage"
+	// 	return
+	// }
+
+	filename = newGuid + ext
+	// data, err := ioutil.ReadAll(file)
+	// if err != nil {
+	// 	return
+	// }
+
+	maxFileSize := configService.GetUploadSize("uploadImageSize")
+	if maxFileSize <= 0 {
+		maxFileSize = 1000
+	}
+
+	// > 2M?
+	if float64(len(data)) > maxFileSize*float64(1024*1024) {
+		msg = "fileIsTooLarge"
+		return
+	}
+
+	toPath := dir + "/" + filename
+	err = ioutil.WriteFile(toPath, data, 0777)
+	if err != nil {
+		return
+	}
+	// 改变成gif图片
+	_, toPathGif := TransToGif(toPath, 0, true)
+	filename = GetFilename(toPathGif)
+	filesize := GetFilesize(toPathGif)
+	fileUrlPath += "/" + filename
+
+	// File
+	fileInfo := info.File{FileId: bson.NewObjectId(),
+		Name:  filename,
+		Title: handel.Filename,
+		Path:  fileUrlPath,
+		Size:  filesize}
+	ok, msg = fileService.AddImage(fileInfo, "", c.getUserId(), true)
+	if ok {
+		id = fileInfo.FileId.Hex()
+	}
+	return
+}

app/controllers/api/ApiFileController.go

@@ -0,0 +1,163 @@
+package api
+
+import (
+	"github.com/revel/revel"
+	//	"encoding/json"
+	//	. "github.com/leanote/leanote/app/lea"
+	//	"gopkg.in/mgo.v2/bson"
+	//	"github.com/leanote/leanote/app/lea/netutil"
+	//	"github.com/leanote/leanote/app/info"
+	//	"io/ioutil"
+	"os"
+	//	"strconv"
+	"archive/tar"
+	"compress/gzip"
+	"io"
+	"strings"
+	"time"
+)
+
+// 文件操作, 图片, 头像上传, 输出
+
+type ApiFile struct {
+	ApiBaseContrller
+}
+
+/*
+// 协作时复制图片到owner
+func (c ApiFile) CopyImage(userId, fileId, toUserId string) revel.Result {
+	re := info.NewRe()
+
+	re.Ok, re.Id = fileService.CopyImage(userId, fileId, toUserId)
+
+	return c.RenderJSON(re)
+}
+
+// get all images by userId with page
+func (c ApiFile) GetImages(albumId, key string, page int) revel.Result {
+	imagesPage := fileService.ListImagesWithPage(c.getUserId(), albumId, key, page, 12)
+	re := info.NewRe()
+	re.Ok = true
+	re.Item = imagesPage
+	return c.RenderJSON(re)
+}
+
+func (c ApiFile) UpdateImageTitle(fileId, title string) revel.Result {
+	re := info.NewRe()
+	re.Ok = fileService.UpdateImageTitle(c.getUserId(), fileId, title)
+	return c.RenderJSON(re)
+}
+
+func (c ApiFile) DeleteImage(fileId string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = fileService.DeleteImage(c.getUserId(), fileId)
+	return c.RenderJSON(re)
+}
+
+*/
+
+//-----------
+
+// 输出image
+// [OK]
+func (c ApiFile) GetImage(fileId string) revel.Result {
+	path := fileService.GetFile(c.getUserId(), fileId) // 得到路径
+	if path == "" {
+		return c.RenderText("")
+	}
+	fn := revel.BasePath + "/" + strings.TrimLeft(path, "/")
+	file, _ := os.Open(fn)
+	return c.RenderFile(file, revel.Inline) // revel.Attachment
+}
+
+// 下载附件
+// [OK]
+func (c ApiFile) GetAttach(fileId string) revel.Result {
+	attach := attachService.GetAttach(fileId, c.getUserId()) // 得到路径
+	path := attach.Path
+	if path == "" {
+		return c.RenderText("No Such File")
+	}
+	fn := revel.BasePath + "/" + strings.TrimLeft(path, "/")
+	file, _ := os.Open(fn)
+	return c.RenderBinary(file, attach.Title, revel.Attachment, time.Now()) // revel.Attachment
+}
+
+// 下载所有附件
+// [OK]
+func (c ApiFile) GetAllAttachs(noteId string) revel.Result {
+	note := noteService.GetNoteById(noteId)
+	if note.NoteId == "" {
+		return c.RenderText("")
+	}
+	// 得到文件列表
+	attachs := attachService.ListAttachs(noteId, c.getUserId())
+	if attachs == nil || len(attachs) == 0 {
+		return c.RenderText("")
+	}
+
+	/*
+		dir := revel.BasePath + "/files/tmp"
+		err := os.MkdirAll(dir, 0755)
+		if err != nil {
+			return c.RenderText("")
+		}
+	*/
+
+	filename := note.Title + ".tar.gz"
+	if note.Title == "" {
+		filename = "all.tar.gz"
+	}
+
+	// file write
+	fw, err := os.Create(revel.BasePath + "/files/" + filename)
+	if err != nil {
+		return c.RenderText("")
+	}
+	// defer fw.Close() // 不需要关闭, 还要读取给用户下载
+
+	// gzip write
+	gw := gzip.NewWriter(fw)
+	defer gw.Close()
+
+	// tar write
+	tw := tar.NewWriter(gw)
+	defer tw.Close()
+
+	// 遍历文件列表
+	for _, attach := range attachs {
+		fn := revel.BasePath + "/" + strings.TrimLeft(attach.Path, "/")
+		fr, err := os.Open(fn)
+		fileInfo, _ := fr.Stat()
+		if err != nil {
+			return c.RenderText("")
+		}
+		defer fr.Close()
+
+		// 信息头
+		h := new(tar.Header)
+		h.Name = attach.Title
+		h.Size = fileInfo.Size()
+		h.Mode = int64(fileInfo.Mode())
+		h.ModTime = fileInfo.ModTime()
+
+		// 写信息头
+		err = tw.WriteHeader(h)
+		if err != nil {
+			panic(err)
+		}
+
+		// 写文件
+		_, err = io.Copy(tw, fr)
+		if err != nil {
+			panic(err)
+		}
+	} // for
+
+	//    tw.Close()
+	//    gw.Close()
+	//    fw.Close()
+	//    file, _ := os.Open(dir + "/" + filename)
+	// fw.Seek(0, 0)
+	return c.RenderBinary(fw, filename, revel.Attachment, time.Now()) // revel.Attachment
+}

app/controllers/api/ApiNoteController.go

@@ -0,0 +1,642 @@
+package api
+
+import (
+	"github.com/revel/revel"
+	//	"encoding/json"
+	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"gopkg.in/mgo.v2/bson"
+	"os"
+	"os/exec"
+	// "strings"
+	"time"
+	"regexp"
+	//	"github.com/leanote/leanote/app/types"
+	//	"io/ioutil"
+	//	"fmt"
+	//	"bytes"
+	//	"os"
+)
+
+// 笔记API
+
+type ApiNote struct {
+	ApiBaseContrller
+}
+
+// 获取同步的笔记
+// > afterUsn的笔记
+// 无Desc, Abstract, 有Files
+/*
+  {
+    "NoteId": "55195fa199c37b79be000005",
+    "NotebookId": "55195fa199c37b79be000002",
+    "UserId": "55195fa199c37b79be000001",
+    "Title": "Leanote语法Leanote语法Leanote语法Leanote语法Leanote语法",
+    "Desc": "",
+    "Tags": null,
+    "Abstract": "",
+    "Content": "",
+    "IsMarkdown": true,
+    "IsBlog": false,
+    "IsTrash": false,
+    "Usn": 5,
+    "Files": [],
+    "CreatedTime": "2015-03-30T22:37:21.695+08:00",
+    "UpdatedTime": "2015-03-30T22:37:21.724+08:00",
+    "PublicTime": "2015-03-30T22:37:21.695+08:00"
+  }
+*/
+func (c ApiNote) GetSyncNotes(afterUsn, maxEntry int) revel.Result {
+	if maxEntry == 0 {
+		maxEntry = 100
+	}
+	notes := noteService.GetSyncNotes(c.getUserId(), afterUsn, maxEntry)
+	return c.RenderJSON(notes)
+}
+
+// 得到笔记本下的笔记
+// [OK]
+func (c ApiNote) GetNotes(notebookId string) revel.Result {
+	if notebookId != "" && !bson.IsObjectIdHex(notebookId) {
+		re := info.NewApiRe()
+		re.Msg = "notebookIdInvalid"
+		return c.RenderJSON(re)
+	}
+	_, notes := noteService.ListNotes(c.getUserId(), notebookId, false, c.GetPage(), pageSize, defaultSortField, false, false)
+	return c.RenderJSON(noteService.ToApiNotes(notes))
+}
+
+// 得到trash
+// [OK]
+func (c ApiNote) GetTrashNotes() revel.Result {
+	_, notes := noteService.ListNotes(c.getUserId(), "", true, c.GetPage(), pageSize, defaultSortField, false, false)
+	return c.RenderJSON(noteService.ToApiNotes(notes))
+
+}
+
+// get Note
+// [OK]
+/*
+{
+  "NoteId": "550c0bee2ec82a2eb5000000",
+  "NotebookId": "54a1676399c37b1c77000004",
+  "UserId": "54a1676399c37b1c77000002",
+  "Title": "asdfadsf--=",
+  "Desc": "",
+  "Tags": [
+  ],
+  "Abstract": "",
+  "Content": "",
+  "IsMarkdown": false,
+  "IsBlog": false,
+  "IsTrash": false,
+  "Usn": 8,
+  "Files": [
+    {
+      "FileId": "551975d599c37b970f000000",
+      "LocalFileId": "",
+      "Type": "",
+      "Title": "",
+      "HasBody": false,
+      "IsAttach": false
+    },
+    {
+      "FileId": "551975de99c37b970f000001",
+      "LocalFileId": "",
+      "Type": "doc",
+      "Title": "李铁-print-en.doc",
+      "HasBody": false,
+      "IsAttach": true
+    },
+    {
+      "FileId": "551975de99c37b970f000002",
+      "LocalFileId": "",
+      "Type": "doc",
+      "Title": "李铁-print.doc",
+      "HasBody": false,
+      "IsAttach": true
+    }
+  ],
+  "CreatedTime": "2015-03-20T20:00:52.463+08:00",
+  "UpdatedTime": "2015-03-31T00:12:44.967+08:00",
+  "PublicTime": "2015-03-20T20:00:52.463+08:00"
+}
+*/
+func (c ApiNote) GetNote(noteId string) revel.Result {
+	if !bson.IsObjectIdHex(noteId) {
+		re := info.NewApiRe()
+		re.Msg = "noteIdInvalid"
+		return c.RenderJSON(re)
+	}
+
+	note := noteService.GetNote(noteId, c.getUserId())
+	if note.NoteId == "" {
+		re := info.NewApiRe()
+		re.Msg = "notExists"
+		return c.RenderJSON(re)
+	}
+	apiNotes := noteService.ToApiNotes([]info.Note{note})
+	return c.RenderJSON(apiNotes[0])
+}
+
+// 得到note和内容
+// [OK]
+func (c ApiNote) GetNoteAndContent(noteId string) revel.Result {
+	noteAndContent := noteService.GetNoteAndContent(noteId, c.getUserId())
+
+	apiNotes := noteService.ToApiNotes([]info.Note{noteAndContent.Note})
+	apiNote := apiNotes[0]
+	apiNote.Content = noteService.FixContent(noteAndContent.Content, noteAndContent.IsMarkdown)
+	return c.RenderJSON(apiNote)
+}
+
+// content里的image, attach链接是
+// https://leanote.com/api/file/getImage?fileId=xx
+// https://leanote.com/api/file/getAttach?fileId=xx
+// 将fileId=映射成ServerFileId, 这里的fileId可能是本地的FileId
+func (c ApiNote) fixPostNotecontent(noteOrContent *info.ApiNote) {
+	if noteOrContent.Content == "" {
+		return
+	}
+
+	files := noteOrContent.Files
+	if files != nil && len(files) > 0 {
+		for _, file := range files {
+			if file.LocalFileId != "" {
+				LogJ(file)
+				if !file.IsAttach {
+					// <img src="https://"
+					// ![](http://demo.leanote.top/api/file/getImage?fileId=5863219465b68e4fd5000001)
+					reg, _ := regexp.Compile(`https*://[^/]*?/api/file/getImage\?fileId=`+file.LocalFileId)
+					// Log(reg)
+					noteOrContent.Content = reg.ReplaceAllString(noteOrContent.Content, `/api/file/getImage?fileId=`+file.FileId)  
+
+					// // "http://a.com/api/file/getImage?fileId=localId" => /api/file/getImage?fileId=serverId
+					// noteOrContent.Content = strings.Replace(noteOrContent.Content, 
+					// 	baseUrl + "/api/file/getImage?fileId="+file.LocalFileId, 
+					// 	"/api/file/getImage?fileId="+file.FileId, -1)
+				} else {
+					reg, _ := regexp.Compile(`https*://[^/]*?/api/file/getAttach\?fileId=`+file.LocalFileId)
+					// Log(reg)
+					noteOrContent.Content = reg.ReplaceAllString(noteOrContent.Content, `/api/file/getAttach?fileId=`+file.FileId)  
+					/*
+					noteOrContent.Content = strings.Replace(noteOrContent.Content, 
+						baseUrl + "/api/file/getAttach?fileId="+file.LocalFileId, 
+						"/api/file/getAttach?fileId="+file.FileId, -1)
+					*/
+				}
+			}
+		}
+	}
+}
+
+// 得到内容
+func (c ApiNote) GetNoteContent(noteId string) revel.Result {
+	userId := c.getUserId()
+	note := noteService.GetNote(noteId, userId)
+	//	re := info.NewRe()
+	noteContent := noteService.GetNoteContent(noteId, userId)
+	if noteContent.Content != "" {
+		noteContent.Content = noteService.FixContent(noteContent.Content, note.IsMarkdown)
+	}
+
+	apiNoteContent := info.ApiNoteContent{
+		NoteId:  noteContent.NoteId,
+		UserId:  noteContent.UserId,
+		Content: noteContent.Content,
+	}
+
+	return c.RenderJSON(apiNoteContent)
+}
+
+// 添加笔记
+// [OK]
+func (c ApiNote) AddNote(noteOrContent info.ApiNote) revel.Result {
+	userId := bson.ObjectIdHex(c.getUserId())
+	re := info.NewRe()
+	myUserId := userId
+	// 为共享新建?
+	/*
+		if noteOrContent.FromUserId != "" {
+			userId = bson.ObjectIdHex(noteOrContent.FromUserId)
+		}
+	*/
+	//	Log(noteOrContent.Title)
+	//		LogJ(noteOrContent)
+
+	/*
+		LogJ(c.Params)
+		for name, _ := range c.Params.Files {
+			Log(name)
+			file, _, _ := c.Request.FormFile(name)
+			LogJ(file)
+		}
+	*/
+	//	return c.RenderJSON(re)
+	if noteOrContent.NotebookId == "" || !bson.IsObjectIdHex(noteOrContent.NotebookId) {
+		re.Msg = "notebookIdNotExists"
+		return c.RenderJSON(re)
+	}
+
+	noteId := bson.NewObjectId()
+	// TODO 先上传图片/附件, 如果不成功, 则返回false
+	//
+	attachNum := 0
+	if noteOrContent.Files != nil && len(noteOrContent.Files) > 0 {
+		for i, file := range noteOrContent.Files {
+			if file.HasBody {
+				if file.LocalFileId != "" {
+					// FileDatas[54c7ae27d98d0329dd000000]
+					ok, msg, fileId := c.upload("FileDatas["+file.LocalFileId+"]", noteId.Hex(), file.IsAttach)
+
+					if !ok {
+						re.Ok = false
+						if msg != "" {
+							Log(msg)
+							Log(file.LocalFileId)
+							re.Msg = "fileUploadError"
+						}
+						// 报不是图片的错误没关系, 证明客户端传来非图片的数据
+						if msg != "notImage" {
+							return c.RenderJSON(re)
+						}
+					} else {
+						// 建立映射
+						file.FileId = fileId
+						noteOrContent.Files[i] = file
+
+						if file.IsAttach {
+							attachNum++
+						}
+					}
+				} else {
+					return c.RenderJSON(re)
+				}
+			}
+		}
+	}
+
+	c.fixPostNotecontent(&noteOrContent)
+
+	//	Log("Add")
+	//	LogJ(noteOrContent)
+
+	//	return c.RenderJSON(re)
+
+	note := info.Note{UserId: userId,
+		NoteId:     noteId,
+		NotebookId: bson.ObjectIdHex(noteOrContent.NotebookId),
+		Title:      noteOrContent.Title,
+		Tags:       noteOrContent.Tags,
+		Desc:       noteOrContent.Desc,
+		//		ImgSrc:     noteOrContent.ImgSrc,
+		IsBlog:      noteOrContent.IsBlog,
+		IsMarkdown:  noteOrContent.IsMarkdown,
+		AttachNum:   attachNum,
+		CreatedTime: noteOrContent.CreatedTime,
+		UpdatedTime: noteOrContent.UpdatedTime,
+	}
+	noteContent := info.NoteContent{NoteId: note.NoteId,
+		UserId:      userId,
+		IsBlog:      note.IsBlog,
+		Content:     noteOrContent.Content,
+		Abstract:    noteOrContent.Abstract,
+		CreatedTime: noteOrContent.CreatedTime,
+		UpdatedTime: noteOrContent.UpdatedTime,
+	}
+
+	// 通过内容得到Desc, abstract
+	if noteOrContent.Abstract == "" {
+		note.Desc = SubStringHTMLToRaw(noteContent.Content, 200)
+		noteContent.Abstract = SubStringHTML(noteContent.Content, 200, "")
+	} else {
+		note.Desc = SubStringHTMLToRaw(noteContent.Abstract, 200)
+	}
+
+	note = noteService.AddNoteAndContentApi(note, noteContent, myUserId)
+
+	if note.NoteId == "" {
+		re.Ok = false
+		return c.RenderJSON(re)
+	}
+
+	// 添加需要返回的
+	noteOrContent.NoteId = note.NoteId.Hex()
+	noteOrContent.Usn = note.Usn
+	noteOrContent.CreatedTime = note.CreatedTime
+	noteOrContent.UpdatedTime = note.UpdatedTime
+	noteOrContent.UserId = c.getUserId()
+	noteOrContent.IsMarkdown = note.IsMarkdown
+	// 删除一些不要返回的, 删除Desc?
+	noteOrContent.Content = ""
+	noteOrContent.Abstract = ""
+	//	apiNote := info.NoteToApiNote(note, noteOrContent.Files)
+	return c.RenderJSON(noteOrContent)
+}
+
+// 更新笔记
+// [OK]
+func (c ApiNote) UpdateNote(noteOrContent info.ApiNote) revel.Result {
+	re := info.NewReUpdate()
+
+	noteUpdate := bson.M{}
+	needUpdateNote := false
+
+	noteId := noteOrContent.NoteId
+
+	if noteOrContent.NoteId == "" {
+		re.Msg = "noteIdNotExists"
+		return c.RenderJSON(re)
+	}
+
+	if noteOrContent.Usn <= 0 {
+		re.Msg = "usnNotExists"
+		return c.RenderJSON(re)
+	}
+
+	//	Log("_____________")
+	//	LogJ(noteOrContent)
+	/*
+		LogJ(c.Params.Files)
+		LogJ(c.Request.Header)
+		LogJ(c.Params.Values)
+	*/
+
+	// 先判断USN的问题, 因为很可能添加完附件后, 会有USN冲突, 这时附件就添错了
+	userId := c.getUserId()
+	note := noteService.GetNote(noteId, userId)
+	if note.NoteId == "" {
+		re.Msg = "notExists"
+		return c.RenderJSON(re)
+	}
+	if note.Usn != noteOrContent.Usn {
+		re.Msg = "conflict"
+		Log("conflict")
+		return c.RenderJSON(re)
+	}
+	Log("没有冲突")
+
+	// 如果传了files
+	// TODO 测试
+	/*
+		for key, v := range c.Params.Values {
+			Log(key)
+			Log(v)
+		}
+	*/
+	//	Log(c.Has("Files[0]"))
+	if c.Has("Files[0][LocalFileId]") {
+		//		LogJ(c.Params.Files)
+		if noteOrContent.Files != nil && len(noteOrContent.Files) > 0 {
+			for i, file := range noteOrContent.Files {
+				if file.HasBody {
+					if file.LocalFileId != "" {
+						// FileDatas[54c7ae27d98d0329dd000000]
+						ok, msg, fileId := c.upload("FileDatas["+file.LocalFileId+"]", noteId, file.IsAttach)
+						if !ok {
+							Log("upload file error")
+							re.Ok = false
+							if msg == "" {
+								re.Msg = "fileUploadError"
+							} else {
+								re.Msg = msg
+							}
+							return c.RenderJSON(re)
+						} else {
+							// 建立映射
+							file.FileId = fileId
+							noteOrContent.Files[i] = file
+						}
+					} else {
+						return c.RenderJSON(re)
+					}
+				}
+			}
+		}
+
+		//		Log("after upload")
+		//		LogJ(noteOrContent.Files)
+
+	}
+
+	// 移到外面来, 删除最后一个file时也要处理, 不然总删不掉
+	// 附件问题, 根据Files, 有些要删除的, 只留下这些
+	attachService.UpdateOrDeleteAttachApi(noteId, userId, noteOrContent.Files)
+
+	// Desc前台传来
+	if c.Has("Desc") {
+		needUpdateNote = true
+		noteUpdate["Desc"] = noteOrContent.Desc
+	}
+	/*
+		if c.Has("ImgSrc") {
+			needUpdateNote = true
+			noteUpdate["ImgSrc"] = noteOrContent.ImgSrc
+		}
+	*/
+	if c.Has("Title") {
+		needUpdateNote = true
+		noteUpdate["Title"] = noteOrContent.Title
+	}
+	if c.Has("IsTrash") {
+		needUpdateNote = true
+		noteUpdate["IsTrash"] = noteOrContent.IsTrash
+	}
+
+	// 是否是博客
+	if c.Has("IsBlog") {
+		needUpdateNote = true
+		noteUpdate["IsBlog"] = noteOrContent.IsBlog
+	}
+
+	/*
+		Log(c.Has("tags[0]"))
+		Log(c.Has("Tags[]"))
+		for key, v := range c.Params.Values {
+			Log(key)
+			Log(v)
+		}
+	*/
+
+	if c.Has("Tags[0]") {
+		needUpdateNote = true
+		noteUpdate["Tags"] = noteOrContent.Tags
+	}
+
+	if c.Has("NotebookId") {
+		if bson.IsObjectIdHex(noteOrContent.NotebookId) {
+			needUpdateNote = true
+			noteUpdate["NotebookId"] = bson.ObjectIdHex(noteOrContent.NotebookId)
+		}
+	}
+
+	if c.Has("Content") {
+		// 通过内容得到Desc, 如果有Abstract, 则用Abstract生成Desc
+		if noteOrContent.Abstract == "" {
+			noteUpdate["Desc"] = SubStringHTMLToRaw(noteOrContent.Content, 200)
+		} else {
+			noteUpdate["Desc"] = SubStringHTMLToRaw(noteOrContent.Abstract, 200)
+		}
+	}
+
+	noteUpdate["UpdatedTime"] = noteOrContent.UpdatedTime
+
+	afterNoteUsn := 0
+	noteOk := false
+	noteMsg := ""
+	if needUpdateNote {
+		noteOk, noteMsg, afterNoteUsn = noteService.UpdateNote(c.getUserId(), noteOrContent.NoteId, noteUpdate, noteOrContent.Usn)
+		if !noteOk {
+			re.Ok = false
+			re.Msg = noteMsg
+			return c.RenderJSON(re)
+		}
+	}
+
+	//-------------
+	afterContentUsn := 0
+	contentOk := false
+	contentMsg := ""
+	if c.Has("Content") {
+		// 把fileId替换下
+		c.fixPostNotecontent(&noteOrContent)
+		// 如果传了Abstract就用之
+		if noteOrContent.Abstract == "" {
+			noteOrContent.Abstract = SubStringHTML(noteOrContent.Content, 200, "")
+		}
+
+		//		Log("--------> afte fixed")
+		//		Log(noteOrContent.Content)
+		contentOk, contentMsg, afterContentUsn = noteService.UpdateNoteContent(c.getUserId(),
+			noteOrContent.NoteId,
+			noteOrContent.Content,
+			noteOrContent.Abstract,
+			needUpdateNote,
+			noteOrContent.Usn,
+			noteOrContent.UpdatedTime)
+	}
+
+	if needUpdateNote {
+		re.Ok = noteOk
+		re.Msg = noteMsg
+		re.Usn = afterNoteUsn
+	} else {
+		re.Ok = contentOk
+		re.Msg = contentMsg
+		re.Usn = afterContentUsn
+	}
+
+	if !re.Ok {
+		return c.RenderJSON(re)
+	}
+
+	noteOrContent.Content = ""
+	noteOrContent.Usn = re.Usn
+	noteOrContent.UpdatedTime = time.Now()
+
+	//	Log("after upload")
+	//	LogJ(noteOrContent.Files)
+	noteOrContent.UserId = c.getUserId()
+
+	return c.RenderJSON(noteOrContent)
+}
+
+// 删除trash
+func (c ApiNote) DeleteTrash(noteId string, usn int) revel.Result {
+	re := info.NewReUpdate()
+	re.Ok, re.Msg, re.Usn = trashService.DeleteTrashApi(noteId, c.getUserId(), usn)
+	return c.RenderJSON(re)
+}
+
+// 得到历史列表
+/*
+func (c ApiNote) GetHistories(noteId string) revel.Result {
+	re := info.NewRe()
+	histories := noteContentHistoryService.ListHistories(noteId, c.getUserId())
+	if len(histories) > 0 {
+		re.Ok = true
+		re.Item = histories
+	}
+	return c.RenderJSON(re)
+}
+*/
+
+// 0.2 新增
+// 导出成PDF
+func (c ApiNote) ExportPdf(noteId string) revel.Result {
+	re := info.NewApiRe()
+	userId := c.getUserId()
+	if noteId == "" {
+		re.Msg = "noteNotExists"
+		return c.RenderJSON(re)
+	}
+
+	note := noteService.GetNoteById(noteId)
+	if note.NoteId == "" {
+		re.Msg = "noteNotExists"
+		return c.RenderJSON(re)
+	}
+
+	noteUserId := note.UserId.Hex()
+	// 是否有权限
+	if noteUserId != userId {
+		// 是否是有权限协作的
+		if !note.IsBlog && !shareService.HasReadPerm(noteUserId, userId, noteId) {
+			re.Msg = "noteNotExists"
+			return c.RenderJSON(re)
+		}
+	}
+
+	// path 判断是否需要重新生成之
+	guid := NewGuid()
+	fileUrlPath := "files/export_pdf"
+	dir := revel.BasePath + "/" + fileUrlPath
+	if !MkdirAll(dir) {
+		re.Msg = "noDir"
+		return c.RenderJSON(re)
+	}
+	filename := guid + ".pdf"
+	path := dir + "/" + filename
+
+	appKey, _ := revel.Config.String("app.secretLeanote")
+	if appKey == "" {
+		appKey, _ = revel.Config.String("app.secret")
+	}
+
+	// 生成之
+	binPath := configService.GetGlobalStringConfig("exportPdfBinPath")
+	// 默认路径
+	if binPath == "" {
+		binPath = "/usr/local/bin/wkhtmltopdf"
+	}
+
+	url := configService.GetSiteUrl() + "/note/toPdf?noteId=" + noteId + "&appKey=" + appKey
+	var cc string
+	if note.IsMarkdown {
+		cc = binPath + " --lowquality --window-status done \"" + url + "\"  \"" + path + "\"" //  \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
+	} else {
+		cc = binPath + " --lowquality \"" + url + "\"  \"" + path + "\"" //  \"" + cookieDomain + "\" \"" + cookieName + "\" \"" + cookieValue + "\""
+	}
+
+	cmd := exec.Command("/bin/sh", "-c", cc)
+	_, err := cmd.Output()
+	if err != nil {
+		re.Msg = "sysError"
+		return c.RenderJSON(re)
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		re.Msg = "sysError"
+		return c.RenderJSON(re)
+	}
+
+	filenameReturn := note.Title
+	filenameReturn = FixFilename(filenameReturn)
+	if filenameReturn == "" {
+		filenameReturn = "Untitled.pdf"
+	} else {
+		filenameReturn += ".pdf"
+	}
+	return c.RenderBinary(file, filenameReturn, revel.Attachment, time.Now()) // revel.Attachment
+}

app/controllers/api/ApiNotebookController.go

@@ -0,0 +1,106 @@
+package api
+
+import (
+	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	"gopkg.in/mgo.v2/bson"
+	//	"io/ioutil"
+)
+
+// 笔记本API
+
+type ApiNotebook struct {
+	ApiBaseContrller
+}
+
+// 从Notebook -> ApiNotebook
+func (c ApiNotebook) fixNotebooks(notebooks []info.Notebook) []info.ApiNotebook {
+	if notebooks == nil {
+		return nil
+	}
+	apiNotebooks := make([]info.ApiNotebook, len(notebooks))
+	for i, notebook := range notebooks {
+		apiNotebooks[i] = c.fixNotebook(&notebook)
+	}
+	return apiNotebooks
+}
+func (c ApiNotebook) fixNotebook(notebook *info.Notebook) info.ApiNotebook {
+	if notebook == nil {
+		return info.ApiNotebook{}
+	}
+	return info.ApiNotebook{
+		NotebookId:       notebook.NotebookId,
+		UserId:           notebook.UserId,
+		ParentNotebookId: notebook.ParentNotebookId,
+		Seq:              notebook.Seq,
+		Title:            notebook.Title,
+		UrlTitle:         notebook.UrlTitle,
+		IsBlog:           notebook.IsBlog,
+		CreatedTime:      notebook.CreatedTime,
+		UpdatedTime:      notebook.UpdatedTime,
+		Usn:              notebook.Usn,
+		IsDeleted:        notebook.IsDeleted,
+	}
+}
+
+// 获取同步的笔记本
+// [OK]
+// > afterUsn的笔记
+// 返回 {ChunkHighUsn: 本下最大的usn, 借此可以知道是否还有, Notebooks: []}
+func (c ApiNotebook) GetSyncNotebooks(afterUsn, maxEntry int) revel.Result {
+	if maxEntry == 0 {
+		maxEntry = 100
+	}
+	notebooks := notebookService.GeSyncNotebooks(c.getUserId(), afterUsn, maxEntry)
+	return c.RenderJSON(c.fixNotebooks(notebooks))
+}
+
+// 得到用户的所有笔记本
+// [OK]
+// info.SubNotebooks
+func (c ApiNotebook) GetNotebooks() revel.Result {
+	notebooks := notebookService.GeSyncNotebooks(c.getUserId(), 0, 99999)
+	return c.RenderJSON(c.fixNotebooks(notebooks))
+}
+
+// 添加notebook
+// [OK]
+func (c ApiNotebook) AddNotebook(title, parentNotebookId string, seq int) revel.Result {
+	notebook := info.Notebook{NotebookId: bson.NewObjectId(),
+		Title:  title,
+		Seq:    seq,
+		UserId: bson.ObjectIdHex(c.getUserId())}
+	if parentNotebookId != "" && bson.IsObjectIdHex(parentNotebookId) {
+		notebook.ParentNotebookId = bson.ObjectIdHex(parentNotebookId)
+	}
+	re := info.NewRe()
+	re.Ok, notebook = notebookService.AddNotebook(notebook)
+	if !re.Ok {
+		return c.RenderJSON(re)
+	}
+	return c.RenderJSON(c.fixNotebook(&notebook))
+}
+
+// 修改笔记
+// [OK]
+func (c ApiNotebook) UpdateNotebook(notebookId, title, parentNotebookId string, seq, usn int) revel.Result {
+	re := info.NewApiRe()
+
+	ok, msg, notebook := notebookService.UpdateNotebookApi(c.getUserId(), notebookId, title, parentNotebookId, seq, usn)
+	if !ok {
+		re.Ok = false
+		re.Msg = msg
+		return c.RenderJSON(re)
+	}
+	LogJ(notebook)
+	return c.RenderJSON(c.fixNotebook(&notebook))
+}
+
+// 删除笔记本
+// [OK]
+func (c ApiNotebook) DeleteNotebook(notebookId string, usn int) revel.Result {
+	re := info.NewApiRe()
+	re.Ok, re.Msg = notebookService.DeleteNotebookForce(c.getUserId(), notebookId, usn)
+	return c.RenderJSON(re)
+}

app/controllers/api/ApiTagController.go

@@ -0,0 +1,56 @@
+package api
+
+import (
+	"github.com/leanote/leanote/app/info"
+	"github.com/revel/revel"
+	//	"gopkg.in/mgo.v2/bson"
+	//	. "github.com/leanote/leanote/app/lea"
+	//	"io/ioutil"
+)
+
+// 标签API
+
+type ApiTag struct {
+	ApiBaseContrller
+}
+
+// 获取同步的标签
+// [OK]
+// > afterUsn的笔记
+// 返回 {ChunkHighUsn: 本下最大的usn, 借此可以知道是否还有, Notebooks: []}
+func (c ApiTag) GetSyncTags(afterUsn, maxEntry int) revel.Result {
+	if maxEntry == 0 {
+		maxEntry = 100
+	}
+	tags := tagService.GeSyncTags(c.getUserId(), afterUsn, maxEntry)
+	return c.RenderJSON(tags)
+}
+
+// 添加Tag
+// [OK]
+// 不会产生冲突, 即使里面有
+// 返回
+/*
+{
+  "TagId": "551978dd99c37b9bc5000001",
+  "UserId": "54a1676399c37b1c77000002",
+  "Tag": "32",
+  "Usn": 25,
+  "Count": 1,
+  "CreatedTime": "2015-03-31T00:25:01.149312407+08:00",
+  "UpdatedTime": "2015-03-31T00:25:01.149312407+08:00",
+  "IsDeleted": false
+}
+*/
+func (c ApiTag) AddTag(tag string) revel.Result {
+	ret := tagService.AddOrUpdateTag(c.getUserId(), tag)
+	return c.RenderJSON(ret)
+}
+
+// 删除标签
+// [OK]
+func (c ApiTag) DeleteTag(tag string, usn int) revel.Result {
+	re := info.NewReUpdate()
+	re.Ok, re.Msg, re.Usn = tagService.DeleteTagApi(c.getUserId(), tag, usn)
+	return c.RenderJSON(re)
+}

app/controllers/api/ApiUserController.go

@@ -0,0 +1,161 @@
+package api
+
+import (
+	"github.com/revel/revel"
+	//	"encoding/json"
+	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"gopkg.in/mgo.v2/bson"
+	"time"
+	//	"github.com/leanote/leanote/app/types"
+	"io/ioutil"
+	//	"fmt"
+	//	"math"
+	"os"
+
+	//	"path"
+	//	"strconv"
+)
+
+type ApiUser struct {
+	ApiBaseContrller
+}
+
+// 获取用户信息
+// [OK]
+func (c ApiUser) Info() revel.Result {
+	re := info.NewApiRe()
+
+	userInfo := c.getUserInfo()
+	if userInfo.UserId == "" {
+		return c.RenderJSON(re)
+	}
+	apiUser := info.ApiUser{
+		UserId:   userInfo.UserId.Hex(),
+		Username: userInfo.Username,
+		Email:    userInfo.Email,
+		Logo:     userInfo.Logo,
+		Verified: userInfo.Verified,
+	}
+	return c.RenderJSON(apiUser)
+}
+
+// 修改用户名
+// [OK]
+func (c ApiUser) UpdateUsername(username string) revel.Result {
+	re := info.NewApiRe()
+	if c.GetUsername() == "demo" {
+		re.Msg = "cannotUpdateDemo"
+		return c.RenderJSON(re)
+	}
+
+	if re.Ok, re.Msg = Vd("username", username); !re.Ok {
+		return c.RenderJSON(re)
+	}
+
+	re.Ok, re.Msg = userService.UpdateUsername(c.getUserId(), username)
+	return c.RenderJSON(re)
+}
+
+// 修改密码
+// [OK]
+func (c ApiUser) UpdatePwd(oldPwd, pwd string) revel.Result {
+	re := info.NewApiRe()
+	if c.GetUsername() == "demo" {
+		re.Msg = "cannotUpdateDemo"
+		return c.RenderJSON(re)
+	}
+	if re.Ok, re.Msg = Vd("password", oldPwd); !re.Ok {
+		return c.RenderJSON(re)
+	}
+	if re.Ok, re.Msg = Vd("password", pwd); !re.Ok {
+		return c.RenderJSON(re)
+	}
+	re.Ok, re.Msg = userService.UpdatePwd(c.getUserId(), oldPwd, pwd)
+	return c.RenderJSON(re)
+}
+
+// 获得同步状态
+// [OK]
+func (c ApiUser) GetSyncState() revel.Result {
+	ret := bson.M{"LastSyncUsn": userService.GetUsn(c.getUserId()), "LastSyncTime": time.Now().Unix()}
+	return c.RenderJSON(ret)
+}
+
+// 头像设置
+// 参数file=文件
+// 成功返回{Logo: url} 头像新url
+// [OK]
+func (c ApiUser) UpdateLogo() revel.Result {
+	ok, msg, url := c.uploadImage()
+
+	if ok {
+		ok = userService.UpdateAvatar(c.getUserId(), url)
+		return c.RenderJSON(map[string]string{"Logo": url})
+	} else {
+		re := info.NewApiRe()
+		re.Msg = msg
+		return c.RenderJSON(re)
+	}
+}
+
+// 上传图片
+func (c ApiUser) uploadImage() (ok bool, msg, url string) {
+	var fileUrlPath = ""
+	ok = false
+
+	var data []byte
+	c.Params.Bind(&data, "file")
+	handel := c.Params.Files["file"][0]
+	if data == nil || len(data) == 0 {
+		return
+	}
+
+	// file, handel, err := c.Request.FormFile("file")
+	// if err != nil {
+	// 	return
+	// }
+	// defer file.Close()
+	// 生成上传路径
+	fileUrlPath = "public/upload/" + c.getUserId() + "/images/logo"
+
+	dir := revel.BasePath + "/" + fileUrlPath
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		return
+	}
+	// 生成新的文件名
+	filename := handel.Filename
+
+	var ext string
+
+	_, ext = SplitFilename(filename)
+	if ext != ".gif" && ext != ".jpg" && ext != ".png" && ext != ".bmp" && ext != ".jpeg" {
+		msg = "notImage"
+		return
+	}
+
+	filename = NewGuid() + ext
+	// data, err := ioutil.ReadAll(file)
+	// if err != nil {
+	// 	LogJ(err)
+	// 	return
+	// }
+
+	// > 5M?
+	if len(data) > 5*1024*1024 {
+		msg = "fileIsTooLarge"
+		return
+	}
+
+	toPath := dir + "/" + filename
+	err = ioutil.WriteFile(toPath, data, 0777)
+	if err != nil {
+		LogJ(err)
+		return
+	}
+
+	ok = true
+	url = configService.GetSiteUrl() + "/" + fileUrlPath + "/" + filename
+	return
+}

app/controllers/api/UserController.go

@@ -1,27 +0,0 @@
-package api
-
-import (
-	"github.com/revel/revel"
-//	"encoding/json"
-//	"gopkg.in/mgo.v2/bson"
-	. "github.com/leanote/leanote/app/lea"
-//	"github.com/leanote/leanote/app/info"
-//	"github.com/leanote/leanote/app/types"
-//	"io/ioutil"
-//	"fmt"
-//	"math"
-//	"os"
-//	"path"
-//	"strconv"
-)
-
-type ApiUser struct {
-	*revel.Controller
-}
-
-// 修改用户名, 需要重置session
-func (c ApiUser) Info() revel.Result {
-	Log("APIUser");
-	return c.RenderTemplate("home/index.html");
-//	return nil;
-}

app/controllers/api/init.go

@@ -0,0 +1,147 @@
+package api
+
+import (
+	"github.com/leanote/leanote/app/info"
+	"github.com/leanote/leanote/app/service"
+	//		. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	"strings"
+)
+
+var userService *service.UserService
+var noteService *service.NoteService
+var trashService *service.TrashService
+var notebookService *service.NotebookService
+var noteContentHistoryService *service.NoteContentHistoryService
+var authService *service.AuthService
+var shareService *service.ShareService
+var blogService *service.BlogService
+var tagService *service.TagService
+var pwdService *service.PwdService
+var tokenService *service.TokenService
+var suggestionService *service.SuggestionService
+var albumService *service.AlbumService
+var noteImageService *service.NoteImageService
+var fileService *service.FileService
+var attachService *service.AttachService
+var configService *service.ConfigService
+var emailService *service.EmailService
+var sessionService *service.SessionService
+
+var pageSize = 1000
+var defaultSortField = "UpdatedTime"
+var leanoteUserId = "admin" // 不能更改
+
+// 状态
+const (
+	S_DEFAULT                 = iota // 0
+	S_NOT_LOGIN                      // 1
+	S_WRONG_USERNAME_PASSWORD        // 2
+	S_WRONG_CAPTCHA                  // 3
+	S_NEED_CAPTCHA                   // 4
+	S_NOT_OPEN_REGISTER              // 4
+)
+
+// 拦截器
+// 不需要拦截的url
+var commonUrl = map[string]map[string]bool{"ApiAuth": map[string]bool{"Login": true,
+	"Register": true,
+},
+	// 文件的操作也不用登录, userId会从session中获取
+	"ApiFile": map[string]bool{"GetImage": true,
+		"GetAttach":     true,
+		"GetAllAttachs": true,
+	},
+}
+
+func needValidate(controller, method string) bool {
+	// 在里面
+	if v, ok := commonUrl[controller]; ok {
+		// 在commonUrl里
+		if _, ok2 := v[method]; ok2 {
+			return false
+		}
+		return true
+	} else {
+		// controller不在这里的, 肯定要验证
+		return true
+	}
+}
+
+// 这里得到token, 若不是login, logout等公用操作, 必须验证是否已登录
+func AuthInterceptor(c *revel.Controller) revel.Result {
+	// 得到token /api/user/info?userId=xxx&token=xxxxx
+	token := c.Params.Values.Get("token")
+	noToken := false
+	if token == "" {
+		// 若无, 则取sessionId
+		token = c.Session.ID()
+		noToken = true
+	}
+	c.Session["_token"] = token
+
+	// 全部变成首字大写
+	var controller = strings.Title(c.Name)
+	var method = strings.Title(c.MethodName)
+
+	// 验证是否已登录
+	// 通过sessionService判断该token下是否有userId, 并返回userId
+	userId := sessionService.GetUserId(token)
+	if noToken && userId == "" {
+		// 从session中获取, api/file/getImage, api/file/getAttach, api/file/getAllAttach
+		// 客户端
+		userIdI, _ := c.Session["UserId"]
+        if userIdI != nil {
+            userId = userIdI.(string)
+        }
+	}
+	c.Session["_userId"] = userId
+
+	// 是否需要验证?
+	if !needValidate(controller, method) {
+		return nil
+	}
+
+	if userId != "" {
+		return nil // 已登录
+	}
+
+	// 没有登录, 返回错误的信息, 需要登录
+	re := info.NewApiRe()
+	re.Msg = "NOTLOGIN"
+	return c.RenderJSON(re)
+}
+
+func init() {
+	// interceptors
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &ApiAuth{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &ApiUser{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &ApiFile{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &ApiNote{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &ApiTag{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &ApiNotebook{})
+}
+
+// 最外层init.go调用
+// 获取service, 单例
+func InitService() {
+	notebookService = service.NotebookS
+	noteService = service.NoteS
+	noteContentHistoryService = service.NoteContentHistoryS
+	trashService = service.TrashS
+	shareService = service.ShareS
+	userService = service.UserS
+	tagService = service.TagS
+	blogService = service.BlogS
+	tokenService = service.TokenS
+	noteImageService = service.NoteImageS
+	fileService = service.FileS
+	albumService = service.AlbumS
+	attachService = service.AttachS
+	pwdService = service.PwdS
+	suggestionService = service.SuggestionS
+	authService = service.AuthS
+	configService = service.ConfigS
+	emailService = service.EmailS
+	sessionService = service.SessionS
+}

app/controllers/init.go

@@ -1,9 +1,10 @@
 package controllers
 
 import (
-	"github.com/leanote/leanote/app/service"
 	"github.com/leanote/leanote/app/info"
-//	. "github.com/leanote/leanote/app/lea"
+	"github.com/leanote/leanote/app/lea/blog"
+	"github.com/leanote/leanote/app/service"
+	//	. "github.com/leanote/leanote/app/lea"
 	"github.com/revel/revel"
 	"strings"
 )
@@ -19,53 +20,57 @@ var blogService *service.BlogService
 var tagService *service.TagService
 var pwdService *service.PwdService
 var tokenService *service.TokenService
-var suggestionService *service.SuggestionService 
-var albumService *service.AlbumService 
-var noteImageService *service.NoteImageService 
+var suggestionService *service.SuggestionService
+var albumService *service.AlbumService
+var noteImageService *service.NoteImageService
 var fileService *service.FileService
 var attachService *service.AttachService
 var configService *service.ConfigService
 var emailService *service.EmailService
 var sessionService *service.SessionService
+var themeService *service.ThemeService
 
 var pageSize = 1000
 var defaultSortField = "UpdatedTime"
-var leanoteUserId = "admin" // 不能更改
-var siteUrl = "http://leanote.com"
 
 // 拦截器
 // 不需要拦截的url
 // Index 除了Note之外都不需要
-var commonUrl = map[string]map[string]bool{"Index": map[string]bool{"Index": true, 
-		"Login": true, 
-		"DoLogin": true,
-		"Logout": true,
-		"Register": true,
-		"DoRegister": true,
-		"FindPasswword": true,
-		"DoFindPassword": true,
-		"FindPassword2": true,
-		"FindPasswordUpdate": true,
-		"Suggestion": true,
-	},
-	"Note": map[string]bool{"ToImage": true},
+var commonUrl = map[string]map[string]bool{"Index": map[string]bool{"Index": true,
+	"Login":              true,
+	"DoLogin":            true,
+	"Logout":             true,
+	"Register":           true,
+	"DoRegister":         true,
+	"FindPasswword":      true,
+	"DoFindPassword":     true,
+	"FindPassword2":      true,
+	"FindPasswordUpdate": true,
+	"Suggestion":         true,
+},
+	"Note": map[string]bool{"ToPdf": true},
 	"Blog": map[string]bool{"Index": true,
-		"View": true,
-		"AboutMe": true,
-		"Cate": true,
-		"Search": true,
+		"View":               true,
+		"AboutMe":            true,
+		"Cate":               true,
+		"ListCateLatest":     true,
+		"Search":             true,
 		"GetLikeAndComments": true,
-		"IncReadNum": true,
-		"ListComments": true,
-		},
+		"IncReadNum":         true,
+		"ListComments":       true,
+		"Single":             true,
+		"Archive":            true,
+		"Tags":               true,
+	},
 	// 用户的激活与修改邮箱都不需要登录, 通过链接地址
 	"User": map[string]bool{"UpdateEmail": true,
-		"ActiveEmail":true,
-		},
-	"Oauth": map[string]bool{"GithubCallback": true},
-	"File": map[string]bool{"OutputImage": true, "OutputFile": true},
-	"Attach": map[string]bool{"Download": true, "DownloadAll": true},
+		"ActiveEmail": true,
+	},
+	"Oauth":  map[string]bool{"GithubCallback": true},
+	"File":   map[string]bool{"OutputImage": true, "OutputFile": true},
+	"Attach": map[string]bool{"Download": true /*, "DownloadAll": true*/},
 }
+
 func needValidate(controller, method string) bool {
 	// 在里面
 	if v, ok := commonUrl[controller]; ok {
@@ -76,31 +81,31 @@ func needValidate(controller, method string) bool {
 		return true
 	} else {
 		// controller不在这里的, 肯定要验证
-		return true;
+		return true
 	}
 }
 func AuthInterceptor(c *revel.Controller) revel.Result {
 	// 全部变成首字大写
 	var controller = strings.Title(c.Name)
 	var method = strings.Title(c.MethodName)
-	
+
 	// 是否需要验证?
 	if !needValidate(controller, method) {
 		return nil
 	}
-	
+
 	// 验证是否已登录
 	if userId, ok := c.Session["UserId"]; ok && userId != "" {
 		return nil // 已登录
 	}
-	
+
 	// 没有登录, 判断是否是ajax操作
 	if c.Request.Header.Get("X-Requested-With") == "XMLHttpRequest" {
 		re := info.NewRe()
 		re.Msg = "NOTLOGIN"
-		return c.RenderJson(re)
+		return c.RenderJSON(re)
 	}
-	
+
 	return c.Redirect("/login")
 }
 
@@ -118,7 +123,7 @@ func InitService() {
 	tokenService = service.TokenS
 	noteImageService = service.NoteImageS
 	fileService = service.FileS
-	albumService= service.AlbumS
+	albumService = service.AlbumS
 	attachService = service.AttachS
 	pwdService = service.PwdS
 	suggestionService = service.SuggestionS
@@ -126,6 +131,12 @@ func InitService() {
 	configService = service.ConfigS
 	emailService = service.EmailS
 	sessionService = service.SessionS
+	themeService = service.ThemeS
+}
+
+// 初始化博客模板
+// 博客模板不由revel的
+func initBlogTemplate() {
 }
 
 func init() {
@@ -135,12 +146,14 @@ func init() {
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &Note{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &Share{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &User{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &Album{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &File{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &Attach{})
-	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &Blog{})
+	//	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &Blog{})
 	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &NoteContentHistory{})
-	
+
 	revel.OnAppStart(func() {
-		siteUrl, _ = revel.Config.String("site.url")
+		// 博客初始化模板
+		blog.Init()
 	})
-}
+}

app/controllers/member/MemberBaseController.go

@@ -0,0 +1,59 @@
+package member
+
+import (
+	//	"github.com/revel/revel"
+	//	"gopkg.in/mgo.v2/bson"
+	//	"encoding/json"
+	"github.com/leanote/leanote/app/controllers"
+	. "github.com/leanote/leanote/app/lea"
+	//	"io/ioutil"
+	//	"fmt"
+	//	"math"
+	//	"strconv"
+	"strings"
+)
+
+// 公用Controller, 其它Controller继承它
+type MemberBaseController struct {
+	controllers.BaseController // 不能用*BaseController
+}
+
+// 得到sorterField 和 isAsc
+// okSorter = ['email', 'username']
+func (c MemberBaseController) getSorter(sorterField string, isAsc bool, okSorter []string) (string, bool) {
+	sorter := ""
+	c.Params.Bind(&sorter, "sorter")
+	if sorter == "" {
+		return sorterField, isAsc
+	}
+
+	// sorter形式 email-up, email-down
+	s2 := strings.Split(sorter, "-")
+	if len(s2) != 2 {
+		return sorterField, isAsc
+	}
+
+	// 必须是可用的sorter
+	if okSorter != nil && len(okSorter) > 0 {
+		if !InArray(okSorter, s2[0]) {
+			return sorterField, isAsc
+		}
+	}
+
+	sorterField = strings.Title(s2[0])
+	if s2[1] == "up" {
+		isAsc = true
+	} else {
+		isAsc = false
+	}
+	c.ViewArgs["sorter"] = sorter
+	return sorterField, isAsc
+}
+
+func (c MemberBaseController) updateConfig(keys []string) {
+	userId := c.GetUserId()
+	for _, key := range keys {
+		v := c.Params.Values.Get(key)
+		configService.UpdateGlobalStringConfig(userId, key, v)
+	}
+}

app/controllers/member/MemberBlogController.go

@@ -0,0 +1,542 @@
+package member
+
+import (
+	"fmt"
+	"github.com/leanote/leanote/app/info"
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	"io/ioutil"
+	"os"
+	"strings"
+	"time"
+	//	"github.com/leanote/leanote/app/lea/blog"
+)
+
+// 博客管理
+
+type MemberBlog struct {
+	MemberBaseController
+}
+
+func (c MemberBlog) common() info.UserBlog {
+	userId := c.GetUserId()
+	userInfo := userService.GetUserInfo(userId)
+	c.ViewArgs["userInfo"] = userInfo
+
+	// 得到博客设置信息
+	c.ViewArgs["allowCustomDomain"] = configService.GetGlobalStringConfig("allowCustomDomain")
+
+	userBlog := blogService.GetUserBlog(userId)
+	c.ViewArgs["userBlog"] = userBlog
+
+	c.SetUserInfo()
+	c.SetLocale()
+	return userBlog
+}
+
+// 得到sorterField 和 isAsc
+// okSorter = ['email', 'username']
+func (c MemberBlog) getSorter(sorterField string, isAsc bool, okSorter []string) (string, bool) {
+	sorter := ""
+	c.Params.Bind(&sorter, "sorter")
+	if sorter == "" {
+		return sorterField, isAsc
+	}
+
+	// sorter形式 email-up, email-down
+	s2 := strings.Split(sorter, "-")
+	if len(s2) != 2 {
+		return sorterField, isAsc
+	}
+
+	// 必须是可用的sorter
+	if okSorter != nil && len(okSorter) > 0 {
+		if !InArray(okSorter, s2[0]) {
+			return sorterField, isAsc
+		}
+	}
+
+	sorterField = strings.Title(s2[0])
+	if s2[1] == "up" {
+		isAsc = true
+	} else {
+		isAsc = false
+	}
+	c.ViewArgs["sorter"] = sorter
+	return sorterField, isAsc
+}
+
+// 博客列表
+var userPageSize = 15
+
+func (c MemberBlog) Index(sorter, keywords string) revel.Result {
+	userId := c.GetUserId()
+	userInfo := userService.GetUserInfo(userId)
+	c.ViewArgs["userInfo"] = userInfo
+
+	c.ViewArgs["title"] = c.Message("Posts")
+	pageNumber := c.GetPage()
+	sorterField, isAsc := c.getSorter("CreatedTime", false, []string{"title", "urlTitle", "updatedTime", "publicTime", "createdTime"})
+	pageInfo, blogs := blogService.ListAllBlogs(c.GetUserId(), "", keywords, false, pageNumber, userPageSize, sorterField, isAsc)
+	c.ViewArgs["pageInfo"] = pageInfo
+	c.ViewArgs["blogs"] = blogs
+	c.ViewArgs["keywords"] = keywords
+
+	userAndBlog := userService.GetUserAndBlog(c.GetUserId())
+	c.ViewArgs["userAndBlog"] = userAndBlog
+
+	c.common()
+
+	return c.RenderTemplate("member/blog/list.html")
+}
+
+// 修改笔记的urlTitle
+func (c MemberBlog) UpdateBlogUrlTitle(noteId, urlTitle string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Item = blogService.UpateBlogUrlTitle(c.GetUserId(), noteId, urlTitle)
+	return c.RenderJSON(re)
+}
+
+// 修改笔记的urlTitle
+func (c MemberBlog) UpdateBlogAbstract(noteId string) revel.Result {
+	c.common()
+	c.ViewArgs["title"] = c.Message("Update Post Abstract")
+	note := noteService.GetNoteAndContent(noteId, c.GetUserId())
+	if !note.Note.IsBlog {
+		return c.E404()
+	}
+	c.ViewArgs["note"] = note
+	c.ViewArgs["noteId"] = noteId
+	return c.RenderTemplate("member/blog/update_abstract.html")
+}
+func (c MemberBlog) DoUpdateBlogAbstract(noteId, imgSrc, desc, abstract string) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.UpateBlogAbstract(c.GetUserId(), noteId, imgSrc, desc, abstract)
+	return c.RenderJSON(re)
+}
+
+// 基本信息设置
+func (c MemberBlog) Base() revel.Result {
+	c.common()
+	c.ViewArgs["title"] = c.Message("Blog Base Info")
+	return c.RenderTemplate("member/blog/base.html")
+}
+func (c MemberBlog) Comment() revel.Result {
+	c.common()
+	c.ViewArgs["title"] = c.Message("Comment")
+	return c.RenderTemplate("member/blog/comment.html")
+}
+
+func (c MemberBlog) Paging() revel.Result {
+	c.common()
+	c.ViewArgs["title"] = c.Message("Paging")
+	return c.RenderTemplate("member/blog/paging.html")
+}
+
+func (c MemberBlog) Cate() revel.Result {
+	userBlog := c.common()
+	c.ViewArgs["title"] = c.Message("Category")
+
+	notebooks := blogService.ListBlogNotebooks(c.GetUserId())
+	notebooksMap := map[string]info.Notebook{}
+	for _, each := range notebooks {
+		notebooksMap[each.NotebookId.Hex()] = each
+	}
+
+	var i = 0
+	notebooks2 := make([]info.Notebook, len(notebooks))
+
+	// 先要保证已有的是正确的排序
+	cateIds := userBlog.CateIds
+	has := map[string]bool{} // cateIds中有的
+	if cateIds != nil && len(cateIds) > 0 {
+		for _, cateId := range cateIds {
+			if n, ok := notebooksMap[cateId]; ok {
+				notebooks2[i] = n
+				i++
+				has[cateId] = true
+			}
+		}
+	}
+	// 之后
+	for _, each := range notebooks {
+		id := each.NotebookId.Hex()
+		if !has[id] {
+			notebooks2[i] = each
+			i++
+		}
+	}
+	c.ViewArgs["notebooks"] = notebooks2
+
+	return c.RenderTemplate("member/blog/cate.html")
+}
+
+// 修改分类排序
+func (c MemberBlog) UpateCateIds(cateIds []string) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.UpateCateIds(c.GetUserId(), cateIds)
+	return c.RenderJSON(re)
+}
+
+func (c MemberBlog) UpdateCateUrlTitle(cateId, urlTitle string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Item = blogService.UpateCateUrlTitle(c.GetUserId(), cateId, urlTitle)
+	return c.RenderJSON(re)
+}
+
+// 保存之, 包含增加与保存
+func (c MemberBlog) DoAddOrUpdateSingle(singleId, title, content string) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.AddOrUpdateSingle(c.GetUserId(), singleId, title, content)
+	return c.RenderJSON(re)
+}
+func (c MemberBlog) AddOrUpdateSingle(singleId string) revel.Result {
+	c.common()
+	c.ViewArgs["title"] = c.Message("Add Single")
+	c.ViewArgs["singleId"] = singleId
+	if singleId != "" {
+		c.ViewArgs["title"] = c.Message("Update Single")
+		c.ViewArgs["single"] = blogService.GetSingle(singleId)
+	}
+	return c.RenderTemplate("member/blog/add_single.html")
+}
+func (c MemberBlog) SortSingles(singleIds []string) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.SortSingles(c.GetUserId(), singleIds)
+	return c.RenderJSON(re)
+}
+
+func (c MemberBlog) DeleteSingle(singleId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.DeleteSingle(c.GetUserId(), singleId)
+	return c.RenderJSON(re)
+}
+
+// 修改页面标题
+func (c MemberBlog) UpdateSingleUrlTitle(singleId, urlTitle string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Item = blogService.UpdateSingleUrlTitle(c.GetUserId(), singleId, urlTitle)
+	return c.RenderJSON(re)
+}
+
+func (c MemberBlog) Single() revel.Result {
+	c.common()
+	c.ViewArgs["title"] = c.Message("Single")
+	c.ViewArgs["singles"] = blogService.GetSingles(c.GetUserId())
+
+	return c.RenderTemplate("member/blog/single.html")
+}
+
+// 主题
+func (c MemberBlog) Theme() revel.Result {
+	c.common()
+	activeTheme, otherThemes := themeService.GetUserThemes(c.GetUserId())
+	c.ViewArgs["activeTheme"] = activeTheme
+	c.ViewArgs["otherThemes"] = otherThemes
+
+	c.ViewArgs["optionThemes"] = themeService.GetDefaultThemes()
+
+	c.ViewArgs["title"] = c.Message("Theme")
+	return c.RenderTemplate("member/blog/theme.html")
+}
+
+// 编辑主题
+var baseTpls = []string{"header.html", "footer.html", "index.html", "cate.html", "search.html", "post.html", "single.html", "tags.html", "tag_posts.html", "archive.html", "share_comment.html", "404.html", "theme.json", "style.css", "blog.js"}
+
+func (c MemberBlog) UpdateTheme(themeId string, isNew int) revel.Result {
+	// 查看用户是否有该theme, 若没有则复制default之
+	// 得到主题的文件列表
+	userBlog := blogService.GetUserBlog(c.GetUserId())
+	if themeId == "" {
+		_, themeId = themeService.NewThemeForFirst(userBlog)
+		return c.Redirect("/member/blog/updateTheme?themeId=" + themeId)
+	}
+
+	c.common()
+	c.ViewArgs["title"] = c.Message("Update Theme")
+	c.ViewArgs["isNew"] = isNew
+
+	// 先复制之
+	c.ViewArgs["themeId"] = themeId
+
+	// 得到脚本目录
+	userId := c.GetUserId()
+
+	theme := themeService.GetTheme(userId, themeId)
+	if theme.ThemeId == "" {
+		return c.E404()
+	}
+	c.ViewArgs["theme"] = theme
+
+	path := revel.BasePath + "/" + theme.Path
+
+	tpls := ListDir(path)
+	myTpls := make([]string, len(baseTpls))
+	tplMap := map[string]bool{}
+	for i, t := range baseTpls {
+		myTpls[i] = t
+		tplMap[t] = true
+	}
+	// 得到没有的tpls
+	for _, t := range tpls {
+		if t == "images" {
+			continue
+		}
+		if !tplMap[t] {
+			myTpls = append(myTpls, t)
+		}
+	}
+
+	c.ViewArgs["myTpls"] = myTpls
+
+	return c.RenderTemplate("member/blog/update_theme.html")
+}
+
+// 得到文件内容
+func (c MemberBlog) GetTplContent(themeId string, filename string) revel.Result {
+	re := info.NewRe()
+	re.Ok = true
+	re.Item = themeService.GetTplContent(c.GetUserId(), themeId, filename)
+
+	return c.RenderJSON(re)
+}
+func (c MemberBlog) UpdateTplContent(themeId, filename, content string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = themeService.UpdateTplContent(c.GetUserId(), themeId, filename, content)
+	return c.RenderRe(re)
+}
+
+func (c MemberBlog) DeleteTpl(themeId, filename string) revel.Result {
+	re := info.NewRe()
+	re.Ok = themeService.DeleteTpl(c.GetUserId(), themeId, filename)
+	return c.RenderJSON(re)
+}
+
+func (c MemberBlog) ListThemeImages(themeId string) revel.Result {
+	re := info.NewRe()
+	userId := c.GetUserId()
+	path := themeService.GetThemeAbsolutePath(userId, themeId) + "/images"
+	os.MkdirAll(path, 0755)
+	images := ListDir(path)
+	re.List = images
+	re.Ok = true
+	return c.RenderJSON(re)
+}
+
+func (c MemberBlog) DeleteThemeImage(themeId, filename string) revel.Result {
+	re := info.NewRe()
+	path := themeService.GetThemeAbsolutePath(c.GetUserId(), themeId) + "/images/" + filename
+	re.Ok = DeleteFile(path)
+	return c.RenderJSON(re)
+}
+
+// 上传主题图片
+func (c MemberBlog) UploadThemeImage(themeId string) revel.Result {
+	re := c.uploadImage(themeId)
+	c.ViewArgs["fileUrlPath"] = re.Id
+	c.ViewArgs["resultCode"] = re.Code
+	c.ViewArgs["resultMsg"] = re.Msg
+	return c.RenderTemplate("file/blog_logo.html")
+}
+func (c MemberBlog) uploadImage(themeId string) (re info.Re) {
+	var fileId = ""
+	var resultCode = 0     // 1表示正常
+	var resultMsg = "内部错误" // 错误信息
+	var Ok = false
+
+	defer func() {
+		re.Id = fileId // 只是id, 没有其它信息
+		re.Code = resultCode
+		re.Msg = resultMsg
+		re.Ok = Ok
+	}()
+
+	var data []byte
+	c.Params.Bind(&data, "file")
+	handel := c.Params.Files["file"][0]
+	if data == nil || len(data) == 0 {
+		return re
+	}
+
+	// file, handel, err := c.Request.FormFile("file")
+	// if err != nil {
+	// 	return re
+	// }
+	// defer file.Close()
+	// 生成上传路径
+	dir := themeService.GetThemeAbsolutePath(c.GetUserId(), themeId) + "/images"
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		return re
+	}
+	// 生成新的文件名
+	filename := handel.Filename
+
+	var ext string
+
+	_, ext = SplitFilename(filename)
+	if ext != ".gif" && ext != ".jpg" && ext != ".png" && ext != ".bmp" && ext != ".jpeg" {
+		resultMsg = "不是图片"
+		return re
+	}
+
+	filename = filename
+	// data, err := ioutil.ReadAll(file)
+	// if err != nil {
+	// 	LogJ(err)
+	// 	return re
+	// }
+
+	// > 2M?
+	if len(data) > 5*1024*1024 {
+		resultCode = 0
+		resultMsg = "图片大于2M"
+		return re
+	}
+
+	toPath := dir + "/" + filename
+	err = ioutil.WriteFile(toPath, data, 0777)
+	if err != nil {
+		LogJ(err)
+		return re
+	}
+	TransToGif(toPath, 0, true)
+	resultCode = 1
+	resultMsg = "上传成功!"
+
+	return re
+}
+
+//
+// 使用主题
+func (c MemberBlog) ActiveTheme(themeId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = themeService.ActiveTheme(c.GetUserId(), themeId)
+	return c.RenderJSON(re)
+}
+
+// 删除主题
+func (c MemberBlog) DeleteTheme(themeId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = themeService.DeleteTheme(c.GetUserId(), themeId)
+	return c.RenderJSON(re)
+}
+
+// 管理员公开主题
+func (c MemberBlog) PublicTheme(themeId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = themeService.PublicTheme(c.GetUserId(), themeId)
+	return c.RenderJSON(re)
+}
+
+// 导出
+func (c MemberBlog) ExportTheme(themeId string) revel.Result {
+	re := info.NewRe()
+	var path string
+	re.Ok, path = themeService.ExportTheme(c.GetUserId(), themeId)
+	if !re.Ok {
+		return c.RenderText("error...")
+	}
+	fw, err := os.Open(path)
+	if err != nil {
+		return c.RenderText("error")
+	}
+	return c.RenderBinary(fw, GetFilename(path), revel.Attachment, time.Now()) // revel.Attachment
+}
+
+// 导入主题
+func (c MemberBlog) ImportTheme() revel.Result {
+	re := info.NewRe()
+
+	var data []byte
+	c.Params.Bind(&data, "file")
+	handel := c.Params.Files["file"][0]
+	if data == nil || len(data) == 0 {
+		return c.RenderJSON(re)
+	}
+
+	// file, handel, err := c.Request.FormFile("file")
+	// if err != nil {
+	// 	re.Msg = fmt.Sprintf("%v", err)
+	// 	return c.RenderJSON(re)
+	// }
+
+	// defer file.Close()
+	// 生成上传路径
+	userId := c.GetUserId()
+	dir := revel.BasePath + "/public/upload/" + userId + "/tmp"
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		re.Msg = fmt.Sprintf("%v", err)
+		return c.RenderJSON(re)
+	}
+	// 生成新的文件名
+	filename := handel.Filename
+
+	var ext string
+	_, ext = SplitFilename(filename)
+	if ext != ".zip" {
+		re.Msg = "Please upload zip file"
+		return c.RenderJSON(re)
+	}
+
+	filename = filename
+	// data, err := ioutil.ReadAll(file)
+	// if err != nil {
+	// 	return c.RenderJSON(re)
+	// }
+
+	// > 10M?
+	if len(data) > 10*1024*1024 {
+		re.Msg = "File is big than 10M"
+		return c.RenderJSON(re)
+	}
+
+	toPath := dir + "/" + filename
+	err = ioutil.WriteFile(toPath, data, 0777)
+	if err != nil {
+		re.Msg = fmt.Sprintf("%v", err)
+		return c.RenderJSON(re)
+	}
+
+	// 上传好后, 增加之
+	re.Ok, re.Msg = themeService.ImportTheme(c.GetUserId(), toPath)
+	return c.RenderRe(re)
+}
+
+// 安装
+func (c MemberBlog) InstallTheme(themeId string) revel.Result {
+	re := info.NewRe()
+	re.Ok = themeService.InstallTheme(c.GetUserId(), themeId)
+	return c.RenderJSON(re)
+}
+
+// 新建主题
+func (c MemberBlog) NewTheme() revel.Result {
+	_, themeId := themeService.NewTheme(c.GetUserId())
+	return c.Redirect("/member/blog/updateTheme?isNew=1&themeId=" + themeId)
+}
+
+//-----------
+//
+func (c MemberBlog) SetUserBlogBase(userBlog info.UserBlogBase) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.UpdateUserBlogBase(c.GetUserId(), userBlog)
+	return c.RenderJSON(re)
+}
+func (c MemberBlog) SetUserBlogComment(userBlog info.UserBlogComment) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.UpdateUserBlogComment(c.GetUserId(), userBlog)
+	return c.RenderJSON(re)
+}
+func (c MemberBlog) SetUserBlogStyle(userBlog info.UserBlogStyle) revel.Result {
+	re := info.NewRe()
+	re.Ok = blogService.UpdateUserBlogStyle(c.GetUserId(), userBlog)
+	return c.RenderJSON(re)
+}
+
+func (c MemberBlog) SetUserBlogPaging(perPageSize int, sortField string, isAsc bool) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = blogService.UpdateUserBlogPaging(c.GetUserId(), perPageSize, sortField, isAsc)
+	return c.RenderRe(re)
+}

app/controllers/member/MemberGroupController.go

@@ -0,0 +1,58 @@
+package member
+
+import (
+	"github.com/leanote/leanote/app/info"
+	"github.com/revel/revel"
+)
+
+// 分组管理
+type MemberGroup struct {
+	MemberBaseController
+}
+
+// 首页, 显示所有分组和用户
+func (c MemberGroup) Index() revel.Result {
+	c.SetUserInfo()
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("My Group")
+	c.ViewArgs["groups"] = groupService.GetGroupsAndUsers(c.GetUserId())
+	return c.RenderTemplate("member/group/index.html")
+}
+
+// 添加分组
+func (c MemberGroup) AddGroup(title string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Item = groupService.AddGroup(c.GetUserId(), title)
+	return c.RenderJSON(re)
+}
+
+func (c MemberGroup) UpdateGroupTitle(groupId, title string) revel.Result {
+	re := info.NewRe()
+	re.Ok = groupService.UpdateGroupTitle(c.GetUserId(), groupId, title)
+	return c.RenderJSON(re)
+}
+
+func (c MemberGroup) DeleteGroup(groupId string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = groupService.DeleteGroup(c.GetUserId(), groupId)
+	return c.RenderRe(re)
+}
+
+// 添加用户
+func (c MemberGroup) AddUser(groupId, email string) revel.Result {
+	re := info.NewRe()
+	userInfo := userService.GetUserInfoByAny(email)
+	if userInfo.UserId == "" {
+		re.Msg = "userNotExists"
+	} else {
+		re.Ok, re.Msg = groupService.AddUser(c.GetUserId(), groupId, userInfo.UserId.Hex())
+		re.Item = userInfo
+	}
+	return c.RenderRe(re)
+}
+
+func (c MemberGroup) DeleteUser(groupId, userId string) revel.Result {
+	re := info.NewRe()
+	re.Ok, re.Msg = groupService.DeleteUser(c.GetUserId(), groupId, userId)
+	return c.RenderRe(re)
+}

app/controllers/member/MemberIndexController.go

@@ -0,0 +1,37 @@
+package member
+
+import (
+	"github.com/revel/revel"
+)
+
+// admin 首页
+
+type MemberIndex struct {
+	MemberBaseController
+}
+
+// admin 主页
+func (c MemberIndex) Index() revel.Result {
+	c.SetUserInfo()
+	c.ViewArgs["title"] = c.Message("Leanote Member Center")
+
+	c.ViewArgs["countNote"] = noteService.CountNote(c.GetUserId())
+	c.ViewArgs["countBlog"] = noteService.CountBlog(c.GetUserId())
+
+	c.SetLocale()
+
+	return c.RenderTemplate("member/index.html")
+}
+
+// 模板
+func (c MemberIndex) T(t string) revel.Result {
+	c.ViewArgs["str"] = configService.GlobalStringConfigs
+	c.ViewArgs["arr"] = configService.GlobalArrayConfigs
+	c.ViewArgs["map"] = configService.GlobalMapConfigs
+	c.ViewArgs["arrMap"] = configService.GlobalArrMapConfigs
+	return c.RenderTemplate("admin/" + t + ".html")
+}
+
+func (c MemberIndex) GetView(view string) revel.Result {
+	return c.RenderTemplate("admin/" + view)
+}

app/controllers/member/MemberUserController.go

@@ -0,0 +1,40 @@
+package member
+
+import (
+	"github.com/revel/revel"
+)
+
+// 帐户信息
+
+type MemberUser struct {
+	MemberBaseController
+}
+
+func (c MemberUser) Username() revel.Result {
+	c.SetUserInfo()
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("Username")
+	return c.RenderTemplate("member/user/username.html")
+}
+
+func (c MemberUser) Email() revel.Result {
+	c.SetUserInfo()
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("Email")
+	return c.RenderTemplate("member/user/email.html")
+}
+
+func (c MemberUser) Password() revel.Result {
+	c.SetUserInfo()
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("Password")
+	return c.RenderTemplate("member/user/password.html")
+}
+
+func (c MemberUser) Avatar() revel.Result {
+	c.SetUserInfo()
+	c.SetLocale()
+	c.ViewArgs["title"] = c.Message("Avatar")
+	c.ViewArgs["globalConfigs"] = configService.GetGlobalConfigForUser()
+	return c.RenderTemplate("member/user/avatar.html")
+}

app/controllers/member/init.go

@@ -0,0 +1,135 @@
+package member
+
+import (
+	"github.com/leanote/leanote/app/info"
+	"github.com/leanote/leanote/app/service"
+	//	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	//	"strings"
+)
+
+var userService *service.UserService
+var groupService *service.GroupService
+var noteService *service.NoteService
+var trashService *service.TrashService
+var notebookService *service.NotebookService
+var noteContentHistoryService *service.NoteContentHistoryService
+var authService *service.AuthService
+var shareService *service.ShareService
+var blogService *service.BlogService
+var tagService *service.TagService
+var pwdService *service.PwdService
+var tokenService *service.TokenService
+var suggestionService *service.SuggestionService
+var albumService *service.AlbumService
+var noteImageService *service.NoteImageService
+var fileService *service.FileService
+var attachService *service.AttachService
+var configService *service.ConfigService
+var emailService *service.EmailService
+var upgradeService *service.UpgradeService
+var themeService *service.ThemeService
+
+// 拦截器
+// 不需要拦截的url
+// Index 除了Note之外都不需要
+var commonUrl = map[string]map[string]bool{"Index": map[string]bool{"Index": true,
+	"Login":              true,
+	"DoLogin":            true,
+	"Logout":             true,
+	"Register":           true,
+	"DoRegister":         true,
+	"FindPasswword":      true,
+	"DoFindPassword":     true,
+	"FindPassword2":      true,
+	"FindPasswordUpdate": true,
+	"Suggestion":         true,
+},
+	"Blog": map[string]bool{"Index": true,
+		"View":       true,
+		"AboutMe":    true,
+		"SearchBlog": true,
+	},
+	// 用户的激活与修改邮箱都不需要登录, 通过链接地址
+	"User": map[string]bool{"UpdateEmail": true,
+		"ActiveEmail": true,
+	},
+	"Oauth":  map[string]bool{"GithubCallback": true},
+	"File":   map[string]bool{"OutputImage": true, "OutputFile": true},
+	"Attach": map[string]bool{"Download": true, "DownloadAll": true},
+}
+
+func needValidate(controller, method string) bool {
+	// 在里面
+	if v, ok := commonUrl[controller]; ok {
+		// 在commonUrl里
+		if _, ok2 := v[method]; ok2 {
+			return false
+		}
+		return true
+	} else {
+		// controller不在这里的, 肯定要验证
+		return true
+	}
+}
+func AuthInterceptor(c *revel.Controller) revel.Result {
+	// 全部变成首字大写
+	/*
+		var controller = strings.Title(c.Name)
+		var method = strings.Title(c.MethodName)
+		// 是否需要验证?
+		if !needValidate(controller, method) {
+			return nil
+		}
+	*/
+
+	// 验证是否已登录
+	// 必须是管理员
+	if _, ok := c.Session["Username"]; ok {
+		return nil // 已登录
+	}
+
+	// 没有登录, 判断是否是ajax操作
+	if c.Request.Header.Get("X-Requested-With") == "XMLHttpRequest" {
+		re := info.NewRe()
+		re.Msg = "NOTLOGIN"
+		return c.RenderJSON(re)
+	}
+
+	return c.Redirect("/login")
+}
+
+// 最外层init.go调用
+// 获取service, 单例
+func InitService() {
+	notebookService = service.NotebookS
+	noteService = service.NoteS
+	noteContentHistoryService = service.NoteContentHistoryS
+	trashService = service.TrashS
+	shareService = service.ShareS
+	userService = service.UserS
+	groupService = service.GroupS
+	tagService = service.TagS
+	blogService = service.BlogS
+	tokenService = service.TokenS
+	noteImageService = service.NoteImageS
+	fileService = service.FileS
+	albumService = service.AlbumS
+	attachService = service.AttachS
+	pwdService = service.PwdS
+	suggestionService = service.SuggestionS
+	authService = service.AuthS
+	configService = service.ConfigS
+	emailService = service.EmailS
+	upgradeService = service.UpgradeS
+	themeService = service.ThemeS
+}
+
+func init() {
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &MemberIndex{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &MemberUser{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &MemberBlog{})
+	revel.InterceptFunc(AuthInterceptor, revel.BEFORE, &MemberGroup{})
+	revel.OnAppStart(func() {
+	})
+}

app/db/Mgo.go

@@ -2,9 +2,11 @@ package db
 
 import (
 	"fmt"
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
 	"gopkg.in/mgo.v2"
 	"gopkg.in/mgo.v2/bson"
-	"github.com/revel/revel"
+	"strings"
 )
 
 // Init mgo and the common DAO
@@ -23,9 +25,12 @@ var ShareNotebooks *mgo.Collection
 var HasShareNotes *mgo.Collection
 var Blogs *mgo.Collection
 var Users *mgo.Collection
+var Groups *mgo.Collection
+var GroupUsers *mgo.Collection
 
 var Tags *mgo.Collection
-var TagNotes *mgo.Collection
+var NoteTags *mgo.Collection
+var TagCounts *mgo.Collection
 
 var UserBlogs *mgo.Collection
 
@@ -46,17 +51,43 @@ var EmailLogs *mgo.Collection
 var BlogLikes *mgo.Collection
 var BlogComments *mgo.Collection
 var Reports *mgo.Collection
+var BlogSingles *mgo.Collection
+var Themes *mgo.Collection
 
 // session
 var Sessions *mgo.Collection
 
 // 初始化时连接数据库
-func Init() {
-	var url string
-	var ok bool
-	config := revel.Config;
-	url, ok = config.String("db.url")
-	dbname, _ := config.String("db.dbname")
+func Init(url, dbname string) {
+	ok := true
+	config := revel.Config
+	if url == "" {
+		url, ok = config.String("db.url")
+		if !ok {
+			url, ok = config.String("db.urlEnv")
+			if ok {
+				Log("get db conf from urlEnv: " + url)
+			}
+		} else {
+			Log("get db conf from db.url: " + url)
+		}
+
+		if ok {
+			// get dbname from urlEnv
+			urls := strings.Split(url, "/")
+			dbname = urls[len(urls)-1]
+
+			if strings.Contains(dbname, "?") {
+				urls = strings.Split(dbname, "?")
+				dbname = urls[0]
+			}
+		}
+	}
+	if dbname == "" {
+		dbname, _ = config.String("db.dbname")
+	}
+
+	// get db config from host, port, username, password
 	if !ok {
 		host, _ := revel.Config.String("db.host")
 		port, _ := revel.Config.String("db.port")
@@ -66,9 +97,10 @@ func Init() {
 		if username == "" || password == "" {
 			usernameAndPassword = ""
 		}
-		url = "mongodb://" + usernameAndPassword  + host + ":" + port + "/" + dbname
+		url = "mongodb://" + usernameAndPassword + host + ":" + port + "/" + dbname
 	}
-	
+	Log(url)
+
 	// [mongodb://][user:pass@]host1[:port1][,host2[:port2],...][/database][?options]
 	// mongodb://myuser:mypass@localhost:40001,otherhost:40001/mydb
 	var err error
@@ -82,55 +114,61 @@ func Init() {
 
 	// notebook
 	Notebooks = Session.DB(dbname).C("notebooks")
-	
+
 	// notes
 	Notes = Session.DB(dbname).C("notes")
-	
+
 	// noteContents
 	NoteContents = Session.DB(dbname).C("note_contents")
 	NoteContentHistories = Session.DB(dbname).C("note_content_histories")
-	
+
 	// share
 	ShareNotes = Session.DB(dbname).C("share_notes")
 	ShareNotebooks = Session.DB(dbname).C("share_notebooks")
 	HasShareNotes = Session.DB(dbname).C("has_share_notes")
-	
+
 	// user
 	Users = Session.DB(dbname).C("users")
-	
+	// group
+	Groups = Session.DB(dbname).C("groups")
+	GroupUsers = Session.DB(dbname).C("group_users")
+
 	// blog
 	Blogs = Session.DB(dbname).C("blogs")
-	
+
 	// tag
 	Tags = Session.DB(dbname).C("tags")
-	TagNotes = Session.DB(dbname).C("tag_notes")
-	
+	NoteTags = Session.DB(dbname).C("note_tags")
+	TagCounts = Session.DB(dbname).C("tag_count")
+
 	// blog
 	UserBlogs = Session.DB(dbname).C("user_blogs")
-	
+	BlogSingles = Session.DB(dbname).C("blog_singles")
+	Themes = Session.DB(dbname).C("themes")
+
 	// find password
 	Tokens = Session.DB(dbname).C("tokens")
-	
+
 	// Suggestion
 	Suggestions = Session.DB(dbname).C("suggestions")
-	
+
 	// Album & file
 	Albums = Session.DB(dbname).C("albums")
 	Files = Session.DB(dbname).C("files")
 	Attachs = Session.DB(dbname).C("attachs")
-	
+
 	NoteImages = Session.DB(dbname).C("note_images")
-	
+
 	Configs = Session.DB(dbname).C("configs")
 	EmailLogs = Session.DB(dbname).C("email_logs")
-	
+
 	// 社交
 	BlogLikes = Session.DB(dbname).C("blog_likes")
 	BlogComments = Session.DB(dbname).C("blog_comments")
-	
+
 	// 举报
 	Reports = Session.DB(dbname).C("reports")
-	
+
 	// session
 	Sessions = Session.DB(dbname).C("sessions")
 }
@@ -174,22 +212,29 @@ func UpdateByIdAndUserId2(collection *mgo.Collection, id, userId bson.ObjectId,
 	return Err(err)
 }
 func UpdateByIdAndUserIdField(collection *mgo.Collection, id, userId, field string, value interface{}) bool {
-	return UpdateByIdAndUserId(collection, id, userId, bson.M{"$set": bson.M{field:value}})
+	return UpdateByIdAndUserId(collection, id, userId, bson.M{"$set": bson.M{field: value}})
 }
 func UpdateByIdAndUserIdMap(collection *mgo.Collection, id, userId string, v bson.M) bool {
 	return UpdateByIdAndUserId(collection, id, userId, bson.M{"$set": v})
 }
+
 func UpdateByIdAndUserIdField2(collection *mgo.Collection, id, userId bson.ObjectId, field string, value interface{}) bool {
-	return UpdateByIdAndUserId2(collection, id, userId, bson.M{"$set": bson.M{field:value}})
+	return UpdateByIdAndUserId2(collection, id, userId, bson.M{"$set": bson.M{field: value}})
 }
 func UpdateByIdAndUserIdMap2(collection *mgo.Collection, id, userId bson.ObjectId, v bson.M) bool {
 	return UpdateByIdAndUserId2(collection, id, userId, bson.M{"$set": v})
 }
-// 
+
+//
 func UpdateByQField(collection *mgo.Collection, q interface{}, field string, value interface{}) bool {
 	_, err := collection.UpdateAll(q, bson.M{"$set": bson.M{field: value}})
 	return Err(err)
 }
+func UpdateByQI(collection *mgo.Collection, q interface{}, v interface{}) bool {
+	_, err := collection.UpdateAll(q, bson.M{"$set": v})
+	return Err(err)
+}
+
 // 查询条件和值
 func UpdateByQMap(collection *mgo.Collection, q interface{}, v interface{}) bool {
 	_, err := collection.UpdateAll(q, bson.M{"$set": v})
@@ -255,6 +300,7 @@ func GetByQWithFields(collection *mgo.Collection, q bson.M, fields []string, i i
 	}
 	collection.Find(q).Select(selector).One(i)
 }
+
 // 查询某些字段, q是查询条件, fields是字段名列表
 func ListByQWithFields(collection *mgo.Collection, q bson.M, fields []string, i interface{}) {
 	selector := make(bson.M, len(fields))
@@ -270,6 +316,11 @@ func GetByIdAndUserId2(collection *mgo.Collection, id, userId bson.ObjectId, i i
 	collection.Find(GetIdAndUserIdBsonQ(id, userId)).One(i)
 }
 
+// 按field去重
+func Distinct(collection *mgo.Collection, q bson.M, field string, i interface{}) {
+	collection.Find(q).Distinct(field, i)
+}
+
 //----------------------
 
 func Count(collection *mgo.Collection, q interface{}) int {
@@ -303,9 +354,26 @@ func Err(err error) bool {
 		fmt.Println(err)
 		// 删除时, 查找
 		if err.Error() == "not found" {
-			return true;
+			return true
 		}
 		return false
 	}
 	return true
-}
+}
+
+// 检查mognodb是否lost connection
+// 每个请求之前都要检查!!
+func CheckMongoSessionLost() {
+	// fmt.Println("检查CheckMongoSessionLostErr")
+	err := Session.Ping()
+	if err != nil {
+		Log("Lost connection to db!")
+		Session.Refresh()
+		err = Session.Ping()
+		if err == nil {
+			Log("Reconnect to db successful.")
+		} else {
+			Log("重连失败!!!! 警告")
+		}
+	}
+}

app/i18n/i18n.go

@@ -1,89 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"bufio"
-	"strings"
-	"encoding/json"
-)
-
-// convert revel msg to js msg
-
-var msgBasePath = "/Users/life/Documents/Go/package1/src/github.com/leanote/leanote/messages/"
-var targetBasePath = "/Users/life/Documents/Go/package1/src/github.com/leanote/leanote/public/js/i18n/"
-func parse(filename string) {
-	file, err := os.Open(msgBasePath + filename)
-	reader := bufio.NewReader(file)
-	msg := map[string]string{}
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	for true {
-		line, _, err := reader.ReadLine()
-		
-		if err != nil {
-			break
-		}
-		
-		if len(line) == 0 {
-			continue
-		}
-		// 对每一行进行处理
-		if line[0] == '#' || line[1] == '#' {
-			continue;
-		}
-		lineStr := string(line)
-		
-		// 找到第一个=位置
-		pos := strings.Index(lineStr, "=")
-		
-		if pos < 0 {
-			continue;
-		}
-		
-		key := string(line[0:pos])
-		value := string(line[pos+1:])
-		
-//		fmt.Println(lineStr)
-//		fmt.Println(value)
-		
-		msg[key] = value
-	}
-	
-	// JSON
-	b, _ := json.Marshal(msg)
-	str := string(b)
-	fmt.Println(str);
-	
-	targetName := targetBasePath + filename + ".js"
-	file2, err2 := os.OpenFile(targetName, os.O_RDWR|os.O_CREATE, 0644)
-	if err2 != nil {
-		file2, err2 = os.Create(targetName)
-	}
-	file2.WriteString("var MSG = " + str + ";" + `
-function getMsg(key, data) {
-	var msg = MSG[key]
-	if(msg) {
-		if(data) {
-			if(!isArray(data)) {
-				data = [data];
-			}
-			for(var i = 0; i < data.length; ++i) {
-				msg = msg.replace("%s", data[i]);
-			}
-		}
-		return msg;
-	}
-	return key;
-}`)
-}
-
-// 生成js的i18n文件
-func main() {
-	parse("msg.en")
-	parse("msg.zh")
-	parse("blog.zh")
-	parse("blog.en")
-}

app/info/Api.go

@@ -0,0 +1,119 @@
+package info
+
+import (
+	"gopkg.in/mgo.v2/bson"
+	"time"
+)
+
+//---------
+// 数据结构
+//---------
+type NoteFile struct {
+	FileId      string // 服务器端Id
+	LocalFileId string // 客户端Id
+	Type        string // images/png, doc, xls, 根据fileName确定
+	Title       string
+	HasBody     bool // 传过来的值是否要更新内容
+	IsAttach    bool // 是否是附件, 不是附件就是图片
+}
+type ApiNote struct {
+	NoteId     string
+	NotebookId string
+	UserId     string
+	Title      string
+	Desc       string
+	//	ImgSrc     string
+	Tags       []string
+	Abstract   string
+	Content    string
+	IsMarkdown bool
+	//	FromUserId string // 为共享而新建
+	IsBlog      bool // 是否是blog, 更新note不需要修改, 添加note时才有可能用到, 此时需要判断notebook是否设为Blog
+	IsTrash     bool
+	IsDeleted   bool
+	Usn         int
+	Files       []NoteFile
+	CreatedTime time.Time
+	UpdatedTime time.Time
+	PublicTime  time.Time
+}
+
+// 内容
+type ApiNoteContent struct {
+	NoteId bson.ObjectId `bson:"_id,omitempty"`
+	UserId bson.ObjectId `bson:"UserId"`
+
+	Content string `Content`
+
+	//	CreatedTime   time.Time     `CreatedTime`
+	//	UpdatedTime   time.Time     `UpdatedTime`
+}
+
+// 转换
+func NoteToApiNote(note Note, files []NoteFile) ApiNote {
+	apiNote := ApiNote{}
+	return apiNote
+}
+
+//----------
+// 用户信息
+//----------
+
+type ApiUser struct {
+	UserId   string
+	Username string
+	Email    string
+	Verified bool
+	Logo     string
+}
+
+//----------
+// Notebook
+//----------
+type ApiNotebook struct {
+	NotebookId       bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
+	UserId           bson.ObjectId `bson:"UserId"`
+	ParentNotebookId bson.ObjectId `bson:"ParentNotebookId,omitempty"` // 上级
+	Seq              int           `Seq`                               // 排序
+	Title            string        `Title`                             // 标题
+	UrlTitle         string        `UrlTitle`                          // Url标题 2014/11.11加
+	IsBlog           bool          `IsBlog,omitempty`                  // 是否是Blog 2013/12/29 新加
+	CreatedTime      time.Time     `CreatedTime,omitempty`
+	UpdatedTime      time.Time     `UpdatedTime,omitempty`
+	Usn              int           `Usn` // UpdateSequenceNum
+	IsDeleted        bool          `IsDeleted`
+}
+
+//---------
+// api 返回
+//---------
+
+// 一般返回
+type ApiRe struct {
+	Ok  bool
+	Msg string
+}
+
+func NewApiRe() ApiRe {
+	return ApiRe{Ok: false}
+}
+
+// auth
+type AuthOk struct {
+	Ok       bool
+	Token    string
+	UserId   bson.ObjectId
+	Email    string
+	Username string
+}
+
+// 供notebook, note, tag更新的返回数据用
+type ReUpdate struct {
+	Ok  bool
+	Msg string
+	Usn int
+}
+
+func NewReUpdate() ReUpdate {
+	return ReUpdate{Ok: false}
+}

app/info/AttachInfo.go

@@ -7,15 +7,15 @@ import (
 
 // Attach belongs to note
 type Attach struct {
-	AttachId         bson.ObjectId `bson:"_id,omitempty"` //
-	NoteId         bson.ObjectId `bson:"NoteId"` // 
-	UploadUserId         bson.ObjectId `bson:"UploadUserId"` // 可以不是note owner, 协作者userId
-	Name           string        `Name`  // file name, md5, such as 13232312.doc
-	Title          string        `Title` // raw file name
-	Size           int64         `Size`  // file size (byte)
-	Type           string        `Type`  // file type, "doc" = word
-	Path           string        `Path`  // the file path such as: files/userId/attachs/adfadf.doc
-	CreatedTime    time.Time     `CreatedTime`
-	
+	AttachId     bson.ObjectId `bson:"_id,omitempty"` //
+	NoteId       bson.ObjectId `bson:"NoteId"`        //
+	UploadUserId bson.ObjectId `bson:"UploadUserId"`  // 可以不是note owner, 协作者userId
+	Name         string        `Name`                 // file name, md5, such as 13232312.doc
+	Title        string        `Title`                // raw file name
+	Size         int64         `Size`                 // file size (byte)
+	Type         string        `Type`                 // file type, "doc" = word
+	Path         string        `Path`                 // the file path such as: files/userId/attachs/adfadf.doc
+	CreatedTime  time.Time     `CreatedTime`
+
 	// FromFileId bson.ObjectId `bson:"FromFileId,omitempty"` // copy from fileId, for collaboration
 }

app/info/BlogCustom.go

@@ -0,0 +1,58 @@
+package info
+
+import (
+	"time"
+)
+
+// 仅仅为了博客的主题
+
+type BlogInfoCustom struct {
+	UserId      string
+	Username    string
+	UserLogo    string
+	Title       string
+	SubTitle    string
+	Logo        string
+	OpenComment bool
+	CommentType string
+	ThemeId     string
+	SubDomain   string
+	Domain      string
+}
+
+type Post struct {
+	NoteId      string
+	Title       string
+	UrlTitle    string
+	ImgSrc      string
+	CreatedTime time.Time
+	UpdatedTime time.Time
+	PublicTime  time.Time
+	Desc        string
+	Abstract    string
+	Content     string
+	Tags        []string
+	CommentNum  int
+	ReadNum     int
+	LikeNum     int
+	IsMarkdown  bool
+}
+
+// 归档
+type ArchiveMonth struct {
+	Month int
+	Posts []*Post
+}
+type Archive struct {
+	Year         int
+	MonthAchives []ArchiveMonth
+	Posts        []*Post
+}
+
+type Cate struct {
+	CateId       string
+	ParentCateId string
+	Title        string
+	UrlTitle     string
+	Children     []*Cate
+}

app/info/BlogInfo.go

@@ -9,22 +9,23 @@ import (
 
 type BlogItem struct {
 	Note
-	Content string // 可能是content的一部分, 截取. 点击more后就是整个信息了
-	HasMore bool   // 是否是否还有
-	User    User   // 用户信息
+	Abstract string
+	Content  string // 可能是content的一部分, 截取. 点击more后就是整个信息了
+	HasMore  bool   // 是否是否还有
+	User     User   // 用户信息
 }
 
 type UserBlogBase struct {
 	Logo     string `Logo`
 	Title    string `Title`    // 标题
 	SubTitle string `SubTitle` // 副标题
-	AboutMe  string `AboutMe`  // 关于我
+	//	AboutMe  string `AboutMe`  // 关于我
 }
 
 type UserBlogComment struct {
-	CanComment bool   `CanComment` // 是否可以评论
+	CanComment  bool   `CanComment`  // 是否可以评论
 	CommentType string `CommentType` // default 或 disqus
-	DisqusId   string `DisqusId`
+	DisqusId    string `DisqusId`
 }
 
 type UserBlogStyle struct {
@@ -38,18 +39,48 @@ type UserBlog struct {
 	Logo     string        `Logo`
 	Title    string        `Title`    // 标题
 	SubTitle string        `SubTitle` // 副标题
-	AboutMe  string        `AboutMe`  // 关于我
+	AboutMe  string        `AboutMe`  // 关于我, 弃用
+
+	CanComment bool `CanComment` // 是否可以评论
 
-	CanComment bool   `CanComment` // 是否可以评论
-	
 	CommentType string `CommentType` // default 或 disqus
-	DisqusId   string `DisqusId`
+	DisqusId    string `DisqusId`
 
 	Style string `Style` // 风格
 	Css   string `Css`   // 自定义css
 
+	ThemeId   bson.ObjectId `ThemeId,omitempty`         // 主题Id
+	ThemePath string        `bson:"ThemePath" json:"-"` // 不存值, 从Theme中获取, 相对路径 public/
+
+	CateIds []string            `CateIds,omitempty` // 分类Id, 排序好的
+	Singles []map[string]string `Singles,omitempty` // 单页, 排序好的, map包含: ["Title"], ["SingleId"]
+
+	PerPageSize int    `PerPageSize,omitempty`
+	SortField   string `SortField`       // 排序字段
+	IsAsc       bool   `IsAsc,omitempty` // 排序类型, 降序, 升序, 默认是false, 表示降序
+
 	SubDomain string `SubDomain` // 二级域名
 	Domain    string `Domain`    // 自定义域名
+
+}
+
+// 博客统计信息
+type BlogStat struct {
+	NoteId     bson.ObjectId `bson:"_id,omitempty"`
+	ReadNum    int           `ReadNum,omitempty`    // 阅读次数 2014/9/28
+	LikeNum    int           `LikeNum,omitempty`    // 点赞次数 2014/9/28
+	CommentNum int           `CommentNum,omitempty` // 评论次数 2014/9/28
+}
+
+// 单页
+type BlogSingle struct {
+	SingleId    bson.ObjectId `bson:"_id,omitempty"`
+	UserId      bson.ObjectId `UserId`
+	Title       string        `Title`
+	UrlTitle    string        `UrlTitle` // 2014/11/11
+	Content     string        `Content`
+	UpdatedTime time.Time     `UpdatedTime`
+	CreatedTime time.Time     `CreatedTime`
 }
 
 //------------------------
@@ -57,7 +88,7 @@ type UserBlog struct {
 
 // 点赞记录
 type BlogLike struct {
-	LikeId      bson.ObjectId `bson:"_id"`
+	LikeId      bson.ObjectId `bson:"_id,omitempty"`
 	NoteId      bson.ObjectId `NoteId`
 	UserId      bson.ObjectId `UserId`
 	CreatedTime time.Time     `CreatedTime`
@@ -65,7 +96,7 @@ type BlogLike struct {
 
 // 评论
 type BlogComment struct {
-	CommentId bson.ObjectId `bson:"_id"`
+	CommentId bson.ObjectId `bson:"_id,omitempty"`
 	NoteId    bson.ObjectId `NoteId`
 
 	UserId  bson.ObjectId `UserId`  // UserId回复ToUserId
@@ -84,3 +115,14 @@ type BlogCommentPublic struct {
 	BlogComment
 	IsILikeIt bool
 }
+
+type BlogUrls struct {
+	IndexUrl    string
+	CateUrl     string
+	SearchUrl   string
+	SingleUrl   string
+	PostUrl     string
+	ArchiveUrl  string
+	TagsUrl     string
+	TagPostsUrl string
+}

app/info/Configinfo.go

@@ -10,9 +10,9 @@ type Config struct {
 	ConfigId    bson.ObjectId       `bson:"_id"`
 	UserId      bson.ObjectId       `UserId`
 	Key         string              `Key`
-	ValueStr    string              `ValueStr,omitempty` // "1"
-	ValueArr    []string            `ValueArr,omitempty` // ["1","b","c"]
-	ValueMap    map[string]string   `ValueMap,omitempty` // {"a":"bb", "CC":"xx"}
+	ValueStr    string              `ValueStr,omitempty`    // "1"
+	ValueArr    []string            `ValueArr,omitempty`    // ["1","b","c"]
+	ValueMap    map[string]string   `ValueMap,omitempty`    // {"a":"bb", "CC":"xx"}
 	ValueArrMap []map[string]string `ValueArrMap,omitempty` // [{"a":"B"}, {}, {}]
 	IsArr       bool                `IsArr`                 // 是否是数组
 	IsMap       bool                `IsMap`                 // 是否是Map

app/info/GroupInfo.go

@@ -0,0 +1,25 @@
+package info
+
+import (
+	"gopkg.in/mgo.v2/bson"
+	"time"
+)
+
+// 分组
+type Group struct {
+	GroupId     bson.ObjectId `bson:"_id"` // 谁的
+	UserId      bson.ObjectId `UserId`     // 所有者Id
+	Title       string        `Title`      // 标题
+	UserCount   int           `UserCount`  // 用户数
+	CreatedTime time.Time     `CreatedTime`
+
+	Users []User `Users,omitempty` // 分组下的用户, 不保存, 仅查看
+}
+
+// 分组好友
+type GroupUser struct {
+	GroupUserId bson.ObjectId `bson:"_id"` // 谁的
+	GroupId     bson.ObjectId `GroupId`    // 分组
+	UserId      bson.ObjectId `UserId`     //  用户
+	CreatedTime time.Time     `CreatedTime`
+}

app/info/NoteImage.go

@@ -9,4 +9,4 @@ type NoteImage struct {
 	NoteImageId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
 	NoteId      bson.ObjectId `bson:"NoteId"`        // 笔记
 	ImageId     bson.ObjectId `bson:"ImageId"`       // 图片fileId
-}
+}

app/info/NoteInfo.go

@@ -15,14 +15,18 @@ type Note struct {
 	Title         string        `Title` // 标题
 	Desc          string        `Desc`  // 描述, 非html
 
+	Src string   `Src,omitempty` // 来源, 2016/4/22
+
 	ImgSrc string   `ImgSrc` // 图片, 第一张缩略图地址
 	Tags   []string `Tags,omitempty`
 
 	IsTrash bool `IsTrash` // 是否是trash, 默认是false
 
-	IsBlog      bool `IsBlog,omitempty`      // 是否设置成了blog 2013/12/29 新加
-	IsRecommend bool `IsRecommend,omitempty` // 是否为推荐博客 2014/9/24新加
-	IsTop       bool `IsTop,omitempty`       // blog是否置顶
+	IsBlog         bool   `IsBlog,omitempty`      // 是否设置成了blog 2013/12/29 新加
+	UrlTitle       string `UrlTitle,omitempty`    // 博客的url标题, 为了更友好的url, 在UserId, UrlName下唯一
+	IsRecommend    bool   `IsRecommend,omitempty` // 是否为推荐博客 2014/9/24新加
+	IsTop          bool   `IsTop,omitempty`       // blog是否置顶
+	HasSelfDefined bool   `HasSelfDefined`        // 是否已经自定义博客图片, desc, abstract
 
 	// 2014/9/28 添加评论社交功能
 	ReadNum    int `ReadNum,omitempty`    // 阅读次数 2014/9/28
@@ -35,9 +39,14 @@ type Note struct {
 
 	CreatedTime   time.Time     `CreatedTime`
 	UpdatedTime   time.Time     `UpdatedTime`
-	RecommendTime time.Time     `RecommendTime,omitempty`        // 推荐时间
-	PublicTime    time.Time     `PublicTime,omitempty`           // 发表时间, 公开为博客则设置
-	UpdatedUserId bson.ObjectId `bson:"UpdatedUserId"` // 如果共享了, 并可写, 那么可能是其它他修改了
+	RecommendTime time.Time     `RecommendTime,omitempty` // 推荐时间
+	PublicTime    time.Time     `PublicTime,omitempty`    // 发表时间, 公开为博客则设置
+	UpdatedUserId bson.ObjectId `bson:"UpdatedUserId"`    // 如果共享了, 并可写, 那么可能是其它他修改了
+
+	// 2015/1/15, 更新序号
+	Usn int `Usn` // UpdateSequenceNum
+
+	IsDeleted bool `IsDeleted` // 删除位
 }
 
 // 内容
@@ -73,3 +82,31 @@ type NoteContentHistory struct {
 	UserId    bson.ObjectId `bson:"UserId"` // 所属者
 	Histories []EachHistory `Histories`
 }
+
+// 为了NoteController接收参数
+
+// 更新note或content
+// 肯定会传userId(谁的), NoteId
+// 会传Title, Content, Tags, 一种或几种
+type NoteOrContent struct {
+	NotebookId string
+	NoteId     string
+	UserId     string
+	Title      string
+	Desc       string
+	Src        string
+	ImgSrc     string
+	Tags       string
+	Content    string
+	Abstract   string
+	IsNew      bool
+	IsMarkdown bool
+	FromUserId string // 为共享而新建
+	IsBlog     bool   // 是否是blog, 更新note不需要修改, 添加note时才有可能用到, 此时需要判断notebook是否设为Blog
+}
+
+// 分开的
+type NoteAndContentSep struct {
+	NoteInfo Note
+	NoteContentInfo NoteContent
+}

app/info/NotebookInfo.go

@@ -13,11 +13,16 @@ type Notebook struct {
 	ParentNotebookId bson.ObjectId `bson:"ParentNotebookId,omitempty"` // 上级
 	Seq              int           `Seq`                               // 排序
 	Title            string        `Title`                             // 标题
+	UrlTitle         string        `UrlTitle`                          // Url标题 2014/11.11加
 	NumberNotes      int           `NumberNotes`                       // 笔记数
 	IsTrash          bool          `IsTrash,omitempty`                 // 是否是trash, 默认是false
 	IsBlog           bool          `IsBlog,omitempty`                  // 是否是Blog 2013/12/29 新加
 	CreatedTime      time.Time     `CreatedTime,omitempty`
 	UpdatedTime      time.Time     `UpdatedTime,omitempty`
+
+	// 2015/1/15, 更新序号
+	Usn       int  `Usn` // UpdateSequenceNum
+	IsDeleted bool `IsDeleted`
 }
 
 // 仅仅是为了返回前台

app/info/Re.go

@@ -1,18 +1,17 @@
 package info
 
-import (
-)
+import ()
 
 // controller ajax返回
 type Re struct {
-	Ok bool
+	Ok   bool
 	Code int
-	Msg string
-	Id string
+	Msg  string
+	Id   string
 	List interface{}
 	Item interface{}
 }
 
 func NewRe() Re {
 	return Re{Ok: false}
-}
+}

app/info/SessionInfo.go

@@ -14,6 +14,8 @@ type Session struct {
 	LoginTimes int    `LoginTimes` // 登录错误时间
 	Captcha    string `Captcha`    // 验证码
 
+	UserId string `UserId` // API时有值UserId
+
 	CreatedTime time.Time `CreatedTime`
 	UpdatedTime time.Time `UpdatedTime` // 更新时间, expire这个时间会自动清空
 }

app/info/ShareNotebookNoteInfo.go

@@ -76,7 +76,9 @@ type SharingNotebookAndNotes struct {
 type ShareNotebook struct {
 	ShareNotebookId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
 	UserId          bson.ObjectId `bson:"UserId"`
-	ToUserId        bson.ObjectId `bson:"ToUserId"`
+	ToUserId        bson.ObjectId `bson:"ToUserId,omitempty"`
+	ToGroupId       bson.ObjectId `bson:"ToGroupId,omitempty"` // 分享给的用户组
+	ToGroup         Group         `ToGroup,omitempty`          // 仅仅为了显示, 不存储, 分组信息
 	NotebookId      bson.ObjectId `bson:"NotebookId"`
 	Seq             int           `bson:"Seq"`  // 排序
 	Perm            int           `bson:"Perm"` // 权限, 其下所有notes 0只读, 1可修改
@@ -134,7 +136,9 @@ type ShareNotebooksByUser struct {
 type ShareNote struct {
 	ShareNoteId bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
 	UserId      bson.ObjectId `bson:"UserId"`
-	ToUserId    bson.ObjectId `bson:"ToUserId"`
+	ToUserId    bson.ObjectId `bson:"ToUserId,omitempty"`
+	ToGroupId   bson.ObjectId `bson:"ToGroupId,omitempty"` // 分享给的用户组
+	ToGroup     Group         `ToGroup,omitempty`          // 仅仅为了显示, 不存储, 分组信息
 	NoteId      bson.ObjectId `bson:"NoteId"`
 	Perm        int           `bson:"Perm"` // 权限, 0只读, 1可修改
 	CreatedTime time.Time     `CreatedTime`

app/info/TagInfo.go

@@ -2,18 +2,55 @@ package info
 
 import (
 	"gopkg.in/mgo.v2/bson"
+	"time"
 )
 
 // 这里主要是为了统计每个tag的note数目
+// 暂时没用
+/*
 type TagNote struct {
 	TagId   bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
 	UserId  bson.ObjectId `bson:"UserId"`
 	Tag   string        `Title`   // 标题
 	NoteNum int           `NoteNum` // note数目
 }
+*/
 
 // 每个用户一条记录, 存储用户的所有tags
 type Tag struct {
-	UserId  bson.ObjectId `bson:"_id"`
-	Tags []string `Tags`
-}
+	UserId bson.ObjectId `bson:"_id"`
+	Tags   []string      `Tags`
+}
+
+// v2 版标签
+type NoteTag struct {
+	TagId       bson.ObjectId `bson:"_id"`
+	UserId      bson.ObjectId `UserId` // 谁的
+	Tag         string        `Tag`    // UserId, Tag是唯一索引
+	Usn         int           `Usn`    // Update Sequence Number
+	Count       int           `Count`  // 笔记数
+	CreatedTime time.Time     `CreatedTime`
+	UpdatedTime time.Time     `UpdatedTime`
+	IsDeleted   bool          `IsDeleted` // 删除位
+}
+
+type TagCount struct {
+	TagCountId bson.ObjectId `bson:"_id,omitempty"`
+	UserId     bson.ObjectId `UserId` // 谁的
+	Tag        string        `Tag`
+	IsBlog     bool          `IsBlog` // 是否是博客的tag统计
+	Count      int           `Count`  // 统计数量
+}
+
+/*
+type TagsCounts []TagCount
+func (this TagsCounts) Len() int {
+	return len(this)
+}
+func (this TagsCounts) Less(i, j int) bool {
+	return this[i].Count > this[j].Count
+}
+func (this TagsCounts) Swap(i, j int) {
+	this[i], this[j] = this[j], this[i]
+}
+*/

app/info/ThemeInfo.go

@@ -0,0 +1,26 @@
+package info
+
+import (
+	"gopkg.in/mgo.v2/bson"
+	"time"
+)
+
+// 主题, 每个用户有多个主题, 这里面有主题的配置信息
+// 模板, css, js, images, 都在路径Path下
+type Theme struct {
+	ThemeId   bson.ObjectId          `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
+	UserId    bson.ObjectId          `UserId`
+	Name      string                 `Name`
+	Version   string                 `Version`
+	Author    string                 `Author`
+	AuthorUrl string                 `AuthorUrl`
+	Path      string                 `Path`     // 文件夹路径, public/upload/54d7620d99c37b030600002c/themes/54d867c799c37b533e000001
+	Info      map[string]interface{} `Info`     // 所有信息
+	IsActive  bool                   `IsActive` // 是否在用
+
+	IsDefault bool   `IsDefault`       // leanote默认主题, 如果用户修改了默认主题, 则先copy之. 也是admin用户的主题
+	Style     string `Style,omitempty` // 之前的, 只有default的用户才有blog_default, blog_daqi, blog_left_fixed
+
+	CreatedTime time.Time `CreatedTime`
+	UpdatedTime time.Time `UpdatedTime`
+}

app/info/TokenInfo.go

@@ -18,7 +18,7 @@ const (
 
 // 过期时间
 const (
-	PwdOverHours = 2.0
+	PwdOverHours         = 2.0
 	ActiveEmailOverHours = 48.0
 	UpdateEmailOverHours = 2.0
 )
@@ -29,4 +29,4 @@ type Token struct {
 	Token       string        `Token`
 	Type        int           `Type`
 	CreatedTime time.Time     `CreatedTime`
-}
+}

app/info/UserInfo.go

@@ -34,4 +34,58 @@ type User struct {
 	ThirdUserId   string `ThirdUserId`   // 用户Id, 在第三方中唯一可识别
 	ThirdUsername string `ThirdUsername` // 第三方中username, 为了显示
 	ThirdType     int    `ThirdType`     // 第三方类型
+
+	// 用户的帐户类型
+
+	ImageNum   int           `bson:"ImageNum" json:"-"`   // 图片数量
+	ImageSize  int           `bson:"ImageSize" json:"-"`  // 图片大小
+	AttachNum  int           `bson:"AttachNum" json:"-"`  // 附件数量
+	AttachSize int           `bson:"AttachSize" json:"-"` // 附件大小
+	FromUserId bson.ObjectId `FromUserId,omitempty`       // 邀请的用户
+
+	AccountType      string    `bson:"AccountType" json:"-"`      // normal(为空), premium
+	AccountStartTime time.Time `bson:"AccountStartTime" json:"-"` // 开始日期
+	AccountEndTime   time.Time `bson:"AccountEndTime" json:"-"`   // 结束日期
+	// 阈值
+	MaxImageNum      int `bson:"MaxImageNums" json:"-"`     // 图片数量
+	MaxImageSize     int `bson:"MaxImageSize" json:"-"`     // 图片大小
+	MaxAttachNum     int `bson:"MaxAttachNum" json:"-"`     // 图片数量
+	MaxAttachSize    int `bson:"MaxAttachSize" json:"-"`    // 图片大小
+	MaxPerAttachSize int `bson:"MaxPerAttachSize" json:"-"` // 单个附件大小
+
+	// 2015/1/15, 更新序号
+	Usn            int       `Usn`                   // UpdateSequenceNum , 全局的
+	FullSyncBefore time.Time `bson:"FullSyncBefore"` // 需要全量同步的时间, 如果 > 客户端的LastSyncTime, 则需要全量更新
+}
+
+type UserAccount struct {
+	AccountType      string    `bson:"AccountType" json:"-"`      // normal(为空), premium
+	AccountStartTime time.Time `bson:"AccountStartTime" json:"-"` // 开始日期
+	AccountEndTime   time.Time `bson:"AccountEndTime" json:"-"`   // 结束日期
+	// 阈值
+	MaxImageNum      int `bson:"MaxImageNums" json:"-"`     // 图片数量
+	MaxImageSize     int `bson:"MaxImageSize" json:"-"`     // 图片大小
+	MaxAttachNum     int `bson:"MaxAttachNum" json:"-"`     // 图片数量
+	MaxAttachSize    int `bson:"MaxAttachSize" json:"-"`    // 图片大小
+	MaxPerAttachSize int `bson:"MaxPerAttachSize" json:"-"` // 单个附件大小
+}
+
+// note主页需要
+type UserAndBlogUrl struct {
+	User
+	BlogUrl string `BlogUrl`
+	PostUrl string `PostUrl`
+}
+
+// 用户与博客信息结合, 公开
+type UserAndBlog struct {
+	UserId    bson.ObjectId `bson:"_id,omitempty"` // 必须要设置bson:"_id" 不然mgo不会认为是主键
+	Email     string        `Email`                // 全是小写
+	Username  string        `Username`             // 不区分大小写, 全是小写
+	Logo      string        `Logo`
+	BlogTitle string        `BlogTitle` // 博客标题
+	BlogLogo  string        `BlogLogo`  // 博客Logo
+	BlogUrl   string        `BlogUrl`   // 博客链接, 主页
+
+	BlogUrls // 各个页面
 }

app/info/common.go

@@ -4,13 +4,13 @@ import (
 	"math"
 )
 
-
 // 分页数据
 type Page struct {
-	CurPage int // 当前页码
-	TotalPage int // 总页
-	Count int // 总记录数
-	List interface{}
+	CurPage     int // 当前页码
+	TotalPage   int // 总页
+	PerPageSize int
+	Count       int // 总记录数
+	List        interface{}
 }
 
 func NewPage(page, perPageSize, count int, list interface{}) Page {
@@ -18,5 +18,5 @@ func NewPage(page, perPageSize, count int, list interface{}) Page {
 	if count > 0 {
 		totalPage = int(math.Ceil(float64(count) / float64(perPageSize)))
 	}
-	return Page{page, totalPage, count, list}
-}
+	return Page{page, totalPage, perPageSize, count, list}
+}

app/init.go

@@ -1,61 +1,81 @@
 package app
 
 import (
-	"github.com/revel/revel"
-	. "github.com/leanote/leanote/app/lea"
-	"github.com/leanote/leanote/app/service"
-	"github.com/leanote/leanote/app/db"
+	"encoding/json"
+	"fmt"
 	"github.com/leanote/leanote/app/controllers"
 	"github.com/leanote/leanote/app/controllers/admin"
+	"github.com/leanote/leanote/app/controllers/api"
+	"github.com/leanote/leanote/app/controllers/member"
+	"github.com/leanote/leanote/app/db"
+	. "github.com/leanote/leanote/app/lea"
 	_ "github.com/leanote/leanote/app/lea/binder"
-	"github.com/leanote/leanote/app/lea/session"
-	"github.com/leanote/leanote/app/lea/memcache"
+	"github.com/leanote/leanote/app/lea/i18n"
 	"github.com/leanote/leanote/app/lea/route"
-	"reflect"
-	"fmt"
+	"github.com/leanote/leanote/app/service"
+	"github.com/revel/revel"
 	"html/template"
 	"math"
-	"strings"
+	"net/url"
+	"reflect"
 	"strconv"
+	"strings"
 	"time"
-	"encoding/json"
 )
 
 func init() {
 	// Filters is the default set of global filters.
 	revel.Filters = []revel.Filter{
-		revel.PanicFilter,             // Recover from panics and display an error page instead.
+		revel.PanicFilter, // Recover from panics and display an error page instead.
 		route.RouterFilter,
 		// revel.RouterFilter,            // Use the routing table to select the right Action
 		// AuthFilter,						// Invoke the action.
 		revel.FilterConfiguringFilter, // A hook for adding or removing per-Action filters.
 		revel.ParamsFilter,            // Parse parameters into Controller.Params.
-		// revel.SessionFilter,           // Restore and write the session cookie.
-		
+		revel.SessionFilter,           // Restore and write the session cookie.
+
 		// 使用SessionFilter标准版从cookie中得到sessionID, 然后通过MssessionFilter从Memcache中得到
 		// session, 之后MSessionFilter将session只存sessionID然后返回给SessionFilter返回到web
-		session.SessionFilter,         // leanote session 
-		// session.MSessionFilter,         // leanote memcache session 
-		
-		revel.FlashFilter,             // Restore and write the flash cookie.
-		revel.ValidationFilter,        // Restore kept validation errors and save new ones from cookie.
-		revel.I18nFilter,              // Resolve the requested language
-		revel.InterceptorFilter,       // Run interceptors around the action.
-		revel.CompressFilter,          // Compress the result.
-		revel.ActionInvoker,           // Invoke the action.
+		// session.SessionFilter,         // leanote session
+		// session.MSessionFilter,         // leanote memcache session
+
+		revel.FlashFilter,      // Restore and write the flash cookie.
+		revel.ValidationFilter, // Restore kept validation errors and save new ones from cookie.
+		// revel.I18nFilter,        // Resolve the requested language
+		i18n.I18nFilter,         // Resolve the requested language by leanote
+		revel.InterceptorFilter, // Run interceptors around the action.
+		revel.CompressFilter,    // Compress the result.
+		revel.ActionInvoker,     // Invoke the action.
 	}
-	
+
 	revel.TemplateFuncs["raw"] = func(str string) template.HTML {
 		return template.HTML(str)
 	}
+	revel.TemplateFuncs["trim"] = func(str string) string {
+		str = strings.Trim(str, " ")
+		str = strings.Trim(str, " ")
+
+		str = strings.Trim(str, "\n")
+		str = strings.Trim(str, " ")
+
+		// 以下两个空格不一样
+		str = strings.Trim(str, " ")
+		str = strings.Trim(str, " ")
+		return str
+	}
 	revel.TemplateFuncs["add"] = func(i int) string {
-		i = i + 1;
+		i = i + 1
 		return fmt.Sprintf("%v", i)
 	}
 	revel.TemplateFuncs["sub"] = func(i int) int {
-		i = i - 1;
+		i = i - 1
 		return i
 	}
+	// 增加或减少
+	revel.TemplateFuncs["incr"] = func(n, i int) int {
+		n = n + i
+		return n
+	}
 	revel.TemplateFuncs["join"] = func(arr []string) template.HTML {
 		if arr == nil {
 			return template.HTML("")
@@ -72,100 +92,205 @@ func init() {
 		}
 		return str
 	}
+	revel.TemplateFuncs["decodeUrlValue"] = func(i string) string {
+		v, _ := url.ParseQuery("a=" + i)
+		return v.Get("a")
+	}
 	revel.TemplateFuncs["json"] = func(i interface{}) string {
-		b, _ := json.Marshal(i) 
+		b, _ := json.Marshal(i)
 		return string(b)
 	}
+	revel.TemplateFuncs["jsonJs"] = func(i interface{}) template.JS {
+		b, _ := json.Marshal(i)
+		return template.JS(string(b))
+	}
 	revel.TemplateFuncs["datetime"] = func(t time.Time) template.HTML {
 		return template.HTML(t.Format("2006-01-02 15:04:05"))
 	}
+	revel.TemplateFuncs["dateFormat"] = func(t time.Time, format string) template.HTML {
+		return template.HTML(t.Format(format))
+	}
 	revel.TemplateFuncs["unixDatetime"] = func(unixSec string) template.HTML {
 		sec, _ := strconv.Atoi(unixSec)
 		t := time.Unix(int64(sec), 0)
 		return template.HTML(t.Format("2006-01-02 15:04:05"))
 	}
-	
+
 	// interface是否有该字段
 	revel.TemplateFuncs["has"] = func(i interface{}, key string) bool {
-		t := reflect.TypeOf(i) 
+		t := reflect.TypeOf(i)
 		_, ok := t.FieldByName(key)
 		return ok
 	}
 
 	// tags
+	// 2014/12/30 标签添加链接
 	revel.TemplateFuncs["blogTags"] = func(renderArgs map[string]interface{}, tags []string) template.HTML {
 		if tags == nil || len(tags) == 0 {
 			return ""
 		}
-		locale, _ := renderArgs[revel.CurrentLocaleRenderArg].(string)
+		locale, _ := renderArgs[revel.CurrentLocaleViewArg].(string)
 		tagStr := ""
 		lenTags := len(tags)
+
+		tagPostUrl, _ := renderArgs["tagPostsUrl"].(string)
+
 		for i, tag := range tags {
 			str := revel.Message(locale, tag)
+			var classes = "label"
 			if strings.HasPrefix(str, "???") {
 				str = tag
 			}
-			tagStr += str
-			if i != lenTags - 1 {
-				tagStr += ","
+			if InArray([]string{"red", "blue", "yellow", "green"}, tag) {
+				classes += " label-" + tag
+			} else {
+				classes += " label-default"
+			}
+
+			classes += " label-post"
+			var url = tagPostUrl + "/" + tag
+			tagStr += "<a class=\"" + classes + "\" href=\"" + url + "\">" + str + "</a>"
+			if i != lenTags-1 {
+				tagStr += " "
 			}
 		}
 		return template.HTML(tagStr)
 	}
-	/*
-	revel.TemplateFuncs["blogTags"] = func(tags []string) template.HTML {
+
+	revel.TemplateFuncs["blogTagsForExport"] = func(renderArgs map[string]interface{}, tags []string) template.HTML {
 		if tags == nil || len(tags) == 0 {
 			return ""
 		}
-		// TODO 这里判断语言, 从语言包中拿
-		tagMap := map[string]string{"red": "红色", "yellow": "黄色", "blue": "蓝色", "green": "绿色"}
 		tagStr := ""
 		lenTags := len(tags)
+
 		for i, tag := range tags {
-			if text, ok := tagMap[tag]; ok {
-				tagStr += text
+			str := tag
+			var classes = "label"
+			if InArray([]string{"red", "blue", "yellow", "green"}, tag) {
+				classes += " label-" + tag
 			} else {
-				tagStr += tag
+				classes += " label-default"
 			}
-			if i != lenTags - 1 {
-				tagStr += ","
+
+			classes += " label-post"
+			tagStr += "<span class=\"" + classes + "\" >" + str + "</span>"
+			if i != lenTags-1 {
+				tagStr += " "
 			}
 		}
 		return template.HTML(tagStr)
 	}
+
+	revel.TemplateFuncs["msg"] = func(renderArgs map[string]interface{}, message string, args ...interface{}) template.HTML {
+		str, ok := renderArgs[revel.CurrentLocaleViewArg].(string)
+		if !ok {
+			return ""
+		}
+		return template.HTML(i18n.Message(str, message, args...))
+	}
+
+	// 不用revel的msg
+	revel.TemplateFuncs["leaMsg"] = func(renderArgs map[string]interface{}, key string) template.HTML {
+		locale, _ := renderArgs[revel.CurrentLocaleViewArg].(string)
+		str := i18n.Message(locale, key)
+		if strings.HasPrefix(str, "???") {
+			str = key
+		}
+		return template.HTML(str)
+	}
+
+	// lea++
+	revel.TemplateFuncs["blogTagsLea"] = func(renderArgs map[string]interface{}, tags []string, typeStr string) template.HTML {
+		if tags == nil || len(tags) == 0 {
+			return ""
+		}
+		locale, _ := renderArgs[revel.CurrentLocaleViewArg].(string)
+		tagStr := ""
+		lenTags := len(tags)
+
+		tagPostUrl := "http://lea.leanote.com/"
+		if typeStr == "recommend" {
+			tagPostUrl += "?tag="
+		} else if typeStr == "latest" {
+			tagPostUrl += "latest?tag="
+		} else {
+			tagPostUrl += "subscription?tag="
+		}
+
+		for i, tag := range tags {
+			str := revel.Message(locale, tag)
+			var classes = "label"
+			if strings.HasPrefix(str, "???") {
+				str = tag
+			}
+			if InArray([]string{"red", "blue", "yellow", "green"}, tag) {
+				classes += " label-" + tag
+			} else {
+				classes += " label-default"
+			}
+			classes += " label-post"
+			var url = tagPostUrl + tag
+			tagStr += "<a class=\"" + classes + "\" href=\"" + url + "\">" + str + "</a>"
+			if i != lenTags-1 {
+				tagStr += " "
+			}
+		}
+		return template.HTML(tagStr)
+	}
+
+	/*
+		revel.TemplateFuncs["blogTags"] = func(tags []string) template.HTML {
+			if tags == nil || len(tags) == 0 {
+				return ""
+			}
+			// TODO 这里判断语言, 从语言包中拿
+			tagMap := map[string]string{"red": "红色", "yellow": "黄色", "blue": "蓝色", "green": "绿色"}
+			tagStr := ""
+			lenTags := len(tags)
+			for i, tag := range tags {
+				if text, ok := tagMap[tag]; ok {
+					tagStr += text
+				} else {
+					tagStr += tag
+				}
+				if i != lenTags - 1 {
+					tagStr += ","
+				}
+			}
+			return template.HTML(tagStr)
+		}
 	*/
 	revel.TemplateFuncs["li"] = func(a string) string {
-		Log(a)
-		Log("life==")
 		return ""
 	}
 	// str连接
-	revel.TemplateFuncs["urlConcat"] = func(url string, v... interface{}) string {
+	revel.TemplateFuncs["urlConcat"] = func(url string, v ...interface{}) string {
 		html := ""
 		for i := 0; i < len(v); i = i + 2 {
 			item := v[i]
 			if i+1 == len(v) {
-				break;
+				break
 			}
 			value := v[i+1]
 			if item != nil && value != nil {
-			    keyStr, _ := item.(string)
-			    valueStr, err := value.(string)
-			    if !err {
-				    valueInt, _ := value.(int)
-				    valueStr = strconv.Itoa(valueInt)
-			    }
-			    if keyStr != "" && valueStr != "" {
-			    	s := keyStr + "=" + valueStr
-		    		if html != "" {
-			    		html += "&" + s
-			    	} else {
-			    		html += s
-			    	}
-			    }
-		    }
+				keyStr, _ := item.(string)
+				valueStr, err := value.(string)
+				if !err {
+					valueInt, _ := value.(int)
+					valueStr = strconv.Itoa(valueInt)
+				}
+				if keyStr != "" && valueStr != "" {
+					s := keyStr + "=" + valueStr
+					if html != "" {
+						html += "&" + s
+					} else {
+						html += s
+					}
+				}
+			}
 		}
-		
+
 		if html != "" {
 			if strings.Index(url, "?") >= 0 {
 				return url + "&" + html
@@ -175,51 +300,51 @@ func init() {
 		}
 		return url
 	}
-	
+
 	revel.TemplateFuncs["urlCond"] = func(url string, sorterI, keyords interface{}) template.HTML {
 		return ""
 	}
-	
+
 	// http://stackoverflow.com/questions/14226416/go-lang-templates-always-quotes-a-string-and-removes-comments
 	revel.TemplateFuncs["rawMsg"] = func(renderArgs map[string]interface{}, message string, args ...interface{}) template.JS {
-		str, ok := renderArgs[revel.CurrentLocaleRenderArg].(string)
+		str, ok := renderArgs[revel.CurrentLocaleViewArg].(string)
 		if !ok {
 			return ""
 		}
 		return template.JS(revel.Message(str, message, args...))
 	}
-	
+
 	// 为后台管理sorter th使用
 	// 必须要返回HTMLAttr, 返回html, golang 会执行安全检查返回ZgotmplZ
 	// sorterI 可能是nil, 所以用interfalce{}来接收
 	/*
-	data-url="/adminUser/index"
-	data-sorter="email"
-	class="th-sortable {{if eq .sorter "email-up"}}th-sort-up{{else}}{{if eq .sorter "email-down"}}th-sort-down{{end}}{{end}}"
+		data-url="/adminUser/index"
+		data-sorter="email"
+		class="th-sortable {{if eq .sorter "email-up"}}th-sort-up{{else}}{{if eq .sorter "email-down"}}th-sort-down{{end}}{{end}}"
 	*/
 	revel.TemplateFuncs["sorterTh"] = func(url, sorterField string, sorterI interface{}) template.HTMLAttr {
 		sorter := ""
 		if sorterI != nil {
 			sorter, _ = sorterI.(string)
 		}
-		html := "data-url=\"" + url + "\" data-sorter=\"" + sorterField + "\"";
-		html += " class=\"th-sortable ";
-		if sorter == sorterField + "-up" {
-			html += "th-sort-up\"";
-		} else if(sorter == sorterField + "-down") {
-			html += "th-sort-down";
+		html := "data-url=\"" + url + "\" data-sorter=\"" + sorterField + "\""
+		html += " class=\"th-sortable "
+		if sorter == sorterField+"-up" {
+			html += "th-sort-up\""
+		} else if sorter == sorterField+"-down" {
+			html += "th-sort-down"
 		}
-		html += "\"";
+		html += "\""
 		return template.HTMLAttr(html)
 	}
-	
+
 	// pagination
 	revel.TemplateFuncs["page"] = func(urlBase string, page, pageSize, count int) template.HTML {
 		if count == 0 {
-			return "";
+			return ""
 		}
-		totalPage := int(math.Ceil(float64(count)/float64(pageSize)))
-		
+		totalPage := int(math.Ceil(float64(count) / float64(pageSize)))
+
 		preClass := ""
 		prePage := page - 1
 		if prePage == 0 {
@@ -228,10 +353,10 @@ func init() {
 		nextClass := ""
 		nextPage := page + 1
 		var preUrl, nextUrl string
-		
-		preUrl = urlBase + "?page="  + strconv.Itoa(prePage)
+
+		preUrl = urlBase + "?page=" + strconv.Itoa(prePage)
 		nextUrl = urlBase + "?page=" + strconv.Itoa(nextPage)
-		
+
 		// 没有上一页了
 		if page == 1 {
 			preClass = "disabled"
@@ -248,60 +373,64 @@ func init() {
 	// https://groups.google.com/forum/#!topic/golang-nuts/OEdSDgEC7js
 	// http://play.golang.org/p/snygrVpQva
 	// http://grokbase.com/t/gg/golang-nuts/142a6dhfh3/go-nuts-text-template-using-comparison-operators-eq-gt-etc-on-non-existent-variable-causes-the-template-to-stop-outputting-but-with-no-error-correct-behaviour
-	revel.TemplateFuncs["gt"] = func(a1, a2 interface{}) bool {
-		switch a1.(type) {
-		case string:
-			switch a2.(type) {
-			case string:
-				return reflect.ValueOf(a1).String() > reflect.ValueOf(a2).String()
-			}
-		case int, int8, int16, int32, int64:
-			switch a2.(type) {
-			case int, int8, int16, int32, int64:
-				return reflect.ValueOf(a1).Int() > reflect.ValueOf(a2).Int()
-			}
-		case uint, uint8, uint16, uint32, uint64:
-			switch a2.(type) {
-			case uint, uint8, uint16, uint32, uint64:
-				return reflect.ValueOf(a1).Uint() > reflect.ValueOf(a2).Uint()
-			}
-		case float32, float64:
-			switch a2.(type) {
-			case float32, float64:
-				return reflect.ValueOf(a1).Float() > reflect.ValueOf(a2).Float()
-			}
-		}
-		return false
-	}
-	
 	/*
-	{{range $i := N 1 10}}
-        <div>{{$i}}</div>
-    {{end}}
-   */
+		revel.TemplateFuncs["gt"] = func(a1, a2 interface{}) bool {
+			switch a1.(type) {
+			case string:
+				switch a2.(type) {
+				case string:
+					return reflect.ValueOf(a1).String() > reflect.ValueOf(a2).String()
+				}
+			case int, int8, int16, int32, int64:
+				switch a2.(type) {
+				case int, int8, int16, int32, int64:
+					return reflect.ValueOf(a1).Int() > reflect.ValueOf(a2).Int()
+				}
+			case uint, uint8, uint16, uint32, uint64:
+				switch a2.(type) {
+				case uint, uint8, uint16, uint32, uint64:
+					return reflect.ValueOf(a1).Uint() > reflect.ValueOf(a2).Uint()
+				}
+			case float32, float64:
+				switch a2.(type) {
+				case float32, float64:
+					return reflect.ValueOf(a1).Float() > reflect.ValueOf(a2).Float()
+				}
+			}
+			return false
+		}
+	*/
+
+	/*
+			{{range $i := N 1 10}}
+		        <div>{{$i}}</div>
+		    {{end}}
+	*/
 	revel.TemplateFuncs["N"] = func(start, end int) (stream chan int) {
-	    stream = make(chan int)
-	    go func() {
-	        for i := start; i <= end; i++ {
-	            stream <- i
-	        }
-	        close(stream)
-	    }()
-	    return
+		stream = make(chan int)
+		go func() {
+			for i := start; i <= end; i++ {
+				stream <- i
+			}
+			close(stream)
+		}()
+		return
 	}
-	
+
 	// init Email
 	revel.OnAppStart(func() {
 		// 数据库
-		db.Init()
+		db.Init("", "")
 		// email配置
 		InitEmail()
 		InitVd()
-		memcache.InitMemcache() // session服务
+		// memcache.InitMemcache() // session服务
 		// 其它service
 		service.InitService()
 		controllers.InitService()
 		admin.InitService()
+		member.InitService()
 		service.ConfigS.InitGlobalConfigs()
+		api.InitService()
 	})
-}
+}

app/lea/Debug.go

@@ -1,15 +1,34 @@
 package lea
 
 import (
-	"encoding/json"
-	"github.com/revel/revel"
+    "encoding/json"
+    "fmt"
+    "github.com/revel/revel"
 )
 
-func Log(i interface{}) {
-	revel.INFO.Println(i)
+func Log(msg string, i ...interface{}) {
+    revel.AppLog.Info(msg, i...)
+}
+
+func Logf(msg string, i ...interface{}) {
+    revel.AppLog.Infof(msg, i...)
+}
+
+func LogW(msg string, i ...interface{}) {
+    revel.AppLog.Warn(msg, i...)
 }
 
 func LogJ(i interface{}) {
-	b, _ := json.MarshalIndent(i, "", "	") 
-	revel.INFO.Println(string(b))
-}
+    b, _ := json.MarshalIndent(i, "", " ")
+    revel.AppLog.Info(string(b))
+}
+
+// 为test用
+func L(i interface{}) {
+    fmt.Println(i)
+}
+
+func LJ(i interface{}) {
+    b, _ := json.MarshalIndent(i, "", " ")
+    fmt.Println(string(b))
+}

app/lea/Email.go

@@ -1,10 +1,11 @@
 package lea
 
 import (
+	"github.com/revel/revel"
 	"net/smtp"
 	"strings"
-	"github.com/revel/revel"
 )
+
 // 发送邮件
 var host = "smtp.ym.163.com"
 var port = "25"
@@ -12,7 +13,7 @@ var username = "noreply@leanote.com"
 var password = "---"
 
 func InitEmail() {
-	config := revel.Config;
+	config := revel.Config
 	host, _ = config.String("email.host")
 	port, _ = config.String("email.port")
 	username, _ = config.String("email.username")
@@ -56,28 +57,28 @@ var bodyTpl = `
 	</body>
 	</html>
 `
+
 func SendEmailOld(to, subject, body string) bool {
 	hp := strings.Split(host, ":")
 	auth := smtp.PlainAuth("", username, password, hp[0])
-	
+
 	var content_type string
-	
+
 	mailtype := "html"
 	if mailtype == "html" {
-		content_type = "Content-Type: text/"+ mailtype + "; charset=UTF-8"
-	} else{
+		content_type = "Content-Type: text/" + mailtype + "; charset=UTF-8"
+	} else {
 		content_type = "Content-Type: text/plain" + "; charset=UTF-8"
 	}
-	
+
 	//body = strings.Replace(bodyTpl, "$body", body, 1)
 	//body = strings.Replace(body, "$title", title, 1)
 
-	msg := []byte("To: " + to + "\r\nFrom: " + username + "<"+ username +">\r\nSubject: " + subject + "\r\n" + content_type + "\r\n\r\n" + body)
+	msg := []byte("To: " + to + "\r\nFrom: " + username + "<" + username + ">\r\nSubject: " + subject + "\r\n" + content_type + "\r\n\r\n" + body)
 	send_to := strings.Split(to, ";")
 	err := smtp.SendMail(host+":"+port, auth, username, send_to, msg)
-	
+
 	if err != nil {
-		Log(err)
 		return false
 	}
 	return true
@@ -85,5 +86,5 @@ func SendEmailOld(to, subject, body string) bool {
 
 func SendToLeanoteOld(subject, title, body string) {
 	to := "leanote@leanote.com"
-	SendEmailOld(to, subject, body);
-}
+	SendEmailOld(to, subject, body)
+}

app/lea/File.go

@@ -1,10 +1,11 @@
 package lea
 
 import (
-	"strings"
-	"path/filepath"
-	"os"
 	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
 )
 
 // 分离文件名与扩展名(包含.)
@@ -14,14 +15,14 @@ func SplitFilename(filename string) (baseName, ext string) {
 	ext = SubstringByte(filename, strings.LastIndex(filename, "."))
 	baseName = strings.TrimRight(filename, ext)
 	ext = strings.ToLower(ext)
-	return;
+	return
 }
 
 // 转换文件的格式
 // toExt包含.
 func TransferExt(path string, toExt string) string {
-	dir := filepath.Dir(path) + "/"  // 文件路径
-	name := filepath.Base(path) // 文件名 a.jpg
+	dir := filepath.Dir(path) + "/" // 文件路径
+	name := filepath.Base(path)     // 文件名 a.jpg
 	// 获取文件名与路径
 	baseName, _ := SplitFilename(name)
 	return dir + baseName + toExt
@@ -38,7 +39,7 @@ func GetFilesize(path string) int64 {
 	if err == nil {
 		return fileinfo.Size()
 	}
-	return 0;
+	return 0
 }
 
 // 清空dir下所有的文件和文件夹
@@ -55,6 +56,14 @@ func ClearDir(dir string) bool {
 	return true
 }
 
+func MkdirAll(dir string) bool {
+	err := os.MkdirAll(dir, 0777)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
 // list dir's all file, return filenames
 func ListDir(dir string) []string {
 	f, err := os.Open(dir)
@@ -79,12 +88,102 @@ func CopyFile(srcName, dstName string) (written int64, err error) {
 	return io.Copy(dst, src)
 }
 
+func CopyDir(source string, dest string) (err error) {
+	// get properties of source dir
+	sourceinfo, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+
+	// create dest dir
+
+	err = os.MkdirAll(dest, sourceinfo.Mode())
+	if err != nil {
+		return err
+	}
+
+	directory, _ := os.Open(source)
+
+	objects, err := directory.Readdir(-1)
+
+	for _, obj := range objects {
+
+		sourcefilepointer := source + "/" + obj.Name()
+
+		destinationfilepointer := dest + "/" + obj.Name()
+
+		if obj.IsDir() {
+			// create sub-directories - recursively
+			err = CopyDir(sourcefilepointer, destinationfilepointer)
+			if err != nil {
+				//				fmt.Println(err)
+			}
+		} else {
+			// perform copy
+			_, err = CopyFile(sourcefilepointer, destinationfilepointer)
+			if err != nil {
+				//				fmt.Println(err)
+			}
+		}
+	}
+	return
+}
+
+func DeleteFile(path string) bool {
+	err := os.Remove(path)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
 func IsDirExists(path string) bool {
-    fi, err := os.Stat(path)
-    if err != nil {
-        return os.IsExist(err)
-    }else{
-        return fi.IsDir()
-    }
-    return false
-}
+	fi, err := os.Stat(path)
+	if err != nil {
+		return os.IsExist(err)
+	} else {
+		return fi.IsDir()
+	}
+	return false
+}
+
+// 获得文件str内容
+func GetFileStrContent(path string) string {
+	fileBytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		return ""
+	}
+	return string(fileBytes)
+}
+
+func IsFileExist(filename string) bool {
+	var exist = true
+	if _, err := os.Stat(filename); os.IsNotExist(err) {
+		exist = false
+	}
+	return exist
+}
+
+// 写入string内容
+func PutFileStrContent(path, content string) bool {
+	var f *os.File
+	var err1 error
+	defer (func() {
+		if f != nil {
+			f.Close()
+		}
+	})()
+	f, err1 = os.OpenFile(path, os.O_RDWR|os.O_TRUNC|os.O_CREATE, 0666) //打开文件
+	//	Log(err1)
+	//	var n int
+	_, err1 = io.WriteString(f, content) //写入文件(字符串)
+	//	Log(content)
+	//	Log(err1)
+	//	Log(n)
+	//	Log(path)
+
+	if err1 != nil {
+		return false
+	}
+	return true
+}

app/lea/Image.go

@@ -16,7 +16,7 @@ func TransToGif(path string, maxWidth uint, afterDelete bool) (ok bool, transPat
 	transPath = path
 	wand.Genesis()
     defer wand.Terminus()
-    
+
     w := wand.NewMagickWand()
     defer w.Destroy()
 
@@ -24,7 +24,7 @@ func TransToGif(path string, maxWidth uint, afterDelete bool) (ok bool, transPat
     	fmt.Println(err);
     	return;
     }
-    
+
     width := w.ImageWidth()
     height := w.ImageHeight()
     if maxWidth != 0 {
@@ -34,14 +34,14 @@ func TransToGif(path string, maxWidth uint, afterDelete bool) (ok bool, transPat
 	    	width = maxWidth
 	    }
     }
-    
+
 	w.SetImageFormat("GIF");
 
     if err := paint.Thumbnail(w, width, height); err != nil {
     	fmt.Println(err);
     	return;
     }
-    
+
     // 判断是否是gif图片, 是就不用转换了
 	baseName, ext := SplitFilename(path)
     var toPath string
@@ -50,19 +50,19 @@ func TransToGif(path string, maxWidth uint, afterDelete bool) (ok bool, transPat
     } else {
 	    toPath = TransferExt(path, ".gif");
     }
-    
+
     if err := w.WriteImage(toPath); err != nil {
     	fmt.Println(err);
     	return;
     }
-    
+
     if afterDelete {
     	os.Remove(path)
     }
-    
+
     ok = true
     transPath = toPath
-    
+
     return
 }
 
@@ -71,7 +71,7 @@ func TransToGif(path string, maxWidth uint, afterDelete bool) (ok bool, transPat
 func Reset(path string, maxWidth uint) (ok bool, transPath string){
 	wand.Genesis()
     defer wand.Terminus()
-    
+
     w := wand.NewMagickWand()
     defer w.Destroy()
 
@@ -79,7 +79,7 @@ func Reset(path string, maxWidth uint) (ok bool, transPath string){
     	fmt.Println(err);
     	return;
     }
-    
+
     width := w.ImageWidth()
     height := w.ImageHeight()
     if maxWidth != 0 {
@@ -93,20 +93,20 @@ func Reset(path string, maxWidth uint) (ok bool, transPath string){
     	fmt.Println(err);
     	return;
     }
-    
+
     toPath := TransferExt(path, ".gif");
     if err := w.WriteImage(toPath); err != nil {
     	fmt.Println(err);
     	return;
     }
-    
+
     ok = true
     transPath = toPath
-    
+
     return
 }
 */
 
 func TransToGif(path string, maxWidth uint, afterDelete bool) (ok bool, transPath string) {
 	return ok, path
-}
+}

app/lea/Pwd.go

@@ -0,0 +1,22 @@
+package lea
+
+// 对比密码是否一致
+// 因为之前密码是用md5加密的, 所以通过密码长度来判断
+// rawPwd 原始, 用户输入的密码
+func ComparePwd(rawPwd, dbPwd string) bool {
+	if len(dbPwd) == 32 {
+		return Md5(rawPwd) == dbPwd
+	}
+
+	hex := []byte(dbPwd)
+	return CompareHash(hex, rawPwd)
+}
+
+// 加密
+func GenPwd(rawPwd string) string {
+	digest, err := GenerateHash(rawPwd)
+	if err != nil {
+		return ""
+	}
+	return string(digest)
+}

app/lea/Util.go

@@ -1,16 +1,19 @@
 package lea
 
 import (
-	"fmt"
-	"regexp"
+	"bytes"
 	"crypto/md5"
 	"crypto/rand"
 	"encoding/base64"
 	"encoding/hex"
-	"io"
+	"fmt"
+	"github.com/PuerkitoBio/goquery"
 	"gopkg.in/mgo.v2/bson"
+	"io"
+	math_rand "math/rand"
+	"regexp"
+	"strings"
 	"time"
-	math_rand "math/rand" 
 )
 
 // 字符串
@@ -22,6 +25,22 @@ func Md5(s string) string {
 	return hex.EncodeToString(h.Sum(nil))
 }
 
+// 3位数的转换, 为了用bson.id -> 3位数
+func Digest3(str string) string {
+	var b rune = 0
+	for _, k := range str {
+		b += k
+	}
+	return fmt.Sprintf("%d", b%1000)
+}
+func Digest2(str string) string {
+	var b rune = 0
+	for _, k := range str {
+		b += k
+	}
+	return fmt.Sprintf("%d", b%100)
+}
+
 // Guid
 func NewGuid() string {
 	b := make([]byte, 48)
@@ -58,7 +77,7 @@ func Substr(str string, start, length int) string {
 func substr(str string, start, length int, isRune bool) string {
 	rs := []rune(str)
 	rs2 := []byte(str)
-	
+
 	rl := len(rs)
 	if !isRune {
 		rl = len(rs2)
@@ -122,39 +141,49 @@ func ReplaceAll(oldStr, pattern, newStr string) string {
 	return string(s)
 }
 
-func SubStringHTML(param string, length int, end string) string {
-	// 先取出<pre></pre>占位..
-	
-	result := ""
-
-	// 1
+// 获取纯文本
+func SubStringHTMLToRaw(param string, length int) string {
+	if param == "" {
+		return param
+	}
 	n := 0
 	var temp rune // 中文问题, 用rune来解决
-	isCode := false //是不是HTML代码
-	isHTML := false //是不是HTML特殊字符,如&nbsp;
 	rStr := []rune(param)
-	for i := 0; i < len(rStr); i++ {
+	lenStr := len(rStr)
+	isCode := false
+
+	resultRune := make([]rune, length)
+	// s := ""
+	for i := 0; i < lenStr; i++ {
 		temp = rStr[i]
 		if temp == '<' {
 			isCode = true
-		} else if temp == '&' {
-			isHTML = true
-		} else if temp == '>' && isCode {
-			n = n - 1
+			continue
+		} else if temp == '>' {
 			isCode = false
-		} else if temp == ';' && isHTML {
-			isHTML = false
+			resultRune[n] = ' '
+
+			n++
+			if n >= length {
+				break
+			}
+			continue
 		}
-		if !isCode && !isHTML {
-			n = n + 1
-		}
-		result += string(temp)
-		if n >= length {
-			break
+		if !isCode {
+			resultRune[n] = temp
+			// s += string(temp)
+			n++
+			if n >= length {
+				break
+			}
 		}
 	}
-	result += end
-	
+	result := string(resultRune[0:n])
+	return strings.Trim(result, " ")
+}
+
+// 自带方法补全html
+func fixHtml(result string) string {
 	// 取出所有标签
 	tempResult := ReplaceAll(result, "(>)[^<>]*(<?)", "$1$2") // 把标签中间的所有内容都去掉了
 
@@ -163,13 +192,13 @@ func SubStringHTML(param string, length int, end string) string {
 
 	// 把<div class=xxx的class=xxx去掉
 	tempResult = ReplaceAll(tempResult, "<(/?[a-zA-Z]+)[^<>]*>", "<$1>")
-	
+
 	// 3 只能用正则,+stack来去有结束的
 	// golang的正则暂不支持back reference, 以后可以用它来去掉重复的标签
 	p, _ := regexp.Compile("<(/?[a-zA-Z]+)[^<>]*>") // 得到所有的<div>, </div>...
 	strs := p.FindAllString(tempResult, -1)
 
-//	fmt.Println(strs)
+	//	fmt.Println(strs)
 	stack := make([]string, len(strs))
 	stackP := -1
 	for _, each := range strs {
@@ -186,16 +215,82 @@ func SubStringHTML(param string, length int, end string) string {
 	// 补全tag
 	if stackP != -1 {
 		fmt.Println(stack[0 : stackP+1])
-		
+
 		for _, each := range stack[0 : stackP+1] {
 			if each[1] != '/' {
 				result += "</" + each[1:]
 			}
 		}
 	}
-	
+
 	return result
 }
+
+// 获取摘要, HTML
+func SubStringHTML(param string, length int, end string) string {
+	if param == "" {
+		return param
+	}
+	result := ""
+
+	rStr := []rune(param)
+	lenStr := len(rStr)
+
+	if lenStr <= length {
+		result = param
+	} else {
+		// 1
+		n := 0
+		var temp rune   // 中文问题, 用rune来解决
+		isCode := false //是不是HTML代码
+		isHTML := false //是不是HTML特殊字符,如&nbsp;
+		var i = 0
+		for ; i < lenStr; i++ {
+			temp = rStr[i]
+			if temp == '<' {
+				isCode = true
+			} else if temp == '&' {
+				isHTML = true
+			} else if temp == '>' && isCode {
+				// n = n - 1
+				isCode = false
+			} else if temp == ';' && isHTML {
+				isHTML = false
+			}
+			if !isCode && !isHTML {
+				n = n + 1
+			}
+			// 每一次都相加, 速度非常慢!, 重新分配内存, 7倍的差距
+			// result += string(temp)
+			if n >= length {
+				break
+			}
+		}
+
+		result = string(rStr[0:i])
+
+		if end != "" {
+			result += end
+		}
+	}
+
+	// 使用goquery来取出html, 为了补全html
+	htmlReader := bytes.NewBufferString(result)
+	dom, err1 := goquery.NewDocumentFromReader(htmlReader)
+	if err1 == nil {
+		html, _ := dom.Html()
+		html = strings.Replace(html, "<html><head></head><body>", "", 1)
+		html = strings.Replace(html, "</body></html>", "", 1)
+
+		// TODO 把style="float: left"去掉
+		return html
+
+		// 如果有错误, 则使用自己的方法补全, 有风险
+	} else {
+		return fixHtml(result)
+	}
+}
+
 // 是否是合格的密码
 func IsGoodPwd(pwd string) (bool, string) {
 	if pwd == "" {
@@ -210,16 +305,16 @@ func IsGoodPwd(pwd string) (bool, string) {
 // 是否是email
 func IsEmail(email string) bool {
 	if email == "" {
-		return false;
+		return false
 	}
-	ok, _ := regexp.MatchString(`^([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+\.[0-9a-zA-Z]{2,3}$`, email)
+	ok, _ := regexp.MatchString(`^([a-zA-Z0-9]+[_|\_|\.|\-]?)*[_a-z\-A-Z0-9]+@([a-zA-Z0-9]+[_|\_|\.|\-]?)*[a-zA-Z0-9\-]+\.[0-9a-zA-Z]{2,6}$`, email)
 	return ok
 }
 
 // 是否只包含数字, 字母 -, _
 func IsUsername(username string) bool {
 	if username == "" {
-		return false;
+		return false
 	}
 	ok, _ := regexp.MatchString(`[^0-9a-zA-Z_\-]`, username)
 	return !ok
@@ -256,15 +351,15 @@ func RandomPwd(num int) string {
 		chars[j] = byte(i)
 		j++
 	}
-	j--;
-	
+	j--
+
 	str := ""
 	math_rand.Seed(time.Now().UnixNano())
 	for i := 0; i < num; i++ {
 		x := math_rand.Intn(j)
 		str += string(chars[x])
 	}
-	
+
 	return str
 }
 
@@ -278,4 +373,58 @@ func InArray(arr []string, str string) bool {
 		}
 	}
 	return false
-}
+}
+
+// 将名称的特殊字符去掉
+func FixFilename(filename string) string {
+	if filename != "" {
+		// 把特殊字段给替换掉
+		//		str := `life "%&()+,/:;<>=?@\|`
+		// . == \\.
+		// $ === \\$
+		reg, _ := regexp.Compile("\\.|/|#|\\$|!|\\^|\\*|'| |\"|%|&|\\(|\\)|\\+|\\,|/|:|;|<|>|=|\\?|@|\\||\\\\")
+		filename = reg.ReplaceAllString(filename, "-")
+		filename = strings.Trim(filename, "-") // 左右单独的-去掉
+		// 把空格替换成-
+		//		filename = strings.Replace(filename, " ", "-", -1)
+		for strings.Index(filename, "--") >= 0 { // 防止出现连续的--
+			filename = strings.Replace(filename, "--", "-", -1)
+		}
+		return filename
+	}
+	return filename
+}
+
+// 是否是合法的时间
+// 不是, 0001-01-01T00:00:00Z, 且比今天小
+func IsValidTime(t time.Time) bool {
+	if t.Year() > 20 {
+		now := time.Now()
+		if t.Before(now) {
+			return true
+		}
+	}
+	return false
+}
+
+// url传过来的时间没有时区信息, 转到本地时间
+func ToLocalTime(t time.Time) time.Time {
+	return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), 0, time.Local)
+}
+
+// 修复传过来的时间, 如果比今天大, 则设为现在
+func FixUrlTime(t time.Time) time.Time {
+	localTime := ToLocalTime(t)
+	if IsValidTime(localTime) {
+		return localTime
+	}
+	return time.Now()
+}
+
+// 得到用户的随机文件路径 3位/userId/2位
+func GetRandomFilePath(userId, uuid string) string {
+	if uuid == "" {
+		uuid = NewGuid()
+	}
+	return Digest3(userId) + "/" + userId + "/" + Digest2(uuid)
+}

app/lea/Vd.go

@@ -2,8 +2,8 @@ package lea
 
 import (
 	"encoding/json"
-	"strconv"
 	"regexp"
+	"strconv"
 )
 
 // 验证
@@ -27,20 +27,26 @@ var rulesStr = `{
 	],
 	"domain": [
 		{"rule": "domain", "msg": "errorDomain"}
+	],
+	"perPageSize": [
+		{"rule": "min", "data": "1", "msg": "errorPerPageSize"}
+	],
+	"sortField": [
+		{"rule": "sortField", "msg": "errorSortField"}
 	]
 }
 `
 var rulesMap map[string][]map[string]string
 
-var rules = map[string]func(string, map[string]string)(bool, string) {
-	"required": func(value string, rule map[string]string)(ok bool, msg string) {
+var rules = map[string]func(string, map[string]string) (bool, string){
+	"required": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			return
 		}
 		ok = true
-		return 
+		return
 	},
-	"minLength": func(value string, rule map[string]string)(ok bool, msg string) {
+	"minLength": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			return
 		}
@@ -49,22 +55,41 @@ var rules = map[string]func(string, map[string]string)(bool, string) {
 		ok = len(value) >= dataI
 		return
 	},
-	
-	"password": func(value string, rule map[string]string)(ok bool, msg string) {
+	"min": func(value string, rule map[string]string) (ok bool, msg string) {
+		if value == "" {
+			return
+		}
+		data := rule["data"]
+		dataI, _ := strconv.Atoi(data)
+		vI, _ := strconv.Atoi(value)
+		ok = vI >= dataI
+		return
+	},
+
+	"sortField": func(value string, rule map[string]string) (ok bool, msg string) {
+		if value == "" {
+			return
+		}
+		sortFields := []string{"PublicTime", "CreatedTime", "UpdatedTime", "Title"}
+		ok = InArray(sortFields, value)
+		return
+	},
+
+	"password": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			return
 		}
 		ok = len(value) >= 6
 		return
 	},
-	"email": func(value string, rule map[string]string)(ok bool, msg string) {
+	"email": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			return
 		}
 		ok = IsEmail(value)
 		return
 	},
-	"noSpecialChars": func(value string, rule map[string]string)(ok bool, msg string) {
+	"noSpecialChars": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			return
 		}
@@ -72,8 +97,8 @@ var rules = map[string]func(string, map[string]string)(bool, string) {
 		return
 	},
 	// www.baidu.com
-	// 
-	"domain": func(value string, rule map[string]string)(ok bool, msg string) {
+	//
+	"domain": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			ok = true
 			return // 可为空
@@ -81,16 +106,16 @@ var rules = map[string]func(string, map[string]string)(bool, string) {
 		ok2, _ := regexp.MatchString(`[^0-9a-zA-Z_\.\-]`, value)
 		ok = !ok2
 		if !ok {
-			return 
+			return
 		}
 		ok = true
 		return
 	},
 	// abcd
-	"subDomain": func(value string, rule map[string]string)(ok bool, msg string) {
+	"subDomain": func(value string, rule map[string]string) (ok bool, msg string) {
 		if value == "" {
 			ok = true
-			return  // 可为空
+			return // 可为空
 		}
 		if len(value) < 4 {
 			ok = false
@@ -112,7 +137,7 @@ func InitVd() {
 
 func Vd(name, value string) (ok bool, msg string) {
 	rs, _ := rulesMap[name]
-	
+
 	for _, rule := range rs {
 		ruleFunc, _ := rules[rule["rule"]]
 		if ok2, msg2 := ruleFunc(value, rule); !ok2 {
@@ -126,11 +151,11 @@ func Vd(name, value string) (ok bool, msg string) {
 			if msgData != "" {
 				msg += "-" + msgData
 			}
-			return 
+			return
 		}
 	}
 	ok = true
-	return 
+	return
 }
 
 func Vds(m map[string]string) (ok bool, msg string) {
@@ -141,5 +166,5 @@ func Vds(m map[string]string) (ok bool, msg string) {
 		}
 	}
 	ok = true
-	return 
+	return
 }

app/lea/archive/tar.go

@@ -0,0 +1,230 @@
+package archive
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"os"
+	"path"
+)
+
+// main functions shows how to TarGz a directory/file and
+// UnTarGz a file
+// Gzip and tar from source directory or file to destination file
+// you need check file exist before you call this function
+
+func main() {
+	/*
+	   os.Mkdir("/home/ty4z2008/tar", 0777)
+	   w, err := CopyFile("/home/ty4z2008/tar/1.pdf", "/home/ty4z2008/src/1.pdf")
+	   //targetfile,sourcefile
+	   if err != nil {
+	       fmt.Println(err.Error())
+	   }
+	   fmt.Println(w)
+
+	   TarGz("/home/ty4z2008/tar/1.pdf", "/home/ty4z2008/test.tar.gz") //压缩
+	   //UnTarGz("/home/ty4z2008/1.tar.gz", "/home/ty4z2008")     //解压
+	   os.RemoveAll("/home/ty4z2008/tar")
+	*/
+	//    TaZip("/Users/life/Desktop/j", "/Users/life/Desktop/aaa.tar.gz")
+	Zip("/Users/life/Desktop/j", "/Users/life/Desktop/aaa.zip")
+	fmt.Println("ok")
+}
+
+func TarGz(srcDirPath string, destFilePath string) (ok bool) {
+	defer func() { //必须要先声明defer，否则不能捕获到panic异常
+		if err := recover(); err != nil {
+			ok = false
+		}
+
+	}()
+
+	fw, err := os.Create(destFilePath)
+
+	if err != nil {
+		panic(err)
+	}
+	defer fw.Close()
+
+	// Gzip writer
+	gw := gzip.NewWriter(fw)
+	defer gw.Close()
+
+	// Tar writer
+	tw := tar.NewWriter(gw)
+	defer tw.Close()
+
+	// Check if it's a file or a directory
+	f, err := os.Open(srcDirPath)
+	if err != nil {
+		panic(err)
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		panic(err)
+	}
+	if fi.IsDir() {
+		// handle source directory
+		//        fmt.Println("Cerating tar.gz from directory...")
+		tarGzDir(srcDirPath, path.Base(srcDirPath), tw)
+	} else {
+		// handle file directly
+		//        fmt.Println("Cerating tar.gz from " + fi.Name() + "...")
+		tarGzFile(srcDirPath, fi.Name(), tw, fi)
+	}
+	ok = true
+	return
+}
+
+// Deal with directories
+// if find files, handle them with tarGzFile
+// Every recurrence append the base path to the recPath
+// recPath is the path inside of tar.gz
+func tarGzDir(srcDirPath string, recPath string, tw *tar.Writer) {
+	// Open source diretory
+	dir, err := os.Open(srcDirPath)
+	if err != nil {
+		panic(err)
+	}
+	defer dir.Close()
+
+	// Get file info slice
+	fis, err := dir.Readdir(0)
+	if err != nil {
+		panic(err)
+	}
+	for _, fi := range fis {
+		// Append path
+		curPath := srcDirPath + "/" + fi.Name()
+		// Check it is directory or file
+		if fi.IsDir() {
+			// Directory
+			// (Directory won't add unitl all subfiles are added)
+			//            fmt.Printf("Adding path...%s\n", curPath)
+			tarGzDir(curPath, recPath+"/"+fi.Name(), tw)
+		} else {
+			// File
+			//            fmt.Printf("Adding file...%s\n", curPath)
+		}
+
+		tarGzFile(curPath, recPath+"/"+fi.Name(), tw, fi)
+	}
+}
+
+// Deal with files
+func tarGzFile(srcFile string, recPath string, tw *tar.Writer, fi os.FileInfo) {
+	if fi.IsDir() {
+		//    	fmt.Println("??")
+		// Create tar header
+		hdr := new(tar.Header)
+		// if last character of header name is '/' it also can be directory
+		// but if you don't set Typeflag, error will occur when you untargz
+		hdr.Name = recPath // + "/"
+		//        fmt.Println(hdr.Name)
+		hdr.Typeflag = tar.TypeDir
+		//        hdr.Size = 0
+		//hdr.Mode = 0755 | c_ISDIR
+		//        hdr.Mode = int64(fi.Mode()) // 加这个会有错误!!!
+		//        hdr.ModTime = fi.ModTime() // 加这个会有错误!!
+
+		// Write hander
+		err := tw.WriteHeader(hdr)
+		if err != nil {
+			panic(err)
+		}
+	} else {
+		// File reader
+		fr, err := os.Open(srcFile)
+		if err != nil {
+			panic(err)
+		}
+		defer fr.Close()
+
+		// Create tar header
+		hdr := new(tar.Header)
+		hdr.Name = recPath
+		//        fmt.Println(hdr.Name)
+		hdr.Size = fi.Size()
+		hdr.Mode = int64(fi.Mode())
+		hdr.ModTime = fi.ModTime()
+
+		// Write hander
+		err = tw.WriteHeader(hdr)
+		if err != nil {
+			panic(err)
+		}
+
+		// Write file data
+		_, err = io.Copy(tw, fr)
+		if err != nil {
+			panic(err)
+		}
+	}
+}
+
+// Ungzip and untar from source file to destination directory
+// you need check file exist before you call this function
+func UnTarGz(srcFilePath string, destDirPath string) {
+	//    fmt.Println("UnTarGzing " + srcFilePath + "...")
+	// Create destination directory
+	os.Mkdir(destDirPath, os.ModePerm)
+
+	fr, err := os.Open(srcFilePath)
+	if err != nil {
+		panic(err)
+	}
+	defer fr.Close()
+
+	// Gzip reader
+	gr, err := gzip.NewReader(fr)
+	if err != nil {
+		panic(err)
+	}
+	defer gr.Close()
+
+	// Tar reader
+	tr := tar.NewReader(gr)
+
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			// End of tar archive
+			break
+		}
+		//handleError(err)
+		//        fmt.Println("UnTarGzing file..." + hdr.Name)
+		// Check if it is diretory or file
+		if hdr.Typeflag != tar.TypeDir {
+			// Get files from archive
+			// Create diretory before create file
+			os.MkdirAll(destDirPath+"/"+path.Dir(hdr.Name), os.ModePerm)
+			// Write data to file
+			fw, _ := os.Create(destDirPath + "/" + hdr.Name)
+			if err != nil {
+				panic(err)
+			}
+			_, err = io.Copy(fw, tr)
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+	//    fmt.Println("Well done!")
+}
+
+// Copyfile
+func CopyFile(dstName, srcName string) (written int64, err error) {
+	src, err := os.Open(srcName)
+	if err != nil {
+		return
+	}
+	defer src.Close()
+	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return
+	}
+	defer dst.Close()
+	return io.Copy(dst, src)
+}

app/lea/archive/zip.go

@@ -0,0 +1,199 @@
+package archive
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"strings"
+	"github.com/leanote/leanote/app/lea"
+)
+
+// main functions shows how to TarGz a directory/file and
+// UnTarGz a file
+// Gzip and tar from source directory or file to destination file
+// you need check file exist before you call this function
+
+func Zip(srcDirPath string, destFilePath string) (ok bool) {
+	defer func() { //必须要先声明defer，否则不能捕获到panic异常
+		if err := recover(); err != nil {
+			ok = false
+		}
+	}()
+
+	fw, err := os.Create(destFilePath)
+
+	if err != nil {
+		panic(err)
+	}
+	defer fw.Close()
+
+	// Tar writer
+	tw := zip.NewWriter(fw)
+	defer tw.Close()
+
+	// Check if it's a file or a directory
+	f, err := os.Open(srcDirPath)
+	if err != nil {
+		panic(err)
+	}
+	fi, err := f.Stat()
+	if err != nil {
+		panic(err)
+	}
+	if fi.IsDir() {
+		// handle source directory
+		//        fmt.Println("Cerating tar.gz from directory...")
+		zipDir(srcDirPath, path.Base(srcDirPath), tw)
+	} else {
+		// handle file directly
+		//        fmt.Println("Cerating tar.gz from " + fi.Name() + "...")
+		zipFile(srcDirPath, fi.Name(), tw, fi)
+	}
+	ok = true
+	return
+}
+
+// Deal with directories
+// if find files, handle them with zipFile
+// Every recurrence append the base path to the recPath
+// recPath is the path inside of tar.gz
+func zipDir(srcDirPath string, recPath string, tw *zip.Writer) {
+	// Open source diretory
+	dir, err := os.Open(srcDirPath)
+	if err != nil {
+		panic(err)
+	}
+	defer dir.Close()
+
+	// Get file info slice
+	fis, err := dir.Readdir(0)
+	if err != nil {
+		panic(err)
+	}
+	for _, fi := range fis {
+		// Append path
+		curPath := srcDirPath + "/" + fi.Name()
+		// Check it is directory or file
+		if fi.IsDir() {
+			// Directory
+			// (Directory won't add unitl all subfiles are added)
+			//            fmt.Printf("Adding path...%s\n", curPath)
+			zipDir(curPath, recPath+"/"+fi.Name(), tw)
+		} else {
+			// File
+			//            fmt.Printf("Adding file...%s\n", curPath)
+		}
+
+		zipFile(curPath, recPath+"/"+fi.Name(), tw, fi)
+	}
+}
+
+// Deal with files
+func zipFile(srcFile string, recPath string, tw *zip.Writer, fi os.FileInfo) {
+	if fi.IsDir() {
+		//    	fmt.Println("??")
+		// Create tar header
+		/*
+		   fh, err := zip.FileInfoHeader(fi)
+		   if err != nil {
+		       panic(err)
+		   }
+		   fh.Name = recPath // + "/"
+		   err = tw.WriteHeader(hdr)
+		   tw.Create(recPath)
+		*/
+	} else {
+		// File reader
+		fr, err := os.Open(srcFile)
+		if err != nil {
+			panic(err)
+		}
+		defer fr.Close()
+
+		// Write hander
+		w, err2 := tw.Create(recPath)
+		if err2 != nil {
+			panic(err)
+		}
+		// Write file data
+		_, err = io.Copy(w, fr)
+		if err != nil {
+			panic(err)
+		}
+	}
+}
+
+// Ungzip and untar from source file to destination directory
+// you need check file exist before you call this function
+func Unzip(srcFilePath string, destDirPath string) (ok bool, msg string) {
+	ok = false
+	msg = ""
+
+	defer func() { //必须要先声明defer，否则不能捕获到panic异常
+		if err := recover(); err != nil {
+			msg = fmt.Sprintf("%v", err)
+			ok = false
+		}
+	}()
+
+	os.Mkdir(destDirPath, os.ModePerm)
+	r, err := zip.OpenReader(srcFilePath)
+	if err != nil {
+		panic(err)
+	}
+	defer r.Close()
+	for _, f := range r.File {
+		// fmt.Println("FileName : ", f.Name); // j/aaa.zip
+		rc, err := f.Open()
+		if err != nil {
+			panic(err)
+		}
+
+		// 包含恶意目录
+		if strings.Contains(f.Name, "../") {
+			lea.LogW("恶意文件", f.Name);
+			continue
+		}
+
+		// 把首文件夹去掉, 即j去掉, 分离出文件夹和文件名
+		paths := strings.Split(f.Name, "/")
+		prePath := ""
+		filename := ""
+		l := len(paths)
+		//		fmt.Println(l)
+		if l > 1 {
+			// 去掉第1个文件夹
+			if l == 2 {
+				filename = paths[1]
+			} else {
+				filename = paths[l-1]
+				prePath = strings.Join(paths[1:l-1], "/")
+			}
+		} else {
+			filename = f.Name
+		}
+		//		fmt.Println(prePath)
+
+		// 相对于目标文件件下的路径
+		destPath := destDirPath + "/" + filename
+		if prePath != "" {
+			os.MkdirAll(destDirPath+"/"+prePath, os.ModePerm)
+			destPath = destDirPath + "/" + prePath + "/" + filename
+		}
+		// Write data to file
+		//        fmt.Println(destPath)
+		fw, _ := os.Create(destPath)
+		if err != nil {
+			panic(err)
+		}
+		_, err = io.Copy(fw, rc)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	ok = true
+	return
+}

app/lea/binder/binder.go

@@ -1,9 +1,9 @@
 package binder
 
 import (
-	"github.com/revel/revel"
 	"github.com/leanote/leanote/app/info"
-	"github.com/leanote/leanote/app/controllers"
+	"github.com/revel/revel"
+	//	"github.com/leanote/leanote/app/controllers/api"
 	"fmt"
 	"reflect"
 	"strings"
@@ -11,7 +11,7 @@ import (
 
 // leanote binder struct
 // rewrite revel struct binder
-// not need the struct name as prefix, 
+// not need the struct name as prefix,
 // eg:
 // type Note struct {Name}
 // func (c Controller) List(note Note) revel.Result {}
@@ -33,13 +33,13 @@ var MSSBinder = revel.Binder{
 		}
 		return result
 	},
-	
+
 	Unbind: func(output map[string]string, name string, val interface{}) {
 		mapValue := reflect.ValueOf(val)
 		for _, key := range mapValue.MapKeys() {
 			revel.Unbind(output, fmt.Sprintf("%v", key.Interface()),
 				mapValue.MapIndex(key).Interface())
-		}	
+		}
 	},
 }
 
@@ -53,31 +53,56 @@ func nextKey(key string) string {
 	}
 	return key[:fieldLen]
 }
+
 var leanoteStructBinder = revel.Binder{
+	// name == "noteOrContent"
 	Bind: func(params *revel.Params, name string, typ reflect.Type) reflect.Value {
-		result := reflect.New(typ).Elem()
+		result := reflect.New(typ).Elem() // 创建一个该类型的, 然后其field从所有的param去取
 		fieldValues := make(map[string]reflect.Value)
-		for key, _ := range params.Values {
+		//		fmt.Println(name)
+		// fmt.Println(typ) // api.NoteFiles
+		// name = files[0], files[1], noteContent
+		//		fmt.Println(params.Values)
+		/*
+			map[Title:[test1] METHOD:[POST] NotebookId:[54c4f51705fcd14031000002]
+			files[1][FileId]:[]
+			controller:[note]
+			files[1][LocalFileId]:[54c7ae27d98d0329dd000000] files[1][HasBody]:[true] files[0][FileId]:[] files[0][LocalFileId]:[54c7ae855e94ea2dba000000] action:[addNote] Content:[<p>lifedddddd</p><p><img src="app://leanote/data/54bdc65599c37b0da9000002/images/1422368307147_2.png" alt="" data-mce-src="app://leanote/data/54bdc65599c37b0da9000002/images/1422368307147_2.png" style="display: block; margin-left: auto; margin-right: auto;"></p><p><img src="http://127.0.0.1:8008/api/file/getImage?fileId=54c7ae27d98d0329dd000000" alt="" data-mce-src="http://127.0.0.1:8008/api/file/getImg?fileId=54c7ae27d98d0329dd000000"></p><p><br></p><p><img src="http://127.0.0.1:8008/api/file/getImage?fileId=54c7ae855e94ea2dba000000" alt="" data-mce-src="http://127.0.0.1:8008/api/file/getImage?fileId=54c7ae855e94ea2dba000000" style="display: block; margin-left: auto; margin-right: auto;"></p><p><br></p><p><br></p>] IsBlog:[false] token:[user1]
+			files[0][HasBody]:[true]]
+		*/
+		nameIsSlice := strings.Contains(name, "[")
+		//		fmt.Println(params.Values["files[1]"])
+		//		fmt.Println(params.Values["Title"])
+		for key, _ := range params.Values { // Title, Content, Files
 			// 这里, 如果没有点, 默认就是a.
 			// life
+			//			fmt.Println("key:" + key); // files[0][LocalFileId]
+			//			fmt.Println("name:" + name); // files[0][LocalFileId]
 			var suffix string
 			var noPrefix = false
-			if !strings.HasPrefix(key, name + ".") {
+			if nameIsSlice && strings.HasPrefix(key, name) {
+				suffix = key[len(name)+1 : len(key)-1] // files[0][LocalFileId] 去掉 => LocalFileId
+			} else if !strings.HasPrefix(key, name+".") {
 				noPrefix = true
 				suffix = key
-	//			continue
+				//			continue
 			} else {
 				// Get the name of the struct property.
 				// Strip off the prefix. e.g. foo.bar.baz => bar.baz
 				suffix = key[len(name)+1:]
 			}
-	
+			//			fmt.Println(suffix);
+
 			fieldName := nextKey(suffix) // e.g. bar => "bar", bar.baz => "bar", bar[0] => "bar"
+			//			fmt.Println(fieldName);
 			fieldLen := len(fieldName)
-			
+
 			if _, ok := fieldValues[fieldName]; !ok {
 				// Time to bind this field.  Get it and make sure we can set it.
+				fieldName = strings.Title(fieldName) // 传过来title, 但struct是Title
+				//				fmt.Println("xx: " + fieldName)
 				fieldValue := result.FieldByName(fieldName)
+				//				fmt.Println(fieldValue)
 				if !fieldValue.IsValid() {
 					continue
 				}
@@ -86,9 +111,17 @@ var leanoteStructBinder = revel.Binder{
 				}
 				var boundVal reflect.Value
 				// 没有name前缀
-				if(noPrefix) {
+				if noPrefix {
+					// life
+					//					fmt.Println("<<")
+					//					fmt.Println(strings.Title(key[:fieldLen]));
 					boundVal = revel.Bind(params, key[:fieldLen], fieldValue.Type())
 				} else {
+					//					fmt.Println("final")
+					//					fmt.Println(key[:len(name)+1+fieldLen]) // files[0][HasBody
+					if nameIsSlice {
+						fieldLen += 1
+					}
 					boundVal = revel.Bind(params, key[:len(name)+1+fieldLen], fieldValue.Type())
 				}
 				fieldValue.Set(boundVal)
@@ -116,5 +149,8 @@ func init() {
 	revel.TypeBinders[reflect.TypeOf(info.UserBlogComment{})] = leanoteStructBinder
 	revel.TypeBinders[reflect.TypeOf(info.UserBlogStyle{})] = leanoteStructBinder
 	revel.TypeBinders[reflect.TypeOf(info.Notebook{})] = leanoteStructBinder
-	revel.TypeBinders[reflect.TypeOf(controllers.NoteOrContent{})] = leanoteStructBinder
-}
+	revel.TypeBinders[reflect.TypeOf(info.UserAccount{})] = leanoteStructBinder
+	revel.TypeBinders[reflect.TypeOf(info.NoteOrContent{})] = leanoteStructBinder
+	revel.TypeBinders[reflect.TypeOf(info.ApiNote{})] = leanoteStructBinder
+	revel.TypeBinders[reflect.TypeOf(info.NoteFile{})] = leanoteStructBinder
+}

app/lea/blog/Template.go

@@ -0,0 +1,298 @@
+package blog
+
+import (
+	. "github.com/leanote/leanote/app/lea"
+	"github.com/revel/revel"
+	"html/template"
+	"io/ioutil"
+	//	"os"
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+//--------------------
+// leanote 自定义主题
+// 不使用revel的模板机制
+// By life
+//--------------------
+
+var ts = []string{"header.html", "footer.html", "highlight.html", "comment.html", "view.html", "404.html"}
+var selfTs = []string{"header.html", "footer.html", "index.html", "about_me.html"} // 用户自定义的文件列表
+
+type BlogTpl struct {
+	Template    *template.Template
+	PathContent map[string]string // path => content
+}
+
+func (this *BlogTpl) Content(name string) string {
+	return this.PathContent[name]
+}
+
+var BlogTplObject *BlogTpl
+var CloneTemplate *template.Template
+
+type RenderTemplateResult struct {
+	Template    *template.Template
+	PathContent map[string]string
+	ViewArgs map[string]interface{}
+
+	IsPreview  bool // 是否是预览
+	CurBlogTpl *BlogTpl
+}
+
+func parseTemplateError(err error) (templateName string, line int, description string) {
+	description = err.Error()
+	i := regexp.MustCompile(`:\d+:`).FindStringIndex(description)
+	if i != nil {
+		line, err = strconv.Atoi(description[i[0]+1 : i[1]-1])
+		if err != nil {
+		}
+		templateName = description[:i[0]]
+		if colon := strings.Index(templateName, ":"); colon != -1 {
+			templateName = templateName[colon+1:]
+		}
+		templateName = strings.TrimSpace(templateName)
+		description = description[i[1]+1:]
+	}
+	return templateName, line, description
+}
+func (r *RenderTemplateResult) render(req *revel.Request, resp *revel.Response, wr io.Writer) {
+	err := r.Template.Execute(wr, r.ViewArgs)
+	if err == nil {
+		return
+	}
+
+	var templateContent []string
+	templateName, line, description := parseTemplateError(err)
+	var content = ""
+	if templateName == "" {
+		templateName = r.Template.Name()
+		content = r.PathContent[templateName]
+	} else {
+		content = r.PathContent[templateName]
+	}
+	if content != "" {
+		templateContent = strings.Split(content, "\n")
+	}
+
+	compileError := &revel.Error{
+		Title:       "Template Execution Error",
+		Path:        templateName,
+		Description: description,
+		Line:        line,
+		SourceLines: templateContent,
+	}
+
+	// 这里, 错误!!
+	// 这里应该导向到本主题的错误页面
+	resp.Status = 500
+	ErrorResult{r.ViewArgs, compileError, r.IsPreview, r.CurBlogTpl}.Apply(req, resp)
+}
+
+func (r *RenderTemplateResult) Apply(req *revel.Request, resp *revel.Response) {
+	// Handle panics when rendering templates.
+	defer func() {
+		if err := recover(); err != nil {
+		}
+	}()
+
+	chunked := revel.Config.BoolDefault("results.chunked", false)
+
+	// If it's a HEAD request, throw away the bytes.
+	out := io.Writer(resp.GetWriter())
+	if req.Method == "HEAD" {
+		out = ioutil.Discard
+	}
+
+	// In a prod mode, write the status, render, and hope for the best.
+	// (In a dev mode, always render to a temporary buffer first to avoid having
+	// error pages distorted by HTML already written)
+	if chunked && !revel.DevMode {
+		resp.WriteHeader(http.StatusOK, "text/html; charset=utf-8")
+		r.render(req, resp, out) // 这里!!!
+		return
+	}
+
+	// Render the template into a temporary buffer, to see if there was an error
+	// rendering the template.  If not, then copy it into the response buffer.
+	// Otherwise, template render errors may result in unpredictable HTML (and
+	// would carry a 200 status code)
+	var b bytes.Buffer
+	r.render(req, resp, &b)
+	if !chunked {
+		resp.Out.Header().Set("Content-Length", strconv.Itoa(b.Len()))
+	}
+	resp.WriteHeader(http.StatusOK, "text/html; charset=utf-8")
+	b.WriteTo(out)
+}
+
+// 博客模板
+func Init() {
+	BlogTplObject = &BlogTpl{PathContent: map[string]string{}}
+	BlogTplObject.Template = template.New("blog").Funcs(revel.TemplateFuncs)
+	for _, path := range ts {
+		fileBytes, _ := ioutil.ReadFile(revel.ViewsPath + "/Blog/" + path)
+		fileStr := string(fileBytes)
+		path := "blog/" + path
+		//		path := path
+		BlogTplObject.PathContent[path] = fileStr
+		BlogTplObject.Template.New(path).Parse(fileStr) // 以blog为根
+	}
+	// 复制一份
+	CloneTemplate, _ = BlogTplObject.Template.Clone()
+}
+
+// name = index.html, search.html, cate.html, page.html
+// basePath 表未用户主题的基路径, 如/xxx/public/upload/32323232/themes/theme1, 如果没有, 则表示用自带的
+// isPreview 如果是, 错误提示则显示系统的 500 错误详情信息, 供debug
+//
+func RenderTemplate(name string, args map[string]interface{}, basePath string, isPreview bool) revel.Result {
+	var r *RenderTemplateResult
+	// 传来的主题路径为空, 则用系统的
+	// 都不会为空的
+	if basePath == "" {
+		path := "blog/" + name
+		//		path := name
+		t := BlogTplObject.Template.Lookup(path)
+		r = &RenderTemplateResult{
+			Template:    t,
+			PathContent: BlogTplObject.PathContent, // 为了显示错误
+			ViewArgs:  args,                      // 把args给它
+		}
+	} else {
+		// 复制一份
+		newBlogTplObject := &BlogTpl{}
+		var err error
+		newBlogTplObject.Template, err = CloneTemplate.Clone() // 复制一份, 为防止多用户出现问题, 因为newBlogTplObject是全局的
+		if err != nil {
+			return nil
+		}
+		newBlogTplObject.PathContent = map[string]string{}
+		for k, v := range BlogTplObject.PathContent {
+			newBlogTplObject.PathContent[k] = v
+		}
+
+		// 将该basePath下的所有文件提出
+		files := ListDir(basePath)
+		for _, t := range files {
+			if !strings.Contains(t, ".html") {
+				continue
+			}
+			fileBytes, err := ioutil.ReadFile(basePath + "/" + t)
+			if err != nil {
+				continue
+			}
+			fileStr := string(fileBytes)
+			newBlogTplObject.PathContent[t] = fileStr
+			newBlogTplObject.Template.New(t).Parse(fileStr)
+		}
+
+		// 如果本主题下没有, 则用系统的
+		t := newBlogTplObject.Template.Lookup(name)
+
+		if t == nil {
+			path := "blog/" + name
+			t = BlogTplObject.Template.Lookup(path)
+		}
+		r = &RenderTemplateResult{
+			Template:    t,
+			PathContent: newBlogTplObject.PathContent, // 为了显示错误
+			ViewArgs:  args,
+			CurBlogTpl:  newBlogTplObject,
+			IsPreview:   isPreview,
+		}
+	}
+
+	return r
+}
+
+////////////////////
+//
+
+type ErrorResult struct {
+	ViewArgs map[string]interface{}
+	Error      error
+	IsPreview  bool
+	CurBlogTpl *BlogTpl
+}
+
+// 错误显示出
+func (r ErrorResult) Apply(req *revel.Request, resp *revel.Response) {
+	format := req.Format
+	status := resp.Status
+	if status == 0 {
+		status = http.StatusInternalServerError
+	}
+
+	contentType := revel.ContentTypeByFilename("xxx." + format)
+	if contentType == revel.DefaultFileContentType {
+		contentType = "text/plain"
+	}
+
+	// Get the error template.
+	var err error
+	templatePath := fmt.Sprintf("errors/%d.%s", status, format)
+	err = nil
+	//	tmpl, err := revel.MainTemplateLoader.Template("index.html") // 这里找到错误页面主题
+
+	// This func shows a plaintext error message, in case the template rendering
+	// doesn't work.
+	showPlaintext := func(err error) {
+		revel.PlaintextErrorResult{fmt.Errorf("Server Error:\n%s\n\n"+
+			"Additionally, an error occurred when rendering the error page:\n%s",
+			r.Error, err)}.Apply(req, resp)
+	}
+
+	// 根据是否是preview来得到404模板
+	// 是, 则显示系统的错误信息, blog-500.html
+	var tmpl *template.Template
+	if r.IsPreview {
+		tmpl = r.CurBlogTpl.Template.Lookup("blog/404.html")
+	} else {
+		tmpl = r.CurBlogTpl.Template.Lookup("404.html")
+	}
+	if tmpl == nil {
+		if err == nil {
+			err = fmt.Errorf("Couldn't find template %s", templatePath)
+		}
+		showPlaintext(err)
+		return
+	}
+
+	// If it's not a revel error, wrap it in one.
+	var revelError *revel.Error
+	switch e := r.Error.(type) {
+	case *revel.Error:
+		revelError = e
+	case error:
+		revelError = &revel.Error{
+			Title:       "Server Error",
+			Description: e.Error(),
+		}
+	}
+
+	if revelError == nil {
+		panic("no error provided")
+	}
+
+	if r.ViewArgs == nil {
+		r.ViewArgs = make(map[string]interface{})
+	}
+	r.ViewArgs["Error"] = revelError
+	r.ViewArgs["Router"] = revel.MainRouter
+
+	// 不是preview就不要显示错误了
+	if r.IsPreview {
+		var b bytes.Buffer
+		out := io.Writer(resp.GetWriter())
+		//	out = ioutil.Discard
+		err = tmpl.Execute(&b, r.ViewArgs)
+		resp.WriteHeader(http.StatusOK, "text/html; charset=utf-8")
+		b.WriteTo(out)
+	}
+}

app/lea/captcha/Captcha.go

@@ -1,399 +1,401 @@
 package captcha
 
 import (
-    "image"
-    "image/color"
-    "image/png"
-    "io"
-    "math/rand"
-    crand "crypto/rand"
-    "time"
-    "strconv"
-)
-const (
-    stdWidth = 100
-    stdHeight = 40
-    maxSkew = 2
+	crand "crypto/rand"
+	"image"
+	"image/color"
+	"image/png"
+	"io"
+	"math/rand"
+	"strconv"
+	"time"
 )
 
 const (
-    fontWidth  = 5
-    fontHeight = 8
-    blackChar  = 1
+	stdWidth  = 100
+	stdHeight = 40
+	maxSkew   = 2
 )
- 
+
+const (
+	fontWidth  = 5
+	fontHeight = 8
+	blackChar  = 1
+)
+
 var font = [][]byte{
-    { // 0
-        0, 1, 1, 1, 0,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        0, 1, 1, 1, 0,
-    },
-    { // 1
-        0, 0, 1, 0, 0,
-        0, 1, 1, 0, 0,
-        1, 0, 1, 0, 0,
-        0, 0, 1, 0, 0,
-        0, 0, 1, 0, 0,
-        0, 0, 1, 0, 0,
-        0, 0, 1, 0, 0,
-        1, 1, 1, 1, 1,
-    },
-    { // 2
-        0, 1, 1, 1, 0,
-        1, 0, 0, 0, 1,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 1, 1,
-        0, 1, 1, 0, 0,
-        1, 0, 0, 0, 0,
-        1, 0, 0, 0, 0,
-        1, 1, 1, 1, 1,
-    },
-    { // 3
-        1, 1, 1, 1, 0,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 1, 0,
-        0, 1, 1, 1, 0,
-        0, 0, 0, 1, 0,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 0, 1,
-        1, 1, 1, 1, 0,
-    },
-    { // 4
-        1, 0, 0, 1, 0,
-        1, 0, 0, 1, 0,
-        1, 0, 0, 1, 0,
-        1, 0, 0, 1, 0,
-        1, 1, 1, 1, 1,
-        0, 0, 0, 1, 0,
-        0, 0, 0, 1, 0,
-        0, 0, 0, 1, 0,
-    },
-    { // 5
-        1, 1, 1, 1, 1,
-        1, 0, 0, 0, 0,
-        1, 0, 0, 0, 0,
-        1, 1, 1, 1, 0,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 0, 1,
-        1, 1, 1, 1, 0,
-    },
-    { // 6
-        0, 0, 1, 1, 1,
-        0, 1, 0, 0, 0,
-        1, 0, 0, 0, 0,
-        1, 1, 1, 1, 0,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        0, 1, 1, 1, 0,
-    },
-    { // 7
-        1, 1, 1, 1, 1,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 1, 0,
-        0, 0, 1, 0, 0,
-        0, 1, 0, 0, 0,
-        0, 1, 0, 0, 0,
-        0, 1, 0, 0, 0,
-    },
-    { // 8
-        0, 1, 1, 1, 0,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        0, 1, 1, 1, 0,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        0, 1, 1, 1, 0,
-    },
-    { // 9
-        0, 1, 1, 1, 0,
-        1, 0, 0, 0, 1,
-        1, 0, 0, 0, 1,
-        1, 1, 0, 0, 1,
-        0, 1, 1, 1, 1,
-        0, 0, 0, 0, 1,
-        0, 0, 0, 0, 1,
-        1, 1, 1, 1, 0,
-    },
+	{ // 0
+		0, 1, 1, 1, 0,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		0, 1, 1, 1, 0,
+	},
+	{ // 1
+		0, 0, 1, 0, 0,
+		0, 1, 1, 0, 0,
+		1, 0, 1, 0, 0,
+		0, 0, 1, 0, 0,
+		0, 0, 1, 0, 0,
+		0, 0, 1, 0, 0,
+		0, 0, 1, 0, 0,
+		1, 1, 1, 1, 1,
+	},
+	{ // 2
+		0, 1, 1, 1, 0,
+		1, 0, 0, 0, 1,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 1, 1,
+		0, 1, 1, 0, 0,
+		1, 0, 0, 0, 0,
+		1, 0, 0, 0, 0,
+		1, 1, 1, 1, 1,
+	},
+	{ // 3
+		1, 1, 1, 1, 0,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 1, 0,
+		0, 1, 1, 1, 0,
+		0, 0, 0, 1, 0,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 0, 1,
+		1, 1, 1, 1, 0,
+	},
+	{ // 4
+		1, 0, 0, 1, 0,
+		1, 0, 0, 1, 0,
+		1, 0, 0, 1, 0,
+		1, 0, 0, 1, 0,
+		1, 1, 1, 1, 1,
+		0, 0, 0, 1, 0,
+		0, 0, 0, 1, 0,
+		0, 0, 0, 1, 0,
+	},
+	{ // 5
+		1, 1, 1, 1, 1,
+		1, 0, 0, 0, 0,
+		1, 0, 0, 0, 0,
+		1, 1, 1, 1, 0,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 0, 1,
+		1, 1, 1, 1, 0,
+	},
+	{ // 6
+		0, 0, 1, 1, 1,
+		0, 1, 0, 0, 0,
+		1, 0, 0, 0, 0,
+		1, 1, 1, 1, 0,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		0, 1, 1, 1, 0,
+	},
+	{ // 7
+		1, 1, 1, 1, 1,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 1, 0,
+		0, 0, 1, 0, 0,
+		0, 1, 0, 0, 0,
+		0, 1, 0, 0, 0,
+		0, 1, 0, 0, 0,
+	},
+	{ // 8
+		0, 1, 1, 1, 0,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		0, 1, 1, 1, 0,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		0, 1, 1, 1, 0,
+	},
+	{ // 9
+		0, 1, 1, 1, 0,
+		1, 0, 0, 0, 1,
+		1, 0, 0, 0, 1,
+		1, 1, 0, 0, 1,
+		0, 1, 1, 1, 1,
+		0, 0, 0, 0, 1,
+		0, 0, 0, 0, 1,
+		1, 1, 1, 1, 0,
+	},
 }
- 
+
 type Image struct {
-    *image.NRGBA
-    color   *color.NRGBA
-    width   int  //a digit width
-    height  int  //a digit height
-    dotsize int
+	*image.NRGBA
+	color   *color.NRGBA
+	width   int //a digit width
+	height  int //a digit height
+	dotsize int
 }
-func init(){
-    rand.Seed(int64(time.Second))
+
+func init() {
+	rand.Seed(int64(time.Second))
 }
- 
+
 func NewImage(digits []byte, width, height int) *Image {
-    img := new(Image)
-    r := image.Rect(img.width, img.height, stdWidth, stdHeight)
-    img.NRGBA = image.NewNRGBA(r)
-     
-    img.color = &color.NRGBA{
-        uint8(rand.Intn(129)),
-        uint8(rand.Intn(129)),
-        uint8(rand.Intn(129)),
-        0xFF,
-    }
-    // Draw background (10 random circles of random brightness)
-    img.calculateSizes(width, height, len(digits))
-    img.fillWithCircles(10, img.dotsize)
- 
-    maxx := width - (img.width+img.dotsize)*len(digits) - img.dotsize
-    maxy := height - img.height - img.dotsize*2
- 
-    x := rnd(img.dotsize*2, maxx)
-    y := rnd(img.dotsize*2, maxy)
- 
-    // Draw digits.
-    for _, n := range digits {
-        img.drawDigit(font[n], x, y)
-        x += img.width + img.dotsize
-    }
- 
-    // Draw strike-through line.
-    // 中间线不要
-    //img.strikeThrough()
-    
-    return img
+	img := new(Image)
+	r := image.Rect(img.width, img.height, stdWidth, stdHeight)
+	img.NRGBA = image.NewNRGBA(r)
+
+	img.color = &color.NRGBA{
+		uint8(rand.Intn(129)),
+		uint8(rand.Intn(129)),
+		uint8(rand.Intn(129)),
+		0xFF,
+	}
+	// Draw background (10 random circles of random brightness)
+	img.calculateSizes(width, height, len(digits))
+	img.fillWithCircles(10, img.dotsize)
+
+	maxx := width - (img.width+img.dotsize)*len(digits) - img.dotsize
+	maxy := height - img.height - img.dotsize*2
+
+	x := rnd(img.dotsize*2, maxx)
+	y := rnd(img.dotsize*2, maxy)
+
+	// Draw digits.
+	for _, n := range digits {
+		img.drawDigit(font[n], x, y)
+		x += img.width + img.dotsize
+	}
+
+	// Draw strike-through line.
+	// 中间线不要
+	//img.strikeThrough()
+
+	return img
 }
- 
+
 func (img *Image) WriteTo(w io.Writer) (int64, error) {
-    return 0, png.Encode(w, img)
+	return 0, png.Encode(w, img)
 }
- 
+
 func (img *Image) calculateSizes(width, height, ncount int) {
- 
-    // Goal: fit all digits inside the image.
-    var border int
-    if width > height {
-        border = height / 5
-    } else {
-        border = width / 5
-    }
-    // Convert everything to floats for calculations.
-    w := float64(width - border*2) //268
-    h := float64(height - border*2) //48
-    // fw takes into account 1-dot spacing between digits.
- 
-    fw := float64(fontWidth) + 1 //6
- 
-    fh := float64(fontHeight)  //8
-    nc := float64(ncount)  //7
- 
-    // Calculate the width of a single digit taking into account only the
-    // width of the image.
-    nw := w / nc //38
-    // Calculate the height of a digit from this width.
-    nh := nw * fh / fw //51
- 
-    // Digit too high?
- 
-    if nh > h {
-        // Fit digits based on height.
-        nh = h //nh = 44
-        nw = fw / fh * nh
-    }
-    // Calculate dot size.
-    img.dotsize = int(nh / fh)
-    // Save everything, making the actual width smaller by 1 dot to account
-    // for spacing between digits.
-    img.width = int(nw)
-    img.height = int(nh) - img.dotsize
+
+	// Goal: fit all digits inside the image.
+	var border int
+	if width > height {
+		border = height / 5
+	} else {
+		border = width / 5
+	}
+	// Convert everything to floats for calculations.
+	w := float64(width - border*2)  //268
+	h := float64(height - border*2) //48
+	// fw takes into account 1-dot spacing between digits.
+
+	fw := float64(fontWidth) + 1 //6
+
+	fh := float64(fontHeight) //8
+	nc := float64(ncount)     //7
+
+	// Calculate the width of a single digit taking into account only the
+	// width of the image.
+	nw := w / nc //38
+	// Calculate the height of a digit from this width.
+	nh := nw * fh / fw //51
+
+	// Digit too high?
+
+	if nh > h {
+		// Fit digits based on height.
+		nh = h //nh = 44
+		nw = fw / fh * nh
+	}
+	// Calculate dot size.
+	img.dotsize = int(nh / fh)
+	// Save everything, making the actual width smaller by 1 dot to account
+	// for spacing between digits.
+	img.width = int(nw)
+	img.height = int(nh) - img.dotsize
 }
- 
+
 func (img *Image) fillWithCircles(n, maxradius int) {
-    color := img.color
-    maxx := img.Bounds().Max.X
-    maxy := img.Bounds().Max.Y
-    for i := 0; i < n; i++ {
-        setRandomBrightness(color, 255)
-        r := rnd(1, maxradius)
-        img.drawCircle(color, rnd(r, maxx-r), rnd(r, maxy-r), r)
-    }
+	color := img.color
+	maxx := img.Bounds().Max.X
+	maxy := img.Bounds().Max.Y
+	for i := 0; i < n; i++ {
+		setRandomBrightness(color, 255)
+		r := rnd(1, maxradius)
+		img.drawCircle(color, rnd(r, maxx-r), rnd(r, maxy-r), r)
+	}
 }
- 
+
 func (img *Image) drawHorizLine(color color.Color, fromX, toX, y int) {
-    for x := fromX; x <= toX; x++ {
-        img.Set(x, y, color)
-    }
+	for x := fromX; x <= toX; x++ {
+		img.Set(x, y, color)
+	}
 }
- 
+
 func (img *Image) drawCircle(color color.Color, x, y, radius int) {
-    f := 1 - radius
-    dfx := 1
-    dfy := -2 * radius
-    xx := 0
-    yy := radius
- 
-    img.Set(x, y+radius, color)
-    img.Set(x, y-radius, color)
-    img.drawHorizLine(color, x-radius, x+radius, y)
- 
-    for xx < yy {
-        if f >= 0 {
-            yy--
-            dfy += 2
-            f += dfy
-        }
-        xx++
-        dfx += 2
-        f += dfx
-        img.drawHorizLine(color, x-xx, x+xx, y+yy)
-        img.drawHorizLine(color, x-xx, x+xx, y-yy)
-        img.drawHorizLine(color, x-yy, x+yy, y+xx)
-        img.drawHorizLine(color, x-yy, x+yy, y-xx)
-    }
+	f := 1 - radius
+	dfx := 1
+	dfy := -2 * radius
+	xx := 0
+	yy := radius
+
+	img.Set(x, y+radius, color)
+	img.Set(x, y-radius, color)
+	img.drawHorizLine(color, x-radius, x+radius, y)
+
+	for xx < yy {
+		if f >= 0 {
+			yy--
+			dfy += 2
+			f += dfy
+		}
+		xx++
+		dfx += 2
+		f += dfx
+		img.drawHorizLine(color, x-xx, x+xx, y+yy)
+		img.drawHorizLine(color, x-xx, x+xx, y-yy)
+		img.drawHorizLine(color, x-yy, x+yy, y+xx)
+		img.drawHorizLine(color, x-yy, x+yy, y-xx)
+	}
 }
- 
+
 func (img *Image) strikeThrough() {
-    r := 0
-    maxx := img.Bounds().Max.X
-    maxy := img.Bounds().Max.Y
-    y := rnd(maxy/3, maxy-maxy/3)
-    for x := 0; x < maxx; x += r {
-        r = rnd(1, img.dotsize/3)
-        y += rnd(-img.dotsize/2, img.dotsize/2)
-        if y <= 0 || y >= maxy {
-            y = rnd(maxy/3, maxy-maxy/3)
-        }
-        img.drawCircle(img.color, x, y, r)
-    }
+	r := 0
+	maxx := img.Bounds().Max.X
+	maxy := img.Bounds().Max.Y
+	y := rnd(maxy/3, maxy-maxy/3)
+	for x := 0; x < maxx; x += r {
+		r = rnd(1, img.dotsize/3)
+		y += rnd(-img.dotsize/2, img.dotsize/2)
+		if y <= 0 || y >= maxy {
+			y = rnd(maxy/3, maxy-maxy/3)
+		}
+		img.drawCircle(img.color, x, y, r)
+	}
 }
- 
+
 func (img *Image) drawDigit(digit []byte, x, y int) {
-    skf := rand.Float64() * float64(rnd(-maxSkew, maxSkew))
-    xs := float64(x)
-    minr := img.dotsize / 2               // minumum radius
-    maxr := img.dotsize/2 + img.dotsize/4 // maximum radius
-    y += rnd(-minr, minr)
-    for yy := 0; yy < fontHeight; yy++ {
-        for xx := 0; xx < fontWidth; xx++ {
-            if digit[yy*fontWidth+xx] != blackChar {
-                continue
-            }
-            // Introduce random variations.
-            or := rnd(minr, maxr)
-            ox := x + (xx * img.dotsize) + rnd(0, or/2)
-            oy := y + (yy * img.dotsize) + rnd(0, or/2)
- 
-            img.drawCircle(img.color, ox, oy, or)
-        }
-        xs += skf
-        x = int(xs)
-    }
+	skf := rand.Float64() * float64(rnd(-maxSkew, maxSkew))
+	xs := float64(x)
+	minr := img.dotsize / 2               // minumum radius
+	maxr := img.dotsize/2 + img.dotsize/4 // maximum radius
+	y += rnd(-minr, minr)
+	for yy := 0; yy < fontHeight; yy++ {
+		for xx := 0; xx < fontWidth; xx++ {
+			if digit[yy*fontWidth+xx] != blackChar {
+				continue
+			}
+			// Introduce random variations.
+			or := rnd(minr, maxr)
+			ox := x + (xx * img.dotsize) + rnd(0, or/2)
+			oy := y + (yy * img.dotsize) + rnd(0, or/2)
+
+			img.drawCircle(img.color, ox, oy, or)
+		}
+		xs += skf
+		x = int(xs)
+	}
 }
- 
+
 func setRandomBrightness(c *color.NRGBA, max uint8) {
-    minc := min3(c.R, c.G, c.B)
-    maxc := max3(c.R, c.G, c.B)
-    if maxc > max {
-        return
-    }
-    n := rand.Intn(int(max-maxc)) - int(minc)
-    c.R = uint8(int(c.R) + n)
-    c.G = uint8(int(c.G) + n)
-    c.B = uint8(int(c.B) + n)
+	minc := min3(c.R, c.G, c.B)
+	maxc := max3(c.R, c.G, c.B)
+	if maxc > max {
+		return
+	}
+	n := rand.Intn(int(max-maxc)) - int(minc)
+	c.R = uint8(int(c.R) + n)
+	c.G = uint8(int(c.G) + n)
+	c.B = uint8(int(c.B) + n)
 }
- 
+
 func min3(x, y, z uint8) (o uint8) {
-    o = x
-    if y < o {
-        o = y
-    }
-    if z < o {
-        o = z
-    }
-    return
+	o = x
+	if y < o {
+		o = y
+	}
+	if z < o {
+		o = z
+	}
+	return
 }
- 
+
 func max3(x, y, z uint8) (o uint8) {
-    o = x
-    if y > o {
-        o = y
-    }
-    if z > o {
-        o = z
-    }
-    return
+	o = x
+	if y > o {
+		o = y
+	}
+	if z > o {
+		o = z
+	}
+	return
 }
- 
+
 // rnd returns a random number in range [from, to].
 func rnd(from, to int) int {
-    //println(to+1-from)
-    return rand.Intn(to+1-from) + from
+	//println(to+1-from)
+	return rand.Intn(to+1-from) + from
 }
- 
+
 const (
-    // Standard length of uniuri string to achive ~95 bits of entropy.
-    StdLen = 16
-    // Length of uniurl string to achive ~119 bits of entropy, closest
-    // to what can be losslessly converted to UUIDv4 (122 bits).
-    UUIDLen = 20
+	// Standard length of uniuri string to achive ~95 bits of entropy.
+	StdLen = 16
+	// Length of uniurl string to achive ~119 bits of entropy, closest
+	// to what can be losslessly converted to UUIDv4 (122 bits).
+	UUIDLen = 20
 )
- 
+
 // Standard characters allowed in uniuri string.
 var StdChars = []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
- 
+
 // New returns a new random string of the standard length, consisting of
 // standard characters.
 func New() string {
-    return NewLenChars(StdLen, StdChars)
+	return NewLenChars(StdLen, StdChars)
 }
- 
+
 // NewLen returns a new random string of the provided length, consisting of
 // standard characters.
 func NewLen(length int) string {
-    return NewLenChars(length, StdChars)
+	return NewLenChars(length, StdChars)
 }
- 
+
 // NewLenChars returns a new random string of the provided length, consisting
 // of the provided byte slice of allowed characters (maximum 256).
 func NewLenChars(length int, chars []byte) string {
-    b := make([]byte, length)
-    r := make([]byte, length+(length/4)) // storage for random bytes.
-    clen := byte(len(chars))
-    maxrb := byte(256 - (256 % len(chars)))
-    i := 0
-    for {
-        if _, err := io.ReadFull(crand.Reader, r); err != nil {
-            panic("error reading from random source: " + err.Error())
-        }
-        for _, c := range r {
-            if c >= maxrb {
-                // Skip this number to avoid modulo bias.
-                continue
-            }
-            b[i] = chars[c%clen]
-            i++
-            if i == length {
-                return string(b)
-            }
-        }
-    }
-    panic("unreachable")
+	b := make([]byte, length)
+	r := make([]byte, length+(length/4)) // storage for random bytes.
+	clen := byte(len(chars))
+	maxrb := byte(256 - (256 % len(chars)))
+	i := 0
+	for {
+		if _, err := io.ReadFull(crand.Reader, r); err != nil {
+			panic("error reading from random source: " + err.Error())
+		}
+		for _, c := range r {
+			if c >= maxrb {
+				// Skip this number to avoid modulo bias.
+				continue
+			}
+			b[i] = chars[c%clen]
+			i++
+			if i == length {
+				return string(b)
+			}
+		}
+	}
+	panic("unreachable")
 }
 
 func Fetch() (*Image, string) {
-    d := make([]byte, 4)
-    s := NewLen(4)
-    ss := ""
-    d = []byte(s)
-    for v := range d {
-        d[v] %= 10
-        ss += strconv.FormatInt(int64(d[v]), 32)
-    }
-    return NewImage(d, 100, 40), ss
-}
+	d := make([]byte, 4)
+	s := NewLen(4)
+	ss := ""
+	d = []byte(s)
+	for v := range d {
+		d[v] %= 10
+		ss += strconv.FormatInt(int64(d[v]), 32)
+	}
+	return NewImage(d, 100, 40), ss
+}

app/lea/crypto.go

@@ -0,0 +1,26 @@
+// contains two cryptographic functions for both storing and comparing passwords.
+package lea
+
+import (
+	"golang.org/x/crypto/bcrypt"
+)
+
+// GenerateHash generates bcrypt hash from plaintext password
+func GenerateHash(password string) ([]byte, error) {
+	hex := []byte(password)
+	hashedPassword, err := bcrypt.GenerateFromPassword(hex, 10)
+	if err != nil {
+		return hashedPassword, err
+	}
+	return hashedPassword, nil
+}
+
+// CompareHash compares bcrypt password with a plaintext one. Returns true if passwords match
+// and false if they do not.
+func CompareHash(digest []byte, password string) bool {
+	hex := []byte(password)
+	if err := bcrypt.CompareHashAndPassword(digest, hex); err == nil {
+		return true
+	}
+	return false
+}

app/lea/html2image/Html2Image.go

@@ -24,29 +24,29 @@ import (
 type Html2Image struct {
 	image *image.RGBA
 	gc *draw2d.ImageGraphicContext
-	
+
 	// 试探
 	gc2 *draw2d.ImageGraphicContext
-	
+
 	width float64 // 图片宽度
 	height float64
-	
+
 	painWidth float64 // 画布宽度
-	
+
 	startX float64
 	x float64
 	y float64
-	
+
 	isFirstP bool // 是否是第一个段落?
-	
+
 	// 换行和段落的高度
 	brY float64
 	pY float64
-	
+
 	// 字体
 	normalFontFamily draw2d.FontData
 	boldFontFamily draw2d.FontData
-	
+
 	// preTag 之前的标签
 	preTag *html.Node
 }
@@ -58,23 +58,23 @@ func NewHtml2Image() *Html2Image {
 	i, gc := h.InitGc(h.width, h.height)
 	h.gc = gc;
 	h.image = i
-	
+
 	// 试探
 	_, h.gc2 = h.InitGc(h.width, 100)
-	
-	h.startX = 10 
-	
+
+	h.startX = 10
+
 	// 最初位置
 	h.x =  h.startX
 	h.y = 80
-	
+
 	h.isFirstP = true
-	
+
 	h.normalFontFamily = draw2d.FontData{"xihei", 4, draw2d.FontStyleNormal};
 	h.boldFontFamily = draw2d.FontData{"heiti", 5, draw2d.FontStyleNormal};
-	
+
 	h.SetNormalFont()
-	
+
 	return h
 }
 
@@ -86,12 +86,12 @@ func (this *Html2Image) InitGc(w, h float64) (* image.RGBA, *draw2d.ImageGraphic
 	gc.SetFillColor(image.White)
 	// fill the background
 	// gc.Clear()
-	
+
 	draw2d.SetFontFolder(revel.BasePath + "/public/fonts/weibo")
 	draw2d.Rect(gc, 0, 0, w, h) // 设置背景
 	gc.FillStroke()
 	gc.SetFillColor(image.Black)
-	
+
 	// 这个很耗时
 //	gc.Translate(0, 0)
 	return i, gc
@@ -101,7 +101,7 @@ func (this *Html2Image) SaveToPngFile(filePath string) bool {
 //	m := this.image;
 	m := this.image.SubImage(image.Rect(0, 0, int(this.width), int(this.y + 20)))
 	// 需要截断之
-	
+
 	f, err := os.Create(filePath)
 	if err != nil {
 		return false
@@ -124,14 +124,14 @@ func (this *Html2Image) SaveToPngFile(filePath string) bool {
 func (this *Html2Image) SetSmallFont() {
 	this.gc.SetFontData(this.normalFontFamily)
 	this.gc2.SetFontData(this.normalFontFamily)
-	
+
 	this.gc.SetFillColor(color.NRGBA{60, 60, 60, 255})
 	this.gc.SetFontSize(12)
 	this.gc2.SetFontSize(12)
-	
+
 	this.brY = 16
 	this.pY = 30
-	
+
 	this.painWidth = this.width - 10
 }
 
@@ -139,13 +139,13 @@ func (this *Html2Image) SetNormalFont() {
 	this.gc.SetFillColor(image.Black)
 	this.gc.SetFontData(this.normalFontFamily)
 	this.gc2.SetFontData(this.normalFontFamily)
-	
+
 	this.gc.SetFontSize(14)
 	this.gc2.SetFontSize(14)
-	
+
 	this.brY = 20
 	this.pY = 30
-	
+
 	this.painWidth = this.width - 10
 }
 func (this *Html2Image) SetAColor() {
@@ -155,16 +155,16 @@ func (this *Html2Image) SetAColor() {
 // 标题
 func (this *Html2Image) SetTitleFont() {
 	this.gc.SetFillColor(image.Black)
-	
+
 	this.gc.SetFontData(this.boldFontFamily)
 	this.gc2.SetFontData(this.boldFontFamily)
-	
+
 	this.gc.SetFontSize(24)
 	this.gc2.SetFontSize(24)
-	
+
 	this.brY = 30
 	this.pY = 60
-	
+
 	this.painWidth = this.width - 100
 }
 
@@ -175,9 +175,9 @@ func (this *Html2Image) SetHeadFont(h string) {
 
 	this.gc.SetFontData(this.boldFontFamily)
 	this.gc2.SetFontData(this.boldFontFamily)
-	
+
 	this.painWidth = this.width - 50
-	
+
 	if h == "h1" {
 		this.gc.SetFontSize(20)
 		this.gc2.SetFontSize(20)
@@ -229,7 +229,7 @@ func (this *Html2Image) IsOver(r []rune) bool {
 	// 以下的方法可以极大节约时间
 //	a, b, c, d := this.gc2.GetStringBounds(string(r))
 //	width2 := c - a + 2
-	
+
 //	fmt.Println(width2)
 //	fmt.Println(c - a)
 
@@ -268,7 +268,7 @@ func (this *Html2Image) InsertText(text string, needTest bool, prefix string) {
 		this.InsertText(text, true, prefix)
 		return;
 	}
-	
+
 	r := []rune(text)
 	// 试探吧, 可能需要截取
 	if !needTest || !this.IsOver(r) {
@@ -316,17 +316,17 @@ func (this *Html2Image) InsertText(text string, needTest bool, prefix string) {
 								end = i
 							}
 						}
-						
+
 						// 这一段写上
 //						println("------>" + string(r[0:end]))
-						
+
 						// 这里, 判断后面一个是否是标点符号
 						end = this.includePunctuation(r, end)
 						this.InsertText(string(r[0:end]), false, prefix)
 						this.NewBr()
 						// 之后的
 						this.InsertText(string(r[end:]), true, prefix)
-						
+
 						return;
 					} else {
 						// 没超出, 不用计算, 但出要看是否是结尾了
@@ -351,17 +351,17 @@ func (this *Html2Image) InsertText(text string, needTest bool, prefix string) {
 					end = maxRI + 1
 				}
 			}
-			
+
 			// 这一段写上
 //			println("-e----->" + string(r[0:end]))
-			
+
 			// 这里, 判断后面一个是否是标点符号
 			end = this.includePunctuation(r, end)
 			this.InsertText(string(r[0:end]), false, prefix)
 			this.NewBr()
 			// 之后的
 			this.InsertText(string(r[end:]), true, prefix)
-			
+
 			return;
 		}
 	}
@@ -376,9 +376,9 @@ func (this *Html2Image) SetBottom(username, url string) {
 	this.gc.SetStrokeColor(color.NRGBA{200, 0, 0, 255})
 	this.gc.SetLineWidth(2)
     this.gc.FillStroke()
-    
+
     this.SetSmallFont()
-    
+
     // 左侧写字
     this.NewP()
     this.InsertText("本文来自 " + username + " 的leanote笔记", true, "  ")
@@ -389,11 +389,11 @@ func (this *Html2Image) SetBottom(username, url string) {
     	siteUrl = "http://leanote.com"
     }
     this.InsertA(siteUrl + "/blog/" + username, false)
-    
+
 	this.setLogo()
 //    this.painWidth = this.width - 100
 //    this.NewP()
-//    this.InsertText("leanote, 不一样的笔记.", false, "  ") 
+//    this.InsertText("leanote, 不一样的笔记.", false, "  ")
 //    this.NewBr()
 //    this.InsertText("在这里你可以管理自己的知识", false, "  ")
 //    this.NewBr()
@@ -401,7 +401,7 @@ func (this *Html2Image) SetBottom(username, url string) {
 //    this.NewBr()
 //    this.InsertText("并且还可以将笔记设为博客公开", false, "  ")
 //    this.InsertText(". 赶紧加入吧! leanote.com", false, "")
-//    
+//
     // Logo
 }
 
@@ -411,7 +411,7 @@ func (this *Html2Image) setImage(path string, x, y float64) {
     	return;
         panic(err)
     }
-    
+
     var m1 image.Image
 	_, ext := lea.SplitFilename(path)
     if ext == ".png" {
@@ -424,8 +424,8 @@ func (this *Html2Image) setImage(path string, x, y float64) {
 	if err != nil {
 	    return
         panic(err)
-    }   
-    
+    }
+
     this.gc.Translate(x, y)
     this.gc.DrawImage(m1)
     this.gc.Translate(-x, -y)
@@ -448,10 +448,10 @@ func (this *Html2Image) InsertA(text string, isNormal bool) {
 	if text == "" {
 		return
 	}
-	
+
 	this.SetAColor()
 	this.InsertText(text, true, "")
-	
+
 	// 还原
 	if isNormal {
 		this.SetNormalFont()
@@ -464,17 +464,17 @@ func (this *Html2Image) InsertA(text string, isNormal bool) {
 func (this *Html2Image) InsertTitle(title string) {
 	oldX := this.x
 	oldY := this.y - 35
-	
+
 	// 插入之
 	this.SetTitleFont()
-	
+
 	this.InsertText(title, true, "  ")
-	
+
 	// 还原字体大小
 	this.SetNormalFont()
-	
+
 	this.NewBr()
-	
+
 	this.gc.MoveTo(oldX, oldY)
     this.gc.LineTo(this.x, this.y - 10)
 	this.gc.SetStrokeColor(color.NRGBA{200, 0, 0, 255})
@@ -512,7 +512,7 @@ func (this *Html2Image) InsertCode(n *html.Node) {
 		}
 	}
 	this.NewBr()
-	
+
 	this.gc.MoveTo(oldX, oldY)
     this.gc.LineTo(this.x, this.y - 20)
 	this.gc.SetStrokeColor(color.NRGBA{0, 200, 0, 255})
@@ -521,14 +521,14 @@ func (this *Html2Image) InsertCode(n *html.Node) {
 }
 
 // 插入图片
-// 这个path应该是url, 
+// 这个path应该是url,
 // http://abc.com/a.gif 需要先下载
 // 或 /upload/a.gif
 func (this *Html2Image) InsertImage(path string, needTrans bool, width uint) {
 	if path == "" {
 		return;
 	}
-	
+
 	// 是url, 那么取网络图片之
 	var ok bool
 	if strings.HasPrefix(path, "http") || strings.HasPrefix(path, "//") {
@@ -539,7 +539,7 @@ func (this *Html2Image) InsertImage(path string, needTrans bool, width uint) {
 	} else {
 		path = revel.BasePath + "/public/" + path
 	}
-	
+
 	// 需要转换, logo不需要转换
 	if(needTrans) {
 		painWidth := uint(this.painWidth - 10)
@@ -557,7 +557,7 @@ func (this *Html2Image) InsertImage(path string, needTrans bool, width uint) {
     	return;
         panic(err)
     }
-    
+
     var m1 image.Image
 	_, ext := lea.SplitFilename(path)
     if ext == ".png" {
@@ -568,8 +568,8 @@ func (this *Html2Image) InsertImage(path string, needTrans bool, width uint) {
 	if err != nil {
 	    return
         panic(err)
-    }   
-    
+    }
+
     // 如果之前是p, 那么不要有<br>
     if this.preTag.Data != "p" {
 	    this.NewBr()
@@ -580,9 +580,9 @@ func (this *Html2Image) InsertImage(path string, needTrans bool, width uint) {
     this.gc.Translate(-this.x, -this.y) // 这个有用些
 	this.y += float64(m1.Bounds().Dy()) - 20
 	this.NewP()
-    
+
     os.Remove(path)
-    
+
     // 如果图片是文章第一个的话, 之后的需要p
     this.isFirstP = false
 }
@@ -605,7 +605,7 @@ func (this *Html2Image) InsertBody(htmlStr string) (ok bool) {
 				this.preTag = n
 			}
 		}()
-		
+
 		// 标签
 		if n.Type == html.ElementNode {
 			if n.Data == "p" {
@@ -616,7 +616,7 @@ func (this *Html2Image) InsertBody(htmlStr string) (ok bool) {
 				}
 				return;
 			}
-			
+
 			// 也是一个段落, 只是要缩进
 			if n.Data == "ul" || n.Data == "ol" {
 				this.NewP()
@@ -637,7 +637,7 @@ func (this *Html2Image) InsertBody(htmlStr string) (ok bool) {
 					} else {
 						f(c, n, "")
 					}
-					
+
 					if c.Type == html.ElementNode {
 						if c.Data == "br" || c.Data == "p" {
 							needPrefix = true
@@ -650,19 +650,19 @@ func (this *Html2Image) InsertBody(htmlStr string) (ok bool) {
 				this.NewBr()
 				return;
 			}
-			
+
 			// 标题
 			if n.Data == "h1" || n.Data == "h2" || n.Data == "h3" || n.Data == "h4" {
 				this.InsertHead(n)
 				return;
 			}
-			
+
 			if n.Data == "pre" {
 				// 把之后的全拿过来
 				this.InsertCode(n)
 				return;
 			}
-			
+
 			// 图片
 			// 得到src
 			if n.Data == "img" {
@@ -680,22 +680,22 @@ func (this *Html2Image) InsertBody(htmlStr string) (ok bool) {
 				}
 				return;
 			}
-			
+
 			// 链接
 			// 如果链接里只有文本, 那么单独处理, 如果还有其它的, 不作链接处理
 			if n.Data == "a" {
 				if n.FirstChild == n.LastChild {
 					this.InsertA(n.FirstChild.Data, true)
 					return;
-				} 
+				}
 			}
-			
+
 			// 空行
 			if n.Data == "br" { // || n.Data == "div"
 				this.NewBr()
 			}
 		}
-		
+
 		// 是文本, 输出之
 		if n.Type == html.TextNode {
 			data := strings.TrimSpace(n.Data);
@@ -705,36 +705,36 @@ func (this *Html2Image) InsertBody(htmlStr string) (ok bool) {
 			}
 			return;
 		}
-		
+
 		// 其余的
-		
+
 		for c := n.FirstChild; c != nil; c = c.NextSibling {
 			f(c, n, prefix)
 		}
-		
+
 		return;
 	}
 	f(doc, nil, "")
-	
+
 	return true
 }
 
 // 主函数
 func ToImage(uid, username, noteId, title, htmlStr, toPath string) (ok bool) {
 	h := NewHtml2Image()
-	
+
 	// 标题
 	h.InsertTitle(title)
-	
+
 	// 主体
 	ok = h.InsertBody(htmlStr)
 	if(!ok) {
 		return
 	}
-	
+
 	// 页眉与页脚
 	h.SetBottom(username, "")
-	
+
 	// 保存成png图片
 	ok = h.SaveToPngFile(toPath)
 	return
@@ -757,4 +757,4 @@ func TestFillString() {
 
 func ToImage(uid, username, noteId, title, htmlStr, toPath string) (ok bool) {
 	return false
-}
+}

app/lea/html2image/ToImage.go

@@ -7,4 +7,3 @@ import (
 func Html2Image(userInfo info.User, note info.Note, content, toPath string) bool {
 	return true
 }
-

app/lea/i18n/i18n.go

@@ -0,0 +1,224 @@
+package i18n
+
+import (
+	"fmt"
+	"github.com/revel/revel"
+	"github.com/robfig/config"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	. "github.com/leanote/leanote/app/lea"
+)
+
+const (
+	CurrentLocaleViewArg = "currentLocale" // The key for the current locale render arg value
+
+	messageFilesDirectory = "messages"
+	messageFilePattern    = `^\w+\.conf$`
+	unknownValueFormat    = "??? %s ???"
+	defaultLanguageOption = "i18n.default_language"
+	localeCookieConfigKey = "i18n.cookie"
+)
+
+var (
+	// All currently loaded message configs.
+	// en-us, zh-cn, zh-hk ->
+	messages map[string]*config.Config
+)
+
+func GetAllLangMessages() map[string]*config.Config {
+	return messages
+}
+
+func HasLang(lang string) bool {
+	_, ok := messages[lang]
+	return ok
+}
+
+func GetDefaultLang() string {
+	lang, _ := revel.Config.String(defaultLanguageOption)
+	return lang
+}
+
+// Return all currently loaded message languages.
+func MessageLanguages() []string {
+	languages := make([]string, len(messages))
+	i := 0
+	for language, _ := range messages {
+		languages[i] = language
+		i++
+	}
+	return languages
+}
+
+// Perform a message look-up for the given locale and message using the given arguments.
+//
+// When either an unknown locale or message is detected, a specially formatted string is returned.
+func Message(locale, message string, args ...interface{}) string {
+	language, region := parseLocale(locale)
+
+	langAndRegion := language + "-" + region
+	// revel.TRACE.Println(langAndRegion + " 怎么回事")
+
+	messageConfig, knownLanguage := messages[langAndRegion]
+	if !knownLanguage {
+		// revel.TRACE.Printf("Unsupported language for locale '%s' and message '%s', trying default language", locale, message)
+
+		if defaultLanguage, found := revel.Config.String(defaultLanguageOption); found {
+			// revel.TRACE.Printf("Using default language '%s'", defaultLanguage)
+
+			messageConfig, knownLanguage = messages[defaultLanguage]
+			if !knownLanguage {
+				// WARN.Printf("Unsupported default language for locale '%s' and message '%s'", defaultLanguage, message)
+				return fmt.Sprintf(unknownValueFormat, message)
+			}
+		} else {
+			// WARN.Printf("Unable to find default language option (%s); messages for unsupported locales will never be translated", defaultLanguageOption)
+			return fmt.Sprintf(unknownValueFormat, message)
+		}
+	}
+
+	// This works because unlike the goconfig documentation suggests it will actually
+	// try to resolve message in DEFAULT if it did not find it in the given section.
+	value, error := messageConfig.String(region, message)
+	if error != nil {
+		// WARN.Printf("Unknown message '%s' for locale '%s'", message, locale)
+		return fmt.Sprintf(unknownValueFormat, message)
+	}
+
+	if len(args) > 0 {
+		// revel.TRACE.Printf("Arguments detected, formatting '%s' with %v", value, args)
+		value = fmt.Sprintf(value, args...)
+	}
+
+	return value
+}
+
+func parseLocale(locale string) (language, region string) {
+	if strings.Contains(locale, "-") {
+		languageAndRegion := strings.Split(locale, "-")
+		return languageAndRegion[0], languageAndRegion[1]
+	}
+
+	return locale, ""
+}
+
+// Recursively read and cache all available messages from all message files on the given path.
+func loadMessages(path string) {
+	messages = make(map[string]*config.Config)
+
+	if error := filepath.Walk(path, loadEachMessageLang); error != nil && !os.IsNotExist(error) {
+		// ERROR.Println("Error reading messages files:", error)
+	}
+}
+
+// 加载每一个文件夹
+func loadEachMessageLang(parentPath string, parentInfo os.FileInfo, osError error) (err error) {
+	if !parentInfo.IsDir() {
+		return nil
+	}
+
+	if err := filepath.Walk(parentPath, func(path string, info os.FileInfo, osError error) error {
+		return loadMessageFile(parentInfo.Name(), path, info, osError)
+
+	}); err != nil && !os.IsNotExist(err) {
+		// ERROR.Println("Error reading messages files:", error)
+	}
+	return err
+}
+
+// Load a single message file
+func loadMessageFile(locale string, path string, info os.FileInfo, osError error) error {
+	if osError != nil {
+		return osError
+	}
+	if info.IsDir() {
+		return nil
+	}
+
+	if matched, _ := regexp.MatchString(messageFilePattern, info.Name()); matched {
+		if config, error := parseMessagesFile(path); error != nil {
+			return error
+		} else {
+			// locale := parseLocaleFromFileName(info.Name())
+			// revel.TRACE.Print(locale + "----locale")
+
+			// If we have already parsed a message file for this locale, merge both
+			if _, exists := messages[locale]; exists {
+				messages[locale].Merge(config)
+				Logf("Successfully merged messages for locale '%s'", locale)
+			} else {
+				messages[locale] = config
+			}
+
+			Logf("Successfully loaded messages from file", info.Name())
+		}
+	} else {
+		Logf("Ignoring file %s because it did not have a valid extension", info.Name())
+	}
+
+	return nil
+}
+
+func parseMessagesFile(path string) (messageConfig *config.Config, error error) {
+	messageConfig, error = config.ReadDefault(path)
+	return
+}
+
+func parseLocaleFromFileName(file string) string {
+	extension := filepath.Ext(file)[1:]
+	return strings.ToLower(extension)
+}
+
+func init() {
+	revel.OnAppStart(func() {
+		loadMessages(filepath.Join(revel.BasePath, messageFilesDirectory))
+	})
+}
+
+func I18nFilter(c *revel.Controller, fc []revel.Filter) {
+	if foundCookie, cookieValue := hasLocaleCookie(c.Request); foundCookie {
+		// revel.TRACE.Printf("Found locale cookie value: %s", cookieValue)
+		setCurrentLocaleControllerArguments(c, cookieValue)
+	} else if foundHeader, headerValue := hasAcceptLanguageHeader(c.Request); foundHeader {
+		// revel.TRACE.Printf("Found Accept-Language header value: %s", headerValue)
+		setCurrentLocaleControllerArguments(c, headerValue)
+	} else {
+		// revel.TRACE.Println("Unable to find locale in cookie or header, using empty string")
+		setCurrentLocaleControllerArguments(c, "")
+	}
+	fc[0](c, fc[1:])
+}
+
+// Set the current locale controller argument (CurrentLocaleControllerArg) with the given locale.
+func setCurrentLocaleControllerArguments(c *revel.Controller, locale string) {
+	c.Request.Locale = locale
+	c.ViewArgs[CurrentLocaleViewArg] = locale
+}
+
+// Determine whether the given request has valid Accept-Language value.
+//
+// Assumes that the accept languages stored in the request are sorted according to quality, with top
+// quality first in the slice.
+func hasAcceptLanguageHeader(request *revel.Request) (bool, string) {
+	if request.AcceptLanguages != nil && len(request.AcceptLanguages) > 0 {
+		return true, request.AcceptLanguages[0].Language
+	}
+
+	return false, ""
+}
+
+// Determine whether the given request has a valid language cookie value.
+func hasLocaleCookie(request *revel.Request) (bool, string) {
+	if request != nil {
+		name := revel.Config.StringDefault(localeCookieConfigKey, revel.CookiePrefix+"_LANG")
+		if cookie, error := request.Cookie(name); error == nil {
+			return true, cookie.GetValue()
+		} else {
+			// revel.TRACE.Printf("Unable to read locale cookie with name '%s': %s", name, error.Error())
+		}
+	}
+
+	return false, ""
+}

app/lea/memcache/Memcache.go

@@ -1,66 +0,0 @@
-package memcache
-
-import (
-	"github.com/robfig/gomemcache/memcache"
-	"encoding/json"
-	"strconv"
-)
-
-var client *memcache.Client
-
-// onAppStart后调用
-func InitMemcache() {
-	client = memcache.New("localhost:11211")	
-}
-
-//------------
-// map
-
-func SetMap(key string, value map[string]string, expiration int32) {
-	// 把value转成byte
-	bytes, _ := json.Marshal(value)
-	if expiration == -1 {
-		expiration = 30 * 24 * 60 * 60 // 30天
-	}
-	client.Set(&memcache.Item{Key: key, Value: bytes, Expiration: expiration})
-}
-
-func GetMap(key string) map[string]string {
-	item, err := client.Get(key)
-	if err != nil {
-		return nil
-	}
-	
-	m := map[string]string{}
-	json.Unmarshal(item.Value, &m)	
-	return m
-}
-
-//------------
-// string
-func GetString(key string) string {
-	item, err := client.Get(key)
-	if err != nil {
-		return ""
-	}
-	return string(item.Value)
-}
-func SetString(key string, value string, expiration int32) {
-	if expiration == -1 {
-		expiration = 30 * 24 * 60 * 60 // 30天
-	}
-	client.Set(&memcache.Item{Key: key, Value: []byte(value), Expiration: expiration})
-}
-
-//-------------------------
-// int, 是通过转成string来存的
-
-func GetInt(key string) int {
-	str := GetString(key)
-	i, _ := strconv.Atoi(str)
-	return i
-}
-func SetInt(key string, value int, expiration int32) {
-	str := strconv.Itoa(value)
-	SetString(key, str, expiration)
-}

app/lea/netutil/NetUtil.go

@@ -1,11 +1,13 @@
 package netutil
+
 import (
-	"strings"
 	"os"
-//	"path/filepath"
-	"net/http"
-	"io/ioutil"
+	"strings"
+	//	"path/filepath"
 	. "github.com/leanote/leanote/app/lea"
+	"io/ioutil"
+	"net"
+	"net/http"
 )
 
 // net的util
@@ -15,33 +17,33 @@ import (
 // 返回文件的完整目录
 func WriteUrl(url string, toPath string) (length int64, newFilename, path string, ok bool) {
 	if url == "" {
-		return;
+		return
 	}
 	content, err := GetContent(url)
 	if err != nil {
-		return;
+		return
 	}
-	
+
 	length = int64(len(content))
-	
+
 	// a.html?a=a11&xxx
 	url = trimQueryParams(url)
 	_, ext := SplitFilename(url)
 	if toPath == "" {
 		toPath = "/tmp"
 	}
-//	dir := filepath.Dir(toPath)
+	//	dir := filepath.Dir(toPath)
 	newFilename = NewGuid() + ext
 	fullPath := toPath + "/" + newFilename
-	
+
 	// 写到文件中
 	file, err := os.Create(fullPath)
-    defer file.Close()
-    if err != nil {
-    	return
+	defer file.Close()
+	if err != nil {
+		return
 	}
 	file.Write(content)
-	
+
 	path = fullPath
 	ok = true
 	return
@@ -51,42 +53,49 @@ func WriteUrl(url string, toPath string) (length int64, newFilename, path string
 func GetContent(url string) (content []byte, err error) {
 	var resp *http.Response
 	resp, err = http.Get(url)
-	Log(err)
-	if(resp != nil && resp.Body != nil) {
+	if resp != nil && resp.Body != nil {
 		defer resp.Body.Close()
 	} else {
 	}
-    if resp == nil || resp.Body == nil || err != nil || resp.StatusCode != http.StatusOK {
-		return
-    }
-    
-    var buf []byte
-   	buf, err = ioutil.ReadAll(resp.Body)
-   	if(err != nil) {
-   		Log(err)
+	if resp == nil || resp.Body == nil || err != nil || resp.StatusCode != http.StatusOK {
 		return
 	}
-	
-   	content = buf;
-   	err = nil
-    return
+
+	var buf []byte
+	buf, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+
+	content = buf
+	err = nil
+	return
 }
 
 // 将url ?, #后面的字符串去掉
 func trimQueryParams(url string) string {
-	pos := strings.Index(url, "?");
+	pos := strings.Index(url, "?")
 	if pos != -1 {
-		url = Substr(url, 0, pos);
+		url = Substr(url, 0, pos)
 	}
-	
-	pos = strings.Index(url, "#");
+
+	pos = strings.Index(url, "#")
 	if pos != -1 {
-		url = Substr(url, 0, pos);
+		url = Substr(url, 0, pos)
 	}
-	
-	pos = strings.Index(url, "!");
+
+	pos = strings.Index(url, "!")
 	if pos != -1 {
-		url = Substr(url, 0, pos);
+		url = Substr(url, 0, pos)
 	}
-	return url;
-}
+	return url
+}
+
+// 通过domain得到ip
+func GetIpFromDomain(domain string) string {
+	ip, _ := net.LookupIP(domain)
+	if ip != nil && len(ip) > 0 {
+		return ip[0].String()
+	}
+	return ""
+}

app/lea/route/Route.go

@@ -1,9 +1,9 @@
 package route
 
 import (
+	"github.com/leanote/leanote/app/db"
 	"github.com/revel/revel"
-//	"github.com/leanote/leanote/app/service"
-//	. "github.com/leanote/leanote/app/lea"
+		// . "github.com/leanote/leanote/app/lea"
 	"net/url"
 	"strings"
 )
@@ -11,45 +11,67 @@ import (
 // overwite revel RouterFilter
 // /api/user/Info => ApiUser.Info()
 var staticPrefix = []string{"/public", "/favicon.ico", "/css", "/js", "/images", "/tinymce", "/upload", "/fonts"}
+
 func RouterFilter(c *revel.Controller, fc []revel.Filter) {
 	// 补全controller部分
-	path := c.Request.Request.URL.Path
-	
+	path := c.Request.URL.Path
+
 	// Figure out the Controller/Action
-	var route *revel.RouteMatch = revel.MainRouter.Route(c.Request.Request)
+	// var route *revel.RouteMatch = revel.MainRouter.Route(c.Request.Request)
+	route := revel.MainRouter.Route(c.Request)
+
 	if route == nil {
-		c.Result = c.NotFound("No matching route found: " + c.Request.RequestURI)
+		c.Result = c.NotFound("No matching route found: " + c.Request.GetRequestURI())
 		return
 	}
 
+	// Log("---------" + route.Action + "  " + path)
+
 	// The route may want to explicitly return a 404.
 	if route.Action == "404" {
 		c.Result = c.NotFound("(intentionally)")
 		return
 	}
-	
+
 	//----------
 	// life start
 	/*
-	type URL struct {
-	    Scheme   string
-	    Opaque   string    // encoded opaque data
-	    User     *Userinfo // username and password information
-	    Host     string    // host or host:port
-	    Path     string
-	    RawQuery string // encoded query values, without '?'
-	    Fragment string // fragment for references, without '#'
-	}
+		type URL struct {
+		    Scheme   string
+		    Opaque   string    // encoded opaque data
+		    User     *Userinfo // username and password information
+		    Host     string    // host or host:port
+		    Path     string
+		    RawQuery string // encoded query values, without '?'
+		    Fragment string // fragment for references, without '#'
+		}
 	*/
 	if route.ControllerName != "Static" {
+
+		// 检查mongodb 是否lost
+		db.CheckMongoSessionLost()
+
+		// /api/file/getImage -> App\file (/api/file/getImage)
+		// App\auth
+		// App\note
+		// static\static
+		// 
+		// Log("---------" + route.ControllerName + "  " + path)
+
 		// api设置
 		// leanote.com/api/user/get => ApiUser::Get
-		if strings.HasPrefix(path, "/api/") || strings.HasPrefix(path, "api/") {
-			route.ControllerName = "Api" + route.ControllerName
+		//*       /api/login               ApiAuth.Login,  这里的设置, 其实已经转成了ApiAuth了
+		if strings.HasPrefix(path, "/api") && !strings.HasPrefix(route.ControllerName, "App\\api") {
+			route.ControllerName = "App\\api" + strings.Split(route.ControllerName, "\\")[1]
+			// route.ControllerName = "App\\apifile"
+		} else if strings.HasPrefix(path, "/member") && !strings.HasPrefix(route.ControllerName, "App\\member") {
+			// member设置
+			// route.ControllerName = "App\\Member" + route.ControllerName
+			route.ControllerName = "App\\member" + strings.Split(route.ControllerName, "\\")[1]
 		}
 		// end
 	}
-	
+
 	// Set the action.
 	if err := c.SetAction(route.ControllerName, route.MethodName); err != nil {
 		c.Result = c.NotFound(err.Error())
@@ -69,11 +91,10 @@ func RouterFilter(c *revel.Controller, fc []revel.Filter) {
 			arg := c.MethodType.Args[i]
 			c.Params.Fixed.Set(arg.Name, value)
 		} else {
-			revel.WARN.Println("Too many parameters to", route.Action, "trying to add", value)
+			// revel.WARN.Println("Too many parameters to", route.Action, "trying to add", value)
 			break
 		}
 	}
 
 	fc[0](c, fc[1:])
 }
-

app/lea/session/MSession.go

@@ -1,38 +0,0 @@
-package session
-
-import (
-	"github.com/revel/revel"
-	"github.com/leanote/leanote/app/lea/memcache"
-	. "github.com/leanote/leanote/app/lea"
-)
-
-// 使用filter
-// 很巧妙就使用了memcache来处理session
-// revel的session(cookie)只存sessionId, 其它信息存在memcache中
-
-func MSessionFilter(c *revel.Controller, fc []revel.Filter) {
-	sessionId := c.Session.Id()
-	
-	// 从memcache中得到cache, 赋给session
-	cache := revel.Session(memcache.GetMap(sessionId))
-	
-	Log("memcache")
-	LogJ(cache)
-	if cache == nil {
-		cache = revel.Session{}
-		cache.Id()
-	}
-	c.Session = cache
-	
-	// Make session vars available in templates as {{.session.xyz}}
-	c.RenderArgs["session"] = c.Session
-
-	fc[0](c, fc[1:])
-	
-	// 再把session保存之
-	LogJ(c.Session)
-	memcache.SetMap(sessionId, c.Session, -1)	
-
-	// 只留下sessionId
-	c.Session = revel.Session{revel.SESSION_ID_KEY: sessionId}
-}

app/lea/session/session.go

@@ -1,208 +0,0 @@
-package session
-
-import (
-	"github.com/revel/revel"
-//	. "github.com/leanote/leanote/app/lea"
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// 主要修改revel的cookie, 设置Domain
-// 为了使sub domain共享cookie
-// cookie.domain = leanote.com
-
-// A signed cookie (and thus limited to 4kb in size).
-// Restriction: Keys may not have a colon in them.
-type Session map[string]string
-
-const (
-	SESSION_ID_KEY = "_ID"
-	TIMESTAMP_KEY  = "_TS"
-)
-
-// expireAfterDuration is the time to live, in seconds, of a session cookie.
-// It may be specified in config as "session.expires". Values greater than 0
-// set a persistent cookie with a time to live as specified, and the value 0
-// sets a session cookie.
-var expireAfterDuration time.Duration
-var cookieDomain = "" // life
-func init() {
-	// Set expireAfterDuration, default to 30 days if no value in config
-	revel.OnAppStart(func() {
-		var err error
-		if expiresString, ok := revel.Config.String("session.expires"); !ok {
-			expireAfterDuration = 30 * 24 * time.Hour
-		} else if expiresString == "session" {
-			expireAfterDuration = 0
-		} else if expireAfterDuration, err = time.ParseDuration(expiresString); err != nil {
-			panic(fmt.Errorf("session.expires invalid: %s", err))
-		}
-		
-		cookieDomain, _ = revel.Config.String("cookie.domain")
-	})
-}
-
-// Id retrieves from the cookie or creates a time-based UUID identifying this
-// session.
-func (s Session) Id() string {
-	if sessionIdStr, ok := s[SESSION_ID_KEY]; ok {
-		return sessionIdStr
-	}
-
-	buffer := make([]byte, 32)
-	if _, err := rand.Read(buffer); err != nil {
-		panic(err)
-	}
-
-	s[SESSION_ID_KEY] = hex.EncodeToString(buffer)
-	return s[SESSION_ID_KEY]
-}
-
-// getExpiration return a time.Time with the session's expiration date.
-// If previous session has set to "session", remain it
-func (s Session) getExpiration() time.Time {
-	if expireAfterDuration == 0 || s[TIMESTAMP_KEY] == "session" {
-		// Expire after closing browser
-		return time.Time{}
-	}
-	return time.Now().Add(expireAfterDuration)
-}
-
-// cookie returns an http.Cookie containing the signed session.
-func (s Session) cookie() *http.Cookie {
-	var sessionValue string
-	ts := s.getExpiration()
-	s[TIMESTAMP_KEY] = getSessionExpirationCookie(ts)
-	for key, value := range s {
-		if strings.ContainsAny(key, ":\x00") {
-			panic("Session keys may not have colons or null bytes")
-		}
-		if strings.Contains(value, "\x00") {
-			panic("Session values may not have null bytes")
-		}
-		sessionValue += "\x00" + key + ":" + value + "\x00"
-	}
-
-	sessionData := url.QueryEscape(sessionValue)
-	cookie := http.Cookie{
-		Name:     revel.CookiePrefix + "_SESSION",
-		Value:    revel.Sign(sessionData) + "-" + sessionData,
-		Path:     "/",
-		HttpOnly: revel.CookieHttpOnly,
-		Secure:   revel.CookieSecure,
-		Expires:  ts.UTC(),
-	}
-	
-	if cookieDomain != "" {
-		cookie.Domain = cookieDomain
-	}
-	
-	return &cookie
-}
-
-// sessionTimeoutExpiredOrMissing returns a boolean of whether the session
-// cookie is either not present or present but beyond its time to live; i.e.,
-// whether there is not a valid session.
-func sessionTimeoutExpiredOrMissing(session Session) bool {
-	if exp, present := session[TIMESTAMP_KEY]; !present {
-		return true
-	} else if exp == "session" {
-		return false
-	} else if expInt, _ := strconv.Atoi(exp); int64(expInt) < time.Now().Unix() {
-		return true
-	}
-	return false
-}
-
-// getSessionFromCookie returns a Session struct pulled from the signed
-// session cookie.
-func getSessionFromCookie(cookie *http.Cookie) Session {
-	session := make(Session)
-
-	// Separate the data from the signature.
-	hyphen := strings.Index(cookie.Value, "-")
-	if hyphen == -1 || hyphen >= len(cookie.Value)-1 {
-		return session
-	}
-	sig, data := cookie.Value[:hyphen], cookie.Value[hyphen+1:]
-
-	// Verify the signature.
-	if !revel.Verify(data, sig) {
-		revel.INFO.Println("Session cookie signature failed")
-		return session
-	}
-
-	revel.ParseKeyValueCookie(data, func(key, val string) {
-		session[key] = val
-	})
-
-	if sessionTimeoutExpiredOrMissing(session) {
-		session = make(Session)
-	}
-
-	return session
-}
-
-// SessionFilter is a Revel Filter that retrieves and sets the session cookie.
-// Within Revel, it is available as a Session attribute on Controller instances.
-// The name of the Session cookie is set as CookiePrefix + "_SESSION".
-func SessionFilter(c *revel.Controller, fc []revel.Filter) {
-	session := restoreSession(c.Request.Request)
-	// c.Session, 重新生成一个revel.Session给controller!!!
-//	Log("sessoin--------")
-//	LogJ(session)
-	revelSession := revel.Session(session) // 强制转换 还是同一个对象, 但有个问题, 这样Session.Id()方法是用revel的了
-	c.Session = revelSession
-	// 生成sessionId
-	c.Session.Id()
-	sessionWasEmpty := len(c.Session) == 0
-
-	// Make session vars available in templates as {{.session.xyz}}
-	c.RenderArgs["session"] = c.Session
-
-	fc[0](c, fc[1:])
-
-	// Store the signed session if it could have changed.
-	if len(c.Session) > 0 || !sessionWasEmpty {
-		// 转换成lea.Session
-		session = Session(c.Session)
-		c.SetCookie(session.cookie())
-	}
-}
-
-// restoreSession returns either the current session, retrieved from the
-// session cookie, or a new session.
-func restoreSession(req *http.Request) Session {
-	cookie, err := req.Cookie(revel.CookiePrefix + "_SESSION")
-	if err != nil {
-		return make(Session)
-	} else {
-		return getSessionFromCookie(cookie)
-	}
-}
-
-// getSessionExpirationCookie retrieves the cookie's time to live as a
-// string of either the number of seconds, for a persistent cookie, or
-// "session".
-func getSessionExpirationCookie(t time.Time) string {
-	if t.IsZero() {
-		return "session"
-	}
-	return strconv.FormatInt(t.Unix(), 10)
-}
-
-// SetNoExpiration sets session to expire when browser session ends
-func (s Session) SetNoExpiration() {
-	s[TIMESTAMP_KEY] = "session"
-}
-
-// SetDefaultExpiration sets session to expire after default duration
-func (s Session) SetDefaultExpiration() {
-	delete(s, TIMESTAMP_KEY)
-}