Ejemplo n.º 1
0
        public async Task SubmitForm(LabSheetEntity entity, string keyValue)
        {
            //var claimsIdentity = _httpContext.HttpContext.User.Identity as ClaimsIdentity;
            //claimsIdentity.CheckArgumentIsNull(nameof(claimsIdentity));
            //var claim = claimsIdentity?.FindFirst(t => t.Type == ClaimTypes.NameIdentifier));
            if (!string.IsNullOrEmpty(keyValue))
            {
                entity.Modify(keyValue);
                entity.F_LastModifyUserId = _usersService.GetCurrentUserId();
                await _service.UpdatePartialAsync(entity);

                //删除明细
                await _detailService.DeleteAsync(t => t.F_RequestId.ToString() == keyValue);
            }
            else
            {
                entity.Create();
                entity.F_CreatorUserId = _usersService.GetCurrentUserId();
                await _service.InsertAsync(entity);
            }
            //循环写入明细
            //foreach (var item in entity.Items)
            //{
            //    item.Create();
            //    _detailService.Insert(item);
            //}
        }
Ejemplo n.º 2
0
        public async Task <string> SampleSpit(string keyValue, string items)
        {
            var entity = await _service.FindEntityAsync(keyValue);

            var details = await GetItem(entity.F_RequestDate, entity.F_RequestId);

            var modifyRows = new List <LabSheetItemsEntity>();

            foreach (var item in items.ToJArrayObject())
            {
                var id   = item.Value <string>("id");
                var find = details.FirstOrDefault(t => t.F_Id == id);
                if (find == null)
                {
                    continue;
                }
                modifyRows.Add(find);
            }
            if (modifyRows.Count == 0)
            {
                return("");
            }
            var newsheet = new LabSheetEntity
            {
                F_Id             = Common.GuId(),
                F_CreatorTime    = DateTime.Now,
                F_CreatorUserId  = entity.F_CreatorUserId,
                F_RequestDate    = entity.F_RequestDate,
                F_RequestId      = long.Parse(Common.CreateNo()), //生成新的申请单号
                F_Pid            = entity.F_Pid,
                F_Name           = entity.F_Name,
                F_DialysisNo     = entity.F_DialysisNo,
                F_RecordNo       = entity.F_RecordNo,
                F_PatientNo      = entity.F_RecordNo,
                F_Gender         = entity.F_Gender,
                F_BirthDay       = entity.F_BirthDay,
                F_InsuranceNo    = entity.F_InsuranceNo,
                F_IdNo           = entity.F_IdNo,
                F_MaritalStatus  = entity.F_MaritalStatus,
                F_IdealWeight    = entity.F_IdealWeight,
                F_Height         = entity.F_Height,
                F_PrimaryDisease = entity.F_PrimaryDisease,
                F_Diagnosis      = entity.F_Diagnosis,
                F_SampleType     = entity.F_SampleType,
                F_Container      = entity.F_Container,
                F_Status         = entity.F_Status,
                F_DoctorId       = entity.F_DoctorId,
                F_DoctorName     = entity.F_DoctorName,
                F_OrderTime      = entity.F_OrderTime
            };
            await _service.InsertAsync(newsheet);

            foreach (var item in modifyRows)
            {
                item.F_RequestId = newsheet.F_RequestId;
                await _detailService.UpdateAsync(item, true);
            }
            return(newsheet.F_Id);
        }
Ejemplo n.º 3
0
 public IActionResult SubmitForm(LabSheetEntity entity, string keyValue)
 {
     _labRequestApp.SubmitForm(entity, keyValue);
     return(Success("操作成功。"));
 }
Ejemplo n.º 4
0
 public Task <int> UpdateForm(LabSheetEntity entity)
 {
     return(_service.UpdatePartialAsync(entity));
 }
Ejemplo n.º 5
0
        /// <summary>
        /// 批量写入数据
        /// </summary>
        /// <param name="pids"></param>
        /// <param name="itemids"></param>
        public async Task CreateRecords(string pids, string itemids)
        {
            //var claimsIdentity = _httpContext.HttpContext.User.Identity as ClaimsIdentity;
            //claimsIdentity.CheckArgumentIsNull(nameof(claimsIdentity));
            var user = await _usersService.GetCurrentUserAsync();

            var pidsParam    = pids.ToJArrayObject();
            var itemidsParam = itemids.ToJArrayObject();
            var labItemList  = new List <LabItemEntity>();

            foreach (var item in itemidsParam)
            {
                var itemId = item.Value <string>("id");
                var entity = await _labItemApp.GetForm(itemId);

                if (entity != null)
                {
                    labItemList.Add(entity);
                }
            }
            //var user = OperatorProvider.Provider.GetCurrent();

            var patients = new List <PatientEntity>();

            foreach (var group in labItemList.GroupBy(t => t.F_CuvetteNo))
            {
                foreach (var item in pidsParam)
                {
                    var pId     = item.Value <string>("id");
                    var patient = patients.FirstOrDefault(t => t.F_Id == pId);
                    if (patient == null)
                    {
                        patient = await _patientApp.GetForm(pId);

                        if (patient == null)
                        {
                            continue;
                        }
                        patients.Add(patient);
                    }

                    //var claimUserId = claimsIdentity?.FindFirst(t => t.Type == ClaimTypes.NameIdentifier));
                    //var claimUserName = claimsIdentity?.FindFirst(t => t.Type == ClaimTypes.Name));
                    var masterEntity = new LabSheetEntity
                    {
                        F_Id             = Common.GuId(),
                        F_CreatorTime    = DateTime.Now,
                        F_CreatorUserId  = user?.F_Id,
                        F_RequestDate    = DateTime.Today,
                        F_RequestId      = long.Parse(Common.CreateNo()),
                        F_Pid            = patient.F_Id,
                        F_Name           = patient.F_Name,
                        F_BeInfected     = "+".Equals(patient.F_Tp) || "+".Equals(patient.F_Hiv) || "+".Equals(patient.F_HBsAg) || "+".Equals(patient.F_HBeAg) || "+".Equals(patient.F_HBeAb),
                        F_DialysisNo     = patient.F_DialysisNo,
                        F_RecordNo       = patient.F_RecordNo,
                        F_PatientNo      = patient.F_RecordNo,
                        F_Gender         = patient.F_Gender,
                        F_BirthDay       = patient.F_BirthDay,
                        F_InsuranceNo    = patient.F_InsuranceNo,
                        F_IdNo           = patient.F_IdNo,
                        F_MaritalStatus  = patient.F_MaritalStatus,
                        F_IdealWeight    = patient.F_IdealWeight,
                        F_Height         = patient.F_Height,
                        F_PrimaryDisease = patient.F_PrimaryDisease,
                        F_Diagnosis      = patient.F_Diagnosis,
                        F_SampleType     = group.First().F_SampleType,
                        F_Container      = group.First().F_Container,
                        F_Status         = 1,
                        F_DoctorId       = user?.F_Id,
                        F_DoctorName     = user?.F_RealName,
                        F_OrderTime      = DateTime.Now
                    };
                    await _service.InsertAsync(masterEntity);

                    var details = new List <LabSheetItemsEntity>();
                    foreach (var child in group)
                    {
                        details.Add(new LabSheetItemsEntity
                        {
                            F_Id             = Common.GuId(),
                            F_CreatorTime    = masterEntity.F_CreatorTime,
                            F_CreatorUserId  = user?.F_Id,
                            F_RequestId      = masterEntity.F_RequestId,
                            F_Code           = child.F_Code,
                            F_Name           = child.F_Name,
                            F_EnName         = child.F_EnName,
                            F_ShortName      = child.F_ShortName,
                            F_SampleType     = child.F_SampleType,
                            F_Container      = child.F_Container,
                            F_CuvetteNo      = child.F_CuvetteNo,
                            F_Type           = child.F_Type,
                            F_ThirdPartyCode = child.F_ThirdPartyCode,
                            F_IsExternal     = child.F_IsExternal,
                            F_Sorter         = child.F_Sorter,
                            F_IsPeriodic     = child.F_IsPeriodic,
                            F_TimeInterval   = child.F_TimeInterval
                        });
                    }
                    await _detailService.InsertAsync(details);
                }
            }
        }