haoliang/Haoliang.Models/DataCollection/AdditionalCollectionModels.cs

using System;
using System.Collections.Generic;

namespace Haoliang.Models.DataCollection
{
    public class CollectionTask
    {
        public int Id { get; set; }
        public int DeviceId { get; set; }
        public string TaskName { get; set; }
        public string Status { get; set; } // Pending, Running, Completed, Failed
        public DateTime ScheduledTime { get; set; }
        public DateTime? StartTime { get; set; }
        public DateTime? EndTime { get; set; }
        public bool IsSuccess { get; set; }
        public string ErrorMessage { get; set; }
        public int RetryCount { get; set; }
        public DateTime CreatedAt { get; set; }
    }

    public class CollectionResult
    {
        public int Id { get; set; }
        public int DeviceId { get; set; }
        public bool IsSuccess { get; set; }
        public string RawJson { get; set; }
        public string ParsedData { get; set; }
        public DateTime CollectionTime { get; set; }
        public long? ResponseTime { get; set; }
        public int? DataSize { get; set; }
        public string ErrorMessage { get; set; }
        public DateTime CreatedAt { get; set; }
    }

    public class CollectionLog
    {
        public int Id { get; set; }
        public int DeviceId { get; set; }
        public LogLevel LogLevel { get; set; }
        public string LogCategory { get; set; }
        public string LogMessage { get; set; }
        public string LogData { get; set; }
        public DateTime LogTime { get; set; }
        public DateTime CreatedAt { get; set; }
    }

    public class PingResult
    {
        public bool IsSuccess { get; set; }
        public int PingTimeMs { get; set; }
        public string ErrorMessage { get; set; }
        public DateTime Timestamp { get; set; }
    }

    public class DeviceStatus
    {
        public int Id { get; set; }
        public int DeviceId { get; set; }
        public string Status { get; set; }
        public bool IsRunning { get; set; }
        public string NCProgram { get; set; }
        public int CumulativeCount { get; set; }
        public string OperatingMode { get; set; }
        public DateTime RecordTime { get; set; }
    }

    public class TagData
    {
        public string Id { get; set; }
        public string Desc { get; set; }
        public string Quality { get; set; }
        public object Value { get; set; }
        public DateTime Time { get; set; }
    }

    public class CollectionStatistics
    {
        public DateTime Date { get; set; }
        public int TotalAttempts { get; set; }
        public int SuccessCount { get; set; }
        public int FailedCount { get; set; }
        public decimal SuccessRate { get; set; }
        public int DeviceCount { get; set; }
        public int OnlineDeviceCount { get; set; }
        public long TotalDataSize { get; set; }
        public TimeSpan? AverageResponseTime { get; set; }
    }

    public interface ICachingService
    {
        Task<T> GetAsync<T>(string key);
        Task SetAsync<T>(string key, T value, TimeSpan? expiration = null);
        Task<bool> RemoveAsync(string key);
        Task<bool> ExistsAsync(string key);
        Task ClearAsync();
        Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null);
        Task<IEnumerable<string>> GetAllKeysAsync();
        Task<bool> RefreshAsync<T>(string key);
    }

    public interface ISchedulerService
    {
        Task StartSchedulerAsync();
        Task StopSchedulerAsync();
        Task ScheduleTaskAsync(ScheduledTask task);
        Task<bool> RemoveTaskAsync(string taskId);
        Task<IEnumerable<ScheduledTask>> GetAllScheduledTasksAsync();
        Task<ScheduledTask> GetTaskByIdAsync(string taskId);
        Task ExecuteTaskAsync(string taskId);
        Task<TaskExecutionResult> GetTaskExecutionResultAsync(string taskId);
        Task<bool> IsTaskRunningAsync(string taskId);
    }

    public interface IWebSocketAuthMiddleware
    {
        Task AuthenticateAsync(string connectionId, string token);
        Task<string> GetUserIdAsync(string connectionId);
        Task<string> GetConnectionIdAsync(string userId);
        Task<bool> IsAuthenticatedAsync(string connectionId);
        Task<bool> HasPermissionAsync(string connectionId, string permission);
    }

    public class BackgroundTaskManager : ISchedulerService
    {
        // Implementation would go here - this is just a placeholder
        public async Task StartSchedulerAsync() { await Task.CompletedTask; }
        public async Task StopSchedulerAsync() { await Task.CompletedTask; }
        public async Task ScheduleTaskAsync(ScheduledTask task) { await Task.CompletedTask; }
        public async Task<bool> RemoveTaskAsync(string taskId) { return true; }
        public async Task<IEnumerable<ScheduledTask>> GetAllScheduledTasksAsync() { return new List<ScheduledTask>(); }
        public async Task<ScheduledTask> GetTaskByIdAsync(string taskId) { return null; }
        public async Task ExecuteTaskAsync(string taskId) { await Task.CompletedTask; }
        public async Task<TaskExecutionResult> GetTaskExecutionResultAsync(string taskId) { return null; }
        public async Task<bool> IsTaskRunningAsync(string taskId) { return false; }
    }

    public class CacheManager : ICachingService
    {
        // Implementation would go here - this is just a placeholder
        public async Task<T> GetAsync<T>(string key) { return default; }
        public async Task SetAsync<T>(string key, T value, TimeSpan? expiration = null) { await Task.CompletedTask; }
        public async Task<bool> RemoveAsync(string key) { return true; }
        public async Task<bool> ExistsAsync(string key) { return false; }
        public async Task ClearAsync() { await Task.CompletedTask; }
        public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null) { return default; }
        public async Task<IEnumerable<string>> GetAllKeysAsync() { return new List<string>(); }
        public async Task<bool> RefreshAsync<T>(string key) { return true; }
    }
}