private void DeletePartsWithNoData(ref List <Run> fieldCodes, ref RecursiveDatasHolder recDatas)
{
List <string> fieldCodeNames = CollectFieldCodeNames(ref fieldCodes);
// List<Tuple<int, int>>-ben tároljuk azt, hogy milyen indexek között helyezkednek el a nem használt elemek
List <Tuple <int, int> > locations = new List <Tuple <int, int> >();
/*
* Kiszedjük a Run listából azoknak az elemeknek a kezdő és záró indexét, amikhez nem tartozik elem az adatfile-ból
* Majd miután ez meg van, ezeket kitöröljük a file-ból
*/
for (int i = 0; i < fieldCodeNames.Count - 1; ++i)
{
if (!AnyRecContains(fieldCodeNames[i], ref recDatas) && fieldCodeNames[i].StartsWith("R_"))
{
int startIndex = i;
int endIndex = FindEndIndex(fieldCodes, fieldCodeNames[i], startIndex);
locations.Add(new Tuple <int, int>(startIndex, endIndex));
}
}
//A végén csak végig megyünk az indexeken és a 2 közti elemeket töröljük
foreach (var location in locations)
{
DeleteUnusedParts(ref fieldCodes, location.Item1, location.Item2);
}
}
private List <KeyValuePair <string, int> > RecWithMoreOccurences(RecursiveDatasHolder datas)
{
List <KeyValuePair <string, int> > temp = new List <KeyValuePair <string, int> >();
foreach (var recData in datas.Datas)
{
foreach (var innerData in recData.Values)
{
if (innerData is RecursiveData)
{
var castedData = innerData as RecursiveData;
if (castedData.Values.Count > 0)
{
string tagName = castedData.Values[0].Name;
int sum = 0;
foreach (var mostInnerData in castedData.Values)
{
if (mostInnerData.Name == tagName)
{
sum++;
}
}
if (sum > 1)
{
temp.Add(new KeyValuePair <string, int>(castedData.Name, sum - 1));
}
}
}
}
}
return(temp);
}
/*
* Megtaláljuk R_* kezdését, illetve a végét /R_*-ot.
* Lemásoljuk annyiszor, ahány adat van a listába
* Majd végig iterálunk a tag-eken és alkalmazzuk a SwapDataInSubList-et
*/
public void MergeData(WordprocessingDocument doc, BaseData baseData)
{
RecursiveDatasHolder recDatas = baseData as RecursiveDatasHolder;
List <Run> runs = GetRuns(doc);
//Kitöröljük azokat a részeket, amikhez nem tartozik adat az adatfile-ból
DeletePartsWithNoData(ref runs, ref recDatas);
//Minden megmaradó Recursive részhez kigyüjtjük a kezdő és a záró indexeket
Dictionary <string, Tuple <int, int> > recLocations = GetStartAndEndIndexes(runs);
//A kezdő és záró indexekkel (recLocations) copyzzuk annyiszor, ahányszor előfordul az adat
CloneAllRecursiveFields(runs, recLocations, recDatas);
//Kigyüjtjük a FieldCode-okat és elkezdjük cserélgetni az adatokat
List <FieldCode> fieldCodes = doc.MainDocumentPart.RootElement.Descendants <FieldCode>().ToList();
List <FieldCode> newFc = FilterFieldCodes(fieldCodes);
Dictionary <string, List <string> > datasInDict = TransformRecDatasToDict(recDatas);
WordDataSwapper swapper = new WordDataSwapper();
foreach (var fc in newFc)
{
swapper.SwapFieldCode(fc, datasInDict);
}
runs = GetRuns(doc);
foreach (var run in runs)
{
DeleteFlagTags(run);
}
}
public void MergeRecursiveFields(List <RecursiveData> values)
{
using (WordprocessingDocument doc = WordprocessingDocument.Open(path, true))
{
RecursiveDatasHolder holder = new RecursiveDatasHolder(values);
new WordGeneratorRecursive().MergeData(doc, holder);
}
}
private Dictionary <string, List <string> > TransformRecDatasToDict(RecursiveDatasHolder datas)
{
Dictionary <string, List <string> > temp = new Dictionary <string, List <string> >();
for (int i = 0; i < datas.Datas.Count; ++i)
{
foreach (var innerData in datas.Datas[i].Values)
{
string name = innerData.Name;
if (name.Contains("G_"))
{
GroupData gData = innerData as GroupData;
foreach (var fData in gData.Values)
{
if (!temp.ContainsKey(fData.Name))
{
temp[fData.Name] = new List <string>
{
fData.Value.Value
};
}
else
{
temp[fData.Name].Add(fData.Value.Value);
}
}
}
else
{
RecursiveData rData = innerData as RecursiveData;
foreach (var inRecData in rData.Values)
{
GroupData gData = inRecData as GroupData;
foreach (var fData in gData.Values)
{
if (!temp.ContainsKey(fData.Name))
{
temp[fData.Name] = new List <string>
{
fData.Value.Value
};
}
else
{
temp[fData.Name].Add(fData.Value.Value);
}
}
}
}
}
}
return(temp);
}
private bool AnyRecContains(string fcName, ref RecursiveDatasHolder recDatas)
{
foreach (var rc in recDatas.Datas)
{
if (rc.Name == fcName)
{
return(true);
}
if (HasRecChild(rc))
{
foreach (var child in rc.Values)
{
if (child.Name == fcName)
{
return(true);
}
}
}
}
return(false);
}
private void CloneAllRecursiveFields(List <Run> runs, Dictionary <string, Tuple <int, int> > locations, RecursiveDatasHolder datas)
{
List <KeyValuePair <string, int> > recDataToCopy = RecWithMoreOccurences(datas);
//Majd meg kéne nézni, hogy miért nem másolja le normálisan!!
//recDataToCopy.Add(new KeyValuePair<string, int>("R_ILLETMENYEK_KERKIEG", 3));
foreach (var data in recDataToCopy)
{
Tuple <int, int> temp = locations[data.Key];
int num1 = temp.Item1 + 3;
int num2 = temp.Item2 - 2;
CloneSpecificRecursiveFields(runs, /*temp.Item1*/
num1, num2, data.Value);
}
}