private string GetHasRightUserName(WxUserItem activeUser, Library lib)
{
string userName = "";
string strError = "";
// 查找当前微信用户绑定的工作人员账号
//WxUserItem user = WxUserDatabase.Current.GetWorker(weixinId, libId);
// todo 后面可以放开对读者的权限
if (activeUser != null &&
activeUser.type == WxUserDatabase.C_Type_Worker &&
activeUser.userName != WxUserDatabase.C_Public)
{
// 检索是否有权限 _wx_setHomePage
string needRight = dp2WeiXinService.C_Right_SetBb;
int nHasRights = dp2WeiXinService.Instance.CheckRights(activeUser,
lib.Entity,
needRight,
out strError);
if (nHasRights == -1)
{
dp2WeiXinService.Instance.WriteErrorLog("CheckRights()出错：" + strError);
userName = "";
}
if (nHasRights == 1)
{
userName = activeUser.userName;
}
else
{
userName = "";
}
}
return(userName);
}
public ActionResult Message(string code, string state)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Library/Message");
return(View());
}
// 获取消息
List <UserMessageItem> list = UserMessageDb.Current.GetByUserId(activeUser.weixinId);
return(View(list));
ERROR1:
ViewBag.Error = strError;
return(View());
}
// 书目查询主界面
public ActionResult Detail(string code, string state, string biblioPath)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Biblio/Detail");
return(View());
}
if (activeUser != null)
{
ViewBag.PatronBarcode = activeUser.readerBarcode;
}
ViewBag.BiblioPath = biblioPath;
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
/// <summary>
/// 绑定账户
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="returnUrl"></param>
/// <returns></returns>
public ActionResult Bind(string code, string state, string returnUrl, string from)
{
ViewBag.ReturnUrl = returnUrl;
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Accout/Bind");
return(View());
}
//// ｗｅｂ来源
//if (from == "web")
//{
// string weixinId = "temp";//这是时间还得用temp因为还没有登录成功，只是做一些初始化设置，后面 "~~" + guid; //2018/3/8
// // 初始化session
// state = "ilovelibrary";
// SessionInfo sessionInfo = null;
// nRet = this.InitSession(state, weixinId, out sessionInfo, out strError);
// if (nRet == -1)
// goto ERROR1;
// // 初始化 viewbag
// nRet = this.InitViewBag(sessionInfo, out strError);
// if (nRet == -1)
// goto ERROR1;
// ViewBag.fromUrl = "/Account/Bind?from=web";
// return View();
//}
//// 登录检查
//nRet = this.CheckLogin(code, state, out strError);
//if (nRet == -1 || nRet ==0)
//{
// goto ERROR1;
//}
ViewBag.fromUrl = "/Account/Bind";
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
public ApiResult ActivePatron(string weixinId, string id)
{
ApiResult result = new ApiResult();
string error = "";
if (HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo] == null)
{
error = "session失效。";
goto ERROR1;
}
SessionInfo sessionInfo = (SessionInfo)HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo];
if (sessionInfo == null)
{
error = "session失效2。";
goto ERROR1;
}
if (weixinId == "null")
{
weixinId = "";
}
if (id == "null")
{
id = "";
}
WxUserItem user = wxUserDb.GetById(id);
if (user == null)
{
error = "未找到" + id + "对应的绑定用户";
goto ERROR1;
}
//设为活动账户
WxUserDatabase.Current.SetActivePatron1(user.weixinId, user.id);
//更新session
int nRet = sessionInfo.Init1(weixinId, out error);
if (nRet == -1)
{
goto ERROR1;
}
return(result);// repo.Add(item);
ERROR1:
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
/// <summary>
/// 在借续借界面
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns></returns>
public ActionResult BorrowInfo()
{
string strError = "";
int nRet = 0;
SessionInfo sessionInfo = this.GetSessionInfo1();
if (sessionInfo == null)
{
strError = "session失效";
goto ERROR1;
}
nRet = this.InitViewBag(sessionInfo, out strError);
if (nRet == -1)
{
goto ERROR1;
}
WxUserItem activeUserItem = sessionInfo.Active;
if (activeUserItem == null || activeUserItem.type != WxUserDatabase.C_Type_Patron)
{
strError = "当前帐户不是读者帐户";
goto ERROR1;
}
ViewBag.patronBarcode = activeUserItem.readerBarcode;
string patronXml = "";
string recPath = "";
nRet = this.GetReaderXml(activeUserItem,
out patronXml,
out recPath,
out strError);
if (nRet == -1 || nRet == 0 || nRet == -2)
{
goto ERROR1;
}
string strWarningText = "";
string maxBorrowCountString = "";
string curBorrowCountString = "";
List <BorrowInfo2> overdueList = dp2WeiXinService.Instance.GetBorrowInfo(patronXml,
out strWarningText,
out maxBorrowCountString,
out curBorrowCountString);
ViewBag.maxBorrowCount = maxBorrowCountString;
ViewBag.curBorrowCount = curBorrowCountString;
return(View(overdueList));
ERROR1:
ViewBag.Error = strError;
return(View());
}
/// <summary>
///
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns>
/// -1 出错，或者非正常途径登录
/// -2 未绑定
/// -3 未设置默认账户
/// 0 未找到读者记录
/// 1 成功
/// </returns>
private int GetReaderXml(WxUserItem activeUser,
out string patronXml,
out string recPath,
out string strError)
{
patronXml = "";
strError = "";
recPath = "";
int nRet = 0;
if (activeUser == null)
{
strError = "activeUser参数不能为空";
return(-1);
}
if (activeUser.type != WxUserDatabase.C_Type_Patron)
{
strError = "当前活动需为读者帐号";
return(-1);
}
string libId = activeUser.libId;
string patronBarcode = activeUser.readerBarcode;
// 登录人是读者自己
string loginUserName = activeUser.readerBarcode;
bool isPatron = true;
// 获取读者记录
LoginInfo loginInfo = new LoginInfo(loginUserName, isPatron);
string timestamp = "";
nRet = dp2WeiXinService.Instance.GetPatronXml(libId,
loginInfo,
patronBarcode,
"advancexml", // 格式
out recPath,
out timestamp,
out patronXml,
out strError);
if (nRet == -1 || nRet == 0)
{
return(-1);
}
activeUser.recPath = recPath; // todo 应该在绑定的时候赋值，但绑定时没有返回路径
//todo1 要保存到数据库里
return(1);
}
public SetReaderInfoResult SetPatron(string libId,
string userName,
string opeType,
string recPath,
string timestamp,
string weixinId,
SimplePatron patron)
{
SetReaderInfoResult result = new SetReaderInfoResult();
string strError = "";
string outputRecPath = "";
string outputTimestamp = "";
WxUserItem userItem = null;
int nRet = dp2WeiXinService.Instance.SetReaderInfo(libId,
userName,
opeType,
recPath,
timestamp,
weixinId,
patron,
out outputRecPath,
out outputTimestamp,
out userItem,
out strError);
if (nRet == -1)
{
result.errorCode = -1;
result.errorInfo = strError;
return(result);
}
// 返回读者路径和时间戳
result.recPath = outputRecPath;
result.timestamp = outputTimestamp;
// 如果是读者自助注册过来的，需要把注册的这个帐户设置为当前帐户
// reregister不需要设置活动帐户，因为当前帐户就是他本身。
if (opeType == "register")
{
result.info = userItem.readerBarcode;
nRet = ApiHelper.ActiveUser(userItem, out strError);
if (nRet == -1)
{
result.errorInfo = strError;
return(result);
}
}
return(result);
}
public WxUserResult Bind(BindItem item)
{
string error = "";
dp2WeiXinService.Instance.WriteDebug("走进bind API");
if (item.bindLibraryCode == null)
{
item.bindLibraryCode = "";
}
// 返回对象
WxUserResult result = new WxUserResult();
// 前端有时传上来是这个值
if (item.prefix == "null")
{
item.prefix = "";
}
WxUserItem userItem = null;
int nRet = dp2WeiXinService.Instance.Bind(item.libId,
item.bindLibraryCode,
item.prefix,
item.word,
item.password,
item.weixinId,
out userItem,
out error);
if (nRet == -1)
{
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
result.users = new List <WxUserItem>();
result.users.Add(userItem);
// 将绑定的帐户设为当前帐户
nRet = ApiHelper.ActiveUser(userItem, out error);
if (nRet == -1)
{
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
return(result);
}
/// <summary>
/// 预约请求界面
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns></returns>
public ActionResult Reservation()
{
string strError = "";
int nRet = 0;
SessionInfo sessionInfo = this.GetSessionInfo1();
if (sessionInfo == null)
{
strError = "session失效";
goto ERROR1;
}
nRet = this.InitViewBag(sessionInfo, out strError);
if (nRet == -1)
{
goto ERROR1;
}
WxUserItem activeUserItem = sessionInfo.Active;
if (activeUserItem == null || activeUserItem.type != WxUserDatabase.C_Type_Patron)
{
strError = "当前帐户不是读者帐户";
goto ERROR1;
}
// 放到界面的变量
ViewBag.patronBarcode = activeUserItem.readerBarcode;
string patronXml = "";
string recPath = "";
nRet = this.GetReaderXml(activeUserItem,
out patronXml,
out recPath,
out strError);
if (nRet == -1 || nRet == 0 || nRet == -2)
{
goto ERROR1;
}
// 预约请求
string strReservationWarningText = "";
List <ReservationInfo> reservations = dp2WeiXinService.Instance.GetReservations(patronXml,
out strReservationWarningText);
return(View(reservations));
ERROR1:
ViewBag.Error = strError;
return(View());
}
/*
* // web登录
* public ActionResult WebLogin(string returnUrl)
* {
* ViewBag.ReturnUrl = returnUrl;
*
* string strError = "";
*
* //// 检查是否从微信入口进来
* //string strError = "";
* //string state = "ilovelibrary";
* //int nRet = this.CheckIsFromWeiXin("", state, out strError);
* //if (nRet == -1 && strError!="未登录1")
* // goto ERROR1;
*
*
*
* // 临时id
* //string guid = Guid.NewGuid().ToString();
* string weixinId = "temp" ;//这是时间还得用temp因为还没有登录成功，只是做一些初始化设置，后面 "~~" + guid; //2018/3/8
*
*
* // 初始化session
* string state = "ilovelibrary";
* SessionInfo sessionInfo = null;
* int nRet = this.InitSession(state, weixinId, out sessionInfo, out strError);
* if (nRet == -1)
* goto ERROR1;
*
* // 初始化 viewbag
* nRet = this.InitViewBag(sessionInfo, out strError);
* if (nRet == -1)
* goto ERROR1;
*
* return View();
*
*
* ERROR1:
* ViewBag.Error = strError;
* return View();
* }
*/
/// <summary>
/// 账户管理
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns></returns>
public ActionResult Index(string code, string state, string myWeixinId)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError,
myWeixinId);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Account/Index");
return(View());
}
//dp2WeiXinService.Instance.WriteLog1("Index页面，获取完当前对象。");
// 检查微信id是否已经绑定的读者
string weixinId = ViewBag.weixinId; //(string)Session[WeiXinConst.C_Session_WeiXinId];
//dp2WeiXinService.Instance.WriteLog1("Index页面，检查绑了" + userList.Count + "对象。");
if (activeUser.type == WxUserDatabase.C_Type_Worker && activeUser.userName == "public")
{
List <WxUserItem> userList = WxUserDatabase.Current.Get(weixinId, null, -1);
if (userList.Count > 1)
{
ViewBag.Warn = "您尚未绑定当前图书馆[" + ViewBag.LibName + "]的帐户，请点击'新增绑定账号'按钮绑定帐户。";
}
else
{
return(RedirectToAction("Bind"));
}
}
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
/// <summary>
/// 将帐户置为当前活动帐户，会被bind,读者注册功能调用
/// </summary>
/// <param name="userItem"></param>
/// <param name="error"></param>
/// <returns></returns>
public static int ActiveUser(WxUserItem userItem,
out string error)
{
error = "";
int nRet = 0;
if (HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo] == null)
{
error = "session失效。";
return(-1);
}
SessionInfo sessionInfo = (SessionInfo)HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo];
if (sessionInfo == null)
{
error = "session失效2。";
return(-1);
}
// 读者注册过来的，不可能为null
if (userItem == null)
{
error = "异常：userItem不能为null。";
return(-1);
}
if (sessionInfo.ActiveUser != null)
{
dp2WeiXinService.Instance.WriteDebug("原来session中的user对象id=[" + sessionInfo.ActiveUser.id + "],weixinid=[" + sessionInfo.WeixinId + "]");
}
else
{
dp2WeiXinService.Instance.WriteDebug("原来session中无user对象");
}
// 置为活动状态 2020-3-1,改在外面函数设，不再SaveUserToLocal函数里
WxUserDatabase.Current.SetActivePatron1(userItem.weixinId, userItem.id);
// 更新session的activeUser
nRet = sessionInfo.GetActiveUser(userItem.weixinId, out error);
if (nRet == -1)
{
return(-1);
}
return(0);
}
/// <summary>
/// 修改密码
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="patronBarcode"></param>
/// <returns></returns>
public ActionResult ChangePassword(string code, string state, string patronBarcode)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Account/ChangePassword");
return(View());
}
if (String.IsNullOrEmpty(patronBarcode) == true)
{
string weixinId = ViewBag.weixinId; //(string)Session[WeiXinConst.C_Session_WeiXinId];
WxUserItem userItem = WxUserDatabase.Current.GetActive(weixinId);
if (userItem.type == WxUserDatabase.C_Type_Worker)
{
strError = "当前用户不可能是工作人员";
goto ERROR1;
}
if (userItem != null)
{
patronBarcode = userItem.readerBarcode;
}
}
ViewBag.patronBarcode = patronBarcode;
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
public ApiResult UpdateUserInfo(string userId, string infoType)
{
ApiResult result = new ApiResult();
string error = "";
if (infoType == "libName")
{
WxUserItem user = WxUserDatabase.Current.GetById(userId);
LibEntity lib = LibDatabase.Current.GetLibById1(user.libId);
user.libName = lib.libName;
user.libraryCode = "";
user.bindLibraryCode = "";
WxUserDatabase.Current.Update(user);
}
return(result);
}
public ApiResult Setting(string weixinId, WxUserItem input)
{
ApiResult result = new ApiResult();
string error = "";
// 更新session信息???
if (HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo] == null)
{
error = "session失效。";
goto ERROR1;
}
SessionInfo sessionInfo = (SessionInfo)HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo];
if (sessionInfo == null)
{
error = "session失效2。";
goto ERROR1;
}
if (sessionInfo.Active == null)
{
error = "session中没有活动帐号，不可能的情况";
goto ERROR1;
}
//sessionInfo.Active.libraryCode = input.libraryCode;
sessionInfo.Active.showCover = input.showCover;
sessionInfo.Active.showPhoto = input.showPhoto;
WxUserDatabase.Current.Update(sessionInfo.Active);
return(result);
ERROR1:
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
// 柜台绑定
public ActionResult ScanQRCodeBind(string code, string state,
string libId)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Accout/ScanQRCodeBind");
return(View());
}
if (libId == null)
{
libId = "";
}
// 图书馆html
string weixinId = ViewBag.weixinId; //(string)Session[WeiXinConst.C_Session_WeiXinId];
ViewBag.LibVersions = dp2WeiXinService.Instance.LibManager.GetLibVersiongString();
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
// 资源
public ActionResult GetObject(string code, string state, string libId, string uri)
{
string strError = "";
int nRet = 0;
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1 && ViewBag.LibState != LibraryManager.C_State_Hangup)
{
goto ERROR1;
}
//处理 dp2 系统外部的 URL
Uri tempUri = dp2WeiXinService.GetUri(uri);
if (tempUri != null &&
(tempUri.Scheme == "http" || tempUri.Scheme == "https"))
{
return(Redirect(uri));
}
string weixinId = ViewBag.weixinId;
nRet = dp2WeiXinService.GetObject0(this, libId, weixinId, uri, out strError);
if (nRet == -1)
{
goto ERROR1;
}
return(null);
ERROR1:
MemoryStream ms = dp2WeiXinService.Instance.GetErrorImg(strError);
return(File(ms.ToArray(), "image/jpeg"));
}
public ApiResult Delete(string id)
{
ApiResult result = new ApiResult();
string error = "";
WxUserItem newActiveUser = null;
int nRet = dp2WeiXinService.Instance.Unbind(id,
out newActiveUser,
out error);
if (nRet == -1)
{
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
// 由于有错误信息的话，把错误信息输出
if (String.IsNullOrEmpty(error) == false)
{
result.errorInfo = error;
}
// 设置当前活动帐户，更新session信息
if (newActiveUser != null) //如果当前删除不是活动帐户，则返回的newActiveUser为null
{
nRet = ApiHelper.ActiveUser(newActiveUser, out error);
if (nRet == -1)
{
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
}
return(result);
}
public ActionResult SelectLib(string code, string state, string returnUrl)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1 && ViewBag.LibState != LibraryManager.C_State_Hangup)
{
goto ERROR1;
}
SessionInfo sessionInfo = this.GetSessionInfo1();
ViewBag.returnUrl = returnUrl;
// 2017-10-1 只列出可访问的图书馆
List <Library> avaiblelibList = dp2WeiXinService.Instance.LibManager.GetLibraryByIds(sessionInfo.libIds);
// 绑定的帐户
List <WxUserItem> list = WxUserDatabase.Current.Get(sessionInfo.WeixinId, null, -1);
// 可显示的域区
List <Area> areaList = new List <Area>();
foreach (Area area in dp2WeiXinService.Instance.areaMgr.areas)
{
//area.visible = true;
//int disVisibleCout = 0;
List <libModel> libList = new List <libModel>();
foreach (libModel lib in area.libs)
{
// lib.visible = true;
lib.Checked = "";
lib.bindFlag = "";
// 如果是到期的图书馆，不显示出来
Library thisLib = dp2WeiXinService.Instance.LibManager.GetLibrary(lib.libId);//.GetLibById(lib.libId);
if (thisLib != null && thisLib.Entity.state == "到期")
{
//lib.visible = false;
//disVisibleCout++;
continue;
}
//如果不在可访问范围，不显示
if (thisLib != null && avaiblelibList.IndexOf(thisLib) == -1)
{
//lib.visible = false;
//disVisibleCout++;
continue;
}
libList.Add(lib);
//
if (this.CheckIsBind(list, lib) == true) //libs.Contains(lib.libId)
{
lib.bindFlag = " * ";
}
if (sessionInfo.Active != null)
{
if (lib.libId == sessionInfo.Active.libId &&
lib.libraryCode == sessionInfo.Active.bindLibraryCode)
{
lib.Checked = " checked ";
}
}
}
// 如果下级图书馆都是到期状态，则地址不显示
//if (disVisibleCout == area.libs.Count)
//{
// area.visible = false;
//}
if (libList.Count > 0)
{
Area newArea = new Area();
newArea.name = area.name;
newArea.libs = libList;
areaList.Add(newArea);
}
}
ViewBag.areaList = areaList;// dp2WeiXinService.Instance.areaMgr.areas;
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
// 书目查询主界面
public ActionResult Index(string code, string state)
{
// 登录检查
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Biblio/Index?a=1");// ("书目查询", "/Biblio/Index?a=1", lib.libName);
return(View());
}
// nRet = this.CheckLogin(code, state, out strError);
//if (nRet == -1)
//{
// goto ERROR1;
//}
//if (nRet == 0)
//{
// return Redirect("~/Account/Bind?from=web");
//}
// 如果当前图书馆是不公开书目，则出现提示
LibEntity lib = dp2WeiXinService.Instance.GetLibById(ViewBag.LibId);
if (lib == null)
{
strError = "未设置当前图书馆。";
goto ERROR1;
}
string weixinId = ViewBag.weixinId; // (string)Session[WeiXinConst.C_Session_WeiXinId];
if (lib.noShareBiblio == 1)
{
List <WxUserItem> users = WxUserDatabase.Current.Get(weixinId, lib.id, -1);
if (users.Count == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetLinkHtml("书目查询", "/Biblio/Index?a=1", lib.libName);
return(View());
}
}
WxUserItem userItem1 = WxUserDatabase.Current.GetActive(weixinId);
if (userItem1 != null)
{
ViewBag.PatronBarcode = userItem1.readerBarcode;
}
string match = lib.match;
if (String.IsNullOrEmpty(match) == true)
{
match = "left";
}
ViewBag.Match = match;
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
public ApiResult SetLibId(string weixinId, string libId)
{
ApiResult result = new ApiResult();
string error = "";
string temp = libId;
string bindLibraryCode = "";
int nIndex = libId.IndexOf("~");
if (nIndex > 0)
{
libId = temp.Substring(0, nIndex);
bindLibraryCode = temp.Substring(nIndex + 1);
}
if (HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo] == null)
{
error = "session失效。";
goto ERROR1;
}
SessionInfo sessionInfo = (SessionInfo)HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo];
if (sessionInfo == null)
{
error = "session失效2。";
goto ERROR1;
}
//如果选择的图书馆就是是当前活动帐户对应的图书馆，则不用处理
if (sessionInfo.Active != null &&
sessionInfo.Active.libId == libId &&
sessionInfo.Active.bindLibraryCode == bindLibraryCode)
{
return(result);
}
// 如果微信用户已经绑定了该图书馆的帐户，则设这个馆第一个帐户为活动帐户
WxUserItem user = null;
List <WxUserItem> list = WxUserDatabase.Current.Get(weixinId, libId, -1); //注意这里不区分分馆,在下面还是要看分馆
if (list.Count > 0)
{
List <WxUserItem> foundList = new List <WxUserItem>();
foreach (WxUserItem u in list)
{
if (u.bindLibraryCode == bindLibraryCode)
{
user = u;
break;
}
}
}
if (user == null) // 绑public身份创建一个帐号
{
// 先看看有没有public的,有的话，用绑定的实际帐号替换
//注意这里不过滤图书馆，就是说临时选择的图书馆，如果未绑定正式帐户，则会被新选择的图书馆public帐户代替
List <WxUserItem> publicList = WxUserDatabase.Current.GetWorkers(weixinId, "", "public");
if (publicList.Count > 0)
{
user = publicList[0];
if (publicList.Count > 1)
{
dp2WeiXinService.Instance.WriteLog1("!!!异常：出现" + publicList.Count + "个public帐户?应该只有一个，把多余的帐户删除");
for (int i = 1; i < publicList.Count; i++)
{
WxUserDatabase.Current.SimpleDelete(publicList[i].id);
}
}
user.libId = libId;
Library lib = dp2WeiXinService.Instance.LibManager.GetLibrary(libId);
if (lib == null)
{
error = "未找到id=" + libId + "对应的图书馆";
goto ERROR1;
}
user.libName = lib.Entity.libName;
user.bindLibraryCode = bindLibraryCode;
if (string.IsNullOrEmpty(user.bindLibraryCode) == false)
{
user.libName = user.bindLibraryCode;
}
user.libraryCode = "";
WxUserDatabase.Current.Update(user);
}
else
{
try
{
user = WxUserDatabase.Current.CreatePublic(weixinId, libId, bindLibraryCode);
}
catch (Exception ex)
{
error = ex.Message;
goto ERROR1;
}
}
}
// 设为当前帐户
WxUserDatabase.Current.SetActivePatron1(user.weixinId, user.id);
// 初始化sesson
int nRet = sessionInfo.Init1(user.weixinId, out error);
if (nRet == -1)
{
goto ERROR1;
}
//===================
return(result);
ERROR1:
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
public WxUserResult Bind(BindItem item)
{
string error = "";
dp2WeiXinService.Instance.WriteLog1("!!!走进bind API");
if (item.bindLibraryCode == null)
{
item.bindLibraryCode = "";
}
// 返回对象
WxUserResult result = new WxUserResult();
if (HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo] == null)
{
error = "session失效。";
goto ERROR1;
}
SessionInfo sessionInfo = (SessionInfo)HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo];
if (sessionInfo == null)
{
error = "session失效2。";
goto ERROR1;
}
// 前端有时传上来是这个值
if (item.prefix == "null")
{
item.prefix = "";
}
WxUserItem userItem = null;
int nRet = dp2WeiXinService.Instance.Bind(item.libId,
item.bindLibraryCode,
item.prefix,
item.word,
item.password,
item.weixinId,
out userItem,
out error);
if (nRet == -1)
{
goto ERROR1;
}
result.users = new List <WxUserItem>();
result.users.Add(userItem);
if (sessionInfo.Active != null)
{
dp2WeiXinService.Instance.WriteLog1("原来session中的user对象id=[" + sessionInfo.Active.id + "],weixinid=[" + sessionInfo.WeixinId + "]");
}
else
{
dp2WeiXinService.Instance.WriteLog1("原来session中无user对象");
}
dp2WeiXinService.Instance.WriteUserInfo(item.weixinId, "bind返回后");
//更新session信息
nRet = sessionInfo.Init1(item.weixinId, out error);
if (nRet == -1)
{
goto ERROR1;
}
dp2WeiXinService.Instance.WriteUserInfo(item.weixinId, "session.init后");
return(result);
ERROR1:
result.errorCode = -1;
result.errorInfo = error;
return(result);
}
/// <summary>
/// 我的信息主界面
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns></returns>
public ActionResult PersonalInfo(string code, string state)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Patron/PersonalInfo");
return(View());
}
if (activeUser != null && activeUser.type != WxUserDatabase.C_Type_Patron)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetLinkHtml("我的信息", "/Patron/PersonalInfo");
return(View());
}
string patronXml = "";
string recPath = "";
nRet = this.GetReaderXml(activeUser,
out patronXml,
out recPath,
out strError);
if (nRet == -1 || nRet == 0)
{
goto ERROR1;
}
//ViewBag.userName = loginUserName;
//ViewBag.patronBarcode = patronBarcode;
ViewBag.overdueUrl = "../Patron/OverdueInfo";
ViewBag.borrowUrl = "../Patron/BorrowInfo";
ViewBag.reservationUrl = "../Patron/Reservation";
string libId = ViewBag.LibId;
Patron patron = null;
patron = dp2WeiXinService.Instance.ParsePatronXml(libId,
patronXml,
recPath,
ViewBag.showPhoto);
return(View(patron));
ERROR1:
ViewBag.Error = strError;
return(View());
}
// PUT api/<controller>/5
public long Put(WxUserItem item)
{
return(repo.Update(item));
}
/// <summary>
/// 获取当前帐号
/// </summary>
/// <param name="state"></param>
/// <param name="code"></param>
/// <param name="browseId"></param>
/// <param name="strError"></param>
/// <returns></returns>
public int GetActive(string code,
string state,
out WxUserItem activeUser,
out string strError,
string myWeixinId = "")
{
strError = "";
int nRet = 0;
activeUser = null;
// 获取session对象，如果不存在新new一个
SessionInfo sessionInfo = this.GetSessionInfo1();
try
{
if (sessionInfo != null)
{
//sessionInfo.ClearDebugInfo();
}
else
{
// 当发现session为空时，new一个sessioninfo
sessionInfo = new SessionInfo();
sessionInfo.AddDebugInfo("session不存在，新建一个session对象");
Session[WeiXinConst.C_Session_sessioninfo] = sessionInfo;
// 得到weixinid
GzhCfg gzh1 = sessionInfo.gzh;
List <string> libList1 = new List <string>();
if (string.IsNullOrEmpty(state) == true)
{
if (string.IsNullOrEmpty(code) == false)
{
strError = "从微信入口进来，code参数不能为空";
return(-1);
}
state = "ilovelibrary";
}
sessionInfo.AddDebugInfo("给sesion存入state[" + state + "]");
nRet = dp2WeiXinService.Instance.GetGzhAndLibs(state,
out gzh1,
out libList1,
out strError);
if (nRet == -1)
{
return(-1);
}
if (gzh1 == null)
{
strError = "异常，未得到公众号配置信息";
goto ERROR1;
}
sessionInfo.SetInfo(state, gzh1, libList1);
}
sessionInfo.AddDebugInfo("~~~~~~" + this.Request.Path + "~~~~~~");
// 如果客户端特别传来了weixinid，使用传来的weixinid
if (string.IsNullOrEmpty(myWeixinId) == false &&
sessionInfo.WeixinId != myWeixinId)
{
sessionInfo.AddDebugInfo("原来的weixinid=" + sessionInfo.WeixinId);
sessionInfo.WeixinId = myWeixinId;
sessionInfo.Active = null;
sessionInfo.AddDebugInfo("使用传进来的weixinId=" + myWeixinId);
}
if (code == null)
{
code = "";
}
if (state == null)
{
state = "";
}
if (sessionInfo.WeixinId == null)
{
sessionInfo.WeixinId = "";
}
sessionInfo.AddDebugInfo("走进GetActive(),code=[" + code + "] state=[" + state + "],session.weixinId=[" + sessionInfo.WeixinId + "]");
activeUser = sessionInfo.Active;
if (activeUser != null)
{
sessionInfo.AddDebugInfo("session中有活动帐号");
if (activeUser.weixinId.Substring(0, 2) == "~~" &&
string.IsNullOrEmpty(code) == false)
{
strError = "异常：微信入口怎么是临时ID";
goto ERROR1;
}
if (string.IsNullOrEmpty(state) == false && //传进来的state不为空
sessionInfo.gzhState != state)
{
sessionInfo.AddDebugInfo("发现之前state为[" + sessionInfo.gzhState + "]，目前传入的state参数为[" + state + "],两者不一样，重新初始化session信息");
sessionInfo.AddDebugInfo("传入的code为[" + code + "]，有值，重新获取weixinId");
sessionInfo.WeixinId = "";
sessionInfo.Active = null;
}
else
{
sessionInfo.AddDebugInfo("使用当前已有session信息");
// 初始化 viewbag
nRet = this.InitViewBag(sessionInfo, out strError);
if (nRet == -1)
{
goto ERROR1;
}
sessionInfo.AddDebugInfo("GetActive()返回1,当前有活动帐号");
return(1);
}
}
// 得到weixinid
GzhCfg gzh = sessionInfo.gzh;
List <string> libList = new List <string>();
if (string.IsNullOrEmpty(state) == true)
{
if (string.IsNullOrEmpty(code) == false)
{
strError = "从微信入口进来，code参数不能为空";
return(-1);
}
state = "ilovelibrary";
}
sessionInfo.AddDebugInfo("给sesion存入state[" + state + "]");
nRet = dp2WeiXinService.Instance.GetGzhAndLibs(state,
out gzh,
out libList,
out strError);
if (nRet == -1)
{
return(-1);
}
if (gzh == null)
{
strError = "异常，未得到公众号配置信息";
goto ERROR1;
}
sessionInfo.SetInfo(state, gzh, libList);
sessionInfo.AddDebugInfo("配置信息存到session");
string weixinId = sessionInfo.WeixinId;
if (string.IsNullOrEmpty(weixinId) == false &&
weixinId.Length > 2 &&
weixinId.Substring(0, 2) == "~~" &&
string.IsNullOrEmpty(code) == false)
{
sessionInfo.AddDebugInfo("异常：发现微信入口是临时ID，根据code重新获取id");
weixinId = "";
}
// 正式id
if (string.IsNullOrEmpty(weixinId) == false)
{
sessionInfo.AddDebugInfo("session中已有id=[" + weixinId + "],直接使用该id初始化对象");
}
else
{
//微信入口
if (string.IsNullOrEmpty(code) == false)
{
// 正式微信id的情况
sessionInfo.AddDebugInfo("微信入口，根据微信code=[" + code + "]获取weixinId");
// 根据微信接口得到weixinid
nRet = dp2WeiXinService.Instance.GetWeiXinId1(code,
gzh,
out weixinId,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (String.IsNullOrEmpty(weixinId) == true)
{
strError = "异常，未得到微信id";
return(-1);
}
sessionInfo.oauth2_return_code = code;
sessionInfo.AddDebugInfo("根据微信code获到的weixinId=[" + weixinId + "]");
// 写到微信浏览器的cookies里，以解决微信不退出，但web页面失效的问题
HttpCookie aCookie = new HttpCookie("browseId");
aCookie.Value = weixinId;
aCookie.Expires = DateTime.MaxValue;//设为永久不失效， DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);
sessionInfo.AddDebugInfo("将微信入口的weixinid写入微信浏览器的cookies=" + weixinId);
}
else
{
// 浏览器id
sessionInfo.AddDebugInfo("session中weixinid为空，且没有微信传来的code");
sessionInfo.AddDebugInfo("检查浏览器是否存在cookies");
string browseId = "";
if (Request.Cookies["browseId"] != null)
{
HttpCookie aCookie = Request.Cookies["browseId"];
browseId = aCookie.Value;
sessionInfo.AddDebugInfo("存在cookies=" + browseId);
}
if (string.IsNullOrEmpty(browseId) == true)
{
sessionInfo.AddDebugInfo("不存在cookies或值为空");
string guid = Guid.NewGuid().ToString();
browseId = "~~" + guid;
sessionInfo.AddDebugInfo("创建一个临时id=" + browseId);
// 写到cookies
HttpCookie aCookie = new HttpCookie("browseId");
aCookie.Value = browseId;
aCookie.Expires = DateTime.MaxValue;//设为永久不失效， DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);
sessionInfo.AddDebugInfo("将临时id写入cookies=" + browseId);
}
weixinId = browseId;
}
}
// 初始化session
nRet = sessionInfo.Init1(weixinId, out strError);// this.InitSession(state, weixinId, out sessionInfo, out strError);
if (nRet == -1)
{
return(-1);
}
// 有当前帐号
activeUser = sessionInfo.Active;
if (activeUser != null)
{
// 初始化 viewbag
nRet = this.InitViewBag(sessionInfo, out strError);
if (nRet == -1)
{
goto ERROR1;
}
sessionInfo.AddDebugInfo("GetActive()返回1,存在活动帐户");
return(1);
}
ViewBag.AppName = sessionInfo.gzh.appNameCN;
ViewBag.weixinId = sessionInfo.WeixinId;
}
catch (Exception ex)
{
strError = ex.Message;
goto ERROR1;
}
strError = "尚未选择图书馆";
sessionInfo.AddDebugInfo("GetActive()返回0,error=[" + strError + "]");
return(0);
ERROR1:
sessionInfo.AddDebugInfo("GetActive()返回-1,error=[" + strError + "]");
return(-1);
}
public ActionResult Setting(string code, string state, string returnUrl)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Patron/Setting");
return(View());
}
string weixinId = ViewBag.weixinId; //(string)Session[WeiXinConst.C_Session_WeiXinId];
ViewBag.returnUrl = returnUrl;
string photoChecked = "";
if (ViewBag.showPhoto == 1)
{
photoChecked = " checked='checked' ";
}
ViewBag.photoChecked = photoChecked;
string coverChecked = "";
if (ViewBag.showCover == 1)
{
coverChecked = " checked='checked' ";
}
ViewBag.coverChecked = coverChecked;
// 检查是否绑定工作人员，决定界面上是否出现 打开监控功能
ViewBag.info = "监控本馆消息";
string tracingChecked = "";
string maskChecked = "";
if (activeUser == null)
{
strError = "当前活动帐号不存在";
goto ERROR1;
}
if (activeUser.type == WxUserDatabase.C_Type_Worker && activeUser.userName != "public")
{
ViewBag.workerId = activeUser.id;
if (activeUser.tracing == "on" || activeUser.tracing == "on -mask")
{
tracingChecked = " checked='checked' ";
maskChecked = " checked='checked' ";
if (activeUser.tracing == "on -mask")
{
maskChecked = " ";
}
}
}
ViewBag.tracingChecked = tracingChecked;
ViewBag.maskChecked = maskChecked;
if (ViewBag.LibName == "[" + WeiXinConst.C_Dp2003LibName + "]")
{
ViewBag.info = "监控所有图书馆的消息";
}
ViewBag.subLibGray = "";
// 未绑定帐户 ，todo 普通读者一样可选择关注馆藏地
if (activeUser == null ||
activeUser.userName == "public")
//|| (activeUser.type==WxUserDatabase.C_Type_Worker && activeUser.userName=="public")
//|| (activeUser.type==WxUserDatabase.C_Type_Patron && activeUser.rights.Contains("borrow") == false && activeUser.rights.Contains("return") == false))
{
//string bindUrl = "/Account/Bind?returnUrl=" + HttpUtility.UrlEncode(returnUrl);
//string bindLink = "<a href='javascript:void(0)' onclick='gotoUrl(\"" + bindUrl + "\")'>尚未绑定帐户</a>。";
//ViewBag.bindLink = bindLink;
ViewBag.subLibGray = "color:#cccccc";
return(View());
}
string accountInfo = "";
if (activeUser.type == WxUserDatabase.C_Type_Worker)
{
accountInfo = "帐号:" + activeUser.userName;
}
else
{
accountInfo = "读者:" + activeUser.readerBarcode;
}
if (accountInfo != "")
{
accountInfo = "(" + accountInfo + ")";
}
ViewBag.accountInfo = accountInfo;
ViewBag.userId = activeUser.id;
string locationXml = activeUser.location;
if (String.IsNullOrEmpty(activeUser.location) == true &&
activeUser.userName != "public")
{
// 从dp2服务器获取
nRet = dp2WeiXinService.Instance.GetLocation(ViewBag.LibId,
activeUser,
out locationXml,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
//保存到微信用户库
activeUser.location = locationXml;
WxUserDatabase.Current.Update(activeUser);
}
// 解析本帐户拥有的全部馆藏地
List <SubLib> subLibs = SubLib.ParseSubLib(locationXml, true);
//上次选中的打上勾
if (String.IsNullOrEmpty(activeUser.selLocation) == false)
{
string selLocation = SubLib.ParseToSplitByComma(activeUser.selLocation);
if (selLocation != "")
{
string[] selLocList = selLocation.Split(new char[] { ',' });
foreach (SubLib subLib in subLibs)
{
foreach (Location loc in subLib.Locations)
{
string locPath = subLib.libCode + "/" + loc.Name;
if (selLocList.Contains(locPath) == true)
{
subLib.Checked = "checked";
loc.Checked = "checked";
}
}
}
}
// end
}
// todo 其实，可以用一个字段来表示馆藏地和选中的项，就量在xml的字段中加checked属性，
// 但如果服务器更新了，刷的时候就全部覆盖了。
// 现在还没做到服务器更新后，自动刷过来
ViewBag.libList = subLibs;
ViewBag.verifyBarcode = "";
if (activeUser != null && activeUser.verifyBarcode == 1)
{
ViewBag.verifyBarcode = "checked";
}
ViewBag.audioType = 1;
if (activeUser != null && activeUser.audioType > 0)
{
ViewBag.audioType = activeUser.audioType;
}
return(View());
ERROR1:
ViewBag.Error = strError;
return(View());
}
// 二维码
public ActionResult QRcode(string code, string state)
{
string strError = "";
int nRet = 0;
// 检查当前是否已经选择了图书馆绑定了帐号
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
if (nRet == 0)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetSelLibLink(state, "/Patron/QRcode");
return(View());
}
if (activeUser != null && activeUser.type != WxUserDatabase.C_Type_Patron)
{
ViewBag.RedirectInfo = dp2WeiXinService.GetLinkHtml("二维码", "/Patron/QRcode");
return(View());
}
string strXml = "";
string patronBarcode = "";
string recPath = "";
nRet = this.GetReaderXml(activeUser,
out strXml,
out recPath,
out strError);
if (nRet == -1)
{
goto ERROR1;
}
// 如果图书馆是挂起状态，作为警告
string libId = activeUser.libId;
Library lib = dp2WeiXinService.Instance.LibManager.GetLibrary(libId);
string warn = LibraryManager.GetLibHungWarn(lib);
ViewBag.Warn = warn;
string qrcodeUrl = "";
if (String.IsNullOrEmpty(warn) == true)
{
qrcodeUrl = "./getphoto?libId=" + HttpUtility.UrlEncode(libId)
+ "&type=pqri"
+ "&barcode=" + HttpUtility.UrlEncode(activeUser.readerBarcode);
//+ "&width=400&height=400";
}
ViewBag.qrcodeUrl = qrcodeUrl;
return(View(activeUser));
ERROR1:
ViewBag.Error = strError;
return(View());
}
// 图片
public ActionResult GetPhoto(string code, string state, string libId, string type, string barcode, string objectPath)
{
MemoryStream ms = new MemoryStream();;
string strError = "";
int nRet = 0;
WxUserItem activeUser = null;
nRet = this.GetActive(code, state,
out activeUser,
out strError);
if (nRet == -1 && ViewBag.LibState != LibraryManager.C_State_Hangup)
{
goto ERROR1;
}
// 读者二维码
if (type == "pqri")
{
// 设置媒体类型
Response.ContentType = "image/jpeg";
// 获得读者证号二维码字符串
string strCode = "";
nRet = dp2WeiXinService.Instance.GetQRcode(libId,
barcode,
out strCode,
out strError);
if (nRet == -1 || nRet == 0)
{
goto ERROR1;
}
// 获得二维码图片
string strWidth = Request.QueryString["width"];
string strHeight = Request.QueryString["height"];
int nWidth = 0;
if (string.IsNullOrEmpty(strWidth) == false)
{
if (Int32.TryParse(strWidth, out nWidth) == false)
{
strError = "width 参数 '" + strWidth + "' 格式不合法";
goto ERROR1;
}
}
int nHeight = 0;
if (string.IsNullOrEmpty(strHeight) == false)
{
if (Int32.TryParse(strHeight, out nHeight) == false)
{
strError = "height 参数 '" + strHeight + "' 格式不合法";
goto ERROR1;
}
}
dp2WeiXinService.Instance.GetQrImage(strCode,
nWidth,
nHeight,
Response.OutputStream,
out strError);
if (strError != "")
{
goto ERROR1;
}
return(null);
}
// 取头像 或 封面
string weixinId = ViewBag.weixinId;
nRet = dp2WeiXinService.GetObject0(this, libId, weixinId, objectPath, out strError);
if (nRet == -1)
{
goto ERROR1;
}
return(null);
ERROR1:
ms = dp2WeiXinService.Instance.GetErrorImg(strError);
return(File(ms.ToArray(), "image/jpeg"));
}
/// <summary>
///
/// </summary>
/// <param name="weixinId"></param>
/// <param name="libId"></param>
/// <param name="msgId"></param>
/// <param name="style">browse/full</param>
/// <returns></returns>
public WxMessageResult GetMessage(string weixinId,
string group,
string libId,
string msgId,
string subject,
string style)
{
WxMessageResult result = new WxMessageResult();
string strError = "";
strError = dp2WeiXinService.checkGroup(group);
if (strError != "")
{
result.errorInfo = strError;
result.errorCode = -1;
return(result);
}
if (HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo] == null)
{
result.errorInfo = "session失效。";
result.errorCode = -1;
return(result);
}
SessionInfo sessionInfo = (SessionInfo)HttpContext.Current.Session[WeiXinConst.C_Session_sessioninfo];
if (sessionInfo == null)
{
result.errorInfo = "session失效2。";
result.errorCode = -1;
return(result);
}
// 检查下有无绑定工作人员账号
result.userName = "";
string userName = "";
string libraryCode = "";
if (string.IsNullOrEmpty(weixinId) == false)
{
// 查找当前微信用户绑定的工作人员账号
WxUserItem user = sessionInfo.Active; //WxUserDatabase.Current.GetWorker(weixinId, libId);
if (user != null)
{
libraryCode = user.bindLibraryCode;
// 检索是否有权限 _wx_setbbj
string needRight = dp2WeiXinService.GetNeedRight(group);
LibEntity lib = dp2WeiXinService.Instance.GetLibById(libId);
if (lib == null)
{
result.errorInfo = "未找到id为[" + libId + "]的图书馆定义。";
result.errorCode = -1;
return(result);
}
int nHasRights = dp2WeiXinService.Instance.CheckRights(user,
lib,
needRight,
out strError);
if (nHasRights == -1)
{
result.errorInfo = strError;
result.errorCode = -1;
return(result);
}
if (nHasRights == 1)
{
userName = user.userName;
}
else
{
userName = "";
}
}
}
result.userName = userName;
List <MessageItem> list = null;
int nRet = dp2WeiXinService.Instance.GetMessage(group,
libId + "/" + libraryCode,
msgId,
subject,
style,
out list,
out strError);
if (nRet == -1)
{
result.errorCode = -1;
result.errorInfo = strError;
}
result.items = list;
result.errorCode = nRet;
result.errorInfo = strError;
return(result);
}
/// <summary>
/// 绑定
/// </summary>
/// <param name="strParam"></param>
/// <returns></returns>
private bool DoBinding(string strParam)
{
// 设置当前命令
this.CurrentCmdName = dp2CommandUtility.C_Command_Binding;
if (strParam == "")
{
Console.WriteLine("请输入'读者证条码号'（注:您也可以同时输入'读者证条码号'和'密码'，中间以/分隔，例如:R0000001/123）。");
return(false);
}
// 看看上一次输入过用户名的没有？如果已存在用户名，那么这次输入的就是密码
BindingCommand bindingCmd = (BindingCommand)this.CmdContiner.GetCommand(dp2CommandUtility.C_Command_Binding);
string readerBarcode = strParam;
int nTempIndex = strParam.IndexOf('/');
if (nTempIndex > 0) // 同时输入读者证条码与密码
{
bindingCmd.ReaderBarcode = strParam.Substring(0, nTempIndex);
bindingCmd.Password = strParam.Substring(nTempIndex + 1);
}
else
{
// 看看上一次输入过用户名的没有？如果已存在用户名，那么这次输入的就是密码
if (bindingCmd.ReaderBarcode == "")
{
bindingCmd.ReaderBarcode = strParam;
Console.WriteLine("读输入密码");
return(false);
}
else
{
bindingCmd.Password = strParam;
}
}
string strReaderBarcode = "";
string strError = "";
WxUserItem userItem = null;
long lRet = dp2CommandService.Instance.
Bind("", "", bindingCmd.ReaderBarcode,
bindingCmd.Password,
this.WeiXinId,
out userItem,
out strReaderBarcode,
out strError);
if (lRet == -1)
{
Console.WriteLine(strError);
return(false);
}
// 把用户名与密码清掉，以便再绑其它账号
bindingCmd.ReaderBarcode = "";
bindingCmd.Password = "";
// 设到当前读者变量上
this.ReaderBarcode = strReaderBarcode;
Console.WriteLine("绑定成功!");
return(false);
}
