public void MarcRecordUtility_SetField_4()
        {
            MarcRecord record = new MarcRecord();
            MarcRecord result = record.SetField(700, 1, "^aСидоров^bС. С.");

            Assert.AreSame(record, result);
            Assert.AreEqual(0, record.Fields.Count);
        }
        public void MarcRecordUtility_SetField_1()
        {
            MarcRecord record = new MarcRecord();
            MarcRecord result = record.SetField(700, "^aСидоров^bС. С.");

            Assert.AreSame(record, result);
            Assert.AreEqual(1, record.Fields.Count);
            Assert.AreEqual(2, record.Fields[0].SubFields.Count);
            Assert.AreEqual("Сидоров", record.Fields[0].SubFields[0].Value);
        }
        public void MarcRecordUtility_SetField_6()
        {
            MarcRecord record = new MarcRecord();

            record.AddField(700, "^aИванов^bИ. И.");
            record.AddField(700, "^aПетров^bП. П.");
            MarcRecord result = record.SetField(700, 1, "^aСидоров^bС. С.");

            Assert.AreSame(record, result);
            Assert.AreEqual(2, record.Fields.Count);
            Assert.AreEqual(2, record.Fields[0].SubFields.Count);
            Assert.AreEqual("Иванов", record.Fields[0].SubFields[0].Value);
            Assert.AreEqual(2, record.Fields[0].SubFields.Count);
            Assert.AreEqual("Сидоров", record.Fields[1].SubFields[0].Value);
        }
Example #4
0
        private void _fixShelfButton_Click
        (
            object sender,
            EventArgs e
        )
        {
            if (_currentRecord == null ||
                _currentExemplar == null)
            {
                XtraMessageBox.Show
                (
                    "Нечего исправлять!"
                );
                return;
            }

            string currentShelf = CurrentShelf;

            if (string.IsNullOrEmpty(currentShelf))
            {
                XtraMessageBox.Show
                (
                    "Не задан раздел!"
                );
                return;
            }

            if (currentShelf.ContainsAnySymbol
                (
                    ' ',
                    ',',
                    ';'
                ))
            {
                XtraMessageBox.Show
                (
                    "Раздел содержит недопустимые символы!"
                );
                return;
            }

            string shelf = _currentRecord.FM(906);

            if (!string.IsNullOrEmpty(shelf))
            {
                XtraMessageBox.Show
                (
                    "В записи уже установлен "
                    + "систематический шифр, "
                    + "его нельзя менять!"
                );
                return;
            }

            _currentRecord.SetField
            (
                906,
                currentShelf
            );

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            _client.WriteRecord
            (
                _currentRecord,
                false,
                true
            );
            stopwatch.Stop();
            _logBox.Output.WriteLine
            (
                "Исправлен раздел для метки {0}: {1} ({2})",
                _currentExemplar.Barcode,
                _currentRecord.UserData,
                stopwatch.Elapsed
            );

            _SetHtml(string.Empty);

            _currentRecord   = null;
            _currentExemplar = null;
        }
Example #5
0
        static bool ProcessRecord
        (
            MarcRecord record
        )
        {
            string article = record.FM(1);

            if (string.IsNullOrEmpty(article))
            {
                WriteLogLine("Запись без идентификатора, пропускаем ее");
                return(false);
            }

            WriteLog("[{0}] СТАТЬЯ {1}: ", RecordCount, article);

            string code    = GetCode(record, "code");
            string year    = GetCode(record, "year");
            string volume  = GetCode(record, "to");
            string number  = GetCode(record, "no") ?? GetCode(record, "vy");
            string chapter = GetCode(record, "ch");

            if (string.IsNullOrEmpty(code))
            {
                WriteLog("Нет поля code, пропускаем запись ");
                return(false);
            }
            if (string.IsNullOrEmpty(year))
            {
                WriteLog("Нет поля year, пропускаем запись ");
                return(false);
            }
            if (string.IsNullOrEmpty(number))
            {
                WriteLog("Нет поля number, пропускаем запись ");
                return(false);
            }

            MagazineInfo magazine;

            if (!Magazines.TryGetValue(code, out magazine))
            {
                WriteLog("Журнал с неизвестным кодом {0}, пропускаем ", code);
                return(true);
            }

            if (magazine.Flag != "1")
            {
                WriteLog("Журнал не помечен как импортируемый, пропускаем ");
                return(true);
            }

            if ((string.CompareOrdinal(year, MinYear) < 0) ||
                (string.CompareOrdinal(year, MaxYear) > 0))
            {
                WriteLog
                (
                    "Год {0} не входит в диапазон {1}-{2}, пропускаем ",
                    year,
                    MinYear,
                    MaxYear
                );
                return(true);
            } // if

            string issueIndex = magazine.Index + "/" + year;

            if (!string.IsNullOrEmpty(volume))
            {
                issueIndex += ("/" + volume);
            }
            issueIndex += ("/" + number);
            if (!string.IsNullOrEmpty(chapter))
            {
                issueIndex += ("/" + chapter);
            }

            if (CurrentIssue != issueIndex)
            {
                WriteLog
                (
                    "ЖУРНАЛ {0} {1}/{2} ",
                    magazine.Title,
                    year,
                    number
                );

                int[] previousArticles = new int[0];

                lock (SyncRoot)
                {
                    try
                    {
                        previousArticles = Client.Search
                                           (
                            "\"II={0}\"",
                            issueIndex
                                           );
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex);
                    }
                }
                if (previousArticles.Length != 0)
                {
                    if (WhenAlreadyExists == "skip")
                    {
                        WriteLog
                        (
                            "Найдено {0} предыдущих версий статей, пропускаем{1}",
                            previousArticles.Length,
                            Environment.NewLine
                        );
                        return(false);
                    }
                    if (WhenAlreadyExists == "delete")
                    {
                        WriteLog
                        (
                            "Найдено {0} предыдущих версий статей, удаляем... ",
                            previousArticles.Length
                        );
                        lock (SyncRoot)
                        {
                            Client.DeleteRecords
                            (
                                Client.Database,
                                previousArticles
                            );
                        }
                        WriteLog("удалено" + Environment.NewLine);
                    }
                    else
                    {
                        throw new ApplicationException
                              (
                                  string.Format
                                  (
                                      "Неизвестное управляющее слово {0}",
                                      WhenAlreadyExists
                                  )
                              );
                    }
                } // if

                MarcRecord issueRecord = null;

                lock (SyncRoot)
                {
                    try
                    {
                        issueRecord = Client.SearchReadOneRecord
                                      (
                            "\"I={0}\"",
                            issueIndex
                                      );
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine(ex);
                        return(true);
                    }
                }
                if (issueRecord == null)
                {
                    WriteLog("Нет записи I={0}, создаем ее... ", issueIndex);
                    issueRecord = new MarcRecord();
                    issueRecord
                    .SetField(920, "NJ")
                    .SetField(933, magazine.Index)
                    .SetField(903, issueIndex)
                    .SetField(934, year)
                    .SetField(936, number)
                    .SetField(300, "Запись создана при импорте статей МАРС");
                    if (!string.IsNullOrEmpty(volume))
                    {
                        issueRecord.SetField(935, volume);
                    }
                    lock (SyncRoot)
                    {
                        //Buffer.Append(issueRecord);
                        Client.WriteRecord(issueRecord, false, true);
                        RecordCount++;
                    }
                    WriteLog("создана ");
                } // if

                CurrentIssue = issueIndex;
            } // if

            RecordTask recordTask = new RecordTask
            {
                CurrentIssue = CurrentIssue,
                Magazine     = magazine,
                Record       = record
            };

            Queue.QueueTask
            (
                DoFormat,
                recordTask
            );
            WriteLog("=> в очередь ");

            return(true);
        }