v3.4.0

.gitattributes

@@ -0,0 +1,2 @@
+*.js linguist-language=java
+*.css linguist-language=java

.gitignore

@@ -0,0 +1,34 @@
+# maven ignore
+target/
+*.jar
+*.war
+*.zip
+*.tar
+*.tar.gz
+
+# eclipse ignore
+.settings/
+.project 
+.classpath
+
+# idea ignore
+.idea/
+*.ipr
+*.iml
+*.iws
+
+# temp ignore
+logs/
+*.doc
+*.log
+*.cache
+*.diff
+*.patch
+*.tmp
+
+# system ignore
+.DS_Store
+Thumbs.db
+
+*.class
+

LICENSE

@@ -1,21 +1,661 @@
-MIT License
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
-Copyright (c) 2019 alvis
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+                            Preamble
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+  The GNU Affero General Public License is a free, copyleft license for
-copies or substantial portions of the Software.
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  The licenses for most software and other practical works are designed
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+to take away your freedom to share and change the works.  By contrast,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+our General Public Licenses are intended to guarantee your freedom to
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+share and change all versions of a program--to make sure it remains free
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+software for all its users.
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+
-SOFTWARE.
+  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
+them 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.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey 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;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If 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 convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  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.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+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.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     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
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

README.md

@@ -0,0 +1,137 @@
+# 学之思在线考试系统
+
+### 项目介绍
+学之思在线考试系统是一款 java + vue 的前后端分离的考试系统。主要优点是开发、部署简单快捷、界面设计友好、代码结构清晰。目前支持web端和微信小程序，能覆盖到pc机和手机等设备。
+
+
+### 开源版使用须知
+ * 仅用个人学习，商用请购买授权 [http://www.alvisu.com/buy.html](http://www.alvisu.com/buy.html) 
+ * 禁止将本项目的代码和资源进行任何形式的出售，产生的一切任何后果责任由侵权者自负
+
+### 演示地址
+ * 官网：[http://www.alvisu.com](http://www.alvisu.com)
+ * 学之思：[http://www.alvisu.com/uexam.html](http://www.alvisu.com/uexam.html) 
+ * 学多多：[http://www.alvisu.com/xdd.html](http://www.alvisu.com/xdd.html) 
+ * 思多多：[http://www.alvisu.com/sdd.html](http://www.alvisu.com/sdd.html) 
+
+### 学之思仓库版本地址
+* gitee - postgresql ：[https://gitee.com/alvis-yu/uexam](https://gitee.com/alvis-yu/uexam)
+* github - postgresql ：[https://github.com/alvis-u/uexam](https://github.com/alvis-u/uexam)
+* gitee - mysql ：[https://gitee.com/alvis-yu/uexam-mysql](https://gitee.com/alvis-yu/uexam-mysql)
+* github - mysql ：[https://github.com/alvis-u/uexam-mysql](https://github.com/alvis-u/uexam-mysql)
+
+### 学之思交流群(加群获取数据库脚本)
+* 交流一群：`530136203`(满)
+* 交流二群：`947654489`(满)
+* 交流三群：`670546875`(满)
+* 交流四群：`1039666905`
+* 作者QQ：`2693073475`
+
+ 
+### 大事件
+ * 2020/5 商业考试系统思多多正式版发布 地址：[http://www.alvisu.com/sdd.html](http://www.alvisu.com/sdd.html) 
+ * 2020/3 考试系统实战教程发布 试听地址：[https://alvis.ke.qq.com/?tuin=a0850a43](https://alvis.ke.qq.com/?tuin=a0850a43)
+ * 2020/2 项目累计突破2000 star
+ * 2020/1 累计超过150万用户使用
+ * 2019/12 项目累计突破1000 star
+ * 2019/11 入围开源中国最受欢迎开源项目
+ * 2019/10 累计超过100万学生使用
+ * 2019/10 荣获码云最有价值开源项目
+ * 2019/8 release 1.0 发布
+ * 2019/7 学之思开源考试系统项目启动
+
+
+### 学生系统功能
+* 登录、注册： 注册时要选年级，过滤不同年级的试卷， 账号为student/123456
+* 首页： 任务中心、固定试卷、时段试卷、可以能做的一部分试卷
+* 试卷中心： 包含了所有能做的试卷，按学科来过滤和分页
+* 考试记录： 所有的试卷考试记录在此处分页，可以查看试卷结果、用时、得分、自行批改等
+* 错题本： 所有做错的题目，可以看到做题的结果、分数、难度、解析、正确答案等
+* 个人中心： 个人日志记录
+* 消息： 消息通知 
+* 试卷答题和试卷查看： 展示出题目的基本信息和需要填写的内容
+
+### 管理系统功能
+* 登录： 账号为 admin/123456
+* 主页： 包含了试卷、题目、做卷数、做题数、用户活跃度的统计功能，活跃度和做题数是按月统计
+* 用户管理： 对不同角色 学生、教师、管理员 的增删改查管理功能
+* 卷题管理：
+    1. 试卷列表：试卷的增删改查，新增包含选择学科、试卷类型、试卷名称、考试时间，试卷内容包含添加大标题，然后添加题目到此试卷中，组成一套完整的试卷
+    2. 题目列表：题目的增删改查，目前题型包含单选题、多选题、判断题、填空题、简单题，支持图片、公式等。
+* 教育管理：对不同年级的学科进行增删改查
+* 消息中心：可以对多个用户进行消息发送，预留：加入班级，推送试卷等消息
+* 日志中心：用户的基本操作进行日志记录，了解用户使用过情况
+
+### 小程序学生系统功能：
+* 用户登录登出功能，登录会自动绑定微信账号，登出会解绑
+* 首页包含任务中心、固定试卷、时段试卷、推送试卷模块，和web端保持一致
+* 试卷模块，固定试卷和时段试卷的分页查询，下拉加载更多，上拉刷新当前数据
+* 记录模块，考试结果的分页，包含了试卷基本信息
+* 我的模块，包含个人资料的修改，个人动态，消息中心模块
+
+
+###  技术栈列表
+后台系统：
+* spring-boot  2.1.6.RELEASE
+* spring-boot-security 用户登录验证 
+* undertow  web容器 
+* postgresql/mysql 优秀的开源数据库
+* redis 缓存，提升系统性能
+* mybatis 数据库中间件
+* hikari 速度最快的数据库连接池
+* 七牛云存储 目前10G内免费
+
+前台系统：
+* Vue.js  采用新版，使用了vue-cli3搭建的系统，减少大量配置文件
+* element-ui  最流行的vue组件，采用的最新版
+* vue-element-admin 最新版，对该系统做了大量精简，只保留了部分样式和控件
+* echarts 图表统计
+* ueditor 为了支持填空题，做了部分修改
+
+微信小程序：
+* iView 主题样式
+
+### 使用教程
+1. redis 安装
+2. 进群获取到数据库脚本，创建表初始化数据
+3. /uexam/source/exam为后台代码，建议使用IntelliJ IDEA打开，在application-dev.yml文件中，配置好postgesql/mysql、redis的服务地址，打开ExamApplication文件编译运行,默认端口为8000。
+4. 学生系统地址：http://localhost:8000/student
+5. 管理端地址：http://localhost:8000/admin
+
+### 软件架构图
+![](doc/image/frame/2.png)
+
+### 系统展示
+* 学生考试系统
+<table>
+    <tr>
+        <td><img src="doc/image/student/2.png"/></td>
+        <td><img src="doc/image/student/12.png"/></td>
+    </tr>
+</table>
+
+*  小程序考试系统
+<table>
+    <tr>
+        <td><img src="doc/image/wx/student/1.png"/></td>
+        <td><img src="doc/image/wx/student/2.png"/></td>
+        <td><img src="doc/image/wx/student/3.png"/></td>
+        <td><img src="doc/image/wx/student/4.png"/></td>
+    </tr>
+    <tr>
+        <td><img src="doc/image/wx/student/5.png"/></td>
+        <td><img src="doc/image/wx/student/8.png"/></td>
+        <td><img src="doc/image/wx/student/6.png"/></td>
+        <td><img src="doc/image/wx/student/7.png"/></td>
+    </tr>
+</table>
+
+* 后台管理系统
+
+<table>
+    <tr>
+        <td><img src="doc/image/admin/12.png"/></td>
+        <td><img src="doc/image/admin/13.png"/></td>
+    </tr>
+</table>
+     

source/exam/.gitignore

@@ -0,0 +1,29 @@
+/target/
+!.mvn/wrapper/maven-wrapper.jar
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/build/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+
+### Customer ###
+/logs/

source/exam/mvnw

@@ -0,0 +1,225 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Maven2 Start Up Batch script
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   M2_HOME - location of maven2's installed home dir
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+  if [ -f /etc/mavenrc ] ; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ] ; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "`uname`" in
+  CYGWIN*) cygwin=true ;;
+  MINGW*) mingw=true;;
+  Darwin*) darwin=true
+    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+    if [ -z "$JAVA_HOME" ]; then
+      if [ -x "/usr/libexec/java_home" ]; then
+        export JAVA_HOME="`/usr/libexec/java_home`"
+      else
+        export JAVA_HOME="/Library/Java/Home"
+      fi
+    fi
+    ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+  if [ -r /etc/gentoo-release ] ; then
+    JAVA_HOME=`java-config --jre-home`
+  fi
+fi
+
+if [ -z "$M2_HOME" ] ; then
+  ## resolve links - $0 may be a link to maven's home
+  PRG="$0"
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+      PRG="$link"
+    else
+      PRG="`dirname "$PRG"`/$link"
+    fi
+  done
+
+  saveddir=`pwd`
+
+  M2_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  M2_HOME=`cd "$M2_HOME" && pwd`
+
+  cd "$saveddir"
+  # echo Using m2 at $M2_HOME
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --unix "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+fi
+
+# For Migwn, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME="`(cd "$M2_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+  # TODO classpath?
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+      if $darwin ; then
+        javaHome="`dirname \"$javaExecutable\"`"
+        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+      else
+        javaExecutable="`readlink -f \"$javaExecutable\"`"
+      fi
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+  if [ -n "$JAVA_HOME"  ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="`which java`"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+
+  if [ -z "$1" ]
+  then
+    echo "Path not specified to find_maven_basedir"
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ] ; do
+    if [ -d "$wdir"/.mvn ] ; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=`cd "$wdir/.."; pwd`
+    fi
+    # end of workaround
+  done
+  echo "${basedir}"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    echo "$(tr -s '\n' ' ' < "$1")"
+  fi
+}
+
+BASE_DIR=`find_maven_basedir "$(pwd)"`
+if [ -z "$BASE_DIR" ]; then
+  exit 1;
+fi
+
+export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+echo $MAVEN_PROJECTBASEDIR
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --path --windows "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+fi
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

source/exam/mvnw.cmd

@@ -0,0 +1,143 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Maven2 Start Up Batch script
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a key stroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM enable echoing my setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
+if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat"
+if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%" == "on" pause
+
+if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE%
+
+exit /B %ERROR_CODE%

source/exam/pom.xml

@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.alvis</groupId>
+    <artifactId>exam</artifactId>
+    <version>3.0.4</version>
+    <packaging>jar</packaging>
+
+    <name>exam</name>
+    <description>学之思考试平台</description>
+
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <java.version>1.8</java.version>
+        <mysql.version>8.0.17</mysql.version>
+        <spring.boot.version>2.1.6.RELEASE</spring.boot.version>
+    </properties>
+
+
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.1.6.RELEASE</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+
+
+    <repositories>
+        <repository>
+            <id>nexus-aliyun</id>
+            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
+        </repository>
+    </repositories>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-cache</artifactId>
+            <version>${spring.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+            <version>${spring.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+            <version>${spring.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <version>${spring.boot.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.springframework.boot</groupId>
+                    <artifactId>spring-boot-starter-tomcat</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-undertow</artifactId>
+            <version>${spring.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.session</groupId>
+            <artifactId>spring-session-data-redis</artifactId>
+            <version>${spring.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <version>${spring.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+            <version>2.1.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.pagehelper</groupId>
+            <artifactId>pagehelper-spring-boot-starter</artifactId>
+            <version>1.2.12</version>
+        </dependency>
+
+
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+            <version>2.6.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.9</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.modelmapper</groupId>
+            <artifactId>modelmapper</artifactId>
+            <version>2.3.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.8</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.9</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.qiniu</groupId>
+            <artifactId>qiniu-java-sdk</artifactId>
+            <version>7.2.25</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <version>${spring.boot.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- hot debug -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <version>${spring.boot.version}</version>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+    </dependencies>
+
+
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring.boot.version}</version>
+                <configuration>
+                    <fork>true</fork>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <skipTests>true</skipTests>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.mybatis.generator</groupId>
+                <artifactId>mybatis-generator-maven-plugin</artifactId>
+                <version>1.3.7</version>
+                <configuration>
+                    <configurationFile>src/main/resources/mybatis-generator/generatorConfig.xml</configurationFile>
+                    <verbose>true</verbose>
+                    <overwrite>true</overwrite>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>Generate MyBatis Artifacts</id>
+                        <phase>deploy</phase>
+                        <goals>
+                            <goal>generate</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.mybatis.generator</groupId>
+                        <artifactId>mybatis-generator-core</artifactId>
+                        <version>1.3.7</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>mysql</groupId>
+                        <artifactId>mysql-connector-java</artifactId>
+                        <version>${mysql.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+        </plugins>
+    </build>
+</project>

source/exam/src/main/java/com/alvis/exam/ExamApplication.java

@@ -0,0 +1,22 @@
+package com.alvis.exam;
+
+import com.alvis.exam.configuration.property.SystemConfig;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+/**
+ * @author alvis
+ */
+@SpringBootApplication
+@EnableTransactionManagement
+@EnableConfigurationProperties(value = { SystemConfig.class})
+@EnableCaching
+public class ExamApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ExamApplication.class, args);
+    }
+}

source/exam/src/main/java/com/alvis/exam/base/BaseApiController.java

@@ -0,0 +1,23 @@
+package com.alvis.exam.base;
+
+
+import com.alvis.exam.context.WebContext;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.utility.ModelMapperSingle;
+import org.modelmapper.ModelMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+/**
+ * @author alvis
+ */
+public class BaseApiController {
+    protected final static String DEFAULT_PAGE_SIZE = "10";
+    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
+    @Autowired
+    protected WebContext webContext;
+
+    protected User getCurrentUser() {
+        return webContext.getCurrentUser();
+    }
+}

source/exam/src/main/java/com/alvis/exam/base/BaseEntity.java

@@ -0,0 +1,9 @@
+package com.alvis.exam.base;
+
+
+/**
+ * @author alvis
+ */
+public abstract class BaseEntity {
+
+}

source/exam/src/main/java/com/alvis/exam/base/BasePage.java

@@ -0,0 +1,15 @@
+package com.alvis.exam.base;
+
+import lombok.Data;
+
+/**
+ * @author alvis
+ */
+
+@Data
+public class BasePage {
+    private Integer pageIndex;
+
+    private Integer pageSize;
+
+}

source/exam/src/main/java/com/alvis/exam/base/RestResponse.java

@@ -0,0 +1,59 @@
+package com.alvis.exam.base;
+
+/**
+ * @author alvis
+ */
+public class RestResponse<T> {
+    private int code;
+    private String message;
+    private T response;
+
+    public RestResponse(int code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    public RestResponse(int code, String message, T response) {
+        this.code = code;
+        this.message = message;
+        this.response = response;
+    }
+
+    public static RestResponse fail(Integer code, String msg) {
+        return new RestResponse<>(code, msg);
+    }
+
+    public static RestResponse ok() {
+        SystemCode systemCode = SystemCode.OK;
+        return new RestResponse<>(systemCode.getCode(), systemCode.getMessage());
+    }
+
+    public static <F> RestResponse<F> ok(F response) {
+        SystemCode systemCode = SystemCode.OK;
+        return new RestResponse<>(systemCode.getCode(), systemCode.getMessage(), response);
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public void setCode(int code) {
+        this.code = code;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public T getResponse() {
+        return response;
+    }
+
+    public void setResponse(T response) {
+        this.response = response;
+    }
+}

source/exam/src/main/java/com/alvis/exam/base/SystemCode.java

@@ -0,0 +1,52 @@
+package com.alvis.exam.base;
+
+/**
+ * @author alvis
+ */
+public enum SystemCode {
+    /**
+     * OK
+     */
+    OK(1, "成功"),
+    /**
+     * AccessTokenError
+     */
+    AccessTokenError(400, "用户登录令牌失效"),
+    /**
+     * UNAUTHORIZED
+     */
+    UNAUTHORIZED(401, "用户未登录"),
+    /**
+     * UNAUTHORIZED
+     */
+    AuthError(402, "用户名或密码错误"),
+    /**
+     * InnerError
+     */
+    InnerError(500, "系统内部错误"),
+    /**
+     * ParameterValidError
+     */
+    ParameterValidError(501, "参数验证错误"),
+
+    /**
+     * AccessDenied
+     */
+    AccessDenied(502,"用户没有权限访问");
+
+    int code;
+    String message;
+
+    SystemCode(int code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/application/ApplicationContextProvider.java

@@ -0,0 +1,32 @@
+package com.alvis.exam.configuration.application;
+
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author alvis
+ */
+@Component
+public class ApplicationContextProvider implements ApplicationContextAware {
+    private static ApplicationContext context;
+
+    private ApplicationContextProvider() {
+    }
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        context = applicationContext;
+    }
+
+    public static <T> T getBean(Class<T> aClass) {
+        return context.getBean(aClass);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T getBean(String name) {
+        return (T) context.getBean(name);
+    }
+}
+

source/exam/src/main/java/com/alvis/exam/configuration/property/CookieConfig.java

@@ -0,0 +1,12 @@
+package com.alvis.exam.configuration.property;
+
+public class CookieConfig {
+
+    public static String getName() {
+        return "exam";
+    }
+
+    public static Integer getInterval() {
+        return 30 * 24 * 60 * 60;
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/property/PasswordKeyConfig.java

@@ -0,0 +1,9 @@
+package com.alvis.exam.configuration.property;
+
+import lombok.Data;
+
+@Data
+public class PasswordKeyConfig {
+    private String publicKey;
+    private String privateKey;
+}

source/exam/src/main/java/com/alvis/exam/configuration/property/QnConfig.java

@@ -0,0 +1,14 @@
+package com.alvis.exam.configuration.property;
+
+import lombok.Data;
+
+import java.time.Duration;
+import java.util.List;
+
+@Data
+public class QnConfig {
+    private String url;
+    private String bucket;
+    private String accessKey;
+    private String secretKey;
+}

source/exam/src/main/java/com/alvis/exam/configuration/property/SystemConfig.java

@@ -0,0 +1,19 @@
+package com.alvis.exam.configuration.property;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.List;
+
+
+/**
+ * @author alvis
+ */
+@ConfigurationProperties(prefix = "system")
+@Data
+public class SystemConfig {
+    private PasswordKeyConfig pwdKey;
+    private List<String> securityIgnoreUrls;
+    private WxConfig wx;
+    private QnConfig qn;
+}

source/exam/src/main/java/com/alvis/exam/configuration/property/WxConfig.java

@@ -0,0 +1,14 @@
+package com.alvis.exam.configuration.property;
+
+import lombok.Data;
+
+import java.time.Duration;
+import java.util.List;
+
+@Data
+public class WxConfig {
+    private String appid;
+    private String secret;
+    private Duration tokenToLive;
+    private List<String> securityIgnoreUrls;
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/cache/CacheConfig.java

@@ -0,0 +1,78 @@
+package com.alvis.exam.configuration.spring.cache;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.cache.CacheProperties;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.cache.interceptor.SimpleKey;
+import org.springframework.cache.interceptor.SimpleKeyGenerator;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.CacheKeyPrefix;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.cache.RedisCacheWriter;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.data.redis.serializer.*;
+
+import java.time.Duration;
+
+
+@Configuration
+@EnableCaching
+public class CacheConfig extends CachingConfigurerSupport {
+
+/*  @Autowired
+    private CacheProperties cacheProperties;*/
+
+    /**
+     * redis序列化修改为ObjectMapper
+     *
+     * @return RedisCacheConfiguration
+     */
+/*    @Bean
+    public RedisCacheConfiguration redisCacheConfiguration() {
+        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        serializer.setObjectMapper(objectMapper);
+        return RedisCacheConfiguration.defaultCacheConfig().entryTtl(cacheProperties.getRedis().getTimeToLive())
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));
+    }*/
+
+
+    /**
+     * spring boot redis默认序列化方式
+     *
+     * @return RedisTemplate
+     */
+    @Bean
+    public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
+        final RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(redisConnectionFactory);
+        redisTemplate.setKeySerializer(RedisSerializer.string());
+        redisTemplate.setHashKeySerializer(RedisSerializer.string());
+        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
+
+    /**
+     * spring redis 默认生成key方式,包含::号
+     *
+     * @param prefix
+     * @param key
+     * @return
+     */
+    public String simpleKeyGenerator(String prefix, String key) {
+        return CacheKeyPrefix.simple().compute(prefix) + key;
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/exception/ExceptionHandle.java

@@ -0,0 +1,49 @@
+package com.alvis.exam.configuration.spring.exception;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.base.SystemCode;
+import com.alvis.exam.utility.ErrorUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.validation.BindException;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import java.util.stream.Collectors;
+
+@ControllerAdvice
+public class ExceptionHandle {
+    private final static Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);
+
+    @ExceptionHandler(Exception.class)
+    @ResponseBody
+    public RestResponse handler(Exception e) {
+        logger.error(e.getMessage(), e);
+        return new RestResponse<>(SystemCode.InnerError.getCode(), SystemCode.InnerError.getMessage());
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    @ResponseBody
+    public RestResponse handler(MethodArgumentNotValidException e) {
+        String errorMsg = e.getBindingResult().getAllErrors().stream().map(file -> {
+            FieldError fieldError = (FieldError) file;
+            return ErrorUtil.parameterErrorFormat(fieldError.getField(), fieldError.getDefaultMessage());
+        }).collect(Collectors.joining());
+        return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
+    }
+
+    @ExceptionHandler(BindException.class)
+    @ResponseBody
+    public RestResponse handler(BindException e) {
+        String errorMsg = e.getBindingResult().getAllErrors().stream().map(file -> {
+            FieldError fieldError = (FieldError) file;
+            return ErrorUtil.parameterErrorFormat(fieldError.getField(), fieldError.getDefaultMessage());
+        }).collect(Collectors.joining());
+        return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
+    }
+
+
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/mvc/WebMvcConfiguration.java

@@ -0,0 +1,58 @@
+package com.alvis.exam.configuration.spring.mvc;
+
+import com.alvis.exam.configuration.property.SystemConfig;
+import com.alvis.exam.configuration.spring.wx.TokenHandlerInterceptor;
+import lombok.AllArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.*;
+
+import java.util.List;
+
+
+/**
+ * @author alvis
+ */
+
+@Configuration
+@AllArgsConstructor
+public class WebMvcConfiguration extends WebMvcConfigurationSupport {
+
+    private final TokenHandlerInterceptor tokenHandlerInterceptor;
+    private final SystemConfig systemConfig;
+
+    @Override
+    public void addViewControllers(ViewControllerRegistry registry) {
+        registry.addRedirectViewController("/", "/student/index.html");
+        registry.addRedirectViewController("/student", "/student/index.html");
+        registry.addRedirectViewController("/admin", "/admin/index.html");
+    }
+
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        registry.addResourceHandler("/**")
+                .addResourceLocations("classpath:/static/")
+                .setCachePeriod(31556926);
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        List<String> securityIgnoreUrls = systemConfig.getWx().getSecurityIgnoreUrls();
+        String[] ignores = new String[securityIgnoreUrls.size()];
+        registry.addInterceptor(tokenHandlerInterceptor)
+                .addPathPatterns("/api/wx/**")
+                .excludePathPatterns(securityIgnoreUrls.toArray(ignores));
+        super.addInterceptors(registry);
+    }
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowCredentials(true)
+                .allowedMethods("*")
+                .allowedOrigins("*")
+                .allowedHeaders("*");
+        super.addCorsMappings(registry);
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/AuthenticationBean.java

@@ -0,0 +1,14 @@
+package com.alvis.exam.configuration.spring.security;
+
+import lombok.Data;
+
+/**
+ * @author alvis
+ */
+
+@Data
+public class AuthenticationBean {
+    private String userName;
+    private String password;
+    private boolean remember;
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/LoginAuthenticationEntryPoint.java

@@ -0,0 +1,30 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.base.SystemCode;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * 未登录
+ * @author alvis
+ */
+@Component
+public final class LoginAuthenticationEntryPoint extends LoginUrlAuthenticationEntryPoint {
+
+    public LoginAuthenticationEntryPoint() {
+        super("/api/user/login");
+    }
+
+    @Override
+    public void commence(HttpServletRequest request, HttpServletResponse response,
+                         AuthenticationException authException) throws IOException, ServletException {
+        RestUtil.response(response, SystemCode.UNAUTHORIZED);
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestAccessDeniedHandler.java

@@ -0,0 +1,22 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.base.SystemCode;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.web.access.AccessDeniedHandler;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * 没权限
+ */
+@Component
+public class RestAccessDeniedHandler implements AccessDeniedHandler {
+    @Override
+    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
+        RestUtil.response(httpServletResponse, SystemCode.AccessDenied);
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestAuthenticationFailureHandler.java

@@ -0,0 +1,24 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.base.SystemCode;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * 账号验证异常
+ * @author alvis
+ */
+@Component
+public class RestAuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {
+
+    @Override
+    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
+        RestUtil.response(response, SystemCode.AuthError.getCode(), exception.getMessage());
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestAuthenticationProvider.java

@@ -0,0 +1,77 @@
+package com.alvis.exam.configuration.spring.security;
+
+
+import com.alvis.exam.context.WebContext;
+import com.alvis.exam.domain.enums.RoleEnum;
+import com.alvis.exam.domain.enums.UserStatusEnum;
+import com.alvis.exam.service.AuthenticationService;
+import com.alvis.exam.service.UserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.authentication.AuthenticationProvider;
+import org.springframework.security.authentication.BadCredentialsException;
+import org.springframework.security.authentication.LockedException;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+/**
+ * 登录用户名密码验证
+ *
+ * @author :  Alvis
+ * Description :  身份验证
+ * Creation Date:  2018-05-02 5:00 PM
+ */
+
+@Component
+public class RestAuthenticationProvider implements AuthenticationProvider {
+
+    private final AuthenticationService authenticationService;
+    private final UserService userService;
+    private final WebContext webContext;
+
+    @Autowired
+    public RestAuthenticationProvider(AuthenticationService authenticationService, UserService userService, WebContext webContext) {
+        this.authenticationService = authenticationService;
+        this.userService = userService;
+        this.webContext = webContext;
+    }
+
+    @Override
+    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
+        String username = authentication.getName();
+        String password = (String) authentication.getCredentials();
+
+        com.alvis.exam.domain.User user = userService.getUserByUserName(username);
+        if (user == null) {
+            throw new UsernameNotFoundException("用户名或密码错误");
+        }
+
+        boolean result = authenticationService.authUser(user, username, password);
+        if (!result) {
+            throw new BadCredentialsException("用户名或密码错误");
+        }
+
+        UserStatusEnum userStatusEnum = UserStatusEnum.fromCode(user.getStatus());
+        if (UserStatusEnum.Disable == userStatusEnum) {
+            throw new LockedException("用户被禁用");
+        }
+
+        ArrayList<GrantedAuthority> grantedAuthorities = new ArrayList<>();
+        grantedAuthorities.add(new SimpleGrantedAuthority(RoleEnum.fromCode(user.getRole()).getRoleName()));
+
+        User authUser = new User(user.getUserName(), user.getPassword(), grantedAuthorities);
+        return new UsernamePasswordAuthenticationToken(authUser, authUser.getPassword(), authUser.getAuthorities());
+    }
+
+    @Override
+    public boolean supports(Class<?> aClass) {
+        return true;
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestAuthenticationSuccessHandler.java

@@ -0,0 +1,45 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.base.SystemCode;
+import com.alvis.exam.context.WebContext;
+import com.alvis.exam.domain.UserEventLog;
+import com.alvis.exam.event.UserEvent;
+import com.alvis.exam.service.UserService;
+import lombok.AllArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * 登录成功返回
+ *
+ * @author alvis
+ */
+@Component
+@AllArgsConstructor
+public class RestAuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
+
+    private final ApplicationEventPublisher eventPublisher;
+    private final UserService userService;
+
+    @Override
+    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
+        User springUser = (User) authentication.getPrincipal();
+        com.alvis.exam.domain.User user = userService.getUserByUserName(springUser.getUsername());
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        userEventLog.setContent(user.getUserName() + " 登录了学之思考试系统");
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        com.alvis.exam.domain.User newUser = new com.alvis.exam.domain.User();
+        newUser.setUserName(user.getUserName());
+        newUser.setImagePath(user.getImagePath());
+        RestUtil.response(response, SystemCode.OK.getCode(), SystemCode.OK.getMessage(), newUser);
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestDetailsServiceImpl.java

@@ -0,0 +1,47 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.context.WebContext;
+import com.alvis.exam.domain.enums.RoleEnum;
+import com.alvis.exam.service.UserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+/**
+ * @author :  Alvis
+ * Description :  验证通过之后,第二、三...请求，会调用此类
+ * Creation Date:  2018-05-02 4:32 PM
+ */
+
+@Component
+public class RestDetailsServiceImpl implements UserDetailsService {
+
+    private final UserService userService;
+
+    @Autowired
+    public RestDetailsServiceImpl(UserService userService) {
+        this.userService = userService;
+    }
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+
+        com.alvis.exam.domain.User user = userService.getUserByUserName(username);
+
+        if (user == null) {
+            throw new UsernameNotFoundException("Username  not found.");
+        }
+
+        ArrayList<GrantedAuthority> grantedAuthorities = new ArrayList<>();
+        grantedAuthorities.add(new SimpleGrantedAuthority(RoleEnum.fromCode(user.getRole()).getRoleName()));
+
+        return new User(user.getUserName(), user.getPassword(), grantedAuthorities);
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestLoginAuthenticationFilter.java

@@ -0,0 +1,57 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.configuration.property.CookieConfig;
+
+import com.alvis.exam.utility.JsonUtil;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
+import org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices;
+import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * 登录参数序列化
+ * @author alvis
+ */
+
+public class RestLoginAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
+    private final org.slf4j.Logger logger = LoggerFactory.getLogger(RestLoginAuthenticationFilter.class);
+
+    public RestLoginAuthenticationFilter() {
+        super(new AntPathRequestMatcher("/api/user/login", "POST"));
+    }
+
+    @Override
+    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
+        UsernamePasswordAuthenticationToken authRequest;
+        try (InputStream is = request.getInputStream()) {
+            AuthenticationBean authenticationBean = JsonUtil.toJsonObject(is, AuthenticationBean.class);
+            request.setAttribute(TokenBasedRememberMeServices.DEFAULT_PARAMETER, authenticationBean.isRemember());
+            authRequest = new UsernamePasswordAuthenticationToken(authenticationBean.getUserName(), authenticationBean.getPassword());
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+            authRequest = new UsernamePasswordAuthenticationToken("", "");
+        }
+        setDetails(request, authRequest);
+        return this.getAuthenticationManager().authenticate(authRequest);
+
+    }
+
+    void setUserDetailsService(UserDetailsService userDetailsService) {
+        RestTokenBasedRememberMeServices tokenBasedRememberMeServices = new RestTokenBasedRememberMeServices(CookieConfig.getName(), userDetailsService);
+        tokenBasedRememberMeServices.setTokenValiditySeconds(CookieConfig.getInterval());
+        setRememberMeServices(tokenBasedRememberMeServices);
+    }
+
+    private void setDetails(HttpServletRequest request, UsernamePasswordAuthenticationToken authRequest) {
+        authRequest.setDetails(authenticationDetailsSource.buildDetails(request));
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestLogoutSuccessHandler.java

@@ -0,0 +1,44 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.base.SystemCode;
+import com.alvis.exam.context.WebContext;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserEventLog;
+import com.alvis.exam.event.UserEvent;
+import com.alvis.exam.service.UserService;
+import lombok.AllArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * 用户登出
+ *
+ * @author alvis
+ */
+@Component
+@AllArgsConstructor
+public class RestLogoutSuccessHandler extends SimpleUrlLogoutSuccessHandler {
+
+    private final ApplicationEventPublisher eventPublisher;
+    private final UserService userService;
+
+    @Override
+    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
+        org.springframework.security.core.userdetails.User springUser = (org.springframework.security.core.userdetails.User) authentication.getPrincipal();
+        if (null != springUser) {
+            com.alvis.exam.domain.User user = userService.getUserByUserName(springUser.getUsername());
+            UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+            userEventLog.setContent(user.getUserName() + " 登出了学之思考试系统");
+            eventPublisher.publishEvent(new UserEvent(userEventLog));
+        }
+        RestUtil.response(response, SystemCode.OK);
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestTokenBasedRememberMeServices.java

@@ -0,0 +1,22 @@
+package com.alvis.exam.configuration.spring.security;
+
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.web.authentication.rememberme.TokenBasedRememberMeServices;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * 记住我，Cookie
+ * @author alvis
+ */
+public class RestTokenBasedRememberMeServices extends TokenBasedRememberMeServices {
+    public RestTokenBasedRememberMeServices(String key, UserDetailsService userDetailsService) {
+        super(key, userDetailsService);
+    }
+
+    @Override
+    protected boolean rememberMeRequested(HttpServletRequest request, String parameter) {
+        return (boolean) request.getAttribute(DEFAULT_PARAMETER);
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/RestUtil.java

@@ -0,0 +1,40 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.base.SystemCode;
+import com.alvis.exam.utility.JsonUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.MediaType;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * @author alvis
+ */
+public class RestUtil {
+    private static final Logger logger = LoggerFactory.getLogger(RestUtil.class);
+
+
+    public static void response(HttpServletResponse response, SystemCode systemCode) {
+        response(response, systemCode.getCode(), systemCode.getMessage());
+    }
+
+    public static void response(HttpServletResponse response, int systemCode, String msg) {
+        response(response, systemCode, msg, null);
+    }
+
+
+    public static void response(HttpServletResponse response, int systemCode, String msg, Object content) {
+        try {
+            RestResponse res = new RestResponse<>(systemCode, msg, content);
+            String resStr = JsonUtil.toJsonStr(res);
+            response.setContentType("application/json;charset=utf-8");
+            response.getWriter().write(resStr);
+        } catch (IOException e) {
+            logger.error(e.getMessage(), e);
+        }
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/security/SecurityConfigurer.java

@@ -0,0 +1,97 @@
+package com.alvis.exam.configuration.spring.security;
+
+import com.alvis.exam.configuration.property.CookieConfig;
+import com.alvis.exam.configuration.property.SystemConfig;
+import com.alvis.exam.domain.enums.RoleEnum;
+import lombok.AllArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+import java.util.Collections;
+import java.util.List;
+
+
+/**
+ * @author alvis
+ */
+
+@Configuration
+@EnableWebSecurity
+public class SecurityConfigurer {
+
+    @Configuration
+    @AllArgsConstructor
+    public static class FormLoginWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter {
+
+        private final SystemConfig systemConfig;
+        private final LoginAuthenticationEntryPoint restAuthenticationEntryPoint;
+        private final RestAuthenticationProvider restAuthenticationProvider;
+        private final RestDetailsServiceImpl formDetailsService;
+        private final RestAuthenticationSuccessHandler restAuthenticationSuccessHandler;
+        private final RestAuthenticationFailureHandler restAuthenticationFailureHandler;
+        private final RestLogoutSuccessHandler restLogoutSuccessHandler;
+        private final RestAccessDeniedHandler restAccessDeniedHandler;
+
+        /**
+         * @param http http
+         * @throws Exception exception
+         *                   csrf is the from submit get method
+         */
+        @Override
+        protected void configure(HttpSecurity http) throws Exception {
+            http.headers().frameOptions().disable();
+
+            List<String> securityIgnoreUrls = systemConfig.getSecurityIgnoreUrls();
+            String[] ignores = new String[securityIgnoreUrls.size()];
+            http
+                    .addFilterAt(authenticationFilter(), UsernamePasswordAuthenticationFilter.class)
+                    .exceptionHandling().authenticationEntryPoint(restAuthenticationEntryPoint)
+                    .and().authenticationProvider(restAuthenticationProvider)
+                    .authorizeRequests()
+                    .antMatchers(securityIgnoreUrls.toArray(ignores)).permitAll()
+                    .antMatchers("/api/admin/**").hasRole(RoleEnum.ADMIN.getName())
+                    .antMatchers("/api/student/**").hasRole(RoleEnum.STUDENT.getName())
+                    .anyRequest().permitAll()
+                    .and().exceptionHandling().accessDeniedHandler(restAccessDeniedHandler)
+                    .and().formLogin().successHandler(restAuthenticationSuccessHandler).failureHandler(restAuthenticationFailureHandler)
+                    .and().logout().logoutUrl("/api/user/logout").logoutSuccessHandler(restLogoutSuccessHandler).invalidateHttpSession(true)
+                    .and().rememberMe().key(CookieConfig.getName()).tokenValiditySeconds(CookieConfig.getInterval()).userDetailsService(formDetailsService)
+                    .and().csrf().disable()
+                    .cors();
+        }
+
+
+        @Bean
+        public CorsConfigurationSource corsConfigurationSource() {
+            final CorsConfiguration configuration = new CorsConfiguration();
+            configuration.setMaxAge(3600L);
+            configuration.setAllowedOrigins(Collections.singletonList("*"));
+            configuration.setAllowedMethods(Collections.singletonList("*"));
+            configuration.setAllowCredentials(true);
+            configuration.setAllowedHeaders(Collections.singletonList("*"));
+            final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+            source.registerCorsConfiguration("/api/**", configuration);
+            return source;
+        }
+
+
+        @Bean
+        public RestLoginAuthenticationFilter authenticationFilter() throws Exception {
+            RestLoginAuthenticationFilter authenticationFilter = new RestLoginAuthenticationFilter();
+            authenticationFilter.setAuthenticationSuccessHandler(restAuthenticationSuccessHandler);
+            authenticationFilter.setAuthenticationFailureHandler(restAuthenticationFailureHandler);
+            authenticationFilter.setAuthenticationManager(authenticationManagerBean());
+            authenticationFilter.setUserDetailsService(formDetailsService);
+            return authenticationFilter;
+        }
+
+
+    }
+}

source/exam/src/main/java/com/alvis/exam/configuration/spring/wx/TokenHandlerInterceptor.java

@@ -0,0 +1,68 @@
+package com.alvis.exam.configuration.spring.wx;
+
+import com.alvis.exam.base.SystemCode;
+import com.alvis.exam.configuration.spring.security.RestUtil;
+import com.alvis.exam.context.WxContext;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserToken;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.service.UserTokenService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.Date;
+
+@Component
+public class TokenHandlerInterceptor implements HandlerInterceptor {
+
+    private final UserTokenService userTokenService;
+    private final UserService userService;
+    private final WxContext wxContext;
+
+    @Autowired
+    public TokenHandlerInterceptor(UserTokenService userTokenService, UserService userService, WxContext wxContext) {
+        this.userTokenService = userTokenService;
+        this.userService = userService;
+        this.wxContext = wxContext;
+    }
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        String token = request.getHeader("token");
+        if (StringUtils.isEmpty(token)) {
+            RestUtil.response(response, SystemCode.UNAUTHORIZED);
+            return false;
+        }
+
+        if (StringUtils.isBlank(token)) {
+            RestUtil.response(response, SystemCode.UNAUTHORIZED);
+            return false;
+        }
+
+        if (token.length() != 36) {
+            RestUtil.response(response, SystemCode.UNAUTHORIZED);
+            return false;
+        }
+
+        UserToken userToken = userTokenService.getToken(token);
+        if (null == userToken) {
+            RestUtil.response(response, SystemCode.UNAUTHORIZED);
+            return false;
+        }
+
+        Date now = new Date();
+        User user = userService.getUserByUserName(userToken.getUserName());
+        if (now.before(userToken.getEndTime())) {
+            wxContext.setContext(user,userToken);
+            return true;
+        } else {   //refresh token
+            UserToken refreshToken = userTokenService.insertUserToken(user);
+            RestUtil.response(response, SystemCode.AccessTokenError.getCode(), SystemCode.AccessTokenError.getMessage(), refreshToken.getToken());
+            return false;
+        }
+    }
+}

source/exam/src/main/java/com/alvis/exam/context/WebContext.java

@@ -0,0 +1,38 @@
+package com.alvis.exam.context;
+
+import com.alvis.exam.domain.User;
+import com.alvis.exam.service.UserService;
+import lombok.AllArgsConstructor;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+
+@Component
+@AllArgsConstructor
+public class WebContext {
+    private static final String USER_ATTRIBUTES = "USER_ATTRIBUTES";
+    private final UserService userService;
+
+
+    public void setCurrentUser(User user) {
+        RequestContextHolder.currentRequestAttributes().setAttribute(USER_ATTRIBUTES, user, RequestAttributes.SCOPE_REQUEST);
+    }
+
+    public User getCurrentUser() {
+        User user = (User) RequestContextHolder.currentRequestAttributes().getAttribute(USER_ATTRIBUTES, RequestAttributes.SCOPE_REQUEST);
+        if (null != user) {
+            return user;
+        } else {
+            org.springframework.security.core.userdetails.User springUser = (org.springframework.security.core.userdetails.User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+            if (null == springUser) {
+                return null;
+            }
+            user = userService.getUserByUserName(springUser.getUsername());
+            if (null != user) {
+                setCurrentUser(user);
+            }
+            return user;
+        }
+    }
+}

source/exam/src/main/java/com/alvis/exam/context/WxContext.java

@@ -0,0 +1,28 @@
+package com.alvis.exam.context;
+
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserToken;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+
+@Component
+public class WxContext {
+
+    private static final String USER_ATTRIBUTES = "USER_ATTRIBUTES";
+    private static final String USER_TOKEN_ATTRIBUTES = "USER_TOKEN_ATTRIBUTES";
+
+
+    public void setContext(User user, UserToken userToken) {
+        RequestContextHolder.currentRequestAttributes().setAttribute(USER_ATTRIBUTES, user, RequestAttributes.SCOPE_REQUEST);
+        RequestContextHolder.currentRequestAttributes().setAttribute(USER_TOKEN_ATTRIBUTES, userToken, RequestAttributes.SCOPE_REQUEST);
+    }
+
+    public User getCurrentUser() {
+        return (User) RequestContextHolder.currentRequestAttributes().getAttribute(USER_ATTRIBUTES, RequestAttributes.SCOPE_REQUEST);
+    }
+
+    public UserToken getCurrentUserToken() {
+        return (UserToken) RequestContextHolder.currentRequestAttributes().getAttribute(USER_TOKEN_ATTRIBUTES, RequestAttributes.SCOPE_REQUEST);
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/ErrorController.java

@@ -0,0 +1,41 @@
+package com.alvis.exam.controller;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.base.SystemCode;
+import org.springframework.boot.autoconfigure.web.ErrorProperties;
+import org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController;
+import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+public class ErrorController extends BasicErrorController {
+
+    private static final String PATH = "/error";
+
+    public ErrorController() {
+        super(new DefaultErrorAttributes(), new ErrorProperties());
+    }
+
+    @RequestMapping(produces = {MediaType.APPLICATION_JSON_VALUE})
+    @ResponseBody
+    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
+        Map<String, Object> error = new HashMap<>(2);
+        error.put("code", SystemCode.InnerError.getCode());
+        error.put("message", SystemCode.InnerError.getMessage());
+        return new ResponseEntity<>(error, HttpStatus.OK);
+    }
+
+    @Override
+    public String getErrorPath() {
+        return PATH;
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/DashboardController.java

@@ -0,0 +1,50 @@
+package com.alvis.exam.controller.admin;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.ExamPaperQuestionCustomerAnswer;
+import com.alvis.exam.service.*;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.viewmodel.admin.dashboard.IndexVM;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController("AdminDashboardController")
+@RequestMapping(value = "/api/admin/dashboard")
+@AllArgsConstructor
+public class DashboardController extends BaseApiController {
+
+
+    private final ExamPaperService examPaperService;
+    private final QuestionService questionService;
+    private final ExamPaperAnswerService examPaperAnswerService;
+    private final ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService;
+    private final UserEventLogService userEventLogService;
+
+    @RequestMapping(value = "/index", method = RequestMethod.POST)
+    public RestResponse<IndexVM> Index() {
+        IndexVM vm = new IndexVM();
+
+        Integer examPaperCount = examPaperService.selectAllCount();
+        Integer questionCount = questionService.selectAllCount();
+        Integer doExamPaperCount = examPaperAnswerService.selectAllCount();
+        Integer doQuestionCount = examPaperQuestionCustomerAnswerService.selectAllCount();
+
+        vm.setExamPaperCount(examPaperCount);
+        vm.setQuestionCount(questionCount);
+        vm.setDoExamPaperCount(doExamPaperCount);
+        vm.setDoQuestionCount(doQuestionCount);
+
+        List<Integer> mothDayUserActionValue = userEventLogService.selectMothCount();
+        List<Integer> mothDayDoExamQuestionValue = examPaperQuestionCustomerAnswerService.selectMothCount();
+        vm.setMothDayUserActionValue(mothDayUserActionValue);
+        vm.setMothDayDoExamQuestionValue(mothDayDoExamQuestionValue);
+
+        vm.setMothDayText(DateTimeUtil.MothDay());
+        return RestResponse.ok(vm);
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/EducationController.java

@@ -0,0 +1,65 @@
+package com.alvis.exam.controller.admin;
+
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.Subject;
+import com.alvis.exam.service.SubjectService;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.education.SubjectEditRequestVM;
+import com.alvis.exam.viewmodel.admin.education.SubjectPageRequestVM;
+import com.alvis.exam.viewmodel.admin.education.SubjectResponseVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.List;
+
+@RestController("AdminEducationController")
+@RequestMapping(value = "/api/admin/education")
+@AllArgsConstructor
+public class EducationController extends BaseApiController {
+
+    private final SubjectService subjectService;
+
+    @RequestMapping(value = "/subject/list", method = RequestMethod.POST)
+    public RestResponse<List<Subject>> list() {
+        List<Subject> subjects = subjectService.allSubject();
+        return RestResponse.ok(subjects);
+    }
+
+    @RequestMapping(value = "/subject/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<SubjectResponseVM>> pageList(@RequestBody SubjectPageRequestVM model) {
+        PageInfo<Subject> pageInfo = subjectService.page(model);
+        PageInfo<SubjectResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> modelMapper.map(e, SubjectResponseVM.class));
+        return RestResponse.ok(page);
+    }
+
+    @RequestMapping(value = "/subject/edit", method = RequestMethod.POST)
+    public RestResponse edit(@RequestBody @Valid SubjectEditRequestVM model) {
+        Subject subject = modelMapper.map(model, Subject.class);
+        if (model.getId() == null) {
+            subject.setDeleted(false);
+            subjectService.insertByFilter(subject);
+        } else {
+            subjectService.updateByIdFilter(subject);
+        }
+        return RestResponse.ok();
+    }
+
+    @RequestMapping(value = "/subject/select/{id}", method = RequestMethod.POST)
+    public RestResponse<SubjectEditRequestVM> select(@PathVariable Integer id) {
+        Subject subject = subjectService.selectById(id);
+        SubjectEditRequestVM vm = modelMapper.map(subject, SubjectEditRequestVM.class);
+        return RestResponse.ok(vm);
+    }
+
+    @RequestMapping(value = "/subject/delete/{id}", method = RequestMethod.POST)
+    public RestResponse delete(@PathVariable Integer id) {
+        Subject subject = subjectService.selectById(id);
+        subject.setDeleted(true);
+        subjectService.updateByIdFilter(subject);
+        return RestResponse.ok();
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/ExamPaperController.java

@@ -0,0 +1,71 @@
+package com.alvis.exam.controller.admin;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.ExamPaper;
+import com.alvis.exam.service.ExamPaperService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.exam.ExamPaperPageRequestVM;
+import com.alvis.exam.viewmodel.admin.exam.ExamPaperEditRequestVM;
+import com.alvis.exam.viewmodel.admin.exam.ExamResponseVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+
+@RestController("AdminExamPaperController")
+@RequestMapping(value = "/api/admin/exam/paper")
+@AllArgsConstructor
+public class ExamPaperController extends BaseApiController {
+
+    private final ExamPaperService examPaperService;
+
+    @RequestMapping(value = "/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<ExamResponseVM>> pageList(@RequestBody ExamPaperPageRequestVM model) {
+        PageInfo<ExamPaper> pageInfo = examPaperService.page(model);
+        PageInfo<ExamResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            ExamResponseVM vm = modelMapper.map(e, ExamResponseVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+
+    @RequestMapping(value = "/taskExamPage", method = RequestMethod.POST)
+    public RestResponse<PageInfo<ExamResponseVM>> taskExamPageList(@RequestBody ExamPaperPageRequestVM model) {
+        PageInfo<ExamPaper> pageInfo = examPaperService.taskExamPage(model);
+        PageInfo<ExamResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            ExamResponseVM vm = modelMapper.map(e, ExamResponseVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+
+    @RequestMapping(value = "/edit", method = RequestMethod.POST)
+    public RestResponse<ExamPaperEditRequestVM> edit(@RequestBody @Valid ExamPaperEditRequestVM model) {
+        ExamPaper examPaper = examPaperService.savePaperFromVM(model, getCurrentUser());
+        ExamPaperEditRequestVM newVM = examPaperService.examPaperToVM(examPaper.getId());
+        return RestResponse.ok(newVM);
+    }
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<ExamPaperEditRequestVM> select(@PathVariable Integer id) {
+        ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id);
+        return RestResponse.ok(vm);
+    }
+
+    @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
+    public RestResponse delete(@PathVariable Integer id) {
+        ExamPaper examPaper = examPaperService.selectById(id);
+        examPaper.setDeleted(true);
+        examPaperService.updateByIdFilter(examPaper);
+        return RestResponse.ok();
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/MessageController.java

@@ -0,0 +1,80 @@
+package com.alvis.exam.controller.admin;
+
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.Message;
+import com.alvis.exam.domain.MessageUser;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.service.MessageService;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.message.MessagePageRequestVM;
+import com.alvis.exam.viewmodel.admin.message.MessageResponseVM;
+import com.alvis.exam.viewmodel.admin.message.MessageSendVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.validation.Valid;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController("AdminMessageController")
+@RequestMapping(value = "/api/admin/message")
+@AllArgsConstructor
+public class MessageController extends BaseApiController {
+
+    private final MessageService messageService;
+    private final UserService userService;
+
+    @RequestMapping(value = "/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<MessageResponseVM>> pageList(@RequestBody MessagePageRequestVM model) {
+        PageInfo<Message> pageInfo = messageService.page(model);
+        List<Integer> ids = pageInfo.getList().stream().map(d -> d.getId()).collect(Collectors.toList());
+        List<MessageUser> messageUsers = ids.size() == 0 ? null : messageService.selectByMessageIds(ids);
+        PageInfo<MessageResponseVM> page = PageInfoHelper.copyMap(pageInfo, m -> {
+            MessageResponseVM vm = modelMapper.map(m, MessageResponseVM.class);
+            String receives = messageUsers.stream().filter(d -> d.getMessageId().equals(m.getId())).map(d -> d.getReceiveUserName())
+                    .collect(Collectors.joining(","));
+            vm.setReceives(receives);
+            vm.setCreateTime(DateTimeUtil.dateFormat(m.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+    @RequestMapping(value = "/send", method = RequestMethod.POST)
+    public RestResponse send(@RequestBody @Valid MessageSendVM model) {
+        User user = getCurrentUser();
+        List<User> receiveUser = userService.selectByIds(model.getReceiveUserIds());
+        Date now = new Date();
+        Message message = new Message();
+        message.setTitle(model.getTitle());
+        message.setContent(model.getContent());
+        message.setCreateTime(now);
+        message.setReadCount(0);
+        message.setReceiveUserCount(receiveUser.size());
+        message.setSendUserId(user.getId());
+        message.setSendUserName(user.getUserName());
+        message.setSendRealName(user.getRealName());
+        List<MessageUser> messageUsers = receiveUser.stream().map(d -> {
+            MessageUser messageUser = new MessageUser();
+            messageUser.setCreateTime(now);
+            messageUser.setReaded(false);
+            messageUser.setReceiveRealName(d.getRealName());
+            messageUser.setReceiveUserId(d.getId());
+            messageUser.setReceiveUserName(d.getUserName());
+            return messageUser;
+        }).collect(Collectors.toList());
+        messageService.sendMessage(message, messageUsers);
+        return RestResponse.ok();
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/QuestionController.java

@@ -0,0 +1,98 @@
+package com.alvis.exam.controller.admin;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.base.SystemCode;
+import com.alvis.exam.domain.Question;
+import com.alvis.exam.domain.TextContent;
+import com.alvis.exam.domain.enums.QuestionTypeEnum;
+import com.alvis.exam.domain.question.QuestionObject;
+import com.alvis.exam.service.QuestionService;
+import com.alvis.exam.service.TextContentService;
+import com.alvis.exam.utility.*;
+import com.alvis.exam.viewmodel.admin.question.QuestionEditRequestVM;
+import com.alvis.exam.viewmodel.admin.question.QuestionPageRequestVM;
+import com.alvis.exam.viewmodel.admin.question.QuestionResponseVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+
+@RestController("AdminQuestionController")
+@RequestMapping(value = "/api/admin/question")
+@AllArgsConstructor
+public class QuestionController extends BaseApiController {
+
+    private final QuestionService questionService;
+    private final TextContentService textContentService;
+
+    @RequestMapping(value = "/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<QuestionResponseVM>> pageList(@RequestBody QuestionPageRequestVM model) {
+        PageInfo<Question> pageInfo = questionService.page(model);
+        PageInfo<QuestionResponseVM> page = PageInfoHelper.copyMap(pageInfo, q -> {
+            QuestionResponseVM vm = modelMapper.map(q, QuestionResponseVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime()));
+            vm.setScore(ExamUtil.scoreToVM(q.getScore()));
+            TextContent textContent = textContentService.selectById(q.getInfoTextContentId());
+            QuestionObject questionObject = JsonUtil.toJsonObject(textContent.getContent(), QuestionObject.class);
+            String clearHtml = HtmlUtil.clear(questionObject.getTitleContent());
+            vm.setShortTitle(clearHtml);
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+    @RequestMapping(value = "/edit", method = RequestMethod.POST)
+    public RestResponse edit(@RequestBody @Valid QuestionEditRequestVM model) {
+        RestResponse validQuestionEditRequestResult = validQuestionEditRequestVM(model);
+        if (validQuestionEditRequestResult.getCode() != SystemCode.OK.getCode()) {
+            return validQuestionEditRequestResult;
+        }
+
+        if (null == model.getId()) {
+            questionService.insertFullQuestion(model, getCurrentUser().getId());
+        } else {
+            questionService.updateFullQuestion(model);
+        }
+
+        return RestResponse.ok();
+    }
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<QuestionEditRequestVM> select(@PathVariable Integer id) {
+        QuestionEditRequestVM newVM = questionService.getQuestionEditRequestVM(id);
+        return RestResponse.ok(newVM);
+    }
+
+
+    @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
+    public RestResponse delete(@PathVariable Integer id) {
+        Question question = questionService.selectById(id);
+        question.setDeleted(true);
+        questionService.updateByIdFilter(question);
+        return RestResponse.ok();
+    }
+
+    private RestResponse validQuestionEditRequestVM(QuestionEditRequestVM model) {
+        int qType = model.getQuestionType().intValue();
+        boolean requireCorrect = qType == QuestionTypeEnum.SingleChoice.getCode() || qType == QuestionTypeEnum.TrueFalse.getCode();
+        if (requireCorrect) {
+            if (StringUtils.isBlank(model.getCorrect())) {
+                String errorMsg = ErrorUtil.parameterErrorFormat("correct", "不能为空");
+                return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
+            }
+        }
+
+        if (qType == QuestionTypeEnum.GapFilling.getCode()) {
+            Integer fillSumScore = model.getItems().stream().mapToInt(d -> ExamUtil.scoreFromVM(d.getScore())).sum();
+            Integer questionScore = ExamUtil.scoreFromVM(model.getScore());
+            if (!fillSumScore.equals(questionScore)) {
+                String errorMsg = ErrorUtil.parameterErrorFormat("score", "空分数和与题目总分不相等");
+                return new RestResponse<>(SystemCode.ParameterValidError.getCode(), errorMsg);
+            }
+        }
+        return RestResponse.ok();
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/TaskController.java

@@ -0,0 +1,59 @@
+package com.alvis.exam.controller.admin;
+
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.TaskExam;
+import com.alvis.exam.service.TaskExamService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.task.TaskPageRequestVM;
+import com.alvis.exam.viewmodel.admin.task.TaskPageResponseVM;
+import com.alvis.exam.viewmodel.admin.task.TaskRequestVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+
+@RestController("AdminTaskController")
+@RequestMapping(value = "/api/admin/task")
+@AllArgsConstructor
+public class TaskController extends BaseApiController {
+
+    private final TaskExamService taskExamService;
+
+    @RequestMapping(value = "/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<TaskPageResponseVM>> pageList(@RequestBody TaskPageRequestVM model) {
+        PageInfo<TaskExam> pageInfo = taskExamService.page(model);
+        PageInfo<TaskPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, m -> {
+            TaskPageResponseVM vm = modelMapper.map(m, TaskPageResponseVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(m.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+    @RequestMapping(value = "/edit", method = RequestMethod.POST)
+    public RestResponse edit(@RequestBody @Valid TaskRequestVM model) {
+        taskExamService.edit(model, getCurrentUser());
+        TaskRequestVM vm = taskExamService.taskExamToVM(model.getId());
+        return RestResponse.ok(vm);
+    }
+
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<TaskRequestVM> select(@PathVariable Integer id) {
+        TaskRequestVM vm = taskExamService.taskExamToVM(id);
+        return RestResponse.ok(vm);
+    }
+
+    @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
+    public RestResponse delete(@PathVariable Integer id) {
+        TaskExam taskExam = taskExamService.selectById(id);
+        taskExam.setDeleted(true);
+        taskExamService.updateByIdFilter(taskExam);
+        return RestResponse.ok();
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/UploadController.java

@@ -0,0 +1,105 @@
+package com.alvis.exam.controller.admin;
+
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.configuration.property.SystemConfig;
+import com.alvis.exam.service.FileUpload;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.viewmodel.admin.file.UeditorConfigVM;
+import com.alvis.exam.viewmodel.admin.file.UploadResultVM;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartHttpServletRequest;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+
+@Slf4j
+@AllArgsConstructor
+@RequestMapping("/api/admin/upload")
+@RestController("AdminUploadController")
+public class UploadController extends BaseApiController {
+
+    private final FileUpload fileUpload;
+    private final SystemConfig systemConfig;
+    private static final Logger logger = LoggerFactory.getLogger(UploadController.class);
+    private static final String IMAGE_UPLOAD = "imgUpload";
+    private static final String IMAGE_UPLOAD_FILE = "upFile";
+    private final UserService userService;
+
+    @ResponseBody
+    @RequestMapping("/configAndUpload")
+    public Object upload(HttpServletRequest request, HttpServletResponse response) {
+        String action = request.getParameter("action");
+        if (action.equals(IMAGE_UPLOAD)) {
+            try {
+                MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
+                MultipartFile multipartFile = multipartHttpServletRequest.getFile(IMAGE_UPLOAD_FILE);
+                long attachSize = multipartFile.getSize();
+                String imgName = multipartFile.getOriginalFilename();
+                String filePath;
+                try (InputStream inputStream = multipartFile.getInputStream()) {
+                    filePath = fileUpload.uploadFile(inputStream, attachSize, imgName);
+                }
+                String imageType = imgName.substring(imgName.lastIndexOf("."));
+                UploadResultVM uploadResultVM = new UploadResultVM();
+                uploadResultVM.setOriginal(imgName);
+                uploadResultVM.setName(imgName);
+                uploadResultVM.setUrl(filePath);
+                uploadResultVM.setSize(multipartFile.getSize());
+                uploadResultVM.setType(imageType);
+                uploadResultVM.setState("SUCCESS");
+                return uploadResultVM;
+            } catch (IOException e) {
+                logger.error(e.getMessage(), e);
+            }
+        } else {
+            UeditorConfigVM ueditorConfigVM = new UeditorConfigVM();
+            ueditorConfigVM.setImageActionName(IMAGE_UPLOAD);
+            ueditorConfigVM.setImageFieldName(IMAGE_UPLOAD_FILE);
+            ueditorConfigVM.setImageMaxSize(2048000L);
+            ueditorConfigVM.setImageAllowFiles(Arrays.asList(".png", ".jpg", ".jpeg", ".gif", ".bmp"));
+            ueditorConfigVM.setImageCompressEnable(true);
+            ueditorConfigVM.setImageCompressBorder(1600);
+            ueditorConfigVM.setImageInsertAlign("none");
+            ueditorConfigVM.setImageUrlPrefix("");
+            ueditorConfigVM.setImagePathFormat("");
+            return ueditorConfigVM;
+        }
+        return null;
+    }
+
+
+    @RequestMapping("/image")
+    @ResponseBody
+    public RestResponse questionUploadAndReadExcel(HttpServletRequest request) {
+        MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
+        MultipartFile multipartFile = multipartHttpServletRequest.getFile("file");
+        long attachSize = multipartFile.getSize();
+        String imgName = multipartFile.getOriginalFilename();
+        try (InputStream inputStream = multipartFile.getInputStream()) {
+            String filePath = fileUpload.uploadFile(inputStream, attachSize, imgName);
+            userService.changePicture(getCurrentUser(), filePath);
+            return RestResponse.ok(filePath);
+        } catch (IOException e) {
+            return RestResponse.fail(2, e.getMessage());
+        }
+    }
+
+    @RequestMapping("/auth")
+    @ResponseBody
+    public RestResponse auth() {
+        return RestResponse.ok();
+    }
+
+
+}

source/exam/src/main/java/com/alvis/exam/controller/admin/UserController.java

@@ -0,0 +1,148 @@
+package com.alvis.exam.controller.admin;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.other.KeyValue;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserEventLog;
+import com.alvis.exam.domain.enums.UserStatusEnum;
+import com.alvis.exam.service.AuthenticationService;
+import com.alvis.exam.service.UserEventLogService;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.viewmodel.admin.user.*;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
+
+/**
+ * @author alvis
+ */
+@RestController("AdminUserController")
+@RequestMapping(value = "/api/admin/user")
+@AllArgsConstructor
+public class UserController extends BaseApiController {
+
+    private final UserService userService;
+    private final UserEventLogService userEventLogService;
+    private final AuthenticationService authenticationService;
+
+
+    @RequestMapping(value = "/page/list", method = RequestMethod.POST)
+    public RestResponse<PageInfo<UserResponseVM>> pageList(@RequestBody UserPageRequestVM model) {
+        PageInfo<User> pageInfo = userService.userPage(model);
+        PageInfo<UserResponseVM> page = PageInfoHelper.copyMap(pageInfo, d -> UserResponseVM.from(d));
+        return RestResponse.ok(page);
+    }
+
+
+    @RequestMapping(value = "/event/page/list", method = RequestMethod.POST)
+    public RestResponse<PageInfo<UserEventLogVM>> eventPageList(@RequestBody UserEventPageRequestVM model) {
+        PageInfo<UserEventLog> pageInfo = userEventLogService.page(model);
+        PageInfo<UserEventLogVM> page = PageInfoHelper.copyMap(pageInfo, d -> {
+            UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<UserResponseVM> select(@PathVariable Integer id) {
+        User user = userService.getUserById(id);
+        UserResponseVM userVm = UserResponseVM.from(user);
+        return RestResponse.ok(userVm);
+    }
+
+    @RequestMapping(value = "/current", method = RequestMethod.POST)
+    public RestResponse<UserResponseVM> current() {
+        User user = getCurrentUser();
+        UserResponseVM userVm = UserResponseVM.from(user);
+        return RestResponse.ok(userVm);
+    }
+
+
+    @RequestMapping(value = "/edit", method = RequestMethod.POST)
+    public RestResponse<User> edit(@RequestBody @Valid UserCreateVM model) {
+        if (model.getId() == null) {  //create
+            User existUser = userService.getUserByUserName(model.getUserName());
+            if (null != existUser) {
+                return new RestResponse<>(2, "用户已存在");
+            }
+
+            if (StringUtils.isBlank(model.getPassword())) {
+                return new RestResponse<>(3, "密码不能为空");
+            }
+        }
+        if (StringUtils.isBlank(model.getBirthDay())) {
+            model.setBirthDay(null);
+        }
+        User user = modelMapper.map(model, User.class);
+
+        if (model.getId() == null) {
+            String encodePwd = authenticationService.pwdEncode(model.getPassword());
+            user.setPassword(encodePwd);
+            user.setUserUuid(UUID.randomUUID().toString());
+            user.setCreateTime(new Date());
+            user.setLastActiveTime(new Date());
+            user.setDeleted(false);
+            userService.insertByFilter(user);
+        } else {
+            if (!StringUtils.isBlank(model.getPassword())) {
+                String encodePwd = authenticationService.pwdEncode(model.getPassword());
+                user.setPassword(encodePwd);
+            }
+            user.setModifyTime(new Date());
+            userService.updateByIdFilter(user);
+        }
+        return RestResponse.ok(user);
+    }
+
+
+    @RequestMapping(value = "/update", method = RequestMethod.POST)
+    public RestResponse update(@RequestBody @Valid UserUpdateVM model) {
+        User user = userService.selectById(getCurrentUser().getId());
+        modelMapper.map(model, user);
+        user.setModifyTime(new Date());
+        userService.updateByIdFilter(user);
+        return RestResponse.ok();
+    }
+
+
+    @RequestMapping(value = "/changeStatus/{id}", method = RequestMethod.POST)
+    public RestResponse<Integer> changeStatus(@PathVariable Integer id) {
+        User user = userService.getUserById(id);
+        UserStatusEnum userStatusEnum = UserStatusEnum.fromCode(user.getStatus());
+        Integer newStatus = userStatusEnum == UserStatusEnum.Enable ? UserStatusEnum.Disable.getCode() : UserStatusEnum.Enable.getCode();
+        user.setStatus(newStatus);
+        user.setModifyTime(new Date());
+        userService.updateByIdFilter(user);
+        return RestResponse.ok(newStatus);
+    }
+
+
+    @RequestMapping(value = "/delete/{id}", method = RequestMethod.POST)
+    public RestResponse delete(@PathVariable Integer id) {
+        User user = userService.getUserById(id);
+        user.setDeleted(true);
+        userService.updateByIdFilter(user);
+        return RestResponse.ok();
+    }
+
+
+    @RequestMapping(value = "/selectByUserName", method = RequestMethod.POST)
+    public RestResponse<List<KeyValue>> selectByUserName(@RequestBody String userName) {
+        List<KeyValue> keyValues = userService.selectByUserName(userName);
+        return RestResponse.ok(keyValues);
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/controller/student/DashboardController.java

@@ -0,0 +1,118 @@
+package com.alvis.exam.controller.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.TaskExam;
+import com.alvis.exam.domain.TaskExamCustomerAnswer;
+import com.alvis.exam.domain.TextContent;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.enums.ExamPaperTypeEnum;
+import com.alvis.exam.domain.task.TaskItemAnswerObject;
+import com.alvis.exam.domain.task.TaskItemObject;
+import com.alvis.exam.service.*;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.JsonUtil;
+import com.alvis.exam.viewmodel.student.dashboard.*;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.ArrayUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController("StudentDashboardController")
+@RequestMapping(value = "/api/student/dashboard")
+@AllArgsConstructor
+public class DashboardController extends BaseApiController {
+
+    private final UserService userService;
+    private final ExamPaperService examPaperService;
+    private final QuestionService questionService;
+    private final TaskExamService taskExamService;
+    private final TaskExamCustomerAnswerService taskExamCustomerAnswerService;
+    private final TextContentService textContentService;
+
+    @RequestMapping(value = "/index", method = RequestMethod.POST)
+    public RestResponse<IndexVM> index() {
+        IndexVM indexVM = new IndexVM();
+        User user = getCurrentUser();
+
+        PaperFilter fixedPaperFilter = new PaperFilter();
+        fixedPaperFilter.setGradeLevel(user.getUserLevel());
+        fixedPaperFilter.setExamPaperType(ExamPaperTypeEnum.Fixed.getCode());
+        indexVM.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter));
+
+        PaperFilter timeLimitPaperFilter = new PaperFilter();
+        timeLimitPaperFilter.setDateTime(new Date());
+        timeLimitPaperFilter.setGradeLevel(user.getUserLevel());
+        timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.TimeLimit.getCode());
+
+        List<PaperInfo> limitPaper = examPaperService.indexPaper(timeLimitPaperFilter);
+        List<PaperInfoVM> paperInfoVMS = limitPaper.stream().map(d -> {
+            PaperInfoVM vm = modelMapper.map(d, PaperInfoVM.class);
+            vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime()));
+            vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime()));
+            return vm;
+        }).collect(Collectors.toList());
+        indexVM.setTimeLimitPaper(paperInfoVMS);
+        return RestResponse.ok(indexVM);
+    }
+
+
+    @RequestMapping(value = "/task", method = RequestMethod.POST)
+    public RestResponse<List<TaskItemVm>> task() {
+        User user = getCurrentUser();
+        List<TaskExam> taskExams = taskExamService.getByGradeLevel(user.getUserLevel());
+        if (taskExams.size() == 0) {
+            return RestResponse.ok(new ArrayList<>());
+        }
+        List<Integer> tIds = taskExams.stream().map(taskExam -> taskExam.getId()).collect(Collectors.toList());
+        List<TaskExamCustomerAnswer> taskExamCustomerAnswers = taskExamCustomerAnswerService.selectByTUid(tIds, user.getId());
+        List<TaskItemVm> vm = taskExams.stream().map(t -> {
+            TaskItemVm itemVm = new TaskItemVm();
+            itemVm.setId(t.getId());
+            itemVm.setTitle(t.getTitle());
+            TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswers.stream()
+                    .filter(tc -> tc.getTaskExamId().equals(t.getId())).findFirst().orElse(null);
+            List<TaskItemPaperVm> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer);
+            itemVm.setPaperItems(paperItemVMS);
+            return itemVm;
+        }).collect(Collectors.toList());
+        return RestResponse.ok(vm);
+    }
+
+
+    private List<TaskItemPaperVm> getTaskItemPaperVm(Integer tFrameId, TaskExamCustomerAnswer taskExamCustomerAnswers) {
+        TextContent textContent = textContentService.selectById(tFrameId);
+        List<TaskItemObject> paperItems = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class);
+
+        List<TaskItemAnswerObject> answerPaperItems = null;
+        if (null != taskExamCustomerAnswers) {
+            TextContent answerTextContent = textContentService.selectById(taskExamCustomerAnswers.getTextContentId());
+            answerPaperItems = JsonUtil.toJsonListObject(answerTextContent.getContent(), TaskItemAnswerObject.class);
+        }
+
+
+        List<TaskItemAnswerObject> finalAnswerPaperItems = answerPaperItems;
+        return paperItems.stream().map(p -> {
+                    TaskItemPaperVm ivm = new TaskItemPaperVm();
+                    ivm.setExamPaperId(p.getExamPaperId());
+                    ivm.setExamPaperName(p.getExamPaperName());
+                    if (null != finalAnswerPaperItems) {
+                        finalAnswerPaperItems.stream()
+                                .filter(a -> a.getExamPaperId().equals(p.getExamPaperId()))
+                                .findFirst()
+                                .ifPresent(a -> {
+                                    ivm.setExamPaperAnswerId(a.getExamPaperAnswerId());
+                                    ivm.setStatus(a.getStatus());
+                                });
+                    }
+                    return ivm;
+                }
+        ).collect(Collectors.toList());
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/student/EducationController.java

@@ -0,0 +1,43 @@
+package com.alvis.exam.controller.student;
+
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.Subject;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.service.SubjectService;
+import com.alvis.exam.viewmodel.student.education.SubjectEditRequestVM;
+import com.alvis.exam.viewmodel.student.education.SubjectVM;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController("StudentEducationController")
+@RequestMapping(value = "/api/student/education")
+@AllArgsConstructor
+public class EducationController extends BaseApiController {
+
+    private final SubjectService subjectService;
+
+    @RequestMapping(value = "/subject/list", method = RequestMethod.POST)
+    public RestResponse<List<SubjectVM>> list() {
+        User user = getCurrentUser();
+        List<Subject> subjects = subjectService.getSubjectByLevel(user.getUserLevel());
+        List<SubjectVM> subjectVMS = subjects.stream().map(d -> {
+            SubjectVM subjectVM = modelMapper.map(d, SubjectVM.class);
+            subjectVM.setId(String.valueOf(d.getId()));
+            return subjectVM;
+        }).collect(Collectors.toList());
+        return RestResponse.ok(subjectVMS);
+    }
+
+    @RequestMapping(value = "/subject/select/{id}", method = RequestMethod.POST)
+    public RestResponse<SubjectEditRequestVM> select(@PathVariable Integer id) {
+        Subject subject = subjectService.selectById(id);
+        SubjectEditRequestVM vm = modelMapper.map(subject, SubjectEditRequestVM.class);
+        return RestResponse.ok(vm);
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/controller/student/ExamPaperAnswerController.java

@@ -0,0 +1,114 @@
+package com.alvis.exam.controller.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.*;
+import com.alvis.exam.domain.enums.ExamPaperAnswerStatusEnum;
+import com.alvis.exam.event.CalculateExamPaperAnswerCompleteEvent;
+import com.alvis.exam.event.UserEvent;
+import com.alvis.exam.service.ExamPaperAnswerService;
+import com.alvis.exam.service.ExamPaperService;
+import com.alvis.exam.service.SubjectService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.ExamUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.exam.ExamPaperEditRequestVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperPageResponseVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperPageVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperReadVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperSubmitVM;
+import com.alvis.exam.viewmodel.student.exampaper.ExamPaperAnswerPageResponseVM;
+import com.alvis.exam.viewmodel.student.exampaper.ExamPaperAnswerPageVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.Date;
+
+@RestController("StudentExamPaperAnswerController")
+@RequestMapping(value = "/api/student/exampaper/answer")
+@AllArgsConstructor
+public class ExamPaperAnswerController extends BaseApiController {
+
+    private final ExamPaperAnswerService examPaperAnswerService;
+    private final ExamPaperService examPaperService;
+    private final SubjectService subjectService;
+    private final ApplicationEventPublisher eventPublisher;
+
+
+    @RequestMapping(value = "/pageList", method = RequestMethod.POST)
+    public RestResponse<PageInfo<ExamPaperAnswerPageResponseVM>> pageList(@RequestBody @Valid ExamPaperAnswerPageVM model) {
+        model.setCreateUser(getCurrentUser().getId());
+        PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.studentPage(model);
+        PageInfo<ExamPaperAnswerPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            ExamPaperAnswerPageResponseVM vm = modelMapper.map(e, ExamPaperAnswerPageResponseVM.class);
+            Subject subject = subjectService.selectById(vm.getSubjectId());
+            vm.setDoTime(ExamUtil.secondToVM(e.getDoTime()));
+            vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore()));
+            vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore()));
+            vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore()));
+            vm.setSubjectName(subject.getName());
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+    @RequestMapping(value = "/answerSubmit", method = RequestMethod.POST)
+    public RestResponse answerSubmit(@RequestBody @Valid ExamPaperSubmitVM examPaperSubmitVM) {
+        User user = getCurrentUser();
+        ExamPaperAnswerInfo examPaperAnswerInfo = examPaperAnswerService.calculateExamPaperAnswer(examPaperSubmitVM, user);
+        if (null == examPaperAnswerInfo) {
+            return RestResponse.fail(2, "试卷不能重复做");
+        }
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerInfo.getExamPaperAnswer();
+        Integer userScore = examPaperAnswer.getUserScore();
+        String scoreVm = ExamUtil.scoreToVM(userScore);
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        String content = user.getUserName() + " 提交试卷：" + examPaperAnswerInfo.getExamPaper().getName()
+                + " 得分：" + scoreVm
+                + " 耗时：" + ExamUtil.secondToVM(examPaperAnswer.getDoTime());
+        userEventLog.setContent(content);
+        eventPublisher.publishEvent(new CalculateExamPaperAnswerCompleteEvent(examPaperAnswerInfo));
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        return RestResponse.ok(scoreVm);
+    }
+
+
+    @RequestMapping(value = "/edit", method = RequestMethod.POST)
+    public RestResponse edit(@RequestBody @Valid ExamPaperSubmitVM examPaperSubmitVM) {
+        boolean notJudge = examPaperSubmitVM.getAnswerItems().stream().anyMatch(i -> i.getDoRight() == null && i.getScore() == null);
+        if (notJudge) {
+            return RestResponse.fail(2, "有未批改题目");
+        }
+
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(examPaperSubmitVM.getId());
+        ExamPaperAnswerStatusEnum examPaperAnswerStatusEnum = ExamPaperAnswerStatusEnum.fromCode(examPaperAnswer.getStatus());
+        if (examPaperAnswerStatusEnum == ExamPaperAnswerStatusEnum.Complete) {
+            return RestResponse.fail(3, "试卷已完成");
+        }
+        String score = examPaperAnswerService.judge(examPaperSubmitVM);
+        User user = getCurrentUser();
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        String content = user.getUserName() + " 批改试卷：" + examPaperAnswer.getPaperName() + " 得分：" + score;
+        userEventLog.setContent(content);
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        return RestResponse.ok(score);
+    }
+
+    @RequestMapping(value = "/read/{id}", method = RequestMethod.POST)
+    public RestResponse<ExamPaperReadVM> read(@PathVariable Integer id) {
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(id);
+        ExamPaperReadVM vm = new ExamPaperReadVM();
+        ExamPaperEditRequestVM paper = examPaperService.examPaperToVM(examPaperAnswer.getExamPaperId());
+        ExamPaperSubmitVM answer = examPaperAnswerService.examPaperAnswerToVM(examPaperAnswer.getId());
+        vm.setPaper(paper);
+        vm.setAnswer(answer);
+        return RestResponse.ok(vm);
+    }
+
+
+}

source/exam/src/main/java/com/alvis/exam/controller/student/ExamPaperController.java

@@ -0,0 +1,54 @@
+package com.alvis.exam.controller.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.ExamPaper;
+import com.alvis.exam.domain.ExamPaperAnswer;
+import com.alvis.exam.domain.ExamPaperAnswerInfo;
+import com.alvis.exam.event.CalculateExamPaperAnswerCompleteEvent;
+import com.alvis.exam.service.ExamPaperAnswerService;
+import com.alvis.exam.service.ExamPaperService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.ExamUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.exam.ExamPaperEditRequestVM;
+import com.alvis.exam.viewmodel.admin.exam.ExamResponseVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperPageResponseVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperPageVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperReadVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperSubmitVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+
+@RestController("StudentExamPaperController")
+@RequestMapping(value = "/api/student/exam/paper")
+@AllArgsConstructor
+public class ExamPaperController extends BaseApiController {
+
+    private final ExamPaperService examPaperService;
+    private final ExamPaperAnswerService examPaperAnswerService;
+    private final ApplicationEventPublisher eventPublisher;
+
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<ExamPaperEditRequestVM> select(@PathVariable Integer id) {
+        ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id);
+        return RestResponse.ok(vm);
+    }
+
+
+    @RequestMapping(value = "/pageList", method = RequestMethod.POST)
+    public RestResponse<PageInfo<ExamPaperPageResponseVM>> pageList(@RequestBody @Valid ExamPaperPageVM model) {
+        PageInfo<ExamPaper> pageInfo = examPaperService.studentPage(model);
+        PageInfo<ExamPaperPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            ExamPaperPageResponseVM vm = modelMapper.map(e, ExamPaperPageResponseVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/student/QuestionAnswerController.java

@@ -0,0 +1,66 @@
+package com.alvis.exam.controller.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.ExamPaperQuestionCustomerAnswer;
+import com.alvis.exam.domain.Subject;
+import com.alvis.exam.domain.TextContent;
+import com.alvis.exam.domain.question.QuestionObject;
+import com.alvis.exam.service.ExamPaperQuestionCustomerAnswerService;
+import com.alvis.exam.service.QuestionService;
+import com.alvis.exam.service.SubjectService;
+import com.alvis.exam.service.TextContentService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.HtmlUtil;
+import com.alvis.exam.utility.JsonUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.question.QuestionEditRequestVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperSubmitItemVM;
+import com.alvis.exam.viewmodel.student.question.answer.QuestionAnswerVM;
+import com.alvis.exam.viewmodel.student.question.answer.QuestionPageStudentRequestVM;
+import com.alvis.exam.viewmodel.student.question.answer.QuestionPageStudentResponseVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+@RestController("StudentQuestionAnswerController")
+@RequestMapping(value = "/api/student/question/answer")
+@AllArgsConstructor
+public class QuestionAnswerController extends BaseApiController {
+
+    private final ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService;
+    private final QuestionService questionService;
+    private final TextContentService textContentService;
+    private final SubjectService subjectService;
+
+    @RequestMapping(value = "/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<QuestionPageStudentResponseVM>> pageList(@RequestBody QuestionPageStudentRequestVM model) {
+        model.setCreateUser(getCurrentUser().getId());
+        PageInfo<ExamPaperQuestionCustomerAnswer> pageInfo = examPaperQuestionCustomerAnswerService.studentPage(model);
+        PageInfo<QuestionPageStudentResponseVM> page = PageInfoHelper.copyMap(pageInfo, q -> {
+            Subject subject = subjectService.selectById(q.getSubjectId());
+            QuestionPageStudentResponseVM vm = modelMapper.map(q, QuestionPageStudentResponseVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime()));
+            TextContent textContent = textContentService.selectById(q.getQuestionTextContentId());
+            QuestionObject questionObject = JsonUtil.toJsonObject(textContent.getContent(), QuestionObject.class);
+            String clearHtml = HtmlUtil.clear(questionObject.getTitleContent());
+            vm.setShortTitle(clearHtml);
+            vm.setSubjectName(subject.getName());
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<QuestionAnswerVM> select(@PathVariable Integer id) {
+        QuestionAnswerVM vm = new QuestionAnswerVM();
+        ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer = examPaperQuestionCustomerAnswerService.selectById(id);
+        ExamPaperSubmitItemVM questionAnswerVM = examPaperQuestionCustomerAnswerService.examPaperQuestionCustomerAnswerToVM(examPaperQuestionCustomerAnswer);
+        QuestionEditRequestVM questionVM = questionService.getQuestionEditRequestVM(examPaperQuestionCustomerAnswer.getQuestionId());
+        vm.setQuestionVM(questionVM);
+        vm.setQuestionAnswerVM(questionAnswerVM);
+        return RestResponse.ok(vm);
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/controller/student/QuestionController.java

@@ -0,0 +1,18 @@
+package com.alvis.exam.controller.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.service.QuestionService;
+import com.alvis.exam.viewmodel.admin.question.QuestionEditRequestVM;
+import lombok.AllArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+@RestController("StudentQuestionController")
+@RequestMapping(value = "/api/student/question")
+@AllArgsConstructor
+public class QuestionController extends BaseApiController {
+
+    private final QuestionService questionService;
+
+
+}

source/exam/src/main/java/com/alvis/exam/controller/student/UploadController.java

@@ -0,0 +1,55 @@
+package com.alvis.exam.controller.student;
+
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.configuration.property.SystemConfig;
+import com.alvis.exam.service.FileUpload;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.viewmodel.admin.file.UeditorConfigVM;
+import com.alvis.exam.viewmodel.admin.file.UploadResultVM;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartHttpServletRequest;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+
+@Slf4j
+@AllArgsConstructor
+@RequestMapping("/api/student/upload")
+@RestController("StudentUploadController")
+public class UploadController extends BaseApiController {
+
+    private final FileUpload fileUpload;
+    private final UserService userService;
+
+
+    @RequestMapping("/image")
+    @ResponseBody
+    public RestResponse questionUploadAndReadExcel(HttpServletRequest request) {
+        MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
+        MultipartFile multipartFile = multipartHttpServletRequest.getFile("file");
+        long attachSize = multipartFile.getSize();
+        String imgName = multipartFile.getOriginalFilename();
+        try (InputStream inputStream = multipartFile.getInputStream()) {
+            String filePath = fileUpload.uploadFile(inputStream, attachSize, imgName);
+            userService.changePicture(getCurrentUser(), filePath);
+            return RestResponse.ok(filePath);
+        } catch (IOException e) {
+            return RestResponse.fail(2, e.getMessage());
+        }
+    }
+
+
+}

source/exam/src/main/java/com/alvis/exam/controller/student/UserController.java

@@ -0,0 +1,135 @@
+package com.alvis.exam.controller.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.domain.Message;
+import com.alvis.exam.domain.MessageUser;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserEventLog;
+import com.alvis.exam.domain.enums.RoleEnum;
+import com.alvis.exam.domain.enums.UserStatusEnum;
+import com.alvis.exam.event.UserEvent;
+import com.alvis.exam.service.AuthenticationService;
+import com.alvis.exam.service.MessageService;
+import com.alvis.exam.service.UserEventLogService;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.student.user.*;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+
+/**
+ * @author alvis
+ */
+@RestController("StudentUserController")
+@RequestMapping(value = "/api/student/user")
+@AllArgsConstructor
+public class UserController extends BaseApiController {
+
+    private final UserService userService;
+    private final UserEventLogService userEventLogService;
+    private final MessageService messageService;
+    private final AuthenticationService authenticationService;
+    private final ApplicationEventPublisher eventPublisher;
+
+    @RequestMapping(value = "/current", method = RequestMethod.POST)
+    public RestResponse<UserResponseVM> current() {
+        User user = getCurrentUser();
+        UserResponseVM userVm = UserResponseVM.from(user);
+        return RestResponse.ok(userVm);
+    }
+
+
+    @RequestMapping(value = "/register", method = RequestMethod.POST)
+    public RestResponse register(@RequestBody @Valid UserRegisterVM model) {
+        User existUser = userService.getUserByUserName(model.getUserName());
+        if (null != existUser) {
+            return new RestResponse<>(2, "用户已存在");
+        }
+        User user = modelMapper.map(model, User.class);
+        String encodePwd = authenticationService.pwdEncode(model.getPassword());
+        user.setUserUuid(UUID.randomUUID().toString());
+        user.setPassword(encodePwd);
+        user.setRole(RoleEnum.STUDENT.getCode());
+        user.setStatus(UserStatusEnum.Enable.getCode());
+        user.setLastActiveTime(new Date());
+        user.setCreateTime(new Date());
+        user.setDeleted(false);
+        userService.insertByFilter(user);
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        userEventLog.setContent("欢迎 " + user.getUserName() + " 注册来到学之思考试系统");
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        return RestResponse.ok();
+    }
+
+
+    @RequestMapping(value = "/update", method = RequestMethod.POST)
+    public RestResponse update(@RequestBody @Valid UserUpdateVM model) {
+        if (StringUtils.isBlank(model.getBirthDay())) {
+            model.setBirthDay(null);
+        }
+        User user = userService.selectById(getCurrentUser().getId());
+        modelMapper.map(model, user);
+        user.setModifyTime(new Date());
+        userService.updateByIdFilter(user);
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        userEventLog.setContent(user.getUserName() + " 更新了个人资料");
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        return RestResponse.ok();
+    }
+
+    @RequestMapping(value = "/log", method = RequestMethod.POST)
+    public RestResponse<List<UserEventLogVM>> log() {
+        User user = getCurrentUser();
+        List<UserEventLog> userEventLogs = userEventLogService.getUserEventLogByUserId(user.getId());
+        List<UserEventLogVM> userEventLogVMS = userEventLogs.stream().map(d -> {
+            UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));
+            return vm;
+        }).collect(Collectors.toList());
+        return RestResponse.ok(userEventLogVMS);
+    }
+
+    @RequestMapping(value = "/message/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<MessageResponseVM>> messagePageList(@RequestBody MessageRequestVM messageRequestVM) {
+        messageRequestVM.setReceiveUserId(getCurrentUser().getId());
+        PageInfo<MessageUser> messageUserPageInfo = messageService.studentPage(messageRequestVM);
+        List<Integer> ids = messageUserPageInfo.getList().stream().map(d -> d.getMessageId()).collect(Collectors.toList());
+        List<Message> messages = ids.size() != 0 ? messageService.selectMessageByIds(ids) : null;
+        PageInfo<MessageResponseVM> page = PageInfoHelper.copyMap(messageUserPageInfo, e -> {
+            MessageResponseVM vm = modelMapper.map(e, MessageResponseVM.class);
+            messages.stream().filter(d -> e.getMessageId().equals(d.getId())).findFirst().ifPresent(message -> {
+                vm.setTitle(message.getTitle());
+                vm.setContent(message.getContent());
+                vm.setSendUserName(message.getSendUserName());
+            });
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+    @RequestMapping(value = "/message/unreadCount", method = RequestMethod.POST)
+    public RestResponse unReadCount() {
+        Integer count = messageService.unReadCount(getCurrentUser().getId());
+        return RestResponse.ok(count);
+    }
+
+    @RequestMapping(value = "/message/read/{id}", method = RequestMethod.POST)
+    public RestResponse read(@PathVariable Integer id) {
+        messageService.read(id);
+        return RestResponse.ok();
+    }
+
+}

source/exam/src/main/java/com/alvis/exam/controller/wx/BaseWXApiController.java

@@ -0,0 +1,23 @@
+package com.alvis.exam.controller.wx;
+
+import com.alvis.exam.configuration.spring.wx.TokenHandlerInterceptor;
+import com.alvis.exam.context.WxContext;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserToken;
+import com.alvis.exam.utility.ModelMapperSingle;
+import org.modelmapper.ModelMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class BaseWXApiController {
+    protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
+    @Autowired
+    private WxContext wxContext;
+
+    protected User getCurrentUser() {
+        return wxContext.getCurrentUser();
+    }
+
+    protected UserToken getUserToken() {
+        return wxContext.getCurrentUserToken();
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/wx/student/AuthController.java

@@ -0,0 +1,77 @@
+package com.alvis.exam.controller.wx.student;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.configuration.property.SystemConfig;
+import com.alvis.exam.controller.wx.BaseWXApiController;
+import com.alvis.exam.domain.UserToken;
+import com.alvis.exam.domain.enums.UserStatusEnum;
+import com.alvis.exam.service.AuthenticationService;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.service.UserTokenService;
+import com.alvis.exam.utility.WxUtil;
+import com.alvis.exam.viewmodel.wx.student.user.BindInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+
+
+@Controller("WXStudentAuthController")
+@RequestMapping(value = "/api/wx/student/auth")
+@AllArgsConstructor
+@ResponseBody
+public class AuthController extends BaseWXApiController {
+
+    private final SystemConfig systemConfig;
+    private final AuthenticationService authenticationService;
+    private final UserService userService;
+    private final UserTokenService userTokenService;
+
+    @RequestMapping(value = "/bind", method = RequestMethod.POST)
+    public RestResponse bind(@Valid BindInfo model) {
+        com.alvis.exam.domain.User user = userService.getUserByUserName(model.getUserName());
+        if (user == null) {
+            return RestResponse.fail(2, "用户名或密码错误");
+        }
+        boolean result = authenticationService.authUser(user, model.getUserName(), model.getPassword());
+        if (!result) {
+            return RestResponse.fail(2, "用户名或密码错误");
+        }
+        UserStatusEnum userStatusEnum = UserStatusEnum.fromCode(user.getStatus());
+        if (UserStatusEnum.Disable == userStatusEnum) {
+            return RestResponse.fail(3, "用户被禁用");
+        }
+        String code = model.getCode();
+        String openid = WxUtil.getOpenId(systemConfig.getWx().getAppid(), systemConfig.getWx().getSecret(), code);
+        if (null == openid) {
+            return RestResponse.fail(4, "获取微信OpenId失败");
+        }
+        user.setWxOpenId(openid);
+        UserToken userToken = userTokenService.bind(user);
+        return RestResponse.ok(userToken.getToken());
+    }
+
+
+    @RequestMapping(value = "/checkBind", method = RequestMethod.POST)
+    public RestResponse checkBind(@Valid @NotBlank String code) {
+        String openid = WxUtil.getOpenId(systemConfig.getWx().getAppid(), systemConfig.getWx().getSecret(), code);
+        if (null == openid) {
+            return RestResponse.fail(3, "获取微信OpenId失败");
+        }
+        UserToken userToken = userTokenService.checkBind(openid);
+        if (null != userToken) {
+            return RestResponse.ok(userToken.getToken());
+        }
+        return RestResponse.fail(2, "用户未绑定");
+    }
+
+
+    @RequestMapping(value = "/unBind", method = RequestMethod.POST)
+    public RestResponse unBind() {
+        UserToken userToken = getUserToken();
+        userTokenService.unBind(userToken);
+        return RestResponse.ok();
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/wx/student/DashboardController.java

@@ -0,0 +1,124 @@
+package com.alvis.exam.controller.wx.student;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.controller.wx.BaseWXApiController;
+import com.alvis.exam.domain.TaskExam;
+import com.alvis.exam.domain.TaskExamCustomerAnswer;
+import com.alvis.exam.domain.TextContent;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.enums.ExamPaperAnswerStatusEnum;
+import com.alvis.exam.domain.enums.ExamPaperTypeEnum;
+import com.alvis.exam.domain.task.TaskItemAnswerObject;
+import com.alvis.exam.domain.task.TaskItemObject;
+import com.alvis.exam.service.ExamPaperService;
+import com.alvis.exam.service.TaskExamCustomerAnswerService;
+import com.alvis.exam.service.TaskExamService;
+import com.alvis.exam.service.TextContentService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.JsonUtil;
+import com.alvis.exam.viewmodel.student.dashboard.*;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+
+@Controller("WXStudentDashboardController")
+@RequestMapping(value = "/api/wx/student/dashboard")
+@AllArgsConstructor
+@ResponseBody
+public class DashboardController extends BaseWXApiController {
+
+    private final ExamPaperService examPaperService;
+    private final TextContentService textContentService;
+    private final TaskExamService taskExamService;
+    private final TaskExamCustomerAnswerService taskExamCustomerAnswerService;
+
+    @RequestMapping(value = "/index", method = RequestMethod.POST)
+    public RestResponse<IndexVM> index() {
+        IndexVM indexVM = new IndexVM();
+        User user = getCurrentUser();
+
+        PaperFilter fixedPaperFilter = new PaperFilter();
+        fixedPaperFilter.setGradeLevel(user.getUserLevel());
+        fixedPaperFilter.setExamPaperType(ExamPaperTypeEnum.Fixed.getCode());
+        indexVM.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter));
+
+        PaperFilter timeLimitPaperFilter = new PaperFilter();
+        timeLimitPaperFilter.setDateTime(new Date());
+        timeLimitPaperFilter.setGradeLevel(user.getUserLevel());
+        timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.TimeLimit.getCode());
+
+        List<PaperInfo> limitPaper = examPaperService.indexPaper(timeLimitPaperFilter);
+        List<PaperInfoVM> paperInfoVMS = limitPaper.stream().map(d -> {
+            PaperInfoVM vm = modelMapper.map(d, PaperInfoVM.class);
+            vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime()));
+            vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime()));
+            return vm;
+        }).collect(Collectors.toList());
+        indexVM.setTimeLimitPaper(paperInfoVMS);
+        return RestResponse.ok(indexVM);
+    }
+
+    @RequestMapping(value = "/task", method = RequestMethod.POST)
+    public RestResponse<List<TaskItemVm>> task() {
+        User user = getCurrentUser();
+        List<TaskExam> taskExams = taskExamService.getByGradeLevel(user.getUserLevel());
+        if (taskExams.size() == 0) {
+            return RestResponse.ok(new ArrayList<>());
+        }
+        List<Integer> tIds = taskExams.stream().map(taskExam -> taskExam.getId()).collect(Collectors.toList());
+        List<TaskExamCustomerAnswer> taskExamCustomerAnswers = taskExamCustomerAnswerService.selectByTUid(tIds, user.getId());
+        List<TaskItemVm> vm = taskExams.stream().map(t -> {
+            TaskItemVm itemVm = new TaskItemVm();
+            itemVm.setId(t.getId());
+            itemVm.setTitle(t.getTitle());
+            TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswers.stream()
+                    .filter(tc -> tc.getTaskExamId().equals(t.getId())).findFirst().orElse(null);
+            List<TaskItemPaperVm> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer);
+            itemVm.setPaperItems(paperItemVMS);
+            return itemVm;
+        }).collect(Collectors.toList());
+        return RestResponse.ok(vm);
+    }
+
+
+    private List<TaskItemPaperVm> getTaskItemPaperVm(Integer tFrameId, TaskExamCustomerAnswer taskExamCustomerAnswers) {
+        TextContent textContent = textContentService.selectById(tFrameId);
+        List<TaskItemObject> paperItems = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class);
+
+        List<TaskItemAnswerObject> answerPaperItems = null;
+        if (null != taskExamCustomerAnswers) {
+            TextContent answerTextContent = textContentService.selectById(taskExamCustomerAnswers.getTextContentId());
+            answerPaperItems = JsonUtil.toJsonListObject(answerTextContent.getContent(), TaskItemAnswerObject.class);
+        }
+
+
+        List<TaskItemAnswerObject> finalAnswerPaperItems = answerPaperItems;
+        return paperItems.stream().map(p -> {
+                    TaskItemPaperVm ivm = new TaskItemPaperVm();
+                    ivm.setExamPaperId(p.getExamPaperId());
+                    ivm.setExamPaperName(p.getExamPaperName());
+                    if (null != finalAnswerPaperItems) {
+                        finalAnswerPaperItems.stream()
+                                .filter(a -> a.getExamPaperId().equals(p.getExamPaperId()))
+                                .findFirst()
+                                .ifPresent(a -> {
+                                    ivm.setExamPaperAnswerId(a.getExamPaperAnswerId());
+                                    ivm.setStatus(a.getStatus());
+                                });
+                    }
+                    return ivm;
+                }
+        ).collect(Collectors.toList());
+    }
+
+
+}

source/exam/src/main/java/com/alvis/exam/controller/wx/student/ExamPaperAnswerController.java

@@ -0,0 +1,126 @@
+package com.alvis.exam.controller.wx.student;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.controller.wx.BaseWXApiController;
+import com.alvis.exam.domain.*;
+import com.alvis.exam.domain.enums.QuestionTypeEnum;
+import com.alvis.exam.event.CalculateExamPaperAnswerCompleteEvent;
+import com.alvis.exam.event.UserEvent;
+import com.alvis.exam.service.ExamPaperAnswerService;
+import com.alvis.exam.service.ExamPaperService;
+import com.alvis.exam.service.SubjectService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.ExamUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.exam.ExamPaperEditRequestVM;
+import com.alvis.exam.viewmodel.student.exam.*;
+import com.alvis.exam.viewmodel.student.exampaper.ExamPaperAnswerPageResponseVM;
+import com.alvis.exam.viewmodel.student.exampaper.ExamPaperAnswerPageVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.validation.Valid;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+@Controller("WXStudentExamPaperAnswerController")
+@RequestMapping(value = "/api/wx/student/exampaper/answer")
+@AllArgsConstructor
+@ResponseBody
+public class ExamPaperAnswerController extends BaseWXApiController {
+
+    private final ExamPaperAnswerService examPaperAnswerService;
+    private final SubjectService subjectService;
+    private final ApplicationEventPublisher eventPublisher;
+    private final ExamPaperService examPaperService;
+
+    @RequestMapping(value = "/pageList", method = RequestMethod.POST)
+    public RestResponse<PageInfo<ExamPaperAnswerPageResponseVM>> pageList(@Valid ExamPaperAnswerPageVM model) {
+        model.setCreateUser(getCurrentUser().getId());
+        PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.studentPage(model);
+        PageInfo<ExamPaperAnswerPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            ExamPaperAnswerPageResponseVM vm = modelMapper.map(e, ExamPaperAnswerPageResponseVM.class);
+            Subject subject = subjectService.selectById(vm.getSubjectId());
+            vm.setDoTime(ExamUtil.secondToVM(e.getDoTime()));
+            vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore()));
+            vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore()));
+            vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore()));
+            vm.setSubjectName(subject.getName());
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+
+    @RequestMapping(value = "/answerSubmit", method = RequestMethod.POST)
+    public RestResponse answerSubmit(HttpServletRequest request) {
+        ExamPaperSubmitVM examPaperSubmitVM = requestToExamPaperSubmitVM(request);
+        User user = getCurrentUser();
+        ExamPaperAnswerInfo examPaperAnswerInfo = examPaperAnswerService.calculateExamPaperAnswer(examPaperSubmitVM, user);
+        if (null == examPaperAnswerInfo) {
+            return RestResponse.fail(2, "试卷不能重复做");
+        }
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerInfo.getExamPaperAnswer();
+        Integer userScore = examPaperAnswer.getUserScore();
+        String scoreVm = ExamUtil.scoreToVM(userScore);
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        String content = user.getUserName() + " 提交试卷：" + examPaperAnswerInfo.getExamPaper().getName()
+                + " 得分：" + scoreVm
+                + " 耗时：" + ExamUtil.secondToVM(examPaperAnswer.getDoTime());
+        userEventLog.setContent(content);
+        eventPublisher.publishEvent(new CalculateExamPaperAnswerCompleteEvent(examPaperAnswerInfo));
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        return RestResponse.ok(scoreVm);
+    }
+
+    private ExamPaperSubmitVM requestToExamPaperSubmitVM(HttpServletRequest request) {
+        ExamPaperSubmitVM examPaperSubmitVM = new ExamPaperSubmitVM();
+        examPaperSubmitVM.setId(Integer.parseInt(request.getParameter("id")));
+        examPaperSubmitVM.setDoTime(Integer.parseInt(request.getParameter("doTime")));
+        List<String> parameterNames = Collections.list(request.getParameterNames()).stream()
+                .filter(n -> n.contains("_"))
+                .collect(Collectors.toList());
+        //题目答案按序号分组
+        Map<String, List<String>> questionGroup = parameterNames.stream().collect(Collectors.groupingBy(p -> p.substring(0, p.indexOf("_"))));
+        List<ExamPaperSubmitItemVM> answerItems = new ArrayList<>();
+        questionGroup.forEach((k, v) -> {
+            ExamPaperSubmitItemVM examPaperSubmitItemVM = new ExamPaperSubmitItemVM();
+            String p = v.get(0);
+            String[] keys = p.split("_");
+            examPaperSubmitItemVM.setQuestionId(Integer.parseInt(keys[1]));
+            examPaperSubmitItemVM.setItemOrder(Integer.parseInt(keys[0]));
+            QuestionTypeEnum typeEnum = QuestionTypeEnum.fromCode(Integer.parseInt(keys[2]));
+            if (v.size() == 1) {
+                String content = request.getParameter(p);
+                examPaperSubmitItemVM.setContent(content);
+                if (typeEnum == QuestionTypeEnum.MultipleChoice) {
+                    examPaperSubmitItemVM.setContentArray(Arrays.asList(content.split(",")));
+                }
+            } else {  //多个空 填空题
+                List<String> answers = v.stream().sorted(Comparator.comparingInt(ExamUtil::lastNum)).map(inputKey -> request.getParameter(inputKey)).collect(Collectors.toList());
+                examPaperSubmitItemVM.setContentArray(answers);
+            }
+            answerItems.add(examPaperSubmitItemVM);
+        });
+        examPaperSubmitVM.setAnswerItems(answerItems);
+        return examPaperSubmitVM;
+    }
+
+
+    @PostMapping(value = "/read/{id}")
+    public RestResponse<ExamPaperReadVM> read(@PathVariable Integer id) {
+        ExamPaperReadVM vm = new ExamPaperReadVM();
+        ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(id);
+        ExamPaperEditRequestVM paper = examPaperService.examPaperToVM(examPaperAnswer.getExamPaperId());
+        ExamPaperSubmitVM answer = examPaperAnswerService.examPaperAnswerToVM(examPaperAnswer.getId());
+        vm.setPaper(paper);
+        vm.setAnswer(answer);
+        return RestResponse.ok(vm);
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/wx/student/ExamPaperController.java

@@ -0,0 +1,61 @@
+package com.alvis.exam.controller.wx.student;
+
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.controller.wx.BaseWXApiController;
+import com.alvis.exam.domain.ExamPaper;
+import com.alvis.exam.domain.Subject;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.enums.ExamPaperTypeEnum;
+import com.alvis.exam.service.ExamPaperService;
+import com.alvis.exam.service.SubjectService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.admin.exam.ExamPaperEditRequestVM;
+import com.alvis.exam.viewmodel.student.dashboard.IndexVM;
+import com.alvis.exam.viewmodel.student.dashboard.PaperFilter;
+import com.alvis.exam.viewmodel.student.dashboard.PaperInfo;
+import com.alvis.exam.viewmodel.student.dashboard.PaperInfoVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperPageResponseVM;
+import com.alvis.exam.viewmodel.student.exam.ExamPaperPageVM;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+
+@Controller("WXStudentExamController")
+@RequestMapping(value = "/api/wx/student/exampaper")
+@AllArgsConstructor
+@ResponseBody
+public class ExamPaperController extends BaseWXApiController {
+
+    private final ExamPaperService examPaperService;
+    private final SubjectService subjectService;
+
+
+    @RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
+    public RestResponse<ExamPaperEditRequestVM> select(@PathVariable Integer id) {
+        ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id);
+        return RestResponse.ok(vm);
+    }
+
+
+    @RequestMapping(value = "/pageList", method = RequestMethod.POST)
+    public RestResponse<PageInfo<ExamPaperPageResponseVM>> pageList(@Valid ExamPaperPageVM model) {
+        model.setLevelId(getCurrentUser().getUserLevel());
+        PageInfo<ExamPaper> pageInfo = examPaperService.studentPage(model);
+        PageInfo<ExamPaperPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
+            ExamPaperPageResponseVM vm = modelMapper.map(e, ExamPaperPageResponseVM.class);
+            Subject subject = subjectService.selectById(vm.getSubjectId());
+            vm.setSubjectName(subject.getName());
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+}

source/exam/src/main/java/com/alvis/exam/controller/wx/student/UserController.java

@@ -0,0 +1,145 @@
+package com.alvis.exam.controller.wx.student;
+
+import com.alvis.exam.base.BaseApiController;
+import com.alvis.exam.base.RestResponse;
+import com.alvis.exam.controller.wx.BaseWXApiController;
+import com.alvis.exam.domain.Message;
+import com.alvis.exam.domain.MessageUser;
+import com.alvis.exam.domain.User;
+import com.alvis.exam.domain.UserEventLog;
+import com.alvis.exam.domain.enums.RoleEnum;
+import com.alvis.exam.domain.enums.UserStatusEnum;
+import com.alvis.exam.event.UserEvent;
+import com.alvis.exam.service.AuthenticationService;
+import com.alvis.exam.service.MessageService;
+import com.alvis.exam.service.UserEventLogService;
+import com.alvis.exam.service.UserService;
+import com.alvis.exam.utility.DateTimeUtil;
+import com.alvis.exam.utility.PageInfoHelper;
+import com.alvis.exam.viewmodel.student.user.*;
+import com.github.pagehelper.PageInfo;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+
+/**
+ * @author alvis
+ */
+@Controller("WXStudentUserController")
+@RequestMapping(value = "/api/wx/student/user")
+@AllArgsConstructor
+@ResponseBody
+public class UserController extends BaseWXApiController {
+
+    private final UserService userService;
+    private final UserEventLogService userEventLogService;
+    private final MessageService messageService;
+    private final AuthenticationService authenticationService;
+    private final ApplicationEventPublisher eventPublisher;
+
+    @RequestMapping(value = "/current", method = RequestMethod.POST)
+    public RestResponse<UserResponseVM> current() {
+        User user = getCurrentUser();
+        UserResponseVM userVm = UserResponseVM.from(user);
+        userVm.setBirthDay(DateTimeUtil.dateShortFormat(user.getBirthDay()));
+        return RestResponse.ok(userVm);
+    }
+
+    @RequestMapping(value = "/register", method = RequestMethod.POST)
+    public RestResponse register(@Valid UserRegisterVM model) {
+        User existUser = userService.getUserByUserName(model.getUserName());
+        if (null != existUser) {
+            return new RestResponse<>(2, "用户已存在");
+        }
+        User user = modelMapper.map(model, User.class);
+        String encodePwd = authenticationService.pwdEncode(model.getPassword());
+        user.setUserUuid(UUID.randomUUID().toString());
+        user.setPassword(encodePwd);
+        user.setRole(RoleEnum.STUDENT.getCode());
+        user.setStatus(UserStatusEnum.Enable.getCode());
+        user.setLastActiveTime(new Date());
+        user.setCreateTime(new Date());
+        user.setDeleted(false);
+        userService.insertByFilter(user);
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        userEventLog.setContent("欢迎 " + user.getUserName() + " 注册来到学之思考试系统");
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        return RestResponse.ok();
+    }
+
+    @RequestMapping(value = "/update", method = RequestMethod.POST)
+    public RestResponse<UserResponseVM> update(@Valid UserUpdateVM model) {
+        if (StringUtils.isBlank(model.getBirthDay())) {
+            model.setBirthDay(null);
+        }
+        User user = userService.selectById(getCurrentUser().getId());
+        modelMapper.map(model, user);
+        user.setModifyTime(new Date());
+        userService.updateByIdFilter(user);
+        UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
+        userEventLog.setContent(user.getUserName() + " 更新了个人资料");
+        eventPublisher.publishEvent(new UserEvent(userEventLog));
+        UserResponseVM userVm = UserResponseVM.from(user);
+        return RestResponse.ok(userVm);
+    }
+
+    @RequestMapping(value = "/log", method = RequestMethod.POST)
+    public RestResponse<List<UserEventLogVM>> log() {
+        User user = getCurrentUser();
+        List<UserEventLog> userEventLogs = userEventLogService.getUserEventLogByUserId(user.getId());
+        List<UserEventLogVM> userEventLogVMS = userEventLogs.stream().map(d -> {
+            UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class);
+            vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));
+            return vm;
+        }).collect(Collectors.toList());
+        return RestResponse.ok(userEventLogVMS);
+    }
+
+    @RequestMapping(value = "/message/page", method = RequestMethod.POST)
+    public RestResponse<PageInfo<MessageResponseVM>> messagePageList(MessageRequestVM messageRequestVM) {
+        messageRequestVM.setReceiveUserId(getCurrentUser().getId());
+        PageInfo<MessageUser> messageUserPageInfo = messageService.studentPage(messageRequestVM);
+        List<Integer> ids = messageUserPageInfo.getList().stream().map(d -> d.getMessageId()).collect(Collectors.toList());
+        List<Message> messages = ids.size() != 0 ? messageService.selectMessageByIds(ids) : null;
+        PageInfo<MessageResponseVM> page = PageInfoHelper.copyMap(messageUserPageInfo, e -> {
+            MessageResponseVM vm = modelMapper.map(e, MessageResponseVM.class);
+            messages.stream().filter(d -> e.getMessageId().equals(d.getId())).findFirst().ifPresent(message -> {
+                vm.setTitle(message.getTitle());
+                vm.setContent(message.getContent());
+                vm.setSendUserName(message.getSendUserName());
+            });
+            vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
+            return vm;
+        });
+        return RestResponse.ok(page);
+    }
+
+    @RequestMapping(value = "/message/detail/{id}", method = RequestMethod.POST)
+    public RestResponse messageDetail(@PathVariable Integer id) {
+        Message message = messageService.messageDetail(id);
+        return RestResponse.ok(message);
+    }
+
+
+    @RequestMapping(value = "/message/unreadCount", method = RequestMethod.POST)
+    public RestResponse unReadCount() {
+        Integer count = messageService.unReadCount(getCurrentUser().getId());
+        return RestResponse.ok(count);
+    }
+
+    @RequestMapping(value = "/message/read/{id}", method = RequestMethod.POST)
+    public RestResponse read(@PathVariable Integer id) {
+        messageService.read(id);
+        return RestResponse.ok();
+    }
+
+}