/// <summary>
/// Creates a Move Amendment. This will also create a new Operative paragraph at the palce where the amendment should be moved to. Not that this virtual Paragraph
/// will copy the text once when the amendment is created and once when the amendment is accepted. If the text of the paragraph changed in the mean time the displayed
/// text of the virtual operative paragraph may differ.
/// </summary>
/// <param name="section"></param>
/// <param name="paragraphId"></param>
/// <param name="targetIndex"></param>
/// <param name="parentParagraph"></param>
/// <returns></returns>
public static MoveAmendment CreateMoveAmendment(this OperativeSection section, string paragraphId, int targetIndex, OperativeParagraph parentParagraph = null)
{
var sourceParagraph = section.FindOperativeParagraph(paragraphId);
if (sourceParagraph == null)
{
throw new MUNity.Exceptions.Resolution.OperativeParagraphNotFoundException();
}
var newAmendment = new MoveAmendment
{
TargetSectionId = paragraphId
};
var virtualParagraph = new OperativeParagraph
{
IsLocked = true,
IsVirtual = true,
Text = sourceParagraph.Text
};
newAmendment.NewTargetSectionId = virtualParagraph.OperativeParagraphId;
section.InsertIntoRealPosition(virtualParagraph, targetIndex, parentParagraph);
section.PushAmendment(newAmendment);
return(newAmendment);
}
public void TestRemoveOperativeParagraphNotFoundException()
{
var resolution = new Resolution();
var fakeParagraph = new OperativeParagraph();
Assert.Throws <OperativeParagraphNotFoundException>(() => resolution.OperativeSection.RemoveOperativeParagraph(fakeParagraph));
}
/// <summary>
/// Creates a new Operative paragraph inside a given OperativeSection.
/// </summary>
/// <param name="section"></param>
/// <param name="text"></param>
/// <returns></returns>
public static OperativeParagraph CreateOperativeParagraph(this OperativeSection section, string text = "")
{
var paragraph = new OperativeParagraph
{
Text = text
};
section.Paragraphs.Add(paragraph);
return(paragraph);
}
/// <summary>
/// Creates a new Child paragraph in a given Resolution.
/// </summary>
/// <param name="section"></param>
/// <param name="parentId"></param>
/// <param name="text"></param>
/// <returns></returns>
public static OperativeParagraph CreateChildParagraph(this OperativeSection section, string parentId, string text = "")
{
var parentParagraph = section.FindOperativeParagraph(parentId);
if (parentParagraph == null)
{
throw new MUNity.Exceptions.Resolution.OperativeParagraphNotFoundException();
}
var newParagraph = new OperativeParagraph
{
Text = text
};
parentParagraph.Children.Add(newParagraph);
return(newParagraph);
}
/// <summary>
/// Creates a new Add Amendment to add a new operative paragraph at a certain position. This will also create a virtual Paragraph at the stop where
/// the new paragraph may be when it is accepted.
/// </summary>
/// <param name="section">The operative Section of the Resolution where this paragraph should be added.</param>
/// <param name="targetIndex">The index where the paragraph should be added.</param>
/// <param name="text">The Text of the new paragraph</param>
/// <param name="parentParagraph">Use this parent paragraph if the new paragraph should be a sub point</param>
/// <returns></returns>
public static AddAmendment CreateAddAmendment(this OperativeSection section, int targetIndex, string text = "", OperativeParagraph parentParagraph = null)
{
var virtualParagraph = new OperativeParagraph(text)
{
IsVirtual = true,
Visible = false
};
section.InsertIntoRealPosition(virtualParagraph, targetIndex, parentParagraph);
var amendment = new AddAmendment
{
TargetSectionId = virtualParagraph.OperativeParagraphId
};
section.PushAmendment(amendment);
return(amendment);
}
public static OperativeParagraph ToModel(this ResaOperativeParagraph sourceParagraph)
{
if (sourceParagraph.Children == null)
{
sourceParagraph.Children = new List <ResaOperativeParagraph>();
}
var model = new OperativeParagraph()
{
Children = sourceParagraph.Children.Select(n => n.ToModel()).ToList(),
Comment = sourceParagraph.Comment,
Corrected = sourceParagraph.Corrected,
IsLocked = sourceParagraph.IsLocked,
IsVirtual = sourceParagraph.IsVirtual,
Name = sourceParagraph.Name,
OperativeParagraphId = sourceParagraph.ResaOperativeParagraphId,
Text = sourceParagraph.Text,
Visible = sourceParagraph.Visible
};
return(model);
}
/// <summary>
/// An internal function to go throw all operative paragraphs and their child paragraphs and get the path of the paragraph.
/// </summary>
/// <param name="paragraph"></param>
/// <param name="targetId"></param>
/// <param name="path"></param>
/// <returns></returns>
private static OperativeParagraph FindOperativeParagraphPathRecursive(OperativeParagraph paragraph, string targetId, List <OperativeParagraph> path)
{
if (paragraph.OperativeParagraphId == targetId)
{
path.Add(paragraph);
return(paragraph);
}
if (paragraph.Children != null && paragraph.Children.Any())
{
foreach (var child in paragraph.Children)
{
var result = FindOperativeParagraphPathRecursive(child, targetId, path);
if (result != null)
{
path.Add(paragraph);
return(result);
}
}
}
return(null);
}
/// <summary>
/// Removes an Operative Paragraph from the Operative Section. Will also remove all the amendments that
/// are targeting this paragraph.
/// </summary>
/// <param name="section"></param>
/// <param name="paragraph"></param>
public static void RemoveOperativeParagraph(this OperativeSection section, OperativeParagraph paragraph)
{
var path = section.GetOperativeParagraphPath(paragraph.OperativeParagraphId);
if (path == null || !path.Any())
{
throw new MUNity.Exceptions.Resolution.OperativeParagraphNotFoundException();
}
if (path.Count == 1)
{
section.Paragraphs.Remove(paragraph);
}
else
{
path[path.Count - 1].Children.Remove(paragraph);
}
// TODO: Remove all Amendments of this paragraph and all its child paragraphs!
foreach (var amendment in section.AddAmendments.Where(n => n.TargetSectionId == paragraph.OperativeParagraphId).ToList())
{
section.RemoveAmendment(amendment);
}
foreach (var changeAmendment in section.ChangeAmendments.Where(n => n.TargetSectionId == paragraph.OperativeParagraphId).ToList())
{
section.RemoveAmendment(changeAmendment);
}
foreach (var deleteAmendment in section.DeleteAmendments.Where(n => n.TargetSectionId == paragraph.OperativeParagraphId).ToList())
{
section.RemoveAmendment(deleteAmendment);
}
foreach (var moveAmendment in section.MoveAmendments.Where(n => n.TargetSectionId == paragraph.OperativeParagraphId).ToList())
{
section.RemoveAmendment(moveAmendment);
}
}
/// <summary>
/// Only works on one level
/// </summary>
/// <param name="section"></param>
/// <param name="paragraph"></param>
/// <returns></returns>
public static int GetIndexOfParagraphNonVirtual(this OperativeSection section, OperativeParagraph paragraph)
{
int index = 0;
foreach (var p in section.Paragraphs)
{
if (!p.IsVirtual)
{
if (p == paragraph || p.OperativeParagraphId == paragraph.OperativeParagraphId)
{
break;
}
index++;
}
}
return(index);
}
/// <summary> /// Creates a new Text change amendment. /// </summary> /// <param name="section"></param> /// <param name="paragraph"></param> /// <param name="newText"></param> /// <returns></returns> public static ChangeAmendment CreateChangeAmendment(this OperativeSection section, OperativeParagraph paragraph, string newText = "") => section.CreateChangeAmendment(paragraph.OperativeParagraphId, newText);
/// <summary> /// Creates a new Move Amendment. The given targetIndex is the position the new Virtual Paragraph will be located. /// Type in 0 to move it to the beginning of the list. Note that 1 will also move it to the start! /// When you have two Paragraphs (A and B) and want A to move behind B (B, A) you need to set the targetIndex to 2! /// </summary> /// <param name="section">The Operative Section that you want to crate the Move Amendment at.</param> /// <param name="paragraph"></param> /// <param name="targetIndex"></param> /// <param name="parentParagraph"></param> /// <returns></returns> public static MoveAmendment CreateMoveAmendment(this OperativeSection section, OperativeParagraph paragraph, int targetIndex, OperativeParagraph parentParagraph = null) => section.CreateMoveAmendment(paragraph.OperativeParagraphId, targetIndex, parentParagraph);
/// <summary> /// Creates a new amendment to delete a certain operative paragraph. /// </summary> /// <param name="section"></param> /// <param name="paragraph"></param> /// <returns></returns> public static DeleteAmendment CreateDeleteAmendment(this OperativeSection section, OperativeParagraph paragraph) => section.CreateDeleteAmendment(paragraph.OperativeParagraphId);
/// <summary> /// Will also create a Child paragraph by calling the CreateChildParagraph function and pass the Id to it. /// </summary> /// <param name="section"></param> /// <param name="parent"></param> /// <param name="text"></param> /// <returns></returns> public static OperativeParagraph CreateChildParagraph(this OperativeSection section, OperativeParagraph parent, string text = "") => section.CreateChildParagraph(parent.OperativeParagraphId, text);
public static int GetIndexOfParagraph(this OperativeSection section, OperativeParagraph paragraph)
{
return(section.Paragraphs.IndexOf(paragraph));
}
/// <summary> /// Recursive function used by GetRealOperativeParagraphsInfo /// </summary> /// <param name="prePath"></param> /// <param name="paragraph"></param> /// <param name="list"></param> private static void AddRealOperativeParagraphInfoRec(string prePath, OperativeParagraph paragraph, List <(string id, string path, string text)> list)
public OperativeParagraphChangedEventArgs(string tan, string resolutionId, OperativeParagraph paragraph)
{
Tan = tan;
ResolutionId = resolutionId;
Paragraph = paragraph;
}
public OperativeParagraphChangedEventArgs(string resolutionId, OperativeParagraph paragraph)
{
this.ResolutionId = resolutionId;
this.Paragraph = paragraph;
}
