public bool UpdateTaskTemplate(TaskTemplate taskTemplate)
{
var existingTask = db.TaskTemplates.FirstOrDefault(p => p.Id == taskTemplate.Id);
if (existingTask != null)
{
existingTask.Description = taskTemplate.Description;
existingTask.EstimatedDuration = taskTemplate.EstimatedDuration;
existingTask.IsFreeService = taskTemplate.IsFreeService;
existingTask.Notes = taskTemplate.Notes;
existingTask.DisplayOrder = taskTemplate.DisplayOrder;
db.SaveChanges();
}
else
{
var max = db.TaskTemplates.Max(t => t.DisplayOrder);
taskTemplate.DisplayOrder = max + 1;
db.TaskTemplates.Add(taskTemplate);
}
db.SaveChanges();
return(true);
}
void FillListView()
{
try
{
panel.Children.Clear();
Project project = projectCb.SelectedItem as Project;
for (int i = 0; i < Utils.db.Status.Count(); i++)
{
TaskTemplate tt = new TaskTemplate();
tt.DataContext = Utils.db.Task.Where(task =>
task.ExecutorId == _userId &&
task.ProjectId == project.Id &&
task.StatusId == i + 1).Select(task => new
{
Items = task,
btnText = i == 0 ? "В работе" : "Выполнено",
statusId = i == 0 ? 2 : 1,
visibility = i == 3 ? Visibility.Hidden : Visibility.Visible
}).ToList();
tt.Width = 200;
tt.StatusChanged += sttusChanged;
//Block block = new Block();
panel.Children.Add(tt);
}
}
catch (Exception ex)
{
Utils.Error("Ошибка: " + ex.Message);
}
}
public void Set(TaskTemplate taskInfo)
{
_taskInfo = taskInfo;
if (taskInfo == null)
{
EB.Debug.LogError("LTPromotionTaskItemController.Set -> taskInfo is null");
return;
}
_labName.text = taskInfo.task_name;
_labDesc.text = taskInfo.target_tips;
var currentNum = TaskUtility.GetEventCurrentNum(taskInfo.task_id);
var targetNum = TaskUtility.GetEventTargetNum(taskInfo.task_id);
_labProgress.text = LT.Hotfix.Utility.ColorUtility.FormatColorFullLevel(currentNum, targetNum);
_progressBar.value = currentNum / (float)targetNum;
var isFinished = TaskUtility.IsEventFinished(taskInfo.task_id);
_goGoBtn.SetActive(!isFinished);
_goDoneTips.SetActive(isFinished);
SetProgressBarForeground(isFinished);
}
public static int GetExpRewardNum(int taskid)
{
TaskTemplate taskTpl = TaskTemplateManager.Instance.GetTask(taskid);
if (taskTpl == null)
{
return(0);
}
if (taskTpl.xp.Length <= 0)
{
return(0);
}
int A = taskTpl.xp[0];
if (taskTpl.xp.Length >= 2)
{
int B = taskTpl.xp[1];
int lvl = BalanceResourceUtil.GetUserLevel();
return(A + B * lvl);
}
else
{
return(A);
}
}
public void Create()
{
int taskTemplateId;
if (IsUsingExitingTemplate)
{
taskTemplateId = SelectedTemplate.Id;
}
else
{
//Определение индекса последней выборки
List <Entity> taskTemplates = TaskTemplate.where (new Query("TaskTemplate").addTypeQuery(TypeQuery.select)
.addCondition("TaskId", "=", TaskId.ToString()), typeof(TaskTemplate));
string templateNameForEmptyField = "Template " + ((taskTemplates != null) ? taskTemplates.Count + 1 : 1);
string templateName = (newTemplateName == null || newTemplateName == "") ? templateNameForEmptyField : newTemplateName;
DataHelper helper = new DataHelper();
//ppParameters = null для главного шаблона
IPreprocessingParameters ppParameters = null;
taskTemplateId = helper.addTaskTemplate(templateName, TaskId, ppParameters);
}
ParameterCreationViewModel[] parameters = Parameters.ToArray();
selectionId = PreprocessingManager.PrepManager.parseSelection(taskTemplateId, filePath, delimiter.ToCharArray()[0],
TaskId, selectionName, parameters, HasHeader, IsUsingExitingTemplate);
PreprocessingManager.PrepManager.updateTask(TaskId, PreprocessingManager.PrepManager.getCountParameters(),
PreprocessingManager.PrepManager.getCountRows());
taskTreeVM.SendRequestCreateView(this);
OnClose?.Invoke(this, null);
}
// POST: odata/TaskTemplates
public IActionResult Post([FromBody] TaskTemplate taskTemplate)
{
var currentUser = CurrentUser();
// Ensure that user is authorized.
if (!currentUser.CanCreateProjects)
{
return(BadRequest());
}
// Auto-generated.
taskTemplate.CreatedAt = DateTime.UtcNow;
taskTemplate.OrganizationId = currentUser.OrganizationId;
// Validate the model.
ModelState.ClearValidationState(nameof(taskTemplate));
if (!TryValidateModel(taskTemplate, nameof(taskTemplate)))
{
return(BadRequest());
}
_context.TaskTemplates.Add(taskTemplate);
_context.SaveChanges();
return(Ok(taskTemplate));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Description")] TaskTemplate taskTemplate)
{
if (id != taskTemplate.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taskTemplate);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskTemplateExists(taskTemplate.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(taskTemplate));
}
// POST: odata/TaskTemplates
public IHttpActionResult Post(TaskTemplate taskTemplate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUser = CurrentUser();
// Ensure that user is authorized.
if (!currentUser.CanCreateProjects)
{
return(BadRequest());
}
// Auto-generated.
taskTemplate.CreatedAt = DateTime.UtcNow;
taskTemplate.OrganizationId = currentUser.OrganizationId;
db.TaskTemplates.Add(taskTemplate);
db.SaveChanges();
return(Created(taskTemplate));
}
public ServiceResult <TaskTemplate> UpdateTask(TaskTemplate taskTemplate)
{
var serviceResult = new ServiceResult <TaskTemplate>();
try
{
if (taskTemplate != null)
{
var task = Repository.Context.TASKS.FirstOrDefault(a => a.ID == taskTemplate.TaskId);
if (task != null)
{
task.NAME = taskTemplate.TaskName;
task.DESCRIPTION = taskTemplate.Description;
task.STATU_ID = taskTemplate.StatuId;
task.LEVEL_ID = taskTemplate.LevelId;
task.IS_ACTIVE = taskTemplate.IsActive;
task.IS_DELETED = taskTemplate.IsDeleted;
//task.CREATE_DATE = taskTemplate.CreateDate;
task.DATE = taskTemplate.Date;
}
Repository.Context.SaveChanges();
serviceResult.Result = taskTemplate;
}
}
catch (Exception ex)
{
serviceResult.HasError = true;
serviceResult.Exception = ex;
}
return(serviceResult);
}
public ServiceResult <TaskTemplate> PassiveTask(TaskTemplate taskTemplate)
{
var serviceResult = new ServiceResult <TaskTemplate>();
try
{
if (taskTemplate != null)
{
var task = Repository.Context.TASKS.FirstOrDefault(a => a.ID == taskTemplate.TaskId);
if (task != null)
{
task.IS_ACTIVE = false;
task.IS_DELETED = true;
}
Repository.Context.SaveChanges();
serviceResult.Result = taskTemplate;
}
}
catch (Exception ex)
{
serviceResult.HasError = true;
serviceResult.Exception = ex;
}
return(serviceResult);
}
public ActionResult Detail(int id, EventTaskTemplate model, string returnUrl, FormCollection m)
{
EventTaskTemplate p;
Entities cx = new Entities();
model.Data = TaskTemplate.ArrSerialize(TaskTemplate.ArrDeserialize(model.Data));
if (model.Id == 0)
{
p = model;
cx.EventTaskTemplate.Add(p);
cx.SaveChanges();
}
else
{
p = cx.EventTaskTemplate.Single(e => e.Id == id);
p.Name = model.Name;
p.Data = model.Data;
cx.SaveChanges();
}
// redirect
if (returnUrl != null && returnUrl.Length > 0)
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("TaskTemplate", "List"));
}
}
public ServiceResult <TaskTemplate> CreateTask(TaskTemplate taskTemplate)
{
var serviceResult = new ServiceResult <TaskTemplate>();
try
{
if (taskTemplate != null)
{
var task = new TASKS()
{
NAME = taskTemplate.TaskName,
DESCRIPTION = taskTemplate.Description,
STATU_ID = Int.One,
LEVEL_ID = taskTemplate.LevelId,
IS_ACTIVE = taskTemplate.IsActive,
IS_DELETED = taskTemplate.IsDeleted,
CREATE_DATE = DateTime.Now,
DATE = taskTemplate.Date,
};
Repository.Context.TASKS.Add(task);
Repository.Context.SaveChanges();
taskTemplate.TaskId = task.ID;
serviceResult.Result = taskTemplate;
}
}
catch (Exception ex)
{
serviceResult.HasError = true;
serviceResult.Exception = ex;
}
return(serviceResult);
}
public IActionResult TaskTemplate(TaskTemplate taskTemplate)
{
var taskTemplateService = this.GetService <TaskTemplateService>();
var groupId = this.GetService <DepartmentService>().GetUserGroupsByUserId(this.GetUserId()).FirstOrDefault().Id;
if (taskTemplate.Tasks.IsEmpty() && string.IsNullOrEmpty(taskTemplate.Id))
{
var dbTaskTemplate = taskTemplateService.Get(groupId);
ViewData["TaskTemplate"] = dbTaskTemplate;
return(View());
}
else
{
if (string.IsNullOrEmpty(taskTemplate.Id))
{
taskTemplate.Id = groupId;
taskTemplateService.Create(taskTemplate);
}
else
{
taskTemplateService.Update(taskTemplate.Id, "Tasks", taskTemplate.Tasks);
}
var successMsg = "Save template successfully!";
ViewData["TaskTemplate"] = taskTemplate;
this.BuildHeaderMsg(successMsg, string.Empty);
return(View());
}
}
public int SaveOrUpdate(TaskTemplate item)
{
var dbEntity = new DbTaskTemplate
{
Id = item.ID,
Title = item.Title,
CategoryId = item.CategoryID,
Description = item.Description,
ResponsibleId = item.ResponsibleID,
IsNotify = item.isNotify,
Offset = item.Offset.Ticks,
DeadLineIsFixed = item.DeadLineIsFixed,
ContainerId = item.ContainerID,
CreateOn = item.CreateOn == DateTime.MinValue ? DateTime.UtcNow : item.CreateOn,
CreateBy = item.CreateBy == Guid.Empty ? _securityContext.CurrentAccount.ID : item.CreateBy,
LastModifedOn = DateTime.UtcNow,
LastModifedBy = _securityContext.CurrentAccount.ID,
SortOrder = item.SortOrder,
TenantId = TenantID
};
CrmDbContext.Update(dbEntity);
CrmDbContext.SaveChanges();
return(dbEntity.Id);
}
private void importTask(ArchiveTask archTask)
{
models.Task task = new models.Task(archTask);
task.save();
List <Entity> temps = new List <Entity>();
foreach (ArchiveTemplate archTemp in archTask.Templates)
{
TaskTemplate temp = new TaskTemplate(archTemp);
temp.TaskID = task.ID;
temps.Add(temp);
}
DatabaseManager.SharedManager.insertMultipleEntities(temps);
foreach (ArchiveTemplate archTemp in archTask.Templates)
{
archTemp.ID = temps[archTask.Templates.IndexOf(archTemp)].ID;
importSelectionsAndParameters(archTemp);
}
List <Entity> solvers = new List <Entity>();
foreach (ArchiveTaskSolver archSolv in archTask.Solvers)
{
TaskSolver solv = new TaskSolver(archSolv);
solv.TaskID = task.ID;
solvers.Add(solv);
}
DatabaseManager.SharedManager.insertMultipleEntities(solvers);
foreach (ArchiveTaskSolver archSolv in archTask.Solvers)
{
archSolv.ID = solvers[archTask.Solvers.IndexOf(archSolv)].ID;
}
}
public object GetTaskTemplateById(int id)
{
object result = null;
TaskTemplate objTaskTemplate = new TaskTemplate();
try
{
using (_context)
{
objTaskTemplate = _context.TaskTemplate.FirstOrDefault(x => x.Id == id);
result = new
{
objTaskTemplate,
error = "0",
msg = "Success"
};
}
}
catch (Exception ex)
{
ex.ToString();
result = new
{
objTaskTemplate,
error = "1",
msg = "Error"
};
}
return(result);
}
public void updateTaskTemplate(int taskTemplateId, view_models.PreprocessingViewModel.PreprocessingTemplate pp)
{
TaskTemplate entity = (TaskTemplate)DatabaseManager.SharedManager.entityById(taskTemplateId, typeof(TaskTemplate));
entity.PreprocessingParameters = pp;
entity.save();
}
private void importTasksFromArchive(Archive archive)
{
List <Entity> tasks = models.Task.all(typeof(models.Task));
List <ArchiveTask> archTasks = archive.Tasks;
foreach (ArchiveTask archTask in archTasks)
{
var task = tasks.FirstOrDefault(x => archTask.equalsEntity(x));
if (task != null)
{
List <TaskTemplate> templates = TaskTemplate.templatesOfTaskId(task.ID);
List <ArchiveTemplate> archTemps = archTask.Templates;
foreach (ArchiveTemplate archTemp in archTemps)
{
var template = templates.FirstOrDefault(x => archTemp.equalsEntity(x));
if (template != null)
{
List <Selection> selections = Selection.selectionsOfTaskTemplateId(template.ID);
List <ArchiveSelection> archSels = archTemp.Selections;
foreach (ArchiveSelection archSel in archSels)
{
var selection = selections.FirstOrDefault(x => archSel.equalsEntity(x));
if (selection == null)
{
importSelection(archSel, template.ID);
}
else
{
archSel.ID = selection.ID;
}
}
}
else
{
importTemplate(archTemp, task.ID);
}
}
List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID);
List <ArchiveTaskSolver> archSolvs = archTask.Solvers;
foreach (ArchiveTaskSolver archSolver in archSolvs)
{
var solver = solvers.FirstOrDefault(x => archSolver.equalsEntity(x));
if (solver == null)
{
importTaskSolver(archSolver, task.ID);
}
else
{
archSolver.ID = solver.ID;
}
}
}
else
{
importTask(archTask);
}
}
}
public ActionResult SaveTask(TaskTemplate data)
{
try
{
Task templateTask;
if (data.directDescendant > 0)
{
templateTask = db.Tasks.Where(x => x.TaskID == data.directDescendant).FirstOrDefault();
}
else
{
templateTask = db.Tasks.Where(x => x.TaskID == data.templateTaskID).FirstOrDefault();
}
if (templateTask != null)
{
DateTime startDate = DateTime.Parse(data.startDate);
Task task = new Task();
task.TaskDescription = templateTask.TaskDescription;
task.SprintID = data.sprintID;
task.EmployeeID = data.employeeID;
task.StartDate = startDate;
task.EndDate = startDate;
task.Difficulty = templateTask.Difficulty;
if (templateTask.Estimation.HasValue)
{
task.Estimation = templateTask.Estimation;
}
if (!templateTask.TemplateID.HasValue || templateTask.TemplateID.Value <= 0)
{
task.TemplateID = data.templateTaskID;
}
else
{
task.TemplateID = templateTask.TemplateID;
}
string accessLevel = Common.CheckSprintAuthentication(Session, User);
if (accessLevel != Const.PermissionLevels.Administrator && accessLevel != Const.PermissionLevels.Manager)
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Could not save the new task. Insufficient permissions"));
}
db.Tasks.Add(task);
db.SaveChanges();
//jsonResponseText = JsonConvert.SerializeObject(task);
return(Json(task));
}
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Could not save the new task."));
}
catch (Exception ex)
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError, "Could not save the new task"));
}
}
public override void Apply(CreateTaskTemplate command)
{
var task = new TaskTemplate();
task.Create(command.Name, command.Description);
Repository.Save(task);
task.CreateNewVersion(string.Empty, new List <TaskTemplateParameter>());
Repository.Save(task);
}
private void importTemplate(ArchiveTemplate archTemp, int taskId)
{
TaskTemplate template = new TaskTemplate(archTemp);
template.TaskID = taskId;
template.save();
archTemp.ID = template.ID;
importSelectionsAndParameters(archTemp);
}
public ActionResult Edit(TaskTemplate template)
{
if (ModelState.IsValid)
{
RepositoryContext.Current.Update(template);
}
return(View(template));
}
public object UpdateTaskTemplate(int id, [FromBody] TaskTemplate model)
{
object result = null; string message = ""; string errorcode = ""; string excp = "";
if (model == null)
{
return(BadRequest());
}
using (_context)
{
using (var _ctxTransaction = _context.Database.BeginTransaction())
{
try
{
var entityUpdate = _context.TaskTemplate.FirstOrDefault(x => x.Id == id);
if (entityUpdate != null)
{
entityUpdate.TemplateName = model.TemplateName;
entityUpdate.FormName = model.FormName;
entityUpdate.TaskName = model.TaskName;
entityUpdate.Description = model.Description;
entityUpdate.Priority = model.Priority;
entityUpdate.TaskOwner = model.TaskOwner;
entityUpdate.DueDate = model.DueDate;
_context.SaveChanges();
}
var entityUpdateWorkFlowAction = _context.WorkFlowAction.FirstOrDefault(x => x.TaskId == id);
if (entityUpdateWorkFlowAction != null)
{
entityUpdateWorkFlowAction.Name = model.TaskName;
_context.SaveChanges();
}
_ctxTransaction.Commit();
message = "Entry Updated";
errorcode = "0";
}
catch (Exception e)
{
_ctxTransaction.Rollback(); e.ToString();
message = "Entry Update Failed!!";
errorcode = "1";
excp = e.ToString();
}
result = new
{
error = errorcode,
msg = message,
excp = excp
};
}
}
return(result);
}
public static List <LTShowItemData> GetItemRewardList(int taskid)
{
TaskTemplate taskTpl = TaskTemplateManager.Instance.GetTask(taskid);
if (taskTpl == null)
{
return(null);
}
List <LTShowItemData> dataList = new List <LTShowItemData>();
int expnum = GetExpRewardNum(taskid);
int goldnum = GetGoldRewardNum(taskid);
int hcnum = GetHcRewardNum(taskid);
if (expnum > 0)
{
if (BalanceResourceUtil.GetUserLevel() >= CharacterTemplateManager.Instance.GetMaxPlayerLevel())
{
dataList.Add(new LTShowItemData("poten-gold", expnum, LTShowItemType.TYPE_RES));
}
else
{
dataList.Add(new LTShowItemData("exp", expnum, LTShowItemType.TYPE_RES));
}
}
if (goldnum > 0)
{
dataList.Add(new LTShowItemData("gold", goldnum, LTShowItemType.TYPE_RES));
}
if (hcnum > 0)
{
dataList.Add(new LTShowItemData("hc", hcnum, LTShowItemType.TYPE_RES));
}
if (!string.IsNullOrEmpty(taskTpl.res_type) && taskTpl.res_count > 0)
{
dataList.Add(new LTShowItemData(taskTpl.res_type, taskTpl.res_count, LTShowItemType.TYPE_RES));
}
foreach (var reward in taskTpl.rewards.Items)
{
dataList.Add(new LTShowItemData(reward.Key.ToString(), reward.Value, LTShowItemType.TYPE_GAMINVENTORY));
}
int heroshardid = taskTpl.hero_shard;
int count = taskTpl.shard_count * 1;
if (heroshardid > 0 && count > 0)
{
dataList.Add(new LTShowItemData(heroshardid.ToString(), count, LTShowItemType.TYPE_HEROSHARD));
}
return(dataList);
}
public PreprocessingViewModel.PreprocessingTemplate getPreprocessingParameters(int selectionId)
{
//оперделяем шаблон для выборки и достаем из него PreprocessingParameters
Selection selection = ((Selection)services.DatabaseManager.SharedManager.entityById(selectionId, typeof(Selection)));
int templateId = selection.TaskTemplateID;
TaskTemplate template = ((TaskTemplate)services.DatabaseManager.SharedManager.entityById(templateId, typeof(TaskTemplate)));
PreprocessingViewModel.PreprocessingTemplate prepParameters = (PreprocessingViewModel.PreprocessingTemplate)template.PreprocessingParameters;
return(prepParameters);
}
public ActionResult Create(TaskTemplate template)
{
if (ModelState.IsValid)
{
RepositoryContext.Current.Add(template);
return(RedirectToAction("Index"));
}
return(View(template));
}
public int addTaskTemplate(string name, int taskId, IPreprocessingParameters ppParameters)
{
TaskTemplate entity = new TaskTemplate();
entity.Name = name;
entity.TaskID = taskId;
entity.PreprocessingParameters = ppParameters;
entity.save();
return(entity.ID);
}
public static int GetHcRewardNum(int taskid)
{
TaskTemplate taskTpl = TaskTemplateManager.Instance.GetTask(taskid);
if (taskTpl == null)
{
return(0);
}
return(taskTpl.hc);
}
public async Task <IActionResult> Create([Bind("ID,Name,Description,ProjectTemplateID")] TaskTemplate taskTemplate)
{
if (ModelState.IsValid)
{
_context.Add(taskTemplate);
await _context.SaveChangesAsync();
return(RedirectToAction("Edit", "ProjectTemplates", new { id = taskTemplate.ProjectTemplateID }));
}
return(View(taskTemplate));
}
public TaskTemplate GetTaskTemplate(int id)
{
TaskTemplate tasktemplate = db.TaskTemplates.FirstOrDefault(p => p.Id == id);
if (tasktemplate == null)
{
return(null);
}
return(tasktemplate);
}
