/// <summary>
/// 保存部门表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="departmentEntity">机构实体</param>
/// <returns></returns>
public void SaveForm(string keyValue, DepartmentEntity departmentEntity)
{
if (!string.IsNullOrEmpty(keyValue))
{
DepartmentEntity curEntity = this.BaseRepository().FindEntity(keyValue); //获取父对象
if (curEntity.OrganizeId != departmentEntity.OrganizeId || string.IsNullOrEmpty(curEntity.EnCode))
{
departmentEntity.EnCode = GetDepartmentCode(departmentEntity);
}
departmentEntity.Modify(keyValue);
this.BaseRepository().Update(departmentEntity);
if (curEntity.Nature == "承包商")
{
var expression = LinqExtensions.True <DepartmentEntity>();
expression = expression.And(t => t.ParentId == departmentEntity.DepartmentId);
var allc = this.BaseRepository().IQueryable(expression).ToList();
foreach (var item in allc)
{
//将此承包商下级的分包商的发包单位改为承包商的发包单位
item.SendDeptID = departmentEntity.SendDeptID;
item.SendDeptName = departmentEntity.SendDeptName;
this.BaseRepository().Update(item);
}
}
}
else
{
departmentEntity.EnCode = GetDepartmentCode(departmentEntity);
departmentEntity.Create();
if (departmentEntity.Nature == "分包商")
{
//将此分包商的发包单位改为此上级承包商的发包单位
DepartmentEntity curEntity = this.BaseRepository().FindEntity(departmentEntity.ParentId);
departmentEntity.SendDeptID = curEntity.SendDeptID;
departmentEntity.SendDeptName = curEntity.SendDeptName;
}
this.BaseRepository().Insert(departmentEntity);
}
}
/// <summary>
/// 清空日志
/// </summary>
/// <param name="categoryId">日志分类Id</param>
/// <param name="keepTime">保留时间段内</param>
public void RemoveLog(int categoryId, string keepTime)
{
DateTime operateTime = DateTime.Now;
if (keepTime == "7")//保留近一周
{
operateTime = DateTime.Now.AddDays(-7);
}
else if (keepTime == "1")//保留近一个月
{
operateTime = DateTime.Now.AddMonths(-1);
}
else if (keepTime == "3")//保留近三个月
{
operateTime = DateTime.Now.AddMonths(-3);
}
var expression = LinqExtensions.True <LogEntity>();
expression = expression.And(t => t.OperateTime <= operateTime);
expression = expression.And(t => t.CategoryId == categoryId);
this.BaseRepository().Delete(expression);
}
/// <summary>
/// Returns an enumerator that defines when this user defined universe will be invoked
/// </summary>
/// <returns>An enumerator of DateTime that defines when this universe will be invoked</returns>
public virtual IEnumerable <DateTime> GetTriggerTimes(DateTime startTimeUtc, DateTime endTimeUtc, MarketHoursDatabase marketHoursDatabase)
{
var exchangeHours = marketHoursDatabase.GetExchangeHours(Configuration);
var localStartTime = startTimeUtc.ConvertFromUtc(exchangeHours.TimeZone);
var localEndTime = endTimeUtc.ConvertFromUtc(exchangeHours.TimeZone);
var first = true;
foreach (var dateTime in LinqExtensions.Range(localStartTime, localEndTime, dt => dt + Interval))
{
if (first)
{
yield return(dateTime);
first = false;
}
else if (exchangeHours.IsOpen(dateTime, dateTime + Interval, Configuration.ExtendedMarketHours))
{
yield return(dateTime);
}
}
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns>返回分页列表</returns>
public IEnumerable <OrderEntity> GetPageList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <OrderEntity>();
var queryParam = queryJson.ToJObject();
//单据日期
if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
{
DateTime startTime = queryParam["StartTime"].ToDate();
DateTime endTime = queryParam["EndTime"].ToDate().AddDays(1);
expression = expression.And(t => t.OrderDate >= startTime && t.OrderDate <= endTime);
}
//单据编号
if (!queryParam["OrderCode"].IsEmpty())
{
string OrderCode = queryParam["OrderCode"].ToString();
expression = expression.And(t => t.OrderCode.Contains(OrderCode));
}
//客户名称
if (!queryParam["CustomerName"].IsEmpty())
{
string CustomerName = queryParam["CustomerName"].ToString();
expression = expression.And(t => t.CustomerName.Contains(CustomerName));
}
//销售人员
if (!queryParam["SellerName"].IsEmpty())
{
string SellerName = queryParam["SellerName"].ToString();
expression = expression.And(t => t.SellerName.Contains(SellerName));
}
//收款状态
if (!queryParam["PaymentState"].IsEmpty())
{
int PaymentState = queryParam["PaymentState"].ToInt();
expression = expression.And(t => t.PaymentState == PaymentState);
}
return(this.BaseRepository().FindList(expression, pagination));
}
/// <summary>
/// 保存实体数据
/// </summary>
/// <param name="keyValue">主键</param>
/// <param name="entity">数据实体</param>
/// <param name="formModuleContentEntity">表单内容数据</param>
/// <returns></returns>
public int SaveEntity(string keyValue, FormModuleRelationEntity entity, Form_ModuleContentEntity formModuleContentEntity)
{
var db = this.BaseRepository().BeginTrans();
try
{
var expression = LinqExtensions.True <Form_ModuleContentEntity>();
expression = expression.And(t => t.F_FrmId == entity.F_FrmId && t.F_FrmVersion == entity.F_FrmVersion);
Form_ModuleContentEntity form_ModuleContentEntity = db.FindEntity <Form_ModuleContentEntity>(expression);
if (form_ModuleContentEntity == null)
{
formModuleContentEntity.Create();
db.Insert(formModuleContentEntity);
entity.F_ModuleContentId = formModuleContentEntity.F_Id;
}
else
{
entity.F_ModuleContentId = form_ModuleContentEntity.F_Id;
}
if (string.IsNullOrEmpty(keyValue))
{
entity.Create();
db.Insert(entity);
}
else
{
entity.Modify(keyValue);
db.Update(entity);
}
db.Commit();
return(1);
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 工序设定表
/// </summary>
/// <summary>
/// 获取列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns>返回分页列表</returns>
public IEnumerable <Fclt_facilitiesEntity> GetPageList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <Fclt_facilitiesEntity>();
var queryParam = queryJson.ToJObject();
string sqlCondation = " ";
//查询条件
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
string condition = queryParam["condition"].ToString();
string keyword = queryParam["keyword"].ToString();
switch (condition)
{
case "All": //设备编码
sqlCondation = sqlCondation + " and (fclt_num like '%" + keyword + "%'";
sqlCondation = sqlCondation + " or fclt_name like '%" + keyword + "%'";
sqlCondation = sqlCondation + " or fclt_symbol like '%" + keyword + "%')";
break;
default:
break;
}
}
try
{
string sql = "select top 5000 * from fclt_facilities where FlagDelete=0 ";
sql += sqlCondation;
sql += " order by fclt_num";
return(this.ERPRepository().FindList(sql, pagination));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Performs universe selection using the data specified
/// </summary>
/// <param name="utcTime">The current utc time</param>
/// <param name="data">The symbols to remain in the universe</param>
/// <returns>The data that passes the filter</returns>
public override IEnumerable <Symbol> SelectSymbols(DateTime utcTime, BaseDataCollection data)
{
var futuresUniverseDataCollection = data as FuturesChainUniverseDataCollection;
if (futuresUniverseDataCollection == null)
{
throw new ArgumentException($"Expected data of type '{typeof(FuturesChainUniverseDataCollection).Name}'");
}
var underlying = new Tick {
Time = utcTime
};
// date change detection needs to be done in exchange time zone
if (_cacheDate == data.Time.ConvertFromUtc(Future.Exchange.TimeZone).Date)
{
return(Unchanged);
}
var availableContracts = futuresUniverseDataCollection.Data.Select(x => x.Symbol);
var results = Future.ContractFilter.Filter(new FutureFilterUniverse(availableContracts, underlying));
// if results are not dynamic, we cache them and won't call filtering till the end of the day
if (!results.IsDynamic)
{
_cacheDate = data.Time.ConvertFromUtc(Future.Exchange.TimeZone).Date;
}
#if NETCORE
var resultingSymbols = LinqExtensions.ToHashSet(results);
#else
var resultingSymbols = results.ToHashSet();
#endif
futuresUniverseDataCollection.FilteredContracts = resultingSymbols;
return(resultingSymbols);
}
/// <summary>
/// 列表关联分页
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public PageResult <IQueryable <PostDTO> > GetPageJoin(PostPageRequestDTO req)
{
#region 关闭LazyLoad使用贪婪加载查询关联表
//关闭LazyLoad使用贪婪加载查询关联表
//var include = _postRepository.GetAll().Include(p => p.Blog);
#endregion
#region Expression Tree MultiOption Search
var expression = LinqExtensions.True <Post>();
if (!string.IsNullOrEmpty(req.PostNameSearch))
{
expression = expression.And(t => t.Title.Contains(req.PostNameSearch));
}
if (!string.IsNullOrEmpty(req.BlogNameSearch))
{
expression = expression.And(t => t.Blog.Name.Contains(req.BlogNameSearch));
}
#endregion
#region Expression Tree MultiOption Order
#endregion
int totalcount;
var postpage = _postRepository.GetByPage(req.PageIndex, req.PageSize, expression, p => p.Id, true, out totalcount).Include(p => p.Blog).Select(p => new PostDTO
{
PostName = p.Title,
BlogName = p.Blog.Name,
//Tags=p.PostTags.
}).ToPage(totalcount);
return(postpage);
}
private IEnumerable <BpcSP006Entity> GetNewTaskList(string jxbm)
{
List <DbParameter> parameter = new List <DbParameter>();
var expression = LinqExtensions.True <RowColSettingModel>();
StringBuilder sbSql = new StringBuilder();
sbSql.Append(@"SELECT SP002.[RWBH],
NULL AS RWSJ,
SP004.USERID AS SHR,
SP005.USERID AS USERID,
'0' AS RWCD,
'0' AS SQZT,
'0' AS SHZT
FROM [HQPAS].[BPMS].[BPC_SP002] SP002
INNER JOIN [BPMS].[BPC_SP001] SP001
ON SP001.CJBBM = SP002.CJBBM
LEFT JOIN [BPMS].[BPC_SP004] SP004
ON SP004.CJBBM = SP002.CJBBM
AND SP004.ND = SP002.ND
LEFT JOIN [BPMS].[BPC_SP005] SP005
ON SP005.CJBBM = SP002.CJBBM
AND SP005.ND = SP002.ND
WHERE ( SP005.USERID IS NOT NULL )
AND NOT EXISTS (SELECT 1
FROM [BPMS].[BPC_SP006] SP006
WHERE SP006.RWBH = SP002.RWBH
AND SP006.USERID = SP005.USERID)
");
if (!jxbm.IsEmpty())
{
sbSql.Append(" AND SP002.[JXBM] = @jxbm ");
parameter.Add(DbParameters.CreateDbParameter("@jxbm", jxbm));
}
return(new RepositoryFactory().HQPASRepository()
.FindList <BpcSP006Entity>(sbSql.ToString(), parameter.ToArray()));
}
/// <summary>
/// 电表列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <AmmeEntity> GetPageList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <AmmeEntity>();
var queryParam = queryJson.ToJObject();
string sqlCondation = " ";
//查询条件
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
string condition = queryParam["condition"].ToString();
string keyword = queryParam["keyword"].ToString();
switch (condition)
{
case "All":
sqlCondation = sqlCondation + " and (a_ammeName like '%" + keyword + "%'";
sqlCondation = sqlCondation + " or a_ammeNo like '%" + keyword + "%'";
sqlCondation = sqlCondation + " or a_DeptTow like '%" + keyword + "%'";
sqlCondation = sqlCondation + " or a_DeptThree like '%" + keyword + "%'";
sqlCondation = sqlCondation + " or a_Dept like '%" + keyword + "%')";
break;
default:
break;
}
}
try
{
string sql = "select * from fclt_ammeters where 1=1 AND FlagDelete = 0 AND a_Dept <> '废表' ";
sql += sqlCondation;
return(this.ERPRepository().FindList(sql, pagination).OrderBy(t => t.a_ammeNo));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取跟进记录
/// </summary>
/// <param name="objectId">对象Id</param>
/// <param name="pagination">分页</param>
/// <param name="queryJson">条件</param>
/// <returns></returns>
public IEnumerable <TrailRecordEntity> GetPageList(string objectId, Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <TrailRecordEntity>();
var queryParam = queryJson.ToJObject();
expression = expression.And(t => t.ObjectId == objectId && t.DeleteMark == 0 && t.EnabledMark > 0);
//查询条件
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
string condition = queryParam["condition"].ToString();
string keyword = queryParam["keyword"].ToString();
switch (condition)
{
case "TrackContent": //跟进内容
expression = expression.And(t => t.TrackContent.Contains(keyword));
break;
default:
break;
}
}
return(this.BaseRepository().FindList(expression, pagination));
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="queryJson">查询参数</param>
/// <returns>返回列表</returns>
public IEnumerable <Pay_InfoEntity> GetList(string queryJson)
{
var expression = LinqExtensions.True <Pay_InfoEntity>();
var queryParam = queryJson.ToJObject();
if (!queryParam["Approval_Status"].IsEmpty())
{
string Approval_Status = queryParam["Approval_Status"].ToString();
expression = expression.And(t => t.Approval_Status == Approval_Status);
}
if (!queryParam["Pay_CompletetimeBegin"].IsEmpty())
{
var Pay_CompletetimeBegin = DateTime.Parse(queryParam["Pay_CompletetimeBegin"].ToString());
expression = expression.And(t => t.Pay_Completetime >= Pay_CompletetimeBegin);
}
if (!queryParam["Pay_CompletetimeEnd"].IsEmpty())
{
var Pay_CompletetimeEnd = DateTime.Parse(queryParam["Pay_CompletetimeEnd"].ToString());
expression = expression.And(t => t.Pay_Completetime <= Pay_CompletetimeEnd);
}
expression = expression.And(t => t.DeleteMark == 0);
return(this.BaseRepository().IQueryable(expression).ToList());
}
private Expression <Func <DataDictDetailEntity, bool> > ListFilter(DataDictDetailListParam param)
{
var expression = LinqExtensions.True <DataDictDetailEntity>();
if (param != null)
{
if (param.DictKey.ParseToInt() > 0)
{
expression = expression.And(t => t.DictKey == param.DictKey);
}
if (!string.IsNullOrEmpty(param.DictValue))
{
expression = expression.And(t => t.DictValue.Contains(param.DictValue));
}
if (!string.IsNullOrEmpty(param.DictType))
{
expression = expression.And(t => t.DictType.Contains(param.DictType));
}
}
return(expression);
}
public DashboardViewModel createViewModel()
{
var dashboard = new DashboardViewModel();
var scenarios = new List <ScenarioViewModel>();
scenarioRepository
.Fetch()
.ForEach(scenario => scenarios.Add(new ScenarioViewModel(scenario)));
scenarios.ForEach(scenario =>
{
dashboard.TotalScenarios += 1;
dashboard.RunTime += scenario.LastRunTime;
if (scenario.LastRunStatus != ScenarioLastRunStatus.NOTRUN)
{
dashboard.CurrentScenario += 1;
}
});
dashboard.ScenariosNodes = LinqExtensions.SplitGroup(scenarios, 5);
return(dashboard);
}
/// <summary>
/// 医疗机构注册列表
/// </summary>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <PMR005OrgEntity> GetList(string queryJson)
{
var expression = LinqExtensions.True <PMR005OrgEntity>();
var queryParam = queryJson.ToJObject();
//查询条件
if (!queryParam["keyword"].IsEmpty())
{
string keyword = queryParam["keyword"].ToString();
expression = expression.And(t => t.MANAGERORGNAME.Contains(keyword) ||
t.SHORTNAME.Contains(keyword) ||
t.PY.Contains(keyword) ||
t.WB.Contains(keyword));
}
if (!queryParam["orgid"].IsEmpty())
{
string keyword = queryParam["orgid"].ToString();
expression = expression.And(t => t.ADMINISTRATIVECODE == keyword);
}
return(this.HQPASRepository().IQueryable(expression));
}
public async Task <IActionResult> RefreshToken(string token, string refreshToken)
{
var principal = _jwtTokenService.GetPrincipalFromExpiredToken(token);
var username = principal.Identity.Name;
var savedRefreshToken = await _accountFacade.GetRefreshToken(username); //retrieve the refresh token from a data store
if (savedRefreshToken != refreshToken)
{
throw new SecurityTokenException("Invalid refresh token");
}
var newJwtToken = _jwtTokenService.GenerateToken(principal.Claims.ToList());
var newRefreshToken = _jwtTokenService.GenerateRefreshToken();
await _accountFacade.UpdateRefreshToken(username, newRefreshToken);
var result = LinqExtensions.CreateSuccessResponse <RefreshTokenContract>(
new RefreshTokenContract
{
Token = newJwtToken,
RefreshToken = newRefreshToken
});
return(Ok(result));
}
//投资理财套餐
public ActionResult InvestPackage()
{
ApiParamter param = GetRequestParamter <ApiParamter>();
bool isret;
tMembersEntity member;
ActionResult ar = AnalysisToken(param, out isret, out member);
if (isret)
{
return(ar);
}
var where = LinqExtensions.True <tInvestPackageEntity>();
where = where.And(p => p.pkState.Equals(1));
var list = tInvestPackageBLL.Instance.GetList(where).OrderBy(p => p.pkLevel);
return(RetJsonResult(ApiResponseCodeEnum.Success, "", list.Select(r => new
{
r.pkId,
pkName = string.Format("{0}{1}$-{2}$", r.pkName, r.pkMinAmount, r.pkMaxAmount)
})));
}
/// <summary>
/// 分页查询设备巡回检查表
/// </summary>
/// <param name="pagination">分页信息</param>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <DeviceInspectionJobEntity> GetPageList(Pagination pagination, string queryJson)
{
IRepository db = new RepositoryFactory().BaseRepository();
var expression = LinqExtensions.True <DeviceInspectionJobEntity>();
var queryParam = queryJson.ToJObject();
if (!queryParam["keyword"].IsEmpty())
{
string keyWord = queryParam["keyword"].ToString();
expression = expression.And(t => t.InspectionName.Contains(keyWord) || t.DeviceSystem.Contains(keyWord));
}
if (!queryParam["code"].IsEmpty())
{
string code = queryParam["code"].ToString();
expression = expression.And(x => x.DeptCode.StartsWith(code));
}
var query = BaseRepository().IQueryable(expression);
int count = 0;
var data = DataHelper.DataPaging(pagination.rows, pagination.page, query.OrderByDescending(x => x.CreateDate), out count);
pagination.records = count;
return(data);
}
/// <summary>
/// 分析器基本信息列表
/// </summary>
/// <param name="pagination">分页参数</param>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <BpcSM006Entity> GetList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <BpcSM006Entity>();
var queryParam = queryJson.ToJObject();
//分析器类型
if (!queryParam["type"].IsEmpty())
{
string keyword = queryParam["type"].ToString();
expression = expression.And(t => t.FXQLX == keyword);
}
//查询条件
if (!queryParam["keyword"].IsEmpty())
{
string keyword = queryParam["keyword"].ToString();
expression = expression.And(t => t.FXQBM.Contains(keyword) ||
t.FXQMC.Contains(keyword));
}
expression = expression.And(t => t.STATUS == "1");
return(this.HQPASRepository().FindList(expression, pagination));
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns>返回分页列表</returns>
public IEnumerable <Sxc_TeacherEntity> GetPageList(Pagination pagination, string queryJson)
{
//return this.BaseRepository(DbName).FindList(pagination);
int total;
var expression = LinqExtensions.True <Sxc_TeacherEntity>();
var queryParam = queryJson.ToJObject();
if (!queryParam["Name"].IsEmpty())
{
string keyord = queryParam["Name"].ToString();
expression = expression.And(t => t.Name.Contains(keyord));
}
PropertySortCondition[] ps = new[] { new PropertySortCondition("ID", ListSortDirection.Ascending) };
//Include("Agent").Include("UserPayment"). Where(x=>true
//Include(t=>t.UserPayment.User.UserProfile).
var query = this.BaseRepository(DbName).IQueryable().Where(expression, pagination.page, pagination.rows, out total, ps).AsEnumerable();
pagination.records = total;
return(query);
}
/// <summary>
/// 下一年度改进报告列表
/// </summary>
/// <param name="pagination">分页参数</param>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <BpeRA004Entity> GetList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <BpeRA004Entity>();
var queryParam = queryJson.ToJObject();
//绩效年度编码
if (!queryParam["jxbm"].IsEmpty())
{
string keyword = queryParam["jxbm"].ToString();
expression = expression.And(t => t.JXBM == keyword);
}
//科室编码
if (!queryParam["deptcode"].IsEmpty())
{
string keyword = queryParam["deptcode"].ToString();
expression = expression.And(t => t.JGBM == keyword);
}
expression = expression.And(t => t.STATUS == "1");
return(this.HQPASRepository().FindList(expression, pagination));
}
/// <summary>
/// 取行排序数据
/// </summary>
/// <param name="pagination"></param>
/// <param name="tbBm"></param>
/// <returns></returns>
public IEnumerable <BpcSc003Entity> GetColSetting(Pagination pagination, string tbBm)
{
List <DbParameter> parameter = new List <DbParameter>();
var expression = LinqExtensions.True <BpcSc003Entity>();
expression = expression.And(t => t.CJBBM == tbBm);
return(HQPASRepository().FindList(expression, pagination));
// StringBuilder sbSql = new StringBuilder();
// sbSql.Append(@"SELECT A.HXBM,
// b.NAME AS RowName,
// A.CJBBM,
// b.SFZD,A.PX
// FROM bpms.BPC_SC002 A
// INNER JOIN bpms.BPC_SC001 B
// ON A.HXBM = b.HXBM
//where 1=1
//");
// sbSql.Append(" and A.CJBBM=@CJBBM and B.SFZD=1");
// parameter.Add(DbParameters.CreateDbParameter("@CJBBM", tbBm));
//return new RepositoryFactory().HQPASRepository()
// .FindList<BpcSc003Entity>(sbSql.ToString(), parameter.ToArray(), pagination);
}
/// <summary>
/// 工序设定表
/// </summary>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <mes_pro_check_setEntity> GetPageList(string queryJson)
{
var expression = LinqExtensions.True <mes_pro_check_setEntity>();
var queryParam = queryJson.ToJObject();
//查询条件
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
string condition = queryParam["condition"].ToString();
string keyword = queryParam["keyword"].ToString();
switch (condition)
{
case "mecs_proIDEnd": //工序权限表完工ID
expression = expression.And(t => t.mpcs_proIDEnd.Equals(keyword));
break;
default:
break;
}
}
expression = expression.And(t => t.FlagDelete == "0");
return(this.ERPRepository().IQueryable(expression).OrderByDescending(t => t.CreationDate).ToList());
}
/// <summary>
/// 获取应急演练步骤人员
/// </summary>
/// <returns></returns>
public IList <EmergencyReportStepsEntity> GetEmergencyReportStepsList(string EmergencyId, string EmergencyReportId)
{
try
{
var list = new List <EmergencyReportStepsEntity>();
var expression = LinqExtensions.True <EmergencyReportStepsEntity>();
if (!string.IsNullOrEmpty(EmergencyReportId))
{
expression = expression.And(t => t.EmergencyReportId == EmergencyReportId);
}
if (!string.IsNullOrEmpty(EmergencyId))
{
expression = expression.And(t => t.EmergencyId == EmergencyId);
}
var db = new RepositoryFactory().BaseRepository();
list = db.IQueryable <EmergencyReportStepsEntity>(expression).ToList();
return(list);
}
catch (Exception ex)
{
return(new List <EmergencyReportStepsEntity>());
}
}
/// <summary>
/// 分页获取列表
/// </summary>
/// <param name="pagination"></param>
/// <param name="queryJson"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public IEnumerable <BpcSc001Entity> GetPageList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <BpcSc001Entity>();
var queryParam = queryJson.ToJObject();
if (!queryParam["rowName"].IsEmpty())
{
string rowName = queryParam["rowName"].ToString();
expression = expression.And(t => t.NAME == rowName);
}
if (!queryParam["isDictionary"].IsEmpty())
{
string isDictionary = queryParam["isDictionary"].ToString();
expression = expression.And(t => t.SFZD == isDictionary);
}
if (!queryParam["status"].IsEmpty())
{
string status = queryParam["status"].ToString();
expression = expression.And(t => t.STATUS == status);
}
return(HQPASRepository().FindList(expression, pagination));
}
/// g更新操作
/// </summary>
/// <param name="uid">用户主键</param>
/// <param name="oid">关联主键</param>
/// <param name="category">类型</param>
/// <param name="operatType"></param>
public int SignInMark(string uid, string oid, string category, OperatType operatType, string SignInDescription)
{
//MessageReadEntity messageReadEntity = new MessageReadEntity();
var expression = LinqExtensions.True <MessageReadEntity>();
expression = expression.And(t => t.UserId == uid && t.MessageId == oid && t.Category == category);
var messageReadEntity = this.BaseRepository().FindEntity(expression);
if (messageReadEntity != null)
{
messageReadEntity.Uniqueid = messageReadEntity.Uniqueid;
messageReadEntity.SignInDescription = SignInDescription;
if (operatType == OperatType.AttendExpo)
{
messageReadEntity.AttendExpo = true;
}
if (operatType == OperatType.NoAttendExpo)
{
messageReadEntity.SignInMark = false;
}
if (operatType == OperatType.SignIn)
{
if (messageReadEntity.SignInMark == false)
{
messageReadEntity.SignInMark = true; messageReadEntity.SignInDate = DateTime.Now;
}
}
messageReadEntity.Modify(messageReadEntity.Uniqueid);
this.BaseRepository().Update(messageReadEntity);
return(1);
}
else
{
return(-1);
}
}
/// <summary>
/// 列表分页 card
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数
/// {"deptid":" DeptCode StartsWith查询 无根据userid获取" }
/// </param>
/// <param name="userid">userid</param>
/// <returns></returns>
public List <CCardEntity> GetCPageList(Pagination pagination, string queryJson, string userid)
{
var db = new RepositoryFactory().BaseRepository();
var queryParam = queryJson.ToJObject();
var Expression = LinqExtensions.True <CCardEntity>();
var user = db.FindEntity <UserEntity>(userid);
if (user.UserId == "System")
{
user.DepartmentCode = "0";
}
//模糊查询 任务名称
if (!queryParam["workname"].IsEmpty())
{
var workname = queryParam["workname"].ToString();
Expression = Expression.And(x => x.WorkName.Contains(workname));
}
//DeptCode StartsWith查询
if (!queryParam["deptid"].IsEmpty())
{
var deptid = queryParam["deptid"].ToString();
var dept = db.FindEntity <DepartmentEntity>(deptid);
Expression = Expression.And(x => x.DeptCode.StartsWith(dept.EnCode));
}
//else
//{
// Expression = Expression.And(x => x.DeptCode.StartsWith(user.DepartmentCode));
//}
var entity = db.FindList(Expression).OrderByDescending(x => x.CreateDate);
pagination.records = entity.Count();
var entityList = entity.Skip(pagination.rows * (pagination.page - 1)).Take(pagination.rows);
return(entityList.ToList());
}
/// <summary>
/// 职位列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns></returns>
public IEnumerable <RoleEntity> GetPageList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <RoleEntity>();
JObject queryParam = queryJson.ToJObject();
if (queryParam != null)
{
//机构主键
if (!queryParam["organizeId"].IsEmpty())
{
string organizeId = queryParam["organizeId"].ToString();
expression = expression.And(t => t.OrganizeId.Equals(organizeId));
}
//查询条件
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
string condition = queryParam["condition"].ToString();
string keyword = queryParam["keyword"].ToString();
switch (condition)
{
case "EnCode": //职位编号
expression = expression.And(t => t.EnCode.Contains(keyword));
break;
case "FullName": //职位名称
expression = expression.And(t => t.FullName.Contains(keyword));
break;
default:
break;
}
}
}
expression = expression.And(t => t.Category == 3);
return(this.BaseRepository().FindList(expression, pagination));
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="pagination">分页</param>
/// <param name="queryJson">查询参数</param>
/// <returns>返回分页列表</returns>
public IEnumerable <Sale_CustomerEntity> GetPageList(Pagination pagination, string queryJson)
{
var expression = LinqExtensions.True <Sale_CustomerEntity>();
var queryParam = queryJson.ToJObject();
string strSql = "select * from Sale_Customer where 1=1";
//单据日期
if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
{
DateTime startTime = queryParam["StartTime"].ToDate();
DateTime endTime = queryParam["EndTime"].ToDate().AddDays(1);
strSql += " and CreateTime >= '" + startTime + "' and CreateTime < '" + endTime + "'";
}
//客户公司名
if (!queryParam["CustomerCompany"].IsEmpty())
{
string CustomerCompany = queryParam["CustomerCompany"].ToString();
strSql += " and CustomerCompany = '" + CustomerCompany + "'";
}
//销售人
if (!queryParam["CreateUserId"].IsEmpty())
{
string CreateUserId = queryParam["CreateUserId"].ToString();
strSql += " and CreateUserId = '" + CreateUserId + "'";
}
else
{
if (!OperatorProvider.Provider.Current().IsSystem)
{
string dataAutor = string.Format(OperatorProvider.Provider.Current().DataAuthorize.ReadAutorize, OperatorProvider.Provider.Current().UserId);
strSql += " and (CreateUserId in (" + dataAutor + "))";
}
}
return(this.BaseRepository().FindList <Sale_CustomerEntity>(strSql.ToString(), pagination));
}
/// <summary>
/// 获取表单列表分页数据
/// </summary>
/// <param name="pagination">分页参数</param>
/// <param name="queryJson">查询条件</param>
/// <returns></returns>
public IEnumerable <FormModuleEntity> GetPageList(Pagination pagination, string queryJson)
{
try
{
var queryParam = queryJson.ToJObject();
var expression = LinqExtensions.True <FormModuleEntity>();
expression = expression.And(t => t.F_DeleteMark == 0);
if (!queryParam["F_FrmCategory"].IsEmpty())//分类查询
{
string f_FrmCategory = queryParam["F_FrmCategory"].ToString();
expression = expression.And(t => t.F_FrmCategory == f_FrmCategory);
}
else if (!queryParam["Keyword"].IsEmpty())//关键字查询
{
string keyword = queryParam["Keyword"].ToString();
expression = expression.And(t => t.F_FrmCode.Contains(keyword) || t.F_FrmName.Contains(keyword));
}
if (!queryParam["F_FrmType"].IsEmpty())//类型查询（系统表单，自定义表单，自定义表单建表）
{
int f_FrmType = Convert.ToInt32(queryParam["F_FrmType"].ToString());
expression = expression.And(t => t.F_FrmType == f_FrmType);
}
else if (!queryParam["F_FrmType2"].IsEmpty())//不等于某种类型
{
int f_FrmType2 = Convert.ToInt32(queryParam["F_FrmType2"].ToString());
expression = expression.And(t => t.F_FrmType != f_FrmType2);
}
return(this.BaseRepository().FindList <FormModuleEntity>(expression, pagination));
}
catch (Exception)
{
throw;
}
}
public void LinqExtensionsExample3TestMethod()
{
LinqExtensions _fc = new LinqExtensions();
Assert.AreEqual<string>("Name1:11000,00;Name3:130000,00", _fc.FromClauseExample3());
}
public void LinqExtensionsExample2TestMethod()
{
LinqExtensions _fc = new LinqExtensions();
Assert.AreEqual<string>("grape", _fc.FromClauseExample2());
}
