private async Task UpdateAssetsFromSource(IEnumerable <AssetViewModel> assets)
{
var logger = new LoggerResult();
var workProgress = new WorkProgressViewModel(ServiceProvider, logger)
{
Title = "Update assets from source",
KeepOpen = KeepOpen.OnWarningsOrErrors,
IsIndeterminate = true,
IsCancellable = false,
};
workProgress.RegisterProgressStatus(logger, true);
workProgress.ServiceProvider.Get <IEditorDialogService>().ShowProgressWindow(workProgress, 500);
var undoRedo = ServiceProvider.Get <IUndoRedoService>();
using (var transaction = undoRedo.CreateTransaction())
{
var tasks = new List <Task>();
foreach (var asset in assets)
{
logger.Verbose($"Updating {asset.Url}...");
var task = asset.Sources.UpdateAssetFromSource(logger);
// Continuation might swallow exceptions, careful to keep the original task like this
task.ContinueWith(x => logger.Verbose($"{asset.Url} updated")).Forget();
tasks.Add(task);
}
await Task.WhenAll(tasks);
logger.Info("Update completed...");
undoRedo.SetName(transaction, $"Update {tasks.Count} asset(s) from their source(s)");
}
await workProgress.NotifyWorkFinished(false, logger.HasErrors);
}
public async void ShowProgressWindow(WorkProgressViewModel workProgress, int minDelay)
{
if (workProgress == null)
{
throw new ArgumentNullException(nameof(workProgress));
}
// Tell the work progress view model that a window will be open for it
workProgress.NotifyWindowWillOpen();
// Create a container object for the work progress to put it in the queue
var progress = new PendingWorkProgress(workProgress);
// As soon as the work is finished, we should display the window, even if the delay is not complete
workProgress.WorkFinished += (sender, e) => progress.ReadyToDisplay.TrySetResult(0);
if (workProgress.WorkDone)
{
progress.ReadyToDisplay.TrySetResult(0);
}
// Compute the list of progress window that should be displayed before this one
List <PendingWorkProgress> precedingWindows;
lock (pendingProgressWindows)
{
precedingWindows = new List <PendingWorkProgress>(pendingProgressWindows);
pendingProgressWindows.Add(progress);
}
// Enqueue a task to display the window when it's ready.
DisplayProgressWindow(precedingWindows, progress);
// Wait the delay before notifying that we're ready to display
await Task.Delay(minDelay);
progress.ReadyToDisplay.TrySetResult(0);
}
private async Task UpdateAssetFromSource()
{
if (updatingFromSource)
{
return;
}
updatingFromSource = true;
var logger = new LoggerResult();
var workProgress = new WorkProgressViewModel(ServiceProvider, logger)
{
Title = "Update assets from source",
KeepOpen = KeepOpen.OnWarningsOrErrors,
IsIndeterminate = true,
IsCancellable = false,
};
workProgress.RegisterProgressStatus(logger, true);
workProgress.ServiceProvider.Get <IEditorDialogService>().ShowProgressWindow(workProgress, 500);
using (var transaction = asset.UndoRedoService.CreateTransaction())
{
await UpdateAssetFromSource(logger);
asset.UndoRedoService.SetName(transaction, $"Update [{asset.Url}] from its source(s)");
}
await workProgress.NotifyWorkFinished(false, logger.HasErrors);
updatingFromSource = false;
}
public static void AddWorkprogress(this tbl_workprogress workprogress, WorkProgressViewModel workprogressVm)
{
//workprogress.ps_id = workprogressVm.ps_id;
//workprogress.junction_name = workprogressVm.junction_name;
//workprogress.poles_total = workprogressVm.poles_total;
//workprogress.ps_id = workprogressVm.ps_id;
//workprogress.ps_id = workprogressVm.ps_id;
}
public WorkProgressWindow(WorkProgressViewModel workProgress)
{
InitializeComponent();
this.workProgress = workProgress;
Loaded += WindowLoaded;
Closing += WindowClosing;
Width = Math.Min(Width, SystemParameters.WorkArea.Width);
Height = Math.Min(Height, SystemParameters.WorkArea.Height);
}
public WorkProgress SaveWorkProgress(WorkProgressViewModel workProg)
{
WorkProgress wProg = null;
if (workProg.ProgId > 0)
{
wProg = this.GetWorkProgress(workProg.ProgId);
}
//不是创建人只能新增不能修改
if (wProg == null ||
wProg.Creator != _identity.Claims.Where(c => c.Type == "name").FirstOrDefault().Value)
{
BizSteps step = _context.BizSteps.Include("BizItem").Where(s => s.StepId == workProg.StepId).FirstOrDefault();
wProg = new WorkProgress();
wProg.WoId = workProg.WoId;
wProg.ItemId = step.BizItem.ItemId;
wProg.StepId = step.StepId;
_context.WorkProgress.Add(wProg);
}
wProg.CompletedTime = workProg.CompletedTime;
wProg.ResultDesc = workProg.ResultDesc;
wProg.AdvanceExpenditure = workProg.AdvanceExpenditure;
wProg.CreateTime = DateTime.Now;
wProg.Creator = _identity.Claims.Where(c => c.Type == "name").FirstOrDefault().Value;
wProg.SortIndex = workProg.SortIndex;
wProg.IsSuccess = workProg.IsSuccess;
//重算代垫费用
WorkOrder wOrder = _context.WorkOrders.Include("WorkProgresses").Where(wo => wo.WoId == wProg.WoId).First();
wOrder.AdvanceExpenditure = wOrder.WorkProgresses.Sum(p => p.AdvanceExpenditure);
wOrder.State = WorkOrderState.InProcess;
if (!string.IsNullOrEmpty(workProg.Url))
{
ProgressImage pi = new ProgressImage();
if (wProg.Images.Count > 0)
{
pi = wProg.Images.FirstOrDefault();
}
else
{
wProg.Images.Add(pi);
}
pi.AliyunKey = workProg.FileName;
pi.Url = workProg.Url;
pi.Expiration = DateTime.Now.AddYears(5);
pi.WorkProgress = wProg;
}
_context.SaveChanges();
return(wProg);
}
public async Task AddExistingProject()
{
var fileDialog = ServiceProvider.Get <IEditorDialogService>().CreateFileOpenModalDialog();
fileDialog.Filters.Add(new FileDialogFilter("Visual Studio C# project", "csproj"));
fileDialog.InitialDirectory = Session.SolutionPath;
var result = await fileDialog.ShowModal();
var projectPath = fileDialog.FilePaths.FirstOrDefault();
if (result == DialogResult.Ok && projectPath != null)
{
var loggerResult = new LoggerResult();
var cancellationSource = new CancellationTokenSource();
var workProgress = new WorkProgressViewModel(ServiceProvider, loggerResult)
{
Title = "Importing package...",
KeepOpen = KeepOpen.OnWarningsOrErrors,
IsIndeterminate = true,
IsCancellable = false
};
using (var transaction = UndoRedoService.CreateTransaction())
{
workProgress.RegisterProgressStatus(loggerResult, true);
ServiceProvider.Get <IEditorDialogService>().ShowProgressWindow(workProgress, 500);
await Task.Run(() =>
{
try
{
Package.AddExistingProject(projectPath, loggerResult);
}
catch (Exception e)
{
loggerResult.Error("An exception occurred while importing the project", e);
}
}, cancellationSource.Token);
RefreshPackageReferences();
UndoRedoService.SetName(transaction, $"Import project '{new UFile(projectPath).GetFileNameWithoutExtension()}'");
}
// Notify that the task is finished
await workProgress.NotifyWorkFinished(cancellationSource.IsCancellationRequested, loggerResult.HasErrors);
}
}
public HttpResponseMessage SaveWorkprogress(HttpRequestMessage request, WorkProgressViewModel workprogress)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
tbl_workprogress newWorkprogress = new tbl_workprogress();
newWorkprogress.AddWorkprogress(workprogress);
//_workprogressRepository.Add(AddWorkprogress);
_unitOfWork.Commit();
//response = request.CreateResponse<SubContractorViewModel>(HttpStatusCode.Created, workprogress);
}
return response;
}));
}
public async Task UpdatePackageTemplate(TemplateDescription template)
{
var loggerResult = new LoggerResult();
var workProgress = new WorkProgressViewModel(ServiceProvider, loggerResult)
{
Title = "Updating package...",
KeepOpen = KeepOpen.OnWarningsOrErrors,
IsIndeterminate = true,
IsCancellable = false
};
workProgress.RegisterProgressStatus(loggerResult, true);
var parameters = new PackageTemplateGeneratorParameters
{
Name = Package.Meta.Name,
OutputDirectory = Package.FullPath.GetFullDirectory(),
Description = template,
Package = Package,
Logger = loggerResult,
};
var generator = TemplateManager.FindTemplateGenerator(parameters);
if (generator == null)
{
await ServiceProvider.Get <IDialogService>().MessageBox(Tr._p("Message", "Unable to retrieve template generator for the selected template. Aborting."), MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
// Errors might occur when generating the template. For the moment we consider them non-fatal and allow to open the project anyway.
await TemplateGeneratorHelper.RunTemplateGeneratorSafe(generator, parameters, workProgress);
RefreshProjects();
await workProgress.NotifyWorkFinished(false, loggerResult.HasErrors);
Package.IsDirty = true;
}
/// <summary>
/// Creates the view models for each asset, directory, profile, project and reference of this package.
/// </summary>
/// <param name="loggerResult">The logger result of the current operation.</param>
/// <param name="workProgress">A <see cref="WorkProgressViewModel"/> instance to update on progresses. Can be <c>null</c>.</param>
/// <param name="cancellationToken">A cancellation token to cancel the load process. Can be <c>null</c>.</param>
internal void LoadPackageInformation(LoggerResult loggerResult, WorkProgressViewModel workProgress, CancellationToken?cancellationToken = null)
{
if (workProgress == null)
{
throw new ArgumentNullException(nameof(workProgress));
}
var progress = workProgress.ProgressValue;
workProgress.UpdateProgressAsync($"Processing asset {progress + 1}/{workProgress.Maximum}...", progress);
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return;
}
foreach (var dependency in Package.Container.DirectDependencies)
{
new DirectDependencyReferenceViewModel(dependency, this, Dependencies, false);
}
foreach (var asset in Package.Assets.ToList())
{
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return;
}
var message = $"Processing asset {progress + 1}/{workProgress.Maximum}...";
workProgress.UpdateProgressAsync(message, progress);
var url = asset.Location;
DirectoryBaseViewModel directory;
var projectSourceCodeAsset = asset.Asset as IProjectAsset;
// TODO CSPROJ=XKPKG override rather than cast to subclass
if (projectSourceCodeAsset != null && this is ProjectViewModel project)
{
directory = project.GetOrCreateProjectDirectory(url.GetFullDirectory() ?? "", false);
}
else
{
directory = GetOrCreateAssetDirectory(url.GetFullDirectory() ?? "", false);
}
CreateAsset(directory, asset, false, loggerResult, true);
++progress;
}
FillRootAssetCollection();
workProgress.UpdateProgressAsync("Package processed", progress);
foreach (var explicitDirectory in Package.ExplicitFolders)
{
GetOrCreateAssetDirectory(explicitDirectory, false);
}
var pluginService = Session.ServiceProvider.Get <IAssetsPluginService>();
foreach (var plugin in pluginService.Plugins)
{
foreach (var property in plugin.ProfileSettings)
{
RegisterSettings(property);
}
}
}
public PendingWorkProgress(WorkProgressViewModel workProgress)
{
WorkProgress = workProgress;
ReadyToDisplay = new TaskCompletionSource <int>();
Displayed = new TaskCompletionSource <int>();
}
public async Task <HttpResponseMessage> SaveWorkProgress()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = HttpContext.Current.Server.MapPath(_uploadPath);
var provider = new MultipartFormDataStreamProvider(root);
Dictionary <string, string> fileNames = new Dictionary <string, string>();
try
{
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
// This illustrates how to get the file names.
foreach (MultipartFileData file in provider.FileData)
{
if (File.Exists(file.LocalFileName))
{
FileInfo fi = new FileInfo(file.LocalFileName);
if (fi.Length < 500)
{
File.Delete(file.LocalFileName);
continue;
}
else
{
File.Move(file.LocalFileName, string.Format("{0}{1}", file.LocalFileName, Path.GetExtension(file.Headers.ContentDisposition.FileName.Replace("\"", ""))));
}
}
fileNames.Add(file.Headers.ContentDisposition.FileName, file.LocalFileName);
}
WorkProgressViewModel wProg = new WorkProgressViewModel();
long progid;
if (long.TryParse(HttpContext.Current.Request.Form["ProgId"], out progid))
{
wProg.ProgId = progid;
}
wProg.StepId = Convert.ToInt32(HttpContext.Current.Request.Form["StepId"]);
wProg.WoId = Convert.ToInt64(HttpContext.Current.Request.Form["WorkOrderId"]);
wProg.SortIndex = Convert.ToInt32(HttpContext.Current.Request.Form["SortIndex"]);
DateTime dt;
if (DateTime.TryParse(HttpContext.Current.Request.Form["CompletedTime"], out dt))
{
wProg.CompletedTime = dt;
}
wProg.ResultDesc = HttpContext.Current.Request.Form["ResultDesc"];
decimal ae;
if (decimal.TryParse(HttpContext.Current.Request.Form["AdvanceExpenditure"], out ae))
{
wProg.AdvanceExpenditure = ae;
}
bool isSuc;
if (bool.TryParse(HttpContext.Current.Request.Form["IsSuccess"], out isSuc))
{
wProg.IsSuccess = isSuc;
}
if (fileNames.Count > 0)
{
wProg.FileName = string.Format("{0}{1}", Path.GetFileName(fileNames.Values.FirstOrDefault()), Path.GetExtension(fileNames.Keys.FirstOrDefault().Replace("\"", "")));
wProg.Url = string.Format("{0}/{1}", _uploadPath, Path.GetFileName(wProg.FileName));
}
_progress.SaveWorkProgress(wProg);
return(Request.CreateResponse <ResMessageContent>(HttpStatusCode.OK, ResMessage.Success()));
}
catch (System.Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
/// <summary>
/// Creates the view models for each asset, directory, profile, project and reference of this package.
/// </summary>
/// <param name="loggerResult">The logger result of the current operation.</param>
/// <param name="workProgress">A <see cref="WorkProgressViewModel"/> instance to update on progresses. Can be <c>null</c>.</param>
/// <param name="cancellationToken">A cancellation token to cancel the load process. Can be <c>null</c>.</param>
internal void LoadPackageInformation(LoggerResult loggerResult, WorkProgressViewModel workProgress, CancellationToken?cancellationToken = null)
{
if (workProgress == null)
{
throw new ArgumentNullException(nameof(workProgress));
}
var progress = workProgress.ProgressValue;
workProgress.UpdateProgressAsync($"Processing asset {progress + 1}/{workProgress.Maximum}...", progress);
foreach (var profile in Package.Profiles)
{
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return;
}
var viewModel = new ProfileViewModel(Session, Package, profile, this);
Profiles.Add(viewModel);
foreach (var project in viewModel.Projects)
{
AddProject(project);
}
}
foreach (var localPackage in Package.LocalDependencies)
{
var viewModel = Session.AllPackages.SingleOrDefault(x => x.Match(localPackage.Id));
if (viewModel != null)
{
// ReSharper disable once ObjectCreationAsStatement - The PackageReferenceViewModel will register itself in the proper collection to keep being referenced
new LocalPackageReferenceViewModel(localPackage, viewModel, this, Dependencies, false);
}
}
foreach (var storeDependency in Package.Meta.Dependencies)
{
// TODO: Use Guid at some point to retrieve the package
var viewModel = Session.AllPackages.SingleOrDefault(x => x.Name == storeDependency.Name);
if (viewModel != null)
{
// ReSharper disable once ObjectCreationAsStatement - The PackageReferenceViewModel will register itself in the proper collection to keep being referenced
new StorePackageReferenceViewModel(storeDependency, viewModel, this, Dependencies, false);
}
}
foreach (var asset in Package.Assets.ToList())
{
if (cancellationToken.HasValue && cancellationToken.Value.IsCancellationRequested)
{
return;
}
var message = $"Processing asset {progress + 1}/{workProgress.Maximum}...";
workProgress.UpdateProgressAsync(message, progress);
var url = asset.Location;
DirectoryBaseViewModel directory;
var projectSourceCodeAsset = asset.Asset as IProjectAsset;
if (projectSourceCodeAsset != null && asset.SourceProject != null)
{
var project = Content.OfType <ProjectViewModel>().First(x => string.Compare(asset.SourceProject.GetFileNameWithoutExtension(), x.Name, StringComparison.InvariantCultureIgnoreCase) == 0);
directory = GetOrCreateProjectDirectory(project, url.GetDirectory() ?? "", false);
}
else
{
directory = GetOrCreateAssetDirectory(url.GetDirectory() ?? "", false);
}
CreateAsset(directory, asset, false, loggerResult, true);
++progress;
}
FillRootAssetCollection();
workProgress.UpdateProgressAsync("Package processed", progress);
foreach (var explicitDirectory in Package.ExplicitFolders)
{
GetOrCreateAssetDirectory(explicitDirectory, false);
}
var pluginService = Session.ServiceProvider.Get <IAssetsPluginService>();
foreach (var plugin in pluginService.Plugins)
{
foreach (var property in plugin.ProfileSettings)
{
RegisterSettings(property);
}
}
}
/// <summary>
/// Invokes the given template generator safely. The generator will be prepared on the calling thread, and run from
/// a task. This methods will catch and log all exceptions occurring during the template generation.
/// </summary>
/// <param name="generator">The template generator to run.</param>
/// <param name="parameters">The parameters for the template generator.</param>
/// <param name="workProgress">The view model used to report progress.</param>
/// <returns>A task that completes when the template generator has finished to run.</returns>
internal static async Task <bool> RunTemplateGeneratorSafe <TParameters>(ITemplateGenerator <TParameters> generator, TParameters parameters, WorkProgressViewModel workProgress) where TParameters : TemplateGeneratorParameters
{
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var success = false;
try
{
success = await generator.PrepareForRun(parameters);
if (!success)
{
// If the preparation failed without error, it means that the user cancelled the operation.
if (!parameters.Logger.HasErrors)
{
parameters.Logger.Info(Tr._p("Log", "Operation cancelled."));
}
return(false);
}
}
catch (Exception e)
{
parameters.Logger.Error(Tr._p("Log", "An exception occurred while generating the template."), e);
}
if (parameters.Logger.HasErrors || !success)
{
workProgress?.ServiceProvider.Get <IEditorDialogService>().ShowProgressWindow(workProgress, 0);
return(false);
}
workProgress?.ServiceProvider.Get <IEditorDialogService>().ShowProgressWindow(workProgress, 500);
var result = await Task.Run(() =>
{
try
{
return(generator.Run(parameters));
}
catch (Exception e)
{
parameters.Logger.Error(Tr._p("Log", "An exception occurred while generating the template."), e);
return(false);
}
});
return(result && !parameters.Logger.HasErrors);
}
