/// <summary>
///
/// </summary>
/// <param name="store"></param>
/// <param name="handler"></param>
public void Issue(LocalStudentWorkStore store,RaiseChangedHandler handler)
{
lock (this)
{
if (store == null || store.Students == null)
{
this.RaiseChanged(handler, "没有作品分发！");
MessageBox.Show("没有作品分发！");
return;
}
else if(this.netService != null && this.panelWork != null && this.panelWork.Controls != null)
{
bool flag = false;
for (int i = 0; i < this.panelWork.Controls.Count; i++)
{
StudentControl sc = this.panelWork.Controls[i] as StudentControl;
if (sc != null && sc.UserInfo != null && ((sc.State & StudentControl.EnumStudentState.Online) == StudentControl.EnumStudentState.Online))
{
flag = true;
this.IssueWorkData(store,store.Students[sc.UserInfo.UserID], handler);
}
}
if (!flag)
{
string msg = "没有在线学生可分发作品数据！";
this.RaiseChanged(handler, msg);
MessageBox.Show(msg);
}
}
}
}
/// <summary>
/// 导入。
/// </summary>
/// <param name="stream"></param>
/// <param name="teacherId"></param>
/// <param name="handler"></param>
public void Import(WorkExportImportManifest mainfest,RaiseChangedHandler handler)
{
if (!string.IsNullOrEmpty(this.teacherID) && !string.IsNullOrEmpty(this.teacherName) &&
mainfest != null && mainfest.Storages != null && mainfest.Storages.Count > 0)
{
for (int i = 0; i < mainfest.Storages.Count; i++)
{
this.ImportWorkData(mainfest.Storages[i], handler);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="store"></param>
/// <param name="students"></param>
/// <param name="dir"></param>
/// <param name="zipFile"></param>
/// <param name="handler"></param>
private void ImportWorkFiles(LocalStudentWorkStore store, LocalStudents students, string dir, ZipFile zipFile, RaiseChangedHandler handler)
{
if (store != null && students != null && students.Count > 0 && zipFile != null)
{
foreach (LocalStudent ls in students)
{
if (ls.HasWork())
{
LocalStudentWork lsw = ls.Work;
if (lsw.WorkFiles != null && lsw.WorkFiles.Count > 0)
{
string zipDir = string.Format("{0}{1}{2}{1}", dir, Path.DirectorySeparatorChar, ls.StudentID);
this.RaiseChanged(handler, string.Format("导入[{0},{1}]作品数据...", ls.StudentName, ls.StudentCode));
foreach (LocalStudentWorkFile lswf in lsw.WorkFiles)
{
string sPath = string.Format("{0}{1}{2}", zipDir, lswf.FileID, lswf.FileExt);
try
{
using (Stream stream = ZipUtils.ZipFileData(zipFile, sPath))
{
if (stream != null)
{
this.RaiseChanged(handler, string.Format("导入作品{0}{1}...", lswf.FileName, lswf.FileExt));
using (FileStream fs = new FileStream(lsw.StudentWorkFilePath(store, ls, lswf), FileMode.Create, FileAccess.Write))
{
byte[] buf = new byte[512];
int len = 0;
while ((len = stream.Read(buf, 0, buf.Length)) > 0)
{
fs.Write(buf, 0, len);
}
}
}
}
}
catch (Exception x)
{
Exception t = new Exception(string.Format("[{0},{1}]{2}{3}:{4}", ls.StudentName, ls.StudentCode, lswf.FileName, lswf.FileExt, sPath), x);
UtilTools.OnExceptionRecord(t, typeof(ImportWorkUtils));
}
}
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="mainfest"></param>
/// <param name="zipFile"></param>
/// <param name="isImportFile"></param>
private void ImportWorkData(ExportImportManifest mainfest, ZipFile zipFile, bool isImportFile, RaiseChangedHandler handler)
{
if (mainfest != null && mainfest.ClassID_CatalogID != null && mainfest.ClassID_CatalogID.Length > 0 && zipFile != null)
{
for (int i = 0; i < mainfest.ClassID_CatalogID.Length; i++)
{
if (!string.IsNullOrEmpty(mainfest.ClassID_CatalogID[i]))
{
string[] arr = mainfest.ClassID_CatalogID[i].Split('_');
if (arr != null && arr.Length > 1)
{
this.ImportWorkData(mainfest.ClassID_CatalogID[i], arr[0], arr[1], zipFile, isImportFile, handler);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dir"></param>
/// <param name="classID"></param>
/// <param name="catalogID"></param>
/// <param name="zipFile"></param>
/// <param name="isImportFile"></param>
/// <param name="handler"></param>
private void ImportWorkData(string dir, string classID, string catalogID, ZipFile zipFile, bool isImportFile, RaiseChangedHandler handler)
{
string filename = string.Format("{0}{1}TSW_{2}_{3}.cfg.xml", dir, Path.DirectorySeparatorChar,classID, catalogID);
using (Stream stream = ZipUtils.ZipFileData(zipFile, filename))
{
LocalStudentWorkStore importStore = UtilTools.DeSerializer<LocalStudentWorkStore>(stream);
if (importStore != null && (importStore.Students != null) && (importStore.Students.Count > 0) && !string.IsNullOrEmpty(this.teacherID))
{
LocalStudentWorkStore localStore = LocalStudentWorkStore.DeSerializer(this.teacherID, catalogID, classID);
if (localStore != null)
{
#region 更新学生作品信息数据。
this.RaiseChanged(handler, string.Format("导入[{0},{1}]", importStore.ClassName, importStore.CatalogName));
if (localStore.Students == null)
{
localStore.Students = new LocalStudents();
}
foreach (LocalStudent ls in importStore.Students)
{
LocalStudent student = localStore.Students[ls.StudentID];
if (student == null)
{
localStore.Students.Add(ls);
}
else
{
student = ls;
}
}
#endregion
this.RaiseChanged(handler, string.Format("更新[{0},{1}]记录文件...", localStore.ClassName, localStore.CatalogName));
//更新记录文件。
this.CorrectWorkFileSuffix(localStore);
WorkStoreHelper.Serializer(ref localStore);
//localStore.Serializer();
//导入学生作品数据。
if (isImportFile)
{
this.RaiseChanged(handler, string.Format("开始导入[{0},{1}]学生作品数据...", localStore.ClassName, localStore.CatalogName));
this.ImportWorkFiles(localStore, importStore.Students, dir, zipFile, handler);
}
}
else
{
this.RaiseChanged(handler, string.Format("更新[{0},{1}]记录文件...", importStore.ClassName, importStore.CatalogName));
this.CorrectWorkFileSuffix(importStore);
WorkStoreHelper.Serializer(ref importStore);
//importStore.Serializer();
//导入作品数据。
this.RaiseChanged(handler, string.Format("开始导入[{0},{1}]学生作品数据...", importStore.ClassName, importStore.CatalogName));
this.ImportWorkFiles(importStore, importStore.Students, dir, zipFile, handler);
}
}
}
}
/// <summary>
/// 导出数据。
/// </summary>
/// <param name="outputFilePath"></param>
/// <param name="handler"></param>
public void Export(string outputFilePath, RaiseChangedHandler handler)
{
lock (this)
{
if (nodes != null && nodes.Count > 0 && !string.IsNullOrEmpty(outputFilePath))
{
this.RaiseChanged(handler, "开始检索数据...");
Stack<NodeValue> stack = null;
Dictionary<String, List<String>> dict = new Dictionary<string, List<string>>();
foreach (TreeNode n in nodes)
{
stack = new Stack<NodeValue>();
this.GetAllNodeValue(n, stack);
if (stack.Count > 0)
{
this.SetOutputData(stack.ToArray(), ref dict);
}
}
ExportImportManifest mainfset = new ExportImportManifest("2.0");
mainfset.TeacherID = this.teacherID;
List<String> list_ClassID_CatalogID = new List<string>();
List<LocalStudentWorkStore> listStore = new List<LocalStudentWorkStore>();
if (dict != null && dict.Count > 0)
{
#region 检索存储文件。
this.RaiseChanged(handler, "开始加载检索文件...");
foreach (string key in dict.Keys)
{
string[] arr = key.Split('_');
if (arr != null && arr.Length > 1)
{
LocalStudentWorkStore store = LocalStudentWorkStore.DeSerializer(this.teacherID, arr[1], arr[0]);
if (store != null && store.Students != null)
{
list_ClassID_CatalogID.Add(key);
List<String> list = dict[key];
if (list != null && list.Count > 0 && (list.Count != store.Students.Count))
{
List<LocalStudent> removeStudents = new List<LocalStudent>();
foreach (LocalStudent ls in store.Students)
{
if (!list.Contains(ls.StudentID))
{
removeStudents.Add(ls);
}
}
if (removeStudents.Count > 0)
{
store.Students.Remove(removeStudents.ToArray());
}
}
listStore.Add(store);
}
}
}
#endregion
}
if (listStore.Count > 0)
{
mainfset.ClassID_CatalogID = list_ClassID_CatalogID.ToArray();
this.RaiseChanged(handler, "创建导出清单文件...");
outputFilePath = outputFilePath.Replace(Path.GetExtension(outputFilePath), ".zip");
using (FileStream outputStream = new FileStream(outputFilePath, FileMode.Create, FileAccess.Write))
{
this.RaiseChanged(handler, "创建压缩文件...");
Crc32 crc = new Crc32();
using (ZipOutputStream zipStream = new ZipOutputStream(outputStream))
{
zipStream.SetLevel(9);
byte[] data = UtilTools.Serializer<ExportImportManifest>(mainfset);
if (data != null)
{
this.RaiseChanged(handler, "压缩导出清单文件...");
ZipEntry entry = new ZipEntry("ExportImportManifest.xml");
entry.DateTime = DateTime.Now;
entry.Size = data.Length;
crc.Reset();
crc.Update(data);
entry.Crc = crc.Value;
zipStream.PutNextEntry(entry);
zipStream.Write(data, 0, data.Length);
zipStream.CloseEntry();
}
this.RaiseChanged(handler, "开始抽取压缩作品数据...");
this.BuildZipFile(zipStream,crc, listStore, handler);
this.RaiseChanged(handler, "压缩作品数据完成");
}
}
this.RaiseChanged(handler, "作品数据导出完成");
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="zipStream"></param>
/// <param name="crc"></param>
/// <param name="listStore"></param>
/// <param name="handler"></param>
private void BuildZipFile(ZipOutputStream zipStream,Crc32 crc, List<LocalStudentWorkStore> listStore, RaiseChangedHandler handler)
{
foreach (LocalStudentWorkStore store in listStore)
{
string root = string.Format("{0}_{1}", store.ClassID, store.CatalogID);
byte[] data = UtilTools.Serializer<LocalStudentWorkStore>(store);
if (data != null && data.Length > 0)
{
this.RaiseChanged(handler, string.Format("开始压缩[{0},{1}]...", store.ClassName, store.CatalogName));
this.BuildZipData(zipStream, crc, data, string.Format("{0}{1}TSW_{2}_{3}.cfg.xml", root, Path.DirectorySeparatorChar,store.ClassID, store.CatalogID));
if (store.Students != null && store.Students.Count > 0)
{
this.RaiseChanged(handler, "开始压缩学生作品...");
foreach (LocalStudent ls in store.Students)
{
string dir = string.Format("{0}{1}{2}{1}", root, Path.DirectorySeparatorChar,ls.StudentID);
if (ls.HasWork())
{
LocalStudentWork lsw = ls.Work;
if (lsw.WorkFiles != null && lsw.WorkFiles.Count > 0)
{
foreach (LocalStudentWorkFile f in lsw.WorkFiles)
{
string path = lsw.StudentWorkFilePath(store, ls, f);
if (File.Exists(path))
{
this.RaiseChanged(handler, string.Format("开始压缩学生作品[{0},{1}{2}]...", ls.StudentName, f.FileName, f.FileExt));
using (MemoryStream ms = new MemoryStream())
{
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
int len = 0;
byte[] buf = new byte[512];
while ((len = fs.Read(buf, 0, buf.Length)) > 0)
{
ms.Write(buf, 0, len);
}
}
this.BuildZipData(zipStream, crc, ms.ToArray(), string.Format("{0}{1}{2}", dir, f.FileID, f.FileExt));
}
}
}
}
}
}
this.RaiseChanged(handler, "压缩学生作品完成");
}
}
}
}
/// <summary>
/// 创建静态实例。
/// </summary>
/// <param name="service"></param>
/// <param name="Changed"></param>
/// <returns></returns>
public static TeaClientServicePoxyFactory Instance(ICoreService service, RaiseChangedHandler changed)
{
lock (typeof(TeaClientServicePoxyFactory))
{
Credentials cert = service["credentials"] as Credentials;
if (cert == null)
{
throw new Exception("容器中密钥丢失！请关闭系统后重新登录！");
}
TeaClientServicePoxyFactory factory = PoxyCache[cert] as TeaClientServicePoxyFactory;
if (factory == null)
{
factory = new TeaClientServicePoxyFactory(cert);
PoxyCache[cert] = factory;
}
factory.Changed = changed;
return factory;
}
}
/// <summary>
/// 导出学生作品文件。
/// </summary>
/// <param name="studentID">学生ID。</param>
/// <param name="target">目标目录。</param>
/// <param name="changed"></param>
/// <returns>导出作品目录。</returns>
public string OutputWorkFile(string studentID, string target, RaiseChangedHandler changed)
{
lock (this)
{
if (!string.IsNullOrEmpty(studentID) && !string.IsNullOrEmpty(target))
{
string targetDir = Path.GetFullPath(string.Format("{0}/{1}/{2}/{3}", target, this.TeacherName, this.CatalogName, this.ClassName));
if (!Directory.Exists(targetDir))
{
this.OnChanged(changed, "创建目录：" + targetDir);
Directory.CreateDirectory(targetDir);
}
if (this.Students != null && this.Students.Count > 0)
{
LocalStudent ls = this.Students[studentID];
if (ls != null && ls.HasWork())
{
#region 创建导出目录。
string targetRoot = Path.GetFullPath(string.Format("{0}/{1}", targetDir, ls.StudentName));
if (!Directory.Exists(targetRoot))
{
Directory.CreateDirectory(targetRoot);
this.OnChanged(changed, "创建目录：" + ls.StudentName);
}
else
{
try
{
//删除目录下的文件。
string[] files = Directory.GetFiles(targetRoot, "*.*");
if (files != null && files.Length > 0)
{
for (int k = 0; k < files.Length; k++)
{
if (File.Exists(files[k]))
{
File.Delete(files[k]);
}
}
}
}
catch (Exception) { }
}
#endregion
#region 作业。
int fcount = 0;
if (ls.Work.WorkFiles != null && (fcount = ls.Work.WorkFiles.Count) > 0)
{
for(int i = 0; i < fcount; i++)
{
#region 作业数据。
LocalStudentWorkFile f = ls.Work.WorkFiles[i];
string sourcePath = ls.Work.StudentWorkFilePath(this, ls, f);
if (File.Exists(sourcePath))
{
try
{
string targetPath = Path.GetFullPath(string.Format("{0}/{1}{2}", targetRoot, f.FileName, f.FileExt));
using (FileStream source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read))
{
using (FileStream output = new FileStream(targetPath, FileMode.Create, FileAccess.Write))
{
this.OnChanged(changed, "开始创建文件：" + f.FileName);
byte[] buf = new byte[512];
int len = 0;
while ((len = source.Read(buf, 0, buf.Length)) > 0)
{
output.Write(buf, 0, len);
}
this.OnChanged(changed, "创建文件：" + f.FileName + "完成");
}
}
}
catch (Exception x)
{
this.OnChanged(changed, "创建文件[" + f.FileName + "]时发生异常：" + x.Message);
Program.GlobalExceptionHandler(x);
}
}
#endregion
}
}
#endregion
return targetRoot;
}
}
}
return null;
}
}
///// <summary>
///// 清理冗余作品。
///// </summary>
///// <param name="changed"></param>
//public bool ClearWorks(RaiseChangedHandler changed)
//{
// lock (this)
// {
// bool result = false;
// try
// {
// if (this.Students != null && this.Students.Count > 0)
// {
// Hashtable htCache = Hashtable.Synchronized(new Hashtable());
// for (int i = 0; i < this.Students.Count; i++)
// {
// LocalStudent ls = this.Students[i];
// if (ls != null && ls.Works != null && ls.Works.Count > 0)
// {
// #region 剔除重复学生。
// if (htCache.ContainsKey(ls.StudentID))
// {
// result = true;
// LocalStudent old = ((object[])htCache[ls.StudentID])[0] as LocalStudent;
// if (old.Works != null && old.Works.Count > 0)
// {
// if (ls.Works != null && ls.Works.Count > 0)
// {
// if (ls.Works[0].Time < old.Works[0].Time)
// {
// this.OnChanged(changed, string.Format("清理{0}的冗余作品", ls.StudentName));
// this.Students.Remove(i);
// continue;
// }
// else
// {
// this.OnChanged(changed, string.Format("清理{0}的冗余作品", old.StudentName));
// this.Students.Remove((int)(((object[])htCache[ls.StudentID])[1]));
// }
// }
// else
// {
// this.OnChanged(changed, string.Format("清理{0}的冗余作品", ls.StudentName));
// this.Students.Remove(i);
// continue;
// }
// }
// else
// {
// this.OnChanged(changed, string.Format("清理{0}的冗余作品", old.StudentName));
// this.Students.Remove((int)(((object[])htCache[ls.StudentID])[1]));
// }
// }
// #endregion
// #region 剔除冗余作业。
// if (ls.Works != null && ls.Works.Count > 1)
// {
// ls.Works.Sort();
// LocalStudentWork lsw = ls.Works[0];
// if (lsw != null)
// {
// this.OnChanged(changed, string.Format("清理{0}的冗余作品,保留作品:{1}", ls.StudentName, lsw.WorkName));
// ls.Works = new LocalStudentWorks();
// ls.Works.Add(lsw);
// result = true;
// }
// }
// #endregion
// //缓存数据。
// htCache[ls.StudentID] = new object[] { ls, i };
// }
// }
// }
// if (result)
// {
// this.Serializer();
// }
// this.OnChanged(changed, "清理完毕！");
// }
// catch (Exception x)
// {
// this.OnChanged(changed, string.Format("清理发生异常：{0}", x.Message));
// }
// return result;
// }
//}
/// <summary>
/// 消息处理。
/// </summary>
/// <param name="changed"></param>
/// <param name="message"></param>
private void OnChanged(RaiseChangedHandler changed, string message)
{
if (changed != null)
{
changed(message);
}
}
/// <summary>
/// 导出所有学生作品数据。
/// </summary>
/// <param name="target">目标目录。</param>
/// <param name="Changed">消息处理。</param>
public void OutputAllWorkFiles(string target, RaiseChangedHandler changed)
{
lock (this)
{
int len = 0;
if (this.Students != null && (len = this.Students.Count) > 0)
{
for(int i = 0; i < len; i++)
{
LocalStudent ls = this.Students[i];
this.OutputWorkFile(ls.StudentID, target, changed);
}
}
}
}
/// <summary>
/// 更新程序。
/// </summary>
/// <param name="handler">消息委托。</param>
/// <returns></returns>
public bool Updates(RaiseChangedHandler handler)
{
handler("开始下载更新，请稍后...");
string path = string.Format("{0}/Update_{1:yyyyMMddHHmmss}.zip", Application.StartupPath, DateTime.Now);
if (this.Download(path))
{
handler("下载完毕，准备更新...");
List<string> kills = new List<string>();
#region 关闭宿主程序。
handler("关闭宿主程序...");
string[] runs = Directory.GetFiles(Application.StartupPath, "*.exe");
string current = Path.GetFileNameWithoutExtension(Application.ExecutablePath);
for (int i = 0; i < runs.Length; i++)
{
if (runs[i].ToLower().IndexOf(current.ToLower()) == -1)
{
string pn = Path.GetFileNameWithoutExtension(runs[i]);
Process[] pros = Process.GetProcessesByName(pn);
if (pros != null && pros.Length > 0)
{
foreach (Process p in pros)
{
if (!p.HasExited)
{
try
{
p.Kill();
if (runs[i].ToLower().IndexOf(".vshosts.") == -1)
{
kills.Add(runs[i]);
}
Thread.Sleep(500);
}
catch (Exception e)
{
logger.Error("关闭宿主程序[" + p + "]发生异常：" + e.Message);
continue;
}
}
}
}
}
}
#endregion
#region 解压更新。
handler("解压更新中，请稍后...");
string dir = Application.StartupPath;
ZipTools.UnZip(path, new UnZipStreamHanlder(delegate(string filename, Stream stream)
{
try
{
if (!string.IsNullOrEmpty(filename) && stream != null)
{
handler("update:" + Path.GetFileNameWithoutExtension(filename));
string fp = Path.GetFullPath(string.Format("{0}/{1}", dir, filename));
using (FileStream fs = new FileStream(fp, FileMode.Create, FileAccess.Write))
{
int len = 0;
byte[] buf = new byte[1024];
while ((len = stream.Read(buf, 0, buf.Length)) > 0)
{
fs.Write(buf, 0, len);
}
}
}
}
catch (Exception e)
{
string err = string.Format("更新文件[{0}]发生异常:{1}", filename, e.Message);
logger.Error(err);
handler(err);
}
}));
#endregion
handler("更新完成，启动宿主程序...");
this.UpdateSuccess();
#region 启动宿主程序。
if (kills.Count > 0)
{
foreach (string s in kills)
{
if (File.Exists(s))
{
try
{
Process.Start(s);
}
catch (Exception e)
{
logger.Error("启动宿主程序[" + s + "]发生异常：" + e.Message);
continue;
}
}
}
}
#endregion
return true;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="storage"></param>
/// <param name="handler"></param>
private void ImportWorkData(StudentWorkTeaStorage storage,RaiseChangedHandler handler)
{
lock (this)
{
if (string.IsNullOrEmpty(this.teacherID) || string.IsNullOrEmpty(this.teacherName))
{
return;
}
if (this.zipFile != null && storage != null && !string.IsNullOrEmpty(storage.CatalogID) && !string.IsNullOrEmpty(storage.ClassID) &&
(storage.Student != null) && !string.IsNullOrEmpty(storage.Student.StudentID))
{
LocalStudentWorkStore store = LocalStudentWorkStore.DeSerializer(this.teacherID, storage.CatalogID, storage.ClassID);
#region 初始化数据。
if (store == null)
{
store = new LocalStudentWorkStore();
store.TeacherID = this.teacherID;
store.TeacherName = this.teacherName;
store.GradeID = storage.GradeID;
store.GradeName = null;
store.CatalogID = storage.CatalogID;
store.CatalogName = storage.CatalogName;
store.ClassID = storage.ClassID;
store.ClassName = null;
store.Evaluate = null;
}
#endregion
if (store.Students == null)
{
store.Students = new LocalStudents();
}
LocalStudent ls = store.Students[storage.Student.StudentID];
if (ls == null)
{
ls = new LocalStudent();
ls.StudentID = storage.Student.StudentID;
ls.StudentCode = storage.Student.StudentCode;
ls.StudentName = storage.Student.StudentName;
store.Students.Add(ls);
}
if (ls.Work == null) ls.Work = new LocalStudentWork();
ls.Work.WorkID = storage.WorkID;
ls.Work.WorkName = storage.WorkName;
ls.Work.UploadIP = storage.UploadIP;
ls.Work.Type = storage.Type;
ls.Work.Time = storage.Time;
ls.Work.Status = storage.Status;
if (storage.Review != null)
{
ls.Work.Review = new LocalWorkReview();
ls.Work.Review.ReviewValue = storage.Review.ReviewValue;
ls.Work.Review.SubjectiveReviews = storage.Review.SubjectiveReviews;
ls.Work.Review.TeacherID = storage.Review.TeacherID;
ls.Work.Review.TeacherName = storage.Review.TeacherName;
}
ls.Work.FileExt = storage.FileExt;
ls.Work.Description = storage.Description;
//ls.Work.CheckCode = storage.CheckCode;
this.RaiseChanged(handler, string.Format("导入[{0},{1}]作品数据...", ls.StudentName, ls.StudentCode));
if (this.isImportFile && !string.IsNullOrEmpty(storage.WorkPath))
{
//导入文件。
ls.Work.WorkFiles = new LocalStudentWorkFiles();
this.ImportWorkFiles(storage.WorkPath, store, ls, ls.Work, handler);
}
//序列化保存。
WorkStoreHelper.Serializer(ref store);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="handler"></param>
/// <param name="message"></param>
private void RaiseChanged(RaiseChangedHandler handler, string message)
{
if (handler != null)
{
handler(message);
}
}
/// <summary>
///
/// </summary>
/// <param name="store"></param>
/// <param name="ls"></param>
/// <param name="handler"></param>
private void IssueWorkData(LocalStudentWorkStore store,LocalStudent ls, RaiseChangedHandler handler)
{
lock (this)
{
if (store != null && ls != null && ls.HasWork())
{
LocalStudentWork lsw = ls.Work;
int len = 0;
if (lsw.WorkFiles != null && (len = lsw.WorkFiles.Count) > 0)
{
this.RaiseChanged(handler, string.Format("下发[{0},{1}]作品数据{2}", ls.StudentName, ls.StudentCode, lsw.WorkName));
string[] filePaths = new string[len];
for (int i = 0; i < len; i++)
{
filePaths[i] = lsw.StudentWorkFilePath(store, ls, lsw.WorkFiles[i]);
}
byte[] data = ZipUtils.Zip(filePaths);
if (data != null && data.Length > 0)
{
IssueWorkFile issue = new IssueWorkFile();
issue.StudentID = ls.StudentID;
issue.WorkName = lsw.WorkName;
issue.UID = store.TeacherID;
issue.Time = DateTime.Now;
issue.Data = data;
this.netService.SendIssueWork(issue);
}
else
{
this.RaiseChanged(handler, string.Format("压缩数据文件失败！[{0},{1}]", ls.StudentName, lsw.WorkName));
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="filepath"></param>
/// <param name="isImportFile"></param>
/// <param name="handler"></param>
public void Import(string filepath, bool isImportFile, RaiseChangedHandler handler)
{
if (!string.IsNullOrEmpty(filepath) && File.Exists(filepath))
{
this.RaiseChanged(handler, "读取文件...");
if (!string.Equals(Path.GetExtension(filepath), ".zip", StringComparison.InvariantCultureIgnoreCase))
{
this.RaiseChanged(handler, "文件后缀非zip格式！");
return;
}
try
{
using (FileStream inputStream = new FileStream(filepath, FileMode.Open, FileAccess.Read))
{
this.RaiseChanged(handler, "校验文件格式...");
using (ZipFile zipFile = new ZipFile(inputStream))
{
using (Stream stream = ZipUtils.ZipFileData(zipFile, "ExportImportManifest.xml"))
{
if (stream == null)
{
this.RaiseChanged(handler, "该压缩文件不是学生作品数据文件！");
return;
}
else
{
using (MemoryStream ms = new MemoryStream())
{
int len = 0;
byte[] buf = new byte[512];
while ((len = stream.Read(buf, 0, buf.Length)) > 0)
{
ms.Write(buf, 0, len);
}
ms.Position = 0;
XmlDocument docfest = new XmlDocument();
docfest.Load(ms);
ms.Position = 0;
XmlElement ver = docfest.SelectSingleNode("//Ver") as XmlElement;
if (ver != null && !string.IsNullOrEmpty(ver.InnerText))
{
float fVer = 0;
if (float.TryParse(ver.InnerText, out fVer))
{
if (fVer == 1.0)
{
#region 旧版本。
WorkExportImportManifest mainfest = UtilTools.DeSerializer<WorkExportImportManifest>(ms);
if (mainfest == null)
{
this.RaiseChanged(handler, "该学生作品数据文件版本不能被解析！");
return;
}
else
{
ImportOldVersionWorkUtils oldImport = new ImportOldVersionWorkUtils(this.teacherID, this.teacherName, zipFile, isImportFile);
oldImport.Import(mainfest, handler);
this.RaiseChanged(handler, "学生作品数据导入完成！");
}
#endregion
}
else if (fVer == 2.0)
{
#region 新版本。
ExportImportManifest mainfest = UtilTools.DeSerializer<ExportImportManifest>(ms);
if (mainfest == null)
{
this.RaiseChanged(handler, "该学生作品数据文件版本不能被解析！");
return;
}
else if (!string.IsNullOrEmpty(mainfest.TeacherID) &&
string.Equals(mainfest.TeacherID, this.teacherID, StringComparison.InvariantCultureIgnoreCase))
{
this.RaiseChanged(handler, "开始导入学生作品数据信息...");
this.ImportWorkData(mainfest, zipFile, isImportFile, handler);
this.RaiseChanged(handler, "学生作品数据信息导入完成");
}
else
{
this.RaiseChanged(handler, "该学生作品数据文件不属于当前教师用户，不能导入！");
return;
}
#endregion
}
else
{
this.RaiseChanged(handler, string.Format("该学生作品数据文件版本号[{0}]不能被解析！", ver.InnerText));
return;
}
}
else
{
this.RaiseChanged(handler, string.Format("该学生作品数据文件版本号[{0}]格式不正确，不能被解析！", ver.InnerText));
return;
}
}
else
{
this.RaiseChanged(handler, "该学生作品数据文件版本不能被解析！");
return;
}
}
}
}
}
}
}
catch (Exception x)
{
this.RaiseChanged(handler, x.Message);
MessageBox.Show("发生异常：" + x.Message);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="zipWorkPath"></param>
/// <param name="store"></param>
/// <param name="ls"></param>
/// <param name="lsw"></param>
/// <param name="handler"></param>
private void ImportWorkFiles(string zipWorkPath, LocalStudentWorkStore store, LocalStudent ls, LocalStudentWork lsw, RaiseChangedHandler handler)
{
if (this.zipFile != null && !string.IsNullOrEmpty(zipWorkPath))
{
Stream stream = stream = ZipUtils.ZipFileData(this.zipFile, zipWorkPath);
if (stream != null)
{
if (string.Equals(Path.GetExtension(zipWorkPath), ".zip", StringComparison.InvariantCultureIgnoreCase))
{
#region 压缩文件解压。
using (ZipInputStream zipStream = new ZipInputStream(stream))
{
if (zipStream == null)
{
return;
}
ZipEntry entry = null;
while ((entry = zipStream.GetNextEntry()) != null)
{
if (entry != null && entry.IsFile && !string.IsNullOrEmpty(entry.Name))
{
LocalStudentWorkFile lswf = new LocalStudentWorkFile();
lswf.FileID = string.Format("{0}", Guid.NewGuid()).Replace("-", string.Empty);
lswf.FileExt = Path.GetExtension(entry.Name);
lswf.FileName = Path.GetFileNameWithoutExtension(entry.Name);
if (string.IsNullOrEmpty(lsw.FileExt))
{
lsw.FileExt = lswf.FileExt;
}
else if (lsw.FileExt.IndexOf(lswf.FileExt) == -1)
{
lsw.FileExt += "|" + lswf.FileExt;
}
lswf.Size = entry.Size;
lsw.WorkFiles.Add(lswf);
this.RaiseChanged(handler, string.Format("导入作品{0}{1}...", lswf.FileName, lswf.FileExt));
using (FileStream fs = new FileStream(lsw.StudentWorkFilePath(store, ls, lswf), FileMode.Create, FileAccess.Write))
{
byte[] buf = new byte[512];
int len = 0;
while ((len = zipStream.Read(buf, 0, buf.Length)) > 0)
{
fs.Write(buf, 0, len);
}
}
}
}
}
#endregion
}
else
{
#region 导入单独文件。
LocalStudentWorkFile lswf = new LocalStudentWorkFile();
lswf.FileID = string.Format("{0}", Guid.NewGuid()).Replace("-", string.Empty);
lswf.FileName = lsw.WorkName;
lswf.FileExt = Path.GetExtension(zipWorkPath);
if (string.IsNullOrEmpty(lsw.FileExt))
{
lsw.FileExt = lswf.FileExt;
}
else if (lsw.FileExt.IndexOf(lswf.FileExt) == -1)
{
lsw.FileExt += "|" + lswf.FileExt;
}
lswf.Size = stream.Length;
lsw.WorkFiles.Add(lswf);
this.RaiseChanged(handler, string.Format("导入作品{0}{1}...", lswf.FileName, lswf.FileExt));
using (FileStream fs = new FileStream(lsw.StudentWorkFilePath(store, ls, lswf), FileMode.Create, FileAccess.Write))
{
byte[] buf = new byte[512];
StreamUtils.Copy(stream, fs, buf);
}
#endregion
}
}
}
}
