private FieldElement GetDateFieldElement(ComponentPart componentPart)
{
if (componentPart == null || componentPart.Elements == null || !componentPart.Elements.Any())
{
return(null);
}
FieldElement dateFieldElement = componentPart.Elements.Where(element =>
{
DateTimeFieldElement dateTimeFieldElement = element as DateTimeFieldElement;
if (dateTimeFieldElement != null)
{
return(true);
}
TextFieldElement textFieldElement = element as TextFieldElement;
if (textFieldElement != null)
{
return(true);
}
return(false);
}).FirstOrDefault() as FieldElement;
return(dateFieldElement);
}
//Version 2.0 script can be attached to both date/time field element as well as text field element
//Format date range (if applicable)
//Enter date range as: dd.MM.yyyy - dd.MM.yyyy
//Format it to: dd.-dd. MMMM yyyy e.g.
public IEnumerable <ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
{
CultureInfo targetCulture = CultureInfo.CreateSpecificCulture("de-DE");
handled = false;
if (citation == null)
{
return(null);
}
if (citation.Reference == null)
{
return(null);
}
if (componentPart == null)
{
return(null);
}
if (componentPart.Elements == null || componentPart.Elements.Count != 1)
{
return(null);
}
FieldElement firstDateContainingFieldElement = componentPart.Elements.Where(element =>
{
DateTimeFieldElement dateTimeFieldElement = element as DateTimeFieldElement;
if (dateTimeFieldElement != null)
{
return(true);
}
TextFieldElement textFieldElement = element as TextFieldElement;
if (textFieldElement != null)
{
return(true);
}
return(false);
}).FirstOrDefault() as FieldElement;
if (firstDateContainingFieldElement == null)
{
return(null);
}
ReferencePropertyId referencePropertyId = firstDateContainingFieldElement.PropertyId;
Reference referenceResolved = componentPart.Scope == ComponentPartScope.ParentReference ? citation.Reference.ParentReference : citation.Reference;
if (referenceResolved == null)
{
return(null);
}
string date = referenceResolved.GetValue(referencePropertyId) as string;
if (string.IsNullOrEmpty(date))
{
return(null);
}
FontStyle fontStyle =
firstDateContainingFieldElement is DateTimeFieldElement ?
((DateTimeFieldElement)firstDateContainingFieldElement).FontStyle :
((TextFieldElement)firstDateContainingFieldElement).FontStyle;
DateTime dateSingle;
DateTime dateA;
DateTime dateB;
CultureInfo deDE = new CultureInfo("de-DE");
string[] formats = new string[] { "dd.MM.yyyy", "d.M.yyyy", "d.MM.yyyy", "dd.M.yyyy", "dd.MM.yy", "d.M.yy", "d.MM.yy", "dd.M.yy" };
//try single date first
var found = DateTime.TryParseExact(date, formats, deDE, DateTimeStyles.None, out dateSingle);
if (found)
{
var monthStringShort = dateSingle.ToString("MMM", targetCulture);
var monthStringLong = dateSingle.ToString("MMMM", targetCulture);
var monthString = monthStringShort == monthStringLong ? monthStringShort : monthStringShort + ".";
var yearString = dateSingle.ToString("yyyy");
var dayString = dateSingle.Day.ToString("D2");
var outputFormatSingle = "{0} {1}, {2}";
var dateSingleText = string.Format(outputFormatSingle, monthString, dayString, yearString);
var outputSingleDate = new TextUnitCollection();
var textSingleDate = new LiteralTextUnit(dateSingleText);
textSingleDate.FontStyle = fontStyle;
outputSingleDate.Add(textSingleDate);
handled = true;
return(outputSingleDate);
}
//then try date range
List <string> dates = date.Split('-').Select(d => d.Trim()).ToList();
if (dates.Count != 2)
{
return(null);
}
var foundA = DateTime.TryParseExact(dates.ElementAt(0), formats, deDE, DateTimeStyles.None, out dateA);
var foundB = DateTime.TryParseExact(dates.ElementAt(1), formats, deDE, DateTimeStyles.None, out dateB);
if (!foundA || !foundB)
{
return(null);
}
var monthAStringShort = dateA.ToString("MMM", targetCulture);
var monthAStringLong = dateA.ToString("MMMM", targetCulture);
var monthAString = monthAStringShort == monthAStringLong ? monthAStringShort : monthAStringShort + ".";
var monthBStringShort = dateB.ToString("MMM", targetCulture);
var monthBStringLong = dateB.ToString("MMMM", targetCulture);
var monthBString = monthBStringShort == monthBStringLong ? monthBStringShort : monthBStringShort + ".";
var yearAString = dateA.ToString("yyyy");
var yearBString = dateB.ToString("yyyy");
var dayAString = dateA.Day.ToString("D2");
var dayBString = dateB.Day.ToString("D2");
string outputFormat = string.Empty;
string dateRangeText = string.Empty;
//same year, same month
if (dateA.Year == dateB.Year && dateA.Month == dateB.Month && dateA.Day != dateB.Day)
{
outputFormat = "{0}.-{1}. {2} {3}"; //e.g. 08.-11. September 2013
dateRangeText = string.Format(outputFormat, dayAString, dayBString, monthAStringLong, yearAString);
}
//same year, different months
else if (dateA.Year == dateB.Year && dateA.Month != dateB.Month)
{
outputFormat = "{0}. {1} - {2}. {3} {4}"; //e.g. 27. September - 04. Oktober 2013
dateRangeText = string.Format(outputFormat, dayAString, monthAStringLong, dayBString, monthBStringLong, yearAString);
}
//different years
else
{
outputFormat = "{0}. {1} {2} - {3}. {4} {5}"; //e.g. 27. Dezember 2013 - 04. Januar 2014
dateRangeText = string.Format(outputFormat, dayAString, monthAStringLong, yearAString, dayBString, monthBStringLong, yearBString);
}
var output = new TextUnitCollection();
var text = new LiteralTextUnit(dateRangeText);
text.FontStyle = fontStyle;
output.Add(text);
handled = true;
return(output);
}
public IEnumerable <ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
{
//return handled = true if this macro generates the output (as an IEnumerable<ITextUnit>); the standard output will be suppressed
//return handled = false if you want Citavi to produce the standard output;
handled = false;
if (citation == null)
{
return(null);
}
if (citation.Reference == null)
{
return(null);
}
if (componentPart == null)
{
return(null);
}
if (componentPart.Elements == null || componentPart.Elements.Count == 0)
{
return(null);
}
Reference referenceInScope = null;
if (componentPart.Scope == ComponentPartScope.Reference)
{
referenceInScope = citation.Reference;
}
else if (componentPart.Scope == ComponentPartScope.ParentReference)
{
referenceInScope = citation.Reference.ParentReference;
}
if (referenceInScope == null)
{
return(null);
}
DateTimeFieldElement dateTimeFieldElement = componentPart.Elements.OfType <DateTimeFieldElement>().FirstOrDefault();
if (dateTimeFieldElement == null)
{
return(null);
}
var propertyId = dateTimeFieldElement.PropertyId;
var dateTimeStringValue = referenceInScope.GetValue(propertyId) as string;
if (string.IsNullOrEmpty(dateTimeStringValue))
{
return(null);
}
DateTime dateValue;
if (!DateTimeInformation.TryParse(dateTimeStringValue, out dateValue))
{
return(null);
}
var formattedDate = string.Format(new MyCustomDateProvider(), "{0}", dateValue);
if (string.IsNullOrEmpty(formattedDate))
{
return(null);
}
var formattedDateTextUnits = TextUnitCollectionUtility.TaggedTextToTextUnits(null, formattedDate);
if (formattedDateTextUnits == null || !formattedDateTextUnits.Any())
{
return(null);
}
if (dateTimeFieldElement.FontStyle != FontStyle.Neutral)
{
foreach (ITextUnit textUnit in formattedDateTextUnits)
{
textUnit.FontStyle |= dateTimeFieldElement.FontStyle;
}
}
List <LiteralElement> outputDateLiteralElements = formattedDateTextUnits.TextUnitsToLiteralElements(componentPart);
componentPart.Elements.ReplaceItem(dateTimeFieldElement, outputDateLiteralElements);
foreach (LiteralElement literalElement in componentPart.Elements.OfType <LiteralElement>())
{
literalElement.ApplyCondition = ElementApplyCondition.Always;
}
return(null);
}
public IEnumerable<ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
{
handled = false;
if (citation == null) return null;
if (citation.Reference == null) return null;
if (componentPart == null) return null;
if (componentPart.Elements == null || componentPart.Elements.Count == 0) return null;
bool ambiguityFound = false;
BibliographyCitation bibliographyCitation = citation as BibliographyCitation;
if (bibliographyCitation == null)
{
PlaceholderCitation placeholderCitation = citation as PlaceholderCitation;
if (placeholderCitation != null)
{
bibliographyCitation = placeholderCitation.CorrespondingBibliographyCitation;
}
}
if (bibliographyCitation != null &&
bibliographyCitation.AmbiguityFound &&
!string.IsNullOrEmpty(bibliographyCitation.IdentifyingLetter)
) ambiguityFound = true;
#region Find field elements of type DateTime
IEnumerable<DateTimeFieldElement> dateTimeFieldElements = componentPart.Elements.OfType<DateTimeFieldElement>();
if (dateTimeFieldElements == null || dateTimeFieldElements.Count() != 1) return null;
DateTimeFieldElement dateTimeFieldElement = dateTimeFieldElements.ElementAt(0);
if (dateTimeFieldElement == null) return null;
#endregion
#region Determine reference to look at
Reference reference;
if (componentPart.Scope == ComponentPartScope.ParentReference)
{
if (citation.Reference.ParentReference == null) return null;
reference = citation.Reference.ParentReference as Reference;
}
else
{
reference = citation.Reference as Reference;
}
if (reference == null) return null;
#endregion Determine reference to look at
#region Determine reference language
Language language;
if (String.Equals(reference.LanguageCode, CultureInfo.GetCultureInfo("en").TwoLetterISOLanguageName, StringComparison.OrdinalIgnoreCase))
{
language = Language.English;
}
else if (String.Equals(reference.LanguageCode, CultureInfo.GetCultureInfo("de").TwoLetterISOLanguageName, StringComparison.OrdinalIgnoreCase))
{
language = Language.German;
}
else
{
language = Language.Other;
}
#endregion Determine reference language
var propertyId = dateTimeFieldElement.PropertyId;
var dateTimeStringValue = reference.GetValue(propertyId) as string;
if (string.IsNullOrEmpty(dateTimeStringValue)) return null;
//das folgende geht nicht, da DateTimeFieldFormatter leider "internal" ist
//TextUnitCollection textUnits = DateTimeFieldFormatter.Format(citation, dateTimeFieldElement, dateTimeStringValue);
List<Segment> segments = GetSegments(dateTimeStringValue);
List<LiteralElement> literalElements = new List<LiteralElement>();
TextUnitCollection debug = new TextUnitCollection();
//int counter = 1;
foreach (Segment segment in segments)
{
switch (segment.type)
{
case SegmentType.Text:
{
var literalElement = new LiteralElement(componentPart, segment.text);
literalElement.FontStyle = dateTimeFieldElement.FontStyle;
literalElements.Add(literalElement);
}
break;
case SegmentType.DateTime:
{
string newDateString;
#region YEAR information only
if (!segment.ContainsMonthInformation && !segment.ContainsDayInformation)
{
switch (language)
{
default:
case (Language.English):
{
newDateString = segment.dateTime.ToString("yyyy", new CultureInfo("en-US")); //or "en-UK"
}
break;
case (Language.German):
{
newDateString = segment.dateTime.ToString("yyyy", new CultureInfo("de-DE")); // or "de-CH" or "de-AT"
}
break;
case (Language.Other):
{
newDateString = segment.dateTime.ToString("yyyy", new CultureInfo("en-US"));
}
break;
}
}
#endregion
#region YEAR and MONTH
else if (!segment.ContainsDayInformation)
{
switch (language)
{
default:
case (Language.English):
{
newDateString = segment.dateTime.ToString("MM/yyyy", new CultureInfo("en-US")); //or "en-UK"
}
break;
case (Language.German):
{
newDateString = segment.dateTime.ToString("MMM yyyy", new CultureInfo("de-DE")); // or "de-CH" or "de-AT"
}
break;
case (Language.Other):
{
newDateString = segment.dateTime.ToString("MM/yyyy", new CultureInfo("en-US"));
}
break;
}
}
#endregion
#region YEAR and MONTH and DAY
else
{
switch (language)
{
default:
case (Language.English):
{
newDateString = segment.dateTime.ToString("d", new CultureInfo("en-US")); //or "en-UK"
}
break;
case (Language.German):
{
newDateString = segment.dateTime.ToString("dd. MM yyyy", new CultureInfo("de-DE")); // or "de-CH" or "de-AT"
}
break;
case (Language.Other):
{
newDateString = segment.dateTime.ToString("MM/dd/yyyy", new CultureInfo("en-US"));
}
break;
}
}
#endregion
var literalElement = new LiteralElement(componentPart, newDateString);
literalElement.FontStyle = dateTimeFieldElement.FontStyle;
literalElements.Add(literalElement);
}
break;
}
}
if (ambiguityFound)
{
var literalElement = new LiteralElement(componentPart, bibliographyCitation.IdentifyingLetter);
literalElement.FontStyle = dateTimeFieldElement.FontStyle;
literalElements.Add(literalElement);
}
//replace the DateTimeFieldElement by the LiteralElements
componentPart.Elements.ReplaceItem(dateTimeFieldElement, literalElements);
//and Citavi handles the rest, therefore we say handled = false && return null
handled = false;
return null;
}
public IEnumerable <ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
{
//return handled = true if this macro generates the output (as a IEnumerable<ITextUnit>); the standard output will be suppressed
//return handled = false if you want Citavi to produce the standard output;
//you can still manipulate the component part and its elements before letting Citavi generate the output with handled = false
handled = false;
if (citation == null)
{
return(null);
}
if (citation.Reference == null)
{
return(null);
}
if (componentPart == null)
{
return(null);
}
if (componentPart.Elements == null || componentPart.Elements.Count == 0)
{
return(null);
}
var hasOriginalPublication = !string.IsNullOrEmpty(citation.Reference.OriginalPublication); //Erstveröffentlichung
var hasYearResolved = !string.IsNullOrEmpty(citation.Reference.YearResolved); //Jahr ermittelt
if (!hasOriginalPublication && !hasYearResolved)
{
return(null); //die Komponente "leert" sich von alleine, denn die (statische) Beschriftung wird nur ausgegeben, wenn eines der Felder Inhalt hat.
}
IEnumerable <DateTimeFieldElement> originalPublicationFieldElements = componentPart.Elements.OfType <DateTimeFieldElement>().Where(element => element.PropertyId == ReferencePropertyId.OriginalPublication);
if (originalPublicationFieldElements == null || originalPublicationFieldElements.Count() != 1)
{
return(null);
}
DateTimeFieldElement originalPublicationFieldElement = originalPublicationFieldElements.FirstOrDefault();
if (originalPublicationFieldElement == null)
{
return(null);
}
IEnumerable <DateTimeFieldElement> yearResolvedFieldElements = componentPart.Elements.OfType <DateTimeFieldElement>().Where(element => element.PropertyId == ReferencePropertyId.YearResolved);
if (yearResolvedFieldElements == null || yearResolvedFieldElements.Count() != 1)
{
return(null);
}
DateTimeFieldElement yearResolvedFieldElement = yearResolvedFieldElements.FirstOrDefault();
if (yearResolvedFieldElement == null)
{
return(null);
}
IEnumerable <LiteralElement> literalElements = componentPart.Elements.OfType <LiteralElement>().Where(element => element.Text == " [" || element.Text == "]");
if (literalElements == null || literalElements.Count() != 2)
{
return(null);
}
LiteralElement literalElement1 = literalElements.FirstOrDefault();
LiteralElement literalElement2 = literalElements.Last();
if (literalElement1 == null)
{
return(null);
}
if (literalElement2 == null)
{
return(null);
}
//nur hasOriginalPublication -> eckige Klammern vor & nach "Erstveröffentlichung" sollen entfallen
if (hasOriginalPublication && !hasYearResolved)
{
literalElement1.Text = "";
literalElement2.Text = "";
return(null);
}
//nur hasYearResolved? -> alles bleibt, wie es ist
if (!hasOriginalPublication && hasYearResolved)
{
return(null);
}
//hasOriginalPublication UND hasYearResolved? -> alles bleibt, wie es ist
if (hasOriginalPublication && hasYearResolved)
{
// componentPart.Elements.Remove(hasYearResolved); falls nur das Erstveröffentlichungsjahr ausgegeben werden soll
// literalElement1.Text = "";
// literalElement2.Text = "";
return(null);
}
//hierher sollten wir nie kommen, aber wer weiss
return(null);
}
