This forum is read-only - Please use our new Citavi Forum instead.
Dieses Forum dient nur zur Recherche - Bitte nutzen Sie das neue Citavi Forum für Ihre Fragen.

Vorname nur bei uneindeutigen Nachnamen einfügen Topic is solved

Erhalten Sie Hilfe bei der Anwendung juristischer Zitationsstile.

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby Sebastian Pabel » 2017-08-09 09:41

Hallo,

hier hat sich das Interface geändert. Die IList<IPerson> gibt es nicht mehr. Um eine LIste der Autoren zu erhalten, rufen Sie bitte folgendes auf:

Code: Select all
List<Person> AuthorsList = citation.Reference.Authors.ToList();


Viele Grüße
Sebastian

Wurde Ihre Frage vollständig beantwortet? Bitte klicken Sie auf das grüne Häkchen (= Antwort akzeptieren) oben rechts in meiner Antwort. Andere Forenbenutzer können sich dann leichter orientieren, wenn sie auf der Suche nach einer Lösung sind.
Sebastian Pabel
Site Admin
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby SarahR » 2017-08-09 09:50

Sebastian Pabel wrote:Hallo,

hier hat sich das Interface geändert. Die IList<IPerson> gibt es nicht mehr. Um eine LIste der Autoren zu erhalten, rufen Sie bitte folgendes auf:

Code: Select all
List<Person> AuthorsList = citation.Reference.Authors.ToList();


Viele Grüße
Sebastian



Vielen Dank! Leider muss ich noch mal nachfragen. Was machen ich jetzt genau mit der Zeile? Füge ich die in den Code von Silvester ein? Falls ja, wo?
SarahR
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby Sebastian Pabel » 2017-08-09 10:21

Hallo,

ersetzen Sie bitte die IList<IPerson> ...-Zeile dadurch.

Viele Grüße
Sebastian

Wurde Ihre Frage vollständig beantwortet? Bitte klicken Sie auf das grüne Häkchen (= Antwort akzeptieren) oben rechts in meiner Antwort. Andere Forenbenutzer können sich dann leichter orientieren, wenn sie auf der Suche nach einer Lösung sind.
Sebastian Pabel
Site Admin
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby SarahR » 2017-08-09 10:56

Danke für die weitere Hilfe! Leider schaffe ich es immer noch nicht ohne Fehlermeldungen.

Der Code sieht gerade so aus:

Code: Select all
    using System;
    using System.Linq;
    using System.Collections.Generic;
    using SwissAcademic.Citavi;
    using SwissAcademic.Citavi.Metadata;


    namespace SwissAcademic.Citavi.Citations
    {
       public class ComponentPartFilter
          :
          IComponentPartFilter
       {
          //Version 1.2 Takes all combinations of number/sex into account
          //Version 1.1 Takes organizations into account
          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 (citation.PreviousCitation == null) return null;
             if (citation.PreviousCitation.Reference == null) return null;

           // Autoren ggfs. Vornamen hinzufügen
             if (componentPart == null) return null;
             if (componentPart.Elements == null || componentPart.Elements.Count == 0) return null;

             IEnumerable<PersonFieldElement> personFieldElements = componentPart.Elements.OfType<PersonFieldElement>();
             if (personFieldElements == null || personFieldElements.Count() != 1) return null;

             PersonFieldElement personFieldElement = personFieldElements.ElementAt(0);

             if (personFieldElement == null) return null;

             List<Person> AuthorsList = citation.Reference.Authors.ToList();
             if(AuthorsList.Count==0)
                return null;
             if(AuthorsList[0].Notes.Equals("Uneindeutig"))
             {
                personFieldElement.FirstGroupPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.FirstGroupFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.FirstGroupMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.FirstGroupMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
                   // more than two authors: use "FirstGroup", "SecondGroup" and "LastPerson"
                   // note that the citation style truncates the list aftre the third author, so we can content ourselves with the first three
                   // and use "LastPerson" for the third one
             if(AuthorsList.Count==2) // only two authors - no need for "LastPerson"
                personFieldElement.UseDifferentFormatForLastPerson=false;
             else // more than two authors
                personFieldElement.UseDifferentFormatForLastPerson=true;
             if(AuthorsList.Count>1&& AuthorsList[1].Notes.Equals("Uneindeutig"))
             {
                personFieldElement.SecondGroupPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.SecondGroupFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.SecondGroupMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.SecondGroupMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
             if(AuthorsList.Count>2 && AuthorsList[2].Notes.Equals("Uneindeutig")) // third Person last - we don't show more than three here
             {
                personFieldElement.LastPersonPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.LastPersonFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.LastPersonMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.LastPersonMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
             

             //check for 1st PersonFieldElement in ComponentPart
             var firstPersonFieldElement = componentPart.Elements.FirstOrDefault(item => item is PersonFieldElement) as PersonFieldElement;
             if (firstPersonFieldElement == null) return null;

             //determine Persons to compare
             List<IPerson> thesePersons = null;
             List<IPerson> previousPersons = null;

             switch (firstPersonFieldElement.PropertyId)
             {
                #region Authors

                case ReferencePropertyId.Authors:
                   {
                      thesePersons = citation.Reference.GetAuthors() as List<IPerson>;
                      previousPersons = citation.PreviousCitation.Reference.GetAuthors() as List<IPerson>;
                   }
                   break;

                #endregion Authors

                #region Editors

                case ReferencePropertyId.Editors:
                   {
                      thesePersons = citation.Reference.GetEditors() as List<IPerson>;
                      previousPersons = citation.PreviousCitation.Reference.GetEditors() as List<IPerson>;
                   }
                   break;

                #endregion Editors

                #region AuthorsEditorsOrganizations

                case ReferencePropertyId.AuthorsOrEditorsOrOrganizations:
                   {
                      thesePersons = citation.Reference.GetAuthorsOrEditorsOrOrganizations() as List<IPerson>;
                      previousPersons = citation.PreviousCitation.Reference.GetAuthorsOrEditorsOrOrganizations() as List<IPerson>;
                   }
                   break;

                #endregion AuthorsEditorsOrganizations

                #region Collaborators

                case ReferencePropertyId.Collaborators:
                   {
                      thesePersons = citation.Reference.GetCollaborators() as List<IPerson>;
                      previousPersons = citation.PreviousCitation.Reference.GetCollaborators() as List<IPerson>;
                   }
                   break;

                #endregion Collaborators

                #region OthersInvolved

                case ReferencePropertyId.OthersInvolved:
                   {
                      thesePersons = citation.Reference.GetOthersInvolved() as List<IPerson>;
                      previousPersons = citation.PreviousCitation.Reference.GetOthersInvolved() as List<IPerson>;
                   }
                   break;

                #endregion OthersInvolved
             }

             if (thesePersons == null || thesePersons.Count == 0) return null;
             if (previousPersons == null || previousPersons.Count == 0) return null;

             var equality = CheckPersonEquality(thesePersons, previousPersons);
             if (equality == PersonEquality.None) return null;

             #region Equality detected - generate output

             //we DO have some equality, so let's check what we need to output instead of the person's name(s)
             var text = string.Empty;
             switch (equality)
             {
                case PersonEquality.M:
                   text = "ders.";
                   break;

                default: //all others
                   text = "dies.";
                   break;

             }

             var output = new TextUnitCollection();
             var statement = new LiteralTextUnit(text);
             statement.FontStyle = SwissAcademic.Drawing.FontStyle.Italic;
             output.Add(statement);

             handled = true;
             return output;

             #endregion Equality detected - generate output
          }

          #region CheckPersonEquality

          private static PersonEquality CheckPersonEquality(IList<IPerson> personsA, IList<IPerson> personsB)
          {
             var personListA = personsA as List<IPerson>;
             var personListB = personsB as List<IPerson>;

             if (personListA == null || personListA.Count == 0) return PersonEquality.None;
             if (personListB == null || personListB.Count == 0) return PersonEquality.None;
             if (personListA.Count != personListB.Count) return PersonEquality.None;

             //we DO have two lists of persons of same length
             //FIRST sort by id for comparison
             var personIdComparer = new PersonIdComparer();
             personListA.Sort(personIdComparer);
             personListB.Sort(personIdComparer);


             var allCounter = personListA.Count;
             var maleCounter = 0;
             var femaleCounter = 0;
             var neutralCounter = 0;

             //loop, compare GUID/id and determine/count sex
             for (int i = 0; i < personListA.Count; i++)
             {
                var idA = personListA[i].GetValue(PersonPropertyId.Id).ToString();
                var idB = personListB[i].GetValue(PersonPropertyId.Id).ToString();

                if (!idA.Equals(idB, StringComparison.Ordinal)) return PersonEquality.None;

                //identical!
                //determine sex (just need to look at one of them, because they are identical)
                if (personListA[i].Sex == Sex.Male) maleCounter++;
                if (personListA[i].Sex == Sex.Female) femaleCounter++;
                if (personListA[i].Sex == Sex.Neutral || personListA[i].Sex == Sex.Unknown) neutralCounter++;
             }

             //still here, so ALL persons are equal, now return equality based on sex
             if (allCounter == 1 && maleCounter == 1) return PersonEquality.M;
             else if (allCounter == 1 && femaleCounter == 1) return PersonEquality.F;
             else if (allCounter == 1 && neutralCounter == 1) return PersonEquality.N;

             else if (allCounter > 1 && maleCounter == allCounter) return PersonEquality.MM;
             else if (allCounter > 1 && femaleCounter == allCounter) return PersonEquality.FF;
             else if (allCounter > 1 && neutralCounter == allCounter) return PersonEquality.NN;

             else if (allCounter > 1 && maleCounter + femaleCounter == allCounter) return PersonEquality.FM;
             else if (allCounter > 1 && femaleCounter + neutralCounter == allCounter) return PersonEquality.FN;
             else if (allCounter > 1 && maleCounter + neutralCounter == allCounter) return PersonEquality.MN;

             else if (allCounter >= 3
                && maleCounter >= 1 && femaleCounter >= 1 && neutralCounter >= 1
                && maleCounter + femaleCounter + neutralCounter == allCounter) return PersonEquality.FMN;
             else return PersonEquality.None;

          }

          #endregion CheckPersonEquality

          #region Enum PersonEquality

          public enum PersonEquality
          {
             /// <summary>
             /// None: Different persons and/or different numbers of persons.
             /// </summary>
             /// <returns></returns>
             None,

             /// <summary>
             /// Identical person, a single female (Latin: eadem)
             /// </summary>
             F,
             /// <summary>
             /// Identical person, a single male (Latin: idem)
             /// </summary>
             M,
             /// <summary>
             /// Identical persons, a single (neutral) organization (Latin: idem)
             /// </summary>
             N,

             /// <summary>
             /// Identical persons, only females, 2 or more (Latin: eaedem)
             /// </summary>
             FF,
             /// <summary>
             /// Identical persons, only males, 2 or more (Latin: eidem)
             /// </summary>
             MM,
             /// <summary>
             /// Identical persons, only (neutral) organizations, 2 or more (Latin: eadem)
             /// </summary>
             NN,

             /// <summary>
             /// Identical persons, mixed group of females and males only
             /// </summary>
             FM,
             /// <summary>
             /// Identical persons, mixed group of females and neutrals only
             /// </summary>
             FN,
             /// <summary>
             /// Identical persons, mixed group of males and neutrals only
             /// </summary>
             MN,

             /// <summary>
             /// Identical persons, mixed group of females, males and neutrals
             /// </summary>
             FMN
          }

          #endregion PersonEquality

          #region PersonIdComparer

          //The following is a sort comparer that will bring all person collections into a well defined order
          //namely in the order of their internal GUID values.
          public class PersonIdComparer : IComparer<IPerson>
          {
             public int Compare(IPerson person1, IPerson person2)
             {
                int returnValue = 1;
                if (person1 != null && person2 != null)
                {
                   returnValue = person1.GetValue(PersonPropertyId.Id).ToString().CompareTo(person2.GetValue(PersonPropertyId.Id).ToString());
                }
                return returnValue;
             }
          }

          #endregion PersonIdComparer
       }
    }


Die Zeile IList<IPerson>... habe ich eigentlich geändert. Trotzdem bekomme ich weiterhin mehrmals die Fehlermeldung: "Der Typ- oder Namespacename 'IPerson' konnte nicht gefunden werden. (Fehlt eine Using-Direktive oder ein Assemblyverweis?)". Hätte ich die Zeile vielleicht noch an weiteren Stellen einfügen müssen?
SarahR
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby Sebastian Pabel » 2017-08-09 11:32

Hallo,

es waren noch einige Verweise auf IList<IPerson> enthalten. Ich habe diese jetzt alle zu "normalen" List<Person> geändert.

Folgendes generiert keine Fehlermeldungen mehr. Bitte testen Sie aber, ob es auch funktioniert:

Code: Select all
    using System;
    using System.Linq;
    using System.Collections.Generic;
    using SwissAcademic.Citavi;
    using SwissAcademic.Citavi.Metadata;


    namespace SwissAcademic.Citavi.Citations
    {
       public class ComponentPartFilter
          :
          IComponentPartFilter
       {
          //Version 1.2 Takes all combinations of number/sex into account
          //Version 1.1 Takes organizations into account
          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 (citation.PreviousCitation == null) return null;
             if (citation.PreviousCitation.Reference == null) return null;

           // Autoren ggfs. Vornamen hinzufügen
             if (componentPart == null) return null;
             if (componentPart.Elements == null || componentPart.Elements.Count == 0) return null;

             IEnumerable<PersonFieldElement> personFieldElements = componentPart.Elements.OfType<PersonFieldElement>();
             if (personFieldElements == null || personFieldElements.Count() != 1) return null;

             PersonFieldElement personFieldElement = personFieldElements.ElementAt(0);

             if (personFieldElement == null) return null;

             List<Person> AuthorsList = citation.Reference.Authors.ToList();
             if(AuthorsList.Count==0)
                return null;
             if(AuthorsList[0].Notes.Equals("Uneindeutig"))
             {
                personFieldElement.FirstGroupPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.FirstGroupFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.FirstGroupMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.FirstGroupMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
                   // more than two authors: use "FirstGroup", "SecondGroup" and "LastPerson"
                   // note that the citation style truncates the list aftre the third author, so we can content ourselves with the first three
                   // and use "LastPerson" for the third one
             if(AuthorsList.Count==2) // only two authors - no need for "LastPerson"
                personFieldElement.UseDifferentFormatForLastPerson=false;
             else // more than two authors
                personFieldElement.UseDifferentFormatForLastPerson=true;
             if(AuthorsList.Count>1&& AuthorsList[1].Notes.Equals("Uneindeutig"))
             {
                personFieldElement.SecondGroupPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.SecondGroupFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.SecondGroupMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.SecondGroupMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
             if(AuthorsList.Count>2 && AuthorsList[2].Notes.Equals("Uneindeutig")) // third Person last - we don't show more than three here
             {
                personFieldElement.LastPersonPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.LastPersonFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.LastPersonMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.LastPersonMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
             

             //check for 1st PersonFieldElement in ComponentPart
             var firstPersonFieldElement = componentPart.Elements.FirstOrDefault(item => item is PersonFieldElement) as PersonFieldElement;
             if (firstPersonFieldElement == null) return null;

             //determine Persons to compare
             List<Person> thesePersons = null;
             List<Person> previousPersons = null;

             switch (firstPersonFieldElement.PropertyId)
             {
                #region Authors

                case ReferencePropertyId.Authors:
                   {
                      thesePersons = citation.Reference.Authors.ToList();
                      previousPersons = citation.PreviousCitation.Reference.Authors.ToList();
                   }
                   break;

                #endregion Authors

                #region Editors

                case ReferencePropertyId.Editors:
                   {
                      thesePersons = citation.Reference.Editors.ToList();
                      previousPersons = citation.PreviousCitation.Reference.Editors.ToList();
                   }
                   break;

                #endregion Editors

                #region AuthorsEditorsOrganizations

                case ReferencePropertyId.AuthorsOrEditorsOrOrganizations:
                   {
                      thesePersons = citation.Reference.AuthorsOrEditorsOrOrganizations.ToList();
                      previousPersons = citation.PreviousCitation.Reference.AuthorsOrEditorsOrOrganizations.ToList();
                   }
                   break;

                #endregion AuthorsEditorsOrganizations

                #region Collaborators

                case ReferencePropertyId.Collaborators:
                   {
                      thesePersons = citation.Reference.Collaborators.ToList();
                      previousPersons = citation.PreviousCitation.Reference.Collaborators.ToList();
                   }
                   break;

                #endregion Collaborators

                #region OthersInvolved

                case ReferencePropertyId.OthersInvolved:
                   {
                      thesePersons = citation.Reference.OthersInvolved.ToList();
                      previousPersons = citation.PreviousCitation.Reference.OthersInvolved.ToList();
                   }
                   break;

                #endregion OthersInvolved
             }

             if (thesePersons == null || thesePersons.Count == 0) return null;
             if (previousPersons == null || previousPersons.Count == 0) return null;

             var equality = CheckPersonEquality(thesePersons, previousPersons);
             if (equality == PersonEquality.None) return null;

             #region Equality detected - generate output

             //we DO have some equality, so let's check what we need to output instead of the person's name(s)
             var text = string.Empty;
             switch (equality)
             {
                case PersonEquality.M:
                   text = "ders.";
                   break;

                default: //all others
                   text = "dies.";
                   break;

             }

             var output = new TextUnitCollection();
             var statement = new LiteralTextUnit(text);
             statement.FontStyle = SwissAcademic.Drawing.FontStyle.Italic;
             output.Add(statement);

             handled = true;
             return output;

             #endregion Equality detected - generate output
          }

          #region CheckPersonEquality

          private static PersonEquality CheckPersonEquality(List<Person> personsA, List<Person> personsB)
          {
             var personListA = personsA;
             var personListB = personsB;

             if (personListA == null || personListA.Count == 0) return PersonEquality.None;
             if (personListB == null || personListB.Count == 0) return PersonEquality.None;
             if (personListA.Count != personListB.Count) return PersonEquality.None;

             //we DO have two lists of persons of same length
             //FIRST sort by id for comparison
             var personIdComparer = new PersonIdComparer();
             personListA.Sort(personIdComparer);
             personListB.Sort(personIdComparer);


             var allCounter = personListA.Count;
             var maleCounter = 0;
             var femaleCounter = 0;
             var neutralCounter = 0;

             //loop, compare GUID/id and determine/count sex
             for (int i = 0; i < personListA.Count; i++)
             {
                var idA = personListA[i].GetValue(PersonPropertyId.Id).ToString();
                var idB = personListB[i].GetValue(PersonPropertyId.Id).ToString();

                if (!idA.Equals(idB, StringComparison.Ordinal)) return PersonEquality.None;

                //identical!
                //determine sex (just need to look at one of them, because they are identical)
                if (personListA[i].Sex == Sex.Male) maleCounter++;
                if (personListA[i].Sex == Sex.Female) femaleCounter++;
                if (personListA[i].Sex == Sex.Neutral || personListA[i].Sex == Sex.Unknown) neutralCounter++;
             }

             //still here, so ALL persons are equal, now return equality based on sex
             if (allCounter == 1 && maleCounter == 1) return PersonEquality.M;
             else if (allCounter == 1 && femaleCounter == 1) return PersonEquality.F;
             else if (allCounter == 1 && neutralCounter == 1) return PersonEquality.N;

             else if (allCounter > 1 && maleCounter == allCounter) return PersonEquality.MM;
             else if (allCounter > 1 && femaleCounter == allCounter) return PersonEquality.FF;
             else if (allCounter > 1 && neutralCounter == allCounter) return PersonEquality.NN;

             else if (allCounter > 1 && maleCounter + femaleCounter == allCounter) return PersonEquality.FM;
             else if (allCounter > 1 && femaleCounter + neutralCounter == allCounter) return PersonEquality.FN;
             else if (allCounter > 1 && maleCounter + neutralCounter == allCounter) return PersonEquality.MN;

             else if (allCounter >= 3
                && maleCounter >= 1 && femaleCounter >= 1 && neutralCounter >= 1
                && maleCounter + femaleCounter + neutralCounter == allCounter) return PersonEquality.FMN;
             else return PersonEquality.None;

          }

          #endregion CheckPersonEquality

          #region Enum PersonEquality

          public enum PersonEquality
          {
             /// <summary>
             /// None: Different persons and/or different numbers of persons.
             /// </summary>
             /// <returns></returns>
             None,

             /// <summary>
             /// Identical person, a single female (Latin: eadem)
             /// </summary>
             F,
             /// <summary>
             /// Identical person, a single male (Latin: idem)
             /// </summary>
             M,
             /// <summary>
             /// Identical persons, a single (neutral) organization (Latin: idem)
             /// </summary>
             N,

             /// <summary>
             /// Identical persons, only females, 2 or more (Latin: eaedem)
             /// </summary>
             FF,
             /// <summary>
             /// Identical persons, only males, 2 or more (Latin: eidem)
             /// </summary>
             MM,
             /// <summary>
             /// Identical persons, only (neutral) organizations, 2 or more (Latin: eadem)
             /// </summary>
             NN,

             /// <summary>
             /// Identical persons, mixed group of females and males only
             /// </summary>
             FM,
             /// <summary>
             /// Identical persons, mixed group of females and neutrals only
             /// </summary>
             FN,
             /// <summary>
             /// Identical persons, mixed group of males and neutrals only
             /// </summary>
             MN,

             /// <summary>
             /// Identical persons, mixed group of females, males and neutrals
             /// </summary>
             FMN
          }

          #endregion PersonEquality

          #region PersonIdComparer

          //The following is a sort comparer that will bring all person collections into a well defined order
          //namely in the order of their internal GUID values.
          public class PersonIdComparer : IComparer<Person>
          {
             public int Compare(Person person1, Person person2)
             {
                int returnValue = 1;
                if (person1 != null && person2 != null)
                {
                   returnValue = person1.GetValue(PersonPropertyId.Id).ToString().CompareTo(person2.GetValue(PersonPropertyId.Id).ToString());
                }
                return returnValue;
             }
          }

          #endregion PersonIdComparer
       }
   }


Viele Grüße
Sebastian

Wurde Ihre Frage vollständig beantwortet? Bitte klicken Sie auf das grüne Häkchen (= Antwort akzeptieren) oben rechts in meiner Antwort. Andere Forenbenutzer können sich dann leichter orientieren, wenn sie auf der Suche nach einer Lösung sind.
Sebastian Pabel
Site Admin
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby SarahR » 2017-08-09 13:20

Sebastian Pabel wrote:Hallo,

es waren noch einige Verweise auf IList<IPerson> enthalten. Ich habe diese jetzt alle zu "normalen" List<Person> geändert.

Folgendes generiert keine Fehlermeldungen mehr. Bitte testen Sie aber, ob es auch funktioniert:

Code: Select all
    using System;
    using System.Linq;
    using System.Collections.Generic;
    using SwissAcademic.Citavi;
    using SwissAcademic.Citavi.Metadata;


    namespace SwissAcademic.Citavi.Citations
    {
       public class ComponentPartFilter
          :
          IComponentPartFilter
       {
          //Version 1.2 Takes all combinations of number/sex into account
          //Version 1.1 Takes organizations into account
          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 (citation.PreviousCitation == null) return null;
             if (citation.PreviousCitation.Reference == null) return null;

           // Autoren ggfs. Vornamen hinzufügen
             if (componentPart == null) return null;
             if (componentPart.Elements == null || componentPart.Elements.Count == 0) return null;

             IEnumerable<PersonFieldElement> personFieldElements = componentPart.Elements.OfType<PersonFieldElement>();
             if (personFieldElements == null || personFieldElements.Count() != 1) return null;

             PersonFieldElement personFieldElement = personFieldElements.ElementAt(0);

             if (personFieldElement == null) return null;

             List<Person> AuthorsList = citation.Reference.Authors.ToList();
             if(AuthorsList.Count==0)
                return null;
             if(AuthorsList[0].Notes.Equals("Uneindeutig"))
             {
                personFieldElement.FirstGroupPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.FirstGroupFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.FirstGroupMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.FirstGroupMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
                   // more than two authors: use "FirstGroup", "SecondGroup" and "LastPerson"
                   // note that the citation style truncates the list aftre the third author, so we can content ourselves with the first three
                   // and use "LastPerson" for the third one
             if(AuthorsList.Count==2) // only two authors - no need for "LastPerson"
                personFieldElement.UseDifferentFormatForLastPerson=false;
             else // more than two authors
                personFieldElement.UseDifferentFormatForLastPerson=true;
             if(AuthorsList.Count>1&& AuthorsList[1].Notes.Equals("Uneindeutig"))
             {
                personFieldElement.SecondGroupPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.SecondGroupFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.SecondGroupMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.SecondGroupMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
             if(AuthorsList.Count>2 && AuthorsList[2].Notes.Equals("Uneindeutig")) // third Person last - we don't show more than three here
             {
                personFieldElement.LastPersonPersonNameOrder=PersonNameOrder.FirstNameLastName;
                personFieldElement.LastPersonFirstNameFormat=NameFormat.AbbreviatedCompact;
                personFieldElement.LastPersonMiddleNameUsage=MiddleNameUsage.FirstOnly;
                personFieldElement.LastPersonMiddleNameFormat=NameFormat.AbbreviatedCompact;
             }
             

             //check for 1st PersonFieldElement in ComponentPart
             var firstPersonFieldElement = componentPart.Elements.FirstOrDefault(item => item is PersonFieldElement) as PersonFieldElement;
             if (firstPersonFieldElement == null) return null;

             //determine Persons to compare
             List<Person> thesePersons = null;
             List<Person> previousPersons = null;

             switch (firstPersonFieldElement.PropertyId)
             {
                #region Authors

                case ReferencePropertyId.Authors:
                   {
                      thesePersons = citation.Reference.Authors.ToList();
                      previousPersons = citation.PreviousCitation.Reference.Authors.ToList();
                   }
                   break;

                #endregion Authors

                #region Editors

                case ReferencePropertyId.Editors:
                   {
                      thesePersons = citation.Reference.Editors.ToList();
                      previousPersons = citation.PreviousCitation.Reference.Editors.ToList();
                   }
                   break;

                #endregion Editors

                #region AuthorsEditorsOrganizations

                case ReferencePropertyId.AuthorsOrEditorsOrOrganizations:
                   {
                      thesePersons = citation.Reference.AuthorsOrEditorsOrOrganizations.ToList();
                      previousPersons = citation.PreviousCitation.Reference.AuthorsOrEditorsOrOrganizations.ToList();
                   }
                   break;

                #endregion AuthorsEditorsOrganizations

                #region Collaborators

                case ReferencePropertyId.Collaborators:
                   {
                      thesePersons = citation.Reference.Collaborators.ToList();
                      previousPersons = citation.PreviousCitation.Reference.Collaborators.ToList();
                   }
                   break;

                #endregion Collaborators

                #region OthersInvolved

                case ReferencePropertyId.OthersInvolved:
                   {
                      thesePersons = citation.Reference.OthersInvolved.ToList();
                      previousPersons = citation.PreviousCitation.Reference.OthersInvolved.ToList();
                   }
                   break;

                #endregion OthersInvolved
             }

             if (thesePersons == null || thesePersons.Count == 0) return null;
             if (previousPersons == null || previousPersons.Count == 0) return null;

             var equality = CheckPersonEquality(thesePersons, previousPersons);
             if (equality == PersonEquality.None) return null;

             #region Equality detected - generate output

             //we DO have some equality, so let's check what we need to output instead of the person's name(s)
             var text = string.Empty;
             switch (equality)
             {
                case PersonEquality.M:
                   text = "ders.";
                   break;

                default: //all others
                   text = "dies.";
                   break;

             }

             var output = new TextUnitCollection();
             var statement = new LiteralTextUnit(text);
             statement.FontStyle = SwissAcademic.Drawing.FontStyle.Italic;
             output.Add(statement);

             handled = true;
             return output;

             #endregion Equality detected - generate output
          }

          #region CheckPersonEquality

          private static PersonEquality CheckPersonEquality(List<Person> personsA, List<Person> personsB)
          {
             var personListA = personsA;
             var personListB = personsB;

             if (personListA == null || personListA.Count == 0) return PersonEquality.None;
             if (personListB == null || personListB.Count == 0) return PersonEquality.None;
             if (personListA.Count != personListB.Count) return PersonEquality.None;

             //we DO have two lists of persons of same length
             //FIRST sort by id for comparison
             var personIdComparer = new PersonIdComparer();
             personListA.Sort(personIdComparer);
             personListB.Sort(personIdComparer);


             var allCounter = personListA.Count;
             var maleCounter = 0;
             var femaleCounter = 0;
             var neutralCounter = 0;

             //loop, compare GUID/id and determine/count sex
             for (int i = 0; i < personListA.Count; i++)
             {
                var idA = personListA[i].GetValue(PersonPropertyId.Id).ToString();
                var idB = personListB[i].GetValue(PersonPropertyId.Id).ToString();

                if (!idA.Equals(idB, StringComparison.Ordinal)) return PersonEquality.None;

                //identical!
                //determine sex (just need to look at one of them, because they are identical)
                if (personListA[i].Sex == Sex.Male) maleCounter++;
                if (personListA[i].Sex == Sex.Female) femaleCounter++;
                if (personListA[i].Sex == Sex.Neutral || personListA[i].Sex == Sex.Unknown) neutralCounter++;
             }

             //still here, so ALL persons are equal, now return equality based on sex
             if (allCounter == 1 && maleCounter == 1) return PersonEquality.M;
             else if (allCounter == 1 && femaleCounter == 1) return PersonEquality.F;
             else if (allCounter == 1 && neutralCounter == 1) return PersonEquality.N;

             else if (allCounter > 1 && maleCounter == allCounter) return PersonEquality.MM;
             else if (allCounter > 1 && femaleCounter == allCounter) return PersonEquality.FF;
             else if (allCounter > 1 && neutralCounter == allCounter) return PersonEquality.NN;

             else if (allCounter > 1 && maleCounter + femaleCounter == allCounter) return PersonEquality.FM;
             else if (allCounter > 1 && femaleCounter + neutralCounter == allCounter) return PersonEquality.FN;
             else if (allCounter > 1 && maleCounter + neutralCounter == allCounter) return PersonEquality.MN;

             else if (allCounter >= 3
                && maleCounter >= 1 && femaleCounter >= 1 && neutralCounter >= 1
                && maleCounter + femaleCounter + neutralCounter == allCounter) return PersonEquality.FMN;
             else return PersonEquality.None;

          }

          #endregion CheckPersonEquality

          #region Enum PersonEquality

          public enum PersonEquality
          {
             /// <summary>
             /// None: Different persons and/or different numbers of persons.
             /// </summary>
             /// <returns></returns>
             None,

             /// <summary>
             /// Identical person, a single female (Latin: eadem)
             /// </summary>
             F,
             /// <summary>
             /// Identical person, a single male (Latin: idem)
             /// </summary>
             M,
             /// <summary>
             /// Identical persons, a single (neutral) organization (Latin: idem)
             /// </summary>
             N,

             /// <summary>
             /// Identical persons, only females, 2 or more (Latin: eaedem)
             /// </summary>
             FF,
             /// <summary>
             /// Identical persons, only males, 2 or more (Latin: eidem)
             /// </summary>
             MM,
             /// <summary>
             /// Identical persons, only (neutral) organizations, 2 or more (Latin: eadem)
             /// </summary>
             NN,

             /// <summary>
             /// Identical persons, mixed group of females and males only
             /// </summary>
             FM,
             /// <summary>
             /// Identical persons, mixed group of females and neutrals only
             /// </summary>
             FN,
             /// <summary>
             /// Identical persons, mixed group of males and neutrals only
             /// </summary>
             MN,

             /// <summary>
             /// Identical persons, mixed group of females, males and neutrals
             /// </summary>
             FMN
          }

          #endregion PersonEquality

          #region PersonIdComparer

          //The following is a sort comparer that will bring all person collections into a well defined order
          //namely in the order of their internal GUID values.
          public class PersonIdComparer : IComparer<Person>
          {
             public int Compare(Person person1, Person person2)
             {
                int returnValue = 1;
                if (person1 != null && person2 != null)
                {
                   returnValue = person1.GetValue(PersonPropertyId.Id).ToString().CompareTo(person2.GetValue(PersonPropertyId.Id).ToString());
                }
                return returnValue;
             }
          }

          #endregion PersonIdComparer
       }
   }


Viele Grüße
Sebastian

Wurde Ihre Frage vollständig beantwortet? Bitte klicken Sie auf das grüne Häkchen (= Antwort akzeptieren) oben rechts in meiner Antwort. Andere Forenbenutzer können sich dann leichter orientieren, wenn sie auf der Suche nach einer Lösung sind.


Alles perfekt. Vielen Dank für die Mühe und die Lösung für mein Problem. Das hat mir wirklich sehr geholfen.
SarahR
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby KoBri2 » 2017-11-15 09:44

Hallo!

ich bin sehr froh, dass es eine Lösung für die Frage gibt.
Was ich leider noch nicht verstanden habe, ist, wo ich bei dem Autor den Marker "uneindeutig" setzten muss. Unter Person/Institution ist es unpraktisch, da ich den Vornamen nur hinzuzitieren möchte, wenn die Person als Autor auftritt, nicht jedoch, wenn sie als Herausgeber auftritt. Geht das?

Viele Grüße und vielen Dank!
KoBri2
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby Sebastian Pabel » 2017-11-15 14:00

Hallo, KoBri2,

den Marker "Uneindeutig" setzen Sie im Notizfeld der betreffenden Person, also über das Menü Listen > Personen und Institutionen.

Ob das Skript nur für Autoren oder für Autoren und Herausgeber greift, hängt davon ab, ob Sie es im Zitationsstileditor auf die Komponente Autor oder Autor, Herausgeber oder Institution anwenden.

Viele Grüße
Sebastian

Wurde Ihre Frage vollständig beantwortet? Bitte klicken Sie auf das grüne Häkchen (= Antwort akzeptieren) oben rechts in meiner Antwort. Andere Forenbenutzer können sich dann leichter orientieren, wenn sie auf der Suche nach einer Lösung sind.
Sebastian Pabel
Site Admin
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby KoBri2 » 2017-11-17 11:36

Lieber Sebastian,

vielen Dank für die schnelle Antwort. Ich habe den Code ausprobiert- allerdings nutze ich nicht die "ders./dies."-Funktion, sodass es zu folgendem Problem kommt: in der ersten Fn. taucht der Nachname der markierten Pers. auf, in den folgenden Fn. anstelle des Nachnamens "ders.".
Wenn Sie mir dabei helfen könnten, wäre ich Ihnen super dankbar- ich mache bestimmt zu viele Fehler, wenn ich anfange aus dem Code Dinge herauszulöschen.

Viele Grüße!
KoBri2
 

Re: Vorname nur bei uneindeutigen Nachnamen einfügen

Postby Susanne Sitzler » 2017-11-17 16:54

Lieber KoBri2,

vielen Dank für Ihre Frage.

Folgendes Skript gibt keine ders. mehr aus und generiert keine Fehlermeldungen. Bitte testen Sie aber, ob es auch für Ihre Zwecke wie gewünscht funktioniert:

[edit: Code entfernt]

Viele Grüße
Susanne

Wurde Ihre Frage vollständig beantwortet? Bitte klicken Sie auf das grüne Häkchen (= Antwort akzeptieren) oben rechts in meiner Antwort. Andere Forenbenutzer können sich dann leichter orientieren, wenn sie auf der Suche nach einer Lösung sind.
Susanne Sitzler
Citavi Customer Service
 

PreviousNext

Return to Juristische Zitationsstile anwenden