735 lines
34 KiB
C#
735 lines
34 KiB
C#
using IRaCIS.Application.ExpressionExtend;
|
|
using IRaCIS.Application.Interfaces;
|
|
using IRaCIS.Application.ViewModels;
|
|
using IRaCIS.Core.Application.Contracts.RequestAndResponse;
|
|
using IRaCIS.Core.Domain.Interfaces;
|
|
using IRaCIS.Core.Domain.Models;
|
|
using IRaCIS.Core.Domain.Share;
|
|
using IRaCIS.Infra.Data.ExpressionExtend;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
|
|
namespace IRaCIS.Application.Services
|
|
{
|
|
public class StatisticsService : IStatisticsService
|
|
{
|
|
private readonly IDoctorRepository _doctorRepository;
|
|
private readonly ITrialRepository _trialRepository;
|
|
private readonly IEnrollRepository _enrollRepository;
|
|
private readonly IWorkloadRepository _workloadRepository;
|
|
private readonly ICRORepository _croCompanyRepository;
|
|
private readonly IDictionaryRepository _dictionaryRepository;
|
|
private readonly IHospitalRepository _hospitalRepository;
|
|
private readonly IEnrollDetailRepository _enrollDetailRepository;
|
|
private readonly IUserRepository _userRepository;
|
|
private readonly IUserTrialRepository _userTrialRepository;
|
|
|
|
public StatisticsService(IDoctorRepository doctorRepository, ITrialRepository trialRepository,
|
|
IEnrollRepository intoGroupRepository, IWorkloadRepository workloadRepository,
|
|
ICRORepository croCompanyRepository,
|
|
IDictionaryRepository dictionaryRepository,
|
|
IHospitalRepository hospitalRepository,
|
|
IEnrollDetailRepository enrollDetailRepository, IUserRepository userRepository,
|
|
IUserTrialRepository userTrialRepository)
|
|
{
|
|
_doctorRepository = doctorRepository;
|
|
_trialRepository = trialRepository;
|
|
_enrollRepository = intoGroupRepository;
|
|
_workloadRepository = workloadRepository;
|
|
_croCompanyRepository = croCompanyRepository;
|
|
_dictionaryRepository = dictionaryRepository;
|
|
_hospitalRepository = hospitalRepository;
|
|
_enrollDetailRepository = enrollDetailRepository;
|
|
_userRepository = userRepository;
|
|
_userTrialRepository = userTrialRepository;
|
|
}
|
|
|
|
public PageOutput<WorkloadByTrialAndReviewerDTO> GetWorkloadByTrialAndReviewer(StatisticsWorkloadQueryParam param,
|
|
Guid userId)
|
|
{
|
|
var currentUser = _userRepository.FindSingleOrDefault(u => u.Id == userId);
|
|
|
|
var bDate = new DateTime(param.BeginDate.Year, param.BeginDate.Month, param.BeginDate.Day);
|
|
var eDate = new DateTime(param.EndDate.Year, param.EndDate.Month, param.EndDate.Day);
|
|
eDate = eDate.AddDays(1);
|
|
Expression<Func<Workload, bool>> workloadLambda = x => x.DataFrom == (int)WorkLoadFromStatus.FinalConfirm;
|
|
workloadLambda = workloadLambda.And(x => x.WorkTime >= bDate && x.WorkTime < eDate);
|
|
|
|
Expression<Func<Trial, bool>> trialLambda = x => true;
|
|
if (currentUser.SuperAdmin) //超级管理员按照条件查询所有
|
|
{
|
|
if (Guid.Empty != param.CroId && param.CroId != null)
|
|
{
|
|
trialLambda = trialLambda.And(u => u.CROId == param.CroId);
|
|
}
|
|
}
|
|
else if (currentUser.UserType.Contains("CROCoordinator")) //协调者看CRO下面的
|
|
{
|
|
trialLambda = trialLambda.And(u => u.CROId == currentUser.OrganizationId);
|
|
}
|
|
else //不管是精鼎的pm还是我们的pm 还是运维人员 只能看到自己参与项目的统计
|
|
{
|
|
List<Guid> trialIdList = _userTrialRepository.Find(u => u.UserId == userId&&u.SiteId==Guid.Empty).Select(u => u.TrialId).ToList();
|
|
trialLambda = trialLambda.And(u => trialIdList.Contains(u.Id));
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(param.TrialCode))
|
|
{
|
|
trialLambda = trialLambda.And(u => u.Code.Contains(param.TrialCode.Trim()));
|
|
}
|
|
|
|
Expression<Func<Doctor, bool>> doctorLambda = x => true;
|
|
if (!string.IsNullOrWhiteSpace(param.Reviewer))
|
|
{
|
|
|
|
var reviewer = param.Reviewer.Trim();
|
|
doctorLambda = doctorLambda.And(u => u.ChineseName.Contains(reviewer)
|
|
|| u.FirstName.Contains(reviewer)
|
|
|| u.LastName.Contains(reviewer)
|
|
|| u.Code.Contains(reviewer)
|
|
);
|
|
|
|
}
|
|
if (Guid.Empty != param.HospitalId && param.HospitalId != null)
|
|
{
|
|
doctorLambda = doctorLambda.And(u => u.HospitalId == param.HospitalId);
|
|
}
|
|
|
|
var workloadQuery = from workLoad in _workloadRepository.GetAll().Where(workloadLambda)
|
|
join trial in _trialRepository.Find(trialLambda)
|
|
on workLoad.TrialId equals trial.Id
|
|
join doctor in _doctorRepository.Find(doctorLambda)
|
|
on workLoad.DoctorId equals doctor.Id
|
|
group workLoad by new { workLoad.DoctorId, workLoad.TrialId }
|
|
into gWorkLoad
|
|
|
|
select new
|
|
{
|
|
DoctorId = gWorkLoad.Key.DoctorId,
|
|
TrialId = gWorkLoad.Key.TrialId,
|
|
Downtime = gWorkLoad.Sum(t => t.Downtime),
|
|
Training = gWorkLoad.Sum(t => t.Training),
|
|
Timepoint = gWorkLoad.Sum(t => t.Timepoint),
|
|
TimepointIn24H = gWorkLoad.Sum(t => t.TimepointIn24H),
|
|
TimepointIn48H = gWorkLoad.Sum(t => t.TimepointIn48H),
|
|
Global = gWorkLoad.Sum(t => t.Global),
|
|
Adjudication = gWorkLoad.Sum(t => t.Adjudication),
|
|
AdjudicationIn24H = gWorkLoad.Sum(t => t.AdjudicationIn24H),
|
|
AdjudicationIn48H = gWorkLoad.Sum(t => t.AdjudicationIn48H),
|
|
RefresherTraining= gWorkLoad.Sum(t => t.RefresherTraining),
|
|
|
|
};
|
|
var query = from w in workloadQuery
|
|
join trial in _trialRepository.Find(trialLambda) on w.TrialId equals trial.Id into t
|
|
from trialItem in t.DefaultIfEmpty()
|
|
join doctor in _doctorRepository.Find(doctorLambda) on w.DoctorId equals doctor.Id into tt
|
|
from doctorItem in tt.DefaultIfEmpty()
|
|
join cro in _croCompanyRepository.GetAll() on trialItem.CROId equals cro.Id into ttt
|
|
from croItem in ttt.DefaultIfEmpty()
|
|
select new WorkloadByTrialAndReviewerDTO
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
TrialId = trialItem.Id,
|
|
Indication = trialItem.Indication,
|
|
TrialCode = trialItem.Code,
|
|
CroId = trialItem.CROId,
|
|
Cro = croItem.CROName,
|
|
ReviewerCode = doctorItem.Code,
|
|
ChineseName = doctorItem.ChineseName,
|
|
FirstName = doctorItem.FirstName,
|
|
LastName = doctorItem.LastName,
|
|
Training = w.Training,
|
|
Timepoint = w.Timepoint,
|
|
TimepointIn24H = w.TimepointIn24H,
|
|
TimepointIn48H = w.TimepointIn48H,
|
|
Adjudication = w.Adjudication,
|
|
AdjudicationIn24H = w.AdjudicationIn24H,
|
|
AdjudicationIn48H = w.AdjudicationIn48H,
|
|
Global = w.Global,
|
|
Downtime = w.Downtime,
|
|
RefresherTraining=w.RefresherTraining,
|
|
|
|
PersonalTotal = w.Timepoint + w.TimepointIn24H + w.TimepointIn48H + w.Adjudication + w.AdjudicationIn24H +
|
|
w.AdjudicationIn48H + w.Global
|
|
};
|
|
|
|
var propName = param.SortField == "" ? "ReviewerCode" : param.SortField;
|
|
query = param.Asc
|
|
? query.OrderBy(propName).ThenBy(t=>t.TrialCode).ThenBy(u=>u.ReviewerCode)
|
|
: query.OrderByDescending(propName).ThenBy(t => t.TrialCode).ThenBy(u => u.ReviewerCode);
|
|
if (propName == "FirstName" || propName == "LastName")
|
|
{
|
|
query = param.Asc
|
|
? query.OrderBy(t => t.LastName).ThenBy(t => t.FirstName)
|
|
: query.OrderByDescending(t => t.LastName).ThenBy(t => t.FirstName);
|
|
}
|
|
var count = query.Count();
|
|
|
|
query = query
|
|
.Skip((param.PageIndex - 1) * param.PageSize)
|
|
.Take(param.PageSize);
|
|
var doctorViewList = query.ToList();
|
|
|
|
return new PageOutput<WorkloadByTrialAndReviewerDTO>(param.PageIndex, param.PageSize, count, doctorViewList);
|
|
}
|
|
public PageOutput<EnrollStatByReviewerDTO> GetEnrollStatByReviewer(EnrollStatByReviewerQueryDTO param)
|
|
{
|
|
var bDate = new DateTime(param.BeginDate.Year, param.BeginDate.Month, 1);
|
|
var eDate = new DateTime(param.EndDate.Year, param.EndDate.Month, 1);
|
|
eDate = eDate.AddMonths(1);
|
|
|
|
Expression<Func<Enroll, bool>> enrollLambda = x => true;
|
|
enrollLambda = enrollLambda.And(x => x.EnrollTime >= bDate && x.EnrollTime < eDate);
|
|
|
|
Expression<Func<Hospital, bool>> hospitalLambda = x => true;
|
|
if (Guid.Empty != param.HospitalId&& param.HospitalId!=null)
|
|
{
|
|
hospitalLambda = hospitalLambda.And(u => u.Id == param.HospitalId);
|
|
}
|
|
|
|
Expression<Func<Doctor, bool>> doctorLambda = x => true;
|
|
if (!string.IsNullOrWhiteSpace(param.Reviewer))
|
|
{
|
|
|
|
var reviewer = param.Reviewer.Trim();
|
|
doctorLambda = doctorLambda.And(u => u.ChineseName.Contains(reviewer)
|
|
|| u.FirstName.Contains(reviewer)
|
|
|| u.LastName.Contains(reviewer)
|
|
|| u.Code.Contains(reviewer)
|
|
);
|
|
}
|
|
|
|
var enrollQueryable =
|
|
from enroll in _enrollRepository.Find(enrollLambda)
|
|
group enroll by new { enroll.DoctorId }
|
|
into g
|
|
select new
|
|
{
|
|
DoctorId = g.Key.DoctorId,
|
|
Submitted = g.Sum(t =>
|
|
t.EnrollStatus == (int)EnrollStatus.HasCommittedToCRO?1:0),
|
|
Approved = g.Sum(t =>
|
|
t.EnrollStatus == (int)EnrollStatus.InviteIntoGroup?1:0),
|
|
Reading = g.Sum(t =>
|
|
t.EnrollStatus == (int)EnrollStatus.DoctorReading?1:0),
|
|
Finished = g.Sum(t =>
|
|
t.EnrollStatus >= (int)EnrollStatus.End?1:0),
|
|
};
|
|
|
|
|
|
var query = from w in enrollQueryable
|
|
|
|
join doctor in _doctorRepository.Find(doctorLambda) on w.DoctorId equals doctor.Id
|
|
join hospital in _hospitalRepository.Find(hospitalLambda) on doctor.HospitalId equals hospital.Id
|
|
select new EnrollStatByReviewerDTO
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
Hospital = hospital.HospitalName,
|
|
ReviewerCode = doctor.Code,
|
|
ChineseName = doctor.ChineseName,
|
|
FirstName = doctor.FirstName,
|
|
LastName = doctor.LastName,
|
|
Pending = w.Submitted,
|
|
Approved = w.Approved,
|
|
Reading = w.Reading,
|
|
Finished = w.Finished,
|
|
|
|
Total = w.Submitted+ w.Approved+ w.Reading+ w.Finished
|
|
};
|
|
|
|
if (param.SortField != "EntryRate")
|
|
{
|
|
var propName = param.SortField == "" ? "ReviewerCode" : param.SortField;
|
|
query = param.Asc
|
|
? query.OrderBy(propName).ThenBy(u => u.ReviewerCode)
|
|
: query.OrderByDescending(propName).ThenBy(u => u.ReviewerCode);
|
|
if (propName == "FirstName" || propName == "LastName")
|
|
{
|
|
query = param.Asc
|
|
? query.OrderBy(t => t.LastName).ThenBy(t => t.FirstName)
|
|
: query.OrderByDescending(t => t.LastName).ThenBy(t => t.FirstName);
|
|
}
|
|
}
|
|
|
|
|
|
var count = query.Count();
|
|
query = query
|
|
.Skip((param.PageIndex - 1) * param.PageSize)
|
|
.Take(param.PageSize);
|
|
var list = query.ToList();
|
|
|
|
if (param.SortField == "EntryRate")
|
|
{
|
|
list = param.Asc
|
|
? list.OrderBy(t => t.EntryRate).ToList()
|
|
: list.OrderByDescending(t => t.EntryRate).ToList();
|
|
}
|
|
|
|
return new PageOutput<EnrollStatByReviewerDTO>(param.PageIndex, param.PageSize, count, list);
|
|
}
|
|
|
|
public PageOutput<EnrollStatByTrialDTO> GetEnrollStatByTrial(EnrollStatByTrialQueryDTO param)
|
|
{
|
|
|
|
#region 筛选条件
|
|
|
|
Expression<Func<Trial, bool>> trialLambda = x => true;
|
|
|
|
if (param.Expedited != null)
|
|
{
|
|
trialLambda = trialLambda.And(o => o.Expedited == param.Expedited);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(param.TrialCode))
|
|
{
|
|
var code = param.TrialCode.Trim();
|
|
trialLambda = trialLambda.And(o => o.Code.Contains(code));
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(param.Indication))
|
|
{
|
|
var indication = param.Indication.Trim();
|
|
trialLambda = trialLambda.And(o => o.Indication.Contains(indication));
|
|
}
|
|
|
|
if (param.CROId != Guid.Empty&& param.CROId != null)
|
|
{
|
|
trialLambda = trialLambda.And(o => o.CROId == param.CROId);
|
|
}
|
|
|
|
|
|
if (param.BeginDate != null && param.EndDate != null)
|
|
{
|
|
var bDate = new DateTime(param.BeginDate.Value.Year, param.BeginDate.Value.Month, param.BeginDate.Value.Day);
|
|
var eDate = new DateTime(param.EndDate.Value.Year, param.EndDate.Value.Month, param.BeginDate.Value.Day);
|
|
eDate = eDate.AddMonths(1);
|
|
|
|
trialLambda = trialLambda.And(o => o.CreateTime>=bDate&&o.CreateTime<eDate);
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
var trialEnrollStatQuery = _enrollRepository.GetAll()
|
|
.Where(t => t.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup).GroupBy(t => t.TrialId).Select(g => new
|
|
{
|
|
TrialId = g.Key,
|
|
EnrollCount = g.Count()
|
|
});
|
|
|
|
var trialQuery = from trial in _trialRepository.GetAll().Where(trialLambda)
|
|
join cro in _croCompanyRepository.GetAll() on trial.CROId equals cro.Id into t
|
|
from cro in t.DefaultIfEmpty()
|
|
|
|
join trialEnroll in trialEnrollStatQuery on trial.Id equals trialEnroll.TrialId
|
|
select new EnrollStatByTrialDTO
|
|
{
|
|
TrialId= trial.Id,
|
|
Cro = cro != null ? cro.CROName : "",
|
|
Expedited = trial.Expedited,
|
|
Indication = trial.Indication,
|
|
TrialCode = trial.Code,
|
|
EnrollCount= trialEnroll.EnrollCount,
|
|
CreateTime = trial.CreateTime
|
|
};
|
|
|
|
var propName = param.SortField == "" ? "TrialCode" : param.SortField;
|
|
trialQuery = param.Asc
|
|
? trialQuery.OrderBy(propName)
|
|
: trialQuery.OrderByDescending(propName);
|
|
|
|
var count = trialQuery.Count();
|
|
|
|
trialQuery = trialQuery
|
|
.Skip((param.PageIndex - 1) * param.PageSize)
|
|
.Take(param.PageSize);
|
|
|
|
var trialList = trialQuery.ToList();
|
|
|
|
var trialIds = trialList.Select(t => t.TrialId).ToList();
|
|
|
|
var enrollReviewerQuery = from enroll in _enrollRepository.GetAll()
|
|
.Where(t => t.EnrollStatus >= (int)EnrollStatus.ConfirmIntoGroup&& trialIds.Contains(t.TrialId))
|
|
join reviewer in _doctorRepository.GetAll() on enroll.DoctorId equals reviewer.Id
|
|
|
|
select new
|
|
{
|
|
TrialId = enroll.TrialId,
|
|
NameCN = reviewer.ChineseName,
|
|
Name = reviewer.LastName + " / " + reviewer.FirstName
|
|
};
|
|
var enrollReviewerByTrialList = enrollReviewerQuery.ToList().GroupBy(t => t.TrialId).Select(g => new
|
|
{
|
|
TrialId = g.Key,
|
|
ReviewerNameCNList = g.Select(t => t.NameCN).ToList(),
|
|
ReviewerNameList = g.Select(t => t.Name).ToList()
|
|
}).ToList();
|
|
|
|
|
|
trialList.ForEach(t =>
|
|
{
|
|
var trialDoctors = enrollReviewerByTrialList.FirstOrDefault(u => u.TrialId == t.TrialId);
|
|
|
|
if (trialDoctors != null)
|
|
{
|
|
t.ReviewerNameCNList = trialDoctors.ReviewerNameCNList;
|
|
t.ReviewerNameList = trialDoctors.ReviewerNameList;
|
|
}
|
|
});
|
|
|
|
|
|
return new PageOutput<EnrollStatByTrialDTO>(param.PageIndex, param.PageSize, count, trialList);
|
|
|
|
}
|
|
|
|
|
|
#region Dashboard 数据统计
|
|
public ReadingDataDTO GetReadingDataByType()
|
|
{
|
|
int tp = 0; int ad = 0; int g = 0;
|
|
var finalConfirmWorkload = _workloadRepository.Find(u => u.DataFrom == (int)WorkLoadFromStatus.FinalConfirm).ToList();
|
|
foreach (var item in finalConfirmWorkload)
|
|
{
|
|
tp += (item.Timepoint + item.TimepointIn24H + item.TimepointIn48H);
|
|
ad += (item.Adjudication + item.AdjudicationIn24H + item.AdjudicationIn48H);
|
|
g += item.Global;
|
|
}
|
|
return new ReadingDataDTO
|
|
{
|
|
Timepoint = tp,
|
|
Adjudication = ad,
|
|
Global = g
|
|
};
|
|
}
|
|
|
|
public List<ReadingDataMonthDTO> GetReadingDataByMonth(int monthCount)
|
|
{
|
|
DateTime now = DateTime.Now.AddMonths(-1);
|
|
DateTime eTime = new DateTime(now.Year, now.Month, 20);
|
|
|
|
DateTime now6 = now.AddMonths(-1 * (monthCount - 1));
|
|
DateTime bTime = new DateTime(now.AddMonths(-(monthCount - 1)).Year,
|
|
now.AddMonths(-(monthCount - 1)).Month, 1, 0, 0, 0, 0);
|
|
|
|
var query = from workload in _workloadRepository
|
|
.Find(u => u.DataFrom == (int)WorkLoadFromStatus.FinalConfirm &&
|
|
u.WorkTime >= bTime && u.WorkTime < eTime)
|
|
group workload by workload.YearMonth
|
|
into gWorkLoad
|
|
select new ReadingDataMonthDTO
|
|
{
|
|
Month = gWorkLoad.Key,
|
|
Timepoint = gWorkLoad.Sum(t => t.Timepoint) + gWorkLoad.Sum(t => t.TimepointIn24H)
|
|
+ gWorkLoad.Sum(t => t.TimepointIn48H),
|
|
Adjudication = gWorkLoad.Sum(t => t.Adjudication) + gWorkLoad.Sum(t => t.AdjudicationIn24H)
|
|
+ gWorkLoad.Sum(t => t.AdjudicationIn48H),
|
|
Global = gWorkLoad.Sum(t => t.Global)
|
|
};
|
|
var workloadList = query.OrderByDescending(u => u.Month).ToList();
|
|
List<ReadingDataMonthDTO> result = new List<ReadingDataMonthDTO>();
|
|
|
|
for (int i = 0; i < monthCount; i++)
|
|
{
|
|
var tempTime = now.AddMonths(-1 * i);
|
|
var existedItem = workloadList.Find(u => u.Month ==
|
|
(tempTime.Year + "-" + tempTime.Month.ToString().PadLeft(2, '0')));
|
|
if (existedItem != null)
|
|
{
|
|
result.Add(new ReadingDataMonthDTO
|
|
{
|
|
Month = existedItem.Month,
|
|
Timepoint = existedItem.Timepoint,
|
|
Adjudication = existedItem.Adjudication,
|
|
Global = existedItem.Global
|
|
});
|
|
}
|
|
else
|
|
{
|
|
result.Add(new ReadingDataMonthDTO
|
|
{
|
|
Month = tempTime.Year + "-" + tempTime.Month.ToString().PadLeft(2, '0'),
|
|
Timepoint = 0,
|
|
Adjudication = 0,
|
|
Global = 0
|
|
});
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public List<ReadingDataRankDTO> GetReadingDataRank(int topCount)
|
|
{
|
|
var query = from workload in _workloadRepository
|
|
.Find(u => u.DataFrom == (int)WorkLoadFromStatus.FinalConfirm)
|
|
group workload by workload.DoctorId
|
|
into gWorkLoad
|
|
|
|
select new ReadingDataRankDTO
|
|
{
|
|
TotalReadingCount = gWorkLoad.Sum(t => t.Timepoint) + gWorkLoad.Sum(t => t.TimepointIn24H)
|
|
+ gWorkLoad.Sum(t => t.TimepointIn48H) + gWorkLoad.Sum(t => t.Adjudication) + gWorkLoad.Sum(t => t.AdjudicationIn24H)
|
|
+ gWorkLoad.Sum(t => t.AdjudicationIn48H) + gWorkLoad.Sum(t => t.Global),
|
|
ReviewerId = gWorkLoad.Key,
|
|
Timepoint = gWorkLoad.Sum(t => t.Timepoint) + gWorkLoad.Sum(t => t.TimepointIn24H)
|
|
+ gWorkLoad.Sum(t => t.TimepointIn48H),
|
|
Adjudication = gWorkLoad.Sum(t => t.Adjudication) + gWorkLoad.Sum(t => t.AdjudicationIn24H)
|
|
+ gWorkLoad.Sum(t => t.AdjudicationIn48H),
|
|
Global = gWorkLoad.Sum(t => t.Global)
|
|
};
|
|
var workloadList = query.OrderByDescending(u => u.TotalReadingCount).Take(topCount).ToList();
|
|
var reviewerList = from w in workloadList
|
|
join doctor in _doctorRepository.Find() on w.ReviewerId equals doctor.Id into tt
|
|
from doctorItem in tt.DefaultIfEmpty()
|
|
select new ReadingDataRankDTO
|
|
{
|
|
TotalReadingCount = w.TotalReadingCount,
|
|
ReviewerId = w.ReviewerId,
|
|
Timepoint = w.Timepoint,
|
|
Adjudication = w.Adjudication,
|
|
Global = w.Global,
|
|
ReviewerCode = doctorItem == null ? string.Empty : doctorItem.Code,
|
|
FirstName = doctorItem == null ? string.Empty : doctorItem.FirstName,
|
|
LastName = doctorItem == null ? string.Empty : doctorItem.LastName,
|
|
ChineseName = doctorItem == null ? string.Empty : doctorItem.ChineseName
|
|
};
|
|
return reviewerList.ToList();
|
|
}
|
|
|
|
|
|
public List<RankReviewersDTO> GetReviewersByRank()
|
|
{
|
|
var query = from q in (from reviewer in _doctorRepository.GetAll()
|
|
//.Find(u => u.ReviewStatus == 1 && u.CooperateStatus == 1)
|
|
group reviewer by reviewer.RankId
|
|
into gReviewer
|
|
select new
|
|
{
|
|
RankId = gReviewer.Key,
|
|
ReviewerCount = gReviewer.Count()
|
|
})
|
|
|
|
join dic in _dictionaryRepository.Find() on q.RankId equals dic.Id into tt
|
|
from dicItem in tt.DefaultIfEmpty()
|
|
select new RankReviewersDTO
|
|
{
|
|
RankId = q.RankId,
|
|
ReviewerCount = q.ReviewerCount,
|
|
RankName = dicItem == null ? "Other" : dicItem.Value
|
|
};
|
|
|
|
var rankList = query.ToList();
|
|
var staffList = rankList.Where(u => u.RankName == "Staff" || u.RankName == "Other");
|
|
int staffCount = 0;
|
|
foreach (var item in staffList)
|
|
{
|
|
staffCount += item.ReviewerCount;
|
|
}
|
|
rankList.RemoveAll(u => u.RankName == "Staff" || u.RankName == "Other");
|
|
|
|
rankList.Add(new RankReviewersDTO { RankId = Guid.NewGuid(), RankName = "Staff", ReviewerCount = staffCount });
|
|
|
|
return rankList;
|
|
}
|
|
|
|
public List<EnrollQuartDataDTO> GetEnrollDataByQuarter(int type, int count)
|
|
{
|
|
//等于0按照月份 否则按照季度
|
|
if (type != 0)
|
|
{
|
|
var quarterCount = count;
|
|
var year = DateTime.Now.AddMonths(-(quarterCount - 1) * 3 - DateTime.Now.Month % 3 + 1).Year;
|
|
var month = DateTime.Now.AddMonths(-(quarterCount - 1) * 3 - DateTime.Now.Month % 3 + 1).Month;
|
|
|
|
var beginMonth = new DateTime(year, month, 1);
|
|
|
|
var endMonth = DateTime.Now;
|
|
var querySql = from enrollDetail in _enrollDetailRepository.GetAll().Where(t =>
|
|
t.CreateTime > beginMonth && t.CreateTime < endMonth &&
|
|
t.EnrollStatus == (int)EnrollStatus.ConfirmIntoGroup)
|
|
select new
|
|
{
|
|
|
|
OptTime = enrollDetail.CreateTime,
|
|
Year = enrollDetail.CreateTime.Year,
|
|
Month = enrollDetail.CreateTime.Month,
|
|
};
|
|
|
|
var result = querySql.GroupBy(t => new { t.Year, t.Month }).Select(s => new EnrollDataDTO
|
|
{
|
|
Year = s.Key.Year,
|
|
Month = s.Key.Month,
|
|
EnrollCount = s.Count()
|
|
}).ToList();
|
|
|
|
|
|
#region 填充数据
|
|
|
|
List<EnrollDataDTO> returnList = new List<EnrollDataDTO>();
|
|
for (int i = 0; i < DateTime.Now.Month % 3 + (quarterCount - 1) * 3; i++)
|
|
{
|
|
var tempTime = DateTime.Now.AddMonths(-1 * i);
|
|
var existedItem = result.FirstOrDefault(u => u.YearMonth == tempTime.ToString("yyyy-MM"));
|
|
if (existedItem != null)
|
|
{
|
|
returnList.Add(new EnrollDataDTO
|
|
{
|
|
Month = existedItem.Month,
|
|
Year = existedItem.Year,
|
|
EnrollCount = existedItem.EnrollCount
|
|
});
|
|
}
|
|
else
|
|
{
|
|
returnList.Add(new EnrollDataDTO
|
|
{
|
|
Month = tempTime.Month,
|
|
Year = tempTime.Year,
|
|
EnrollCount = 0
|
|
});
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
var returnResult = returnList.GroupBy(t => t.QuarterStr).Select(u => new EnrollQuartDataDTO()
|
|
{
|
|
ViewStr = u.Key,
|
|
EnrollCount = u.Sum(t => t.EnrollCount)
|
|
}).ToList();
|
|
|
|
return returnResult;
|
|
}
|
|
else
|
|
{
|
|
var year = DateTime.Now.AddMonths(-(count - 1)).Year;
|
|
var month = DateTime.Now.AddMonths(-(count - 1)).Month;
|
|
|
|
var beginMonth = new DateTime(year, month, 1);
|
|
|
|
var endMonth = DateTime.Now;
|
|
var querySql = from enrollDetail in _enrollDetailRepository.GetAll().Where(t =>
|
|
t.CreateTime > beginMonth && t.CreateTime < endMonth &&
|
|
t.EnrollStatus == (int)EnrollStatus.ConfirmIntoGroup)
|
|
select new
|
|
{
|
|
|
|
OptTime = enrollDetail.CreateTime,
|
|
Year = enrollDetail.CreateTime.Year,
|
|
Month = enrollDetail.CreateTime.Month,
|
|
};
|
|
|
|
var result = querySql.GroupBy(t => new { t.Year, t.Month }).Select(s => new EnrollDataDTO
|
|
{
|
|
Year = s.Key.Year,
|
|
Month = s.Key.Month,
|
|
EnrollCount = s.Count()
|
|
}).ToList();
|
|
|
|
#region 填充数据
|
|
|
|
List<EnrollDataDTO> returnList = new List<EnrollDataDTO>();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
var tempTime = DateTime.Now.AddMonths(-1 * i);
|
|
var existedItem = result.FirstOrDefault(u => u.YearMonth == tempTime.ToString("yyyy-MM"));
|
|
if (existedItem != null)
|
|
{
|
|
returnList.Add(new EnrollDataDTO
|
|
{
|
|
Month = existedItem.Month,
|
|
Year = existedItem.Year,
|
|
EnrollCount = existedItem.EnrollCount
|
|
});
|
|
}
|
|
else
|
|
{
|
|
returnList.Add(new EnrollDataDTO
|
|
{
|
|
Month = tempTime.Month,
|
|
Year = tempTime.Year,
|
|
EnrollCount = 0
|
|
});
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
var returnResult = returnList.GroupBy(t => t.YearMonth).Select(u => new EnrollQuartDataDTO()
|
|
{
|
|
ViewStr = u.Key,
|
|
EnrollCount = u.Sum(t => t.EnrollCount)
|
|
}).ToList();
|
|
|
|
return returnResult;
|
|
}
|
|
|
|
}
|
|
|
|
public List<TrialDataRankDTO> GetTrialCountRank(int topCount)
|
|
{
|
|
var queryList = (from enrollDetail in _enrollDetailRepository.GetAll().Where(t =>
|
|
t.EnrollStatus == (int)EnrollStatus.ConfirmIntoGroup)
|
|
group enrollDetail by enrollDetail.DoctorId
|
|
into g
|
|
select new
|
|
{
|
|
ReviewerId = g.Key,
|
|
TrialCount = g.Count()
|
|
}).OrderByDescending(u => u.TrialCount).Take(topCount).ToList();
|
|
|
|
var trialDataRank = from stat in queryList
|
|
join doctor in _doctorRepository.GetAll() on stat.ReviewerId equals doctor.Id
|
|
select new TrialDataRankDTO()
|
|
{
|
|
TrialCount = stat.TrialCount,
|
|
ChineseName = doctor.ChineseName,
|
|
FirstName = doctor.FirstName,
|
|
LastName = doctor.LastName,
|
|
ReviewerId = doctor.Id,
|
|
ReviewerCode = doctor.Code
|
|
};
|
|
return trialDataRank.ToList();
|
|
|
|
}
|
|
|
|
public List<LatestWorkLoadDTO> GetLatestWorkLoadList(int searchCount)
|
|
{
|
|
var workloadList = _workloadRepository.GetAll()
|
|
.Where(t => t.DataFrom == (int)WorkLoadFromStatus.FinalConfirm &&
|
|
(t.Adjudication + t.AdjudicationIn24H + t.AdjudicationIn48H) > 0 &&
|
|
(t.Timepoint + t.TimepointIn24H + t.TimepointIn48H) > 0)
|
|
.OrderByDescending(t => t.CreateTime).Take(searchCount).ToList();
|
|
|
|
|
|
var reviewerList = from w in workloadList
|
|
join doctor in _doctorRepository.Find() on w.DoctorId equals doctor.Id into tt
|
|
from doctorItem in tt.DefaultIfEmpty()
|
|
join trial in _trialRepository.GetAll() on w.TrialId equals trial.Id into cc
|
|
from trialItem in cc.DefaultIfEmpty()
|
|
select new LatestWorkLoadDTO
|
|
{
|
|
|
|
ReviewerId = w.DoctorId,
|
|
Timepoint = w.Timepoint + w.TimepointIn48H + w.TimepointIn24H,
|
|
Adjudication = w.Adjudication + w.AdjudicationIn48H + w.AdjudicationIn24H,
|
|
Global = w.Global,
|
|
ReviewerCode = doctorItem == null ? string.Empty : doctorItem.Code,
|
|
FirstName = doctorItem == null ? string.Empty : doctorItem.FirstName,
|
|
LastName = doctorItem == null ? string.Empty : doctorItem.LastName,
|
|
ChineseName = doctorItem == null ? string.Empty : doctorItem.ChineseName,
|
|
|
|
TrialCode = trialItem == null ? string.Empty : trialItem.Code
|
|
};
|
|
return reviewerList.ToList();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|