public async Task AddTaskTest(string taskDesc, int priority, string startDatestr, string endDatestr)
{
DateTime startDate = DateTime.Parse(startDatestr);
DateTime endDate = DateTime.Parse(endDatestr);
var taskAdd = new TaskAdd
{
TaskDescription = taskDesc,
Priority = priority,
StartDate = startDate,
EndDate = endDate
};
var resulTasks = new Tasks
{
EndDate = endDate,
Priortiy = priority,
TaskDeatails = taskDesc,
Status = 1,
StartDate = startDate,
TaskId = 1
};
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(map => map.Map <Tasks>(It.IsAny <TaskAdd>())).Returns(resulTasks);
var mockTaskRepo = new Mock <ITaskRepo>();
mockTaskRepo.Setup(tskService => tskService.AddTask(It.IsAny <Tasks>()))
.Returns(Task.FromResult <bool>(true));
var taskService = new TasksService(mockMapper.Object, mockTaskRepo.Object, logger);
var result = await taskService.AddTask(taskAdd);
Assert.True(result);
}
public static List <TaskAdd> AddNewTask(int elementid, int elementtype, int tasktype, int taskstatus, string tasktext, int tilltime, int?datecreate = null, int?lastmodified = null, int?responsibleuserid = null)
{
var provider = new AmoCRMProvider();
Task newTask = new Task();
newTask.request = new Request();
newTask.request.tasks = new Tasks();
newTask.request.tasks.add = new List <TaskAdd>();
TaskAdd newTaskItem = new TaskAdd();
newTaskItem.element_id = elementid;
newTaskItem.element_type = elementtype;
newTaskItem.task_type = tasktype;
newTaskItem.status = taskstatus;
newTaskItem.text = tasktext;
newTaskItem.complete_till = tilltime;
newTaskItem.date_create = datecreate;
newTaskItem.last_modified = lastmodified;
//newTaskItem.request_id = //этож output-параметр... зачем он тут? хз
newTaskItem.responsible_user_id = responsibleuserid;
newTask.request.tasks.add.Add(newTaskItem);
Console.WriteLine("Start AddNewTask\n");
Console.WriteLine(JsonConvert.SerializeObject(newTask));
TaskResponse ids = provider.SendNewTask(SessionID, newTask);
Environment.ExitCode = Convert.ToInt16(provider.HadErrors);
return(ids.tasks.add);
//todo вернуть текущее время и время сервера. Время сервера есть в ответе Auth. А вот текущее правильно ли будет брать сразу после? не совсем, наверное, все же..
}
public async Task <data.Task> Add(TaskAdd add)
{
try
{
var newTask = new data.Task();
newTask.CompletedDate = add.CompletedDate;
newTask.DueDate = add.DueDate;
newTask.Name = add.Name;
newTask.StartedDate = add.StartedDate;
newTask.Status = add.Status;
newTask.TaskId = await data.Sequence.SequenceGenerator.GetNextId("Task");
newTask.RowKey = newTask.TaskId.ToString();
newTask.UserUserId = add.UserUserId;
newTask.PartitionKey = add.UserUserId.ToString();
TableOperation insertOperation = TableOperation.Insert(newTask);
var taskTable = await data.Utils.GetTable("Task");
await taskTable.ExecuteAsync(insertOperation);
return(newTask);
}
catch (Exception e)
{
LogFactory.GetLogger().Log(LogLevel.Error, e);
return(null);
}
}
public async Task <data.Task> Add(data.ToDoDbContext db, TaskAdd add)
{
try
{
var newTask = new data.Task();
newTask.CompletedDate = add.CompletedDate;
newTask.DueDate = add.DueDate;
newTask.Name = add.Name;
newTask.StartedDate = add.StartedDate;
newTask.Status = add.Status;
// Add references to parent Classes
var userLookup = await db.Users.FirstOrDefaultAsync(w => w.UserId == add.UserUserId);
if (userLookup != null)
{
newTask.User = userLookup;
}
db.Tasks.Add(newTask);
return(newTask);
}
catch (Exception e)
{
LogFactory.GetLogger().Log(LogLevel.Error, e);
return(null);
}
}
public IActionResult AddTask()
{
SubjectUpdate(HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
TaskAdd newtask = new TaskAdd(subjects);
return(View(newtask));
}
public IActionResult AddTask(TaskAdd task)
{
Assignment assignment = new Assignment();
Models.Task ad_tast = new Models.Task();
assignment.Deadline = task.taskAdd.Deadline;
assignment.Requirenments = task.taskAdd.Requirenments;
if (ModelState.IsValid)
{
_Assignment.Insert(assignment);
ad_tast.AssignmentId = _Assignment.GetAll().OrderBy(a => a.Id).LastOrDefault().Id;
_Task.Insert(ad_tast);
if (task.taskAdd.IsTest == true)
{
var l = _Lesson.GetById(task.taskAdd.Lesson);
l.TestTaskId = _Task.GetAll().OrderBy(a => a.Id).LastOrDefault().Id;
_Lesson.Update(l);
}
else
{
var l = _Lesson.GetById(task.taskAdd.Lesson);
l.HwTaskId = _Task.GetAll().OrderBy(a => a.Id).LastOrDefault().Id;
_Lesson.Update(l);
}
return(RedirectToAction("Index", "Teacher"));
}
else
{
return(View(task));
}
}
public ActionResult Save(TaskAdd task)
{
ViewBag.Projects = project.ListofProjects();
ViewBag.Users = _userManager.Listofpersons();
_taskManager.Save(task);
return(View());
}
public void Post(TaskAdd task)
{
var session = GetSession();
var col = MongoDatabase.GetCollection <Task>("tasks");
col.InsertOne(new Task {
User = session.UserName, Name = task.Name
});
}
private void OutlookItems_ItemAdd(object Item)
{
if (Item is Outlook.TaskItem)
{
OutlookTask newTask = new OutlookTask();
taskAndCategoryLoader.UpdateTask(newTask, Item as Outlook.TaskItem, taskAndCategoryLoader.Categories, taskAndCategoryLoader.DefaultCategory);
taskAndCategoryLoader.Tasks.Add(newTask);
TaskAdd?.Invoke(newTask);
}
}
public int Save(TaskAdd task)
{
Connection.Open();
string query = "Insert into Task values('" + task.ProjectId + "','" + task.UserId + "','" + task.Description + "','" + task.DueDate + "','" + task.Priority + "')";
Command.CommandText = query;
int rowAffected = Command.ExecuteNonQuery();
Connection.Close();
return(rowAffected);
}
public TaskAdd GetTaskAdd()
{
var result = new TaskAdd();
result.CompletedDate = TaskView.CompletedDate;
result.DueDate = TaskView.DueDate;
result.Name = TaskView.Name;
result.StartedDate = TaskView.StartedDate;
result.Status = TaskView.Status;
result.TaskId = TaskView.TaskId;
result.UserUserId = TaskView.UserUserId;
return(result);
}
public async Task<Tuple<bool, string>> AddTask(TaskAdd projTask)
{
if ((projTask.EndDate > DateTime.MinValue) && (projTask.StartDate > DateTime.MinValue)
&& (projTask.StartDate > projTask.EndDate))
return new Tuple<bool, string>(false, "start date greater than end date");
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(projTask);
var validationResults = new List<ValidationResult>();
if (Validator.TryValidateObject(projTask, validationContext, validationResults))
{
var taskDO = mapper.Map<ProjTask>(projTask);
return await projectTaskRepo.AddTask(projTask.ProjectId, taskDO);
}
return new Tuple<bool, string>(false, "validation failures");
}
public async Task <bool> AddTask(TaskAdd taskAdd)
{
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(taskAdd);
var validationResults = new List <ValidationResult>();
if (Validator.TryValidateObject(taskAdd, validationContext, validationResults))
{
var tasks = mapper.Map <Tasks>(taskAdd);
var result = await taskRepo.AddTask(tasks);
taskAdd.TaskId = tasks.TaskId;
return(result);
}
return(false);
}
public void GetterSetterTest()
{
var taskAdd = new TaskAdd
{
EndDate = DateTime.Today.AddDays(1),
StartDate = DateTime.Today,
ParentTaskId = 1,
Priority = 1,
TaskDescription = "task1",
TaskId = 0
};
Assert.Equal(DateTime.Today.AddDays(1), taskAdd.EndDate);
Assert.Equal(DateTime.Today, taskAdd.StartDate);
Assert.Equal(1, taskAdd.ParentTaskId);
Assert.Equal(1, taskAdd.Priority);
Assert.Equal("task1", taskAdd.TaskDescription);
Assert.Equal(0, taskAdd.TaskId);
}
// Add Transaction Code
public async Task <TaskView> Add(TaskAdd add)
{
try
{
using (var db = new data.ToDoDbContext())
{
var result = await Add(db, add);
await db.SaveChangesAsync();
return((TaskView)result);
}
}
catch (Exception e)
{
LogFactory.GetLogger().Log(LogLevel.Error, e);
return(null);
}
}
public async Task PostTest(string taskDesc, int priority, string startDatestr, string endDatestr)
{
DateTime startDate = DateTime.Parse(startDatestr);
DateTime endDate = DateTime.Parse(endDatestr);
var taskAdd = new TaskAdd
{
TaskDescription = taskDesc,
Priority = priority,
StartDate = startDate,
EndDate = endDate
};
var mockService = new Mock <ITaskService>();
mockService.Setup(service => service.AddTask(It.IsAny <TaskAdd>())).Returns(Task.FromResult(true));
var controller = new TaskController(mockService.Object, logger);
var result = (await controller.Post(taskAdd)).Result as CreatedResult;
Assert.NotNull(result);
Assert.Equal(201, result.StatusCode);
}
public void GetterSetterTest()
{
var taskAdd = new TaskAdd
{
EndDate = DateTime.Today.AddDays(2),
ParentTaskId = "P/1-1",
Priority = 1,
ProjectId = "P/1",
StartDate = DateTime.Today,
TaskDescription = "Task1",
TaskOwnerId = "Usr/1"
};
Assert.Equal(DateTime.Today.AddDays(2), taskAdd.EndDate);
Assert.Equal("P/1-1", taskAdd.ParentTaskId);
Assert.Equal(1, taskAdd.Priority);
Assert.Equal(DateTime.Today, taskAdd.StartDate);
Assert.Equal("Task1", taskAdd.TaskDescription);
Assert.Equal("Usr/1", taskAdd.TaskOwnerId);
}
public static IEnumerable AddNewTask(SqlString Host, SqlString SessionID, SqlInt32 elementid, SqlInt16 elementtype, SqlInt16 tasktype, SqlInt16 taskstatus,
SqlString tasktext, SqlInt32 tilltime, SqlInt16? datecreate = null, SqlInt16? lastmodified = null, SqlInt16? responsibleuserid = null)
{
var provider = new Classes.AmoDownloaderCLR();
Task newTask = new Task();
newTask.request = new Request();
newTask.request.tasks = new Tasks();
newTask.request.tasks.add = new List<TaskAdd>();
TaskAdd newTaskItem = new TaskAdd();
newTaskItem.element_id = (Int32)elementid;
newTaskItem.element_type = (int)elementtype;
newTaskItem.task_type = (int)tasktype;
newTaskItem.status = (int)taskstatus;
newTaskItem.text = (string)tasktext;
newTaskItem.complete_till = (Int32)tilltime;
newTaskItem.date_create = (int?)datecreate;
newTaskItem.last_modified = (int?)lastmodified;
newTaskItem.responsible_user_id = (int?)responsibleuserid;
newTask.request.tasks.add.Add(newTaskItem);
Console.WriteLine("Start AddNewTask\n");
Console.WriteLine(JsonConvert.SerializeObject(newTask));
var ids = provider.SendQuery(Host, SessionID, newTask);
Environment.ExitCode = Convert.ToInt16(provider.HadErrors);
var i = JsonConvert.DeserializeObject<TaskResponseRoot>(ids);
ArrayList list = new ArrayList();
foreach (var newTaskResponse in i.response.tasks.add)
{
TaskResponse newRec = new TaskResponse();
newRec.Id = newTaskResponse.id;
newRec.AmoTime = i.response.Amo_time;
newRec.ProgramTime = DateTime.Now;
list.Add(newRec);
}
return list;
}
public HttpResponseMessage Post(TaskAdd model)
{
try
{
if (ModelState.IsValid)
{
int id = _service.Insert(model);
ItemResponse <int> resp = new ItemResponse <int>();
resp.Item = id;
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
log.Error("Error adding a task", ex);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <ActionResult <bool> > AddTask([FromBody] TaskAdd taskAdd)
{
if (taskAdd == null)
{
ModelState.AddModelError("ParameterEmpty", "Input parameter are all empty");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await projService.AddTask(taskAdd);
if (result.Item1)
{
return(Created($"api/Task/{result.Item2}", result.Item1));
}
else
{
return(StatusCode(500, "Unable to create project"));
}
}
public TaskEntity TaskAdd(TaskAdd request)
{
_log.LogDebug("TaskAdd");
if (request == null)
{
throw new ArgumentNullException("request");
}
_log.LogDebug("Creating new entity");
TaskEntity entity = new TaskEntity(
Guid.NewGuid(),
request.Name,
request.Completed);
_log.LogDebug("Saving entity");
_context.Task.Add(entity);
_context.SaveChanges();
_log.LogDebug("Returning result");
return(entity);
}
public async Task <TaskView> TaskAdd(TaskAdd add)
{
try
{
string json = "";
var client = new HttpClient();
using (var ms = new MemoryStream())
{
var serializer = new DataContractJsonSerializer(typeof(TaskAdd));
serializer.WriteObject(ms, add);
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
json = sr.ReadToEnd();
}
var stream = await client.PostAsync("http://tododotnet.lan:9271/api/task", new StringContent(json, Encoding.UTF8, "application/json"));
using (var ms = new MemoryStream())
{
var serializer = new DataContractJsonSerializer(typeof(TaskView), new DataContractJsonSerializerSettings()
{
DateTimeFormat = new DateTimeFormat("yyyy-MM-dd'T'HH:mm:ss")
});
await stream.Content.CopyToAsync(ms);
ms.Position = 0;
var view = serializer.ReadObject(ms) as TaskView;
return(view);
}
}
catch (Exception e)
{
LogFactory.GetLogger().Log(LogLevel.Error, e);
return(null);
}
}
public async Task AddTaskTest()
{
var taskAdd = new TaskAdd
{
EndDate = DateTime.Today.AddDays(2),
ParentTaskId = "P/1-1",
Priority = 1,
ProjectId = "P/1",
StartDate = DateTime.Today,
TaskDescription = "Task1",
TaskOwnerId = "Usr/1"
};
var projectService = new Mock <IProjTaskService>();
projectService.Setup(ser => ser.AddTask(It.IsAny <TaskAdd>()))
.Returns(Task.FromResult(new Tuple <bool, string>(true, "P/1-1")));
var logger = createLogger();
var projectController = new ProjectController(projectService.Object, logger);
var actionResult = (await projectController.AddTask(taskAdd)).Result as CreatedResult;
Assert.NotNull(actionResult);
Assert.Equal(201, actionResult.StatusCode);
}
public ActionResult Add(TaskAdd model)
{
if (!ModelState.IsValid)
{
return(new HttpStatusCodeResult(400));
}
try
{
if (db.question_tasks.Any(qt => model.questions.Contains(qt.question_id.ToString())))
{
return(new HttpStatusCodeResult(501));
}
var questions = db.questions.Where(q => model.questions.Contains(q.id.ToString())).ToList();
questions.ForEach(qs => qs.state = true);
db.SaveChanges();
model.questions.ToList().ForEach(q =>
{
db.tasks.Add(new Tasks {
created_date = DateTime.Now, question_id = Convert.ToInt32(q), user_id = model.user_id, order_state = "İşlem Bekleniyor"
});
db.question_tasks.Add(new QuestionTasks {
question_id = Convert.ToInt32(q), user_id = model.user_id
});
db.SaveChanges();
});
}
catch (Exception exs)
{
return(new HttpStatusCodeResult(500, exs.Message.ToString()));
}
return(new HttpStatusCodeResult(200));
}
public async Task AddTaskTest()
{
var projTasks = new ProjTask
{
ParentTaskId = "",
EndDate = DateTime.Today.AddDays(2),
Priority = 1,
Start = DateTime.Today,
Name = "ParentTask",
TaskOwnerId = "Usr/2",
Status = 0
};
var taskAdd = new TaskAdd
{
ParentTaskId = "",
EndDate = DateTime.Today.AddDays(2),
Priority = 1,
StartDate = DateTime.Today,
TaskDescription = "ParentTask",
TaskOwnerId = "Usr/2",
ProjectId = "P/1"
};
var mockProjTaskRepo = new Mock <IProjectTaskRepo>();
mockProjTaskRepo.Setup(repo => repo.AddTask(It.IsAny <string>(), It.IsAny <ProjTask>()))
.Returns(Task.FromResult(new Tuple <bool, string>(true, "P/1-1")));
var mockLogger = createProjServiceLogger();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(map => map.Map <ProjTask>(It.IsAny <TaskAdd>())).Returns(projTasks);
var projectTaskService = new ProjTaskService(mockProjTaskRepo.Object, mockLogger, mockMapper.Object);
var result = await projectTaskService.AddTask(taskAdd);
Assert.True(result.Item1);
Assert.Equal("P/1-1", result.Item2);
}
public List <TaskAdd> AllTasks()
{
Connection.Open();
string query = "Select * from Task";
Command.CommandText = query;
List <TaskAdd> listoftask = new List <TaskAdd>();
SqlDataReader reader = Command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
TaskAdd task = new TaskAdd();
task.Id = (int)reader["Id"];
task.Description = reader["Description"].ToString();
listoftask.Add(task);
}
}
reader.Close();
Connection.Close();
return(listoftask);
}
public int Save(TaskAdd task)
{
return(taskGateway.Save(task));
}
public ApiResult Add(TaskAdd TaskAdd)
{
ApiResult result = new ApiResult();
string message = string.Empty;
Action action = () =>
{
using (FLDbContext db = new FLDbContext())
{
foreach (FLTask Task in TaskAdd.TaskList)
{
if (string.IsNullOrEmpty(Task.TaskName))
{
message = "请填写任务名称";
goto Response;
}
Task.CreateDate = DateTime.Now;
Task.IsDel = false;
db.FLTask.Add(Task);
db.SaveChanges();
if (Task.IsBaseClass == true)
{
//使用默认的班次
List <TaskFlow> tfList = new List <TaskFlow>();
List <Flow> FlowList = new FlowDAO().GetFlow(Task.TableType);
foreach (BaseClass bs in TaskAdd.BaseClassList)
{
foreach (Flow Flow in FlowList)
{
List <BaseClassUser> bculist = db.BaseClassUser.Where(t => t.BaseClassID == bs.ID && t.FlowID == Flow.ID).ToList();
foreach (BaseClassUser bcu in bculist)
{
foreach (TaskFlow tf in Task.TaskFlowList)
{
//这里可以缓存一个bdf来提升效率
if (tf.IsBase)
{
BaseDateFlow bdf = db.BaseDateFlow.FirstOrDefault(t => t.FlowID == tf.FlowID);
tf.BeginDate = bdf.BeginDate;
tf.EndDate = bdf.EndDate;
tf.RemindDate = bdf.RemindDate;
}
//tf.FlowID = bcu.FlowID;
tf.MaintainUserID = bcu.UserID;
tf.IsReminded = false;
tf.MaintainUserID = bcu.UserID;
tf.TaskID = Task.ID;
tfList.Add(tf);
}
}
}
}
db.TaskFlow.AddRange(tfList);
}
else
{
//先验证是否完整
List <Flow> flowList = new FlowDAO().GetFlow(Task.TableType);
foreach (Flow flow in flowList)
{
if (Task.TaskFlowList.FirstOrDefault(t => t.FlowID == flow.ID) == null)
{
message = "请填写完整的流程";
goto Response;
}
}
foreach (TaskFlow tf in Task.TaskFlowList)
{
if (tf.IsBase)
{
BaseDateFlow bdf = db.BaseDateFlow.FirstOrDefault(t => t.FlowID == tf.FlowID);
tf.BeginDate = bdf.BeginDate;
tf.EndDate = bdf.EndDate;
tf.RemindDate = bdf.RemindDate;
}
tf.IsReminded = false;
tf.TaskID = Task.ID;
}
db.TaskFlow.AddRange(Task.TaskFlowList);
}
}
}
new SysLogDAO().AddLog(LogType.Success, message: "成功添加任务");
result = ApiResult.NewSuccessJson("成功添加任务");
Response:
if (!string.IsNullOrEmpty(message))
{
//回滚
foreach (FLTask Task in TaskAdd.TaskList)
{
if (Task.ID != 0)
{
new FLDbContext().FLTask.Remove(new FLDbContext().FLTask.FirstOrDefault(t => t.ID == Task.ID));
}
else
{
break;
}
}
result = ApiResult.NewErrorJson(message);
}
};
TransactioExtension.Excute(action);
return(result);
}
