public ActionResult Edit(long[] ids)
 {
     using (var session = new SessionFactory().OpenSession())
     {
         var model = session.Load<TrainManagementItem>(ids[0]);
         if (model.ExamStatus != null && !model.ExamStatus.Equals(ExamStatusConst.未考试))
         {
             FlashWarn("您已经完成该考试！");
             return Close();
         }
         var q = new Criteria<Exam>(session)
          .AndIn<TrainManagementItem>(m => m.TrainManId, n => n.TrainManId, n => n.Id == ids[0]);
         var exam = q.Load();
         if (exam == null)
         {
             FlashWarn("考试不存在！请联系管理员！");
             return Close();
         }
         var models = session.Find<Question>(m => m.ExamId == exam.Id);
         if (models == null || !models.Any())
         {
             FlashWarn("考试题目未设置！");
             return Close();
         }
         Response.Write(string.Format("<script>window.open('Exam?ids={0}','_blank')</script>", ids[0]));
         return Close();
     }
 }

 public static SelectList AllOrganizationList()
 {
     var q = new Criteria<Organization>();
     var d = q.Find();
     d.Insert(0, new Organization { Id = 0, Name = "全部" });
     return new SelectList(d, "Id", "Name");
 }

        public void TearDown()
        {
            TransactionCommitterDB committer = new TransactionCommitterDB(DatabaseConnection.CurrentConnection);
            Criteria criteria1 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "MyShape");
            Criteria criteria2 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "MyShapeChanged");
            Criteria criteria = new Criteria(criteria1, Criteria.LogicalOp.Or, criteria2);
            BusinessObjectCollection<Shape> shapes = 
                BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObjectCollection<Shape>(criteria, null);
            while (shapes.Count > 0)
            {
                Shape shape = shapes[0];
                shape.MarkForDelete();
                committer.AddBusinessObject(shape);
            }

            criteria1 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "Circle");
            criteria2 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "CircleChanged");
            criteria = new Criteria(criteria1, Criteria.LogicalOp.Or, criteria2);
            BusinessObjectCollection<CircleNoPrimaryKey> circles 
                = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObjectCollection
                    <CircleNoPrimaryKey>(criteria, null);
            foreach (CircleNoPrimaryKey circle in circles)

            {
                circle.MarkForDelete();
                committer.AddBusinessObject(circle);
            }
            committer.CommitTransaction();
        }

 public BasicRequestCommand(
     Criteria<FrontControllerRequest> request_criteria,
     ApplicationCommand application_command)
 {
     this.request_specification = request_criteria;
     this.application_command = application_command;
 }

 public void TearDown()
 {
     Criteria criteria1 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "MyShape");
     Shape shape = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject<Shape>(
         criteria1);
     if (shape != null)
     {
         shape.MarkForDelete();
         shape.Save();
     }
     criteria1 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "Circle");
     Criteria criteria2 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "CircleChanged");
     Criteria criteria = new Criteria(criteria1, Criteria.LogicalOp.Or, criteria2);
     CircleNoPrimaryKey circle = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject<CircleNoPrimaryKey>(
         criteria);
     if (circle != null)
     {
         circle.MarkForDelete();
         circle.Save();
     }
     criteria1 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "FilledCircle");
     criteria2 = new Criteria("ShapeName", Criteria.ComparisonOp.Equals, "FilledCircleChanged");
     criteria = new Criteria(criteria1, Criteria.LogicalOp.Or, criteria2);
     FilledCircleNoPrimaryKey filledCircle = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject<FilledCircleNoPrimaryKey>(
         criteria);
     if (filledCircle == null) return;
     filledCircle.MarkForDelete();
     filledCircle.Save();
 }

 static UserHelper()
 {
     var users = new Criteria<User>().Find();
     foreach (var user in users)
     {
         Maps.Add(user.Name, user.Realname);
     }
 }

 public RoleForViewCustomerInfo()
 {
     var specialRolesSetting = new Criteria<Setting>()
        .Where(m => m.Code.Equals(Setting.RecruitingPlanExportTypeGjg)).Load();
     var specialRoleNames = specialRolesSetting == null ? new string[0] :
         specialRolesSetting.Value.Split(new[] { ',', ' ', '，' }, StringSplitOptions.RemoveEmptyEntries);
     _roleNames = specialRoleNames.ToList();
 }

 public static SelectList AllSchoolSectionList()
 {
     var q = new Criteria<Department>();
     q.And(m => m.Type.Equals(DeparmentTypeList.Section));
     var d = q.Find();
     d.Insert(0, new Department { Id = 0, Name = "全部" });
     return new SelectList(d, "Id", "Name");
 }

 /// <summary>
 /// 读取滚动公告
 /// </summary>
 /// <returns></returns>
 public static IList<Notice> GetScrollNotices()
 {
     using (var session = new SessionFactory().OpenSession())
     {
         var today = DateTime.Today;
         var q = new Criteria<Notice>(session).Where(m => m.StopAt >= today);
         return q.Find();
     }
 }

 public static SelectList ClassStudentList(long id)
 {
     var q = new Criteria<SchoolStudent>().Where(m => m.ClassId.Equals(id)).Asc(m => m.StudentNo);
     var d = q.Find();
     foreach (var x in d)
     {
         x.StudentName = "[" + x.StudentNo + "]" + x.StudentName;
     }
     return new SelectList(d, "StudentNo", "StudentName");
 }

        public static string GetName(this string accountNo)
        {
            if (string.IsNullOrEmpty(accountNo)) return null;
            if (Maps.ContainsKey(accountNo)) return Maps[accountNo];

            var user = new Criteria<User>().Where(m => m.Name.Equals(accountNo)).Load();
            if (user == null) return null;
            Maps.Add(accountNo, user.Realname);
            return user.Realname;
        }

    protected void Display_View()
    {
        pnl_viewall.Visible = false;
        List<OrderData> orderList = new List<OrderData>();
        List<AddressData> aAddreses = new List<AddressData>();
        List<Ektron.Cms.Commerce.Basket> basketList;

        OrderApi orderApi = new OrderApi();
        BasketApi basketApi = new BasketApi();
        // customer
        cCustomer = CustomerManager.GetItem(this.m_iID);
        m_iCustomerId = cCustomer.Id;
        this.ltr_id.Text = cCustomer.Id.ToString();
        this.ltr_uname.Text = cCustomer.UserName;
        this.ltr_fname.Text = cCustomer.FirstName;
        this.ltr_lname.Text = cCustomer.LastName;

        this.ltr_dname.Text = cCustomer.DisplayName;
        this.ltr_ordertotal.Text = cCustomer.TotalOrders.ToString();
        this.ltr_orderval.Text = defaultCurrency.ISOCurrencySymbol + EkFunctions.FormatCurrency(cCustomer.TotalOrderValue, defaultCurrency.CultureCode);
        this.ltr_pervalue.Text = defaultCurrency.ISOCurrencySymbol + EkFunctions.FormatCurrency(cCustomer.AverageOrderValue, defaultCurrency.CultureCode);
        // customer
        // orders
        Criteria<OrderProperty> orderCriteria = new Criteria<OrderProperty>();
        orderCriteria.AddFilter(OrderProperty.CustomerId, CriteriaFilterOperator.EqualTo, m_iID);
        orderList = orderApi.GetList(orderCriteria);
        if (orderList.Count == 0)
        {
            ltr_orders.Text = this.GetMessage("lbl no orders");
        }
        dg_orders.DataSource = orderList;
        dg_orders.DataBind();
        // orders
        // addresses
        aAddreses = AddressManager.GetList(m_iID);
        if (aAddreses.Count == 0)
        {
            ltr_address.Text = this.GetMessage("lbl no addresses");
        }
        dg_address.DataSource = aAddreses;
        dg_address.DataBind();
        // addresses
        // baskets
        if (this.m_iID > 0)
        {
            basketList = basketApi.GetList(this.m_iID);
            if (basketList.Count == 0)
            {
                ltr_baskets.Text = this.GetMessage("lbl no baskets");
            }
            dg_baskets.DataSource = basketList;
            dg_baskets.DataBind();
        }
    }

 public static SelectList DepartmentList()
 {
     var q = new Criteria<SchoolDepartment>();
     var d = q.Find();
     foreach (var item in d)
     {
         item.Name = string.Format("{0} [{1}]", item.Name, item.ShortName);
     }
     d.Insert(0, new SchoolDepartment { Id = 0, Name = "无" });
     return new SelectList(d, "Id", "Name");
 }

        private void DoConditionlessQuery(Func<FilterDescriptor<ElasticSearchProject>, BaseFilter> filter)
        {
            var criteria = new Criteria { };
            var s = new SearchDescriptor<ElasticSearchProject>()
                .Strict()
                .From(0)
                .Take(10)
                .Filter(filter);

            this.JsonEquals(s, System.Reflection.MethodInfo.GetCurrentMethod(), "MatchAll");
        }

 public void TestCriteria()
 {
     //---------------Set up test pack-------------------
     var selectQuery = new SelectQuery {Source = new Source("bob")};
     //---------------Execute Test ----------------------
     var criteria = new Criteria("test", Criteria.ComparisonOp.Equals, "testValue");
     selectQuery.Criteria = criteria;
     //---------------Test Result -----------------------
     Assert.AreSame(criteria, selectQuery.Criteria);
     //---------------Tear Down -------------------------
 }

        public void TestConstructor()
        {
            //-------------Setup Test Pack ------------------
            const string surname = "Surname";
            string surnameValue = TestUtil.GetRandomString();
            Criteria criteria = new Criteria(surname, Criteria.ComparisonOp.Equals, surnameValue);

            //-------------Execute test ---------------------
            CriteriaDB criteriaDB = new CriteriaDB(criteria);
            //-------------Test Result ----------------------
            Assert.AreEqual(criteria, criteriaDB);
        }

    public Criteria<OrderProperty> Util_GetDates(Criteria<OrderProperty> orderCriteria)
    {
        string periodText = String.Empty;

        switch (hdn_filter.Value)
        {
            case "#yesterday":
                periodText = GetMessage("lbl yesterday");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.LessThanOrEqualTo, DateTime.Now.Date);
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Date.Subtract(new TimeSpan(1, 0, 0, 0)));
                break;

            case "#thisweek":
                periodText = GetMessage("lbl this week");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Subtract(new TimeSpan(DateTime.Now.DayOfWeek.GetHashCode(), 0, 0, 0)));
                break;

            case "#last7days":
                periodText = GetMessage("lbl last seven days");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Subtract(new TimeSpan(7, 0, 0, 0)));
                break;

            case "#thismonth":
                periodText = GetMessage("lbl this month");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Subtract(new TimeSpan(DateTime.Now.Date.Day, 0, 0, 0)));
                break;

            case "#last30days":
                periodText = GetMessage("lbl last thirty days");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Subtract(new TimeSpan(30, 0, 0, 0)));
                break;

            case "#thisyear":
                periodText = GetMessage("lbl this year");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Subtract(new TimeSpan(DateTime.Now.DayOfYear, 0, 0, 0)));
                break;

            default: // "#today":
                periodText = GetMessage("today");
                orderCriteria.AddFilter(OrderProperty.DateCreated, CriteriaFilterOperator.GreaterThanOrEqualTo, DateTime.Now.Date);
                break;
        }

        SetTitle(GetMessage("lbl top products label"));
        ltr_period.Text = "<a href=\"#periodMenu" + this.ClientID + "\" class=\"commerceperiod" + this.ClientID + " commerceperiodlink\">"
            + periodText + "</a>" + "&#160;&#160;&#160;"
            + GetMessage("lbl quantity") + "&#160;"
            + "<a href=\"#\" class=\"quantitySection" + this.ClientID + " commerceactionlink\" >"
            + _qty.ToString() + "</a>";

        return orderCriteria;
    }

 private void MergeCriteriaSource(Criteria criteria)
 {
     if (criteria == null) return;
     if (criteria.IsComposite())
     {
         MergeCriteriaSource(criteria.LeftCriteria);
         MergeCriteriaSource(criteria.RightCriteria);
     }
     else
     {
         this.Source.MergeWith(criteria.Field.Source);
     }
 }

        public void TestEquals_Null()
        {
            //---------------Set up test pack-------------------
            DateTime dateTimeValue = DateTime.Now;
            const string datetimePropName = "DateTime";
            Criteria criteria1 = new Criteria(datetimePropName, Criteria.ComparisonOp.GreaterThan, dateTimeValue);

            //---------------Execute Test ----------------------
            bool areEquals = criteria1.Equals(null);
            //---------------Test Result -----------------------
            Assert.IsFalse(areEquals);
            //---------------Tear Down -------------------------
        }

        public void TestLeafProperties_AlternateConstructor()
        {
            //-------------Setup Test Pack ------------------
            QueryField field1 = new QueryField("MyField", "MyField", null);
            //-------------Test Pre-conditions --------------

            //-------------Execute test ---------------------
            Criteria criteria = new Criteria(field1, Criteria.ComparisonOp.Equals, "MyValue");

            //-------------Test Result ----------------------
            Assert.AreSame(field1, criteria.Field);
            Assert.AreEqual("MyValue", criteria.FieldValue);
            Assert.AreEqual(Criteria.ComparisonOp.Equals, criteria.ComparisonOperator);
        }