public void SendMessage(string content, int comment_ID, int comment_user)
{
MonkeyDBEntities blog = new MonkeyDBEntities();
//向数据库添加信息
string dtime = DateTime.Now.ToString();
string dttime_two = dtime.Substring(dtime.LastIndexOf(" ") + 1);
Comment comm_Window_Insert = new Comment()
{
Comment_Time = Convert.ToDateTime(dttime_two),
Comment_Content = content,
Parent_Comment_Id = comment_ID,
Comment_User = comment_user,
ULogin_Id = comment_user
};
//添加信息
blog.Entry(comm_Window_Insert).State = System.Data.EntityState.Added;
int count = blog.SaveChanges();
//获取头像
string img = blog.Users_Details.Where(a => a.Users_Details_ID == comment_user).Select(a => a.Users_Details_Photo).First();
Clients.Caller.getMessage(dtime, content, img);
}
/// <summary>
/// 添加博客文章
/// 时间：1-17
/// 修改：1、时间：1-18,内容：将返回值修改为当前添加的文章的自增id
/// </summary>
/// <param name="_wb">文章信息</param>
/// <returns>当前添加的文章的自增ID</returns>
public static int AddBlog(Write_blog _wb)
{
MonkeyDBEntities _db = new MonkeyDBEntities();
//判断文章是否公开，公开就将审核状态改为0（待审核）
//if (_wb.Write_Private == 1)
_wb.Write_State = 0;
//将浏览量和点赞量设为0
_wb.Write_ReadCount = 0;
_wb.Write_ZanCount = 0;
_wb.Write_Collection = 0;
_wb.ULogin_IdIsManager = "否";
//如果创建时间为空，就将系统当前时间设置为文章创建时间
if (_wb.Write_Createdate == null)
{
_wb.Write_Createdate = DateTime.Now;
}
_wb.Blog_Recommend = 2;
//添加到数据库但未提交
_db.Write_blog.Add(_wb);
//提交到数据库，返回提交结果
_db.SaveChanges();
return(_wb.Write_blog_Id);
}
/// <summary>
/// 名称：查询单个用户的所有自定义分类
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_loginId">要查询的用户的登陆账号编号</param>
/// <param name="_val">要查询类别关键字</param>
/// <returns>查询当前用户的所有自定义类别</returns>
public static List <Category> SelectCategory(int _loginId, string _val)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
return(_db.Category.Where(a => a.ULogin_Id == _loginId && a.Category_Type.Contains(_val)).ToList());
}
/// <summary>
/// 名称：查询后台管理员所有分类
/// 时间：1-18
/// 作者：
/// </summary>
/// <returns>查询管理员所有分类</returns>
public static List <Backstage_Category> SelectBackstage_Category()
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
return(_db.Backstage_Category.ToList());
}
/// <summary>
/// 彻底删除文章
/// </summary>
/// <returns></returns>
public JsonResult RealDelBlogManagerIndex(Write_blog wb)
{
MonkeyDBEntities db = new MonkeyDBEntities();
db.Entry(wb).State = System.Data.EntityState.Deleted;; //彻底删除博客
//查询该条博客下面的所有评论
List <Blog_Comment> bclist = db.Blog_Comment.Where(a => a.BC_ArticleID == wb.Write_blog_Id).ToList();
//遍历该博客下面的所评论
foreach (var item in bclist)
{
//删除评论
db.Entry(item).State = System.Data.EntityState.Deleted;
}
//先关闭验证实体有效性（ValidateOnSaveEnabled）这个开关（默认是开启的）
db.Configuration.ValidateOnSaveEnabled = false;
int count = db.SaveChanges();//保存到数据库
//在开启验证实体有效性（ValidateOnSaveEnabled）这个开关
db.Configuration.ValidateOnSaveEnabled = true;
return(Json(count, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 名称：查询单个用户的所有自定义分类（分页）
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_loginId">要查询的用户的登陆账号编号</param>
/// <returns>查询当前用户的所有自定义类别</returns>
public static List <Category> SelectCategory(int _loginId)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
return(_db.Category.Where(a => a.ULogin_Id == _loginId).OrderByDescending(a => a.Category_Id).ToList());
}
/// <summary>
/// 博客详情页
/// </summary>
/// <returns></returns>
public ActionResult DetailsWriteBlogIndex()
{
MonkeyDBEntities db = new MonkeyDBEntities();
Write_blog wb = db.Write_blog.Where(a => a.Write_blog_Id == 10).FirstOrDefault();
@ViewBag.wb = wb;
return(View());
}
/// <summary>
/// 判断该评论是否有二级的方法
/// </summary>
/// <param name="BC_CommentId"></param>
/// <returns></returns>
public JsonResult ChildrenComment(int BC_CommentId)
{
MonkeyDBEntities db = new MonkeyDBEntities();
//查询该条评论的所有二级评论条数
int count = db.Blog_Comment.AsNoTracking().Where(a => a.BC_Comment_ParentId == BC_CommentId).Count();
return(Json(count, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 名称：登录验证
/// 时间：1-26
/// 作者：
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <returns></returns>
public JsonResult Login_Verification(string username, string password)
{
//创建本次请求的返回对象
DTO_Result _res = new DTO_Result();
//验证非空
if (string.IsNullOrEmpty(username))
{
_res.Result_Code = new Random().Next(100000, 999999).ToString();
_res.Result_Title = "手机号不能为空";
return(Json(_res, JsonRequestBehavior.AllowGet));
}
else if (string.IsNullOrEmpty(password))
{
_res.Result_Code = new Random().Next(100000, 999999).ToString();
_res.Result_Title = "密码不能为空";
return(Json(_res, JsonRequestBehavior.AllowGet));
}
else
{
//验证手机号码格式
if (IsMobilePhone(username))
{
//创建数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
string _jmpass = MD5JM(password);
//查询用户信息
var _loginuser = _db.ULogin.Where(a => a.ULogin_Phone.Equals(username) && a.ULogin_Password.Equals(_jmpass));
if (_loginuser.Count() == 1)
{
//获取第一个元素
Session["ULogin"] = _loginuser.FirstOrDefault();
//提示登录成功
_res.Result_Code = "000000";
_res.Result_Title = "登录成功";
return(Json(_res, JsonRequestBehavior.AllowGet));
}
else
{
//提示登录失败
_res.Result_Code = new Random().Next(100000, 999999).ToString();
_res.Result_Title = "手机号或密码错误，登录失败";
return(Json(_res, JsonRequestBehavior.AllowGet));
}
}
else
{
_res.Result_Code = new Random().Next(100000, 999999).ToString();
_res.Result_Title = "手机号格式不正确";
return(Json(_res, JsonRequestBehavior.AllowGet));
}
}
}
/// <summary>
/// 操作文章收藏量
/// 时间：1-18
/// </summary>
/// <param name="_blogId">被收藏的文章编号</param>
/// <param name="_val">增加收藏量或减少收藏量的值</param>
/// <returns></returns>
public static int Collection(int _blogId, int _val)
{
MonkeyDBEntities _db = new MonkeyDBEntities();
string sql = "update Write_blog set Write_ZanCount=Write_ZanCount +" + _val + " where Write_blog_Id = " + _blogId;
//提交数据，并返回结果
return(_db.Database.ExecuteSqlCommand(sql));
}
/// <summary>
/// 添加阅读量
/// 时间：1-17
/// 修改：1、时间：1-18
/// </summary>
/// <param name="_blogId">要添加阅读量得文章编号</param>
/// <returns></returns>
public static int AddReadCount(int _blogId)
{
MonkeyDBEntities _db = new MonkeyDBEntities();
string sql = "update Write_blog set Write_ReadCount=Write_ReadCount +1 where Write_blog_Id = " + _blogId;
//提交数据，并返回结果
return(_db.Database.ExecuteSqlCommand(sql));
}
/// <summary>
/// 名称：查询指定类别下的文章数量
/// 时间：18-1-23
/// 作者：
/// </summary>
/// <param name="_caId"></param>
/// <returns></returns>
public static int SelectChildCount(string _caId)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
string[] _ids = _caId.Split(',');
return(_db.Write_blog.Where(a => _ids.Contains(a.Category_Id.ToString())).Count());
}
/// <summary>
/// 验证自定义类别是否存在
/// </summary>
/// <param name="_loginId">登陆账号id</param>
/// <param name="_ty">类别编号</param>
/// <returns>true代表数据库不存在该条数据；FALSE代表数据库存在该条数据</returns>
public static bool IsContains(int _loginId, int _cId)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
//查询
bool _bo = _db.Category.Where(a => a.ULogin_Id == _loginId && a.Category_Id == _cId).FirstOrDefault() == null;
return(_bo);
}
public JsonResult DelWriteBlog(int Write_blog_Id)
{
MonkeyDBEntities db = new MonkeyDBEntities();
//调用删除的方法
int count = DTO_Write_blog.DeleteBlog(Write_blog_Id);
return(Json(count, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 名称：修改密码
/// 时间：
/// 作者：
/// </summary>
/// <param name="phone">手机号</param>
/// <param name="newpassword">新密码</param>
/// <param name="code">验证码</param>
/// <returns></returns>
public JsonResult ForgetSucc(string newpassword, string code)
{
//验证已获取验证码
if (Session["sendCode"] == null)
{
return(Json(new DTO_Result()
{
Result_Code = "6565", Result_Title = "验证码输入错误"
}, JsonRequestBehavior.AllowGet));
}
else if (!code.Equals((Session["sendCode"] as DTO_Reg).Code))
{
return(Json(new DTO_Result()
{
Result_Code = "6565", Result_Title = "验证码输入错误"
}, JsonRequestBehavior.AllowGet));
}
else if (string.IsNullOrEmpty(newpassword))
{
return(Json(new DTO_Result()
{
Result_Code = "656665", Result_Title = "请输入密码"
}, JsonRequestBehavior.AllowGet));
}
//创建数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
string s = (Session["sendCode"] as DTO_Reg).Phone;
//查询用户
ULogin _ul = _db.ULogin.Where(a => a.ULogin_Phone.Equals(s)).FirstOrDefault();
if (_ul != null)
{
_ul.ULogin_Password = MD5JM(newpassword);
}
//提交数据
if (_db.SaveChanges() > 0)
{
return(Json(new DTO_Result()
{
Result_Code = "000000", Result_Title = "密码修改成功，请重新登录"
}, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new DTO_Result()
{
Result_Code = "004400", Result_Title = "密码修改失败"
}, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// 名称：添加自定义类别
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_ca">要添加的自定义类别数据</param>
/// <returns>新添加的自定义类别自增id</returns>
public static int AddCategory(Category _ca)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
_db.Category.Add(_ca);
//提交
_db.SaveChanges();
//返回自增id
return(_ca.Category_Id);
}
/// <summary>
/// 名称：添加专栏信息
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_sp">要添加的专栏数据</param>
/// <returns>新添加的自定义类别自增id</returns>
public static int AddSpecial(Special _sp)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
_db.Special.Add(_sp);
//提交
_db.SaveChanges();
//返回自增id
return(_sp.Special_Id);
}
/// <summary>
/// 我评论的
/// </summary>
/// <param name="searchcontent"></param>
/// <returns></returns>
public ActionResult MyCommentIndex()
{
MonkeyDBEntities db = new MonkeyDBEntities();
int rows;
//如果为""就赋值为1
if (Request["num"] == "")
{
rows = 1;
}
//如果为null就赋值为1
rows = Convert.ToInt32(Request["num"] ?? "1");
ULogin ul = Session["ULogin"] as ULogin;
//博主评论别人的信息
List <Blog_Comment> bcomlist = db.Blog_Comment.AsNoTracking().Where(a => a.BC_UserID == ul.ULogin_Id).ToList();
//三表联查
var query = from b in bcomlist
join wb in db.Write_blog on b.BC_ArticleID equals wb.Write_blog_Id
join u in db.ULogin on b.BC_ForUserID equals u.ULogin_Id
select new BC_CommentDTO
{
BC_CommentId = b.BC_CommentId,
BC_ArticleID = b.BC_ArticleID,
BC_Comment = b.BC_Comment,
BC_Comment_Time = b.BC_Comment_Time,
Write_Title = wb.Write_Title,
Ulogin_BlogName = u.Ulogin_BlogName
};
//分页
List <BC_CommentDTO> bcdlist = query.OrderByDescending(a => a.BC_CommentId).Skip((rows - 1) * 5).Take(5).ToList();
//得到所有条数
int allcount = query.Count();
//得到所有页数
int allpage = allcount / 5;
//判断是否除尽或页数是否为0
if (allcount % 5 != 0 || allpage == 0)
{
allpage = allpage + 1;
}
ViewBag.bcdlist = bcdlist;
ViewBag.allpage = allpage;
ViewBag.rows = rows;
return(View());
}
public JsonResult DelPeraonalComment(Blog_Comment bc)
{
MonkeyDBEntities db = new MonkeyDBEntities();
//查询该篇文章的所有评论
List <Blog_Comment> querybc = db.Blog_Comment.AsNoTracking().Where(a => a.BC_ArticleID == bc.BC_ArticleID).ToList();
del(db, querybc, bc);
//操作数据库
int count = db.SaveChanges();
return(Json(count, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 名称：修改自定义类别
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_ca">修改后的对象</param>
/// <returns>修改后受影响的行id</returns>
public static int UpdateCategory(Category _ca)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
var _upd = _db.Entry(_ca);
//指定数据已更新
_upd.State = System.Data.EntityState.Unchanged;
//指定修改的字段
_upd.Property("Category_Reception").IsModified = _ca.Category_Reception != null;
_upd.Property("Category_Type").IsModified = !string.IsNullOrEmpty(_ca.Category_Type);
return(_db.SaveChanges());
}
/// <summary>
/// 名称：修改专栏信息
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_sp">修改的数据</param>
/// <returns>操作受影响的行数</returns>
public static int UpdateSpecial(Special _sp)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
var _upd = _db.Entry(_sp);
//指定数据已更新
_upd.State = System.Data.EntityState.Unchanged;
//指定修改的字段
_upd.Property("Special_Name").IsModified = !string.IsNullOrEmpty(_sp.Special_Name);
_upd.Property("Special_Introduce").IsModified = !string.IsNullOrEmpty(_sp.Special_Introduce);
return(_db.SaveChanges());
}
/// <summary>
/// 名称：删除专栏信息
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_spId">要删除的专栏编号</param>
/// <returns>新添加的自定义类别自增id</returns>
public static int DeleteSpecial(int _spId)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
//编辑要删除的数据
Special _sp = new Special()
{
Special_Id = _spId
};
//指定要删除的自定义类别
_db.Entry(_sp).State = System.Data.EntityState.Deleted;
_db.Special.Remove(_sp);
return(_db.SaveChanges());
}
/// <summary>
/// 删除指定文章（真删，彻底清除文章）
/// 时间：1-17
/// </summary>
/// <param name="_blogId">文章编号</param>
/// <returns></returns>
public static int DeleteOneBlog(int _blogId)
{
MonkeyDBEntities _db = new MonkeyDBEntities();
//创建要删除的实体对象
Write_blog _wb = new Write_blog()
{
Write_blog_Id = _blogId
};
//指定需要删除的数据
_db.Entry(_wb).State = System.Data.EntityState.Deleted;
_db.Write_blog.Remove(_wb);
//提交数据库并返回结果
return(_db.SaveChanges());
}
//
// GET: /Home/
public ActionResult Index()
{
MonkeyDBEntities be = new MonkeyDBEntities();
List <Carousel_figure> clist = be.Carousel_figure.ToList();
//退出时 清空session信息
if (Request["way"] == "logOut")
{
Session.Contents.Clear();
}
ViewBag.clist = clist;
return(View());
}
/// <summary>
/// 删除评论的递归算法
/// </summary>
/// <param name="db">数据库上下对象</param>
/// <param name="querybc">该条评论所属文章的所有评论</param>
/// <param name="bc">该条评论的信息</param>
public void del(MonkeyDBEntities db, List <Blog_Comment> querybc, Blog_Comment bc)
{
//查询该条评论的二级评论
List <Blog_Comment> bclist1 = querybc.Where(a => a.BC_Comment_ParentId == bc.BC_CommentId).ToList();
//设置实体状态
db.Entry(bc).State = System.Data.EntityState.Deleted;
//判断该条评论的二级评论条数是否大于等于1
if (bclist1.Count() >= 1)
{
//遍历该评论的二级评论的集合
foreach (var item in bclist1)
{
//递归调用
del(db, querybc, item);
}
}
}
/// <summary>
/// 名称：删除自定义类别
/// 时间：1-18
/// 作者：
/// </summary>
/// <param name="_caId">要删除的自定义类别编号</param>
/// <returns>删除后受影响的行</returns>
public static int DeleteCategory(int _caId)
{
//创建一个数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
//编辑要删除的数据
Category _ca = new Category()
{
Category_Id = _caId
};
//指定要删除的自定义类别
_db.Entry(_ca).State = System.Data.EntityState.Deleted;
_db.Category.Remove(_ca);
return(_db.SaveChanges());
}
public ActionResult UpdateWriteBlogIndex(int Write_blog_Id)
{
ULogin u = Session["ULogin"] as ULogin;//Session["ULogin"] as ULogin;
MonkeyDBEntities db = new MonkeyDBEntities();
//查询所有的后台博客类别
List <Backstage_Category> _bclist = DTO_Backstage_Category.SelectBackstage_Category();
//查询所有自定类别
List <Category> clist = DTO_Category.SelectCategory(u.ULogin_Id);
Write_blog wb = db.Write_blog.Where(a => a.Write_blog_Id == Write_blog_Id).FirstOrDefault();
string[] strlist = wb.Category_Id.Split(',');//这篇文章的类型数组
@ViewBag._bclist = _bclist;
@ViewBag.clist = clist;
@ViewBag.wb = wb;
@ViewBag.Mycalist = strlist;
return(View());
}
/// <summary>
/// 查询文章
/// </summary>
/// <param name="_id">用户登录编号</param>
/// <param name="_is">是否是查询自己的文章（>0为查询自己，=0查询指定用户可见文章，<0查询所有用户可见文章）</param>
/// <param name="_selval">查询关键字内容</param>
/// <returns>文章集合</returns>
public static List <Write_blog> Select(int _id, int _is, string _selval)
{
//创建数据库上下文对象
MonkeyDBEntities _db = new MonkeyDBEntities();
var _all = _db.Write_blog.AsNoTracking().ToList();
List <Write_blog> _lis = new List <Write_blog>();
if (_is >= 0)
{
_lis.AddRange(_all.Where(a => a.ULogin_Id == _id && a.Write_Title.Contains(_selval) && (_is > 0 || a.Write_IsDel == 2 && a.Write_State == 2 && a.Write_Private == 1)).ToList());
_lis.AddRange(_all.Where(a => a.ULogin_Id == _id && a.Write_Content.Contains(_selval) && (_is > 0 || a.Write_IsDel == 2 && a.Write_State == 2 && a.Write_Private == 1)).ToList());
}
else
{
_lis.AddRange(_all.Where(a => a.Write_Title.Contains(_selval) && a.Write_IsDel == 2 && a.Write_State == 2 && a.Write_Private == 1).ToList());
_lis.AddRange(_all.Where(a => a.Write_Content.Contains(_selval) && a.Write_IsDel == 2 && a.Write_State == 2 && a.Write_Private == 1).ToList());
}
return(_lis);
}
/// <summary>
/// 将指定文章收入回收站
/// 时间：1-17
/// </summary>
/// <param name="_blogId">文章编号</param>
/// <returns></returns>
public static int DeleteBlog(int _blogId)
{
MonkeyDBEntities _db = new MonkeyDBEntities();
//创建要删除的实体对象
Write_blog _wb = new Write_blog()
{
Write_blog_Id = _blogId, Write_Deletedate = DateTime.Now, Write_IsDel = 0
};
var _upd = _db.Entry(_wb);
//指定数据已更新
_upd.State = System.Data.EntityState.Unchanged;
//指定修改的字段
_upd.Property("Write_Deletedate").IsModified = true;
_upd.Property("Write_IsDel").IsModified = true;
//提交数据，并返回结果
return(_db.SaveChanges());
}
/// <summary>
/// 删除的文章（回收站）
/// </summary>
/// <returns></returns>
public ActionResult DelBlogManagerIndex(string searchcontent)
{
MonkeyDBEntities db = new MonkeyDBEntities();
int rows;
//如果为""就赋值为1
if (Request["num"] == "")
{
rows = 1;
}
//如果为null就赋值为1
rows = Convert.ToInt32(Request["num"] ?? "1");
int Write_ArticleType;
if (Request["Write_ArticleType"] == "")//判断得到的文章类型是否为“”
{
Write_ArticleType = -1;
}
Write_ArticleType = Convert.ToInt32(Request["Write_ArticleType"] ?? "-1");
//得到博主信息
//ULogin ul= Session["ULogin"] as ULogin;
ULogin ul = new ULogin()
{
ULogin_Id = 1
};
//创建一个返回值为bool型的委托
Func <Write_blog, bool> getpage = a => a.Write_IsDel == 0 && a.ULogin_Id == ul.ULogin_Id && a.ULogin_IdIsManager == "否" && (Write_ArticleType == -1 || a.Write_ArticleType == Write_ArticleType) && (string.IsNullOrEmpty(searchcontent) || a.Write_Content.Contains(searchcontent.Trim()) || a.Write_Title.Contains(searchcontent.Trim()) || a.Write_Label.Contains(searchcontent.Trim()));
//创建以及博客集合
List <Write_blog> wblist = new List <Write_blog>();
wblist = db.Write_blog.Where(getpage).OrderByDescending(a => a.Write_blog_Id).Skip((rows - 1) * 5).Take(5).ToList();
//创建一个装评论条数的集合
List <int> bccountlist = new List <int>();
//查询所有的评论
List <Blog_Comment> bclist = db.Blog_Comment.AsNoTracking().ToList();
//遍历博客
foreach (var item in wblist)
{
//查询该博客对应的评论的条数
int count = bclist.Where(a => a.BC_ArticleID == item.Write_blog_Id).Count();
//添加到集合
bccountlist.Add(count);
}
//得到所有条数
int allcount = db.Write_blog.Where(getpage).Count();
//得到所有页数
int allpage = allcount / 5;
//判断是否除尽或页数是否为0
if (allcount % 5 != 0 || allpage == 0)
{
allpage = allpage + 1;
}
//传值到页面
ViewBag.allpage = allpage; //总页数
ViewBag.rows = rows; //第几页
ViewBag.bccountlist = bccountlist; //评论条数
ViewBag.wblist = wblist; //博客集合
ViewBag.searchcontent = searchcontent; //搜索框
ViewBag.Write_ArticleType = Write_ArticleType; //文章类型
return(View());
}
