private void GetImportListProxy(SpecLabEntities _entities, DatabaseCommand <GetImportListParams, List <ImportNoteShortData> > paramCommand) { var importQuery = (from import in _entities.Imports select import); if (!string.IsNullOrEmpty(paramCommand.CallingInfo.ImportId)) { importQuery = importQuery.Where(e => e.ImportId.StartsWith(paramCommand.CallingInfo.ImportId)); } if (paramCommand.CallingInfo.StartDate != null) { importQuery = importQuery.Where(e => e.ImportDate >= paramCommand.CallingInfo.StartDate); } if (paramCommand.CallingInfo.EndDate != null) { var limitDate = paramCommand.CallingInfo.EndDate.GetValueOrDefault().AddDays(1); importQuery = importQuery.Where(e => e.ImportDate < limitDate); } var listResult = importQuery.Select(t => new ImportNoteShortData() { ImportId = t.ImportId, ImportUserId = t.ImportUserId, ImportDate = t.ImportDate, NumberImport = t.SampleNumber }); listResult = listResult.OrderByDescending(t => t.ImportDate); paramCommand.ReturnValue.AddRange(listResult); }
private void DeleteStorageInfoProxy(SpecLabEntities _entities, DatabaseCommand <string, object> paramCommand) { var existStorage = (from storage in _entities.Storages where storage.StorageId.Equals(paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select storage).FirstOrDefault(); if (existStorage == null) { throw new BusinessException(ErrorCode.StorageIdNotExists, paramCommand.CallingInfo); } else { var checkStorageInUse = (from exists in _entities.TubeSamples where exists.StorageId == paramCommand.CallingInfo select exists.StorageId); if (checkStorageInUse.Any()) { throw new BusinessException(ErrorCode.StorageIdAlreadyInUse); } checkStorageInUse = (from exists in _entities.SampleHistories where exists.StorageId == paramCommand.CallingInfo select exists.StorageId); if (checkStorageInUse.Any()) { throw new BusinessException(ErrorCode.StorageIdAlreadyInUse); } _entities.Storages.Remove(existStorage); _entities.SaveChanges(); } }
private void GetRemovalListProxy(SpecLabEntities _entities, DatabaseCommand <GetRemovalListParams, List <RemovalNoteShortData> > paramCommand) { var removalQuery = (from import in _entities.Removals select import); if (!string.IsNullOrEmpty(paramCommand.CallingInfo.RemovalId)) { removalQuery = removalQuery.Where(e => e.RemovalId.StartsWith(paramCommand.CallingInfo.RemovalId)); } if (paramCommand.CallingInfo.StartDate != null) { removalQuery = removalQuery.Where(e => e.RemovalDate >= paramCommand.CallingInfo.StartDate); } if (paramCommand.CallingInfo.EndDate != null) { var limitDate = paramCommand.CallingInfo.EndDate.GetValueOrDefault().AddDays(1); removalQuery = removalQuery.Where(e => e.RemovalDate < limitDate); } removalQuery = removalQuery.OrderByDescending(t => t.RemovalDate); var listResult = removalQuery.Select(t => new RemovalNoteShortData() { RemovalId = t.RemovalId, RemovalUserId = t.RemovalUserId, RemovalDate = t.RemovalDate, RemovalReason = t.RemovalReason, NumberRemoval = t.SampleNumber }); paramCommand.ReturnValue.AddRange(listResult); }
private void GetLoginUserInfoProxy(SpecLabEntities _entities, DatabaseCommand <string, LoginUserInfo> paramCommand) { if (paramCommand.CallingInfo != null) { if (CommonConstant.SystemAdmin.ToLower().Equals(paramCommand.CallingInfo.ToLower())) { paramCommand.ReturnValue = GetSystemAdminLoginInfo(); } else { var dbItem = _entities.UserInfoes .FirstOrDefault(u => u.UserId.ToLower().Equals(paramCommand.CallingInfo.ToLower())); if (dbItem != null) { var existsUser = new LoginUserInfo() { FullName = dbItem.FullName, UserId = dbItem.UserId, Status = CommonUtils.GetEnumFromValue <UserStatus>(dbItem.Status) }; var rights = dbItem.UserRights.ToList(); existsUser.Rights.AddRange(dbItem.UserRights.ToList().ConvertAll(ConvertUserRightCode)); paramCommand.ReturnValue = existsUser; } } } }
private void UpdateUserRightsProxy(SpecLabEntities _entities, DatabaseCommand <UpdateRightParams, bool> paramCommand) { var listRights = (from u in _entities.UserRights where u.UserInfo.UserId.ToLower().Equals(paramCommand.CallingInfo.UserId.ToLower()) select u); foreach (var right in listRights) { _entities.UserRights.Remove(right); } _entities.SaveChanges(); foreach (var rightCode in paramCommand.CallingInfo.UpdateRights) { _entities.UserRights.Add(new UserRight() { CreateDate = DateTime.Now, UpdateDate = DateTime.Now, UserId = paramCommand.CallingInfo.UserId, RightCode = rightCode.ToString() }); } _entities.SaveChanges(); paramCommand.ReturnValue = true; }
private void AddStorageInfoProxy(SpecLabEntities _entities, DatabaseCommand <ShortStorageInfo, object> paramCommand) { var existStorage = (from storage in _entities.Storages where storage.StorageId.Equals(paramCommand.CallingInfo.StorageId, StringComparison.OrdinalIgnoreCase) select storage).FirstOrDefault(); if (existStorage != null) { throw new BusinessException(ErrorCode.StorageIdExists); } else { _entities.Storages.Add(new Storage() { UpdateDate = DateTime.Now, CreateDate = DateTime.Now, NumberStorage = paramCommand.CallingInfo.NumberStorage, NumColumn = paramCommand.CallingInfo.NumColumn, NumRows = paramCommand.CallingInfo.NumRows, StorageId = paramCommand.CallingInfo.StorageId }); _entities.SaveChanges(); } }
private void GetExportHistoryProxy(SpecLabEntities _entities, DatabaseCommand <GetExportHistoryParam, List <ReportExportHistoryInfo> > paramCommand) { var historyQuery = (from history in _entities.viewExportHistories select history); if (paramCommand.CallingInfo.StartDate != null) { historyQuery = historyQuery.Where(history => history.ExportDate >= paramCommand.CallingInfo.StartDate); } if (paramCommand.CallingInfo.EndDate != null) { var limitDate = paramCommand.CallingInfo.EndDate.GetValueOrDefault().AddDays(1); historyQuery = historyQuery.Where(history => history.ExportDate < limitDate); } historyQuery = historyQuery.OrderByDescending(history => history.ExportDate); var listResult = historyQuery.Select(history => new ReportExportHistoryInfo() { TubeId = history.TubeId, ExportDate = history.ExportDate, ExportUserId = history.ExportUserId, ExportReason = history.ExportReason, SampleType = (SampleType)history.SampleType, UpdateDate = history.UpdateDate, UpdateUserId = history.UpdateUserId, StorageId = history.StorageId, MaximumStorage = history.NumberStorage, LocationNum = history.LocationNum }); paramCommand.ReturnValue.AddRange(listResult); }
private void SaveContentProxy(SpecLabEntities _entities, DatabaseCommand <ContentInfo, object> paramCommand) { var existContent = (from content in _entities.Contents where content.ContentId == paramCommand.CallingInfo.ContentId select content).FirstOrDefault(); var loginInfo = SessionUtils.LoginUserInfo; if (existContent == null) { //throw new BusinessException(ErrorCode.ContentIdNotExists, paramCommand.CallingInfo); _entities.Contents.Add(new Content() { CreateUser = loginInfo == null ? null : loginInfo.UserId, UpdateUser = loginInfo == null ? null : loginInfo.UserId, UpdateDate = DateTime.Now, CreateDate = DateTime.Now, ContentId = paramCommand.CallingInfo.ContentId, ContentText = paramCommand.CallingInfo.ContentText }); _entities.SaveChanges(); } else { existContent.UpdateDate = DateTime.Now; existContent.UpdateUser = loginInfo == null ? null : loginInfo.UserId; existContent.ContentText = paramCommand.CallingInfo.ContentText; _entities.SaveChanges(); } }
private void ChangePasswordProxy(SpecLabEntities _entities, DatabaseCommand <ChangePassParams, bool> paramCommand) { paramCommand.ReturnValue = false; var selectedUser = (from u in _entities.UserInfoes where u.UserId.ToLower().Equals(paramCommand.CallingInfo.UserId.ToLower()) select u).FirstOrDefault(); if (selectedUser == null) { throw new BusinessException(ErrorCode.UserIdNotExists); } else { string passwordHash = GeneratePasswordHash( paramCommand.CallingInfo.OldPass, selectedUser.PasswordSalt); if (!passwordHash.Equals(selectedUser.Password)) { throw new BusinessException(ErrorCode.PasswordNotMatch); } else { string passwordSalt = Guid.NewGuid().ToString(); passwordHash = GeneratePasswordHash(paramCommand.CallingInfo.NewPass, passwordSalt); selectedUser.Password = passwordHash; selectedUser.PasswordSalt = passwordSalt; _entities.SaveChanges(); paramCommand.ReturnValue = true; } } }
private void GetSampleStatisticsProxy(SpecLabEntities _entities, DatabaseCommand <string, List <ReportSampleStatisticInfo> > paramCommand) { var query = _entities.viewSampleStatistics .Where(statistic => statistic.Status != (int)TubeSampleStatus.Remove); paramCommand.ReturnValue = query.ToList().ConvertAll(ConvertReportSampleStatisticInfo); }
private void GetAllShortUserInfoProxy(SpecLabEntities _entities, DatabaseCommand <object, List <ShortUserInfo> > paramCommand) { var userStatusEnable = UserStatus.Enable.ToString(); var listUsers = (from u in _entities.UserInfoes where u.Status.Equals(userStatusEnable) select u).ToList(); paramCommand.ReturnValue = listUsers.ConvertAll(ConvertToShortUserInfo); }
private void UpdateUserProxy(SpecLabEntities _entities, DatabaseCommand <LoginUserInfo, LoginUserInfo> paramCommand) { var dbItem = _entities.UserInfoes .FirstOrDefault(c => c.UserId.ToLower().Equals( paramCommand.CallingInfo.UserId)); dbItem.FullName = paramCommand.CallingInfo.FullName; _entities.SaveChanges(); paramCommand.ReturnValue = this.GetLoginUserInfo(paramCommand.CallingInfo.UserId); }
private void GetListStorageIdProxy(SpecLabEntities _entities, DatabaseCommand <object, List <ShortStorageInfo> > paramCommand) { var listStorageId = (from u in _entities.Storages select new ShortStorageInfo() { StorageId = u.StorageId, NumberStorage = u.NumberStorage, NumRows = u.NumRows, NumColumn = u.NumColumn }).ToList(); paramCommand.ReturnValue = listStorageId; }
private void CreateNewUserProxy(SpecLabEntities _entities, DatabaseCommand <CreateNewUserParams, LoginUserInfo> paramCommand) { if (paramCommand.CallingInfo.LoginUserInfo.UserId.Equals(CommonConstant.SystemAdmin)) { throw new BusinessException(ErrorCode.UserIdExists); } var existsUser = _entities.UserInfoes .FirstOrDefault(u => u.UserId.ToLower() .Equals(paramCommand.CallingInfo.LoginUserInfo.UserId.ToLower())); if (existsUser != null) { throw new BusinessException(ErrorCode.UserIdExists); } else { string passwordSalt = Guid.NewGuid().ToString(); string paswordHash = GeneratePasswordHash(paramCommand.CallingInfo.Password, passwordSalt); var dbItem = new UserInfo() { UserId = paramCommand.CallingInfo.LoginUserInfo.UserId, FullName = paramCommand.CallingInfo.LoginUserInfo.FullName, CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Password = paswordHash, PasswordSalt = passwordSalt, Status = UserStatus.Enable.ToString() }; _entities.UserInfoes.Add(dbItem); foreach (var rightCode in paramCommand.CallingInfo.LoginUserInfo.Rights) { _entities.UserRights.Add(new UserRight() { CreateDate = DateTime.Now, UpdateDate = DateTime.Now, UserId = paramCommand.CallingInfo.LoginUserInfo.UserId, RightCode = rightCode.ToString() }); } _entities.SaveChanges(); paramCommand.ReturnValue = this.GetLoginUserInfo(paramCommand.CallingInfo.LoginUserInfo.UserId); } }
public static Header GetHeader(string _labId) { using (SpecLabEntities _entities = CommonUtils.GetBusinessObject <SpecLabEntities>()) { try { var query = _entities.Headers.Where(o => o.LabID == _labId).FirstOrDefault(); return(query); } catch (Exception ex) { _logger.Error(string.Format("Failed to saved database: {0}", ex)); return(null); } } }
private void GetTubeExportCountProxy(SpecLabEntities _entities, DatabaseCommand <GetTubeExportCountParams, List <TubeExportCount> > paramCommand) { var query = (from tube in _entities.TubeSamples select new TubeExportCount() { TubeId = tube.TubeId, NumberExport = tube.NumberExport }); if (paramCommand.CallingInfo.TubeIds.Count > 0) { query = query.Where(t => paramCommand.CallingInfo.TubeIds.Contains(t.TubeId)); } paramCommand.ReturnValue = query.ToList(); }
private void DeleteUserProxy(SpecLabEntities _entities, DatabaseCommand <string, bool> paramCommand) { var userInfo = (from u in _entities.UserInfoes where u.UserId.Equals(paramCommand.CallingInfo) select u).FirstOrDefault(); var listRightDelete = userInfo.UserRights.ToList(); foreach (var rightDelete in listRightDelete) { _entities.UserRights.Remove(rightDelete); } _entities.UserInfoes.Remove(userInfo); _entities.SaveChanges(); paramCommand.ReturnValue = true; }
private void GetSampleSpecProxy(SpecLabEntities _entities, DatabaseCommand <string, SampleSpecInfo> paramCommand) { var sampleDbItem = (from sample in _entities.SampleSpecs where sample.SampleSpecId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select sample).FirstOrDefault(); if (sampleDbItem == null) { throw new BusinessException(ErrorCode.SampleSpecIdNotExists); } SampleSpecInfo info = new SampleSpecInfo() { LocationId = sampleDbItem.Source, PatientName = sampleDbItem.PatientName, SampleSpecId = sampleDbItem.SampleSpecId, YearOfBirth = sampleDbItem.Age, Sex = (SampleSex)sampleDbItem.Sex[0], UserInput = sampleDbItem.UserInput, DateInput = sampleDbItem.DateInput }; var tubeListDbItem = (from tube in _entities.TubeSamples where tube.SampleSpecId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select new TubeSampleSpecInfo() { Volume = tube.Volume, LocationNum = tube.LocationNum, SampleSpecId = tube.SampleSpecId, StorageId = tube.StorageId, TubeId = tube.TubeId, Status = (TubeSampleStatus)tube.Status, DateInput = sampleDbItem.DateInput, Type = (TubeSampleType)tube.TubeType, SampleType = (SampleType)tube.SampleType, }).ToList(); info.TubeSampleSpecs.AddRange(tubeListDbItem); paramCommand.ReturnValue = info; }
/// <summary> /// kiểm tra storage id /// </summary> /// <param name="_entities"></param> /// <param name="storageId"></param> private void ValidateStorageId(SpecLabEntities _entities, string storageId, int locationNum) { var query = (from storage in _entities.Storages where storage.StorageId.Equals(storageId, StringComparison.OrdinalIgnoreCase) select storage.NumberStorage); if (!query.Any()) { throw new BusinessException(ErrorCode.StorageIdNotExists, storageId); } else { var numberStorage = query.FirstOrDefault(); if (locationNum > numberStorage) { throw new BusinessException(ErrorCode.StorageLocationOutOfBound, storageId, numberStorage); } } }
private void UpdateStorageInfoProxy(SpecLabEntities _entities, DatabaseCommand <ShortStorageInfo, object> paramCommand) { var existStorage = (from storage in _entities.Storages where storage.StorageId.Equals(paramCommand.CallingInfo.StorageId, StringComparison.OrdinalIgnoreCase) select storage).FirstOrDefault(); if (existStorage == null) { throw new BusinessException(ErrorCode.StorageIdNotExists, paramCommand.CallingInfo.StorageId); } else { existStorage.NumberStorage = paramCommand.CallingInfo.NumberStorage; existStorage.NumRows = paramCommand.CallingInfo.NumRows; existStorage.NumColumn = paramCommand.CallingInfo.NumColumn; _entities.SaveChanges(); } }
private void GetRemovalInfoProxy(SpecLabEntities _entities, DatabaseCommand <string, RemovalNote> paramCommand) { var result = (from removal in _entities.Removals where removal.RemovalId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select new RemovalNote() { RemovalDate = removal.RemovalDate, RemovalId = removal.RemovalId, RemovalUserId = removal.RemovalUserId, RemovalReason = removal.RemovalReason, }).FirstOrDefault(); if (result == null) { throw new BusinessException(ErrorCode.RemovalIdNotExists); } var listRemovalDetail = (from removalDetail in _entities.RemovalDetails join tube in _entities.TubeSamples on removalDetail.TubeId equals tube.TubeId join spec in _entities.SampleSpecs on tube.SampleSpecId equals spec.SampleSpecId where removalDetail.RemovalId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select new RemovalNoteDetail() { RemovalId = removalDetail.RemovalId, TubeId = removalDetail.TubeId, RemovalDetailId = removalDetail.RemovalDetailId, Status = (TubeSampleStatus)removalDetail.Status, Type = (TubeSampleType)removalDetail.TubeType, Volume = removalDetail.Volume, LocationNum = removalDetail.LocationNum, StorageId = removalDetail.StorageId, SampleSpecId = tube.SampleSpecId, InputDate = spec.DateInput, NumberExport = removalDetail.NumberExport }).ToList(); result.RemovalNoteDetails.AddRange(listRemovalDetail); paramCommand.ReturnValue = result; }
private void GetImportInfoProxy(SpecLabEntities _entities, DatabaseCommand <string, ImportNote> paramCommand) { var result = (from import in _entities.Imports where import.ImportId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select new ImportNote() { ImportDate = import.ImportDate, ImportId = import.ImportId, ImportUserId = import.ImportUserId, }).FirstOrDefault(); if (result == null) { throw new BusinessException(ErrorCode.ExportIdNotExists); } var listExportDetail = (from importDetail in _entities.ImportDetails join import in _entities.Imports on importDetail.ImportId equals import.ImportId join tube in _entities.TubeSamples on importDetail.TubeId equals tube.TubeId where importDetail.ImportId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select new ImportNoteDetail() { ImportId = importDetail.ImportId, TubeId = importDetail.TubeId, ImportDetailId = importDetail.ImportDetailId, Status = (TubeSampleStatus)importDetail.Status, Type = (TubeSampleType)importDetail.TubeType, Volume = importDetail.Volume, LocationNum = importDetail.LocationNum, StorageId = importDetail.StorageId, SampleSpecId = tube.SampleSpecId, SampleType = (SampleType)tube.SampleType, ImportDate = import.ImportDate, NumberExport = importDetail.NumberExport }).ToList(); result.ImportNoteDetails.AddRange(listExportDetail); paramCommand.ReturnValue = result; }
private void GetNumberRemovalProxy(SpecLabEntities _entities, DatabaseCommand <GetNumberRemovalParams, int> paramCommand) { var query = (from Removal in _entities.Removals select Removal); if (paramCommand.CallingInfo.FromDate != null) { query = query.Where(t => t.RemovalDate >= paramCommand.CallingInfo.FromDate); } if (paramCommand.CallingInfo.ToDate != null) { var limitDate = paramCommand.CallingInfo.ToDate.GetValueOrDefault().AddDays(1); query = query.Where(t => t.RemovalDate < limitDate); } paramCommand.ReturnValue = query.Count(); }
private void GetLoginUserInfoProxy(SpecLabEntities _entities, DatabaseCommand <LoginParams, LoginUserInfo> paramCommand) { if (paramCommand.CallingInfo.Username.ToLower().Equals(CommonConstant.SystemAdmin.ToLower())) { string password = GeneratePasswordSystemAdmin(); if (paramCommand.CallingInfo.Password.Equals(password)) { paramCommand.ReturnValue = this.GetSystemAdminLoginInfo(); } else { throw new BusinessException(ErrorCode.PasswordNotMatch); } } else { var existsUser = _entities.UserInfoes.FirstOrDefault(u => u.UserId.ToLower() .Equals(paramCommand.CallingInfo.Username.ToLower())); if (existsUser == null) { throw new BusinessException(ErrorCode.UserIdNotExists); } else if (!existsUser.Status.ToString().Equals(UserStatus.Enable.ToString())) { throw new BusinessException(ErrorCode.UserNotActive); } else { string passwordHash = GeneratePasswordHash( paramCommand.CallingInfo.Password, existsUser.PasswordSalt); if (!passwordHash.Equals(existsUser.Password)) { throw new BusinessException(ErrorCode.PasswordNotMatch); } paramCommand.ReturnValue = this.GetLoginUserInfo(paramCommand.CallingInfo.Username); } } }
private void GetContentInfoByIdProxy(SpecLabEntities _entities, DatabaseCommand <string, ContentInfo> paramCommand) { var existContent = (from u in _entities.Contents where u.ContentId == paramCommand.CallingInfo select new ContentInfo() { ContentId = u.ContentId, ContentText = u.ContentText }).FirstOrDefault(); if (existContent == null) { throw new BusinessException(ErrorCode.ContentIdNotExists, paramCommand.CallingInfo); } else { paramCommand.ReturnValue = existContent; } }
private void GetTubeDetailProxy(SpecLabEntities _entities, DatabaseCommand <string, TubeSampleSpecInfo> paramCommand) { var summaryInfo = (from tube in _entities.TubeSamples join sample in _entities.SampleSpecs on tube.SampleSpecId equals sample.SampleSpecId where tube.TubeId == paramCommand.CallingInfo select new TubeSampleSpecInfo() { DateInput = sample.DateInput, LocationNum = tube.LocationNum, StorageId = tube.StorageId, Status = (TubeSampleStatus)tube.Status, Type = (TubeSampleType)tube.TubeType, TubeId = tube.TubeId, Volume = tube.Volume, SampleSpecId = tube.SampleSpecId }).FirstOrDefault(); paramCommand.ReturnValue = summaryInfo; }
private void GetStorageStatisticsProxy(SpecLabEntities _entities, DatabaseCommand <string, List <ReportStorageStatisticsInfo> > paramCommand) { var query = _entities.viewStorageStatistics .Where(statistic => statistic.Status != (int)TubeSampleStatus.Remove) .OrderBy(statistic => statistic.StorageId) .ThenBy(statistic => statistic.LocationNum) .Select(statistic => new ReportStorageStatisticsInfo() { StorageId = statistic.StorageId, LocationNum = statistic.LocationNum, TubeId = statistic.TubeId, Status = (TubeSampleStatus)statistic.Status, MaximumStorage = statistic.NumberStorage, Volume = statistic.Volume, NumberExport = statistic.NumberExport }); paramCommand.ReturnValue = query.ToList(); }
protected DatabaseCommand <InVal, ReturnVal> ProxyCalling <InVal, ReturnVal>( Action <SpecLabEntities, DatabaseCommand <InVal, ReturnVal> > actionEntity, DatabaseCommand <InVal, ReturnVal> dbCommandInfo) { using (SpecLabEntities _entities = CommonUtils.GetBusinessObject <SpecLabEntities>()) { try { actionEntity(_entities, dbCommandInfo); return(dbCommandInfo); } catch (DbUpdateException updateException) { _logger.Error(string.Format("Failed to saved database: {0}", updateException)); throw new BusinessException(ErrorCode.InternalErrorException, updateException); } catch (DbEntityValidationException entityValidationException) { _logger.Error(string.Format("Failed to saved database: {0}", entityValidationException)); foreach (var entityValidationError in entityValidationException.EntityValidationErrors) { foreach (var error in entityValidationError.ValidationErrors) { _logger.ErrorFormat("Failed to saved database: {0}", error.ErrorMessage); } } throw new BusinessException(ErrorCode.InternalErrorException, entityValidationException); } catch (BusinessException) { throw; } catch (Exception exception) { _logger.Error(string.Format("Iternal error: {0}", exception)); throw new BusinessException(ErrorCode.InternalErrorException, exception); } } }
private void GetImportHistoryProxy(SpecLabEntities _entities, DatabaseCommand <string, List <SampleHistoryInfo> > paramCommand) { var sampleDbItem = (from sample in _entities.SampleSpecs where sample.SampleSpecId.Equals( paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) select sample).FirstOrDefault(); if (sampleDbItem == null) { throw new BusinessException(ErrorCode.SampleSpecIdNotExists); } var historyListDbItem = (from tube in _entities.TubeSamples join history in _entities.SampleHistories on tube.TubeId equals history.TubeId where tube.SampleSpecId.Equals(paramCommand.CallingInfo, StringComparison.OrdinalIgnoreCase) && history.Action == (int)HistoryAction.Import select new SampleHistoryInfo() { HistoryId = history.HistoryId, TubeId = history.TubeId, HistoryDate = history.HistoryDate, Action = (HistoryAction)history.Action, UserId = history.UserId, Description = history.Description, LocationNum = history.LocationNum, StorageId = history.StorageId, Status = (TubeSampleStatus)history.Status, Type = (TubeSampleType)history.TubeType, Volume = history.Volume }); List <SampleHistoryInfo> listData = new List <SampleHistoryInfo>(); listData.AddRange(historyListDbItem); paramCommand.ReturnValue = listData; }
private void GetTubeHistoryProxy(SpecLabEntities _entities, DatabaseCommand <string, List <SampleHistoryInfo> > paramCommand) { var historyQuery = (from history in _entities.SampleHistories where history.TubeId == paramCommand.CallingInfo select new SampleHistoryInfo() { HistoryId = history.HistoryId, TubeId = history.TubeId, HistoryDate = history.HistoryDate, Action = (HistoryAction)history.Action, UserId = history.UserId, Description = history.Description, LocationNum = history.LocationNum, StorageId = history.StorageId, Status = (TubeSampleStatus)history.Status, Type = (TubeSampleType)history.TubeType, Volume = history.Volume, NumberExport = history.NumberExport, }); historyQuery = historyQuery.OrderByDescending(his => his.HistoryDate); paramCommand.ReturnValue.AddRange(historyQuery); }