[mysql+qt] 图书管理系统

一.图书管理数据库概念模式设计

图书管理系统包括了游客、用户登录、管理员登录三种模式。

在游客模式下，可以实现检索书籍的功能。

游客可以注册用户，但是借书权限需要管理员授予。

用户登录后，在检索书籍功能的基础上，还可以进行书籍的借阅，并且查看自己的借还情况。

管理员登录后，可以对图书进行管理，即入库新的书籍，也可以对用户进行管理，即授予用户借书证，注销用户。



二.数据库设计

管理员(manager)

属性	主码/外码	数据类型	说明
Username	主码	varchar(20)	用户名
Password		varchar(20) not null	密码

用户(user)

属性	主码/外码	数据类型	说明
Username	主码	varchar(20)	用户名
Password		varchar(20) not null	密码

图书(book)

属性	主码/外码	数据类型	说明
book_id	主码	char(5)	编号
Name		varchar(20) not null	书名
Price		float(9,2)	价格
Number		int unsigned	数量
storage_date		date	入库时间
manage_name	外码，参照manager	varchar(20)	入库人员
Publisher		varchar(15) not null	出版社
publish_year		year	出版日期
Type		varchar(10) not null	分类

作者信息（book_author）

属性	主码/外码	数据类型	说明
Book_id	主码 外码，参照book	char(5)	编号
Author_name	主码	varchar(20)	作者

借阅(loan)

属性	主码/外码	数据类型	说明
Username	主码	varchar(20)	用户名
book_id	主码	char(5)	编号
loan_number	主码	int unsigned	单册编号
loan_date		date	借阅日期

三.开发技术

本次图书管理系统用MySql和qt进行开发。两者都是知名的跨平台、开源的项目。

mysql被广泛应用于web开发中，相比起其他数据库，其体积较小，而且被多种语言支持，是非常流行的开源关系型数据库。

qt是基于C++的图形界面开发库，它提供了基本窗口控件对象绘制、网络、多线程开发、数据库连接、XML使用等功能。

基于mysql开发的qt应用程序的搭建非常简单，只需安装32位的mysql和qt creator，然后把mysql提供的libmysql.dll放到qt的bin下，而不需要安装特别的插件，因为qt已经默认安装了mysql的驱动。

对于mysql，qt提供了两种驱动，一种是QMYSQL驱动程序，另一种是QODBC驱动程序，在这里我们选择了前者。



qt的数据库驱动程序

qt提供了两种操纵数据库的方式，一种是使用QSqlQuery类，就可以直接使用底层的SQL语句，另一种是使用QsqlTableModel，使用者不需要了解SQL语法，qt对sql语句进行了很好的封装，在这里我们选择了QSqlQuery。

四.详细设计

1.图书搜索

只提供图书检索功能，游客可以选择注册，但是借书权限需要管理员添加。

图书检索实例：



检索采用了‘%string%’形式，可以搜索到包含用户输入字符串的信息。

用户可以不用填写所有信息，只需填写一部分感兴趣的信息即可。代码会根据用户的输入生成相应的SQL查询代码。

为了便于编程，搜索采取的是所有信息的交集，如果想要检索并集，只能分别查询。这样的设计已经基本能够满足用户的搜索需求了。

左侧的类型和右侧的搜索栏是独立的，它们点击后的搜索是单独进行的，而不是取交集。

该系统会对用户输入的语句进行简单的判断，在一些异常情况下，会给出一些提示：



如果是错误的输入，会有sql底层的警告信息：



如果没有查找到结果，也会给出提示。



注：因为没有写预备语句，查询不能保证安全性，对于有意的破坏性语句（sql注入），可能会导致数据库的崩溃。

2.用户注册



注册过程中也会对用户输入的信息做出相应的判断：



注册完成后，会向user表中插入user信息，借书权限默认为false。

3.用户/管理员登录

登录时，会根据用户输入的用户名，在数据库在搜索密码，如果没有搜到，提示用户名不存在，如果搜到的密码和用户输入不匹配，提示密码错误。



切换用户和管理员登录，只需在上面的分栏选择。

游客身份，显示图书搜索界面

用户身份，显示图书搜索、借阅情况界面

管理员身份，显示图书搜索、用户管理、单册入库、多册入库界面

4.借阅情况

在借阅情况窗口，用户可以查到自己的借阅信息，包括书本编号、名称，以及借阅、归还日期。单册编号是为了维护借阅关系的主码，针对一本书被借多次的情况设置的。



同时，用户可在这里进行归还书籍操作。

点击归还后，借阅信息动态更新。同时可以发现，在用户登录后，查询书籍的界面多了一个借阅书籍的按钮，用户可以在查询的过程中进行书本借阅操作，如：



借阅成功后，库存量会减少，然后用户借阅窗口的信息也会动态更新。

如果用户没有选中书籍，或者用户借阅数量已经达到上限，都会给出警告：



5.用户管理

以管理员身份登录后，可以对用户进行管理，在这里可以看到用户的几乎所有信息。同时也可以执行删除/授予借书权限、用户删除操作。

判断是删除还是授予权限，是由用户当前的状态决定。



如果一个用户有未归还的书籍，管理系统会禁止删除操作：



6.单册入库





信息必须全部填写，否则不允许插入：



只有全部填写才能插入书籍：



在插入的同时，会给书籍设置一个编号，编号通过如下算法得到:

id = select count(*)from book

while(exist id) id++

之所以执行第二步，是因为数据库可能因为删除书籍操作导致中间部分编号的缺失。

同时，还会存入当前的入库人员（管理员），入库时间等信息。入库时间是通过获取系统时间得到的，如果计算机的系统时间被篡改了，我们也没有很好的办法。

插入成功后，输入框会自动清空，便于下一次入库。

很遗憾的是，这里并没有对输入数据进行类型检查（预处理操作），所以输入了什么错误的东西，数据库也会一并接收。

删除书籍只提供了指定书的编号删除的功能。因为删除书时一般都有明确的导向，不像查询书籍，需要实现复合条件搜索功能。

7.多册入库

除了单册入库，我们还提供了多册入库的功能，包括了表格的填写，和文本文件的读入：



表格填写入库。

直接点击表格，就可以对内容进行编辑。



如果管理员插入了和原来相同的书籍，我们会询问管理员是否需要合并，如果点击确认，就将原来书籍的数量更新，否则将取消入库。

表格插入也会检测用户输入是否完整的数据，最后是一条条插入数据的。如果哪一条插入失败，会有单独的提示。

同样，我们可以通过文件读入来批量录入，点击右上角的加载文件，文件需要按照一定的格式书写，并且只支持.txt后缀的文件。



以下是一个预先准备好的文件：



读入后的显示效果如下：



此时文件还没有加载到数据库里，需要点击提交表单。

由于这里限定一页只显示13列，而文本有时会有超过13条书本信息的记录，所以点击了提交后，只提交13本书的信息，剩下的书本记录会在提交后继续加载到表格中。

也就是说，对于多条数据，管理员需要多次提交表单。

mysql建立数据库代码：

CREATE SCHEMA `book_manage` ;
use book_manage;
set autocommit=0;

create table `manager`
(
`username` varchar(20),
`password` varchar(20) not null,
primary key(`username`)
);

create table `user`
(
`username` varchar(20) not null,
`password` varchar(20) not null,
primary key (`username`)
);

create table `book`
(
`book_id` char(5),
`name` varchar(20) not null,
`price` float(9,2) unsigned,
`number` int unsigned not null,
`storage_date` date,
`manage_name` char(20),
`publisher` varchar(15) not null,
`publish_year` year,
`type` varchar(10) not null,
primary key(`book_id`),
foreign key(`manage_name`) references `manager`(`username`)
);

create table `book_author`
(
`book_id` char(5),
`author_name` varchar(20),
primary key(`author_name`,`book_id`),
foreign key(`book_id`) references `book`(`book_id`) on delete cascade on update cascade
);

create table `loan`
(
`username` char(20),
`book_id` char(5),
`loan_date` date,
`loan_number` int unsigned,
primary key(`username`,`book_id`,`loan_number`),
foreign key(`username`) references `user`(`username`),
foreign key(`book_id`) references `book`(`book_id`)
);

database.pro

#-------------------------------------------------
#
# Project created by QtCreator 2016-04-03T16:38:55
#
#-------------------------------------------------

QT       += core gui sql

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = Database
TEMPLATE = app

QTPLUGIN += QSQLMYSQL

SOURCES += main.cpp\
database.cpp

HEADERS  += database.h

INCLUDEPATH += "C:/Program Files (x86)/MySQL/MySQL Server 5.7/include"

LIBS += "C:/Program Files (x86)/MySQL/MySQL Server 5.7/lib/libmysql.lib"

database.h

#ifndef DATABASE_H
#define DATABASE_H
#include <QObject>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QVector>

class QWidget;
class QLineEdit;
class QComboBox;
class QPushButton;
class QLabel;
class QGridLayout;
class QTabWidget;
class QVBoxLayout;
class QHBoxLayout;
class QTreeWidget;
class QTreeWidgetItem;
class QGroupBox;
class QToolButton;
class QTableWidget;
class QCheckBox;
class QTableWidgetItem;
class QTimer;

class database : public QObject
{
Q_OBJECT

private:

enum{MANAGER,USER,VISITOR,USER_LOGIN,USER_REGISTER};
QString current_user;

int user_type;
int current_page;
int max_page;

int user_current_page;
int user_max_page;
int user_num;

int current_row_number;

QTimer *timer;

QTableWidget *tablewidget;
QGridLayout *gridLayout ;
QVBoxLayout *vboxLayout0;
QVBoxLayout *vboxLayout1;
QVBoxLayout *vboxLayout ;
QWidget *titleImage;

QVBoxLayout *vboxLayout3;
QVBoxLayout *vboxLayout2;
QHBoxLayout *hboxLayout1;
QHBoxLayout *hboxLayout ;
QHBoxLayout *hboxLayout2;
QHBoxLayout *hboxLayout3;

QLabel *spacelabel2;
QLabel *spacelabel3;
QGroupBox *groupbox;
QGroupBox *groupbox1;
QPushButton *clearbutton;
QPushButton *searchbutton;
QPushButton *registerbutton;
QPushButton *loginbutton;
QPushButton *quitloginbutton;
QLabel *label;

QTreeWidget *tree;
QTreeWidgetItem *root;

QLineEdit *nameLine;
QLineEdit *publishLine;
QLineEdit *priceLine;
QLineEdit *priceLine1;
QLineEdit *authorLine;
QComboBox *dateBox;
QComboBox *dateBox1;
QComboBox *isLent;
QWidget *window;

QPushButton *nextbutton;
QPushButton *lastbutton;

QSqlDatabase db;
QSqlQuery query;

QTabWidget *mainTabWidget;
QTabWidget *loginTabWidget;
QWidget *user_loginWidget;
QWidget *manager_loginWidget;

QLineEdit *username1;
QLineEdit *password1;
QLineEdit *username2;
QLineEdit *password2;

QPushButton *okbutton;
QVBoxLayout *vboxLayout4;
QVBoxLayout *vboxLayout5;
QVBoxLayout *vboxLayout6;
QHBoxLayout *hboxLayout4;
QHBoxLayout *hboxLayout5;
QHBoxLayout *hboxLayout6;
QGridLayout *gridLayout2;
QTabWidget *manageTabWidget;
QWidget *addBookWidget;
QLabel *label2;

QLineEdit *nameLine2;
QComboBox *typeBox2;
QLineEdit *priceLine2;
QLineEdit *authorLine2;
QLineEdit *numLine2;
QLineEdit *publishLine2;
QComboBox *dateBox2;

QWidget *window1;
QWidget *window2;
QWidget *window3;
QWidget *window4;
QWidget *window5;

QWidget *registerWindow;
QLabel *label3;
QLineEdit *nameLine3;
QLineEdit *passwordLine1;
QLineEdit *passwordLine2;
QPushButton *registerOkButton;
QHBoxLayout *hboxLayout7;
QHBoxLayout *hboxLayout8;
QVBoxLayout *vboxLayout7;
QGridLayout *gridLayout3;
QLabel *label4;
QVector<QString>result;

QLabel *label5;
QLineEdit *idLine;
QVBoxLayout *vboxLayout9;
QHBoxLayout *hboxLayout9;
QWidget *deletebookWidget;
QPushButton *deleteOkButton;

QTableWidget *tablewidget1;
QVBoxLayout *vboxLayout10;
QHBoxLayout *hboxLayout10;
QPushButton *deleteUserButton;
QPushButton *grantLentButton;
QPushButton *lastPageButton;
QPushButton *nextPageButton;
QTableWidgetItem *item0[13];
QTableWidgetItem *item1[13];
QVector<QString*>userMessage;

QTableWidgetItem *item2[10];
QTableWidgetItem *item3[10];
QPushButton *lendBookButton;

QTableWidget *tablewidget2;
QVector<QString*>loanMessage;
QHBoxLayout *hboxLayout11;
QVBoxLayout *vboxLayout11;
QTableWidgetItem *item4[3];
QPushButton *returnBookButton;

QTableWidget *tablewidget3;
QVBoxLayout *vboxLayout12;
QHBoxLayout *hboxLayout12;
QPushButton *addBookOkButton;
QPushButton *addBookClearButton;

QComboBox *bookType[13];
QComboBox *publishDate[13];
QString bookMessage[7];

QLabel *tipLabel;
QWidget *fileWindow;
QHBoxLayout *hboxLayout13;
QPushButton *loadFileButton;
QVector<QString*>multiBookMessage;

void setLayout();
bool createConnection();

void setWindowShowBook(int type);
void setWindowSearchBook(int type);
void setWindowAddBook();
void setWindowUserManage();
void setWindowLoanBook();
void setWindowMutiAddBook();
void setWindowTitle();

void updateManageWindow();
void updateShowBookWindow();
void updateLoanBookWindow();
void updateTitle(int type);

bool addBook();

void loadUserMessage();
void loadLoanMessage();

QWidget* createLoginWindow(int type);

public:

database(QObject *parent = 0);
~database();

private slots:

void searchBook();
void updateTime();
void clear();
void quitLogin();
void returnBook();
void managerLogin();
void deleteLogin();
void bookLastPage();
void bookNextPage();
void deleteBook();
void searchBookByType(QTreeWidgetItem*,int);
void userLogin();
void setWindowRegister();
void setWindowLogin();
void Register();
void deleteUser();
void grantLent();
void userNextPage();
void userLastPage();
void lendBook();
void oneAddBook();
void mutiAddBook();
void clearAddBookMessage();
void openFile();
};

#endif // DATABASE_H

database.cpp

/*  _______________________
|                       |
|  author:fish1996      |
|  start:2016/04/03     |
|  finish:2016/04/22    |
|  tool:mysql+qtCreator |
|  图书管理系统           |
|                       |
———————————————————————
*/
#include "database.h"
#include <QWidget>
#include <QLineEdit>
#include <QLayout>
#include <QComboBox>
#include <QLabel>
#include <QFrame>
#include <QGroupBox>
#include <QPushButton>
#include <QTabWidget>
#include <QTreeWidget>
#include <QPalette>
#include <QBrush>
#include <QPixmap>
#include <QDateTime>
#include <QtSql>
#include <QStringList>
#include <QPluginLoader>
#include <QMessageBox>
#include <QCheckBox>
#include <QTableWidget>
#include <QTimer>
#include <QDir>
#include <QFileDialog>

/* 构造函数 */
database::database(QObject *parent)
: QObject(parent)
{
//初始化变量
user_num = 0;
user_type = VISITOR;
current_user = "游客";

//新建计时器
timer = new QTimer();
connect(timer, SIGNAL(timeout()), this, SLOT(updateTime()));
timer->start(1000);

//初始化指针
tablewidget = NULL;
tablewidget2 = NULL;
nextbutton = NULL;
lastbutton = NULL;
hboxLayout6 = NULL;
lastbutton = NULL;
nextbutton = NULL;

deleteUserButton = NULL;
grantLentButton = NULL;
lendBookButton = NULL;
returnBookButton = NULL;

window4 = NULL;

for(int i=0;i<10;i++){
item2[i] = NULL;
item3[i] = NULL;
}

//窗口布局
setLayout();

//连接数据库
createConnection();
}

/* 析构函数 */
database::~database()
{
//取消与数据库的连接
db.removeDatabase("book_manage");
}

/*  _______________________
|                       |
|   第一部分：页面布局     |
|                       |
———————————————————————
*/

/* 初始化布局 */
void database::setLayout()
{
//显示标题栏
setWindowTitle();

//以游客身份新建搜索窗口
setWindowSearchBook(VISITOR);
}

/* 标题窗口布局*/
void database::setWindowTitle()
{
//申请内存
QPalette palette;
loginbutton = new QPushButton(tr("登录"));
registerbutton = new QPushButton(tr("注册"));
spacelabel2 = new QLabel();
spacelabel3 = new QLabel("\n\n");
vboxLayout0 = new QVBoxLayout();
hboxLayout2 = new QHBoxLayout();
hboxLayout3 = new QHBoxLayout();
titleImage = new QWidget();
window = new QWidget();
vboxLayout3 = new QVBoxLayout();
mainTabWidget = new QTabWidget();

//登录注册按钮状态设置
registerbutton->setFlat(true);
registerbutton->setFixedSize(QSize(60,30));
loginbutton->setFlat(true);
loginbutton->setFixedSize(QSize(60,30));

//建立信号与槽
connect(registerbutton,SIGNAL(clicked()),this,SLOT(setWindowRegister()));
//点击注册按钮，显示注册窗口
connect(loginbutton,SIGNAL(clicked()),this,SLOT(setWindowLogin()));
//点击登录按钮，显示登录窗口

//设置标题图片
QDir d;
titleImage->setAutoFillBackground(true);
palette.setBrush(QPalette::Background,QBrush(QPixmap(d.currentPath()+"/title.jpg")));
titleImage->setPalette(palette);
titleImage->setLayout(hboxLayout2);

//标题栏布局
hboxLayout3->addWidget(spacelabel2);
hboxLayout3->addWidget(loginbutton);
hboxLayout3->addWidget(registerbutton);

vboxLayout3->addWidget(spacelabel3);
vboxLayout3->addLayout(hboxLayout3);

hboxLayout2->addStretch();
hboxLayout2->addLayout(vboxLayout3);

//将标题图片和标签窗口加入总布局
vboxLayout0->addWidget(titleImage);
vboxLayout0->addWidget(mainTabWidget);

//总窗口显示
window->setAutoFillBackground(true);
window->setLayout(vboxLayout0);
window->setWindowTitle(tr("图书管理系统"));
window->setFixedSize(1024*1.2,768*1.2);
window->show();
}

/* 登录窗口布局 */
void database::setWindowLogin()
{
//登录时禁用登录和注册按钮
loginbutton->setDisabled(true);
registerbutton->setDisabled(true);

//新建用户和管理员登录窗口
user_loginWidget = createLoginWindow(1);
manager_loginWidget = createLoginWindow(2);

//加入两个登录窗口加入分栏布局，并显示
loginTabWidget = new QTabWidget();
loginTabWidget->addTab(user_loginWidget,"用户登录");
loginTabWidget->addTab(manager_loginWidget,"管理员登录");

//禁用关闭按钮
loginTabWidget->setWindowFlags(loginTabWidget->windowFlags()&~Qt::WindowCloseButtonHint);

loginTabWidget->show();

}

/* 搜索书籍界面布局 */
void database::setWindowSearchBook(int type)
{
//如果身份为用户，需要销毁之前的窗口新建
if(type==USER_LOGIN||type==USER_REGISTER){
delete window1;
}

//常量
const int num = 8;
const int columnNum = 3;
const int typenum =23;

//申请内存
window1 = new QWidget();
gridLayout = new QGridLayout();
vboxLayout1 = new QVBoxLayout();
vboxLayout = new QVBoxLayout();

hboxLayout1 = new QHBoxLayout();
hboxLayout = new QHBoxLayout();

groupbox = new QGroupBox();
groupbox1 = new QGroupBox();
clearbutton = new QPushButton(tr("清空"));
searchbutton = new QPushButton(tr("搜索"));
tablewidget = new QTableWidget();

tree = new QTreeWidget();
root = new QTreeWidgetItem(QStringList()<<"所有类型");
QTreeWidgetItem *leaf[typenum];

//建立信号与槽
connect(searchbutton,SIGNAL(clicked()),this,SLOT(searchBook()));
//点击搜索按钮，进行搜索操作
connect(clearbutton,SIGNAL(clicked()),this,SLOT(clear()));
//点击清除按钮，进行清除操作
connect(tree,SIGNAL(itemClicked(QTreeWidgetItem*,int)),
this,SLOT(searchBookByType(QTreeWidgetItem*,int)));
//点击树状列表，进行查找书籍操作

//更新窗口信息
updateTitle(type);

//设置左边的树状图书分类栏
tree->setHeaderLabels(QStringList()<<"图书类型");
tree->addTopLevelItem(root);
tree->setFixedWidth(280);

tree->setColumnWidth(1,10);

QString str2[] = {
"马列主义毛邓思想","哲学","社会科学总论","政治法律","军事","经济","文化科学体育教育","语言文字",
"文学","艺术","历史地理","自然科学总论","数理科学与化学","天文学与地理科学","生物科学","医药卫生",
"工业技术","交通运输","航空航天","环境科学"
};
for(int i=0;i<20;i++){
leaf[i] = new QTreeWidgetItem(QStringList()<<str2[i]);
root->addChild(leaf[i]);
}

tree->expandAll();

//设置高级搜索栏
window = new QWidget();
nameLine = new QLineEdit();
publishLine = new QLineEdit();
authorLine = new QLineEdit();
dateBox = new QComboBox();
dateBox1 = new QComboBox();
priceLine = new QLineEdit();
priceLine1 = new QLineEdit();
isLent = new QComboBox();

label = new QLabel[num];
QString str[] = {"书名","出版社","作者","年份"," --","状态","价位"," --"};

for(int i=0;i<num;i++){
label[i].setText(str[i]);
gridLayout->addWidget(label+i,i/columnNum+1,2*(i%columnNum)+1);
}

dateBox->addItem("    ");
dateBox1->addItem("    ");
for(int i=0;i<60;i++){
dateBox->addItem(QString::number(2016-i));
dateBox1->addItem(QString::number(2016-i));
}

isLent->addItem("    ");
isLent->addItem("已借出");
isLent->addItem("未借出");

//表格布局，放置搜索选项
gridLayout->addWidget(nameLine,1,2);       //书名
gridLayout->addWidget(publishLine,1,4);       //类型
gridLayout->addWidget(authorLine,1,6);     //作者名称
gridLayout->addWidget(dateBox,2,2);        //年份（起）
gridLayout->addWidget(dateBox1,2,4);       //年份（终）
gridLayout->addWidget(isLent,2,6);        //借阅状态
gridLayout->addWidget(priceLine,3,2);     //价格（从）
gridLayout->addWidget(priceLine1,3,4);     //价格（到）

//搜索选项加入群组中
groupbox->setLayout(gridLayout);
groupbox->setFixedSize(600,140);

//垂直布局，放置两个按钮
vboxLayout1->addStretch();
vboxLayout1->addWidget(searchbutton);
vboxLayout1->addWidget(clearbutton);
vboxLayout1->addStretch();

groupbox1->setLayout(vboxLayout1);
groupbox1->setFixedSize(200,140);

//水平布局，依次加入搜索选项和按钮的垂直布局
hboxLayout1->addWidget(groupbox);
hboxLayout1->setSpacing(30);
hboxLayout1->addWidget(groupbox1);

//垂直布局，依次加入搜索框和显示框
vboxLayout->addLayout(hboxLayout1);
vboxLayout->addWidget(tablewidget);
setWindowShowBook(type);
vboxLayout->addLayout(hboxLayout6);

//水平布局，加入左边栏和右窗口
hboxLayout->addWidget(tree);
hboxLayout->addLayout(vboxLayout);

//窗口1加入水平布局
window1->setLayout(hboxLayout);
mainTabWidget->addTab(window1,"图书搜索");

//如果对象为用户，那么新建借书窗口
if(type==USER_LOGIN||type==USER_REGISTER){
setWindowLoanBook();
}
}

/* 单册添加书籍界面布局 */
void database::setWindowAddBook()
{
//申请内存
QLabel *label3 = new QLabel;
label3->setText("(如果有多个作者，请用空格分开)");

addBookWidget = new QWidget();
deletebookWidget = new QWidget();
window3 = new QWidget();
vboxLayout4 = new QVBoxLayout();
vboxLayout5 = new QVBoxLayout();
vboxLayout6 = new QVBoxLayout();
vboxLayout9 = new QVBoxLayout();
hboxLayout4 = new QHBoxLayout();
hboxLayout5 = new QHBoxLayout();
hboxLayout9 = new QHBoxLayout();
deleteOkButton = new QPushButton("确定");

manageTabWidget = new QTabWidget();
gridLayout2 = new QGridLayout();
okbutton = new QPushButton(tr("确定"));

nameLine2 = new QLineEdit();
typeBox2 = new QComboBox();
priceLine2 = new QLineEdit();
authorLine2 = new QLineEdit();
numLine2 = new QLineEdit();
publishLine2 = new QLineEdit();
dateBox2 = new QComboBox();

idLine = new QLineEdit();
label2 = new QLabel[7];
label5 = new QLabel;
label5->setText("请输入待删除书目的编号");

//建立信号与槽
connect(deleteOkButton,SIGNAL(clicked()),this,SLOT(deleteBook()));
//点击确认删除按钮，进行删除书籍操作
connect(okbutton,SIGNAL(clicked()),this,SLOT(oneAddBook()));
//点击确认按钮，进行添加书本操作

//设置选项框信息
QString str[7] = {"书名","价格","数量","出版社","出版日期",
"分类","作者"};
QString str2[20] = {
"马列主义毛邓思想","哲学","社会科学总论","政治法律","军事","经济","文化科学体育教育","语言文字",
"文学","艺术","历史地理","自然科学总论","数理科学与化学","天文学与地理科学","生物科学","医药卫生",
"工业技术","交通运输","航空航天","环境科学"
};

for(int i = 0;i < 7;i++){
label2[i].setText(str[i]);
}

for(int i=0;i<20;i++){
typeBox2->addItem(str2[i]);
}

for(int i=0;i<60;i++){
dateBox2->addItem(QString::number(2016-i));
}

//窗口布局

//设置选项框表格
gridLayout2->addWidget(label2,1,1);
gridLayout2->addWidget(label2+1,1,3);
gridLayout2->addWidget(label2+2,2,1);
gridLayout2->addWidget(label2+3,2,3);
gridLayout2->addWidget(label2+4,3,1);
gridLayout2->addWidget(label2+5,3,3);
gridLayout2->addWidget(label2+6,4,1);

gridLayout2->addWidget(nameLine2,1,2);
gridLayout2->addWidget(priceLine2,1,4);
gridLayout2->addWidget(numLine2,2,2);
gridLayout2->addWidget(publishLine2,2,4);
gridLayout2->addWidget(dateBox2,3,2);
gridLayout2->addWidget(typeBox2,3,4);
gridLayout2->addWidget(authorLine2,4,2);
gridLayout2->addWidget(label3,4,3,1,2);

//加入确认按钮
hboxLayout5->addStretch();
hboxLayout5->addWidget(okbutton);
hboxLayout5->addStretch();

vboxLayout6->addLayout(gridLayout2);
vboxLayout6->addLayout(hboxLayout5);

addBookWidget->setLayout(vboxLayout6);

hboxLayout9->addStretch();
hboxLayout9->addWidget(deleteOkButton);
hboxLayout9->addStretch();

vboxLayout9->addStretch();
vboxLayout9->addWidget(label5);
vboxLayout9->addWidget(idLine);
vboxLayout9->addLayout(hboxLayout9);
vboxLayout9->addStretch();

//添加分页窗口
deletebookWidget->setLayout(vboxLayout9);
manageTabWidget->addTab(addBookWidget,"添加图书");
manageTabWidget->addTab(deletebookWidget,"删除书籍");
vboxLayout5->addSpacing(100);
vboxLayout5->addWidget(manageTabWidget);
vboxLayout5->addSpacing(300);

hboxLayout4->addStretch();
hboxLayout4->addLayout(vboxLayout5);
hboxLayout4->addStretch();

window3->setLayout(hboxLayout4);
}

/* 多册添加书籍界面布局 */
void database::setWindowMutiAddBook()
{
//申请内存
tipLabel = new QLabel();
window5 = new QWidget();
tablewidget3 = new QTableWidget();
vboxLayout12 = new QVBoxLayout();
hboxLayout12 = new QHBoxLayout();
hboxLayout13 = new QHBoxLayout();
addBookOkButton = new QPushButton("提交表单");
addBookClearButton = new QPushButton("清空表单");
loadFileButton = new QPushButton("加载文件");

//建立信号与槽
connect(addBookOkButton,SIGNAL(clicked()),this,SLOT(mutiAddBook()));
connect(addBookClearButton,SIGNAL(clicked()),this,SLOT(clearAddBookMessage()));
connect(loadFileButton,SIGNAL(clicked()),this,SLOT(openFile()));

//设置选项信息
tipLabel->setText("请双击表格进行内容填写,或者通过文本加载。"
"如果有多个作者，请用空格分开\n"
"文本格式：按表格属性填写，同样属性按空格分开。"
"输入下本书籍信息要换行区分");
tipLabel->setFrameShape (QFrame::Box);
QStringList header;
tablewidget3->setRowCount(13);
tablewidget3->setColumnCount(7);
header<<"书名"<<"价格"<<"数量"<<"出版社"<<"出版日期"<<"分类"<<"作者";

//初始化表格信息
for(int i=0;i<13;i++){
for(int j=0;j<7;j++){
if(j==4){
publishDate[i] = new QComboBox();
for(int k=0;k<60;k++){
publishDate[i]->addItem(QString::number(2016-k));
}
tablewidget3->setCellWidget(i,j,publishDate[i]);
}
else if(j==5){
QString str[] = {
"马列主义毛邓思想","哲学","社会科学总论","政治法律","军事","经济","文化科学体育教育","语言文字",
"文学","艺术","历史地理","自然科学总论","数理科学与化学","天文学与地理科学","生物科学","医药卫生",
"工业技术","交通运输","航空航天","环境科学"
};
bookType[i] = new QComboBox();
for(int k=0;k<20;k++){
bookType[i]->addItem(str[k]);
}
tablewidget3->setCellWidget(i,j,bookType[i]);
}
else{
QTableWidgetItem *item = new QTableWidgetItem("");
tablewidget3->setItem(i,j,item);
}
}
}

tablewidget3->setHorizontalHeaderLabels(header);

//加入按钮和表格
hboxLayout12->addStretch();
hboxLayout12->addWidget(addBookOkButton);
hboxLayout12->addWidget(addBookClearButton);

hboxLayout13->addWidget(tipLabel);
hboxLayout13->addWidget(loadFileButton);

vboxLayout12->addLayout(hboxLayout13);
vboxLayout12->addWidget(tablewidget3);
vboxLayout12->addLayout(hboxLayout12);

window5->setLayout(vboxLayout12);
}

/* 借阅书籍界面布局 */
void database::setWindowLoanBook()
{
//申请内存
window4 = new QWidget();
mainTabWidget->addTab(window4,"借阅情况");

tablewidget2 = new QTableWidget(3,7);
hboxLayout11 = new QHBoxLayout();
vboxLayout11 = new QVBoxLayout();
returnBookButton = new QPushButton("归还书籍");

//建立信号与槽
connect(returnBookButton,SIGNAL(clicked()),this,SLOT(returnBook()));
//点击还书按钮，进行还书操作

//加入按钮和表格
hboxLayout11->addStretch();
hboxLayout11->addWidget(returnBookButton);
hboxLayout11->addStretch();

vboxLayout11->addWidget(tablewidget2);
vboxLayout11->addLayout(hboxLayout11);
vboxLayout11->addStretch();

window4->setLayout(vboxLayout11);

//更新借阅表格
updateLoanBookWindow();
}

/* 用户管理界面布局 */
void database::setWindowUserManage()
{
//申请内存
lastPageButton = new QPushButton("上一页");
nextPageButton = new QPushButton("下一页");
deleteUserButton = new QPushButton("删除用户信息");
grantLentButton = new QPushButton("授予/删除借书权限");
tablewidget1 = new QTableWidget(13,11);
window2 = new QWidget();
hboxLayout10 = new QHBoxLayout();
vboxLayout10 = new QVBoxLayout();

//建立信号与槽
connect(lastPageButton,SIGNAL(clicked()),this,SLOT(userLastPage()));
//点击上一页按钮，翻到上一页
connect(nextPageButton,SIGNAL(clicked()),this,SLOT(userNextPage()));
//点击下一页按钮，翻到下一页
connect(deleteUserButton,SIGNAL(clicked()),this,SLOT(deleteUser()));
//点击删除用户按钮，进行删除用户操作
connect(grantLentButton,SIGNAL(clicked()),this,SLOT(grantLent()));
//点击借书授权按钮，进行借书授权操作

//载入用户信息，并更新用户管理表格
loadUserMessage();
updateManageWindow();

//加入按钮
hboxLayout10->addStretch();
hboxLayout10->addWidget(deleteUserButton);
hboxLayout10->addWidget(grantLentButton);
hboxLayout10->addWidget(lastPageButton);
hboxLayout10->addWidget(nextPageButton);

//布局
vboxLayout10->addWidget(tablewidget1);
vboxLayout10->addLayout(hboxLayout10);
window2->setLayout(vboxLayout10);
}

/* 用户注册界面布局 */
void database::setWindowRegister()
{
//申请内存
registerWindow = new QWidget();
gridLayout3 = new QGridLayout();

label4 = new QLabel[3];
label4[0].setText("用户名");
label4[1].setText("密码");
label4[2].setText("密码确认");
label3 = new QLabel("请输入注册信息(借书权\n"
"限将由管理员添加）");
nameLine3 = new QLineEdit();
passwordLine1 = new QLineEdit();
passwordLine2 = new QLineEdit();
passwordLine1->setEchoMode(QLineEdit::Password);
passwordLine2->setEchoMode(QLineEdit::Password);
registerOkButton = new QPushButton("确定");
hboxLayout7 = new QHBoxLayout();
hboxLayout8 = new QHBoxLayout();
vboxLayout7 = new QVBoxLayout();

//页面布局
hboxLayout7->addStretch();
hboxLayout7->addWidget(registerOkButton);
hboxLayout7->addStretch();

gridLayout3->addWidget(&label4[0],1,1);
gridLayout3->addWidget(&label4[1],2,1);
gridLayout3->addWidget(&label4[2],3,1);

gridLayout3->addWidget(nameLine3,1,2);
gridLayout3->addWidget(passwordLine1,2,2);
gridLayout3->addWidget(passwordLine2,3,2);

vboxLayout7->addWidget(label3);
vboxLayout7->addLayout(gridLayout3);
vboxLayout7->addLayout(hboxLayout7);

hboxLayout8->addStretch();
hboxLayout8->addLayout(vboxLayout7);
hboxLayout8->addStretch();

registerWindow->setLayout(hboxLayout8);
registerWindow->resize(400,300);
registerWindow->show();

//建立信号与槽
connect(registerOkButton,SIGNAL(clicked()),this,SLOT(Register()));
//点击确认登录按钮，进行登录操作
}

/* 显示书籍信息界面布局 */
void database::setWindowShowBook(int type)
{
//申请内存
hboxLayout6 = new QHBoxLayout();
lastbutton = new QPushButton(tr("上一页"));
nextbutton = new QPushButton(tr("下一页"));

//建立信号与槽
connect(lastbutton,SIGNAL(clicked()),this,SLOT(bookLastPage()));
//点击上一页按钮，翻到上一页
connect(nextbutton,SIGNAL(clicked()),this,SLOT(bookNextPage()));
//点击下一页按钮，翻到下一页

//页面布局
hboxLayout6->addStretch();
hboxLayout6->addWidget(lastbutton);
hboxLayout6->addWidget(nextbutton);

//如果当前使用者为用户，加入借阅书籍按钮
if(type==USER_LOGIN||type==USER_REGISTER){
lendBookButton = new QPushButton(tr("借阅书籍"));
connect(lendBookButton,SIGNAL(clicked()),this,SLOT(lendBook()));
hboxLayout6->addWidget(lendBookButton);
}

//初始化当前页和最大页
current_page = 1;
max_page = 1;

//更新显示书目窗口
updateShowBookWindow();
}

/* 更新书籍信息界面 */
void database::updateShowBookWindow()
{
QStringList header;

//清除表格信息
tablewidget->clear();

//设置表格为不可选择、不可修改
tablewidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
tablewidget->setSelectionMode(QAbstractItemView::NoSelection);

//根据当前使用者的不同使用不同的标题栏
if(user_type==USER){
tablewidget->setRowCount(10);
tablewidget->setColumnCount(11);
header<<""<<"编号"<<"书名"<<"价格"<<"库存"<<"入库时间"
<<"入库人员"<<"出版社"<<"出版年份"<<"类型"<<"作者";
}
else{
tablewidget->setRowCount(10);
tablewidget->setColumnCount(10);
header<<"编号"<<"书名"<<"价格"<<"库存"<<"入库时间"
<<"入库人员"<<"出版社"<<"出版年份"<<"类型"<<"作者";
}

//加入标题栏
tablewidget->setHorizontalHeaderLabels(header);

//设置宽度
for(int i=0;i<10;i++){
tablewidget->setColumnWidth(i,120);
}

//求出当前页的最多显示条目
int max;

if(result.length()==0)return;
if(current_page==max_page){
max = result.length()%100/10;
if(max==0)max=10;
}
else max = 10;

//根据当前使用者的不同在表格上显示不同信息
if(user_type==USER){
for(int i=0;i<max;i++){
item2[i] = new QTableWidgetItem();
item2[i]->setCheckState(Qt::Unchecked);
item3[i] = new QTableWidgetItem(result.at(10*i+100*(current_page-1)));
tablewidget->setItem(i,0,item2[i]);
tablewidget->setItem(i,1,item3[i]);
for(int j=1;j<10;j++){
QTableWidgetItem *item = new QTableWidgetItem(result.at(10*i+j+100*(current_page-1)));
tablewidget->setItem(i,j + 1,item);
}
}
}
else{
for(int i=0;i<max;i++){
for(int j=0;j<10;j++){
QTableWidgetItem *item = new QTableWidgetItem(result.at(10*i+j+100*(current_page-1)));
tablewidget->setItem(i,j,item);
}
}
}
}

/* 更新借阅书籍界面 */
void database::updateLoanBookWindow()
{
//更新前加载借阅信息
loadLoanMessage();

QStringList header;

//清空表格信息
tablewidget2->clear();

//设置标题栏
header<<""<<"书本编号"<<"书本名称"<<"借阅日期"<<"单册编号"<<"最晚归还日期"<<"剩余归还天数";
tablewidget2->setHorizontalHeaderLabels(header);

//设置表格为不可修改，不可选择
tablewidget2->setEditTriggers(QAbstractItemView::NoEditTriggers);
tablewidget2->setSelectionMode(QAbstractItemView::NoSelection);

//将信息显示到表格上
for(int i=0;i<loanMessage.length();i++){
item4[i] = new QTableWidgetItem();
item4[i]->setCheckState(Qt::Unchecked);
tablewidget2->setItem(i,0,item4[i]);
for(int j=0;j<6;j++){
QTableWidgetItem *item = new QTableWidgetItem(loanMessage.at(i)[j]);
tablewidget2->setItem(i,j + 1,item);
}
}
}

/* 更新用户管理界面 */
void database::updateManageWindow()
{
//计算当前页面能显示的最多用户数
int max;
if(user_current_page==user_max_page){
max = (user_num%13==0)?13:user_num%13;
}
else{
max = 13;
}

//清除表格信息
tablewidget1->clear();

//设置表格为不可选择，不可修改
tablewidget1->setEditTriggers(QAbstractItemView::NoEditTriggers);
tablewidget1->setSelectionMode(QAbstractItemView::NoSelection);

//设置标题栏
QStringList header;
header<<""<<"用户名"<<"密码"<<"借书权限"<<"借阅数目"<<"借阅书籍1"
<<"借阅日期"<<"借阅书籍2"<<"借阅日期"<<"借阅书籍3"<<"借阅日期";
tablewidget1->setHorizontalHeaderLabels(header);

//将信息显示到表格上
for(int i=0;i<max;i++){
int row = i + (user_current_page - 1)*13;
item0[i] = new QTableWidgetItem();
item0[i]->setCheckState(Qt::Unchecked);
item1[i] = new QTableWidgetItem(userMessage.at(row)[0]);

tablewidget1->setItem(i,0,item0[i]);
tablewidget1->setItem(i,1,item1[i]);

for(int j=1;j<10;j++){
QTableWidgetItem *item = new QTableWidgetItem(userMessage.at(row)[j]);
tablewidget1->setItem(i,j+1,item);
}
}
}

/* 更新时间显示 */
void database::updateTime()
{
//获取系统时间
QDateTime current_date_time = QDateTime::currentDateTime();
QString current_date = current_date_time.toString("yyyy-MM-dd hh:mm:ss ddd");
QString text = "当前用户: " + current_user + " | 当前时间:"+current_date+" ";
spacelabel2->setText(text);
}

/* 更新标题栏信息 */
void database::updateTitle(int type)
{
//获取系统时间
QDateTime current_date_time = QDateTime::currentDateTime();
QString current_date = current_date_time.toString("yyyy-MM-dd hh:mm:ss ddd");
QString text;

//如果当前使用者为游客，更新标题栏，直接返回
if(type==VISITOR){
text = "当前用户：游客 | 当前时间:"+current_date+" ";
spacelabel2->setText(text);
return;
}

//登录后删除登录、注册按钮
delete loginbutton;
delete registerbutton;

//新建退出登录按钮，点击退出登录按钮，进行退出登录操作
quitloginbutton = new QPushButton("退出登录");
connect(quitloginbutton,SIGNAL(clicked()),this,SLOT(quitLogin()));
hboxLayout3->addWidget(quitloginbutton);

quitloginbutton->setFlat(true);

//根据当前使用者显示不同的标题栏
if(type==USER_LOGIN){
text = "当前用户："+username1->text()+" | 当前时间:"+current_date+" ";
current_user = username1->text();
user_type = USER;
//删除登录窗口
delete loginTabWidget;
}
else if(type==USER_REGISTER){
text = "当前用户："+nameLine3->text()+" | 当前时间:"+current_date+" ";
current_user = nameLine3->text();
user_type = USER;
//删除注册窗口
delete registerWindow;
}
else if(type==MANAGER){
text = "当前用户："+username2->text()+" | 当前时间:"+current_date+" ";
current_user = username2->text();
user_type = MANAGER;
//删除登录窗口
delete loginTabWidget;
}
spacelabel2->setText(text);
}

/* 创建登录窗口（登录窗口布局的辅助函数） */
QWidget* database::createLoginWindow(int type)
{
//申请内存
QWidget *widget = new QWidget();
QLabel *username_label = new QLabel;
QLabel *password_label = new QLabel;
QGridLayout *glayout = new QGridLayout;
QPushButton *yesbutton = new QPushButton(tr("确定"));
QPushButton *quitbutton = new QPushButton(tr("退出"));
QHBoxLayout *hlayout = new QHBoxLayout();
QVBoxLayout *vlayout = new QVBoxLayout();

//根据不同类型建立不同的输入栏
if(type==1){
username1 = new QLineEdit();
password1 = new QLineEdit();
password1->setEchoMode(QLineEdit::Password);
glayout->addWidget(username1,1,2);
glayout->addWidget(password1,2,2);
}
else if(type==2){
username2 = new QLineEdit();
password2 = new QLineEdit();
password2->setEchoMode(QLineEdit::Password);
glayout->addWidget(username2,1,2);
glayout->addWidget(password2,2,2);
}

username_label->setText(tr("账号"));
password_label->setText(tr("密码"));

//表格布局加入文字标签
glayout->setContentsMargins(50,100,50,100);
glayout->setSpacing(40);
glayout->addWidget(username_label,1,1);

glayout->addWidget(password_label,2,1);

//加入按钮和输入栏
hlayout->addStretch();
hlayout->addWidget(yesbutton);
hlayout->addWidget(quitbutton);
hlayout->addStretch();
vlayout->addLayout(glayout);
vlayout->addLayout(hlayout);

widget->setLayout(vlayout);

//点击退出按钮，进行删除登录窗口操作
connect(quitbutton,SIGNAL(clicked()),this,SLOT(deleteLogin()));

//点击确认按钮，根据类型不同将信号发送到用户登录和管理员登录中
if(type==1){
connect(yesbutton,SIGNAL(clicked()),this,SLOT(userLogin()));
}
else if(type==2){
connect(yesbutton,SIGNAL(clicked()),this,SLOT(managerLogin()));
}

return widget;
}

/* 清空搜索框 */
void database::clear()
{
nameLine->clear();
publishLine->clear();
authorLine->clear();
priceLine->clear();
priceLine1->clear();
}

/* 清空多册添加的表单 */
void database::clearAddBookMessage()
{
//对每一个表单，设置为空
for(int i = 0;i<13;i++){
for(int j = 0;j<7;j++){
if(j!=5&&j!=4){
tablewidget3->item(i,j)->setText("");
}
}
}
//如果有图书信息缓存，清空
for(int i=0;i<multiBookMessage.length();i++){
multiBookMessage.pop_front();
}
}

/* 删除登录界面*/
void database::deleteLogin()
{
//删除登陆界面，并将登录注册按钮设为可使用
delete loginTabWidget;
loginbutton->setEnabled(true);
registerbutton->setEnabled(true);
}

/* 退出登录更新界面*/
void database::quitLogin()
{
//删除退出登录按钮
delete quitloginbutton;

//根据当前使用者的不同，删除对应的窗口以及控件
if(user_type==MANAGER){
delete window3;
delete window2;
delete window5;
}
else if(user_type==USER){
delete window4;
delete lendBookButton;
}

//获取系统时间
QDateTime current_date_time = QDateTime::currentDateTime();
QString current_date = current_date_time.toString("yyyy-MM-dd hh:mm:ss ddd");
QString text = "当前用户: 游客 | 当前时间:"+current_date+" ";

//更新使用者类型为游客
user_type = VISITOR;
current_user = "游客";
spacelabel2->setText(text);

//重新建立登录注册按钮，并摆放
loginbutton = new QPushButton("登录");
registerbutton = new QPushButton("注册");
loginbutton->setFlat(true);
registerbutton->setFlat(true);
registerbutton->setFixedSize(QSize(60,30));
loginbutton->setFixedSize(QSize(60,30));
hboxLayout3->addWidget(loginbutton);
hboxLayout3->addWidget(registerbutton);

//重新连接登录注册与对应的槽函数
connect(loginbutton,SIGNAL(clicked()),this,SLOT(setWindowLogin()));
connect(registerbutton,SIGNAL(clicked()),this,SLOT(setWindowRegister()));
}

/* 用户管理翻页（上一页）*/
void database::userLastPage()
{
//当前页为1,不存在上一页，返回
if(user_current_page==1)return;
//当前页减1
user_current_page--;
//更新用户管理窗口
updateManageWindow();
}

/* 用户管理翻页（下一页）*/
void database::userNextPage()
{
//如果当前页面为最大页面，不存在下一页面，返回
if(user_current_page==user_max_page)return;
//当前页面加一
user_current_page++;
//更新用户管理窗口
updateManageWindow();
}

/* 显示书籍翻页（上一页）*/
void database::bookLastPage()
{
//当前页为1,不存在上一页，返回
if(current_page==1)return;
//当前页减1
current_page--;
//更新显示书本窗口
updateShowBookWindow();
}

/* 显示书籍翻页（下一页）*/
void database::bookNextPage()
{
//如果当前页面为最大页面，不存在下一页面，返回
if(current_page==max_page)return;
//当前页面加一
current_page++;
//更新显示书本窗口
updateShowBookWindow();
}

/* 打开文件导入书籍数据 */
void database::openFile()
{
//新建文件显示窗口
fileWindow = new QWidget;
QFileDialog dlg(fileWindow,"打开文本");
dlg.resize(400,300);
dlg.setAcceptMode(QFileDialog::AcceptOpen);

//只允许打开.txt后缀的文件
dlg.setNameFilter("*txt");

//打开文件对话框
if(dlg.exec()==QDialog::Accepted ){
QStringList files = dlg.selectedFiles();
if(!files.isEmpty()){
//以只读形式打开选中文件
QFile file;
file.setFileName(files.at(0));
file.open(QIODevice::ReadOnly);
if(!file.atEnd()){
int count = 0;
int rowNum = 0;
//读取文本所有信息，并进行转码处理
QByteArray buff;
buff = file.readAll();
QString fileContent = QString::fromLocal8Bit(buff);
QString str = "";

//对文本进行格式化处理
for(int k=0;k<=fileContent.length();k++){
//读到换行符或者读完文本，把书籍信息存储
if(fileContent.at(k)=='\n'||k==fileContent.length()){
bookMessage[6] = str;
if(rowNum>=13){ //列数超过显示范围，暂存到容器中
QString *tmp = new QString[7];
for(int i=0;i<7;i++){
tmp[i] = bookMessage[i];
}
multiBookMessage.push_back(tmp);
}
else{ //列数未超过显示范围，直接显示在表格中
for(int i=0;i<7;i++){
if(i==4)publishDate[rowNum]->setCurrentText(bookMessage[i]);
else if(i==5)bookType[rowNum]->setCurrentText(bookMessage[i]);
else{
tablewidget3->item(rowNum,i)->setText(bookMessage[i]);
}
}
rowNum++;
count = 0;
str = "";
}
//如果以换行符结束，不需要继续处理
if(fileContent.at(k)=='\n'&&k==fileContent.length()-1){
break;
}
}
//读到空格且不是作者信息中的空格，跳过空格，并把字符串存储到bookmessage中
else if(fileContent.at(k)==' '&&count!=6){
bookMessage[count++] = str;
str = "";
}
//读到空格且是作者信息中的空格，直接存储空格信息
else if(fileContent.at(k)==' '&&count==6){
str = str + fileContent.at(k);
}
//读到支持的文本内容，将其加入字符串中
else if(fileContent.at(k).isLetter()||fileContent.at(k).isNumber()
||fileContent.at(k)=='.'||fileContent.at(k)==':'
||fileContent.at(k)=='-'||fileContent.at(k)=='"'
||fileContent.at(k)=='('||fileContent.at(k)==')'
||fileContent.at(k)=='·'){
str = str + fileContent.at(k);
}
}
}
}
}
}

/*  _______________________
|                       |
|   第二部分：业务逻辑     |
|                       |
———————————————————————
*/

/* 用户注册 */
void database::Register()
{
//检测用户是否输入了全部的信息
if(nameLine3->text().isEmpty()||passwordLine1->text().isEmpty()||passwordLine2->text().isEmpty()){
QMessageBox::critical(NULL, "Error", "您的信息填写不完整",
QMessageBox::Yes);
return;
}

//检测密码是否一致
if(passwordLine1->text().compare(passwordLine2->text())!=0){
QMessageBox::critical(NULL, "Error", "两次密码输入不一致！",
QMessageBox::Yes);
return;
}

//查询用户名是否已存在于数据库
QSqlQuery query;
query.exec("select username from user where username = '" + nameLine3->text() + "'");
if(query.next()){
QMessageBox::critical(NULL, "Error", "该用户名已被注册",
QMessageBox::Yes);
return;
}

//向user表中插入用户信息
query.exec("insert into user values('" + nameLine3->text() + "','" + passwordLine1->text() + "'" +",false)");
if(query.isActive()){
QMessageBox::about(0,"database","注册成功！");
}
else{
QMessageBox::critical(NULL, "Error", "注册失败",
QMessageBox::Yes);
return;
}

//更新检索书籍窗口
setWindowSearchBook(USER_REGISTER);
}

/* 用户登录 */
void database::userLogin()
{
QSqlQuery query2;

//根据用户输入的用户名，在user表中查询其密码
query2.exec("select password from user where username = '"
+username1->text()+"'");
if(!query2.isActive()){
return;
}

//判断密码是否与结果一致
if(query2.next()){
QString sel_password = query2.value(0).toString();
if(QString::compare(sel_password,password1->text())!=0){
QMessageBox::critical(NULL, "Error", "密码错误",
QMessageBox::Yes);
return;
}
}
//如果数据库中没有此用户名，给出警告
else{
QMessageBox::critical(NULL, "Error", "该用户名不存在",
QMessageBox::Yes);
return;
}

//更新检索书籍窗口
setWindowSearchBook(USER_LOGIN);
}

/* 管理员登录 */
void database::managerLogin()
{
QSqlQuery query2;

//根据用户输入的用户名，在manager表中查询其密码
query2.exec("select password from manager where username = '"
+username2->text()+"'");
if(!query2.isActive()){
return;
}

//判断密码是否与结果一致
if(query2.next()){
QString sel_password = query2.value(0).toString();
if(QString::compare(sel_password,password2->text())!=0){
QMessageBox::critical(NULL, "Error", "密码错误",
QMessageBox::Yes);
return;
}
}

//如果数据库中没有此用户名，给出警告
else{
QMessageBox::critical(NULL, "Error", "该用户名不存在",
QMessageBox::Yes);
return;
}

//更新标题栏信息
updateTitle(MANAGER);

//添加图书单册入库窗口
setWindowAddBook();
//添加用户管理窗口
setWindowUserManage();
//添加图书多册入库窗口
setWindowMutiAddBook();

//在分页栏中加入以上窗口
mainTabWidget->addTab(window2,"用户管理");
mainTabWidget->addTab(window3,"单册入库");
mainTabWidget->addTab(window5,"多册入库");
}

/* 多条件查询书籍 */
void database::searchBook()
{
//判断用户是否填写了信息
if(nameLine->text().isEmpty()&&publishLine->text().isEmpty()&&authorLine->text().isEmpty()
&&(!dateBox->currentText().compare("    ")&&!dateBox1->currentText().compare("    "))
&&!isLent->currentText().compare("    ")&&(priceLine->text().isEmpty()&&priceLine1->text().isEmpty())){
QMessageBox::critical(0,QObject::tr("error"),"您尚未填写任何信息");
return;
}

//检查日期和价格的填写是否正确
else if(((dateBox->currentText().compare("    ")==0&&dateBox->currentText().compare("    ")!=0)||
(dateBox->currentText().compare("    ")!=0&&dateBox->currentText().compare("    ")==0))&&
(!priceLine->text().isEmpty()&&priceLine1->text().isEmpty()||
priceLine->text().isEmpty()&&!priceLine1->text().isEmpty())){
QMessageBox::critical(0,QObject::tr("error"),"您的日期和价格范围有误");
return;
}
else if((dateBox->currentText().compare("    ")==0&&dateBox->currentText().compare("    ")!=0)||
(dateBox->currentText().compare("    ")!=0&&dateBox->currentText().compare("    ")==0)){
QMessageBox::critical(0,QObject::tr("error"),"您的日期范围有误");
return;
}
else if(!priceLine->text().isEmpty()&&priceLine1->text().isEmpty()||
priceLine->text().isEmpty()&&!priceLine1->text().isEmpty()){
QMessageBox::critical(0,QObject::tr("error"),"您的价格范围有误");
return;
}
int x1,x2,y1,y2;
x1=x2=y1=y2=0;
if(dateBox->currentText().compare("    ")){
x1 = dateBox->currentText().toInt();
x2 = dateBox1->currentText().toInt();
}
if(!priceLine->text().isEmpty()){
y1 = priceLine->text().toInt();
y2 = priceLine1->text().toInt();
}

if(x1>x2&&y1>y2){
QMessageBox::critical(0,QObject::tr("error"),"您的日期和价格范围有误");
return;
}
else if(x1>x2){
QMessageBox::critical(0,QObject::tr("error"),"您的日期范围有误");
return;
}
else if(y1>y2){
QMessageBox::critical(0,QObject::tr("error"),"您的价格范围有误");
return;
}

//将用户输入的信息暂存于容器中
QVector<QString>list;
if(!nameLine->text().isEmpty()){
list.push_back("name");
list.push_back(nameLine->text());
}
if(!publishLine->text().isEmpty()){
list.push_back("publisher");
list.push_back(publishLine->text());
}
if(!authorLine->text().isEmpty()){
list.push_back("author");
list.push_back(authorLine->text());
}
if(dateBox->currentText().compare("    ")!=0){
list.push_back("publish_year");
list.push_back(dateBox->currentText());
list.push_back(dateBox1->currentText());
}

if(isLent->currentText().compare("    ")!=0){
QString str;
if(isLent->currentText().compare("未借出")==0){
str = ">";
}
else if(isLent->currentText().compare("已借出")==0){
str = "=";
}
list.push_back("number");
list.push_back(str);
}
if(!priceLine->text().isEmpty()){
list.push_back("price");
list.push_back(priceLine->text());
list.push_back(priceLine1->text());
}

//根据用户输入的信息在book表和book_author两个表中进行检索
int len = list.length();
int count = 0;
QString ans = "select * from book where " ;
QSqlQuery query,query2;

while(count<len){
if(count!=0)ans = ans + " and ";
QString tmp = list.front();
list.pop_front();
count++;
QString tmp1,tmp2;
if(tmp.compare("publish_year")==0){
tmp1 = list.front();
list.pop_front();
count++;
tmp2 = list.front();
list.pop_front();
count++;
ans = ans + tmp + " >= '" + tmp1 + "' and " +
tmp + " <= '" + tmp2 + "'";
}
else if(tmp.compare("price")==0){
tmp1 = list.front();
list.pop_front();
count++;
tmp2 = list.front();
list.pop_front();
count++;
ans = ans + tmp + " > " + tmp1 + " and " +
tmp + " < " + tmp2;
}

else if(tmp.compare("number")==0){
tmp1 = list.front();
list.pop_front();
count++;
ans = ans + tmp + tmp1 + "0";
}
else if(tmp.compare("author")==0){
bool flag = false;
QVector<QString>str;
tmp1 = list.front();
list.pop_front();
count++;
query2.exec("select book_id from book_author where author_name like '%" + tmp1 + "%'");
while(query2.next()){
flag = true;
str.push_back(query2.value(0).toString());
}
if(!flag){
QMessageBox::critical(0,QObject::tr("error"),"未查到搜索的结果！");
return;
}
if(str.length()==1){
ans = ans + "book_id = '" + str.front() + "'";
str.pop_front();
}
else{
for(int i=0;i<str.length();i++){
if(i==0) ans = ans + "(book_id = '" + str[i] + "'";
else if(i==str.length()-1) ans = ans + " or book_id = '" + str[i] + "')";
else ans = ans + " or book_id = '" + str[i] + "'";
}
}
str.clear();
}
else{
tmp1 = list.front();
list.pop_front();
count++;
ans = ans + tmp + " like '%" + tmp1 + "%'";
}
}

query.exec(ans);
if(!query.isActive()){
QMessageBox::critical(0,QObject::tr("error"),query.lastError().text());
}

//将结果容器清空，把搜索的结果暂存于结果容器中，之后根据页码显示相应的结果
result.clear();

while(query.next()){

QString ans="";
QString str = query.value(0).toString();
query2.exec("select author_name from book_author where book_id = '"+str+"'");
while(query2.next()){
ans = ans + query2.value(0).toString() + " ";
}
for(int i=0;i<9;i++){
result.push_back(query.value(i).toString());
}
result.push_back(ans);
}
if(result.length()==0){
QMessageBox::critical(0,QObject::tr("error"),"未查到搜索的结果！");
return;
}

//初始化当前页和最大页
current_page = 1;
max_page = result.length()/100 + (result.length()%100!=0);

//更新显示书籍窗口
updateShowBookWindow();
}

/* 按照书的分类查询书籍 */
void database::searchBookByType(QTreeWidgetItem* tree,int num)
{
QSqlQuery query,query2;
QString text = tree->text(0);

//根据分类，在book表和book_author两个表中进行检索
query.exec("select * from book "
"where type = '"+text+"'");
if(!query.isActive()){
QMessageBox::critical(0,QObject::tr("error"),"未查询到结果！");
}

//将结果容器清空，把搜索的结果暂存于结果容器中，之后根据页码显示相应的结果
result.clear();
while(query.next()){
QString ans="";
QString str = query.value(0).toString();
query2.exec("select author_name from book_author where book_id = '"+str+"'");
while(query2.next()){
ans = ans + query2.value(0).toString() + " ";
}
for(int i=0;i<9;i++){
result.push_back(query.value(i).toString());
}
result.push_back(ans);
}

//初始化当前页和最大页
current_page = 1;
max_page = result.length()/100 + (result.length()%100!=0);

//更新显示书籍窗口
updateShowBookWindow();
}

/* 加载借书信息 */
void database::loadLoanMessage()
{
QSqlQuery query,query1;

//由于容器中存的是指针对象，需要一个个释放内存
//防止频繁更新表导致的内存泄漏
for(int i=0;i<loanMessage.length();i++){
for(int j=0;j<5;j++){
loanMessage.at(i)[j].clear();
}
}
//清空借阅信息
loanMessage.clear();

//从表loan中查询借书信息
query.exec("select book_id,loan_date,loan_number from loan where username = '"
+ current_user + "'");

//把搜索的结果暂存于借阅信息容器中，之后根据页码显示相应的结果
while(query.next()){
QString *ans = new QString[6];
ans[0] = query.value(0).toString();
query1.exec("select name from book where book_id = '" + ans[0] + "'");
if(query1.next()){
ans[1] = query1.value(0).toString();
}
else{
qDebug()<<"error";
return;
}
ans[2] = query.value(1).toString();//日期
ans[3] = query.value(2).toString();//单册编号
QDate currentDate = QDate::currentDate();
QDate loanDate = query.value(1).toDate();
QDate returnDate = loanDate.addDays(90);
int remainingTime = currentDate.daysTo(returnDate);
ans[4] = returnDate.toString("yyyy-MM-dd");
if(remainingTime>=0){
ans[5] = QString::number(remainingTime);
}
else{
ans[5] = "已逾期";
}
loanMessage.push_back(ans);
}
}

/* 加载用户信息 */
void database::loadUserMessage()
{
user_num = 0;
QSqlQuery query,query1,query2;

//由于容器中存的是指针对象，需要一个个释放内存
//防止频繁更新表导致的内存泄漏
for(int i=0;i<userMessage.length();i++){
for(int j=0;j<10;j++){
userMessage.at(i)[j].clear();
}
}
//清空用户信息
userMessage.clear();

//在表user中搜索所有信息
query.exec("select * from user");

int i = 0;
QString name[3];
QString id[3];
QString date[3];

//把搜索的结果暂存于借阅信息容器中，之后根据页码显示相应的结果
while(query.next()){
QString *ans = new QString[10];
int num = 0;
int count = 0;
for(int j=0;j<=2;j++){
ans[j] = query.value(j).toString();
}

query1.exec("select book_id,loan_date"
" from loan where username = '" + ans[0] + "'");
while(query1.next()){
id[count] = query1.value(0).toString();
date[count] = query1.value(1).toString();
num++;
query2.exec("select name from book where book_id = '"
+ id[count] + "'");
if(query2.next()){
name[count++] = query2.value(0).toString();
}
}
ans[3] = QString::number(num);

for(int j=0;j<count;j++){
ans[4 + 2*j] = name[j] + "(" + id[j] + ")";
ans[5 + 2*j] = date[j];
}
for(int j=count;j<3;j++){
ans[4 + 2*j] = "";
ans[5 + 2*j] = "";
}
userMessage.push_back(ans);
i++;
user_num++;
}

//初始化当前页码和最大页码
user_current_page = 1;
if(user_num%13==0)user_max_page = user_num/13;
else user_max_page = user_num/13 + 1;
}

/* 连接数据库 */
bool database::createConnection()
{
//连接MySQL数据库
db = QSqlDatabase::addDatabase("QMYSQL");
//设置主机名
db.setHostName("localhost");
//设置数据库名
db.setDatabaseName("book_manage");
//设置账号名
db.setUserName("root");
//设置密码名
db.setPassword("root");
//设置端口
db.setPort(3306);
if(!db.open()){
QMessageBox::critical(0,QObject::tr("error"),db.lastError().text());
return false;
}
return true;
}

/* 删除书籍 */
void database::deleteBook()
{
QSqlQuery query,query1;

//删除之前，检索书号是否存在，便于给出用户反馈信息
query1.exec("select book_id from book where book_id = '" + idLine->text() + "'");
if(!query1.next()){
QMessageBox::critical(NULL, "Error", "该书号不存在",
QMessageBox::Yes);
return;
}

//从book中删除该书本信息
query.exec("delete from book where book_id = '" + idLine->text() + "'");
if(!query.isActive()){
QMessageBox::critical(NULL, "Error", "删除失败",
QMessageBox::Yes);
}
else{
QMessageBox::about(NULL,"Ok","删除成功");
}
}

/* 书籍入库 */
bool database::addBook()
{
QSqlQuery query,query1,query2;

QString author_str = bookMessage[6];
QVector<QString>list;
QString tmp="";

//入库前，先查找是否存在相同（除作者）的书籍
query.exec("select book_id from book where name = '"
+ bookMessage[0] + "' and price = '"
+ bookMessage[1] + "' and publisher = '"
+ bookMessage[3] + "' and publish_year = '"
+ bookMessage[4] + "' and type = '"
+ bookMessage[5] + "'");

//如果存在的话，给出已存在书的信息
//并向用户询问，选择将两本书合并，还是退出
if(query.next()){
query1.exec("select author_name from book_author where book_id = '" +
query.value(0).toString() + "'");
QString author = "";
QString str = "";
while(query1.next()){
author = author + query1.value(0).toString() + " ";
}
for(int i = 0;i<6;i++){
if(i==2)continue;
else str = str + bookMessage[i] + ",";
}
str = str + author;
QMessageBox::StandardButton messagebox  = QMessageBox::question(NULL,"question","图书库已有类似图书：\n（" +
str + ")\n是否需要合并两本书？（不合并则取消入库）");
if(messagebox==QMessageBox::Yes){
query2.exec("update book set number = number + " + bookMessage[2]
+ " where book_id = '" + query.value(0).toString() +"'");
if(query2.isActive()){
return true;
}
else return false;
}
else if(messagebox==QMessageBox::No){
return false;
}
}

//对用户一次输入的多个作者，进行格式化，将作者名分开，并暂存于容器中
for(int i=0;i<author_str.length();i++){
if(author_str.at(i)!=' ')tmp = tmp + author_str.at(i);
else{
list.push_back(tmp);
tmp = "";
}
}
if(!tmp.isEmpty())list.push_back(tmp);

//获取当前时间
QDate d = QDate::currentDate();
QString str2 = d.toString("yyyy-MM-dd");

//查询当前书的总数，为该书分配一个编号，计算方法为当前书总数 + 1
//如果该编号已存在，继续查找连续的编号，直到找到一个未使用的编号为止
query.exec("select count(*) from book");
int num = 0;
int tmp_num;
if(query.next()){
num = query.value(0).toInt();
}
if(num>=99999){
QMessageBox::critical(NULL,"error","数据库存储已满，请申请数据库扩容");
return false;
}
tmp_num = ++num;

int count = 0;
while(tmp_num){
tmp_num/=10;
count++;
}
count=5-count;

QString str = QString::number(num);

for(int i=0;i<count;i++){
str = "0" + str;
}

query.exec("select book_id from book where book_id = '" + str +"'");

while(query.next()){
count = 0;
tmp_num = ++num;
while(tmp_num){
tmp_num/=10;
count++;
}
str = QString::number(num);
count=5-count;
for(int i=0;i<count;i++){
str = "0" + str;
}
query.exec("select book_id from book where book_id = '" + str +"'");
}

//向表book中插入书籍信息
query2.exec("insert into book values('"
+ str + "','" + bookMessage[0] + "'," +
bookMessage[1] + "," + bookMessage[2] + ",'" +
str2 + "','" + current_user + "','" +
bookMessage[3] + "','" + bookMessage[4] +
"','" + bookMessage[5]+"')");

//向表book_author中插入作者信息
for(int i=0;i<list.size();i++){
query1.exec("insert into book_author values('"+
str + "','"+list.front()+"')");
list.pop_front();
}

if(query1.isActive()&&query1.isActive()){
return true;
}
else{
return false;
}
}

/* 单册书籍入库（加载书籍信息） */
void database::oneAddBook()
{
//检查用户填写的信息是否完整
if(nameLine2->text().isEmpty()||priceLine2->text().isEmpty()||
authorLine2->text().isEmpty()||numLine2->text().isEmpty()||
publishLine2->text().isEmpty()){
QMessageBox::critical(NULL, "Error", "您的信息填写不完整",
QMessageBox::Yes);
return;
}

//将用户输入的信息暂存于数组中
bookMessage[0] = nameLine2->text();
bookMessage[1] = priceLine2->text();
bookMessage[2] = numLine2->text();
bookMessage[3] = publishLine2->text();
bookMessage[4] = dateBox2->currentText();
bookMessage[5] = typeBox2->currentText();
bookMessage[6] = authorLine2->text();

if(addBook()){
QMessageBox::about(0,"database","插入成功！");
}
else{
QMessageBox::critical(0,QObject::tr("error"),"插入失败");
}

//清空输入框
nameLine2->clear();
priceLine2->clear();
numLine2->clear();
publishLine2->clear();
authorLine2->clear();
}

/* 多册书籍入库（加载书籍信息） */
void database::mutiAddBook()
{
bool flag = true;
int count = 0;//统计书本数目

//检查用户输入是否完整
for(int i=0;i<13;i++){
bool hasValue = false;
bool isEmpty = false;
for(int j=0;j<7;j++){
if(j==4||j==5)continue;
else{
if(tablewidget3->item(i,j)->text().compare("")==0){
isEmpty = true;
}
else hasValue = true;
}
if(hasValue&&isEmpty){
QMessageBox::critical(NULL,"error","您的信息填写不完整");
return;
}
}
if(!isEmpty){
count++;
}
}

//将用户输入的信息暂存于数组中
for(int i=0;i<count;i++){
for(int j=0;j<7;j++){
if(j==4){
bookMessage[j] = publishDate[i]->currentText();
}
else if(j==5){
bookMessage[j] = bookType[i]->currentText();
}
else{
bookMessage[j] = tablewidget3->item(i,j)->text();
}
}
if(!addBook()){
flag = false;
QMessageBox::critical(NULL,"error","第" + QString::number(i+1) + "本书添加失败");
}
}
if(flag){
QMessageBox::about(NULL,"ok","插入成功");
//清空书本信息
for(int i=0;i<7;i++){
bookMessage[i].clear();
}
}
//对每一个表单，设置为空
for(int i = 0;i<13;i++){
for(int j = 0;j<7;j++){
if(j!=5&&j!=4){
tablewidget3->item(i,j)->setText("");
}
}
}
//继续加载文本信息（如果还有的话）
int max = multiBookMessage.length()<13?multiBookMessage.length():13;
for(int i=0;i<max;i++){
for(int j=0;j<7;j++){
if(j==4)publishDate[i]->setCurrentText(multiBookMessage.at(i)[j]);
else if(j==5)bookType[i]->setCurrentText(multiBookMessage.at(i)[j]);
else{
tablewidget3->item(i,j)->setText(multiBookMessage.at(i)[j]);
}
}
}

for(int i=0;i<max;i++){
multiBookMessage.pop_front();
}
}

/* 删除用户 */
void database::deleteUser()
{
QSqlQuery query;
//判断是否选中用户
bool flag = false;

//求出当前页面最多显示的用户
int max;
if(user_current_page==user_max_page){
max = (user_num%13==0)?13:user_num%13;
}
else max = 13;

//删除管理员选中的用户信息
for(int i=0;i<max;i++){
if(item0[i]->checkState() == Qt::Checked){
//如果用户有未归还的书籍，禁止删除
if(tablewidget1->item(i,4)->text().toInt()>0){
QMessageBox::critical(0,"error","该用户有未归还的书籍，不能删除！");
return;
}
flag = true;
query.exec("delete from user where username = '" +
item1[i]->text() + "'");
}
}
if(!flag){
QMessageBox::critical(0,"error","您尚未选择任何用户！");
return;
}
if(query.isActive()){
QMessageBox::about(0,"ok","删除成功");
}
else{
QMessageBox::critical(0,"error","删除失败");
}

//更新用户信息
loadUserMessage();
//更新用户管理窗口
updateManageWindow();
}

/* 授予借书权限*/
void database::grantLent()
{
//判断是否选中用户
bool flag = false;

//判断执行的操作是授权还是取消授权
int isGrant;
QSqlQuery query;

//求出当前页面最多显示的用户
int max;
if(user_current_page==user_max_page){
max = (user_num%13==0)?13:user_num%13;
}
else max = 13;

//根据用户当前借阅权限，执行授予借阅权限/取消借阅权限操作
for(int i=0;i<max;i++){
if(item0[i]->checkState() == Qt::Checked){
flag = true;
isGrant = tablewidget1->item(i,3)->text().toInt();

if(isGrant==0){
isGrant = true;
query.exec("update user set isLent = true where username = '" +
item1[i]->text() + "'");
}
else if(isGrant==1){
isGrant = false;
query.exec("update user set isLent = false where username = '" +
item1[i]->text() + "'");
}
}
}
if(!flag){
QMessageBox::critical(0,"error","您尚未选择任何用户！");
return;
}
if(query.isActive()){
if(isGrant){
QMessageBox::about(0,"ok","授权成功");
}
else{
QMessageBox::about(0,"ok","取消权限成功");
}
}
else{
if(isGrant){
QMessageBox::critical(0,"error","授权失败");
}
else{
QMessageBox::critical(0,"error","取消权限失败");
}
return;
}

//更新用户信息
loadUserMessage();
//更新用户管理窗口
updateManageWindow();
}

/* 归还书籍 */
void database::returnBook()
{
//判断是否选中书籍
bool flag = false;
QSqlQuery query,query1;

//执行归还操作
for(int i=0;i<loanMessage.length();i++){
if(item4[i]->checkState() == Qt::Checked){
flag = true;
query.exec("delete from loan where username = '" +
current_user + "' and book_id = '" +
loanMessage.at(i)[0] + "' and loan_number = " +
loanMessage.at(i)[3]);
query1.exec("update book set number = number + 1 where book_id = '"+
loanMessage.at(i)[0] + "'");
}
}
if(!flag){
QMessageBox::critical(0,"error","您尚未选中任何书目！");
return;
}
if(query.isActive()){
QMessageBox::about(NULL,"ok","归还成功！");
}
else{
QMessageBox::about(NULL,"error","归还失败");
return;
}
if(query1.isActive()){
QMessageBox::about(NULL,"ok","更新成功！");
}
else{
QMessageBox::about(NULL,"error","更新失败");
return;
}

//更新借书窗口
updateLoanBookWindow();
}

/* 借阅书籍 */
void database::lendBook()
{
//判断是否选中书籍
bool flag = false;
int max_num = 0;
QSqlQuery query,query1,query2;

//借书前判断用户是否具有借阅权限
query.exec("select isLent from user where username = '" + current_user + "'");

if(query.next()){
bool isLent = query.value(0).toBool();
if(!isLent){
QMessageBox::critical(0,"error","您不具有借书权限,需等待管理员添加!");
return;
}
}
else{
return;
}

//判断用户借阅的书籍是否达到最大书籍
query.exec("select count(*) from loan where username = '" +
current_user + "'");
if(query.next()){
int totalNum = query.value(0).toInt();
if(totalNum>=3){
QMessageBox::critical(0,"error","您的借书数目已达到限额（3本）！");
return;
}
}
else{
return;
}

//得到当前页码所能显示的最多书籍
int max;
if(current_page==max_page){
max = result.length()%100/10;
if(result.length()%100==0)max = 10;
}
else max = 10;
QDate d = QDate::currentDate();
QString date = d.toString("yyyy-MM-dd");

//根据用户选中的书籍插入相应借阅信息
for(int i=0;i<max;i++){
if(item2[i]->checkState() == Qt::Checked){
bool isMutiNum = false;
int num = 1;
flag = true;

//判断当前书本是否有库存
query.exec("select number from book where book_id = '" + item3[i]->text() + "'");
if(query.next()){
int num = query.value(0).toInt();
if(num==0){
QString str = item3[i]->text() + "暂无库存！";
QMessageBox::critical(NULL,"error",str);
}
}
else{
return;
}

//考虑到一本书可以被借多次，在这里进行特殊的处理
query.exec("select loan_number from loan where username ='" +
current_user + "' and book_id = '" + item3[i]->text()
+ "'" );
while(query.next()){
isMutiNum = true;
num = query.value(0).toInt();
if(num>max_num)max_num = num;
}
if(isMutiNum){
max_num++;
query1.exec("insert into loan values('" + current_user + "','" +
item3[i]->text() + "','" + date + "'," +
QString::number(max_num) + ")" );
}
else{
query1.exec("insert into loan values('" + current_user + "','" +
item3[i]->text() + "','" + date + "',1)" );
}
if(query1.isActive()){
query2.exec("update book set number = number - 1 where book_id = '" +
item3[i]->text() + "'");
}
}
}
if(!flag){
QMessageBox::critical(0,"error","您尚未选择任何书目！");
return;
}
if(query1.isActive()){
QMessageBox::about(0,"ok","借阅成功");

}
else{
QMessageBox::critical(0,"error","借阅失败");
return;
}

updateLoanBookWindow();
}

main.cpp

#include "database.h"
#include <QApplication>

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
database w;

return a.exec();
}