public JobList <DeletedJobDto> DeletedJobs(int @from, int count) { return(UseConnection(connection => GetJobs( connection, from, count, DeletedState.StateName, (sqlJob, job, stateData) => new DeletedJobDto { Job = job, DeletedAt = JobHelper.DeserializeNullableDateTime(stateData["DeletedAt"]) }))); }
public JobList <SucceededJobDto> SucceededJobs(int from, int count) { return(UseConnection(connection => GetJobs(connection, from, count, SucceededState.StateName, (sqlJob, job, stateData) => new SucceededJobDto { Job = job, Result = stateData.ContainsKey("Result") ? stateData["Result"] : null, TotalDuration = stateData.ContainsKey("PerformanceDuration") && stateData.ContainsKey("Latency") ? (long?)long.Parse(stateData["PerformanceDuration"]) + (long?)long.Parse(stateData["Latency"]) : null, SucceededAt = JobHelper.DeserializeNullableDateTime(stateData["SucceededAt"]) }))); }
public JobList <FailedJobDto> FailedJobs(int from, int count) { return(UseConnection(connection => GetJobs(connection, from, count, FailedState.StateName, (sqlJob, job, stateData) => new FailedJobDto { Job = job, Reason = sqlJob.StateReason, ExceptionDetails = stateData["ExceptionDetails"], ExceptionMessage = stateData["ExceptionMessage"], ExceptionType = stateData["ExceptionType"], FailedAt = JobHelper.DeserializeNullableDateTime(stateData["FailedAt"]) }))); }
public JobList <DeletedJobDto> DeletedJobs(int from, int count) { return(_storage.UseStatelessTransaction(session => GetJobs( session, @from, count, DeletedState.StateName, (sqlJob, job, stateData) => new DeletedJobDto { Job = job, DeletedAt = JobHelper.DeserializeNullableDateTime(stateData["DeletedAt"]) }))); }
public JobList <FailedJobDto> FailedJobs(int from, int count) { List <KeyValuePair <string, FailedJobDto> > result = GetJobsOnState(States.FailedState.StateName, from, count, (state, job) => new FailedJobDto { Job = job, Reason = state.Reason, FailedAt = JobHelper.DeserializeNullableDateTime(state.Data["FailedAt"]), ExceptionDetails = state.Data["ExceptionDetails"], ExceptionMessage = state.Data["ExceptionMessage"], ExceptionType = state.Data["ExceptionType"], }).OrderByDescending(j => j.Value.FailedAt).ToList(); return(new JobList <FailedJobDto>(result)); }
public JobList <DeletedJobDto> DeletedJobs(int @from, int count) { return(UseConnection(connection => GetJobs( connection, from, count, DeletedState.StateName, (sqlJob, job, stateData) => new DeletedJobDto { Job = job, InDeletedState = DeletedState.StateName.Equals(sqlJob.StateName, StringComparison.OrdinalIgnoreCase), DeletedAt = JobHelper.DeserializeNullableDateTime(stateData["DeletedAt"]) }))); }
public JobList <FailedJobDto> FailedJobs(int from, int count) { return(GetJobs(from, count, FailedState.StateName, (job, data, reason) => new FailedJobDto { Job = job, Reason = reason, ExceptionDetails = data?.GetValue(nameof(FailedJobDto.ExceptionDetails)), ExceptionMessage = data?.GetValue(nameof(FailedJobDto.ExceptionMessage)), ExceptionType = data?.GetValue(nameof(FailedJobDto.ExceptionType)), FailedAt = JobHelper.DeserializeNullableDateTime( data?.GetValue(nameof(FailedJobDto.FailedAt))), })); }
public JobList <DeletedJobDto> DeletedJobs(int @from, int count) { return(GetJobs( from, count, DeletedState.StateName, (sqlJob, job, stateData) => new DeletedJobDto { Job = job, DeletedAt = JobHelper.DeserializeNullableDateTime(stateData.ContainsKey("DeletedAt") ? stateData["DeletedAt"] : null) })); }
public JobList <ProcessingJobDto> ProcessingJobs(int @from, int count) { return(UseConnection(connection => GetJobs( connection, from, count, ProcessingState.StateName, (sqlJob, job, stateData) => new ProcessingJobDto { Job = job, InProcessingState = ProcessingState.StateName.Equals(sqlJob.StateName, StringComparison.OrdinalIgnoreCase), ServerId = stateData.ContainsKey("ServerId") ? stateData["ServerId"] : stateData["ServerName"], StartedAt = JobHelper.DeserializeNullableDateTime(stateData["StartedAt"]), }))); }
/// <summary> /// 获取队列列表 /// </summary> public IList <QueueWithTopEnqueuedJobsDto> Queues() => UseConnection(redis => { var queues = redis.SMembers(_storage.GetRedisKey("queues")); var result = new List <QueueWithTopEnqueuedJobsDto>(queues.Length); foreach (var queue in queues) { string[] firstJobIds = null; long length = 0; long fetched = 0; Task[] tasks = new Task[3]; tasks[0] = _redisClient.LRangeAsync( _storage.GetRedisKey($"queue:{queue}"), -5, -1) .ContinueWith(x => firstJobIds = x.Result); tasks[1] = _redisClient.LLenAsync(_storage.GetRedisKey($"queue:{queue}")) .ContinueWith(x => length = x.Result); tasks[2] = _redisClient.LLenAsync(_storage.GetRedisKey($"queue:{queue}:dequeued")) .ContinueWith(x => fetched = x.Result); Task.WaitAll(tasks); var jobs = GetJobsWithProperties( redis, firstJobIds, new[] { "State" }, new[] { "EnqueuedAt", "State" }, (job, jobData, state) => new EnqueuedJobDto { Job = job, State = jobData[0], EnqueuedAt = JobHelper.DeserializeNullableDateTime(state[0]), InEnqueuedState = jobData[0].Equals(state[1], StringComparison.OrdinalIgnoreCase) }); result.Add(new QueueWithTopEnqueuedJobsDto { Name = queue, FirstJobs = jobs, Length = length, Fetched = fetched }); } return(result); });
public JobList <ScheduledJobDto> ScheduledJobs(int @from, int count) { return(UseConnection(connection => GetJobs( connection, from, count, ScheduledState.StateName, (sqlJob, job, stateData) => new ScheduledJobDto { Job = job, InScheduledState = ScheduledState.StateName.Equals(sqlJob.StateName, StringComparison.OrdinalIgnoreCase), EnqueueAt = JobHelper.DeserializeNullableDateTime(stateData["EnqueueAt"]) ?? DateTime.MinValue, ScheduledAt = sqlJob.StateChanged }))); }
public JobList <SucceededJobDto> SucceededJobs(int from, int count) { List <KeyValuePair <string, SucceededJobDto> > result = GetJobsOnState(States.SucceededState.StateName, from, count, (state, job) => new SucceededJobDto { Job = job, Result = state.Data.ContainsKey("Result") ? state.Data["Result"] : null, TotalDuration = state.Data.ContainsKey("PerformanceDuration") && state.Data.ContainsKey("Latency") ? (long?)long.Parse(state.Data["PerformanceDuration"]) + long.Parse(state.Data["Latency"]) : null, SucceededAt = JobHelper.DeserializeNullableDateTime(state.Data["SucceededAt"]) }).OrderByDescending(j => j.Value.SucceededAt).ToList(); return(new JobList <SucceededJobDto>(result)); }
public JobList <ScheduledJobDto> ScheduledJobs(int from, int count) { return(UseConnection(redis => { var scheduledJobs = redis.SortedSetRangeByRankWithScores( Redis.Prefix + "schedule", from, from + count - 1); if (scheduledJobs.Length == 0) { return new JobList <ScheduledJobDto>(new List <KeyValuePair <string, ScheduledJobDto> >()); } var jobs = new Dictionary <string, Task <RedisValue[]> >(); var states = new Dictionary <string, Task <RedisValue[]> >(); var Tasks = new Task[scheduledJobs.Length * 2]; int i = 0; var batch = redis.CreateBatch(); foreach (var scheduledJob in scheduledJobs) { var JobTask = batch.HashGetAsync(String.Format(Redis.Prefix + "job:{0}", scheduledJob.Element), new RedisValue[] { "Type", "Method", "ParameterTypes", "Arguments" }); Tasks[i++] = JobTask; jobs.Add(scheduledJob.Element, JobTask); var StatesTask = batch.HashGetAsync(String.Format(Redis.Prefix + "job:{0}:state", scheduledJob.Element), new RedisValue[] { "State", "ScheduledAt" }); Tasks[i++] = StatesTask; states.Add(scheduledJob.Element, StatesTask); } batch.Execute(); Task.WaitAll(Tasks); return new JobList <ScheduledJobDto>(scheduledJobs .Select(job => new KeyValuePair <string, ScheduledJobDto>( job.Element, new ScheduledJobDto { EnqueueAt = JobHelper.FromTimestamp((long)job.Score), Job = TryToGetJob(jobs[job.Element].Result[0], jobs[job.Element].Result[1], jobs[job.Element].Result[2], jobs[job.Element].Result[3]), ScheduledAt = states[job.Element].Result.Length > 1 ? JobHelper.DeserializeNullableDateTime(states[job.Element].Result[1]) : null, InScheduledState = ScheduledState.StateName.Equals(states[job.Element].Result[0], StringComparison.OrdinalIgnoreCase) })) .ToList()); })); }
private JobList <EnqueuedJobDto> EnqueuedJobs(HangfireDbContext connection, IEnumerable <int> jobIds) { var jobs = connection.HangfireJobRepository .Where(_ => jobIds.Contains(_.Id)) .ToList(); //SQLITE PCL LIMITED LAMBDA SUPPORT!! var enqueuedJobs = connection.JobQueueRepository .Where(_ => _.FetchedAt == DateTime.MinValue) .ToList() .Where(_ => jobs.Select(x => x.Id).Contains(_.JobId)) .ToList(); var jobsFiltered = enqueuedJobs .Select(jq => jobs.FirstOrDefault(job => job.Id == jq.JobId)); var joinedJobs = jobsFiltered .Where(job => job != null) .Select(job => { var state = connection.StateRepository.LastOrDefault(_ => _.JobId == job.Id); return(new JobDetailedDto { Id = job.Id, InvocationData = job.InvocationData, Arguments = job.Arguments, CreatedAt = job.CreatedAt, ExpireAt = job.ExpireAt, FetchedAt = null, StateName = job.StateName, StateReason = state?.Reason, StateData = JsonConvert.DeserializeObject <Dictionary <string, string> >(state?.Data) }); }) .ToList(); return(DeserializeJobs( joinedJobs, (sqlJob, job, invocationData, stateData) => new EnqueuedJobDto { Job = job, InvocationData = invocationData, State = sqlJob.StateName, EnqueuedAt = sqlJob.StateName == EnqueuedState.StateName ? JobHelper.DeserializeNullableDateTime(stateData.ContainsKey("EnqueuedAt") ? stateData["EnqueuedAt"] : string.Empty) : null })); }
//TODO: need test Query.In method private JobList <EnqueuedJobDto> EnqueuedJobs(HangfireDbContext connection, IEnumerable <int> jobIds) { var jobs = connection.Job .Find(x => jobIds.Contains(x.Id)) .ToList(); var enqueuedJobs = connection.JobQueue .Query() //.Where(x=>x.FetchedAt == null && jobs.Select(c=>c.Id).ToArray().Contains(x.JobId)) // V5 Weirdness: Splitting this to two separate statements worked, but keeping it as one fails! .Where(x => x.FetchedAt == null) .Where(x => jobs.Select(c => c.Id).ToArray().Contains(x.JobId)) .ToList(); var jobsFiltered = enqueuedJobs .Select(jq => jobs.FirstOrDefault(job => job.Id == jq.JobId)); var joinedJobs = jobsFiltered .Where(job => job != null) .Select(job => { var state = job.StateHistory.LastOrDefault(); return(new JobDetailedDto { Id = job.Id, InvocationData = job.InvocationData, Arguments = job.Arguments, CreatedAt = job.CreatedAt, ExpireAt = job.ExpireAt, FetchedAt = null, StateName = job.StateName, StateReason = state?.Reason, StateData = state?.Data }); }) .ToList(); return(DeserializeJobs( joinedJobs, (sqlJob, job, stateData) => new EnqueuedJobDto { Job = job, State = sqlJob.StateName, EnqueuedAt = sqlJob.StateName == EnqueuedState.StateName ? JobHelper.DeserializeNullableDateTime(stateData["EnqueuedAt"]) : null })); }
public JobList <ScheduledJobDto> ScheduledJobs(int from, int count) { return(UseConnection(redis => { var scheduledJobs = redis.ZRangeByScoreWithScores(_storage.GetRedisKey("schedule"), from, from + count - 1); if (scheduledJobs.Length == 0) { return new JobList <ScheduledJobDto>(new List <KeyValuePair <string, ScheduledJobDto> >()); } var jobs = new ConcurrentDictionary <string, List <string> >(); var states = new ConcurrentDictionary <string, List <string> >();; //var pipeline = redis.StartPipe(); //var tasks = new Task[scheduledJobs.Length * 2]; int i = 0; foreach (var scheduledJob in scheduledJobs) { var jobId = scheduledJob; var v1 = _redisClient.HMGet( _storage.GetRedisKey($"job:{jobId}"), new string[] { "Type", "Method", "ParameterTypes", "Arguments" }); jobs.TryAdd(jobId.member, v1.ToList()); i++; var v2 = _redisClient.HMGet( _storage.GetRedisKey($"job:{jobId}:state"), new string[] { "State", "ScheduledAt" }); states.TryAdd(jobId.member, v2.ToList()); i++; } return new JobList <ScheduledJobDto>(scheduledJobs .Select(job => new KeyValuePair <string, ScheduledJobDto>( job.member, new ScheduledJobDto { EnqueueAt = JobHelper.FromTimestamp((long)job.score), Job = TryToGetJob(jobs[job.member][0], jobs[job.member][1], jobs[job.member][2], jobs[job.member][3]), ScheduledAt = states[job.member].Count > 1 ? JobHelper.DeserializeNullableDateTime(states[job.member][1]) : null, InScheduledState = ScheduledState.StateName.Equals(states[job.member][0], StringComparison.OrdinalIgnoreCase) })) .ToList()); })); }
public JobList <ScheduledJobDto> ScheduledJobs(int from, int count) => UseConnection(redis => { var scheduledJobs = redis .SortedSetRangeByRankWithScores(_storage.GetRedisKey("schedule"), from, from + count - 1); if (scheduledJobs.Length == 0) { return(new JobList <ScheduledJobDto>(Enumerable.Empty <KeyValuePair <string, ScheduledJobDto> >())); } var jobProperties = new RedisValue[] { "Type", "Method", "ParameterTypes", "Arguments" }; var stateProperties = new RedisValue[] { "State", "ScheduledAt" }; var jobs = new ConcurrentDictionary <string, string[]>(StringComparer.OrdinalIgnoreCase); var states = new ConcurrentDictionary <string, string[]>(StringComparer.OrdinalIgnoreCase);; var pipeline = redis.CreateBatch(); var tasks = new Task[scheduledJobs.Length * 2]; var i = 0; foreach (var job in scheduledJobs) { var jobId = (string)job.Element; tasks[i++] = pipeline.HashGetAsync(_storage.GetRedisKey($"job:{jobId}"), jobProperties) .ContinueWith(x => jobs.TryAdd(jobId, x.Result.ToStringArray()), ContinuationOptions); tasks[i++] = pipeline.HashGetAsync(_storage.GetRedisKey($"job:{jobId}:state"), stateProperties) .ContinueWith(x => states.TryAdd(jobId, x.Result.ToStringArray()), ContinuationOptions); } pipeline.Execute(); pipeline.WaitAll(tasks); return(new JobList <ScheduledJobDto>(scheduledJobs .Select(job => { var jobId = (string)job.Element; var state = states[jobId]; return new KeyValuePair <string, ScheduledJobDto>(jobId, new ScheduledJobDto { EnqueueAt = JobHelper.FromTimestamp((long)job.Score), Job = TryToGetJob(jobs[jobId], 0), ScheduledAt = JobHelper.DeserializeNullableDateTime(state[1]), InScheduledState = ScheduledState.StateName.Equals(state[0], StringComparison.OrdinalIgnoreCase) }); }))); });
private JobList <EnqueuedJobDto> EnqueuedJobs(HangfireDbContext connection, IEnumerable <int> jobIds) { List <JobDto> jobs = connection.Job .Find(Builders <JobDto> .Filter.In(_ => _.Id, jobIds)) .ToList(); Dictionary <int, JobQueueDto> jobIdToJobQueueMap = connection.JobQueue .Find(Builders <JobQueueDto> .Filter.In(_ => _.JobId, jobs.Select(job => job.Id)) & (Builders <JobQueueDto> .Filter.Not(Builders <JobQueueDto> .Filter.Exists(_ => _.FetchedAt)) | Builders <JobQueueDto> .Filter.Eq(_ => _.FetchedAt, null))) .ToList().ToDictionary(kv => kv.JobId, kv => kv); Dictionary <int, StateDto> jobIdToStateMap = connection.State .Find(Builders <StateDto> .Filter.In(_ => _.Id, jobs.Select(job => job.StateId))) .ToList().ToDictionary(kv => kv.JobId, kv => kv); IEnumerable <JobDto> jobsFiltered = jobs.Where(job => jobIdToJobQueueMap.ContainsKey(job.Id)); List <JobDetailedDto> joinedJobs = jobsFiltered .Select(job => { var state = jobIdToStateMap.ContainsKey(job.Id) ? jobIdToStateMap[job.Id] : null; return(new JobDetailedDto { Id = job.Id, InvocationData = job.InvocationData, Arguments = job.Arguments, CreatedAt = job.CreatedAt, ExpireAt = job.ExpireAt, FetchedAt = null, StateId = job.StateId, StateName = job.StateName, StateReason = state?.Reason, StateData = state?.Data }); }) .ToList(); return(DeserializeJobs( joinedJobs, (sqlJob, job, stateData) => new EnqueuedJobDto { Job = job, State = sqlJob.StateName, EnqueuedAt = sqlJob.StateName == EnqueuedState.StateName ? JobHelper.DeserializeNullableDateTime(stateData["EnqueuedAt"]) : null })); }
public void CheckDefaultConstructor() { var watcher = new FetchedJobsWatcher(Redis.Storage); var redis = Redis.Storage.GetDatabase(); // Arrange redis.SetAdd(Prefix + "queues", "my-queue", 0); redis.ListLeftPush(Prefix + "queue:my-queue:dequeued", "my-job"); watcher.Execute(_cts.Token); Assert.NotNull(JobHelper.DeserializeNullableDateTime( redis.HashGet(Prefix + "job:my-job", "Checked"))); }
public List <FailedJobDto> GetFailedJobs(int from, int count) { return(GetJobs <FailedJobDto>(FailedState.DefaultName, from, count, (job, stateData) => { return new FailedJobDto() { JobInfo = job, Reason = job.StateReason, ExceptionDetails = stateData["ExceptionDetails"], ExceptionMessage = stateData["ExceptionMessage"], ExceptionType = stateData["ExceptionType"], FailedAt = JobHelper.DeserializeNullableDateTime(stateData["FailedAt"]) }; })); }
private JobList <EnqueuedJobDto> EnqueuedJobs(IEnumerable <string> jobIds) { using (var repository = _storage.Repository.OpenSession()) { var jobs = repository.Load <RavenJob>(jobIds.Select(a => Repository.GetId(typeof(RavenJob), a))) .Where(a => a != null && a.StateData != null); return(DeserializeJobs(jobs, (jsonJob, job, stateData) => new EnqueuedJobDto { Job = job, State = jsonJob.StateData.Name, EnqueuedAt = jsonJob.StateData.Name == EnqueuedState.StateName ? JobHelper.DeserializeNullableDateTime(stateData["EnqueuedAt"]) : null })); } }
private DateTime?ExtractCompletionDT(Dictionary <string, string> stateData) { if (stateData.ContainsKey("SucceededAt")) { return(JobHelper.DeserializeNullableDateTime(stateData["SucceededAt"])); } if (stateData.ContainsKey("FailedAt")) { return(JobHelper.DeserializeNullableDateTime(stateData["FailedAt"])); } if (stateData.ContainsKey("DeletedAt")) { return(JobHelper.DeserializeNullableDateTime(stateData["DeletedAt"])); } return(null); }
public void Execute_MarksDequeuedJobAsChecked_IfItHasNoFetchedFlagSet() { var redis = RedisUtils.CreateClient(); // Arrange redis.SetAdd("{hangfire}:queues", "my-queue"); redis.ListRightPush("{hangfire}:queue:my-queue:dequeued", "my-job"); var watcher = CreateWatcher(); // Act watcher.Execute(_cts.Token); Assert.NotNull(JobHelper.DeserializeNullableDateTime( redis.HashGet("{hangfire}:job:my-job", "Checked"))); }
/// <summary> /// 已删除的作业 /// </summary> /// <param name="from">开始范围</param> /// <param name="count">数量</param> public JobList <DeletedJobDto> DeletedJobs(int @from, int count) => UseConnection(redis => { var deletedJobIds = redis.LRange(_storage.GetRedisKey("deleted"), @from, @from + count - 1); return(GetJobsWithProperties( redis, deletedJobIds, null, new[] { "DeletedAt", "State" }, (job, jobData, state) => new DeletedJobDto { Job = job, DeletedAt = JobHelper.DeserializeNullableDateTime(state[0]), InDeletedState = DeletedState.StateName.Equals(state[1], StringComparison.OrdinalIgnoreCase) })); });
public void Execute_MarksDequeuedJobAsChecked_IfItHasNoFetchedFlagSet() { var redis = Redis.Storage.GetDatabase(); // Arrange redis.SetAdd(Prefix + "queues", "my-queue"); redis.ListLeftPush(Prefix + "queue:my-queue:dequeued", "my-job"); var watcher = CreateWatcher(); // Act watcher.Execute(_cts.Token); Assert.NotNull(JobHelper.DeserializeNullableDateTime( redis.HashGet(Prefix + "job:my-job", "Checked"))); }
private JobList <EnqueuedJobDto> EnqueuedJobs(HangfireDbContext connection, IEnumerable <string> jobIds) { var jobObjectIds = jobIds.Select(ObjectId.Parse); var jobs = connection.Job .Find(Builders <JobDto> .Filter.In(_ => _.Id, jobObjectIds)) .ToList(); var filterBuilder = Builders <JobQueueDto> .Filter; var enqueuedJobs = connection.JobQueue .Find(filterBuilder.In(_ => _.JobId, jobs.Select(job => job.Id)) & (filterBuilder.Not(filterBuilder.Exists(_ => _.FetchedAt)) | filterBuilder.Eq(_ => _.FetchedAt, null))) .ToList(); var jobsFiltered = enqueuedJobs .Select(jq => jobs.FirstOrDefault(job => job.Id == jq.JobId)); var joinedJobs = jobsFiltered .Where(job => job != null) .Select(job => { var state = job.StateHistory.LastOrDefault(); return(new JobDetailedDto { Id = job.Id, InvocationData = job.InvocationData, Arguments = job.Arguments, CreatedAt = job.CreatedAt, ExpireAt = job.ExpireAt, FetchedAt = null, StateName = job.StateName, StateReason = state?.Reason, StateData = state?.Data }); }) .ToList(); return(DeserializeJobs( joinedJobs, (sqlJob, job, stateData) => new EnqueuedJobDto { Job = job, State = sqlJob.StateName, EnqueuedAt = sqlJob.StateName == EnqueuedState.StateName ? JobHelper.DeserializeNullableDateTime(stateData["EnqueuedAt"]) : null })); }
private JobList <EnqueuedJobDto> EnqueuedJobs( SessionWrapper session, IEnumerable <int> jobIds) { var jobs = session.Query <_Job>().Where(i => jobIds.Contains(i.Id)).ToList(); return(DeserializeJobs( jobs, (sqlJob, job, stateData) => new EnqueuedJobDto { Job = job, State = sqlJob.StateName, EnqueuedAt = sqlJob.StateName == EnqueuedState.StateName ? JobHelper.DeserializeNullableDateTime(stateData["EnqueuedAt"]) : null })); }
public JobList <SucceededJobDto> SucceededJobs(int from, int count) { var toReturn = GetJobs(from, count, SucceededState.StateName, (jsonJob, job, stateData) => new SucceededJobDto { Job = job, InSucceededState = true, Result = stateData.ContainsKey("Result") ? stateData["Result"] : null, TotalDuration = stateData.ContainsKey("PerformanceDuration") && stateData.ContainsKey("Latency") ? (long?)long.Parse(stateData["PerformanceDuration"]) + (long?)long.Parse(stateData["Latency"]) : null, SucceededAt = JobHelper.DeserializeNullableDateTime(stateData["SucceededAt"]) }); return(toReturn); }
public JobList <DeletedJobDto> DeletedJobs(int @from, int count) { return(UsingDatabase(db => { return new JobList <DeletedJobDto>(db.GetTable <Entities.Job>() .Where(x => x.StateName == "Deleted") .OrderByDescending(x => x.Id) .Skip(from) .Take(count) .Select(x => new KeyValuePair <string, DeletedJobDto>(x.Id.ToString(), new DeletedJobDto() { Job = x.ToCommonJob(), DeletedAt = JobHelper.DeserializeNullableDateTime(x.ToStateData().Data["DeletedAt"]) })) .ToList()); })); }
public void Execute_MarksDequeuedJobAsChecked_IfItHasNoFetchedFlagSet() { using (var redis = RedisUtils.CreateClient()) { // Arrange redis.AddItemToSet("hangfire:queues", "my-queue"); redis.AddItemToList("hangfire:queue:my-queue:dequeued", "my-job"); var watcher = CreateWatcher(); // Act watcher.Execute(_cts.Token); Assert.NotNull(JobHelper.DeserializeNullableDateTime( redis.GetValueFromHash("hangfire:job:my-job", "Checked"))); } }