// GET: api/OrderDetailsExtended
        public async Task <IHttpActionResult> GetOrderDetailsExtended(int page = 0, int pageSize = 5)
        {
            int totalCount = 0;

            IList <OrderDetailsExtendedVm> listVm = new List <OrderDetailsExtendedVm>();
            var result = Task.Factory.StartNew(() => {
                ICriteria criteria = new Criteria <BOOrderDetailsExtended>(OrderDetailsExtendedRepository);
                totalCount         = criteria.Count();

                IList <BOOrderDetailsExtended> listBOs = criteria
                                                         .Add(new OrderBy("OrderID", OrderBy.OrderDirection.Ascending))
                                                         .Skip(page * pageSize)
                                                         .Take(pageSize)
                                                         .List <BOOrderDetailsExtended>();

                foreach (var bo in listBOs)
                {
                    listVm.Add(new OrderDetailsExtendedVm(bo));
                }
                return(listVm);
            });
            await result;

            return(Ok(new { Data = result.Result, Paging = new { Total = totalCount, Limit = pageSize, CurrentPage = page, PageCount = (int)Math.Ceiling((double)totalCount / pageSize) } }));
        }
Exemple #2
0
 static void Main(string[] args)
 {
     ICriteria          criteria   = new Criteria <BOProducts>(ProductsRepository);
     var                totalCount = criteria.Count();
     var                page       = 0;
     var                pageSize   = 100;
     IList <BOProducts> listBOs    = criteria
                                     .Add(new OrderBy("supplier_ids", OrderBy.OrderDirection.Ascending))
                                     .Skip(page * pageSize)
                                     .Take(pageSize)
                                     .List <BOProducts>();
 }
 public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     var keyword = GetDbQueryPara();
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<TrainManagement>(session)
             .Page(pagesize, pageno)
             .Asc(m => m.Id)
             .AddOrder(collection, ViewData)
             //.AndUnless(string.IsNullOrEmpty(keyword), m => m.Name.Include(keyword))
             ;
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }
 public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<ActionLog>(session).Page(pagesize, pageno)
             .Asc(m => m.CreatedAt).AddOrder(collection, ViewData);
         if (collection != null)
         {
             if (collection.AllKeys.Contains("starttime"))
             {
                 var dtStr = (collection["starttime"] + string.Empty).Trim();
                 if (!string.IsNullOrEmpty(dtStr))
                 {
                     DateTime startAt;
                     if (DateTime.TryParse(dtStr, out startAt))
                     {
                         q.And(m => m.CreatedAt >= startAt);
                     }
                 }
             }
             if (collection.AllKeys.Contains("endtime"))
             {
                 var dtStr = (collection["endtime"] + string.Empty).Trim();
                 if (!string.IsNullOrEmpty(dtStr))
                 {
                     DateTime endAt;
                     if (DateTime.TryParse(dtStr, out endAt))
                     {
                         q.And(m => m.CreatedAt <= endAt);
                     }
                 }
             }
             if (collection.AllKeys.Contains("keywords"))
             {
                 var keywords = (collection["keywords"] + string.Empty).Trim();
                 if (!string.IsNullOrEmpty(keywords))
                 {
                     q.And(m => m.Actor.Include(keywords), m => m.Category.Include(keywords),
                         m => m.Title.Include(keywords), m => m.Description.Include(keywords),
                         m => m.Result.Include(keywords));
                 }
             }
         }
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }
        public ActionResult QuickSearch(FormCollection collection, long id = 0, uint pagesize = DefaultPageSize, uint pageno = 1)
        {
            var keyword = GetDbQueryPara();
            using (var session = new SessionFactory().OpenSession())
            {

                var q = new Criteria<TrainExperienceView>(session)
                    .Page(pagesize, pageno)
                    .Asc(m => m.Id)
                    .AddOrder(collection, ViewData)
                    .And(m => m.Status.Equals(TrainExperienceConst.已提交培训管理部门), m => m.Status.Equals(TrainExperienceConst.已提交领导))
                    .And(m => m.TrainManId.Equals(id))
                    .AndUnless(string.IsNullOrEmpty(keyword), m => m.Year.Equals(keyword), m => m.Dept.Include(keyword), m => m.StaffName.Include(keyword))
                    ;
                var models = q.Find().PartPage(pageno, pagesize, q.Count());
                return View(models);
            }
        }
        public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
        {
            var keywords = GetDbQueryPara();
            using (var session = new SessionFactory().OpenSession())
            {
                var q = new Criteria<StandardFile>(session).Page(pagesize, pageno).Asc(m => m.Id).AddOrder(collection, ViewData)
                    .And(m => m.State.Equals(StandardFileStateConst.已发布))
                    .AndUnless(string.IsNullOrEmpty(keywords),
                   m => m.OriginName.Include(keywords),
                   m => m.FileType.Include(keywords),
                   m => m.Creator.Include(keywords),
                   m => m.Description.Include(keywords),
                   m => m.Memo.Include(keywords),
                  m => m.State.Include(keywords),
                   m => m.ApproveState.Include(keywords));

                var models = q.Find().PartPage(pageno, pagesize, q.Count());

                return View(models);
            }
        }
        public new ActionResult User(long[] ids)
        {
            if (ids.Length == 0)
            {
                FlashInfo("请选择要查看用户的角色。");
                return Close();
            }
            using (var session = new SessionFactory().OpenSession())
            {
                var role = session.Load<Role>(m => m.Id.In(ids));
                if (role == null)
                {
                    FlashInfo("请选择要查看用户的角色。");
                    return Close();
                }

                ViewData["roleName"] = role.Name;
                ViewData["roleDeptName"] = role.Department == null ? string.Empty : role.Department.Name;

                var q = new Criteria<FullUser>().Select(m => m.Id)
                    .AndIn<Account>(x => x.Code, y => y.Name, new Criteria<Account>().AndIn<AccountRoleRef>(m => m.Id, n => n.AccountId, n => n.RoleId.In(ids)));
                if (q.Count() == 0)
                {
                    FlashInfo("该角色没有分配给任何用户。");
                }

                ViewData["selectedIds"] = q.PropertieValues<long>();
                q.Reset();
                //q.Reset().AndIn<Role>(m => m.DepartmentId, n => n.DepartmentId, n => n.Id.In(ids));
                var model = q.Find();
                return View(model);
            }
        }
 public ActionResult QuickSearch(FormCollection collection, long id = 0, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<PunishmentDossierFiles>(session).Page(pagesize, pageno).Asc(m => m.Id).AddOrder(collection, ViewData);
         q.And(m => m.ParentId == id);
         if (collection != null && collection.AllKeys.Contains("keywords"))
         {
             var keywords = (collection["keywords"] + string.Empty).Trim();
             if (!string.IsNullOrEmpty(keywords))
             {
             }
         }
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }
        public ActionResult Login(FormCollection collection)
        {
            Reset();
            var key = collection["key"];
            if (!string.IsNullOrEmpty(key))
            {
                return UkeyLogin(key);
            }

            var name = collection["username"];
            var pwd = collection["password"];
            ViewData["username"] = name;

            Session[Const.CurrentAccountName] = name;

            if (string.IsNullOrEmpty(name))
            {
                return JsonMessage(100, "请输入用户名!");
            }
            if (string.IsNullOrEmpty(pwd))
            {
                return JsonMessage(100, "请输入密码!");
            }

            using (var session = new SessionFactory().OpenSession())
            {
                var q = new Criteria<Account>(session)
                     .AndIn<User>(m => m.Name, n => n.Code, n => n.Name.Equals(name) || n.Code.Equals(name))
                     .Limit(2);
                var uc = q.Count(true);
                if (uc == 0)
                {
                    FlashFailureAndLog("用户名或者密码不正确", name);
                    return JsonMessage(100, "用户名或者密码不正确,请重新输入!");
                }
                if (uc > 1)
                {
                    FlashFailureAndLog("用户身份不唯一", name);
                    return JsonMessage(100, "用户身份不唯一,请联系管理员解决!");
                }

                var account = q.Load();
                if (account == null)
                {
                    FlashFailureAndLog("读取用户数据失败", name);
                    return JsonMessage(100, "读取用户数据失败,请联系管理员解决!");
                }

                // 禁用的用户
                if (account.Status == -1)
                {
                    FlashFailureAndLog("你的账户已经被禁用,请联系系统管理员!");
                    return JsonMessage(100, "你的账户已经被禁用,请联系管理员解决!");
                }

                // 未初始化的用户,使用验证码登录
                if (account.Status == 0)
                {
                    if (!pwd.Equals(account.Flag))
                    {
                        FlashFailureAndLog("验证码不正确,请重新输入!");
                        return JsonMessage(100, "验证码不正确,请重新输入!");
                    }

                    Session[Const.CurrentAccountId] = account.Id;
                    Session[Const.CurrentAccountName] = name;

                    FormsAuthentication.SetAuthCookie(account.Name, false);
                    var resetPasswordUrl = "/base/profile/resetpassword?ReturnUrl=" + Request.Params["ReturnUrl"];
                    WriteSuccessLog("初次登录,账户初始化!");
                    return JsonMessage(200, "账户初始化,请稍候...", resetPasswordUrl);
                }

                // 已经初始化的用户,使用密码登录
                if (!account.AuthPassword(pwd))
                {
                    FlashFailureAndLog("用户名密码验证不正确,请重新输入!");
                    return JsonMessage(100, "用户名密码验证不正确,请重新输入!");
                }

                Session[Const.CurrentAccountId] = account.Id;
                Session[Const.CurrentAccountName] = name;

                FormsAuthentication.SetAuthCookie(account.Name, true);

                account.LastLoginAt = DateTime.Now;
                account.LoginCount++;

                if (!session.Update(account))
                {
                    FlashFailureAndLog("更新用户登录记录出错!");
                    return JsonMessage(100, "更新用户登录记录出错,请联系管理员解决!");
                }

                WriteSuccessLog("登录", account);

                var url = Request.Params["ReturnUrl"];
                if (string.IsNullOrEmpty(url))
                {
                    url = FormsAuthentication.DefaultUrl;
                }
                return JsonMessage(200, "验证成功,请稍候...", url);
            }
        }
 public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<School>(session).Page(pagesize, pageno).Asc(m => m.Id).AddOrder(collection, ViewData);
         if (collection != null && collection.AllKeys.Contains("keywords"))
         {
             var keywords = (collection["keywords"] + string.Empty).Trim();
             if (!string.IsNullOrEmpty(keywords))
             {
                 q.And(m => m.Name.Include(keywords), m => m.Address.Include(keywords), m => m.LeaderName.Include(keywords));
             }
         }
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }
Exemple #11
0
 //public bool AddOrganization(Organization organization)
 //{
 //    if (organization == null || organization.Id <= 0) return false;
 //    if (Id <= 0) return false;
 //    var q = new Criteria<AccountOrganizationRef>().Where(m => m.AccountId.Equals(Id) && m.OrganizationId.Equals(organization.Id));
 //    if (q.Count() > 0) return true;
 //    var r = new AccountOrganizationRef { AccountId = Id, OrganizationId = organization.Id };
 //    var db = new SessionFactory().OpenSession();
 //    return db.Create(r);
 //}
 public bool AddRole(Role role)
 {
     if (role == null || role.Id <= 0) return false;
     if (Id <= 0) return false;
     Criteria<AccountRoleRef> q =
         new Criteria<AccountRoleRef>().Where(m => m.AccountId.Equals(Id) && m.RoleId.Equals(role.Id));
     if (q.Count() > 0) return true;
     Session db = new SessionFactory().OpenSession();
     var r = new AccountRoleRef { AccountId = Id, RoleId = role.Id };
     return db.Create(r);
 }
 public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     var keywords = GetDbQueryPara();
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<Dossier>(session)
             .Page(pagesize, pageno)
             .Asc(m => m.Id)
             .AddOrder(collection, ViewData)
             .AndUnless(string.IsNullOrEmpty(keywords), m => m.Name.Include(keywords),
             m => m.ContractNo.Include(keywords),
             m => m.Undertaker.Include(keywords),
             m => m.Type.Include(keywords),
            m => m.State.Include(keywords),
             m => m.ApproveState.Include(keywords))
             ;
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }
        public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
        {
            var keyword = GetDbQueryPara();
            using (var session = new SessionFactory().OpenSession())
            {
                var dept = new Criteria<Department>(session)
                   .AndIn<User>(m => m.Id, n => n.DepartmentId, m => m.Code.Equals(CurrentAccountNo)).Load();

                var q = new Criteria<TrainNeed>(session)
                    .Page(pagesize, pageno)
                    .Asc(m => m.Id)
                    .AddOrder(collection, ViewData)
                     .AndIf(dept != null && dept.Id != 0, m => m.DeptId.Equals(dept.Id))
                    .And(m => (m.Type.Equals(TrainNeedType.员工) && m.Status.Equals(TrainNeedStatus.已提交部门负责人)) || m.Type.Equals(TrainNeedType.部门))
                    //.AndUnless(string.IsNullOrEmpty(keyword), m => m.Name.Include(keyword))
                    ;
                var models = q.Find().PartPage(pageno, pagesize, q.Count());
                return View(models);
            }
        }
        private string LoginUser()
        {
            AuthenticationResponse _AuthenticationResponse = new AuthenticationResponse {
                Result = false
            };

            try
            {
                string m_LoginName  = string.Empty;
                string m_Password   = string.Empty;
                bool   m_IsRemember = false;
                if (Request.Form["EmailAddress"] != null && Request.Form["IsFB"] != null)
                {
                    string _UserEmail = Request.Form["EmailAddress"].ToString();
                    User   _ThisUser  = new User().GetUserDetails(_UserEmail, true);
                    m_LoginName  = _ThisUser.LoginName;
                    m_Password   = _ThisUser.Password;
                    m_IsRemember = false;
                }
                else
                {
                    m_LoginName  = Request.Form["LoginName"].ToString();
                    m_Password   = Request.Form["Password"].ToString();
                    m_IsRemember = Convert.ToBoolean(Request.Form["IsRemember"].ToString());
                }

                bool IsEmailLogin = IsValidEmail(m_LoginName);
                User m_UserDetails;

                if (IsEmailLogin)
                {
                    m_UserDetails = new User().AuthenticateUserWithEmail(m_LoginName, m_Password);
                }
                else
                {
                    m_UserDetails = new User().AuthenticateUser(m_LoginName, m_Password);
                }
                if (m_UserDetails != null)
                {
                    string ACCOUNT_STATUS = new UserAccountSettings().GetUserAccountSettings(m_UserDetails.UserID).AccoutStatus;

                    if (ACCOUNT_STATUS.ToUpper() == "A")
                    {
                        if (!m_IsRemember)
                        {
                            FormsAuthentication.RedirectFromLoginPage(m_UserDetails.UserID.ToString(), false);

                            if (m_UserDetails.Status == "A")
                            {
                                // Check if any unanswered Criteria questions
                                Criteria[] _UnAnsweredCriteriaQuestions = new Criteria().GetUnAnsweredQuestions(m_UserDetails.UserID);
                                _AuthenticationResponse.Result = true;
                                if (_UnAnsweredCriteriaQuestions.Count() == 0)
                                {
                                    _AuthenticationResponse.RedirectPath = "Web/Home";
                                }
                                else
                                {
                                    _AuthenticationResponse.RedirectPath = "Web/Criteria";
                                }
                            }
                            if (m_UserDetails.Status == "P")
                            {
                                _AuthenticationResponse.RedirectPath = "Web/Criteria";
                            }
                            if (m_UserDetails.Status == "I")
                            {
                                _AuthenticationResponse.RedirectPath = "Delete";
                            }
                        }

                        else
                        {
                            FormsAuthentication.SetAuthCookie(m_UserDetails.UserID.ToString(), true);
                            FormsAuthenticationTicket intellidateTicket = new FormsAuthenticationTicket(1, m_UserDetails.UserID.ToString(), DateTime.Now, DateTime.Now.AddDays(30), true, "");
                            HttpCookie intellidateCookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(intellidateTicket));
                            Response.Cookies.Add(intellidateCookie);

                            _AuthenticationResponse.Result = true;
                            if (m_UserDetails.Status == "A")
                            {
                                // Check if any unanswered Criteria questions
                                Criteria[] _UnAnsweredCriteriaQuestions = new Criteria().GetUnAnsweredQuestions(m_UserDetails.UserID);

                                if (_UnAnsweredCriteriaQuestions.Count() == 0)
                                {
                                    _AuthenticationResponse.RedirectPath = "Web/Home";
                                }
                                else
                                {
                                    _AuthenticationResponse.RedirectPath = "Web/Criteria";
                                }
                            }
                            if (m_UserDetails.Status == "P")
                            {
                                _AuthenticationResponse.RedirectPath = "Web/Criteria";
                            }
                            if (m_UserDetails.Status == "I")
                            {
                                _AuthenticationResponse.RedirectPath = "Delete";
                            }
                        }
                    }
                    else if (ACCOUNT_STATUS.ToUpper() == "I")
                    {
                        FormsAuthentication.SetAuthCookie(m_UserDetails.UserID.ToString(), true);
                        FormsAuthenticationTicket intellidateTicket = new FormsAuthenticationTicket(1, m_UserDetails.UserID.ToString(), DateTime.Now, DateTime.Now.AddDays(30), true, "");
                        HttpCookie intellidateCookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(intellidateTicket));
                        Response.Cookies.Add(intellidateCookie);

                        _AuthenticationResponse.Result       = true;
                        _AuthenticationResponse.RedirectPath = "Web/ActivateAccount";
                    }
                    else if (ACCOUNT_STATUS.ToUpper() == "D")
                    {
                        _AuthenticationResponse.Result       = false;
                        _AuthenticationResponse.RedirectPath = null;
                    }
                }
            }
            catch (Exception ex)
            {
                IntellidateR1.Error.LogError(ex, "Login LoginUser");
                _AuthenticationResponse.Result = false;
            }
            return(JsonConvert.SerializeObject(_AuthenticationResponse));
        }
 public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     var keywords = GetDbQueryPara();
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<Contract>(session)
             .And(m => m.State.Equals(ContractStateConst.审计部门审核))
             .Page(pagesize, pageno)
             .Asc(m => m.Id)
             .AddOrder(collection, ViewData)
             .AndUnless(string.IsNullOrEmpty(keywords),
                        m => m.Name.Contains(keywords));
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }
 public ActionResult QuickSearch(FormCollection collection, uint pagesize = DefaultPageSize, uint pageno = 1)
 {
     var keyword = GetDbQueryPara();
     using (var session = new SessionFactory().OpenSession())
     {
         var q = new Criteria<TrainNeed>(session)
             .Page(pagesize, pageno)
             .Asc(m => m.Id)
             .AddOrder(collection, ViewData)
             //加过滤,只显示自己的需求
             .And(m => m.StaffCode.Equals(CurrentAccountNo))
             .And(m => m.Type.Equals(TrainNeedType.员工))
             //.AndUnless(string.IsNullOrEmpty(keyword), m => m.Name.Include(keyword))
             ;
         var models = q.Find().PartPage(pageno, pagesize, q.Count());
         return View(models);
     }
 }