/// <summary>
/// Rebuilds assembly given the dirty files.
/// </summary>
/// <param name="filesToCompile">Dirty files to be recompiled in new assembly.</param>
/// <returns>Path of the new assembly.</returns>
private string rebuildAssembly(List <string> filesToCompile)
{
if (project.IsStartable)
{
NewAssemblyName = project.AssemblyName + "_enc.exe";
}
else
{
NewAssemblyName = project.AssemblyName + "_enc.dll";
}
string path = TemporaryPath + NewAssemblyName;
CompilerErrors errs = CSharpBackgroundCompiler.RecompileWithName(path, filesToCompile);
CompileSuccessful = (errs != null && !errs.HasErrors);
WorkbenchSingleton.SafeThreadAsyncCall(
delegate() {
if (!CompileSuccessful && errs != null)
{
foreach (CompilerError err in errs)
{
BuildError error = new BuildError(err.FileName, err.Line, err.Column, err.ErrorNumber, err.ErrorText);
error.IsWarning = err.IsWarning;
TaskService.Add(new Task(error));
}
}
else
{
TaskService.Clear();
}
}
);
return(path);
}
/// <summary>
/// Starts to run a build inside the SharpDevelop GUI.
/// Only one build can run inside the GUI at one time.
/// </summary>
/// <param name="project">The project/solution to build.</param>
/// <param name="options">The build options.</param>
public static void BuildInGui(IBuildable project, BuildOptions options)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
WorkbenchSingleton.AssertMainThread();
if (guiBuildCancellation != null)
{
BuildResults results = new BuildResults();
WorkbenchSingleton.StatusBar.SetMessage(Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
BuildError error = new BuildError(null, Core.ResourceService.GetString("MainWindow.CompilerMessages.MSBuildAlreadyRunning"));
results.Add(error);
TaskService.Add(new Task(error));
results.Result = BuildResultCode.MSBuildAlreadyRunning;
if (options.Callback != null)
{
options.Callback(results);
}
}
else
{
guiBuildCancellation = new CancellationTokenSource();
IProgressMonitor progressMonitor = WorkbenchSingleton.StatusBar.CreateProgressMonitor(guiBuildCancellation.Token);
guiBuildTrackedFeature = AnalyticsMonitorService.TrackFeature("ICSharpCode.SharpDevelop.Project.BuildEngine.Build");
WorkbenchSingleton.StatusBar.SetMessage(StringParser.Parse("${res:MainWindow.CompilerMessages.BuildVerb}..."));
ProjectService.RaiseEventBuildStarted(new BuildEventArgs(project, options));
StartBuild(project, options,
new MessageViewSink(TaskService.BuildMessageViewCategory, progressMonitor, WorkbenchSingleton.StatusBar));
}
}
public IActionResult Task(Task task)
{
var userId = User.GetUserId();
task.UserId = userId;
if (!ModelState.IsValid)
{
var vm = new TaskViewModel
{
Task = task,
Heading = task.Id == 0 ?
"Dodawanie nowego zadania" : "Edytowanie zadania",
Categories = _taskService.GetCategories()
};
return(View("Task", vm));
}
if (task.Id == 0)
{
_taskService.Add(task);
}
else
{
_taskService.Update(task);
}
return(RedirectToAction("Tasks"));
}
public void ReportError(BuildError error)
{
WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
TaskService.Add(new Task(error));
});
}
/// <summary>
/// Displays the output from NAnt after it has exited.
/// </summary>
/// <param name="sender">The event source.</param>
/// <param name="e">The NAnt exit event arguments.</param>
void NAntExited(object sender, NAntExitEventArgs e)
{
// Update output window.
string outputText = String.Empty;
System.Diagnostics.Debug.Assert(e.Error.Length == 0);
outputText = String.Concat(outputText, e.Output);
// Update task list.
TaskCollection tasks = NAntOutputParser.Parse(outputText);
foreach (SDTask task in tasks)
{
SD.MainThread.InvokeAsyncAndForget(() => TaskService.Add(task));
}
// Bring task list to front.
if (tasks.Count > 0 && ErrorListPad.ShowAfterBuild)
{
PadDescriptor padDescriptor = SD.Workbench.GetPad(typeof(ErrorListPad));
if (padDescriptor != null)
{
SD.MainThread.InvokeAsync(padDescriptor.BringPadToFront);
}
}
}
public void Edit()
{
var task = TaskService.Add(new Task
{
IsActive = true,
Name = "test123",
EstimatedSeconds = 3600,
WorkspaceId = DefaultWorkspaceId,
ProjectId = DefaultProjectId
});
Assert.IsNotNull(task);
var loadedTask = TaskService.Get(task.Id.Value);
loadedTask.Name = "test2";
var editedTask = TaskService.Edit(loadedTask);
Assert.IsNotNull(editedTask);
Assert.AreEqual(task.Id, editedTask.Id);
Assert.AreEqual(task.IsActive, editedTask.IsActive);
Assert.AreEqual(loadedTask.Name, editedTask.Name);
Assert.AreEqual(task.EstimatedSeconds, editedTask.EstimatedSeconds);
Assert.AreEqual(task.WorkspaceId, editedTask.WorkspaceId);
Assert.AreEqual(task.ProjectId, editedTask.ProjectId);
Assert.AreEqual(1, WorkspaceService.Tasks(DefaultWorkspaceId).Count);
}
public ActionResult Create(TaskModel taskmodel)
{
var idP = Session["idProject"] as List <int>;
taskmodel.idProject = idP.First();
task taskToAdd = new task
{
Description = taskmodel.Description,
idProject = taskmodel.idProject,
id_user = taskmodel.id_user,
DeadLine = taskmodel.DeadLine,
StartDate = taskmodel.StartDate,
state = taskmodel.state
};
taskservice.Add(taskToAdd);
taskservice.commit();
taskservice.Dispose();
return(RedirectToAction("AllTasks", new { idProject = idP.First() }));
}
/// <summary>
/// Called by derived classes to show a single test result.
/// </summary>
protected void ShowResult(TestResult result)
{
if (result.IsFailure || result.IsIgnored)
{
TaskService.Add(CreateTask(result));
}
UpdateTestResult(result);
}
// POST: Task?tenant_id
public void Post(string tenant_id, [FromBody] DOMAIN.Entities.Task t)
{
//ID = AutoIncrement & Owner = tenant_id.
t.Owner = tenant_id;
TaskService.Add(t);
TaskService.Commit();
}
public void ShowErrors(CompilerErrorCollection errors)
{
TaskService.ClearExceptCommentTasks();
foreach (CompilerError error in errors)
{
TaskService.Add(new CompilerErrorTask(error));
}
WorkbenchSingleton.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
}
public void GetTimeEntriesByTaskId()
{
var task1 = TaskService.Add(new Task
{
IsActive = true,
Name = "task1",
EstimatedSeconds = 3600,
WorkspaceId = DefaultWorkspaceId,
ProjectId = DefaultProjectId
});
Assert.IsNotNull(task1);
var task2 = TaskService.Add(new Task
{
IsActive = true,
Name = "task2",
EstimatedSeconds = 3600,
WorkspaceId = DefaultWorkspaceId,
ProjectId = DefaultProjectId
});
Assert.IsNotNull(task2);
for (int i = 0; i < 3; i++)
{
var timeEntry = TimeEntryService.Add(new TimeEntry()
{
IsBillable = true,
CreatedWith = "TogglAPI.Net",
Duration = 900,
Start = DateTime.Now.ToIsoDateStr(),
WorkspaceId = DefaultWorkspaceId,
TaskId = task1.Id
});
Assert.IsNotNull(timeEntry);
}
for (int i = 0; i < 3; i++)
{
var timeEntry = TimeEntryService.Add(new TimeEntry()
{
IsBillable = true,
CreatedWith = "TogglAPI.Net",
Duration = 900,
Start = DateTime.Now.ToIsoDateStr(),
WorkspaceId = DefaultWorkspaceId,
TaskId = task2.Id
});
Assert.IsNotNull(timeEntry);
}
Assert.AreEqual(3, TimeEntryService.List().Count(te => te.TaskId == task1.Id));
Assert.AreEqual(3, TimeEntryService.List().Count(te => te.TaskId == task2.Id));
}
public AssemblyDefinition TryResolve(AssemblyNameReference reference)
{
try {
return(Resolve(reference));
} catch (AssemblyResolutionException are) {
LoggingService.DebugFormatted("CQA: Skipping assembly reference: {0}\r\nException:\r\n{1}", reference, are);
TaskService.Add(new Task(null, are.Message, 0, 0, TaskType.Warning));
return(null);
}
}
public ActionResult Create([Bind(Include = "Id,Titulo,Descricao,DataExecucao")] Task task)
{
if (ModelState.IsValid)
{
taskService.Add(task);
return(RedirectToAction("Index"));
}
return(View(task));
}
public async void SettingTaskStateToComplete_AlsoSetsAllParentProjectsStatesToComplete_WhenAllProjectTasksComplete()
{
var db = UnitTestHelper.CreateInMemoryDb(); //ensure that we have same db in the scope of the test
await using (var context = db.CreateContext())
{
//arrange
var projectService = new ProjectService(context, UnitTestHelper.Mapper);
await projectService.Add(DataSeeder.NewProject(3));
await projectService.Add(DataSeeder.NewProject(6, 3));
await projectService.Add(DataSeeder.NewProject(9, 6));
var taskService = new TaskService(context, UnitTestHelper.Mapper);
await taskService.Add(DataSeeder.NewTask(9, 9));
await taskService.Add(DataSeeder.NewTask(3, 3));
//act
var task = DataSeeder.NewTask(9, 9);
task.State = ItemState.Completed;
await taskService.UpdateOrThrow(task);
}
//assert
await using (var context = db.CreateContext())
{
var projectService = new ProjectService(context, UnitTestHelper.Mapper);
var project = await projectService.GetOrThrow(9);
project.State.Should().Be(ItemState.Completed);
project = await projectService.GetOrThrow(6);
project.State.Should().Be(ItemState.Completed);
project = await projectService.GetOrThrow(3);
project.State.Should().Be(ItemState.Planned);
}
}
public void Save()
{
try
{
var IsSaved = ObjTaskService.Add(CurrentTask);
LoadData();
}
catch (Exception ex)
{
}
}
private string addTask(ClientProcess clientProcess, int AssignTo)
{
TaskCard taskCard = getTaskCard(AssignTo, clientProcess);
TaskService taskService = new TaskService();
taskService.Add(taskCard);
System.Threading.Thread.Sleep(1000);
int taskId = getTaskID(taskCard);
DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_TASKID, taskCard.TaskId + "-" + taskId, taskId), true);
return(taskCard.TaskId + "-" + taskId);
}
/// <summary>
/// Enlist errors in ErrorList in SharpDevelop
/// </summary>
/// <param name="errors">List of errors</param>
private void showErrors(List <BuildError> errors)
{
WorkbenchSingleton.SafeThreadAsyncCall(
delegate()
{
TaskService.Clear();
foreach (BuildError error in errors)
{
TaskService.Add(new Task(error));
}
}
);
}
public ActionResult Create([Bind(Include = "TaskID,TaskName,Description,ProjectCode,Plan,Goals,Requirement,Tools,StartDate,DeadLine,EstimatedTime,Complexity,TeamLeaderCode")] Task Task)
{
if (ModelState.IsValid)
{
Task.State = StateEnum.ToDo;
Task.Owner = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
TaskService.Add(Task);
TaskService.Commit();
return(RedirectToAction("Index"));
}
return(View(Task));
}
public void Add()
{
var task = TaskService.Add(new Task
{
IsActive = true,
Name = "test123",
EstimatedSeconds = 3600,
WorkspaceId = DefaultWorkspaceId,
ProjectId = DefaultProjectId
});
Assert.IsNotNull(task);
Assert.AreEqual(1, WorkspaceService.Tasks(DefaultWorkspaceId).Count);
}
// POST: api/Task (Adicionar um objeto)
public IHttpActionResult Post([FromBody] TaskModel model)
{
try
{
service.Add(model);
return(Ok());
}
catch (Exception)
{
// coloca m log com o erro especifico
return(BadRequest());
}
}
/// <summary>
/// Adds error to error list window.
/// </summary>
static void AddError(string fileName, Exception ex)
{
int column = 0;
int line = 0;
XmlException xmlEx = ex as XmlException;
if (xmlEx != null)
{
column = xmlEx.LinePosition - 1;
line = xmlEx.LineNumber - 1;
}
LoggingService.Debug(ex.ToString());
TaskService.Add(new Task(fileName, ex.Message, column, line, TaskType.Error));
}
public async void DeletingTask_SetsSubtasksParentProjectTaskIdToNull()
{
var db = UnitTestHelper.CreateInMemoryDb(); //ensure that we have same db in the scope of the test
await using (var context = db.CreateContext())
{
//arrange
var projectService = new ProjectService(context, UnitTestHelper.Mapper);
await projectService.Add(DataSeeder.NewProject(3));
var taskService = new TaskService(context, UnitTestHelper.Mapper);
await taskService.Add(DataSeeder.NewTask(3, 3));
await taskService.Add(DataSeeder.NewTask(33, 3, 3));
await taskService.Add(DataSeeder.NewTask(333, 3, 3));
//act
var task = DataSeeder.NewTask(3, 3);
await taskService.DeleteOrThrow(task.Id);
}
//assert
await using (var context = db.CreateContext())
{
var tasksService = new TaskService(context, UnitTestHelper.Mapper);
var task = await tasksService.Get(33);
task.ParentTaskId.Should().BeNull();
task = await tasksService.Get(333);
task.ParentTaskId.Should().BeNull();
}
}
public static void ShowResults(BuildResults results)
{
if (results != null)
{
TaskService.InUpdate = true;
foreach (BuildError error in results.Errors)
{
TaskService.Add(new Task(error));
}
TaskService.InUpdate = false;
if (results.Errors.Count > 0 && ErrorListPad.ShowAfterBuild)
{
WorkbenchSingleton.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
}
}
}
public ActionResult Create(task tsk, int id_event)
{
int id_user = Convert.ToInt32(User.Identity.GetUserId());
tsk.assignBy = id_user;
tsk.event_id = id_event;
tsk.statutTask = "waiting";
tsk.organizer_id = tsk.orderTo;
if (ModelState.IsValid)
{
TaskService tskservice = new TaskService();
tskservice.Add(tsk);
tskservice.Commit();
}
return(RedirectToAction("Index"));
}
public void AddTask()
{
var t = new TaskService();
var act = new Task
{
IsActive = true,
UserId = Constants.DefaultUserId,
Name = "test123",
EstimatedSeconds = 3600,
ProjectId = Constants.DefaultProjectId
};
var exp = t.Add(act);
Assert.AreEqual(exp, act);
}
public async void PostingTask_ShouldAddTaskToDb()
{
var db = UnitTestHelper.CreateInMemoryDb();
await using (var context = db.CreateContext())
{
context.Tasks.Should().BeEmpty();
var taskService = new TaskService(context, UnitTestHelper.Mapper);
await taskService.Add(DataSeeder.NewTask(3, 3));
}
await using (var context = db.CreateContext())
{
context.Tasks.Should().HaveCount(1);
}
}
public void AddTest()
{
var mockSet = new Mock <DbSet <tblTask> >();
var mockContext = new Mock <ProjectTaskManagerEntities>();
mockContext.Setup(m => m.tblTasks).Returns(mockSet.Object);
var service = new TaskService(mockContext.Object);
service.Add(new TaskDO()
{
TaskId = 12
});
mockSet.Verify(m => m.Add(It.IsAny <tblTask>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public void TaskService_Add_Returns_ParamaterItself()
{
// Arrange
var service = new TaskService(mockTaskRepo.Object, mockStateChangeRepo.Object);
var stateData = new TaskDto
{
Id = Guid.NewGuid(),
Title = "Test Flow"
};
// Act
var state = service.Add(stateData);
// Assert
Assert.IsNotNull(state);
Assert.AreEqual(stateData.Id, state.Id);
Assert.AreEqual(stateData.Title, state.Title);
}
public Result <int> Add(TaskCard taskCard)
{
var result = new Result <int>();
try
{
TaskService taskService = new TaskService();
result.Value = taskService.Add(taskCard);
result.IsSuccess = true;
return(result);
}
catch (Exception exception)
{
result.IsSuccess = false;
result.ExceptionInfo = exception;
}
return(result);
}
public void Task_Service_Add_Method_Throws_FormatException_With_InvalidValue_Type()
{
//Arrange
TaskBacklog Backlog = new TaskBacklog();
Backlog.SprintId = 1;
TaskBacklog Backlog1 = new TaskBacklog();
Backlog.SprintId = 2;
var request = new TaskBacklog();
var mockRepo = new Mock <ITaskRepository>();
mockRepo.Setup(x => x.Add(Backlog)).Throws(new FormatException());
TaskService obj = new TaskService(mockRepo.Object);
var exception = Record.Exception(() => obj.Add(Backlog));
Assert.IsType <FormatException>(exception);
}
