/// <summary>
/// Converts the <see cref="sourceValue" /> parameter to the <see cref="destinationType" /> parameter using <see cref="formatProvider"
/// /> and <see cref="ignoreCase" />
/// </summary>
/// <param name="sourceValue">the value to convert into an instance of <see cref="DeleteStatus" />.</param>
/// <returns>
/// an instance of <see cref="DeleteStatus" />, or <c>null</c> if there is no suitable conversion.
/// </returns>
public static object ConvertFrom(dynamic sourceValue)
{
if (null == sourceValue)
{
return(null);
}
try
{
DeleteTask.FromJsonString(typeof(string) == sourceValue.GetType() ? sourceValue : sourceValue.ToJsonString());
}
catch
{
// Unable to use JSON pattern
}
try
{
return(new DeleteTask
{
ApiVersion = sourceValue.ApiVersion,
Spec = sourceValue.Spec,
Status = sourceValue.Status,
Metadata = sourceValue.Metadata,
});
}
catch
{
}
return(null);
}
public object Delete(DeleteTask message)
{
using (var db = _connectionFactory.Open())
{
var task = db.Select <Task>(x => x.SessionId == message.SessionId && x.Id == message.TaskId);
if (task == null)
{
return new HttpResult()
{
StatusCode = HttpStatusCode.NotFound
}
}
;
try
{
db.Delete(task);
}
catch (Exception)
{
throw;
}
return(this.Get(new Tasks()
{
SessionId = message.SessionId
}));
}
}
}
public IActionResult DeleteTask([FromBody] DeleteTask DeleteTask)
{
if (DeleteTask == null)
{
return(new JsonResult(new List <object>()
{
new { Error = "no json file", Description = "send a json " }
}));
}
try
{
var del = (from e in Context.Tasks
where e.GuserId == DeleteTask.GuserId && e.TaskId == DeleteTask.TaskId
select e).FirstOrDefault();
Context.Tasks.Remove(del);
Context.SaveChanges();
return(Ok("Task deleted"));
}
catch (Exception e)
{
return(new JsonResult(new List <object>()
{
new { Error = "invalid Json", Description = "Json sent has invalid key value pair" }
}));
}
}
/// <summary>
/// Removes wrapper assembly from build directory, if wrapper assembly
/// no longer exists in output directory or is not in sync with build
/// directory, to force rebuild.
/// </summary>
/// <param name="config">The project configuration.</param>
private void Sync(ConfigurationBase config)
{
if (!CopyLocal || !File.Exists(WrapperAssembly))
{
// nothing to synchronize
return;
}
// determine path where wrapper assembly should be deployed to
string outputFile = FileUtils.CombinePaths(config.OutputDir.FullName,
Path.GetFileName(WrapperAssembly));
// determine last modification date/time of built wrapper assembly
DateTime wrapperModTime = File.GetLastWriteTime(WrapperAssembly);
// rebuild wrapper assembly if output assembly is more recent,
// or have been removed (by the user) to force a rebuild
if (FileSet.FindMoreRecentLastWriteTime(outputFile, wrapperModTime) != null)
{
// remove wrapper assembly to ensure a rebuild is performed
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = SolutionTask.Project;
deleteTask.Parent = SolutionTask;
deleteTask.InitializeTaskConfiguration();
deleteTask.File = new FileInfo(WrapperAssembly);
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
public IActionResult Delete(int Id)
{
var q = new DeleteTask(_configuration);
q.RemoveTask(Id);
return(RedirectToAction("YourTasks"));
}
public void Setup()
{
//create base folder for "project"'s local copy
_workingFolder = Path.Combine(Path.GetTempPath(), "FROM_VSS_DELETE");
Directory.CreateDirectory(_workingFolder);
//This item represents the base project item
_project = new MockVssItem();
_project.Name = "TEMPVSSPROJECT";
_project.SetType((int)VSSItemType.VSSITEM_PROJECT);
string localProjectPath = _workingFolder;
Directory.CreateDirectory(localProjectPath);
//create the instance of the DeleteTask that we will use in the tests
_deleteTask = new DeleteTask();
_deleteTask.Item = _project;
_deleteTask.Path = "$/" + _project.Name;
//make the DeleteTask happy by giving it a dummy project file to reference
XmlDocument doc = new XmlDocument();
doc.LoadXml("<project name='test'/>");
_deleteTask.Project = new Project(doc, Level.Info, 0);
}
public void DeleteTask_Action_Fails()
{
// Arrange
var taskDto = TestHelper.TaskDto();
GenericServiceResponse <bool> fakeResponse = null;
mockClientServicesProvider.Setup(x => x.Logger).Returns(mockLogger.Object).Verifiable();
mockClientServicesProvider.Setup(x => x.TaskService.DeleteTask(taskDto)).Returns(fakeResponse).Verifiable();
var viewModel = new GenericViewModel();
var action = new DeleteTask <GenericViewModel>(mockClientServicesProvider.Object)
{
OnComplete = model => viewModel = model
};
// Act
var result = action.Invoke(taskDto);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(GenericViewModel));
Assert.IsNotNull(result.Notifications);
Assert.IsInstanceOfType(result.Notifications, typeof(NotificationCollection));
Assert.IsTrue(result.Notifications.Count() == 1);
Assert.IsTrue(result.HasErrors);
Assert.IsNotNull(result.Success);
Assert.IsInstanceOfType(result.Success, typeof(bool));
Assert.IsFalse(result.Success);
}
public ActionResult DeleteTask(string _TaskId)
{
DeleteTask deleteTask = new DeleteTask();
deleteTask.RemoveTask(Int32.Parse(_TaskId));
return(Json(_TaskId));
}
public Unit Handle(DeleteTask command)
{
var task = _taskRepository.GetById(command.TaskId);
_taskRepository.Delete(task);
return(Unit.Value);
}
public ActionResult <DeleteTaskResponse> Post(DeleteTask request)
{
if (request.Ids != null)
{
host.Connection.Delete(GXDeleteArgs.Delete <GXTask>(q => request.Ids.Contains(q.Id)));
host.SetChange(TargetType.Tasks, DateTime.Now);
}
return(new DeleteTaskResponse());
}
public object Delete(DeleteTask request)
{
var entity = request.ConvertTo <Task>();
return(InTransaction(db =>
{
Logic.Remove(entity);
return new CommonResponse();
}));
}
public DataPortalResult Delete(Type objectType, object criteria, DataPortalContext context)
{
Thread t = new Thread(DoDelete);
DeleteTask task = new DeleteTask();
task.ObjectType = objectType;
task.Criteria = criteria;
task.Context = context;
t.Start(task);
t.Join();
return(task.Result);
}
public async Task Run_ReturnsNoContentOnSuccess()
{
var handler = new Mock <ICommandHander <DeleteTaskCommand> >();
var container = new Container();
var request = new DefaultHttpRequest(new DefaultHttpContext());
var listId = Guid.NewGuid().ToString();
var taskId = Guid.NewGuid().ToString();
handler.Setup(h => h.Execute(It.IsAny <DeleteTaskCommand>())).Returns(Task.CompletedTask);
container.RegisterInstance(handler.Object);
container.RegisterInstance(_telemetryClient);
DeleteTask.Container = container;
var result = await DeleteTask.Run(request, listId, taskId) as NoContentResult;
Assert.IsNotNull(result);
}
public async Task Run_ReturnsServerErrorOnServerError()
{
var handler = new Mock <ICommandHander <DeleteTaskCommand> >();
var container = new Container();
var request = new DefaultHttpRequest(new DefaultHttpContext());
var listId = Guid.NewGuid().ToString();
var taskId = Guid.NewGuid().ToString();
handler.Setup(h => h.Execute(It.IsAny <DeleteTaskCommand>()))
.ThrowsAsync(new Exception());
container.RegisterInstance(handler.Object);
container.RegisterInstance(_telemetryClient);
DeleteTask.Container = container;
var result = await DeleteTask.Run(request, listId, taskId) as InternalServerErrorResult;
Assert.IsNotNull(result);
}
void DoDelete(object state)
{
DeleteTask task = null;
try
{
task = state as DeleteTask;
if (task != null)
{
task.Result = Portal.Delete(task.ObjectType, task.Criteria, task.Context);
}
}
catch (Exception ex)
{
if (task != null)
{
task.ResultException = ex;
}
}
}
/// <summary>
/// hack:删除任务（只在调试中使用）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Btn_Delete_Click(object sender, RoutedEventArgs e)
{
if (MessageBox.Show("是否要进行任务删除处理？", "注意", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
if (Self != null)
{
var temp = DeleteTask?.Invoke(Self);
if (temp == null)
{
MessageBox.Show("未处理任务删除事件");
}
if (temp.Success)
{
MessageBox.Show("任务删除处理成功");
}
else
{
MessageBox.Show($"任务删除失败：{temp.Msg}");
}
}
}
}
public IActionResult DeleteTask([FromBody] DeleteTask deleteTask)
{
if (deleteTask == null)
{
output.status = "Error";
output.description = "send a json file";
}
else
{
try
{
var delete = context.tasks.Where(e =>
e.GuserId == deleteTask.guserId && e.TaskId == deleteTask.taskId && !e.Status).FirstOrDefault();
if (delete == null)
{
output.status = "Error";
output.description = "no task to delete";
}
else
{
//this line deletes the row from the database
//context.tasks.Remove(del);
//status is updated to indicate that the task is completed
delete.Status = true;
context.SaveChanges();
output.status = "success";
output.description = "task deleted successfully";
}
}
catch (Exception e)
{
output.status = "error";
output.description = e.Message;
}
}
return(new JsonResult(output));
}
public async Task <DataPortalResult> Delete(Type objectType, object criteria, DataPortalContext context, bool isSync)
{
var task =
new DeleteTask
{
Criteria = criteria,
Context = context,
ObjectType = objectType
};
if (isSync)
{
DoDelete(task);
}
else
{
await Task.Factory.StartNew(DoDelete, task);
}
if (task.ResultException != null)
{
throw task.ResultException;
}
return(task.Result);
}
public DataPortalResult Delete(Type objectType, object criteria, DataPortalContext context)
{
Thread t = new Thread(DoDelete);
DeleteTask task = new DeleteTask();
task.ObjectType = objectType;
task.Criteria = criteria;
task.Context = context;
t.Start(task);
t.Join();
return task.Result;
}
/// <summary>
/// Converts a single file or group of files.
/// </summary>
protected override void ExecuteTask()
{
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null)
{
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Resources.BaseDirectory == null)
{
Resources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
_arguments = "";
if (Resources.FileNames.Count > 0)
{
if (OutputFile != null)
{
throw new BuildException(ResourceUtils.GetString("NA2026"), Location);
}
foreach (string filename in Resources.FileNames)
{
FileInfo outputFile = GetOutputFile(new FileInfo(Path.Combine(
Path.GetDirectoryName(filename), Resources.GetManifestResourceName(filename))));
if (NeedsCompiling(new FileInfo(filename), outputFile))
{
// ensure output directory exists
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
string cmdLineArg = string.Format(CultureInfo.InvariantCulture,
" \"{0},{1}\"", filename, outputFile.FullName);
// check if adding arguments to compile current resx to
// total command line would cause it to exceed maximum
// length
bool maxCmdLineExceeded = (_arguments.Length + cmdLineArg.Length > _maxCmdLineLength);
// if this is the first resx that we're compiling, or the
// first one of the next execution of the resgen tool, then
// add options to command line
if (StringUtils.IsNullOrEmpty(_arguments) || maxCmdLineExceeded)
{
if (UseSourcePath)
{
if (SupportsExternalFileReferences)
{
cmdLineArg = " /usesourcepath";
}
else
{
Log(Level.Warning, ResourceUtils.GetString(
"String_ResourceCompilerDoesNotSupportExternalReferences"),
Project.TargetFramework.Description);
}
}
cmdLineArg = "/compile" + cmdLineArg;
}
// if maximum length would have been exceeded by compiling
// the current resx file, then first execute the resgen
// tool
if (maxCmdLineExceeded)
{
try {
// call base class to do the work
base.ExecuteTask();
} catch {
// we only need to remove temporary directory when
// an error occurred and if it was actually created
if (_workingDirectory != null)
{
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = new DirectoryInfo(_workingDirectory);
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
// rethrow exception
throw;
}
// reset command line arguments as we've processed them
_arguments = string.Empty;
}
// append command line arguments to compile current resx
// file to the total command line
AppendArgument(cmdLineArg);
}
}
}
else
{
// Single file situation
if (InputFile == null)
{
throw new BuildException(ResourceUtils.GetString("NA2027"), Location);
}
FileInfo outputFile = GetOutputFile(InputFile);
if (NeedsCompiling(InputFile, outputFile))
{
// ensure output directory exists
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
if (UseSourcePath)
{
if (SupportsExternalFileReferences)
{
AppendArgument("/usesourcepath");
}
else
{
Log(Level.Warning, ResourceUtils.GetString(
"String_ResourceCompilerDoesNotSupportExternalReferences"),
Project.TargetFramework.Description);
}
}
AppendArgument(string.Format(CultureInfo.InvariantCulture,
" \"{0}\" \"{1}\"", InputFile.FullName, outputFile.FullName));
}
}
if (!StringUtils.IsNullOrEmpty(_arguments))
{
try {
// call base class to do the work
base.ExecuteTask();
} finally {
// we only need to remove temporary directory if it was
// actually created
if (_workingDirectory != null)
{
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = new DirectoryInfo(_workingDirectory);
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
}
/// <summary>
/// Converts a single file or group of files.
/// </summary>
protected override void ExecuteTask()
{
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null)
{
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
if (Resources.BaseDirectory == null)
{
Resources.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// clear buffer
_arguments.Length = 0;
if (Resources.FileNames.Count > 0 || QualifiedResources.Count > 0)
{
if (OutputFile != null)
{
throw new BuildException(ResourceUtils.GetString("NA2026"), Location);
}
foreach (string fileName in Resources.FileNames)
{
FileInfo inputFile = new FileInfo(fileName);
FileInfo outputFile = GetOutputFile(new FileInfo(Path.Combine(
inputFile.DirectoryName, Resources.GetManifestResourceName(fileName))));
WriteCommandLineOptions(inputFile, outputFile);
}
// used by <solution> task
foreach (QualifiedResource resource in QualifiedResources)
{
WriteCommandLineOptions(resource.Input, resource.Output);
}
}
else
{
// Single file situation
if (InputFile == null)
{
throw new BuildException(ResourceUtils.GetString("NA2027"), Location);
}
FileInfo outputFile = GetOutputFile(InputFile);
if (NeedsCompiling(InputFile, outputFile))
{
// ensure output directory exists
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
if (UseSourcePath)
{
if (SupportsExternalFileReferences)
{
_arguments.Append("/useSourcePath");
}
else
{
Log(Level.Warning, ResourceUtils.GetString(
"String_ResourceCompilerDoesNotSupportExternalReferences"),
Project.TargetFramework.Description);
}
}
_arguments.Append(string.Format(CultureInfo.InvariantCulture,
" \"{0}\" \"{1}\"", InputFile.FullName, outputFile.FullName));
}
}
if (_arguments.Length != 0)
{
try {
// call base class to do the work
base.ExecuteTask();
} finally {
// we only need to remove temporary directory if it was
// actually created
if (_workingDirectory != null)
{
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = _workingDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
}
public async Task <Unit> DeleteTaskAsync([FromBody] DeleteTask deleteTask)
{
return(await _mediator.Send(deleteTask));
}
public async Task<DataPortalResult> Delete(Type objectType, object criteria, DataPortalContext context, bool isSync)
{
var task =
new DeleteTask
{
Criteria = criteria,
Context = context,
ObjectType = objectType
};
if (isSync)
DoDelete(task);
else
await Task.Factory.StartNew(DoDelete, task);
if (task.ResultException != null)
throw task.ResultException;
return task.Result;
}
public async Task <IActionResult> DeleteTask([FromRoute] DeleteTask command)
{
await _mediator.Send(command);
return(Deleted());
}
/// <summary>
/// Registers or unregisters a single assembly, or a group of assemblies.
/// </summary>
protected override void ExecuteTask()
{
if (AssemblyFile == null && Assemblies.FileNames.Count == 0)
{
return;
}
// when reference assembly are specified, we copy all references
// and all assemblies to a temp directory and run regasm from there
if (References.FileNames.Count != 0)
{
// use a newly created temporary directory as working directory
BaseDirectory = FileUtils.GetTempDirectory();
}
if (Unregister)
{
_arguments.Append(" /unregister");
}
if (TypeLib != null)
{
_arguments.AppendFormat(CultureInfo.InvariantCulture,
" /tlb:\"{0}\"", TypeLib.FullName);
}
if (CodeBase)
{
_arguments.Append(" /codebase");
}
if (RegistryFile != null)
{
_arguments.AppendFormat(CultureInfo.InvariantCulture,
" /regfile:\"{0}\"", RegistryFile.FullName);
}
if (Registered)
{
_arguments.Append(" /registered");
}
if (Verbose)
{
_arguments.Append(" /verbose");
}
else
{
_arguments.Append(" /silent");
}
_arguments.Append(" /nologo");
if (AssemblyFile != null)
{
Log(Level.Info, "{0} '{1}' for COM Interop",
Unregister ? "Unregistering" : "Registering",
AssemblyFile.FullName);
_arguments.AppendFormat(" \"{0}\"", GetAssemblyPath(
AssemblyFile.FullName));
}
else
{
// display build log message
Log(Level.Info, "{0} {1} files for COM interop",
Unregister ? "UnRegistering" : "Registering",
Assemblies.FileNames.Count);
// add files to command line
foreach (string path in Assemblies.FileNames)
{
Log(Level.Verbose, "{0} '{1}' for COM Interop",
Unregister ? "UnRegistering" : "Registering",
path);
_arguments.AppendFormat(" \"{0}\"", GetAssemblyPath(path));
}
}
try {
// call base class to do the work
base.ExecuteTask();
} finally {
// we only need to remove temporary directory if it was
// actually created
if (_workingDirectory != null)
{
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = _workingDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
private void WriteCommandLineOptions(FileInfo inputFile, FileInfo outputFile)
{
if (!NeedsCompiling(inputFile, outputFile))
{
return;
}
// ensure output directory exists
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
string cmdLineArg = string.Format(CultureInfo.InvariantCulture,
"\"{0},{1}\" ", inputFile, outputFile.FullName);
// check if adding arguments to compile current resx to
// total command line would cause it to exceed maximum
// length
bool maxCmdLineExceeded = (_arguments.Length + cmdLineArg.Length > _maxCmdLineLength);
// if this is the first resx that we're compiling, or the
// first one of the next execution of the resgen tool, then
// add options to command line
if (_arguments.Length == 0 || maxCmdLineExceeded)
{
StringBuilder sb = new StringBuilder();
// bug #1415272: first write assembly references, to make sure these
// are taken into account when calculating the length of the command
// line
if (SupportsAssemblyReferences)
{
foreach (string assembly in Assemblies.FileNames)
{
sb.AppendFormat(CultureInfo.InvariantCulture,
"/r:\"{0}\" ", assembly);
}
}
if (UseSourcePath)
{
if (SupportsExternalFileReferences)
{
sb.Append("/useSourcePath ");
}
else
{
Log(Level.Warning, ResourceUtils.GetString(
"String_ResourceCompilerDoesNotSupportExternalReferences"),
Project.TargetFramework.Description);
}
}
sb.Append("/compile ");
sb.Append(cmdLineArg);
cmdLineArg = sb.ToString();
}
// if maximum length would have been exceeded by compiling
// the current resx file, then first execute the resgen
// tool
if (maxCmdLineExceeded)
{
try {
// call base class to do the work
base.ExecuteTask();
} catch {
// we only need to remove temporary directory when
// an error occurred and if it was actually created
if (_workingDirectory != null)
{
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = _workingDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
// rethrow exception
throw;
}
// reset command line arguments as we've processed them
_arguments.Length = 0;
}
// append command line arguments to compile current resx
// file to the total command line
_arguments.Append(cmdLineArg);
}
/// <summary>
/// Generates the license file.
/// </summary>
protected override void ExecuteTask()
{
FileInfo licensesFile = null;
// ensure base directory is set, even if fileset was not initialized
// from XML
if (Assemblies.BaseDirectory == null)
{
Assemblies.BaseDirectory = new DirectoryInfo(Project.BaseDirectory);
}
// get the output .licenses file
if (OutputFile == null)
{
try {
licensesFile = new FileInfo(Project.GetFullPath(Target + ".licenses"));
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2015"), Target), Location, ex);
}
}
else
{
licensesFile = OutputFile;
}
// make sure the directory for the .licenses file exists
if (!licensesFile.Directory.Exists)
{
licensesFile.Directory.Create();
}
// determine whether .licenses file need to be recompiled
if (!NeedsCompiling(licensesFile))
{
return;
}
Log(Level.Verbose, ResourceUtils.GetString("String_CompilingLicenseUsingTarget"),
InputFile.FullName, licensesFile.FullName, Target);
if (HasCommandLineCompiler)
{
// the command line compiler does not allow us to specify the
// full path to the output file, so we have it create the licenses
// file in a temp directory, and copy it to its actual output
// location
// use a newly created temporary directory as working directory
BaseDirectory = FileUtils.GetTempDirectory();
try {
// set target assembly for generated licenses file
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/target:\"{0}\"", Target)));
// set input filename
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/complist:\"{0}\"", InputFile.FullName)));
// set output directory
Arguments.Add(new Argument(string.Format(CultureInfo.InvariantCulture,
"/outdir:\"{0}\"", BaseDirectory.FullName)));
// suppress display of startup banner
Arguments.Add(new Argument("/nologo"));
// adjust verbosity of tool if necessary
if (Verbose)
{
Arguments.Add(new Argument("/v"));
}
// use command line tool to compile licenses file
base.ExecuteTask();
// delete any existing output file
if (File.Exists(licensesFile.FullName))
{
File.Delete(licensesFile.FullName);
}
// copy licenses file to output file (with overwrite)
File.Copy(Path.Combine(BaseDirectory.FullName, Target + ".licenses"),
licensesFile.FullName, true);
} finally {
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = BaseDirectory;
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
else
{
// create new domain
#if (NET_4_0)
AppDomain newDomain = AppDomain.CreateDomain("LicenseGatheringDomain");
LicenseGatherer licenseGatherer = (LicenseGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(LicenseGatherer).Assembly.FullName,
typeof(LicenseGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0]);
#else
AppDomain newDomain = AppDomain.CreateDomain("LicenseGatheringDomain",
AppDomain.CurrentDomain.Evidence);
LicenseGatherer licenseGatherer = (LicenseGatherer)
newDomain.CreateInstanceAndUnwrap(typeof(LicenseGatherer).Assembly.FullName,
typeof(LicenseGatherer).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
#endif
licenseGatherer.CreateLicenseFile(this, licensesFile.FullName);
// unload newly created domain
AppDomain.Unload(newDomain);
}
}
private void MenuItemDeleteTask_OnClick(object sender, RoutedEventArgs e)
{
CommonMethods.WorkWithTables.Delete(thisTask, httpClientProvider.GetDatabaseTaskEditor(), task => task.TaskId, () => DeleteTask?.Invoke(this, default(EventArgs)));
}
public ExecutionResult DeleteTask(DeleteTask command)
{
return(Execute(command));
}
public void DeleteFile(string path)
{
DeleteTask t = new DeleteTask(path);
t.Run();
this.history.Push(t);
}
/// <summary>
/// Executes the task.
/// </summary>
/// <exception cref="BuildException">
/// Project build failed.
/// </exception>
protected override void ExecuteTask()
{
Log(Level.Info, "Starting solution build.");
if (SolutionFile != null)
{
if (!SolutionFile.Exists)
{
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Couldn't find solution file '{0}'.", SolutionFile.FullName),
Location);
}
}
if (Projects.FileNames.Count > 0)
{
Log(Level.Verbose, "Included projects:");
foreach (string projectFile in Projects.FileNames)
{
Log(Level.Verbose, " - {0}", projectFile);
}
}
if (ReferenceProjects.FileNames.Count > 0)
{
Log(Level.Verbose, "Reference projects:");
foreach (string projectFile in ReferenceProjects.FileNames)
{
Log(Level.Verbose, " - {0}", projectFile);
}
}
string basePath = null;
try {
using (TempFileCollection tfc = new TempFileCollection()) {
// store the temp dir so we can clean it up later
basePath = tfc.BasePath;
// ensure temp directory exists
if (!Directory.Exists(tfc.BasePath))
{
Directory.CreateDirectory(tfc.BasePath);
}
// create temporary domain
PermissionSet tempDomainPermSet = new PermissionSet(PermissionState.Unrestricted);
AppDomain temporaryDomain = AppDomain.CreateDomain("temporaryDomain", AppDomain.CurrentDomain.Evidence,
AppDomain.CurrentDomain.SetupInformation, tempDomainPermSet);
try {
ReferencesResolver referencesResolver =
((ReferencesResolver)temporaryDomain.CreateInstanceFrom(Assembly.GetExecutingAssembly().Location,
typeof(ReferencesResolver).FullName).Unwrap());
using (GacCache gacCache = new GacCache(this.Project)) {
SolutionBase sln = SolutionFactory.LoadSolution(this,
tfc, gacCache, referencesResolver);
if (!sln.Compile(_configuration))
{
throw new BuildException("Project build failed.", Location);
}
}
} finally {
// unload temporary domain
AppDomain.Unload(temporaryDomain);
}
}
} finally {
if (basePath != null && Directory.Exists(basePath))
{
Log(Level.Debug, "Cleaning up temp folder '{0}'.", basePath);
// delete temporary directory and all files in it
DeleteTask deleteTask = new DeleteTask();
deleteTask.Project = Project;
deleteTask.Parent = this;
deleteTask.InitializeTaskConfiguration();
deleteTask.Directory = new DirectoryInfo(basePath);
deleteTask.Threshold = Level.None; // no output in build log
deleteTask.Execute();
}
}
}
void DoDelete(object state)
{
DeleteTask task = state as DeleteTask;
task.Result = Portal.Delete(task.ObjectType, task.Criteria, task.Context);
}