/// <summary> Writes this abstract as a MARC tag for aggregation into a MARC record </summary>
        /// <returns> Built MARC tag </returns>
        internal MARC_Field to_MARC_HTML()
        {
            MARC_Field returnValue = new MARC_Field();

            returnValue.Tag                 = 520;
            returnValue.Indicators          = "3 ";
            returnValue.Control_Field_Value = "|a " + abstract_text.Replace("|", "&bar;");

            if (type != null)
            {
                switch (type.ToLower())
                {
                case "subject":
                    returnValue.Indicators = "0 ";
                    break;

                case "review":
                    returnValue.Indicators = "1 ";
                    break;

                case "scope and content":
                    returnValue.Indicators = "2 ";
                    break;

                case "content advice":
                    returnValue.Indicators = "4 ";
                    break;
                }
            }

            return(returnValue);
        }
        /// <summary> DEMO 3: Read the resulting demo2.dat file, change the title, publisher, and add
        /// a subject field and then save it again</summary>
        private static void demo3()
        {
            Console.WriteLine("Performing demo3");

            // Create the marc21 exchange reader
            MARC21_Exchange_Format_Parser parser1 = new MARC21_Exchange_Format_Parser();

            // Read the record
            MARC_Record record = parser1.Parse("demo2.dat");

            // If this is null, say so
            if (record == null)
            {
                Console.WriteLine("Unable to read the demo2.dat in the 3rd demo portion");
                return;
            }

            // Change the title field ( 245 )
            record[245][0].Add_NonRepeatable_Subfield('a', "New Title");

            // Also change the creator field (110 in this case)
            record[110][0].Add_NonRepeatable_Subfield('a', "Corn Maze Production, Incorporated");

            // Add a new field to record
            MARC_Field newSubject = record.Add_Field(650, ' ', '0');

            newSubject.Add_Subfield('a', "Soils");
            newSubject.Add_Subfield('x', "Phosphorous content");
            newSubject.Add_Subfield('z', "Indonesia");

            // Save this as XML and also as Marc21
            record.Save_MARC_XML("demo3.xml");
            record.Save_MARC21("demo3.dat");
        }
        /// <summary> Analyzes this subject to determine the indicator based on the authority/source
        /// when converting this subject into the equivalent MARC </summary>
        /// <param name="returnValue"> MARC Tag to add the indicator to </param>
        /// <param name="fieldBuilder"> Field builder to which the |2 source may be added if the source is not represented in the indicator </param>
        protected void Add_Source_Indicator(MARC_Field returnValue, StringBuilder fieldBuilder)
        {
            string second_indicator = " ";

            if (!String.IsNullOrEmpty(authority))
            {
                switch (authority.ToLower())
                {
                case "lcnaf":
                case "lcsh":
                    second_indicator = "0";
                    break;

                case "lcshac":
                    second_indicator = "1";
                    break;

                case "mesh":
                    second_indicator = "2";
                    break;

                case "nal":
                    second_indicator = "3";
                    break;

                case "csh":
                    second_indicator = "5";
                    break;

                case "rvm":
                    second_indicator = "6";
                    break;

                case "local":
                    second_indicator = "9";
                    break;

                case "":
                    second_indicator = "4";
                    break;

                default:
                    fieldBuilder.Append("|2 " + authority + " ");
                    second_indicator = "7";
                    break;
                }
            }

            returnValue.Indicators = returnValue.Indicators.Substring(0, 1) + second_indicator;
        }
        internal override MARC_Field to_MARC_HTML()
        {
            MARC_Field returnValue = titleInfo.to_MARC_HTML(630, 1, String.Empty, String.Empty);

            // Add to the built field
            StringBuilder fieldBuilder = new StringBuilder(returnValue.Control_Field_Value + " ");

            if (geographics != null)
            {
                foreach (string geo in geographics)
                {
                    fieldBuilder.Append("|z " + geo + " ");
                }
            }

            if (temporals != null)
            {
                foreach (string temporal in temporals)
                {
                    fieldBuilder.Append("|y " + temporal + " ");
                }
            }

            if (topics != null)
            {
                foreach (string topic in topics)
                {
                    fieldBuilder.Append("|x " + topic + " ");
                }
            }

            if (genres != null)
            {
                foreach (string form in genres)
                {
                    fieldBuilder.Append("|v " + form + " ");
                }
            }

            base.Add_Source_Indicator(returnValue, fieldBuilder);

            returnValue.Control_Field_Value = fieldBuilder.ToString().Trim();

            return(returnValue);
        }
        internal override MARC_Field to_MARC_HTML()
        {
            MARC_Field returnValue = new MARC_Field {
                Tag = 255
            };

            // Set the tag
            if ((id.IndexOf("SUBJ") == 0) && (id.Length >= 7))
            {
                string possible_tag = id.Substring(4, 3);
                try
                {
                    int possible_tag_number = Convert.ToInt16(possible_tag);
                    returnValue.Tag = possible_tag_number;
                }
                catch
                {
                }
            }

            StringBuilder builder = new StringBuilder(50);

            if (!String.IsNullOrEmpty(scale))
            {
                builder.Append("|a " + scale + " ");
            }
            if (!String.IsNullOrEmpty(projection))
            {
                builder.Append("|b " + projection + " ");
            }
            if (!String.IsNullOrEmpty(coordinates))
            {
                builder.Append("|c " + coordinates + " ");
            }
            returnValue.Control_Field_Value = builder.ToString().Trim();

            return(returnValue);
        }
Example #6
0
        /// <summary> Reads the data from a XML Node Reader </summary>
        /// <param name="nodeReader">XML Node Reader </param>
        /// <param name="Record"> Record into which to read the contents of the MarcXML file </param>
        /// <returns>TRUE if successful, otherwise FALSE </returns>
        public static bool Read_MARC_Info(XmlReader nodeReader, MARC_Record Record)
        {
            try
            {
                // Move to the this node
                move_to_node(nodeReader, "record");

                // Get the leader information
                int tag = -1;
                while (nodeReader.Read())
                {
                    if ((nodeReader.NodeType == XmlNodeType.EndElement) && (nodeReader.Name == "record"))
                    {
                        return(true);
                    }

                    if (nodeReader.NodeType == XmlNodeType.Element)
                    {
                        switch (nodeReader.Name.Trim().Replace("marc:", ""))
                        {
                        case "leader":
                            nodeReader.Read();
                            Record.Leader = nodeReader.Value;
                            break;

                        case "controlfield":
                            // Get the tag
                            if (nodeReader.MoveToAttribute("tag"))
                            {
                                // The tag should always be numeric per the schema, but just relaxing this
                                // for invalid MARC so the rest of the data can be successfully read.
                                if (Int32.TryParse(nodeReader.Value, out tag))
                                {
                                    // Move to the value and then add this
                                    nodeReader.Read();
                                    Record.Add_Field(tag, nodeReader.Value);
                                }
                            }
                            break;

                        case "datafield":
                            // Set the default indicators
                            char ind1 = ' ';
                            char ind2 = ' ';

                            // Get the indicators if they exist
                            while (nodeReader.MoveToNextAttribute())
                            {
                                if (nodeReader.Name.Trim() == "ind1")
                                {
                                    string temp1 = nodeReader.Value;
                                    if (temp1.Length > 0)
                                    {
                                        ind1 = temp1[0];
                                    }
                                }
                                if (nodeReader.Name.Trim() == "ind2")
                                {
                                    string temp2 = nodeReader.Value;
                                    if (temp2.Length > 0)
                                    {
                                        ind2 = temp2[0];
                                    }
                                }
                                if (nodeReader.Name.Trim() == "tag")
                                {
                                    tag = Convert.ToInt32(nodeReader.Value);
                                }
                            }

                            // Add this datafield
                            MARC_Field newField = Record.Add_Field(tag, ind1, ind2);

                            // Now, add each subfield
                            while (nodeReader.Read())
                            {
                                if ((nodeReader.NodeType == XmlNodeType.EndElement) && (nodeReader.Name.Replace("marc:", "") == "datafield"))
                                {
                                    break;
                                }

                                if ((nodeReader.NodeType == XmlNodeType.Element) && (nodeReader.Name.Replace("marc:", "") == "subfield"))
                                {
                                    // Get the code
                                    nodeReader.MoveToFirstAttribute();
                                    char subfield = nodeReader.Value.Length > 0 ? nodeReader.Value[0] : ' ';

                                    // Get the value
                                    nodeReader.Read();
                                    string dataValue = nodeReader.Value;

                                    // Save this subfield
                                    newField.Add_Subfield(subfield, dataValue);

                                    // Do some special stuff if this is the 260
                                    if (tag == 260)
                                    {
                                        newField.Control_Field_Value = newField.Control_Field_Value + "|" + subfield + " " + dataValue + " ";
                                    }
                                }
                            }
                            break;
                        }
                    }
                }

                return(true);
            }
            catch
            {
                return(false);
            }
        }
Example #7
0
        internal override MARC_Field to_MARC_HTML()
        {
            MARC_Field returnValue = new MARC_Field();

            // Set the tag
            if ((id.IndexOf("SUBJ") == 0) && (id.Length >= 7))
            {
                string possible_tag = id.Substring(4, 3);
                try
                {
                    int possible_tag_number = Convert.ToInt16(possible_tag);
                    returnValue.Tag = possible_tag_number;
                }
                catch
                {
                }
            }

            // Try to guess the tag, if there was no tag
            if ((returnValue.Tag <= 0) && (Topics_Count == 0))
            {
                if ((Temporals_Count > 0) && (Genres_Count == 0) && (Geographics_Count == 0))
                {
                    returnValue.Tag = 648;
                }

                if ((Temporals_Count == 0) && (Genres_Count > 0) && (Geographics_Count == 0))
                {
                    returnValue.Tag = 655;
                }

                if ((Temporals_Count == 0) && (Genres_Count == 0) && (Geographics_Count > 0))
                {
                    returnValue.Tag = 651;
                }
            }

            // 650 is the default
            if (returnValue.Tag <= 0)
            {
                returnValue.Tag = 650;
            }

            // No indicators
            returnValue.Indicators = "  ";
            bool          first_field_assigned = false;
            string        scale         = String.Empty;
            StringBuilder fieldBuilder  = new StringBuilder();
            StringBuilder fieldBuilder2 = new StringBuilder();

            // Whenever there is an occupation, it must map into the 656
            if ((occupations != null) && (occupations.Count > 0))
            {
                returnValue.Tag = 656;
                fieldBuilder.Append("|a ");
                foreach (string occupation in occupations)
                {
                    if (!first_field_assigned)
                    {
                        fieldBuilder.Append(occupation);
                        first_field_assigned = true;
                    }
                    else
                    {
                        fieldBuilder.Append(" -- " + occupation);
                    }
                }
                fieldBuilder.Append(" ");
            }

            switch (returnValue.Tag)
            {
            case 690:
                first_field_assigned = assign_genres(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                first_field_assigned = assign_topics(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2, ref scale);
                first_field_assigned = assign_geographics(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                assign_temporals(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                break;

            case 691:
                first_field_assigned = assign_genres(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                first_field_assigned = assign_geographics(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                first_field_assigned = assign_topics(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2, ref scale);
                assign_temporals(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                break;

            default:
                first_field_assigned = assign_geographics(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                first_field_assigned = assign_temporals(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                first_field_assigned = assign_topics(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2, ref scale);
                assign_genres(first_field_assigned, returnValue.Tag, fieldBuilder, fieldBuilder2);
                break;
            }

            if (!String.IsNullOrEmpty(scale))
            {
                fieldBuilder2.Append("|x " + scale + " ");
            }

            fieldBuilder.Append(fieldBuilder2);
            if (fieldBuilder.Length > 2)
            {
                fieldBuilder.Remove(fieldBuilder.Length - 1, 1);
                if ((returnValue.Tag != 653) && (fieldBuilder[fieldBuilder.Length - 1] != '.'))
                {
                    fieldBuilder.Append(". ");
                }
            }

            Add_Source_Indicator(returnValue, fieldBuilder);

            returnValue.Control_Field_Value = returnValue.Tag == 653 ? fieldBuilder.ToString().Trim().Replace("|x ", "|a ") : fieldBuilder.ToString().Trim();

            return(returnValue);
        }
Example #8
0
        internal MARC_Field to_MARC_HTML()
        {
            if (String.IsNullOrEmpty(note))
            {
                return(null);
            }

            MARC_Field returnValue = new MARC_Field();

            returnValue.Indicators          = "  ";
            returnValue.Control_Field_Value = "|a " + note;

            switch (note_type)
            {
            case Note_Type_Enum.thesis:
                returnValue.Tag = 502;
                break;

            case Note_Type_Enum.bibliography:
                returnValue.Tag = 504;
                break;

            case Note_Type_Enum.restriction:
                returnValue.Tag = 506;
                break;

            case Note_Type_Enum.creation_credits:
                returnValue.Tag = 508;
                break;

            case Note_Type_Enum.citation_reference:
                returnValue.Tag = 510;
                break;

            case Note_Type_Enum.performers:
                returnValue.Tag = 511;
                if ((displayLabel != null) && (displayLabel == "cast"))
                {
                    returnValue.Indicators = "1 ";
                }
                break;

            case Note_Type_Enum.type_of_file_or_data:
                returnValue.Tag = 516;
                break;

            case Note_Type_Enum.date_venue:
                returnValue.Tag = 518;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.preferred_citation:
                returnValue.Tag = 524;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.supplements:
                returnValue.Tag = 525;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.additional_physical_form:
                returnValue.Tag = 530;
                break;

            case Note_Type_Enum.original_version:
                returnValue.Tag = 534;
                break;

            case Note_Type_Enum.original_location:
                returnValue.Tag = 535;
                break;

            case Note_Type_Enum.funding:
                returnValue.Tag = 536;
                break;

            case Note_Type_Enum.system_details:
                returnValue.Tag = 538;
                break;

            case Note_Type_Enum.acquisition:
                returnValue.Tag = 541;
                break;

            case Note_Type_Enum.biographical:
                returnValue.Tag = 545;
                break;

            case Note_Type_Enum.language:
                returnValue.Tag = 546;
                break;

            case Note_Type_Enum.ownership:
                returnValue.Tag = 561;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.version_identification:
                returnValue.Tag = 562;
                break;

            case Note_Type_Enum.publications:
                returnValue.Tag = 581;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.exhibitions:
                returnValue.Tag = 585;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.issuing_body:
                returnValue.Tag = 550;
                break;

            case Note_Type_Enum.numbering_peculiarities:
                returnValue.Tag = 515;
                break;

            case Note_Type_Enum.dates_sequential_designation:
                returnValue.Tag        = 362;
                returnValue.Indicators = "1 ";
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |z " + displayLabel;
                }
                break;

            case Note_Type_Enum.source:
                returnValue.Tag                 = 786;
                returnValue.Indicators          = "0 ";
                returnValue.Control_Field_Value = "|n " + note;
                break;

            case Note_Type_Enum.local:
                returnValue.Tag = 590;
                break;

            case Note_Type_Enum.source_of_description:
                returnValue.Tag = 588;
                break;

            case Note_Type_Enum.internal_comments:
                return(null);

            case Note_Type_Enum.publication_status:
                return(null);

            case Note_Type_Enum.default_type:
                return(null);

            default:
                returnValue.Tag = 500;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    switch (displayLabel.ToUpper())
                    {
                    case "GEOGRAPHIC COVERAGE":
                        returnValue.Tag = 522;
                        break;

                    case "SUPPLEMENT NOTE":
                        returnValue.Tag = 525;
                        break;

                    case "METHODOLOGY":
                        returnValue.Tag = 567;
                        break;

                    case "AWARDS":
                        returnValue.Tag = 586;
                        break;
                    }
                }
                break;
            }

            return(returnValue);
        }
        internal MARC_Field to_MARC_HTML()
        {
            if ((authority == "marcgt") || (genre_term.Trim().Length == 0))
            {
                return(null);
            }

            MARC_Field returnValue = new MARC_Field {
                Tag = 655
            };

            string second_indicator;
            string authority_builder = String.Empty;

            if (!String.IsNullOrEmpty(authority))
            {
                switch (authority.ToLower())
                {
                case "lcsh":
                    second_indicator = "0";
                    break;

                case "lcshac":
                    second_indicator = "1";
                    break;

                case "mesh":
                    second_indicator = "2";
                    break;

                case "nal":
                    second_indicator = "3";
                    break;

                case "csh":
                    second_indicator = "5";
                    break;

                case "rvm":
                    second_indicator = "6";
                    break;

                case "local":
                    second_indicator = "9";
                    break;

                default:
                    authority_builder = " |2 " + authority;
                    second_indicator  = "7";
                    break;
                }
            }
            else
            {
                second_indicator = "4";
            }

            returnValue.Indicators = " " + second_indicator;
            if ((authority_builder.Length == 0) && (genre_term.Length > 1) && (genre_term[genre_term.Length - 1] != '.'))
            {
                returnValue.Control_Field_Value = "|a " + genre_term + ".";
            }
            else
            {
                returnValue.Control_Field_Value = "|a " + genre_term + authority_builder;
            }
            return(returnValue);
        }
Example #10
0
        internal override MARC_Field to_MARC_HTML()
        {
            MARC_Field returnValue = new MARC_Field();

            if ((String.IsNullOrEmpty(country)) && (String.IsNullOrEmpty(city)) && (String.IsNullOrEmpty(county)) && (String.IsNullOrEmpty(province)) && (String.IsNullOrEmpty(territory)) && (String.IsNullOrEmpty(citysection)))
            {
                if (!String.IsNullOrEmpty(area))
                {
                    returnValue.Tag = 752;
                    returnValue.Control_Field_Value = "|g " + area + ".";
                }
                if (!String.IsNullOrEmpty(region))
                {
                    returnValue.Tag = 752;
                    returnValue.Control_Field_Value = "|g " + region + ".";
                }
                return(null);
            }

            // No indicators
            returnValue.Indicators = "  ";

            //if ((id.IndexOf("662") < 0) && (id.IndexOf("752") < 0) && (area.Length > 0)  && (country.Length == 0) && (city.Length == 0) && (county.Length == 0) && (province.Length == 0) && (territory.Length == 0) && ( citysection.Length == 0 ))
            //{
            //    returnValue.Tag = "752";
            //    returnValue.Field = "|g " + area;
            //}
            //else
            //{
            // Set the tag
            returnValue.Tag = 752;
            if (id.IndexOf("SUBJ662") == 0)
            {
                returnValue.Tag = 662;
            }

            StringBuilder fieldBuilder = new StringBuilder();

            if (!String.IsNullOrEmpty(country))
            {
                fieldBuilder.Append("|a " + country + " ");
            }

            if (!String.IsNullOrEmpty(state))
            {
                fieldBuilder.Append("|b " + state + " ");
            }
            else
            {
                if (!String.IsNullOrEmpty(territory))
                {
                    fieldBuilder.Append("|b " + territory + " ");
                }
                else if (!String.IsNullOrEmpty(province))
                {
                    fieldBuilder.Append("|b " + province + " ");
                }
            }
            if (!String.IsNullOrEmpty(county))
            {
                fieldBuilder.Append("|c " + county + " ");
            }
            if (!String.IsNullOrEmpty(city))
            {
                fieldBuilder.Append("|d " + city + " ");
            }
            if (!String.IsNullOrEmpty(citysection))
            {
                fieldBuilder.Append("|f " + citysection + " ");
            }
            if (!String.IsNullOrEmpty(area))
            {
                fieldBuilder.Append("|g " + area + " ");
            }
            if (!String.IsNullOrEmpty(island))
            {
                fieldBuilder.Append("|g " + island + " ");
            }

            if (fieldBuilder.Length > 2)
            {
                fieldBuilder.Remove(fieldBuilder.Length - 1, 1);
                fieldBuilder.Append(". ");
            }

            if (!String.IsNullOrEmpty(authority))
            {
                fieldBuilder.Append("|2 " + authority + " ");
            }

            returnValue.Control_Field_Value = fieldBuilder.ToString().Trim();
            //}


            return(returnValue);
        }
        internal MARC_Field to_MARC_HTML(int Tag, int FillIndicator, string StatementOfResponsibility, string HField)
        {
            if (String.IsNullOrEmpty(title))
            {
                return(null);
            }

            MARC_Field    returnValue  = new MARC_Field();
            StringBuilder fieldBuilder = new StringBuilder();

            returnValue.Tag = Tag;
            if (Tag < 0)
            {
                returnValue.Tag = 0;
            }
            returnValue.Indicators = "  ";
            string fill_indicator_value = "0";

            if (!String.IsNullOrEmpty(nonSort))
            {
                if (nonSort[nonSort.Length - 1] == ' ')
                {
                    fill_indicator_value = (nonSort.Length).ToString();
                }
                else
                {
                    if (nonSort[nonSort.Length - 1] == '\'')
                    {
                        fill_indicator_value = (nonSort.Length).ToString();
                    }
                    else
                    {
                        fill_indicator_value = (nonSort.Length + 1).ToString();
                        nonSort = nonSort + " ";
                    }
                }
            }

            if ((!String.IsNullOrEmpty(displayLabel)) && (displayLabel != "Uncontrolled") && (displayLabel != "Main Entry"))
            {
                fieldBuilder.Append("|i " + displayLabel + ": ");
            }

            if (!String.IsNullOrEmpty(nonSort))
            {
                fieldBuilder.Append("|a " + nonSort + title.Replace("|", "&bar;") + " ");
            }
            else
            {
                fieldBuilder.Append("|a " + title.Replace("|", "&bar;") + " ");
            }

            if (HField.Length > 0)
            {
                fieldBuilder.Append("|h " + HField + " ");
            }

            if (!String.IsNullOrEmpty(subtitle))
            {
                fieldBuilder.Append("|b " + subtitle + " ");
            }

            if (StatementOfResponsibility.Length > 0)
            {
                fieldBuilder.Append("/ |c " + StatementOfResponsibility + " ");
            }

            if (partNumbers != null)
            {
                foreach (string thisPart in partNumbers)
                {
                    fieldBuilder.Append("|n " + thisPart + " ");
                }
            }

            if (partNames != null)
            {
                foreach (string thisPart in partNames)
                {
                    fieldBuilder.Append("|p " + thisPart + " ");
                }
            }

            if (!String.IsNullOrEmpty(language))
            {
                fieldBuilder.Append("|y " + language + " ");
            }

            string completeField = fieldBuilder.ToString().Trim();

            if (completeField.Length > 0)
            {
                if (completeField[completeField.Length - 1] != '.')
                {
                    returnValue.Control_Field_Value = completeField + ".";
                }
                else
                {
                    returnValue.Control_Field_Value = completeField;
                }
            }

            if (returnValue.Tag <= 0)
            {
                switch (titleType)
                {
                case Title_Type_Enum.Uniform:
                    switch (displayLabel)
                    {
                    case "Main Entry":
                        returnValue.Tag = 130;
                        FillIndicator   = 1;
                        break;

                    case "Uncontrolled":
                        returnValue.Tag = 730;
                        FillIndicator   = 1;
                        break;

                    default:
                        returnValue.Tag = 240;
                        FillIndicator   = 2;
                        break;
                    }
                    break;

                case Title_Type_Enum.Translated:
                    returnValue.Tag = 242;
                    FillIndicator   = 2;
                    break;

                case Title_Type_Enum.Abbreviated:
                    returnValue.Tag = 210;
                    FillIndicator   = -1;
                    break;

                case Title_Type_Enum.Alternative:
                    if ((!String.IsNullOrEmpty(displayLabel) && (displayLabel == "Uncontrolled")))
                    {
                        returnValue.Tag = 740;
                        FillIndicator   = 1;
                    }
                    else
                    {
                        returnValue.Tag        = 246;
                        FillIndicator          = -1;
                        returnValue.Indicators = "3 ";
                        if (!String.IsNullOrEmpty(displayLabel))
                        {
                            switch (displayLabel)
                            {
                            case "Portion of title":
                                returnValue.Indicators = "30";
                                break;

                            case "Parallel title":
                                returnValue.Indicators = "31";
                                break;

                            case "Distinctive title":
                                returnValue.Indicators = "32";
                                break;

                            case "Other title":
                                returnValue.Indicators = "33";
                                break;

                            case "Cover title":
                                returnValue.Indicators = "34";
                                break;

                            case "Added title page title":
                                returnValue.Indicators = "35";
                                break;

                            case "Caption title":
                                returnValue.Indicators = "36";
                                break;

                            case "Running title":
                                returnValue.Indicators = "37";
                                break;

                            case "Spine title":
                                returnValue.Indicators = "38";
                                break;

                            default:
                                returnValue.Indicators = "3 ";
                                break;
                            }
                        }
                    }
                    break;
                }
            }

            switch (FillIndicator)
            {
            case 1:
                returnValue.Indicators = fill_indicator_value + " ";
                break;

            case 2:
                returnValue.Indicators = " " + fill_indicator_value;
                break;
            }

            return(returnValue);
        }
Example #12
0
        internal MARC_Field to_MARC_Tag()
        {
            if (String.IsNullOrEmpty(classification))
            {
                return(null);
            }

            MARC_Field returnValue = new MARC_Field
            {
                Indicators = "  ",
                Tag        = 84
            };


            string authority_builder = String.Empty;

            if (!String.IsNullOrEmpty(authority))
            {
                switch (authority.ToLower())
                {
                case "lcc":
                    returnValue.Tag = 50;
                    if (!String.IsNullOrEmpty(displayLabel))
                    {
                        authority_builder = "|3 " + displayLabel;
                    }
                    returnValue.Indicator1 = ' ';
                    returnValue.Indicator2 = '4';
                    break;

                case "ddc":
                    returnValue.Tag = 82;
                    if (!String.IsNullOrEmpty(edition))
                    {
                        authority_builder = "|2 " + edition;
                    }
                    break;

                case "udc":
                    returnValue.Tag = 80;
                    break;

                case "nlm":
                    returnValue.Tag = 60;
                    break;

                case "sudocs":
                    returnValue.Tag        = 86;
                    returnValue.Indicator1 = '0';
                    break;

                case "candocs":
                    returnValue.Tag        = 86;
                    returnValue.Indicator1 = '1';
                    break;

                default:
                    if (!String.IsNullOrEmpty(authority))
                    {
                        authority_builder = "|2 " + authority;
                    }
                    break;
                }
            }
            returnValue.Control_Field_Value = "|a " + classification + authority_builder;
            return(returnValue);
        }
        internal MARC_Field to_MARC_HTML()
        {
            MARC_Field related_item_tag = new MARC_Field
            {
                Indicators = "00",
                Tag        = 787
            };

            switch (Relationship)
            {
            case Related_Item_Type_Enum.Host:
                related_item_tag.Tag        = 773;
                related_item_tag.Indicators = "0 ";
                break;

            case Related_Item_Type_Enum.OtherFormat:
                related_item_tag.Tag        = 776;
                related_item_tag.Indicators = "0 ";
                break;

            case Related_Item_Type_Enum.OtherVersion:
                related_item_tag.Tag        = 775;
                related_item_tag.Indicators = "0 ";
                break;

            case Related_Item_Type_Enum.Preceding:
                related_item_tag.Tag = 780;
                break;

            case Related_Item_Type_Enum.Succeeding:
                related_item_tag.Tag = 785;
                break;
            }

            StringBuilder relatedBuilder = new StringBuilder();
            string        issn           = String.Empty;
            string        isbn           = String.Empty;

            if (!String.IsNullOrEmpty(sobekcm_id))
            {
                relatedBuilder.Append("|o (UFDC)" + sobekcm_id + " ");
            }
            if ((title != null) && (title.Title.Length > 0))
            {
                relatedBuilder.Append("|t " + title.Title + " ");
            }
            if (identifiers != null)
            {
                foreach (Identifier_Info thisIdentifier in identifiers)
                {
                    switch (thisIdentifier.Type.ToUpper())
                    {
                    case "ISSN":
                        issn = thisIdentifier.Identifier;
                        break;

                    case "ISBN":
                        isbn = thisIdentifier.Identifier;
                        break;

                    case "OCLC":
                        relatedBuilder.Append("|w (OCoLC)" + thisIdentifier.Identifier + " ");
                        break;

                    case "LCCN":
                        relatedBuilder.Append("|w (DLC)sn" + thisIdentifier.Identifier + " ");
                        break;

                    default:
                        relatedBuilder.Append("|w " + thisIdentifier.Identifier + " ");
                        break;
                    }
                }
            }
            if (issn.Length > 0)
            {
                relatedBuilder.Append("|x " + issn + " ");
            }
            if (isbn.Length > 0)
            {
                relatedBuilder.Append("|z " + isbn + " ");
            }

            related_item_tag.Control_Field_Value = relatedBuilder.ToString();
            return(related_item_tag);
        }
        internal override MARC_Field to_MARC_HTML()
        {
            MARC_Field returnValue = nameInfo.to_MARC_HTML(true);

            // Set the tag
            returnValue.Tag = 600;
            switch (nameInfo.Name_Type)
            {
            case Name_Info_Type_Enum.Personal:
                returnValue.Tag = 600;
                break;

            case Name_Info_Type_Enum.Corporate:
                returnValue.Tag = 610;
                break;

            case Name_Info_Type_Enum.Conference:
                returnValue.Tag = 611;
                break;
            }

            // Add to the built field
            StringBuilder fieldBuilder = new StringBuilder(returnValue.Control_Field_Value + " ");

            if (geographics != null)
            {
                foreach (string geo in geographics)
                {
                    fieldBuilder.Append("|z " + geo + " ");
                }
            }

            if (temporals != null)
            {
                foreach (string temporal in temporals)
                {
                    fieldBuilder.Append("|y " + temporal + " ");
                }
            }

            if (topics != null)
            {
                foreach (string topic in topics)
                {
                    fieldBuilder.Append("|x " + topic + " ");
                }
            }

            if (genres != null)
            {
                foreach (string form in genres)
                {
                    fieldBuilder.Append("|v " + form + " ");
                }
            }

            Add_Source_Indicator(returnValue, fieldBuilder);

            // Add the relator codes last
            foreach (Name_Info_Role thisRole in nameInfo.Roles)
            {
                if ((thisRole.Role_Type == Name_Info_Role_Type_Enum.Code) && (thisRole.Authority == "marcrelator"))
                {
                    fieldBuilder.Append("|4 " + thisRole.Role + " ");
                }
            }

            returnValue.Control_Field_Value = fieldBuilder.ToString().Trim();

            return(returnValue);
        }
        internal MARC_Field to_MARC_HTML()
        {
            if (String.IsNullOrEmpty(note))
            {
                return(null);
            }

            MARC_Field returnValue = new MARC_Field
            {
                Indicators          = "  ",
                Control_Field_Value = "|a " + note
            };

            switch (note_type)
            {
            case Note_Type_Enum.Thesis:
                returnValue.Tag = 502;
                break;

            case Note_Type_Enum.Bibliography:
                returnValue.Tag = 504;
                break;

            case Note_Type_Enum.Restriction:
                returnValue.Tag = 506;
                break;

            case Note_Type_Enum.CreationCredits:
                returnValue.Tag = 508;
                break;

            case Note_Type_Enum.CitationReference:
                returnValue.Tag = 510;
                break;

            case Note_Type_Enum.Performers:
                returnValue.Tag = 511;
                if ((displayLabel != null) && (displayLabel == "cast"))
                {
                    returnValue.Indicators = "1 ";
                }
                break;

            case Note_Type_Enum.TypeOfFileOrData:
                returnValue.Tag = 516;
                break;

            case Note_Type_Enum.DateVenue:
                returnValue.Tag = 518;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.PreferredCitation:
                returnValue.Tag = 524;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.Supplements:
                returnValue.Tag = 525;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.AdditionalPhysicalForm:
                returnValue.Tag = 530;
                break;

            case Note_Type_Enum.OriginalVersion:
                returnValue.Tag = 534;
                break;

            case Note_Type_Enum.OriginalLocation:
                returnValue.Tag = 535;
                break;

            case Note_Type_Enum.Funding:
                returnValue.Tag = 536;
                break;

            case Note_Type_Enum.SystemDetails:
                returnValue.Tag = 538;
                break;

            case Note_Type_Enum.Acquisition:
                returnValue.Tag = 541;
                break;

            case Note_Type_Enum.Biographical:
                returnValue.Tag = 545;
                break;

            case Note_Type_Enum.Language:
                returnValue.Tag = 546;
                break;

            case Note_Type_Enum.Ownership:
                returnValue.Tag = 561;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.VersionIdentification:
                returnValue.Tag = 562;
                break;

            case Note_Type_Enum.Publications:
                returnValue.Tag = 581;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.Action:
                returnValue.Tag = 583;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = "|a " + displayLabel + " |l " + note;
                }
                break;

            case Note_Type_Enum.Exhibitions:
                returnValue.Tag = 585;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |3 " + displayLabel;
                }
                break;

            case Note_Type_Enum.IssuingBody:
                returnValue.Tag = 550;
                break;

            case Note_Type_Enum.NumberingPeculiarities:
                returnValue.Tag = 515;
                break;

            case Note_Type_Enum.DatesSequentialDesignation:
                returnValue.Tag        = 362;
                returnValue.Indicators = "1 ";
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    returnValue.Control_Field_Value = returnValue.Control_Field_Value + " |z " + displayLabel;
                }
                break;

            case Note_Type_Enum.Source:
                returnValue.Tag                 = 786;
                returnValue.Indicators          = "0 ";
                returnValue.Control_Field_Value = "|n " + note;
                break;

            case Note_Type_Enum.Local:
                returnValue.Tag = 590;
                break;

            case Note_Type_Enum.SourceOfDescription:
                returnValue.Tag = 588;
                break;

            case Note_Type_Enum.InternalComments:
                return(null);

            case Note_Type_Enum.PublicationStatus:
                return(null);

            case Note_Type_Enum.DefaultType:
                return(null);

            default:
                returnValue.Tag = 500;
                if (!String.IsNullOrEmpty(displayLabel))
                {
                    switch (displayLabel.ToUpper())
                    {
                    case "GEOGRAPHIC COVERAGE":
                        returnValue.Tag = 522;
                        break;

                    case "SUPPLEMENT NOTE":
                        returnValue.Tag = 525;
                        break;

                    case "METHODOLOGY":
                        returnValue.Tag = 567;
                        break;

                    case "AWARDS":
                        returnValue.Tag = 586;
                        break;
                    }
                }
                break;
            }

            return(returnValue);
        }