// GET: TaskDetails/Delete/5
public async Task <ActionResult> Delete(int id)
{
TaskDetail taskDetail = null;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var result = await client.GetAsync($"api/TaskDetails/{id}");
if (result.IsSuccessStatusCode)
{
taskDetail = await result.Content.ReadAsAsync <TaskDetail>();
}
else
{
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
return(View(taskDetail));
}
public async Task <ActionResult> Edit(int id, TaskDetail taskDetail)
{
if (ModelState.IsValid)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = await client.PutAsJsonAsync($"api/TaskDetails/{id}", taskDetail);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "Server error try after some time.");
}
}
return(RedirectToAction("Index"));
}
return(View(taskDetail));
}
public IHttpActionResult UpdateTaskDetail(TaskDetail Taskdata)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
TaskDetail objtaskdtl = new TaskDetail();
objtaskdtl = ObjTMEntities.TaskDetails.Find(Taskdata.Task_ID);
if (objtaskdtl != null)
{
objtaskdtl.TaskName = Taskdata.TaskName;
objtaskdtl.Priority = Taskdata.Priority;
objtaskdtl.Start_Date = Taskdata.Start_Date;
objtaskdtl.End_Date = Taskdata.End_Date;
}
int i = this.ObjTMEntities.SaveChanges();
}
catch (Exception ex)
{
throw;
}
return(Ok(Taskdata));
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail = null)
{
EmailService emailService = new EmailService();
List <int> successedIds = new List <int>();
List <int> failedIds = new List <int>();
RWLock.EnterWriteLock();
//从配置文件读取配置
IEmailSettingsManager emailSettingsManager = DIContainer.Resolve <IEmailSettingsManager>();
EmailSettings settings = emailSettingsManager.Get();
//1 首先获取待发送的邮件列表
Dictionary <int, MailMessage> emailQueue = emailService.Dequeue(settings.BatchSendLimit);
//2 逐个邮件进行发送（非异步发送）
//3 记录记录发送成功的和发送失败的ID
foreach (var item in emailQueue)
{
if (emailService.Send(item.Value))
{
successedIds.Add(item.Key);
}
else
{
failedIds.Add(item.Key);
}
}
//4 发送成功的记录删除
emailService.SendFailed(failedIds, settings.SendTimeInterval, settings.NumberOfTries); //从配置文件读取
//5 发送失败的记录更新
emailService.Delete(successedIds); //从配置文件读取
RWLock.ExitWriteLock();
}
public bool UpdateTaskDetail(TaskDetail detailData)
{
var td = context.taskdetails.Find(detailData.JobCodeDetailsID);
try
{
td.JobCodeID = detailData.JobCodeID;
td.Qty = detailData.Qty;
td.ManualPricingYN = false;
td.PartCost = detailData.PartCost;
td.PartStdPrice = detailData.PartStdPrice;
td.PartMemberPrice = detailData.PartMemberPrice;
td.PartAddonStdPrice = detailData.PartAddonStdPrice;
td.PartAddonMemberPrice = detailData.PartAddonMemberPrice;
context.SaveChanges();
RecalculatePrices(3, detailData.JobCodeID);
return(true);
}
catch
{
return(false);
}
}
public void TestIsUserValidToDelete_ReturnFalseWhenUserContainsActiveTasks()
{
var mockRepository = new Mock <IUserRepository>();
var manageUser = new ManageUser(mockRepository.Object, fixture.ManageUserLogger);
var taskDetail = new TaskDetail()
{
Id = 1, Name = "Task 1", Priority = 20, ActiveStatus = true
};
var taskDetailsList = new List <TaskDetail>()
{
taskDetail,
new TaskDetail()
{
Id = 2, Name = "Task 2 ", Priority = 20
},
};
var user = new User()
{
UserId = 1, FirstName = "User 1", TaskDetails = taskDetailsList, Projects = new List <Project>()
};
var result = manageUser.IsUserValidToDelete(user);
Assert.False(result);
}
public JsonResult RunTask(int id)
{
TaskDetail td = taskService.Get(id);
if (td == null)
{
return(Json(new { status = true, message = "执行失败!" }));
}
if (Utility.IsDistributedDeploy() && (td.RunAtServer == RunAtServer.Master || td.RunAtServer == RunAtServer.Search))
{
try
{
TaskServiceClient client = new TaskServiceClient("WCFTaskService");
client.RunTask(id);
}
catch (Exception e)
{
return(Json(new { message = "执行失败!" }));
}
}
else
{
TaskSchedulerFactory.GetScheduler().Run(id);
}
return(Json(new { success = true, message = "执行成功!" }));
}
void ReleaseDesignerOutlets()
{
if (TaskDetail != null)
{
TaskDetail.Dispose();
TaskDetail = null;
}
if (TaskImage != null)
{
TaskImage.Dispose();
TaskImage = null;
}
if (TaskStatus != null)
{
TaskStatus.Dispose();
TaskStatus = null;
}
if (TaskStatusIcon != null)
{
TaskStatusIcon.Dispose();
TaskStatusIcon = null;
}
if (TaskTitle != null)
{
TaskTitle.Dispose();
TaskTitle = null;
}
}
/// <summary>
/// 任务执行的内容
/// </summary>
/// <param name="taskDetail">任务配置状态信息</param>
public void Execute(TaskDetail taskDetail = null)
{
//检查是否分布式运行环境
bool distributedDeploy = Utility.IsDistributedDeploy();
if (distributedDeploy)
{
foreach (SearchEngine searchEngine in SearchEngineService.searchEngines.Values)
{
searchEngine.Commit();
}
}
else
{
IEnumerable <ISearcher> searchers = SearcherFactory.GetSearchersOfBaseLucene();
foreach (var searcher in searchers)
{
if (searcher.SearchEngine is SearchEngine)
{
((SearchEngine)searcher.SearchEngine).Commit();
}
}
}
}
public async Task <IActionResult> Get(string id)
{
try
{
var accessToken = await HttpContext.GetTokenAsync("access_token");
if (Guid.TryParse(id, out Guid parsedId))
{
TaskDetail taskDetail = _unitOfWork.TaskDetails.GetDetail(parsedId, true);
if (taskDetail != null)
{
if (await _taskManager.CanAccessTaskGroupHeaderAsync(taskDetail.TaskHeader.TaskGroupHeaderId, accessToken))
{
return(Ok(_mapper.Map <TaskDet>(taskDetail)));
}
}
}
}
catch (Exception e)
{
string message = e.Message;
}
return(NotFound());
}
public IHttpActionResult PutTaskDetail(int id, TaskDetail taskDetail)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
if (id != taskDetail.Task_ID)
{
return(BadRequest());
}
db.Entry(taskDetail).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskDetailExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void Run(TaskDetail task)
{
if (task == null)
{
return;
}
System.Type type = System.Type.GetType(task.ClassType);
if (type == null)
{
LoggerFactory.GetLogger().Error(string.Format("任务： {0} 的taskType为空。", task.Name));
return;
}
ITask task2 = (ITask)System.Activator.CreateInstance(type);
if (task2 != null && !task.IsRunning)
{
try
{
task2.Execute(null);
}
catch (System.Exception exception)
{
LoggerFactory.GetLogger().Error(exception, string.Format("执行任务： {0} 出现异常。", task.Name));
}
}
}
public async System.Threading.Tasks.Task <ActionResult> Edit(TaskDetail task)
{
TaskDetailValidator validator = new TaskDetailValidator();
ValidationResult validationResults = validator.Validate(task);
if (!validationResults.IsValid)
{
var getProjectsTask = _projectApiRequestHandler.GetProjectsHeaders(projectsType: ProjectType.Active);
foreach (var error in validationResults.Errors)
{
ModelState.AddModelError(nameof(TaskEditViewModel.Task) + '.' + error.PropertyName, error.ErrorMessage);
}
TaskEditViewModel viewModel = new TaskEditViewModel()
{
Task = task,
};
viewModel.ActiveProjects = await getProjectsTask;
return(View(viewModel));
}
await _taskApiRequestHandler.SaveTask(task);
return(RedirectToAction("List"));
}
public void Run(TaskDetail task)
{
if (task == null)
{
return;
}
Type type = Type.GetType(task.ClassType);
if (type == null)
{
LoggerFactory.GetLogger().Error(string.Format("任务： {0} 的taskType为空。", task.Name));
return;
}
var task2 = (ITask)Activator.CreateInstance(type);
if (task2 != null && !task.IsRunning)
{
try
{
task2.Execute(null);
}
catch (Exception exception)
{
LoggerFactory.GetLogger().Error(exception, string.Format("执行任务： {0} 出现异常。", task.Name));
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("TaskDetailId,TaskName,TaskDescription,AssignedDate,EmployeeId,StatusId")] TaskDetail taskDetail)
{
if (id != taskDetail.TaskDetailId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskDetail);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskDetailExists(taskDetail.TaskDetailId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "EmployeeId", "EmployeeId", taskDetail.EmployeeId);
ViewData["StatusId"] = new SelectList(_context.Statuses, "StatusId", "StatusId", taskDetail.StatusId);
return(View(taskDetail));
}
//Hàm sửa đổi thông tin chi tiết của bài tập.
public TaskDetail UpdateTaskDetail(TaskDetail taskdetail)
{
string queryString = "UPDATE TaskDetail SET StudentId = @studentId, TaskId = @taskId, TaskFileUpload = @taskFileUpload, TaskSubmissionState = @taskSubmissionState, TaskScore = @taskScore "
+ " WHERE TaskDetailId = @taskDetailId";
//Mở kết nối đến database
using (SqlConnection connection =
new SqlConnection(this.ConnectionString))
{
// Khởi tạo command với các tham số truyền vào là các trường trong đối tượng TaskDetail
SqlCommand command = new SqlCommand(queryString, connection);
command.Parameters.AddWithValue("@taskDetailId", taskdetail.TaskDetailId);
command.Parameters.AddWithValue("@studentId", taskdetail.Student.UserId);
command.Parameters.AddWithValue("@taskId", taskdetail.Task.TaskId);
command.Parameters.AddWithValue("@taskFileUpload", string.IsNullOrEmpty(taskdetail.TaskFileUpload)
? (object)DBNull.Value : taskdetail.TaskFileUpload);
command.Parameters.AddWithValue("@taskSubmissionState", true);
command.Parameters.AddWithValue("@taskScore", taskdetail.TaskScore == null ? (object)DBNull.Value : taskdetail.TaskScore);
//Mở kết nối và thực hiện query vào database
connection.Open();
command.ExecuteNonQuery(); //Không có giá trị trả về: dùng ExecuteNonQuery
//Đóng kết nối
connection.Close();
}
//Trả về chính tham số truyền vào nếu hàm không xảy ra bất cứ lỗi gì
return(taskdetail);
}
public async Task <int> UpdateAsync(int id, TaskDetail entity)
{
entity.ProjectDetail = null;
entity.UserDetail = null;
projectManagerDbContext.Tasks.Update(entity);
return(await projectManagerDbContext.SaveChangesAsync());
}
public async Task <IActionResult> PutAsync(int id, [FromBody] TaskDetail taskDetail)
{
try
{
logger.LogInformation($"Updating task {id}");
if (taskDetail == null || id != taskDetail.Id)
{
logger.LogInformation("Invalid Task to edit");
return(BadRequest("Invalid task to edit."));
}
if (taskDetail.EndTask && !manageTask.IsTaskValidToClose(taskDetail))
{
logger.LogInformation("You can not close this task as the task have child tasks");
return(BadRequest("You can not close this task as the task have child tasks"));
}
await manageTask.EditTaskAsync(id, taskDetail);
logger.LogInformation($"Task Updated Successfully for the task name { taskDetail.Name } ");
return(Ok($"Task Updated Successfully for the task name { taskDetail.Name }"));
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError, "Internal Server error. Try again later"));
}
}
public async Task <int> EditTask(TaskDetail taskDetail)
{
taskDetail.ProjectDetail = null;
taskDetail.UserDetail = null;
_dbContext.Tasks.Update(taskDetail);
return(await _dbContext.SaveChangesAsync());
}
public async Task <int> InsertAsync(TaskDetail entity)
{
entity.UserDetail = null;
entity.ProjectDetail = null;
projectManagerDbContext.Tasks.Add(entity);
return(await projectManagerDbContext.SaveChangesAsync());
}
public bool IsTaskValidToClose(TaskDetail taskDetail)
{
logger.LogInformation("Check if Task is valid to close it");
var taskCollection = taskRepository.GetAllAsync().Result;
return(!taskCollection.Any(task => task.ParentId == taskDetail.Id && !task.EndTask));
}
/// <summary>
/// 转换成TaskDetailEditModel
/// </summary>
/// <returns></returns>
public static TaskDetailEditModel AsEditModel(this TaskDetail taskDetail)
{
string seconds = taskDetail.GetRulePart(RulePart.seconds);
string minutes = taskDetail.GetRulePart(RulePart.minutes);
string hours = taskDetail.GetRulePart(RulePart.hours);
string day = taskDetail.GetRulePart(RulePart.day);
string mouth = taskDetail.GetRulePart(RulePart.mouth);
string dayOfWeek = taskDetail.GetRulePart(RulePart.dayofweek) ?? string.Empty;
string[] rulePartArray = taskDetail.TaskRule.Split(' ');
TaskFrequency frequency = TaskFrequency.EveryDay;
if ((rulePartArray[3].Contains("/") || rulePartArray[3] == "*") && rulePartArray[4] == "*")
{
frequency = TaskFrequency.EveryDay;
}
else if (rulePartArray[5] != "?" && !rulePartArray[5].Contains("#"))
{
frequency = TaskFrequency.Weekly;
}
else
{
frequency = TaskFrequency.PerMonth;
}
bool dayRepeat = false;
for (int i = 0; i < 3; i++)
{
dayRepeat = rulePartArray[i].Contains("*") || rulePartArray[i].Contains("/");
if (dayRepeat)
{
break;
}
}
return(new TaskDetailEditModel()
{
TaskName = taskDetail.Name,
IsRepeat = taskDetail.TaskRule.Contains("/") || taskDetail.TaskRule.Contains("*"),
Seconds = seconds,
Minutes = minutes,
Hours = hours,
Day = day,
Mouth = mouth,
Frequency = frequency,
DayOrWeekly = !dayOfWeek.Contains("#"),
DayOfMouth = day,
WeeklyOfMouth = dayOfWeek.Contains("#") ? dayOfWeek.Substring(0, dayOfWeek.IndexOf("#")) : "2",
Number = dayOfWeek.Contains("#") ? dayOfWeek.Substring(dayOfWeek.IndexOf("#") + 1) : "1",
DayOfWeek = dayOfWeek.Contains("#") ? null : dayOfWeek.Split(','),
DayRepeat = dayRepeat,
OnceTime = !dayRepeat ? new DateTime(1, 1, 1, Convert.ToInt32(hours), Convert.ToInt32(minutes), Convert.ToInt32(seconds)) : new DateTime(1, 1, 1, 1, 0, 0),
StartDate = string.IsNullOrEmpty(taskDetail.StartDate.ToString()) ? DateTime.Now : taskDetail.StartDate,
EndDate = taskDetail.EndDate ?? new DateTime(),
Enabled = taskDetail.Enabled
});
}
//Add new Task details
public void Post(TaskDetail item)
{
using (CapsuleEntities1 db = new CapsuleEntities1())
{
db.TaskDetails.Add(item);
db.SaveChanges();
}
}
public ActionResult DeleteConfirmed(int id)
{
TaskDetail taskdetail = db.TaskDetails.Find(id);
db.TaskDetails.Remove(taskdetail);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public SubTask(int subTaskID, int taskID, int?childTaskID, string title, TaskDetail childTask)
{
this.SubTaskID = subTaskID;
this.TaskID = taskID;
this.ChildTaskID = childTaskID;
this.Title = title;
this.ChildTask = childTask;
}
public async Task TestEditTaskAsync_VerifyUpdateAsyncCalledOnce()
{
var mockRepository = new Mock <ITaskRepository>();
var manageTask = new ManageTask(mockRepository.Object, fixture.Logger);
var taskDetail = new TaskDetail();
var result = await manageTask.EditTaskAsync(10, taskDetail);
mockRepository.Verify(r => r.UpdateAsync(10, taskDetail), Times.Once);
}
public ActionResult DeleteConfirmed(int id)
{
TaskDetail taskDetail = db.Tasks.Find(id);
db.Tasks.Remove(taskDetail);
db.SaveChanges();
TempData["Success_delete"] = "The information was deleted.";
return(RedirectToAction("Index"));
}
public int UpdateTaskDetail(TaskDetail detailData)
{
if (this.treeview.UpdateTaskDetail(detailData))
{
return(detailData.JobCodeID);
}
return(0);
}
public ActionResult Update(int playerTaskId, FormCollection form)
{
PlayerTask pt = PlayerTask.Load(playerTaskId);
TaskDetail task = pt.GetTask.GetTaskDetail();
task.UpdateTask(pt, form);
return(null);
}
/// <summary>
/// 计算ApplicationData
/// </summary>
/// <param name="taskDetail"></param>
void ITask.Execute(TaskDetail taskDetail)
{
IEnumerable <IApplicationDataCalculater> applicationDataCalculaters = DIContainer.Resolve <IEnumerable <IApplicationDataCalculater> >();
foreach (var applicationDataCalculater in applicationDataCalculaters)
{
applicationDataCalculater.Calculate();
}
}
//Hàm lấy 1 thông tin bài tập theo Id
public TaskDetail GetOneTaskDetailById(long taskDetailId)
{
//Giá trị trả về của hàm này
TaskDetail queryResult = new TaskDetail();
//Câu lệnh truy vấn ở dạng string
string queryString = "SELECT * FROM TaskDetail WHERE TaskDetailId = @taskDetailId";
//Mở kết nối đến database
using (SqlConnection connection =
new SqlConnection(this.ConnectionString))
{
// Khởi tạo command với tham số truyền vào là TaskDetailId
SqlCommand command = new SqlCommand(queryString, connection);
command.Parameters.AddWithValue("@taskDetailId", taskDetailId);
//Mở kết nối và thực hiện query vào database
connection.Open();
SqlDataReader reader = command.ExecuteReader();
//Đọc dữ liệu trả về từ truy vấn ở trên
while (reader.Read())
{
//Lấy từng cột đọc được lưu vào queryResult
if (reader["TaskDetailId"] != DBNull.Value)
{
queryResult.TaskDetailId = (long)reader["TaskDetailId"];
}
if (reader["StudentId"] != DBNull.Value)
{
queryResult.Student.UserId = (long)reader["StudentId"];
}
if (reader["TaskId"] != DBNull.Value)
{
queryResult.Task.TaskId = (long)reader["TaskId"];
}
if (reader["TaskFileUpload"] != DBNull.Value)
{
queryResult.TaskFileUpload = (string)reader["TaskFileUpload"];
}
if (reader["TaskSubmissionState"] != DBNull.Value)
{
queryResult.TaskSubmissionState = (Boolean)reader["TaskSubmissionState"];
}
if (reader["TaskScore"] != DBNull.Value)
{
queryResult.TaskScore = (long)reader["TaskScore"];
}
//Đóng kết nối
reader.Close();
connection.Close();
}
//Trả về kết quả
return(queryResult);
}
}
public GroupRunner(ref Tuple<GroupDetails, TaskCollection> groupTuppleObject) {
InitializeComponent();
GroupTuppleObject = groupTuppleObject;
TaskCollectionObject = GroupTuppleObject.Item2;
TaskCount = TaskCollectionObject.TaskList.Count;
GetTaskDetailsDelegate = new TaskDetail(GetTaskDetails);
GroupNameLabel.Text = GroupTuppleObject.Item1.Name;
Text = "Group Runner : " + GroupTuppleObject.Item1.Name;
GroupIDLabel.Text = GroupTuppleObject.Item1.ID.ToString();
VerboseComboBox.SelectedIndex = 1;
if (TaskCount > 0) {
TasksLoadedCount = 0;
foreach (Task TaskObject in TaskCollectionObject.TaskList)
ThreadPool.QueueUserWorkItem(new WaitCallback(PopulateTasks), TaskObject);
}
}
public object Get(TaskDetail request)
{
if (request.TaskId == -1 || !IsLoggedIn) return UnauthorizedResponse();
try {
using (var conn = DbHelper.OpenConnection()) {
var cmd = new MySqlCommand {
Connection = conn,
CommandText = "GetTaskDetail",
CommandType = CommandType.StoredProcedure,
};
cmd.Parameters.AddWithValue("TaskId", request.TaskId);
var response = new Dictionary<string, dynamic> { { "success", 0 }, { "error", 0 } };
var reader = cmd.ExecuteReader();
if (reader.HasRows) {
response["success"] = 1;
reader.Read();
var numDicts = 0;
var numQuestions = 0;
response["taskname"] = reader.GetString("tsk_name");
response["campus"] = reader.GetString("c_name");
response["campuslat"] = reader.GetDouble("c_lat");
response["campuslng"] = reader.GetDouble("c_lng");
do {
numQuestions += reader.GetInt32("questions");
numDicts++;
response["numberofdic"] = numDicts;
response["questions"] = numQuestions;
} while (reader.Read());
} else {
response["error"] = 1;
response["error_msg"] = "No tasks found.";
}
return response;
}
} catch (Exception e) {
Log.Error(e.Message, e);
throw;
}
}
private void createGeneralInformationTask()
{
TaskInfo = new TaskDetail();
TaskInfo.Id = Guid.NewGuid();
TaskInfo.ContentTypeId = ApprovalInfoTask.ContentTypeId;
TaskInfo.TaskProperties = new SPWorkflowTaskProperties();
TaskInfo.TaskAfterProperties = new SPWorkflowTaskProperties();
TaskInfo.PercentComplete = 0f;
TaskInfo.InfoPathForm = ApprovalInfoTask.InfoPathForm;
}
public GroupCollection(string path, TaskDetail groupTaskDetailDelegate) {
if (File.Exists(path)) {
Path = path;
GroupTaskDetailDelegate = groupTaskDetailDelegate;
InitializeWithTimer(path);
} else Log.Write("GroupCollection::GroupCollection() Error -> Path Given Doesn't Exists. [" + path + "]");
}
public void PerformTask(TaskDetail taskDetail, UIOption Verbose = UIOption.OnlyErrorDialogs) {
try {
int TotalCount = 0, CurrentCount = 0;
string FileName, FileExtension, FileNewName;
taskDetail(-1, 0, "", "", ""); // Loading...
List<FileInfo> FileInfoList = new List<FileInfo>(Source.GetFiles());
FileInfoList = FileInfoList.FindAll(delegate (FileInfo fileInfoObject) {
return ExtensionRegex.IsMatch(fileInfoObject.Extension.ToLower())
&& NameRegex.IsMatch(Path.GetFileNameWithoutExtension(fileInfoObject.Name));
});
TotalCount = FileInfoList.Count;
List<Tuple<FileInfo, IEnumerable<FileTag>>> FileList = new List<Tuple<FileInfo, IEnumerable<FileTag>>>();
if (AttributeMatchList != null) {
IEnumerable<FileTag> FileTagInfoList, FileTagInfoListIntersected;
foreach (FileInfo FileInfoObject in FileInfoList) {
FileTagInfoList = GenerateFileInfo.GetFileTag(FileInfoObject.FullName);
FileTagInfoListIntersected = FileTagInfoList;
FileTagInfoListIntersected = FileTagInfoListIntersected.Intersect(AttributeMatchList);
if (FileTagInfoListIntersected.Count() > 0) FileList.Add(new Tuple<FileInfo, IEnumerable<FileTag>>(FileInfoObject, FileTagInfoList));
}
} else {
foreach (FileInfo FileInfoObject in FileInfoList)
FileList.Add(new Tuple<FileInfo, IEnumerable<FileTag>>(FileInfoObject, GenerateFileInfo.GetFileTag(FileInfoObject.FullName)));
}
TotalCount = FileList.Count;
CurrentCount = 0;
taskDetail(TotalCount, 0, "", "", ""); // Loading Done...
foreach (Tuple<FileInfo, IEnumerable<FileTag>> FileListObject in FileList) {
FileName = Path.GetFileNameWithoutExtension(FileListObject.Item1.Name);
FileExtension = Path.GetExtension(FileListObject.Item1.Name);
FileNewName = GetFormattedName(FileName, FileListObject.Item2);
taskDetail(TotalCount, CurrentCount, FileName, FileExtension, FileNewName);
switch (PerformType) {
case PerformTaskType.Copy:
FileSystem.CopyFile(FileListObject.Item1.FullName, Destination + "/" + FileNewName + FileExtension, Verbose);
break;
case PerformTaskType.Move:
FileSystem.MoveFile(FileListObject.Item1.FullName, Destination + "/" + FileNewName + FileExtension, Verbose);
break;
case PerformTaskType.Rename:
FileSystem.RenameFile(FileListObject.Item1.FullName, FileNewName + FileExtension);
break;
case PerformTaskType.Delete:
FileSystem.DeleteFile(FileListObject.Item1.FullName, Verbose, RecycleOption.SendToRecycleBin);
break;
default:
Log.Write("PerformTask() Warning -> Invalid PerformType Given In " + Name);
break;
}
taskDetail(TotalCount, ++CurrentCount, FileName, FileExtension, FileNewName);
}
} catch (Exception ex) {
Log.Write("Task::PerformTask() Error -> Task - " + Name + " [" + ex.Message + "]");
}
}
private TaskDetail applyProxy(TaskDetail taskDetail)
{
SPPrincipal principal = WorkflowProperties.Site.FindUserOrSiteGroup(taskDetail.InitialAssignTo);
if (principal == null)
return taskDetail;
CCIProxy proxy = principal.GetProxyUser(WorkflowProperties.Site);
if (proxy != null && !string.IsNullOrEmpty(proxy.DelegateUser.LoginName))
{
taskDetail.InitialAssignTo = proxy.DelegateUser.LoginName;
taskDetail.AssignToEmail = proxy.DelegateUser.Email;
sendCCEmail(proxy);
}
return taskDetail;
}
private void AddNewTask(string strApprover)
{
//not add when approver is exist in list
var varExist = from TaskDetail taskQuery in _listTasks
where string.Compare(taskQuery.InitialAssignTo.Trim(), strApprover.Trim(), true) == 0
select taskQuery;
if (varExist.Count<TaskDetail>() > 0) return;
TaskDetail task = new TaskDetail();
task.Id = Guid.NewGuid();
task.ContentTypeId = _approvalConfiguration.ContentTypeId;
task.InfoPathForm = _infoPathForm;
task.TaskProperties = new SPWorkflowTaskProperties();
task.TaskAfterProperties = new SPWorkflowTaskProperties();
if (!_isItemDocumentType)
_paramenters.TaskItemName = __ActivationProperties.Item.Title;
else
_paramenters.TaskItemName = Path.GetFileNameWithoutExtension(__ActivationProperties.Item.Name);
task.Title = string.IsNullOrEmpty(_approvalConfiguration.TaskTitlePrefix) ? _paramenters.TaskItemName :
_approvalConfiguration.TaskTitlePrefix.Trim() + " " + _paramenters.TaskItemName;
task.Body = _approvalConfiguration.TaskInstruction;
task.InitialAssignTo = strApprover;
if (SPUtility.IsLoginValid(__ActivationProperties.Web.Site, strApprover))
{
SPUser myUser = __ActivationProperties.Web.Site.RootWeb.EnsureUser(strApprover);
task.AssignToEmail = myUser.Email;
}
task.PercentComplete = 0f;
_listTasks.Add(task);
}
public void Update(TaskDetail task)
{
if (task == null)
{
return;
}
int index = QuartzTaskScheduler._tasks.FindIndex((TaskDetail n) => n.Id == task.Id);
if (QuartzTaskScheduler._tasks[index] == null)
{
return;
}
task.ClassType = QuartzTaskScheduler._tasks[index].ClassType;
task.LastEnd = QuartzTaskScheduler._tasks[index].LastEnd;
task.LastStart = QuartzTaskScheduler._tasks[index].LastStart;
task.LastIsSuccess = QuartzTaskScheduler._tasks[index].LastIsSuccess;
QuartzTaskScheduler._tasks[index] = task;
System.Type type = System.Type.GetType(task.ClassType);
if (type == null)
{
return;
}
this.Remove(type.Name);
if (!task.Enabled)
{
return;
}
string text = type.Name + "_trigger";
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
IScheduler scheduler = schedulerFactory.GetScheduler();
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.get_JobDataMap().Add(new System.Collections.Generic.KeyValuePair<string, object>("Id", task.Id));
TriggerBuilder triggerBuilder = CronScheduleTriggerBuilderExtensions.WithCronSchedule(TriggerBuilder.Create().WithIdentity(text), task.TaskRule);
if (task.StartDate > System.DateTime.MinValue)
{
triggerBuilder.StartAt(new System.DateTimeOffset(task.StartDate));
}
if (task.EndDate.HasValue && task.EndDate > task.StartDate)
{
TriggerBuilder arg_233_0 = triggerBuilder;
System.DateTime? endDate = task.EndDate;
arg_233_0.EndAt(endDate.HasValue ? new System.DateTimeOffset?(endDate.GetValueOrDefault()) : null);
}
ICronTrigger cronTrigger = (ICronTrigger)triggerBuilder.Build();
System.DateTime dateTime = scheduler.ScheduleJob(jobDetail, cronTrigger).DateTime;
task.NextStart = new System.DateTime?(TimeZoneInfo.ConvertTime(dateTime, cronTrigger.get_TimeZone()));
}
