624 lines
28 KiB
C#
624 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Ease.Core.DataAccess;
|
|
using Ease.Core.Model;
|
|
using Ease.Core.Utility;
|
|
using HRM.BO;
|
|
using Microsoft.AspNetCore.Hosting;
|
|
using SkiaSharp;
|
|
|
|
namespace HRM.DA
|
|
{
|
|
/// <summary>
|
|
/// Employee Profile Picture Bulk Upload. The pictures are copied into
|
|
/// EmployeePhotoBulkUploadRules.FolderName on the server, each named by its Employee No.
|
|
///
|
|
/// Each picture is stored the way an approved profile-picture request stores it
|
|
/// (EssController.ApproveRequest): the original into empFileupload through HREmployeeDA.uplaodFile
|
|
/// (which deletes the employee's previous picture first) with the profile percentage recalculated,
|
|
/// and the 100px thumbnail written by EmployeePhotoService.GenerateThumbnail into
|
|
/// EmployeePhotos\EmpthumbnailsImage, which is what every screen shows.
|
|
///
|
|
/// Saving is all or nothing for the whole folder: every picture goes into the database in ONE
|
|
/// transaction, and the thumbnails are written before it commits with the old ones kept aside,
|
|
/// so a failure anywhere rolls the database back and puts every old thumbnail back.
|
|
/// </summary>
|
|
public class EmployeePhotoBulkUploadService : IEmployeePhotoBulkUploadService
|
|
{
|
|
/// <summary>Files Windows, macOS and Office leave in a folder by themselves; not pictures, not reported.</summary>
|
|
private static readonly string[] SystemFiles = { "thumbs.db", "desktop.ini", ".ds_store" };
|
|
|
|
private readonly IWebHostEnvironment _env;
|
|
private readonly string _folder;
|
|
private readonly string _displayFolder;
|
|
|
|
public EmployeePhotoBulkUploadService(IWebHostEnvironment env)
|
|
{
|
|
_env = env;
|
|
_folder = Path.Combine(env.ContentRootPath, EmployeePhotoBulkUploadRules.FolderName);
|
|
// What the screen shows: only the application's own folder and this one under it
|
|
// (e.g. HRM.UI\EmployeePhotoBulkUpload), never the full path of the server's disk.
|
|
_displayFolder = Path.Combine(new DirectoryInfo(env.ContentRootPath).Name, EmployeePhotoBulkUploadRules.FolderName);
|
|
}
|
|
|
|
public EmployeePhotoBulkUploadInfo GetInfo()
|
|
{
|
|
EnsureFolder();
|
|
return new EmployeePhotoBulkUploadInfo
|
|
{
|
|
FolderPath = _displayFolder,
|
|
Extensions = EmployeePhotoBulkUploadRules.Extensions.ToList(),
|
|
MaxFileSizeMB = EmployeePhotoBulkUploadRules.MaxFileSizeMB,
|
|
MinSidePixels = EmployeePhotoBulkUploadRules.MinSidePixels,
|
|
FileCount = ListFiles().Count
|
|
};
|
|
}
|
|
|
|
public EmployeePhotoBulkUploadReadResult ReadFolder(int payrollTypeID)
|
|
{
|
|
if (payrollTypeID <= 0)
|
|
throw new ServiceException("The payroll type of the login could not be found.");
|
|
|
|
EnsureFolder();
|
|
EmployeePhotoBulkUploadReadResult result = new EmployeePhotoBulkUploadReadResult
|
|
{
|
|
FolderPath = _displayFolder,
|
|
Subfolders = Directory.GetDirectories(_folder).Select(Path.GetFileName)
|
|
.Where(x => !x.StartsWith(".")).OrderBy(x => x).ToList() // not the save's own kept-aside folder
|
|
};
|
|
|
|
result.Files = Check(ListFiles(), payrollTypeID);
|
|
result.ReadyCount = result.Files.Count(x => x.Status == EmployeePhotoBulkUploadFile.Ready);
|
|
result.WarningCount = result.Files.Count(x => x.Status == EmployeePhotoBulkUploadFile.Warning);
|
|
result.ErrorCount = result.Files.Count(x => x.Status == EmployeePhotoBulkUploadFile.Error);
|
|
result.ReplaceCount = result.Files.Count(x => x.HasPhoto && x.Status != EmployeePhotoBulkUploadFile.Error);
|
|
result.CanSave = result.Files.Count > 0 && result.ErrorCount == 0;
|
|
return result;
|
|
}
|
|
|
|
#region Save run (one at a time, followed by the screen)
|
|
|
|
private static readonly object RunLock = new object();
|
|
private static readonly Dictionary<string, EmployeePhotoBulkUploadRun> Runs = new Dictionary<string, EmployeePhotoBulkUploadRun>();
|
|
private static string _activeRunID;
|
|
|
|
public EmployeePhotoBulkUploadRun BeginSave(int payrollTypeID)
|
|
{
|
|
if (payrollTypeID <= 0)
|
|
throw new ServiceException("The payroll type of the login could not be found.");
|
|
|
|
lock (RunLock)
|
|
{
|
|
// Two saves of one folder at once would fight over the same files and thumbnails.
|
|
if (_activeRunID != null)
|
|
throw new ServiceException("Profile pictures are being saved already. Wait until that save ends.");
|
|
|
|
// Finished runs are only kept long enough for the screen to read the outcome.
|
|
foreach (string old in Runs.Where(x => x.Value.FinishedAt.HasValue
|
|
&& x.Value.FinishedAt.Value < DateTime.Now.AddHours(-6))
|
|
.Select(x => x.Key).ToList())
|
|
Runs.Remove(old);
|
|
|
|
EmployeePhotoBulkUploadRun run = new EmployeePhotoBulkUploadRun
|
|
{
|
|
RunID = Guid.NewGuid().ToString("N"),
|
|
Status = EmployeePhotoBulkUploadRun.Running,
|
|
Step = "Starting",
|
|
StartedAt = DateTime.Now,
|
|
StepStartedAt = DateTime.Now
|
|
};
|
|
Runs[run.RunID] = run;
|
|
_activeRunID = run.RunID;
|
|
return Copy(run);
|
|
}
|
|
}
|
|
|
|
public void RunSave(string runID, int payrollTypeID)
|
|
{
|
|
EmployeePhotoBulkUploadRun run;
|
|
lock (RunLock)
|
|
{
|
|
Runs.TryGetValue(runID ?? string.Empty, out run);
|
|
}
|
|
if (run == null)
|
|
return;
|
|
|
|
try
|
|
{
|
|
Save(run, payrollTypeID);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
ExceptionLog.Write(e);
|
|
Finish(run, EmployeePhotoBulkUploadRun.Failed, "Nothing was saved: " + e.Message, null);
|
|
}
|
|
finally
|
|
{
|
|
lock (RunLock)
|
|
{
|
|
if (_activeRunID == runID)
|
|
_activeRunID = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public EmployeePhotoBulkUploadRun GetRun(string runID)
|
|
{
|
|
lock (RunLock)
|
|
{
|
|
EmployeePhotoBulkUploadRun run;
|
|
return Runs.TryGetValue(runID ?? string.Empty, out run) ? Copy(run) : null;
|
|
}
|
|
}
|
|
|
|
public EmployeePhotoBulkUploadRun GetActiveRun()
|
|
{
|
|
lock (RunLock)
|
|
{
|
|
EmployeePhotoBulkUploadRun run;
|
|
return _activeRunID != null && Runs.TryGetValue(_activeRunID, out run) ? Copy(run) : null;
|
|
}
|
|
}
|
|
|
|
/// <summary>The run is changed by the save's thread and read by the screen's requests: hand out copies.</summary>
|
|
private static EmployeePhotoBulkUploadRun Copy(EmployeePhotoBulkUploadRun run)
|
|
{
|
|
lock (run)
|
|
{
|
|
return new EmployeePhotoBulkUploadRun
|
|
{
|
|
RunID = run.RunID,
|
|
Status = run.Status,
|
|
Step = run.Step,
|
|
Total = run.Total,
|
|
Done = run.Done,
|
|
Message = run.Message,
|
|
SavedCount = run.SavedCount,
|
|
ReplacedCount = run.ReplacedCount,
|
|
Files = run.Files.ToList(),
|
|
SavedEmployeeIDs = run.SavedEmployeeIDs.ToList(),
|
|
StartedAt = run.StartedAt,
|
|
FinishedAt = run.FinishedAt,
|
|
StepStartedAt = run.StepStartedAt,
|
|
ElapsedSeconds = (int)((run.FinishedAt ?? DateTime.Now) - run.StartedAt).TotalSeconds,
|
|
StepElapsedSeconds = (int)(DateTime.Now - run.StepStartedAt).TotalSeconds
|
|
};
|
|
}
|
|
}
|
|
|
|
private static void SetStep(EmployeePhotoBulkUploadRun run, string step, int total)
|
|
{
|
|
lock (run)
|
|
{
|
|
run.Step = step;
|
|
run.Total = total;
|
|
run.Done = 0;
|
|
run.StepStartedAt = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
private static void Finish(EmployeePhotoBulkUploadRun run, string status, string message, List<EmployeePhotoBulkUploadFile> files)
|
|
{
|
|
lock (run)
|
|
{
|
|
run.Status = status;
|
|
run.Message = message;
|
|
run.Files = files ?? new List<EmployeePhotoBulkUploadFile>();
|
|
run.FinishedAt = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Checks
|
|
|
|
/// <summary>
|
|
/// Every check of every file: the file itself (type, name, size, a real picture), the same
|
|
/// employee twice, and the employee (in the system, in this payroll type, one only).
|
|
/// Only picture headers are read here, so even a very large folder is checked quickly;
|
|
/// the whole picture is decoded when it is saved.
|
|
/// </summary>
|
|
private List<EmployeePhotoBulkUploadFile> Check(List<string> paths, int payrollTypeID)
|
|
{
|
|
List<EmployeePhotoBulkUploadFile> files = new List<EmployeePhotoBulkUploadFile>();
|
|
Dictionary<EmployeePhotoBulkUploadFile, string> pathOf = new Dictionary<EmployeePhotoBulkUploadFile, string>();
|
|
|
|
foreach (string path in paths)
|
|
{
|
|
EmployeePhotoBulkUploadFile file = new EmployeePhotoBulkUploadFile
|
|
{
|
|
FileName = Path.GetFileName(path),
|
|
EmployeeNo = Path.GetFileNameWithoutExtension(path)
|
|
};
|
|
CheckFile(file, path);
|
|
files.Add(file);
|
|
pathOf[file] = path;
|
|
}
|
|
|
|
// The same employee twice (C0107.jpg and C0107.png): neither is taken, the user keeps one.
|
|
foreach (var group in files.Where(x => !string.IsNullOrWhiteSpace(x.EmployeeNo))
|
|
.GroupBy(x => x.EmployeeNo.Trim(), StringComparer.OrdinalIgnoreCase)
|
|
.Where(g => g.Count() > 1))
|
|
{
|
|
string names = string.Join(", ", group.Select(x => x.FileName));
|
|
foreach (EmployeePhotoBulkUploadFile file in group)
|
|
file.Errors.Add("More than one picture for Employee No " + group.Key + " (" + names + "). Keep only one of them in the folder.");
|
|
}
|
|
|
|
CheckEmployees(files, payrollTypeID);
|
|
|
|
foreach (EmployeePhotoBulkUploadFile file in files)
|
|
{
|
|
file.Status = file.Errors.Count > 0 ? EmployeePhotoBulkUploadFile.Error
|
|
: file.Warnings.Count > 0 ? EmployeePhotoBulkUploadFile.Warning
|
|
: EmployeePhotoBulkUploadFile.Ready;
|
|
}
|
|
|
|
return files.OrderBy(x => x.FileName, StringComparer.OrdinalIgnoreCase).ToList();
|
|
}
|
|
|
|
private static void CheckFile(EmployeePhotoBulkUploadFile file, string path)
|
|
{
|
|
string extension = Path.GetExtension(path).ToLowerInvariant();
|
|
if (!EmployeePhotoBulkUploadRules.Extensions.Contains(extension))
|
|
{
|
|
file.Errors.Add((string.IsNullOrEmpty(extension) ? "The file has no extension" : "'" + extension + "' files are not taken")
|
|
+ ". Only " + string.Join(", ", EmployeePhotoBulkUploadRules.Extensions) + " pictures can be uploaded.");
|
|
return;
|
|
}
|
|
|
|
string name = file.EmployeeNo ?? string.Empty;
|
|
if (name.Trim().Length == 0)
|
|
{
|
|
file.Errors.Add("The file name is empty. Name the picture by the Employee No, e.g. C0107" + extension + ".");
|
|
return;
|
|
}
|
|
if (name != name.Trim())
|
|
file.Errors.Add("The file name starts or ends with a space. Name it exactly by the Employee No, e.g. "
|
|
+ name.Trim() + extension + ".");
|
|
|
|
FileInfo info = new FileInfo(path);
|
|
file.SizeBytes = info.Length;
|
|
if (info.Length == 0)
|
|
{
|
|
file.Errors.Add("The file is empty (0 KB).");
|
|
return;
|
|
}
|
|
if (info.Length > EmployeePhotoBulkUploadRules.MaxFileSizeMB * 1024L * 1024L)
|
|
file.Errors.Add("The picture is " + (info.Length / 1024d / 1024d).ToString("0.#") + " MB; the most a picture can be is "
|
|
+ EmployeePhotoBulkUploadRules.MaxFileSizeMB + " MB. Make it smaller and copy it again.");
|
|
|
|
try
|
|
{
|
|
using (SKCodec codec = SKCodec.Create(path))
|
|
{
|
|
if (codec == null)
|
|
{
|
|
file.Errors.Add("The file is not a picture, or it is damaged, although its name ends in " + extension + ".");
|
|
return;
|
|
}
|
|
if (codec.EncodedFormat != SKEncodedImageFormat.Jpeg && codec.EncodedFormat != SKEncodedImageFormat.Png)
|
|
{
|
|
file.Errors.Add("The file is a " + codec.EncodedFormat.ToString().ToUpperInvariant()
|
|
+ " picture renamed to " + extension + ". Save it as a real JPG or PNG.");
|
|
return;
|
|
}
|
|
|
|
file.Width = codec.Info.Width;
|
|
file.Height = codec.Info.Height;
|
|
}
|
|
}
|
|
catch (Exception e) when (e is IOException || e is UnauthorizedAccessException)
|
|
{
|
|
file.Errors.Add("The file could not be opened (" + e.Message + ").");
|
|
return;
|
|
}
|
|
|
|
if (Math.Min(file.Width, file.Height) < EmployeePhotoBulkUploadRules.MinSidePixels)
|
|
file.Warnings.Add("The picture is only " + file.Width + " x " + file.Height + " pixels, so it may look blurred. At least "
|
|
+ EmployeePhotoBulkUploadRules.MinSidePixels + " x " + EmployeePhotoBulkUploadRules.MinSidePixels + " is recommended.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// The employee of each file, by Employee No: in the system, in the current payroll type and
|
|
/// only one of them. A file that is wrong as a file already has its error and is not looked up.
|
|
/// </summary>
|
|
private void CheckEmployees(List<EmployeePhotoBulkUploadFile> files, int payrollTypeID)
|
|
{
|
|
List<EmployeePhotoBulkUploadFile> toFind = files.Where(x => x.Errors.Count == 0).ToList();
|
|
if (toFind.Count == 0)
|
|
return;
|
|
|
|
EmployeePhotoService photoService = new EmployeePhotoService(_env);
|
|
|
|
// The lookup Salary Master Data Bulk Upload uses: one query per 500 Employee Nos.
|
|
Dictionary<string, List<Employee>> byNo = new HistorySalaryMonthlyService()
|
|
.GetEmployeesByNo(toFind.Select(x => x.EmployeeNo).ToList())
|
|
.Where(x => !string.IsNullOrWhiteSpace(x.EmployeeNo))
|
|
.GroupBy(x => x.EmployeeNo.Trim(), StringComparer.OrdinalIgnoreCase)
|
|
.ToDictionary(g => g.Key, g => g.ToList(), StringComparer.OrdinalIgnoreCase);
|
|
|
|
foreach (EmployeePhotoBulkUploadFile file in toFind)
|
|
{
|
|
List<Employee> found;
|
|
if (!byNo.TryGetValue(file.EmployeeNo, out found) || found.Count == 0)
|
|
{
|
|
file.Errors.Add("There is no employee with Employee No " + file.EmployeeNo
|
|
+ " in the system. The file name must be exactly the Employee No (not e.g. \""
|
|
+ file.EmployeeNo + " (1)\" or \"" + file.EmployeeNo + " - Copy\").");
|
|
continue;
|
|
}
|
|
|
|
List<Employee> inPayrollType = found.Where(x => x.PayrollTypeID == payrollTypeID).ToList();
|
|
if (inPayrollType.Count == 0)
|
|
{
|
|
file.Errors.Add("Employee " + file.EmployeeNo + " belongs to another payroll type, not the current one.");
|
|
continue;
|
|
}
|
|
if (inPayrollType.Count > 1)
|
|
{
|
|
file.Errors.Add("More than one employee of this payroll type has Employee No " + file.EmployeeNo
|
|
+ ", so it is not clear whose picture this is.");
|
|
continue;
|
|
}
|
|
|
|
Employee employee = inPayrollType[0];
|
|
file.EmployeeID = employee.ID;
|
|
file.EmployeeNo = employee.EmployeeNo.Trim();
|
|
file.EmployeeName = employee.Name;
|
|
|
|
if (employee.Status != EnumEmployeeStatus.Live)
|
|
file.Warnings.Add("Employee " + file.EmployeeNo + " is not live — the status is " + employee.Status
|
|
+ ". The picture will still be saved.");
|
|
|
|
file.HasPhoto = photoService.ThumbnailExists(file.EmployeeNo);
|
|
if (photoService.PendingExists(file.EmployeeNo))
|
|
file.Warnings.Add("The employee has a picture waiting for approval on Profile Update. "
|
|
+ "If that request is approved later, it will replace this picture.");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Save
|
|
|
|
/// <summary>
|
|
/// The whole save, all or nothing:
|
|
/// 1. every check again, on the folder as it is now — one error and nothing is saved;
|
|
/// 2. every picture read in full, so a damaged one is found before anything is written;
|
|
/// 3. every picture into the database in ONE transaction, each thumbnail written as it goes
|
|
/// with the old one kept aside; a failure rolls the database back and puts the old
|
|
/// thumbnails back, so every employee is exactly as before;
|
|
/// 4. only after the commit are the pictures taken out of the folder.
|
|
/// </summary>
|
|
private void Save(EmployeePhotoBulkUploadRun run, int payrollTypeID)
|
|
{
|
|
EnsureFolder();
|
|
|
|
// 1. Checks
|
|
SetStep(run, "Checking the pictures", 0);
|
|
List<EmployeePhotoBulkUploadFile> files = Check(ListFiles(), payrollTypeID);
|
|
if (files.Count == 0)
|
|
{
|
|
Finish(run, EmployeePhotoBulkUploadRun.Failed, "There is no picture in the folder. Nothing was saved.", null);
|
|
return;
|
|
}
|
|
List<EmployeePhotoBulkUploadFile> withErrors = files.Where(x => x.Status == EmployeePhotoBulkUploadFile.Error).ToList();
|
|
if (withErrors.Count > 0)
|
|
{
|
|
Finish(run, EmployeePhotoBulkUploadRun.Failed, withErrors.Count + " picture(s) have errors, so nothing was saved. "
|
|
+ "Fix them in the folder, check again and save again.", withErrors);
|
|
return;
|
|
}
|
|
|
|
// 2. Every picture read in full
|
|
SetStep(run, "Reading every picture", files.Count);
|
|
foreach (EmployeePhotoBulkUploadFile file in files)
|
|
{
|
|
try
|
|
{
|
|
using (SKBitmap bitmap = SKBitmap.Decode(File.ReadAllBytes(Path.Combine(_folder, file.FileName))))
|
|
{
|
|
if (bitmap == null)
|
|
file.Errors.Add("The picture is damaged and could not be read. Copy a good copy of it into the folder.");
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
file.Errors.Add("The picture could not be read (" + e.Message + ").");
|
|
}
|
|
if (file.Errors.Count > 0)
|
|
file.Status = EmployeePhotoBulkUploadFile.Error;
|
|
run.Done++;
|
|
}
|
|
withErrors = files.Where(x => x.Status == EmployeePhotoBulkUploadFile.Error).ToList();
|
|
if (withErrors.Count > 0)
|
|
{
|
|
Finish(run, EmployeePhotoBulkUploadRun.Failed, withErrors.Count + " picture(s) could not be read, so nothing was saved. "
|
|
+ "Replace them in the folder, check again and save again.", withErrors);
|
|
return;
|
|
}
|
|
|
|
// 3. Database (one transaction) + thumbnails (old ones kept aside)
|
|
SetStep(run, "Saving the pictures", files.Count);
|
|
EmployeePhotoService photoService = new EmployeePhotoService(_env);
|
|
string backupFolder = Path.Combine(_folder, ".backup-" + run.RunID);
|
|
Directory.CreateDirectory(backupFolder);
|
|
// Employee No -> (thumbnail path, the old one kept aside or null when the employee had none).
|
|
Dictionary<string, Tuple<string, string>> replaced = new Dictionary<string, Tuple<string, string>>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
TransactionContext tc = null;
|
|
EmployeePhotoBulkUploadFile current = null;
|
|
try
|
|
{
|
|
tc = TransactionContext.Begin(true);
|
|
foreach (EmployeePhotoBulkUploadFile file in files)
|
|
{
|
|
current = file;
|
|
byte[] bytes = File.ReadAllBytes(Path.Combine(_folder, file.FileName));
|
|
|
|
HREmployeeDA.uplaodFile(tc, ToUpload(file, bytes));
|
|
ProfileUpdateRequestDA.UpdateProfilePercentage(tc, file.EmployeeID);
|
|
|
|
string oldThumbnail = photoService.FindApprovedFile(file.EmployeeNo);
|
|
string keptAside = null;
|
|
if (oldThumbnail != null)
|
|
{
|
|
keptAside = Path.Combine(backupFolder, Path.GetFileName(oldThumbnail));
|
|
File.Copy(oldThumbnail, keptAside, true);
|
|
}
|
|
// Noted before writing, so even a half-written thumbnail is put back.
|
|
replaced[file.EmployeeNo] = Tuple.Create(oldThumbnail, keptAside);
|
|
photoService.GenerateThumbnail(file.EmployeeNo, bytes);
|
|
|
|
run.Done++;
|
|
}
|
|
current = null;
|
|
|
|
SetStep(run, "Finishing", files.Count);
|
|
run.Done = files.Count;
|
|
tc.End();
|
|
tc = null;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#region Handle Exception
|
|
if (tc != null)
|
|
tc.HandleError();
|
|
ExceptionLog.Write(e);
|
|
List<string> notRestored = RestoreThumbnails(photoService, replaced);
|
|
TryDeleteFolder(backupFolder);
|
|
|
|
List<EmployeePhotoBulkUploadFile> stopped = new List<EmployeePhotoBulkUploadFile>();
|
|
if (current != null)
|
|
{
|
|
current.Errors.Add("Saving stopped at this picture: " + e.Message);
|
|
current.Status = EmployeePhotoBulkUploadFile.Error;
|
|
stopped.Add(current);
|
|
}
|
|
Finish(run, EmployeePhotoBulkUploadRun.Failed,
|
|
"Saving stopped (" + e.Message + "). Nothing was saved — every employee's picture is as it was."
|
|
+ (notRestored.Count > 0
|
|
? " The old on-screen picture of " + string.Join(", ", notRestored) + " could not be put back; it is still in the database."
|
|
: string.Empty),
|
|
stopped);
|
|
return;
|
|
#endregion
|
|
}
|
|
|
|
// 4. Committed: the pictures leave the folder.
|
|
List<EmployeePhotoBulkUploadFile> notes = new List<EmployeePhotoBulkUploadFile>();
|
|
foreach (EmployeePhotoBulkUploadFile file in files)
|
|
{
|
|
try
|
|
{
|
|
File.Delete(Path.Combine(_folder, file.FileName));
|
|
}
|
|
catch (Exception e) when (e is IOException || e is UnauthorizedAccessException)
|
|
{
|
|
// Saved all the same; only the leftover copy needs removing by hand.
|
|
file.Warnings.Add("Saved, but the file could not be removed from the folder (" + e.Message + "). Delete it by hand.");
|
|
notes.Add(file);
|
|
}
|
|
}
|
|
TryDeleteFolder(backupFolder);
|
|
|
|
lock (run)
|
|
{
|
|
run.SavedCount = files.Count;
|
|
run.ReplacedCount = replaced.Count(x => x.Value.Item2 != null);
|
|
run.SavedEmployeeIDs = files.Select(x => x.EmployeeID).ToList();
|
|
}
|
|
Finish(run, EmployeePhotoBulkUploadRun.Saved, "All " + files.Count + " profile picture(s) were saved.", notes);
|
|
}
|
|
|
|
/// <summary>referenceID is the employee id, as the approval and every photo reader use it.</summary>
|
|
private static empFileupload ToUpload(EmployeePhotoBulkUploadFile file, byte[] bytes)
|
|
{
|
|
return new empFileupload
|
|
{
|
|
employeeID = file.EmployeeID,
|
|
referenceID = file.EmployeeID,
|
|
filetype = enumEmpFileUploadType.photo,
|
|
FileFormat = EnumFileFormat.Picture,
|
|
fileName = "Profile Picture" + Path.GetExtension(file.FileName).ToLowerInvariant(),
|
|
fileData = bytes
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// After a rollback: every thumbnail this save wrote goes back to the one kept aside, or is
|
|
/// removed when the employee had none. Returns the Employee Nos that could not be put back.
|
|
/// </summary>
|
|
private static List<string> RestoreThumbnails(EmployeePhotoService photoService, Dictionary<string, Tuple<string, string>> replaced)
|
|
{
|
|
List<string> notRestored = new List<string>();
|
|
foreach (KeyValuePair<string, Tuple<string, string>> item in replaced)
|
|
{
|
|
try
|
|
{
|
|
string oldThumbnail = item.Value.Item1;
|
|
string keptAside = item.Value.Item2;
|
|
if (keptAside != null)
|
|
{
|
|
File.Copy(keptAside, oldThumbnail, true);
|
|
}
|
|
else
|
|
{
|
|
string written = photoService.FindApprovedFile(item.Key);
|
|
if (written != null)
|
|
File.Delete(written);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
ExceptionLog.Write(e);
|
|
notRestored.Add(item.Key);
|
|
}
|
|
}
|
|
return notRestored;
|
|
}
|
|
|
|
private static void TryDeleteFolder(string folder)
|
|
{
|
|
try
|
|
{
|
|
if (Directory.Exists(folder))
|
|
Directory.Delete(folder, true);
|
|
}
|
|
catch (Exception e) when (e is IOException || e is UnauthorizedAccessException)
|
|
{
|
|
// Only a leftover folder of old thumbnails; it is never read as pictures.
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Folder
|
|
|
|
private void EnsureFolder()
|
|
{
|
|
if (!Directory.Exists(_folder))
|
|
Directory.CreateDirectory(_folder);
|
|
}
|
|
|
|
/// <summary>The top-level files of the folder, without the system files and Office lock files.</summary>
|
|
private List<string> ListFiles()
|
|
{
|
|
return Directory.EnumerateFiles(_folder, "*", SearchOption.TopDirectoryOnly)
|
|
.Where(path =>
|
|
{
|
|
string name = Path.GetFileName(path);
|
|
if (SystemFiles.Contains(name.ToLowerInvariant()) || name.StartsWith("~$") || name.StartsWith("."))
|
|
return false;
|
|
return (File.GetAttributes(path) & (FileAttributes.Hidden | FileAttributes.System)) == 0;
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|