1241 lines
51 KiB
C#
1241 lines
51 KiB
C#
using Dto;
|
||
using MotionFramework;
|
||
using MotionFramework.Scripts.Runtime.Engine.Engine.Network.WebRequest;
|
||
using Newtonsoft.Json;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using Cysharp.Threading.Tasks;
|
||
using DefaultNamespace.ProcessMode;
|
||
using Framework.Utils;
|
||
using UnityEngine;
|
||
using Zion.ERP.Inventory;
|
||
using System.IO.Compression;
|
||
using UnityEditor;
|
||
using System.Linq;
|
||
using Framework.ProcessMode;
|
||
using UnityEngine.UI;
|
||
|
||
namespace DefaultNamespace
|
||
{
|
||
public static class FileComponent
|
||
{
|
||
private static string _localFilePath = string.Empty;
|
||
private static string _answerFilePath = string.Empty; //答题卡
|
||
private static List<float> _scores = new List<float>();
|
||
|
||
// 文件下载配置管理器
|
||
private static ExamFileConfigManager _configManager;
|
||
|
||
// 已下载文件路径跟踪（题目名称 -> 文件路径列表）
|
||
private static Dictionary<string, List<string>> _downloadedFiles = new Dictionary<string, List<string>>();
|
||
|
||
// 配置文件路径
|
||
private static readonly string CONFIG_FILE_PATH = "DataConfig/exam_file_config.json";
|
||
|
||
// 答题卡按钮引用（需要在运行时设置）
|
||
private static Button _answerSheetButton;
|
||
|
||
// 答题卡文件路径（题目名称 -> 答题卡文件路径）
|
||
private static Dictionary<string, string> _answerSheetFiles = new Dictionary<string, string>();
|
||
|
||
// 文件下载完成事件（文件名 -> 文件路径）
|
||
public static event System.Action<string, string> OnFileDownloadCompleted;
|
||
|
||
|
||
/// <summary>
|
||
/// 设置答题卡按钮引用
|
||
/// </summary>
|
||
/// <param name="button">答题卡按钮</param>
|
||
public static void SetAnswerSheetButton(Button button)
|
||
{
|
||
_answerSheetButton = button;
|
||
Debug.Log("FileComponent: 答题卡按钮引用已设置");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置过程步骤的分数
|
||
/// </summary>
|
||
/// <param name="processSteps"></param>
|
||
public static void SetProcessSteps(List<ProcessStep> processSteps)
|
||
{
|
||
_scores.Clear();
|
||
foreach (var step in processSteps)
|
||
{
|
||
foreach (var action in step.Actions)
|
||
{
|
||
_scores.Add(action.Score);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 初始化文件下载配置管理器
|
||
/// </summary>
|
||
private static async UniTask InitializeConfigManager()
|
||
{
|
||
if (_configManager != null) return;
|
||
|
||
try
|
||
{
|
||
Debug.Log("开始初始化文件下载配置管理器");
|
||
|
||
// 读取配置文件
|
||
string configPath = Path.Combine(Application.streamingAssetsPath, CONFIG_FILE_PATH);
|
||
if (!File.Exists(configPath))
|
||
{
|
||
Debug.LogError($"配置文件不存在：{configPath}");
|
||
_configManager = new ExamFileConfigManager();
|
||
return;
|
||
}
|
||
|
||
string jsonContent = await File.ReadAllTextAsync(configPath);
|
||
_configManager = JsonConvert.DeserializeObject<ExamFileConfigManager>(jsonContent);
|
||
|
||
if (_configManager == null)
|
||
{
|
||
Debug.LogError("配置文件解析失败");
|
||
_configManager = new ExamFileConfigManager();
|
||
return;
|
||
}
|
||
|
||
// 验证配置
|
||
if (!_configManager.Validate())
|
||
{
|
||
Debug.LogError("配置文件验证失败");
|
||
}
|
||
|
||
Debug.Log($"文件下载配置管理器初始化完成，共加载 {_configManager.examFileConfigs.Count} 个考试类型配置");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"初始化文件下载配置管理器失败：{ex.Message}");
|
||
_configManager = new ExamFileConfigManager();
|
||
}
|
||
}
|
||
|
||
// 移除了ExamQuestionTypes版本的GetExamFileInfos方法，统一使用字符串版本
|
||
|
||
/// <summary>
|
||
/// 获取指定题目的所有文件下载信息（使用题目名字）
|
||
/// </summary>
|
||
/// <param name="examName">题目名字</param>
|
||
/// <returns>文件下载信息列表</returns>
|
||
public static async UniTask<List<FileDownloadInfo>> GetExamFileInfos(string examName)
|
||
{
|
||
await InitializeConfigManager();
|
||
|
||
var config = _configManager.GetConfigByExamType(examName);
|
||
if (config == null)
|
||
{
|
||
Debug.LogWarning($"未找到题目 '{examName}' 的文件配置");
|
||
return new List<FileDownloadInfo>();
|
||
}
|
||
|
||
return config.files;
|
||
}
|
||
|
||
// 移除了所有ExamQuestionTypes版本的方法重载，统一使用字符串题目名称
|
||
|
||
/// <summary>
|
||
/// 获取当前题目的文件下载信息（包含名称和URL，使用全局题目名字）
|
||
/// </summary>
|
||
/// <returns>文件下载信息列表（包含名称和URL）</returns>
|
||
public static async UniTask<List<(string name, string url)>> GetExamFileInfoWithUrls()
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
var fileInfos = await GetExamFileInfos(examName);
|
||
return fileInfos.Select(f => (f.name, f.url)).ToList();
|
||
}
|
||
|
||
// 移除了ExamQuestionTypes版本的DownloadSingleFile方法，统一使用字符串版本
|
||
|
||
// /// <summary>
|
||
// /// 下载单个文件（通过索引）
|
||
// /// </summary>
|
||
// /// <param name="examType">考试类型</param>
|
||
// /// <param name="fileIndex">文件索引（从0开始）</param>
|
||
// public static async UniTaskVoid DownloadSingleFileByIndex(ExamQuestionTypes examType, int fileIndex)
|
||
// {
|
||
// Debug.Log($"FileComponent.DownloadSingleFileByIndex 被调用，考试类型：{examType}，文件索引：{fileIndex}");
|
||
//
|
||
// try
|
||
// {
|
||
// // 从配置文件获取该考试类型的所有文件信息
|
||
// var fileInfos = await GetExamFileInfos(examType);
|
||
// if (fileInfos.Count == 0)
|
||
// {
|
||
// Debug.LogWarning($"考试类型 '{examType}' 在配置文件中没有配置任何文件");
|
||
// return;
|
||
// }
|
||
//
|
||
// if (fileIndex < 0 || fileIndex >= fileInfos.Count)
|
||
// {
|
||
// Debug.LogError($"文件索引 {fileIndex} 超出范围，配置文件中共有 {fileInfos.Count} 个文件");
|
||
// return;
|
||
// }
|
||
//
|
||
// var targetFile = fileInfos[fileIndex];
|
||
// Debug.Log($"开始下载索引为 {fileIndex} 的文件：{targetFile.name}");
|
||
//
|
||
// // 下载单个文件
|
||
// await DownloadSingleFileAsync(examType, targetFile);
|
||
//
|
||
// // 更新已下载文件列表
|
||
// if (!_downloadedFiles.ContainsKey(examType))
|
||
// {
|
||
// _downloadedFiles[examType] = new List<string>();
|
||
// }
|
||
//
|
||
// // 重新获取已下载的文件路径
|
||
// var config = _configManager.GetConfigByExamType(examType);
|
||
// if (config != null)
|
||
// {
|
||
// var downloadedPaths = config.GetDownloadedFilePaths();
|
||
// _downloadedFiles[examType] = downloadedPaths;
|
||
// }
|
||
//
|
||
// Debug.Log($"索引为 {fileIndex} 的文件 '{targetFile.name}' 下载完成");
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// Debug.LogError($"下载索引为 {fileIndex} 的文件时发生错误：{ex.Message}");
|
||
// }
|
||
// }
|
||
|
||
/// <summary>
|
||
/// 从本地StreamingAssets/biaodan目录查找并打开文件（使用全局题目名字）
|
||
/// </summary>
|
||
/// <param name="fileName">要查找的文件名称</param>
|
||
public static async UniTaskVoid DownloadSingleFile(string fileName)
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
Debug.Log($"FileComponent.DownloadSingleFile 被调用，全局题目名字：{examName}，文件名称：{fileName}");
|
||
|
||
try
|
||
{
|
||
// 从配置文件获取该题目的所有文件信息
|
||
var fileInfos = await GetExamFileInfos(examName);
|
||
if (fileInfos.Count == 0)
|
||
{
|
||
Debug.LogWarning($"题目 '{examName}' 在配置文件中没有配置任何文件");
|
||
return;
|
||
}
|
||
|
||
// 查找指定名称的文件配置
|
||
var targetFile = fileInfos.FirstOrDefault(f => f.name == fileName);
|
||
if (targetFile == null)
|
||
{
|
||
Debug.LogError($"在题目 '{examName}' 的配置文件中未找到文件：{fileName}");
|
||
return;
|
||
}
|
||
|
||
// 在StreamingAssets/biaodan目录下查找文件
|
||
string biaodanDir = Path.Combine(Application.streamingAssetsPath, "biaodan");
|
||
if (!Directory.Exists(biaodanDir))
|
||
{
|
||
Debug.LogError($"目录不存在：{biaodanDir}");
|
||
return;
|
||
}
|
||
|
||
// 根据配置中的fileName查找匹配的文件
|
||
string targetFileName = targetFile.fileName;
|
||
string[] files = Directory.GetFiles(biaodanDir, "*", SearchOption.AllDirectories);
|
||
|
||
// 查找完全匹配或包含目标文件名的文件
|
||
string foundFilePath = files.FirstOrDefault(f =>
|
||
{
|
||
string file = Path.GetFileName(f);
|
||
return file == targetFileName ||
|
||
file.Contains(targetFileName) ||
|
||
targetFileName.Contains(file);
|
||
});
|
||
|
||
if (string.IsNullOrEmpty(foundFilePath))
|
||
{
|
||
// 如果精确匹配失败，尝试使用文件名（不含扩展名）匹配
|
||
string fileNameWithoutExt = Path.GetFileNameWithoutExtension(targetFileName);
|
||
foundFilePath = files.FirstOrDefault(f =>
|
||
{
|
||
string file = Path.GetFileNameWithoutExtension(f);
|
||
return file == fileNameWithoutExt || file.Contains(fileNameWithoutExt);
|
||
});
|
||
}
|
||
|
||
if (string.IsNullOrEmpty(foundFilePath) || !File.Exists(foundFilePath))
|
||
{
|
||
Debug.LogError($"在目录 '{biaodanDir}' 中未找到文件：{targetFileName}");
|
||
return;
|
||
}
|
||
|
||
Debug.Log($"在本地找到文件：{foundFilePath}，准备打开");
|
||
|
||
// 检测文件是否已打开
|
||
if (IsFileOpen(foundFilePath))
|
||
{
|
||
Debug.Log($"文件 '{fileName}' 已打开，无需重复打开");
|
||
return;
|
||
}
|
||
|
||
// 打开文件
|
||
bool openResult = FileUtils.OpenFile(foundFilePath);
|
||
if (!openResult)
|
||
{
|
||
Debug.LogError($"打开文件失败：{foundFilePath}");
|
||
return;
|
||
}
|
||
|
||
Debug.Log($"成功打开文件：{foundFilePath}");
|
||
|
||
// 更新已下载文件列表（用于后续上传等功能）
|
||
if (!_downloadedFiles.ContainsKey(examName))
|
||
{
|
||
_downloadedFiles[examName] = new List<string>();
|
||
}
|
||
|
||
// 如果文件不在列表中，则添加
|
||
if (!_downloadedFiles[examName].Contains(foundFilePath))
|
||
{
|
||
_downloadedFiles[examName].Add(foundFilePath);
|
||
}
|
||
|
||
// 检测是否为答题卡文件
|
||
if (IsAnswerSheetFile(fileName))
|
||
{
|
||
Debug.Log($"检测到答题卡文件：{fileName}");
|
||
_answerSheetFiles[examName] = foundFilePath;
|
||
ShowAnswerSheetButton();
|
||
}
|
||
|
||
// 触发文件下载完成事件（保持兼容性）
|
||
OnFileDownloadCompleted?.Invoke(fileName, foundFilePath);
|
||
|
||
Debug.Log($"文件 '{fileName}' 处理完成");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"处理文件 '{fileName}' 时发生错误：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 上传当前考试的文件（完全基于配置文件，使用全局题目名字）
|
||
/// </summary>
|
||
public static async UniTask<(bool, string)> UploadExamFiles()
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
Debug.Log($"FileComponent.UploadExamFiles 被调用，全局题目名字：{examName}");
|
||
|
||
|
||
// 先上传文件，获取文件URL
|
||
var (fileUrl, success) = await UploadExamFilesAsync(examName);
|
||
if (!success)
|
||
{
|
||
Debug.LogError($"文件上传失败：{fileUrl}");
|
||
return (false, fileUrl); // 上传失败，直接返回
|
||
}
|
||
|
||
// 然后提交题目数据，将文件URL作为备注
|
||
await UploadData(fileUrl);
|
||
|
||
Debug.Log($"题目 '{examName}' 的所有数据和文件上传完成（基于配置文件），文件URL：{fileUrl}");
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// Debug.LogError($"上传题目 '{examName}' 的文件时发生错误：{ex.Message}");
|
||
// }
|
||
return (true, "提交成功");
|
||
}
|
||
|
||
|
||
private static async UniTask UploadData(string fileUrl = null)
|
||
{
|
||
// try
|
||
// {
|
||
ExamInfo examInfo = MotionEngine.GetModule<GlobalDataStorage>().ExamInfo;
|
||
|
||
// 构建上传数据
|
||
UploadExamDto uploadExamDto = new UploadExamDto();
|
||
float score = MotionEngine.GetModule<ProcessManager>().CalculateTotalScore();
|
||
// 设置DTO中的所有字段
|
||
uploadExamDto.id = "0";
|
||
uploadExamDto.appId = examInfo.AppID;
|
||
uploadExamDto.courseId = examInfo.CourseId;
|
||
uploadExamDto.examId = examInfo.PaperId;
|
||
uploadExamDto.examinationId = examInfo.ExamRoomId;
|
||
uploadExamDto.stuId = examInfo.StudentId;
|
||
uploadExamDto.groupId = examInfo.GroupId;
|
||
uploadExamDto.machineId = string.Empty;
|
||
uploadExamDto.batchId = examInfo.BatchId;
|
||
uploadExamDto.operationType = "3";
|
||
uploadExamDto.isComp = uploadExamDto.examId.ToString();
|
||
uploadExamDto.currentProcess = "0";
|
||
uploadExamDto.sumProcess = "0";
|
||
uploadExamDto.score = score.ToString();
|
||
uploadExamDto.preScore = "0";
|
||
uploadExamDto.inTimes = (MotionEngine.GetModule<ProcessManager>().GetUsedTimeInSeconds()).ToString();
|
||
uploadExamDto.remark = fileUrl; // 将文件URL作为备注
|
||
uploadExamDto.stepName = string.Empty;
|
||
uploadExamDto.testPoint = string.Empty;
|
||
uploadExamDto.defaultScore = "0";
|
||
|
||
// 构建考试步骤列表
|
||
UploadExamStepList uploadExamStepList = new UploadExamStepList();
|
||
uploadExamStepList.time = (MotionEngine.GetModule<ProcessManager>().GetUsedTimeInSeconds()).ToString();
|
||
|
||
|
||
uploadExamStepList.score = score.ToString();
|
||
|
||
uploadExamStepList.stepList = new List<StepListItem>();
|
||
|
||
|
||
// 获取流程管理器
|
||
var processManager = MotionEngine.GetModule<ProcessManager>();
|
||
|
||
// 获取当前流程集合中的所有步骤
|
||
var steps = processManager.CurrentProcessCollection.Steps;
|
||
|
||
// 遍历所有步骤和动作，创建步骤列表项
|
||
for (int stepIndex = 0; stepIndex < steps.Count; stepIndex++)
|
||
{
|
||
var step = steps[stepIndex];
|
||
float stepScore = (float)step.Score; // 确保转换为float类型
|
||
int actionCount = step.Actions.Count;
|
||
|
||
// 精确计算每个动作的分数，完全保留小数点精度
|
||
float actionScorePerAction = 0f;
|
||
if (actionCount > 0)
|
||
{
|
||
actionScorePerAction = stepScore / (float)actionCount; // 移除Math.Round，保留原始精度
|
||
}
|
||
|
||
for (int actionIndex = 0; actionIndex < step.Actions.Count; actionIndex++)
|
||
{
|
||
var action = step.Actions[actionIndex];
|
||
|
||
// 精确计算每个答案的分数，完全保留小数点精度
|
||
int answerCount = GetTotalQuestionsCount(action);
|
||
float answerScorePerAnswer = 0f;
|
||
if (answerCount > 0)
|
||
{
|
||
answerScorePerAnswer = actionScorePerAction / (float)answerCount; // 移除Math.Round，保留原始精度
|
||
}
|
||
|
||
// 计算动作实际得分（考虑错误扣分）
|
||
float actionActualScore = 0;
|
||
if (action.IsCompleted)
|
||
{
|
||
var currentActionErrors = processManager._incorrectClicksPerStep
|
||
.Where(kvp => kvp.Key.stepIndex == stepIndex && kvp.Key.actionIndex == actionIndex)
|
||
.SelectMany(kvp => kvp.Value)
|
||
.ToList();
|
||
|
||
if (currentActionErrors.Count > 0)
|
||
{
|
||
// 每个错误答案扣一个答案的分数，完全保留小数点精度
|
||
float totalDeduction = answerScorePerAnswer * (float)currentActionErrors.Count; // 移除Math.Round，保留原始精度
|
||
totalDeduction = Math.Min(totalDeduction, actionScorePerAction); // 扣分不超过动作总分
|
||
actionActualScore = Math.Max(0, actionScorePerAction - totalDeduction);
|
||
}
|
||
else
|
||
{
|
||
actionActualScore = actionScorePerAction;
|
||
}
|
||
}
|
||
|
||
// 创建步骤项
|
||
StepListItem stepItem = new StepListItem
|
||
{
|
||
stepName = step.StepDescription,
|
||
testPoint = action.Title,
|
||
setScore = actionActualScore, // 动作实际得分（考虑错误扣分），完全保留小数点
|
||
defaultScore = actionScorePerAction, // 动作应该得到的分数（步骤分数 ÷ 动作数量），完全保留小数点
|
||
isKey = "1",
|
||
batch = (stepIndex + 1).ToString(),
|
||
isTrue = action.IsCompleted ? "1" : "0",
|
||
cause = "",
|
||
answers = GenerateAnswersList(stepIndex, actionIndex, action)
|
||
};
|
||
|
||
// 添加步骤项到列表
|
||
uploadExamStepList.stepList.Add(stepItem);
|
||
}
|
||
}
|
||
|
||
// // 创建步骤项
|
||
// StepListItem stepItem = new StepListItem
|
||
// {
|
||
// stepName = "测试步骤",
|
||
// testPoint = "测试点",
|
||
// setScore = 100,
|
||
// defaultScore = 100,
|
||
// isKey = "1",
|
||
// batch = "1",
|
||
// isTrue = "1",
|
||
// cause = ""
|
||
// };
|
||
|
||
// 序列化考试步骤数据
|
||
uploadExamDto.recordContent = JsonConvert.SerializeObject(uploadExamStepList);
|
||
|
||
// 输出上传数据用于调试
|
||
string jsonString = JsonConvert.SerializeObject(uploadExamDto);
|
||
Debug.Log("准备上传的数据: " + jsonString);
|
||
|
||
// 发送网络请求
|
||
string jsonText = await MotionEngine.GetModule<WebRequestManager>().PostTextAsync(
|
||
url: ApiUrls.TransitInventory.AddSubmitDetail,
|
||
jsonData: jsonString, MotionEngine.GetModule<GlobalDataStorage>().ExamInfo.Token
|
||
);
|
||
|
||
// 输出原始JSON数据用于调试
|
||
Debug.Log("服务器返回数据: " + jsonText);
|
||
|
||
// 解析返回结果
|
||
var response = JsonConvert.DeserializeObject<MessageDto>(jsonText);
|
||
Debug.Log(response);
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// // 处理异常
|
||
// Debug.LogError("上传考试数据时发生错误: " + ex.Message);
|
||
// }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 上传指定题目的文件（完全基于配置文件，使用题目名字，统一使用 _downloadedFiles 字典）
|
||
/// </summary>
|
||
/// <param name="examName">题目名字</param>
|
||
private static async UniTask<(string, bool)> UploadExamFilesAsync(string examName)
|
||
{
|
||
string token = MotionEngine.GetModule<GlobalDataStorage>().ExamInfo.Token;
|
||
|
||
try
|
||
{
|
||
Debug.Log($"开始上传题目 '{examName}' 的文件（基于配置文件，统一使用 _downloadedFiles 字典）");
|
||
|
||
// 从配置文件读取该题目的所有文件信息
|
||
var fileInfos = await GetExamFileInfos(examName);
|
||
if (fileInfos.Count == 0)
|
||
{
|
||
Debug.LogWarning($"题目 '{examName}' 在配置文件中没有配置任何文件，跳过上传");
|
||
return (null, true); // 返回 (null, true) 表示没有文件可上传，但操作成功
|
||
}
|
||
|
||
// 获取已下载的文件路径（统一使用 _downloadedFiles 字典）
|
||
var downloadedPaths = GetDownloadedFilePaths(examName);
|
||
|
||
if (downloadedPaths.Count == 0)
|
||
{
|
||
Debug.LogWarning($"题目 '{examName}' 没有已下载的文件，跳过上传（统一使用 _downloadedFiles 字典）");
|
||
return (null, true); // 返回 (null, true) 表示没有文件可上传，但操作成功
|
||
}
|
||
|
||
// 检测文档是否处于打开状态
|
||
var openDocuments = CheckOpenDocuments(downloadedPaths);
|
||
if (openDocuments.Count > 0)
|
||
{
|
||
string openFileNames = string.Join("、", openDocuments.Select(Path.GetFileName));
|
||
string errorMessage = $"以下文档仍处于打开状态，请先关闭后再上传：{openFileNames}";
|
||
Debug.LogError(errorMessage);
|
||
// 返回错误信息和失败状态
|
||
return ("当前有未关闭的文档，请先关闭在提交！", false);
|
||
}
|
||
|
||
Debug.Log($"从配置文件读取到 {fileInfos.Count} 个文件配置，找到 {downloadedPaths.Count} 个已下载的文件，准备上传（统一使用 _downloadedFiles 字典）");
|
||
|
||
// 统一使用压缩包上传，无论文件数量多少
|
||
string zipPath = await CreateZipFileFromPathsAsync(downloadedPaths, examName);
|
||
if (!string.IsNullOrEmpty(zipPath))
|
||
{
|
||
string result = await MotionEngine.GetModule<WebRequestManager>().UploadFileWithFormData(
|
||
ApiUrls.TransitInventory.UploadFileAndParam, zipPath, token);
|
||
Debug.Log($"压缩包上传结果：{result}（包含 {downloadedPaths.Count} 个文件，统一使用 _downloadedFiles 字典）");
|
||
|
||
// 解析上传结果，提取文件URL
|
||
string fileUrl = ParseUploadResult(result);
|
||
Debug.Log($"解析出的文件URL：{fileUrl}");
|
||
|
||
// 上传完成后删除临时ZIP文件
|
||
if (File.Exists(zipPath))
|
||
{
|
||
File.Delete(zipPath);
|
||
Debug.Log($"已删除临时ZIP文件：{zipPath}");
|
||
}
|
||
|
||
return (fileUrl, true); // 返回解析出的文件URL和成功状态
|
||
}
|
||
else
|
||
{
|
||
Debug.LogError("创建ZIP文件失败");
|
||
return ("创建ZIP文件失败", false);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"上传题目 '{examName}' 的文件时发生错误：{ex.Message}");
|
||
return (ex.Message, false);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析上传结果，提取文件URL
|
||
/// </summary>
|
||
/// <param name="uploadResult">上传返回的JSON结果</param>
|
||
/// <returns>文件URL，如果解析失败则返回null</returns>
|
||
private static string ParseUploadResult(string uploadResult)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrEmpty(uploadResult))
|
||
{
|
||
Debug.LogWarning("上传结果为空，无法解析文件URL");
|
||
return null;
|
||
}
|
||
|
||
// 解析JSON结果
|
||
var response = JsonConvert.DeserializeObject<UploadResponse>(uploadResult);
|
||
|
||
if (response?.code == 200 && response?.data?.url != null)
|
||
{
|
||
Debug.Log($"成功解析文件URL：{response.data.url}");
|
||
return response.data.url;
|
||
}
|
||
else
|
||
{
|
||
Debug.LogWarning($"上传失败或返回结果异常：code={response?.code}, msg={response?.msg}");
|
||
return null;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"解析上传结果时发生错误：{ex.Message}");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 上传响应数据结构
|
||
/// </summary>
|
||
[System.Serializable]
|
||
private class UploadResponse
|
||
{
|
||
public int code { get; set; }
|
||
public string msg { get; set; }
|
||
public UploadFileData data { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 上传数据信息
|
||
/// </summary>
|
||
[System.Serializable]
|
||
private class UploadFileData
|
||
{
|
||
public string name { get; set; }
|
||
public string url { get; set; }
|
||
public string id { get; set; }
|
||
public string data { get; set; }
|
||
}
|
||
|
||
// /// <summary>
|
||
// /// 将两个文件压缩成ZIP包
|
||
// /// </summary>
|
||
// /// <param name="filePath1">第一个文件路径</param>
|
||
// /// <param name="filePath2">第二个文件路径</param>
|
||
// /// <returns>ZIP文件路径</returns>
|
||
// private static async UniTask<string> CreateZipFileAsync(string filePath1, string filePath2)
|
||
// {
|
||
// try
|
||
// {
|
||
// // 创建临时ZIP文件路径
|
||
// string zipPath = Path.Combine(Application.temporaryCachePath, $"ExamFiles_{DateTime.Now:yyyyMMdd_HHmmss}.zip");
|
||
//
|
||
// // 确保目录存在
|
||
// Directory.CreateDirectory(Path.GetDirectoryName(zipPath));
|
||
//
|
||
// // 创建ZIP文件
|
||
// if (File.Exists(zipPath))
|
||
// {
|
||
// File.Delete(zipPath);
|
||
// }
|
||
//
|
||
// using (ZipArchive archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
|
||
// {
|
||
// // 添加第一个文件
|
||
// if (File.Exists(filePath1))
|
||
// {
|
||
// string fileName1 = Path.GetFileName(filePath1);
|
||
// archive.CreateEntryFromFile(filePath1, fileName1);
|
||
// }
|
||
//
|
||
// // 添加第二个文件
|
||
// if (File.Exists(filePath2))
|
||
// {
|
||
// string fileName2 = Path.GetFileName(filePath2);
|
||
// archive.CreateEntryFromFile(filePath2, fileName2);
|
||
// }
|
||
// }
|
||
//
|
||
// Debug.Log($"ZIP文件已创建: {zipPath}");
|
||
// return zipPath;
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// Debug.LogError($"创建ZIP文件时发生错误: {ex.Message}");
|
||
// return string.Empty;
|
||
// }
|
||
// }
|
||
|
||
// 移除了ExamQuestionTypes版本的DownloadSingleFileAsync方法
|
||
|
||
/// <summary>
|
||
/// 下载单个文件（使用题目名字）
|
||
/// </summary>
|
||
/// <param name="examName">题目名字</param>
|
||
/// <param name="fileInfo">文件信息</param>
|
||
private static async UniTask DownloadSingleFileAsync(string examName, FileDownloadInfo fileInfo)
|
||
{
|
||
try
|
||
{
|
||
Debug.Log($"开始下载文件：{fileInfo.name}，URL：{fileInfo.url}（来自配置文件）");
|
||
|
||
fileInfo.downloadStatus = DownloadStatus.Downloading;
|
||
|
||
// 下载文件
|
||
var fileData = await MotionEngine.GetModule<WebRequestManager>().GetFileAsync(fileInfo.url);
|
||
|
||
if (fileData == null || fileData.Length == 0)
|
||
{
|
||
fileInfo.downloadStatus = DownloadStatus.Failed;
|
||
fileInfo.errorMessage = "下载的文件数据为空";
|
||
Debug.LogError($"下载文件 '{fileInfo.name}' 失败：文件数据为空");
|
||
return;
|
||
}
|
||
|
||
// 创建保存目录
|
||
string saveDir = Path.Combine(Application.streamingAssetsPath, "Excel", examName);
|
||
Directory.CreateDirectory(saveDir);
|
||
|
||
// 生成文件路径 - 修复时间戳位置，确保在文件名和扩展名之间
|
||
string fileNameWithoutExt = Path.GetFileNameWithoutExtension(fileInfo.fileName);
|
||
string fileExtension = Path.GetExtension(fileInfo.fileName);
|
||
string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
|
||
string fileName = $"{fileNameWithoutExt}_{timestamp}_{MotionEngine.GetModule<GlobalDataStorage>().ExamInfo.StudentId}{fileExtension}";
|
||
fileInfo.localFilePath = Path.Combine(saveDir, fileName);
|
||
|
||
Debug.Log($"生成文件名 - 原始文件名：{fileInfo.fileName}，处理后：{fileName}");
|
||
|
||
// 保存文件
|
||
await File.WriteAllBytesAsync(fileInfo.localFilePath, fileData);
|
||
|
||
fileInfo.isDownloaded = true;
|
||
fileInfo.downloadStatus = DownloadStatus.Completed;
|
||
fileInfo.errorMessage = null;
|
||
|
||
Debug.Log($"文件 '{fileInfo.name}' 下载完成，保存路径：{fileInfo.localFilePath}（基于配置文件）");
|
||
|
||
// 触发文件下载完成事件
|
||
OnFileDownloadCompleted?.Invoke(fileInfo.name, fileInfo.localFilePath);
|
||
|
||
// 检测是否为答题卡文件
|
||
if (IsAnswerSheetFile(fileInfo.name))
|
||
{
|
||
Debug.Log($"检测到答题卡文件：{fileInfo.name}");
|
||
_answerSheetFiles[examName] = fileInfo.localFilePath;
|
||
ShowAnswerSheetButton();
|
||
}
|
||
|
||
// 打开文件
|
||
FileUtils.OpenFile(fileInfo.localFilePath);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
fileInfo.downloadStatus = DownloadStatus.Failed;
|
||
fileInfo.errorMessage = ex.Message;
|
||
Debug.LogError($"下载文件 '{fileInfo.name}' 时发生错误：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
// 移除了ExamQuestionTypes版本的CreateZipFileFromPathsAsync方法
|
||
|
||
/// <summary>
|
||
/// 从文件路径列表创建ZIP文件（使用题目名字）
|
||
/// </summary>
|
||
/// <param name="filePaths">文件路径列表</param>
|
||
/// <param name="examName">题目名字</param>
|
||
/// <returns>ZIP文件路径</returns>
|
||
private static async UniTask<string> CreateZipFileFromPathsAsync(List<string> filePaths, string examName)
|
||
{
|
||
try
|
||
{
|
||
Debug.Log($"开始创建ZIP包，包含 {filePaths.Count} 个文件（基于配置文件）");
|
||
|
||
// 创建临时ZIP文件路径
|
||
string zipPath = Path.Combine(Application.temporaryCachePath, $"{examName}_Files_{DateTime.Now:yyyyMMdd_HHmmss}.zip");
|
||
|
||
// 确保目录存在
|
||
Directory.CreateDirectory(Path.GetDirectoryName(zipPath));
|
||
|
||
// 删除已存在的ZIP文件
|
||
if (File.Exists(zipPath))
|
||
{
|
||
File.Delete(zipPath);
|
||
}
|
||
|
||
using (ZipArchive archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
|
||
{
|
||
int addedCount = 0;
|
||
|
||
// 遍历配置文件中的所有文件路径
|
||
foreach (string filePath in filePaths)
|
||
{
|
||
if (File.Exists(filePath))
|
||
{
|
||
string fileName = Path.GetFileName(filePath);
|
||
archive.CreateEntryFromFile(filePath, fileName);
|
||
addedCount++;
|
||
Debug.Log($"已添加文件到ZIP：{fileName}（来自配置文件）");
|
||
}
|
||
else
|
||
{
|
||
Debug.LogWarning($"文件不存在，跳过：{filePath}（配置文件中的文件）");
|
||
}
|
||
}
|
||
|
||
Debug.Log($"ZIP包创建完成，共添加 {addedCount} 个文件（基于配置文件中的 {filePaths.Count} 个文件）");
|
||
}
|
||
|
||
Debug.Log($"ZIP文件已创建: {zipPath}（基于配置文件）");
|
||
return zipPath;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Debug.LogError($"创建ZIP文件时发生错误: {ex.Message}");
|
||
return string.Empty;
|
||
}
|
||
}
|
||
|
||
// 移除了ExamQuestionTypes版本的GetDownloadedFilePaths方法
|
||
|
||
/// <summary>
|
||
/// 获取指定题目的已下载文件路径列表（使用题目名字，统一使用 _downloadedFiles 字典）
|
||
/// </summary>
|
||
/// <param name="examName">题目名字</param>
|
||
/// <returns>已下载文件的本地路径列表</returns>
|
||
public static List<string> GetDownloadedFilePaths(string examName)
|
||
{
|
||
Debug.Log($"GetDownloadedFilePaths 被调用，题目名字：{examName}");
|
||
|
||
if (_downloadedFiles.ContainsKey(examName))
|
||
{
|
||
// 过滤掉不存在的文件
|
||
var existingFiles = _downloadedFiles[examName].Where(path => File.Exists(path)).ToList();
|
||
_downloadedFiles[examName] = existingFiles;
|
||
Debug.Log($"获取题目 '{examName}' 的已下载文件路径，共 {existingFiles.Count} 个文件");
|
||
return existingFiles;
|
||
}
|
||
|
||
Debug.Log($"题目 '{examName}' 没有已下载的文件记录");
|
||
return new List<string>();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检测指定文件路径列表中哪些文件处于打开状态
|
||
/// </summary>
|
||
/// <param name="filePaths">要检测的文件路径列表</param>
|
||
/// <returns>处于打开状态的文件路径列表</returns>
|
||
private static List<string> CheckOpenDocuments(List<string> filePaths)
|
||
{
|
||
List<string> openDocuments = new List<string>();
|
||
|
||
foreach (string filePath in filePaths)
|
||
{
|
||
if (IsFileOpen(filePath))
|
||
{
|
||
openDocuments.Add(filePath);
|
||
}
|
||
}
|
||
|
||
return openDocuments;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检测当前题目的所有已下载文件是否处于打开状态（外部可调用，无需传值）
|
||
/// </summary>
|
||
/// <returns>处于打开状态的文件路径列表</returns>
|
||
public static List<string> CheckOpenDocuments()
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
var downloadedPaths = GetDownloadedFilePaths(examName);
|
||
return CheckOpenDocuments(downloadedPaths);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检测单个文件是否处于打开状态
|
||
/// </summary>
|
||
/// <param name="filePath">文件路径</param>
|
||
/// <returns>如果文件处于打开状态返回true，否则返回false</returns>
|
||
private static bool IsFileOpen(string filePath)
|
||
{
|
||
try
|
||
{
|
||
// 尝试以独占模式打开文件
|
||
using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
|
||
{
|
||
// 如果能成功打开，说明文件没有被其他进程占用
|
||
return false;
|
||
}
|
||
}
|
||
catch (IOException)
|
||
{
|
||
// 如果抛出IOException，说明文件被其他进程占用（可能是打开状态）
|
||
return true;
|
||
}
|
||
catch (UnauthorizedAccessException)
|
||
{
|
||
// 如果抛出UnauthorizedAccessException，也可能是文件被占用
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 其他异常，记录日志但不认为文件是打开的
|
||
Debug.LogWarning($"检测文件 '{filePath}' 状态时发生异常：{ex.Message}");
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取动作的总题目数量
|
||
/// </summary>
|
||
/// <param name="action">动作对象</param>
|
||
/// <returns>题目总数</returns>
|
||
private static int GetTotalQuestionsCount(ProcessStepDescription action)
|
||
{
|
||
switch (action.ActionType)
|
||
{
|
||
case ProcessActionType.默认:
|
||
return action.TargetObjects.Count;
|
||
case ProcessActionType.判断题:
|
||
return action.JudgmentQuestions?.Count ?? 0;
|
||
case ProcessActionType.多选题:
|
||
return action.MultipleChoiceQuestions?.Count ?? 0;
|
||
default:
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成答案列表
|
||
/// </summary>
|
||
/// <param name="stepIndex">步骤索引</param>
|
||
/// <param name="actionIndex">动作索引</param>
|
||
/// <param name="action">动作对象</param>
|
||
/// <returns>答案列表</returns>
|
||
private static List<StepListDto> GenerateAnswersList(int stepIndex, int actionIndex, ProcessStepDescription action)
|
||
{
|
||
var answers = new List<StepListDto>();
|
||
var processManager = MotionEngine.GetModule<ProcessManager>();
|
||
|
||
switch (action.ActionType)
|
||
{
|
||
case ProcessActionType.判断题:
|
||
if (action.JudgmentQuestions != null)
|
||
{
|
||
for (int i = 0; i < action.JudgmentQuestions.Count; i++)
|
||
{
|
||
var question = action.JudgmentQuestions[i];
|
||
var answerKey = (stepIndex, actionIndex, i);
|
||
|
||
if (processManager._questionAnswers.ContainsKey(answerKey))
|
||
{
|
||
var answerData = processManager._questionAnswers[answerKey];
|
||
Debug.Log($"<color=green>【框架消息】</color>【GenerateAnswersList】从_questionAnswers读取答案：answerKey={answerKey}, 学生答案={answerData.studentAnswer}, 正确答案={answerData.correctAnswer}");
|
||
answers.Add(new StepListDto
|
||
{
|
||
question = answerData.question,
|
||
studentAnswer = answerData.studentAnswer,
|
||
YAnwser = answerData.correctAnswer
|
||
});
|
||
}
|
||
else
|
||
{
|
||
Debug.Log($"<color=green>【框架消息】</color>【GenerateAnswersList】answerKey={answerKey} 不存在于_questionAnswers中，使用默认值");
|
||
// 如果没有记录，使用默认值
|
||
answers.Add(new StepListDto
|
||
{
|
||
question = question.Question,
|
||
studentAnswer = "",
|
||
YAnwser = question.CorrectAnswer
|
||
});
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case ProcessActionType.多选题:
|
||
if (action.MultipleChoiceQuestions != null)
|
||
{
|
||
for (int i = 0; i < action.MultipleChoiceQuestions.Count; i++)
|
||
{
|
||
var question = action.MultipleChoiceQuestions[i];
|
||
var answerKey = (stepIndex, actionIndex, i);
|
||
|
||
if (processManager._questionAnswers.ContainsKey(answerKey))
|
||
{
|
||
var answerData = processManager._questionAnswers[answerKey];
|
||
answers.Add(new StepListDto
|
||
{
|
||
question = answerData.question,
|
||
studentAnswer = answerData.studentAnswer,
|
||
YAnwser = answerData.correctAnswer
|
||
});
|
||
}
|
||
else
|
||
{
|
||
// 如果没有记录，使用默认值
|
||
answers.Add(new StepListDto
|
||
{
|
||
question = question.Question,
|
||
studentAnswer = "",
|
||
YAnwser = string.Join(",", question.CorrectAnswers)
|
||
});
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case ProcessActionType.默认:
|
||
if (action.TargetObjects != null)
|
||
{
|
||
for (int i = 0; i < action.TargetObjects.Count; i++)
|
||
{
|
||
var obj = action.TargetObjects[i];
|
||
var answerKey = (stepIndex, actionIndex, i);
|
||
|
||
if (processManager._questionAnswers.ContainsKey(answerKey))
|
||
{
|
||
var answerData = processManager._questionAnswers[answerKey];
|
||
answers.Add(new StepListDto
|
||
{
|
||
question = answerData.question,
|
||
studentAnswer = answerData.studentAnswer,
|
||
YAnwser = answerData.correctAnswer
|
||
});
|
||
}
|
||
else
|
||
{
|
||
// 如果没有记录，使用默认值
|
||
bool isClicked = action.ClickedObjects.Contains(obj.ObjectName);
|
||
answers.Add(new StepListDto
|
||
{
|
||
question = obj.ObjectName,
|
||
studentAnswer = isClicked ? "true" : "false",
|
||
YAnwser = "true"
|
||
});
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
return answers;
|
||
}
|
||
|
||
// 移除了GetExamTypeFromName方法，不再需要枚举映射
|
||
|
||
// 移除了ExamQuestionTypes版本的GetDownloadStatus方法
|
||
|
||
/// <summary>
|
||
/// 获取当前题目的下载状态信息（使用全局题目名字）
|
||
/// </summary>
|
||
/// <returns>下载状态信息</returns>
|
||
public static async UniTask<DownloadStatusInfo> GetDownloadStatus()
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
await InitializeConfigManager();
|
||
|
||
var config = _configManager.GetConfigByExamType(examName);
|
||
if (config == null)
|
||
{
|
||
return new DownloadStatusInfo
|
||
{
|
||
TotalFiles = 0,
|
||
DownloadedFiles = 0,
|
||
Progress = 1f,
|
||
Status = DownloadStatus.Completed
|
||
};
|
||
}
|
||
|
||
var downloadedCount = config.GetDownloadedFiles().Count;
|
||
var totalCount = config.files.Count;
|
||
var progress = totalCount > 0 ? (float)downloadedCount / totalCount : 1f;
|
||
|
||
var status = progress == 1f ? DownloadStatus.Completed :
|
||
progress > 0f ? DownloadStatus.Downloading :
|
||
DownloadStatus.NotStarted;
|
||
|
||
return new DownloadStatusInfo
|
||
{
|
||
TotalFiles = totalCount,
|
||
DownloadedFiles = downloadedCount,
|
||
Progress = progress,
|
||
Status = status
|
||
};
|
||
}
|
||
|
||
// 移除了所有ExamQuestionTypes版本的状态查询和管理方法
|
||
|
||
/// <summary>
|
||
/// 检测是否为答题卡文件
|
||
/// </summary>
|
||
/// <param name="fileName">文件名</param>
|
||
/// <returns>是否为答题卡文件</returns>
|
||
private static bool IsAnswerSheetFile(string fileName)
|
||
{
|
||
if (string.IsNullOrEmpty(fileName))
|
||
return false;
|
||
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
|
||
// 特殊处理：物料凭证分析基础知识题目的文件都包含答题卡功能
|
||
if (examName == "物料凭证分析基础知识")
|
||
{
|
||
Debug.Log($"FileComponent: 检测到物料凭证分析基础知识题目，文件 '{fileName}' 被视为答题卡文件");
|
||
return true;
|
||
}
|
||
|
||
// 检测文件名中是否包含"答题卡"关键词
|
||
return fileName.Contains("答题卡");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 显示答题卡按钮
|
||
/// </summary>
|
||
private static void ShowAnswerSheetButton()
|
||
{
|
||
if (_answerSheetButton != null)
|
||
{
|
||
_answerSheetButton.gameObject.SetActive(true);
|
||
Debug.Log("FileComponent: 答题卡按钮已显示");
|
||
}
|
||
else
|
||
{
|
||
Debug.LogWarning("FileComponent: 答题卡按钮引用未设置，无法显示按钮");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 隐藏答题卡按钮
|
||
/// </summary>
|
||
public static void HideAnswerSheetButton()
|
||
{
|
||
if (_answerSheetButton != null)
|
||
{
|
||
_answerSheetButton.gameObject.SetActive(false);
|
||
Debug.Log("FileComponent: 答题卡按钮已隐藏");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 答题卡按钮点击处理方法
|
||
/// </summary>
|
||
public static void OnAnswerSheetButtonClick()
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
|
||
if (!_answerSheetFiles.ContainsKey(examName))
|
||
{
|
||
Debug.LogWarning($"FileComponent: 题目 '{examName}' 没有答题卡文件");
|
||
return;
|
||
}
|
||
|
||
string answerSheetPath = _answerSheetFiles[examName];
|
||
|
||
if (string.IsNullOrEmpty(answerSheetPath) || !File.Exists(answerSheetPath))
|
||
{
|
||
Debug.LogError($"FileComponent: 答题卡文件不存在：{answerSheetPath}");
|
||
return;
|
||
}
|
||
|
||
// 检测文件是否已打开
|
||
if (IsFileOpen(answerSheetPath))
|
||
{
|
||
Debug.Log("FileComponent: 答题卡文件已打开，无需重复打开");
|
||
return;
|
||
}
|
||
|
||
// 打开答题卡文件
|
||
bool openResult = FileUtils.OpenFile(answerSheetPath);
|
||
if (openResult)
|
||
{
|
||
Debug.Log($"FileComponent: 成功打开答题卡文件：{answerSheetPath}");
|
||
}
|
||
else
|
||
{
|
||
Debug.LogError($"FileComponent: 打开答题卡文件失败：{answerSheetPath}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取当前题目的答题卡文件路径
|
||
/// </summary>
|
||
/// <returns>答题卡文件路径，如果没有则返回null</returns>
|
||
public static string GetCurrentAnswerSheetPath()
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
return _answerSheetFiles.ContainsKey(examName) ? _answerSheetFiles[examName] : null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 打开指定文件名的已下载文件
|
||
/// </summary>
|
||
/// <param name="fileName">文件名</param>
|
||
public static void OpenDownloadedFile(string fileName)
|
||
{
|
||
string examName = MotionEngine.GetModule<GlobalDataStorage>().ExamName;
|
||
var downloadedPaths = GetDownloadedFilePaths(examName);
|
||
|
||
// 查找包含指定文件名的文件路径
|
||
var targetPath = downloadedPaths.FirstOrDefault(path =>
|
||
Path.GetFileNameWithoutExtension(path).Contains(fileName) ||
|
||
Path.GetFileName(path).Contains(fileName));
|
||
|
||
if (!string.IsNullOrEmpty(targetPath) && File.Exists(targetPath))
|
||
{
|
||
// 检测文件是否已打开
|
||
if (IsFileOpen(targetPath))
|
||
{
|
||
Debug.Log($"文件 '{fileName}' 已打开，无需重复打开");
|
||
return;
|
||
}
|
||
|
||
// 打开文件
|
||
bool openResult = FileUtils.OpenFile(targetPath);
|
||
if (openResult)
|
||
{
|
||
Debug.Log($"成功打开文件：{targetPath}");
|
||
}
|
||
else
|
||
{
|
||
Debug.LogError($"打开文件失败：{targetPath}");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Debug.LogWarning($"未找到已下载的文件：{fileName}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 下载状态信息
|
||
/// </summary>
|
||
public class DownloadStatusInfo
|
||
{
|
||
public int TotalFiles { get; set; }
|
||
public int DownloadedFiles { get; set; }
|
||
public float Progress { get; set; }
|
||
public DownloadStatus Status { get; set; }
|
||
}
|
||
}
|
||
} |