/// <summary>
/// 传入项目ID 分组ID 得到此条件下的全部任务 列表
/// </summary>
/// <param name="projId"></param>
/// <param name="groupId"></param>
/// <returns></returns>
public ActionResult GetTaskByProjIdAndGroupId(int projId, int groupId)
{
RRWMEntities er = new RRWMEntities();
//获取这个groupID下的全部的用户ID
List<string> idString = new List<string>();
UserService us = new UserService();
List<User> userList = us.FindUsersByGroupId(groupId);
foreach (var u in userList)
{
idString.Add(u.Id);
}
//过滤结果
TaskService ts = new TaskService(er);
List<Task> list = ts.FindByProjectID(projId).ToList();
List<Task> resultList = new List<Task>();
foreach (var l in list)
{
if (idString.Contains(l.TaskerID) && l.TaskProcessStatus == EnumTaskProcessStatus.None)
{
resultList.Add(l);
}
}
List<ComplexTask> comList = ConvertToComplexTaskList(resultList);
return Json(comList);
}
public void CreationTest()
{
var dbContext = new TaskerDbContext();
var service = new TaskService(dbContext);
Assert.IsNotNull(service);
}
public void Execute(IJobExecutionContext context)
{
int @int = context.get_JobDetail().get_JobDataMap().GetInt("Id");
TaskDetail task = TaskSchedulerFactory.GetScheduler().GetTask(@int);
if (task == null)
{
throw new System.ArgumentException("Not found task ：" + task.Name);
}
TaskService taskService = new TaskService();
task.IsRunning = true;
System.DateTime utcNow = System.DateTime.UtcNow;
try
{
ITask task2 = (ITask)System.Activator.CreateInstance(System.Type.GetType(task.ClassType));
task2.Execute(task);
task.LastIsSuccess = new bool?(true);
}
catch (System.Exception exception)
{
LoggerFactory.GetLogger().Error(exception, string.Format("Exception while running job {0} of type {1}", context.get_JobDetail().get_Key(), context.get_JobDetail().get_JobType().ToString()));
task.LastIsSuccess = new bool?(false);
}
task.IsRunning = false;
task.LastStart = new System.DateTime?(utcNow);
if (context.get_NextFireTimeUtc().HasValue)
{
task.NextStart = new System.DateTime?(context.get_NextFireTimeUtc().Value.UtcDateTime);
}
else
{
task.NextStart = null;
}
task.LastEnd = new System.DateTime?(System.DateTime.UtcNow);
taskService.SaveTaskStatus(task);
}
private void UpdateTaskStatus()
{
var tS = new TaskService();
var task = tS.UpdateTask(currentID % 10);
currentID++;
Clients.All.updateTaskStatus(task);
}
/// <summary>
/// We have to keep the parameterless constructor
/// or else VS.Net designer will complain
/// </summary>
/// <param name="kernel">Kernel instance</param>
public MainForm(TimeRecordService timeRecordService, TaskService taskService, IKernel kernel) : this()
{
this.timeRecordService = timeRecordService;
this.taskService = taskService;
this.kernel = kernel;
UpdateButtonsState();
}
/// <summary>
/// 传入成员ID得到此成员全部状态任务列表
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public ActionResult GetTasksByUserId(string userId)
{
RRWMEntities er = new RRWMEntities();
TaskService ts = new TaskService(er);
List<Task> list = ts.FindByUserID(userId);
List<ComplexTask> comList = ConvertToComplexTaskList(list);
return Json(comList);
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
private void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
TaskService service = new TaskService();
dgTasks.DataSource = service.GetByUser(Global.LoggedInUser.ID);
dgTasks.DataBind();
}
}
//任意状态任务
/// <summary>
/// 根据一个taskID得到一个task
/// </summary>
/// <param name="taskId"></param>
/// <returns></returns>
public ActionResult GetTaskByTaskId(string taskId)
{
RRWMEntities er = new RRWMEntities();
TaskService ts = new TaskService(er);
Task task = ts.FindById(taskId);
List<Task> list = new List<Task>();
list.Add(task);
List<ComplexTask> comList = ConvertToComplexTaskList(list);
return Json(comList);
}
/// <summary>
///获取有 任意状态 任务的全部成员列表
/// </summary>
/// <returns></returns>
public List<User> GetUsersContainsTasks()
{
TaskService ts = new TaskService();
Dictionary<User, int> dictionary = ts.FindUserIDsAndTaskCountWithTaskProcessStatus(null, t => t != null);
List<User> list = new List<User>();
foreach (var i in dictionary.Keys)
{
list.Add(i);
}
return list;
}
/// <summary>
///获取有 待确认 任务的全部成员列表
/// </summary>
/// <returns></returns>
public List<User> GetUsersContainsTasksUnconfirmed()
{
TaskService ts = new TaskService();
EnumTaskProcessStatus status = EnumTaskProcessStatus.None;
Dictionary<User, int> dictionary = ts.FindUserIDsAndTaskCountWithTaskProcessStatus(status, t => t != null);//找出所有有待确认任务的Dictionary
List<User> list = new List<User>();
foreach (var i in dictionary.Keys)
{
list.Add(i);
}
return list;//遍历全部键值对，取出全部成员内容，组成列表，返回
}
public void Assign()
{
TaskService target = new TaskService();
Task task = (Task) CreateRecord();
Insert(task);
target.Assign(task.ID, _developer.ID);
Assert.AreEqual(1, target.GetByUser(_developer.ID).Count);
target.Unassign(task.ID);
}
public static void Init()
{
return;
service = new TaskService();
service.Start(box =>
{
TaskClient taskClient = new TaskClient();
box.OnNotifing += box_OnNotifing;
box.OnTaskExecuting += taskClient.Execute;
});
RegistDropMemoryTask();
}
public void GetAssigned()
{
TaskService target = new TaskService();
for (int i = 0; i < 5; i++)
{
InsertAndAssign(_developer);
}
Collection<Task> actual = target.GetByUser(_developer.ID);
Assert.AreEqual(5, actual.Count);
foreach (Task task in actual)
{
target.Unassign(task.ID);
}
}
public void GetByModule()
{
for (int i = 0; i < 10; i++)
{
Insert(CreateRecord());
}
TaskService target = new TaskService();
Collection<Task> actual = target.GetByModule(_module.ID);
Assert.GreaterOrEqual(actual.Count, 10);
foreach (Task task in actual)
{
Assert.AreEqual(_module.ID, task.ModuleID);
}
}
public ServiceList(string url, ResponseToken token)
{
this.eventService = new EventService(url, token);
this.categoryService = new CategoryService(url, token);
this.clubService = new ClubService(url, token);
this.userService = new UserService(url, token);
this.ticketService = new TicketService(url, token);
this.meetingService = new MeetingService(url, token);
this.invoiceService = new InvoiceService(url, token);
this.groupService = new GroupService(url, token);
this.expenseService = new ExpenseService(url, token);
this.emailService = new EmailService(url, token);
this.depositService = new DepositService(url, token);
this.customFieldService = new CustomFieldService(url, token);
this.taskService = new TaskService(url, token);
this.contactService = new ContactService(url, token);
}
//TODO: use and test ~/Controls/Report.ascx
/// <summary>
/// Fills the form with the given item.
/// </summary>
/// <param name="item">The item.</param>
public void FillForm(ProjectItem item)
{
if (item != null)
{
lblType.Text = item.Type.ToString();
lblName.Text = item.Name;
lblDescription.Text = item.Description;
lblStartDate.Text = Utility.MaskNull(item.StartDate);
lblExpEndDate.Text = Utility.MaskNull(item.ExpEndDate);
lblActEndDate.Text = Utility.MaskNull(item.ActEndDate);
double percentComplete;
switch (item.Type)
{
case ProjectItemType.Project:
{
ModuleService service = new ModuleService();
List<Module> modules = new List<Module>(service.GetByProject(item.ID));
List<ProjectItem> moduleItems = modules.ConvertAll(i => (ProjectItem) i);
percentComplete = GetPercentComplete(moduleItems);
break;
}
case ProjectItemType.Module:
{
TaskService taskService = new TaskService();
List<Task> tasks = new List<Task>(taskService.GetByModule(item.ID));
List<ProjectItem> taskItems = tasks.ConvertAll(i => (ProjectItem) i);
percentComplete = GetPercentComplete(taskItems);
break;
}
case ProjectItemType.Task:
{
percentComplete = item.IsComplete ? 1 : 0;
break;
}
default:
{
throw new ArgumentOutOfRangeException();
}
}
lblItemStatus.Text = percentComplete.ToString("p");
}
}
public virtual void Init()
{
WorkspaceService = new WorkspaceService(Constants.ApiToken);
var workspaces = WorkspaceService.List();
ClientService = new ClientService(Constants.ApiToken);
TaskService = new TaskService(Constants.ApiToken);
TagService = new TagService(Constants.ApiToken);
ProjectService = new ProjectService(Constants.ApiToken);
UserService = new UserService(Constants.ApiToken);
TimeEntryService = new TimeEntryService(Constants.ApiToken);
ReportService = new ReportService(Constants.ApiToken);
foreach (var workspace in workspaces)
{
var projects = WorkspaceService.Projects(workspace.Id.Value);
var tasks = WorkspaceService.Tasks(workspace.Id.Value);
var tags = WorkspaceService.Tags(workspace.Id.Value); // TODO
var users = WorkspaceService.Users(workspace.Id.Value); // TODO
var clients = WorkspaceService.Clients(workspace.Id.Value);
var rte = new TimeEntryParams { StartDate = DateTime.Now.AddYears(-1)};
var timeEntries = TimeEntryService.List(rte);
Assert.IsTrue(TimeEntryService.DeleteIfAny(timeEntries.Select(te => te.Id.Value).ToArray()));
Assert.IsTrue(ProjectService.DeleteIfAny(projects.Select(p => p.Id.Value).ToArray()));
Assert.IsTrue(TaskService.DeleteIfAny(tasks.Select(t => t.Id.Value).ToArray()));
Assert.IsTrue(ClientService.DeleteIfAny(clients.Select(c => c.Id.Value).ToArray()));
Assert.IsFalse(WorkspaceService.Projects(workspace.Id.Value).Any());
Assert.IsFalse(WorkspaceService.Tasks(workspace.Id.Value).Any());
Assert.IsFalse(WorkspaceService.Clients(workspace.Id.Value).Any());
Assert.IsFalse(TimeEntryService.List(rte).Any());
}
DefaultWorkspaceId = workspaces.First().Id.Value;
}
public static bool StartupTaskExists()
{
using (TaskService _taskService = new TaskService())
{
Task _task = _taskService.FindTask(Constants.Generic.TASKNAME);
if (_task == null)
{
return false;
}
ExecAction _action = _task.Definition.Actions.OfType<ExecAction>().FirstOrDefault();
if (_action == null || _action.Path != Assembly.GetExecutingAssembly().Location)
{
return false;
}
return true;
}
}
public static void EnableStartupTask(string exePath = null)
{
using (TaskService _taskService = new TaskService())
{
TaskDefinition _def = _taskService.NewTask();
_def.Triggers.Add(new LogonTrigger() { Enabled = true });
_def.Actions.Add(new ExecAction(exePath ?? Assembly.GetExecutingAssembly().Location));
_def.Principal.RunLevel = TaskRunLevel.Highest;
_taskService.RootFolder.RegisterTaskDefinition(Constants.Generic.TASKNAME, _def);
}
}
public static void DisableStartupTask()
{
using (TaskService _taskService = new TaskService())
{
_taskService.RootFolder.DeleteTask(Constants.Generic.TASKNAME, false);
}
}
public TaskController()
{
IoC.Init();
var uowf = IoC.Get<IUnitOfWorkFactory>();
service = new TaskService(uowf);
}
public void CanImplementInterfaceWithTaskReturn()
{
// this was causing issues with the completed method
EventSourceImplementer.RegisterProvider<ITaskService>(new JsonObjectSerializer());
var log = EventSourceImplementer.GetEventSourceAs<ITaskService>();
_listener.EnableEvents((EventSource)log, EventLevel.LogAlways, (EventKeywords)(-1));
// check the service
var service = new TaskService();
Assert.AreEqual("foo", service.GetItem("foo").Result);
// try a proxy
var proxy = TracingProxy.Create<ITaskService>(service);
var task = proxy.GetItem("foo");
Assert.AreEqual("foo", task.Result);
// look at the events
var events = _listener.Events.ToArray();
Assert.AreEqual(2, events.Length);
// check the individual events to make sure the task came back in the payload
Assert.AreEqual(1, events[1].Payload.Count);
Assert.AreEqual(new JsonObjectSerializer().SerializeObject(task, null), events[1].Payload[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskController" /> class.
/// </summary>
/// <param name="developerService">The developer service.</param>
/// <param name="lookupService">The lookup service.</param>
/// <param name="taskService">The task service.</param>
public TaskController(DeveloperService developerService, LookupService lookupService, TaskService taskService)
{
this.lookupService = lookupService;
this.developerService = developerService;
this.taskService = taskService;
}
public BuilderInfo(TaskService taskSvc)
{
ts = taskSvc;
td = ts.NewTask();
}
/// <summary>
///一个函数获取需要的工时列表/
/// </summary>
/// <returns></returns>
public List<Task> GetTask() {
TaskService ts = new TaskService();
List<Task> taskList = ts.FindByUserGroup(2);
return taskList;
}
void SaveSettings(object o)
{
ErrorMessage = string.Empty;
try
{
Trace.TraceInformation("Saving settings...");
Settings.Default.Save();
PendingChanges = false;
Trace.TraceInformation("Settings saved successfully.");
}
catch (Exception ex)
{
ErrorMessage = "Couldn't save settings: " + ex.Message;
return;
}
try
{
Trace.TraceInformation("Updating schedule settings...");
const string taskPath = "IPFilter";
// Get the service on the local machine
using (var service = new TaskService())
{
if (!IsScheduleEnabled)
{
// If we're disabling the scheduling, then delete the task if it exists.
Trace.TraceInformation("Schedule is disabled. Removing any existing scheduled task.");
service.RootFolder.DeleteTask(taskPath, false);
Trace.TraceInformation("Finished updating schedule settings.");
return;
}
var identity = WindowsIdentity.GetCurrent();
if (identity == null)
{
Trace.TraceWarning("Couldn't get the user identity; can't schedule task.");
return;
}
Trace.TraceInformation("Setting up the automatic schedule...");
using (var task = service.NewTask())
{
task.RegistrationInfo.Description = "Updates the IP Filter for bit torrent clients";
task.Triggers.Clear();
// Schedule for midnight, then check every x hours (6 by default).
var trigger = new TimeTrigger(new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 0));
trigger.Repetition.Interval = TimeSpan.FromHours(ScheduleHours ?? 6);
task.Triggers.Add(trigger);
task.Actions.Add(new ExecAction(Process.GetCurrentProcess().MainModule.FileName, "/silent"));
task.Settings.RunOnlyIfNetworkAvailable = true;
task.Settings.StartWhenAvailable = true;
task.Settings.WakeToRun = false;
task.Principal.RunLevel = TaskRunLevel.Highest;
//task.Principal.UserId = identity.Name;
service.RootFolder.RegisterTaskDefinition(taskPath, task, TaskCreation.CreateOrUpdate, identity.Name);
}
Trace.TraceInformation("Finished scheduling automatic update.");
}
}
catch (Exception ex)
{
Trace.TraceError("Couldn't schedule automated update: " + ex);
ErrorMessage = "Couldn't schedule automated update: " + ex.Message;
}
}
public void DeleteWithTasks()
{
ProjectService service = new ProjectService();
Project project = (Project) CreateRecord();
Insert(project);
ModuleService moduleService = new ModuleService();
Module module = new Module(project.ID, "Name", "Description");
moduleService.Insert(module);
TaskService taskService = new TaskService();
for (int i = 0; i < 5; i++)
{
taskService.Insert(new Task(module.ID, "Task", "Description", TaskComplexity.Medium));
}
service.Delete(project.ID);
Assert.AreEqual(0, moduleService.GetByProject(project.ID).Count);
Assert.AreEqual(0, taskService.GetByModule(module.ID).Count);
}
public override void Update()
{
TaskService target = new TaskService();
Task task = (Task) CreateRecord();
Insert(task);
task.Description = "asdf 123";
task.Complexity = TaskComplexity.High;
target.Update(task);
Task updated = target.GetByID(task.ID);
Assert.AreEqual(task.Description, updated.Description);
Assert.AreEqual(task.Complexity, updated.Complexity);
}
public TaskManagement(TaskService taskService) : this()
{
this.taskService = taskService;
UpdateTaskList();
}
private void InsertAndAssign(User user)
{
TaskService target = new TaskService();
Task task = (Task) CreateRecord();
Insert(task);
target.Assign(task.ID, user.ID);
}
