public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi especificado um item para editar", TempData, ModelState);
return(RedirectToAction("index"));
}
try
{
NodeLabel nodeLabel = await db.NodeLabels.FindAsync(id);
if (nodeLabel == null)
{
MensagemParaUsuarioViewModel.MensagemErro("O item não foi encontrado", TempData, ModelState);
return(RedirectToAction("index"));
}
return(View(nodeLabel));
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro(err.Message, TempData, ModelState);
return(RedirectToAction("index"));
}
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Nome,HorasEstimadas, IdNodeLabel")] ProjectNodeViewModel projectNodeVm)
{
if (ModelState.IsValid)
{
try
{
var existente = db.ProjectNodes.Any(x => (x.Pai_Id ?? 0) == (projectNodeVm.IdPai ?? 0) && x.Nome == projectNodeVm.Nome);
if (existente)
{
MensagemParaUsuarioViewModel.MensagemErro("Já existe um item com esse mesmo nome debaixo deste nó de projeto. \r\n Itens de projetos com nomes repetidos podem existir dentro de nós de projeto diferentes, mas não debaixo do mesmo nó.", TempData, ModelState);
CarregaNodeLabels();
return(View(projectNodeVm));
}
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Não foi possível pesquisar no banco de dados por este item.\r\n " + LogServices.ConcatenaExceptions(err), TempData, ModelState);
CarregaNodeLabels();
return(View(projectNodeVm));
}
try
{
ProjectNode pn = db.ProjectNodes.Find(projectNodeVm.Id);
NodeLabel nl = db.NodeLabels.Find(projectNodeVm.IdNodeLabel);
int?idpai = pn.Pai != null?pn.Pai.Id:new Nullable <int>();
pn.Nome = projectNodeVm.Nome;
pn.HorasEstimadas = projectNodeVm.HorasEstimadas;
pn.NodeLabel = nl;
await db.SaveChangesAsync();
return(RedirectToAction("Index", new { Id = idpai }));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. \r\n " + LogServices.ConcatenaExceptions(duce), TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. \r\n " + LogServices.ConcatenaExceptions(err), TempData, ModelState);
}
}
CarregaNodeLabels();
return(View(projectNodeVm));
}
/*
* Following methods are used for setting if a node is up and running, and it
* will update running nodes resource
*/
public virtual void ActivateNode(NodeId nodeId, Resource resource)
{
try
{
writeLock.Lock();
// save if we have a node before
IDictionary <string, CommonNodeLabelsManager.Host> before = CloneNodeMap(ImmutableSet
.Of(nodeId));
CreateHostIfNonExisted(nodeId.GetHost());
try
{
CreateNodeIfNonExisted(nodeId);
}
catch (IOException)
{
Log.Error("This shouldn't happen, cannot get host in nodeCollection" + " associated to the node being activated"
);
return;
}
CommonNodeLabelsManager.Node nm = GetNMInNodeSet(nodeId);
nm.resource = resource;
nm.running = true;
// Add node in labelsCollection
ICollection <string> labelsForNode = GetLabelsByNode(nodeId);
if (labelsForNode != null)
{
foreach (string label in labelsForNode)
{
NodeLabel labelInfo = labelCollections[label];
if (labelInfo != null)
{
labelInfo.AddNodeId(nodeId);
}
}
}
// get the node after edition
IDictionary <string, CommonNodeLabelsManager.Host> after = CloneNodeMap(ImmutableSet
.Of(nodeId));
UpdateResourceMappings(before, after);
}
finally
{
writeLock.Unlock();
}
}
public virtual IList <NodeLabel> PullRMNodeLabelsInfo()
{
try
{
readLock.Lock();
IList <NodeLabel> infos = new AList <NodeLabel>();
foreach (KeyValuePair <string, NodeLabel> entry in labelCollections)
{
NodeLabel label = entry.Value;
infos.AddItem(label.GetCopy());
}
infos.Sort();
return(infos);
}
finally
{
readLock.Unlock();
}
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Nome")] NodeLabel nodeLabel)
{
if (ModelState.IsValid)
{
try
{
db.Entry(nodeLabel).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser salvo. " + err.Message, TempData, ModelState);
}
}
return(View(nodeLabel));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
NodeLabel nodeLabel = new NodeLabel {
Id = id
};
var count = (from p in db.ProjectNodes
where p.NodeLabel.Id == nodeLabel.Id
select p).Count();
if (count > 0)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse rótulo não pode ser excluído porque está associado a projetos.", TempData, ModelState);
return(View(nodeLabel));
}
try
{
db.Entry(nodeLabel).State = EntityState.Deleted;
await db.SaveChangesAsync();
MensagemParaUsuarioViewModel.MensagemSucesso("Registro Excluido.", TempData);
return(RedirectToAction("Index"));
}
catch (DbUpdateConcurrencyException duce)
{
MensagemParaUsuarioViewModel.MensagemErro(" Talvez esse registro tenha sido excluído por outra pessoa. " + duce.Message, TempData, ModelState);
}
catch (Exception err)
{
MensagemParaUsuarioViewModel.MensagemErro("Esse registro não pôde ser excluído. " + err.Message, TempData, ModelState);
}
return(View(nodeLabel));
}
public async Task <JsonResult> Salvar([Bind(Include = "Id, Nome, Descricao, HorasEstimadas, IdPai, IdNodeLabel, NomeNodeLabel")] ProjectNodeViewModel projectNodeVm)
{
MensagemParaUsuarioViewModel result = new MensagemParaUsuarioViewModel();
if (ModelState.IsValid)
{
try
{
var existente = db.ProjectNodes.Any(x => (x.Pai_Id ?? 0) == projectNodeVm.IdPai && x.Nome == projectNodeVm.Nome && x.Id != projectNodeVm.Id);
if (existente)
{
result.Titulo = "Nome Duplicado.";
result.Mensagem = "Já existe um item com esse mesmo nome debaixo deste nó de projeto. \r\n Itens de projetos com nomes repetidos podem existir dentro de nós de projeto diferentes, mas não debaixo do mesmo nó.";
result.Sucesso = false;
return(Json(result));
}
}
catch (Exception err)
{
result.Titulo = "Erro.";
result.Mensagem = "Não foi possível pesquisar no banco de dados por este item.\r\n " + LogServices.ConcatenaExceptions(err);;
result.Sucesso = false;
return(Json(result));
}
ProjectNode pn = new ProjectNode();
if (projectNodeVm.Id > 0)
{
pn = db.ProjectNodes.Find(projectNodeVm.Id) ?? new ProjectNode();
}
else
{
//só procura o pai para novos
if ((projectNodeVm.IdPai ?? 0) > 0)
{
ProjectNode pai = db.ProjectNodes.Where(x => x.Id == projectNodeVm.IdPai).FirstOrDefault();
if (pai != null)
{
pn.Pai = pai;
}
}
db.ProjectNodes.Add(pn);
}
pn.HorasEstimadas = projectNodeVm.HorasEstimadas;
pn.Nome = projectNodeVm.Nome;
pn.Descricao = projectNodeVm.Descricao;
if ((projectNodeVm.IdNodeLabel ?? 0) > 0)
{
NodeLabel nl = db.NodeLabels.Find(projectNodeVm.IdNodeLabel);
if (nl != null)
{
pn.NodeLabel = nl;
projectNodeVm.NomeNodeLabel = nl.Nome;
}
}
try
{
await db.SaveChangesAsync();
result.Titulo = "Salvar nó de projeto.";
result.Mensagem = "Salvo com sucesso!";
//atualiza o projectNodeVm para os dados voltarem para o node da treeview
projectNodeVm.Id = pn.Id;
projectNodeVm.IdPai = pn.Pai != null ? pn.Pai.Id : new Nullable <int>();
result.Objeto = projectNodeVm;
result.Sucesso = true;
}
catch (DbUpdateConcurrencyException duce)
{
result.Titulo = "Erro de concorrência ao salvar.";
result.Mensagem = "Talvez esse registro tenha sido excluído por outra pessoa. \r\n " + LogServices.ConcatenaExceptions(duce);
result.Sucesso = false;
}
catch (Exception err)
{
result.Titulo = "Erro ao salvar.";
result.Mensagem = "Esse registro não pôde ser salvo.\r\n " + LogServices.ConcatenaExceptions(err);;
result.Sucesso = false;
}
}
else
{
result.Titulo = "Estado inválido";
result.Mensagem = "Favor corrigir erros de preenchimento do formulário";
result.Sucesso = false;
}
return(Json(result));
}
private void UpdateResourceMappings(IDictionary <string, CommonNodeLabelsManager.Host
> before, IDictionary <string, CommonNodeLabelsManager.Host> after)
{
// Get NMs in before only
ICollection <NodeId> allNMs = new HashSet <NodeId>();
foreach (KeyValuePair <string, CommonNodeLabelsManager.Host> entry in before)
{
Sharpen.Collections.AddAll(allNMs, entry.Value.nms.Keys);
}
foreach (KeyValuePair <string, CommonNodeLabelsManager.Host> entry_1 in after)
{
Sharpen.Collections.AddAll(allNMs, entry_1.Value.nms.Keys);
}
// Map used to notify RM
IDictionary <NodeId, ICollection <string> > newNodeToLabelsMap = new Dictionary <NodeId
, ICollection <string> >();
// traverse all nms
foreach (NodeId nodeId in allNMs)
{
CommonNodeLabelsManager.Node oldNM;
if ((oldNM = GetNMInNodeSet(nodeId, before, true)) != null)
{
ICollection <string> oldLabels = GetLabelsByNode(nodeId, before);
// no label in the past
if (oldLabels.IsEmpty())
{
// update labels
NodeLabel label = labelCollections[NoLabel];
label.RemoveNode(oldNM.resource);
// update queues, all queue can access this node
foreach (RMNodeLabelsManager.Queue q in queueCollections.Values)
{
Resources.SubtractFrom(q.resource, oldNM.resource);
}
}
else
{
// update labels
foreach (string labelName in oldLabels)
{
NodeLabel label = labelCollections[labelName];
if (null == label)
{
continue;
}
label.RemoveNode(oldNM.resource);
}
// update queues, only queue can access this node will be subtract
foreach (RMNodeLabelsManager.Queue q in queueCollections.Values)
{
if (IsNodeUsableByQueue(oldLabels, q))
{
Resources.SubtractFrom(q.resource, oldNM.resource);
}
}
}
}
CommonNodeLabelsManager.Node newNM;
if ((newNM = GetNMInNodeSet(nodeId, after, true)) != null)
{
ICollection <string> newLabels = GetLabelsByNode(nodeId, after);
newNodeToLabelsMap[nodeId] = ImmutableSet.CopyOf(newLabels);
// no label in the past
if (newLabels.IsEmpty())
{
// update labels
NodeLabel label = labelCollections[NoLabel];
label.AddNode(newNM.resource);
// update queues, all queue can access this node
foreach (RMNodeLabelsManager.Queue q in queueCollections.Values)
{
Resources.AddTo(q.resource, newNM.resource);
}
}
else
{
// update labels
foreach (string labelName in newLabels)
{
NodeLabel label = labelCollections[labelName];
label.AddNode(newNM.resource);
}
// update queues, only queue can access this node will be subtract
foreach (RMNodeLabelsManager.Queue q in queueCollections.Values)
{
if (IsNodeUsableByQueue(newLabels, q))
{
Resources.AddTo(q.resource, newNM.resource);
}
}
}
}
}
// Notify RM
if (rmContext != null && rmContext.GetDispatcher() != null)
{
rmContext.GetDispatcher().GetEventHandler().Handle(new NodeLabelsUpdateSchedulerEvent
(newNodeToLabelsMap));
}
}
internal Edge(EdgeLabel label, NodeLabel target)
{
Label = label;
TargetLabel = target;
}
internal Node(NodeLabel label, IEnumerable <Edge> edges = null)
{
Label = label;
Edges = (edges ?? new List <Edge>()).ToList();
}
public void UndoLast()
{
if (undoactions.Count >= 1)
{
MindNodeAction action = undoactions.Last();
undoactions.Remove(action);
switch (action.name)
{
case "CreateNode":
if (action.involvedNodes.Count >= 1)
{
MindNode createdNode = action.involvedNodes.Pop();
redoactions.Add(new MindNodeAction(1, "DeleteNode", createdNode));
createdNode.DeleteNode();
}
break;
case "DeleteNode":
if (action.involvedNodes.Count >= 1)
{
MindNode deletednode = action.involvedNodes.Pop();
redoactions.Add(new MindNodeAction(0, "CreateNode", deletednode));
if (deletednode.parent != null)
{
deletednode.parent.AddChildNoStyle(deletednode, false);
}
// Refresh Pivot Representation after reinstating node
deletednode.UpdatePivots();
}
break;
case "MoveNodes":
if (action.involvedNodes.Count >= 1)
{
MindNodeAction newaction = new MindNodeAction(2, "MoveNodes");
foreach (MindNode movedNode in action.involvedNodes)
{
newaction.involvedNodes.Push(movedNode);
newaction.startpoint.Push(new CalcPoint(movedNode.xpos, movedNode.ypos));
if (action.startpoint.Count > 0)
{
CalcPoint oldPos = action.startpoint.Pop();
movedNode.SetPosition(oldPos.X, oldPos.Y, false);
}
// Refresh Pivot Representation after moving node
movedNode.UpdatePivots();
}
redoactions.Add(newaction);
}
break;
case "ConnectNodes":
if (action.involvedNodes.Count >= 2)
{
MindNodeAction newAction = new MindNodeAction(3, "DeleteConnections");
for (int i = 0; i < action.involvedNodes.Count / 2; i++)
{
MindNode rightnode = action.involvedNodes.Pop();
MindNode leftnode = action.involvedNodes.Pop();
newAction.involvedNodes.Push(leftnode);
newAction.involvedNodes.Push(rightnode);
leftnode.DeleteConnection(rightnode);
}
redoactions.Add(newAction);
}
break;
case "DeleteConnections":
if (action.involvedNodes.Count >= 2)
{
MindNodeAction newAction = new MindNodeAction(3, "ConnectNodes");
for (int i = 0; i < action.involvedNodes.Count / 2; i++)
{
MindNode rightnode = action.involvedNodes.Pop();
MindNode leftnode = action.involvedNodes.Pop();
MindNode rightExistingNode = GlobalNodeHandler.masterNode.GetExistingNode(rightnode.id);
MindNode leftExistingNode = GlobalNodeHandler.masterNode.GetExistingNode(rightnode.id);
newAction.involvedNodes.Push(leftnode);
newAction.involvedNodes.Push(rightnode);
//leftnode.AddConnection(rightnode);
// Refresh Pivot Representation after reinstating connection
//leftnode.UpdatePivots();
}
redoactions.Add(newAction);
}
break;
case "ChangeText":
if (action.involvedNodes.Count >= 1)
{
MindNodeAction newaction = new MindNodeAction(4, "ChangeText");
MindNode changedNode = action.involvedNodes.Pop();
newaction.text = changedNode.text;
newaction.involvedNodes.Push(changedNode);
changedNode.SetText(action.text);
redoactions.Add(newaction);
}
else if (action.involvedLabel != null)
{
MindNodeAction newaction = new MindNodeAction(4, "ChangeText");
NodeLabel changedLabel = action.involvedLabel;
newaction.text = changedLabel.GetText();
newaction.involvedLabel = changedLabel;
changedLabel.SetText(action.text);
redoactions.Add(newaction);
}
break;
case "Transform":
if (action.involvedNodes.Count >= 1)
{
MindNodeAction newaction = new MindNodeAction(5, "Transform");
MindNode changedNode = action.involvedNodes.Pop();
newaction.sourceSize.X = changedNode.width;
newaction.sourceSize.Y = changedNode.height;
newaction.startpoint.Push(new CalcPoint(changedNode.xpos, changedNode.ypos));
newaction.involvedNodes.Push(changedNode);
if (action.sourceSize.X != -1)
{
changedNode.width = action.sourceSize.X;
changedNode.SetScaled(false);
}
if (action.sourceSize.Y != -1)
{
changedNode.height = action.sourceSize.Y;
changedNode.SetScaled(false);
}
CalcPoint oldPos = action.startpoint.Pop();
if (oldPos != null)
{
changedNode.SetPosition(oldPos.X, oldPos.Y, false);
}
// Refresh Pivot Representation after resetting transformation
changedNode.UpdatePivots();
changedNode.updateRepresentation();
redoactions.Add(newaction);
}
break;
}
}
}
