Пример #1
0
        private static void DoFormat
        (
            object arg
        )
        {
            try
            {
                RecordTask taskInfo = (RecordTask)arg;
                using (IrbisConnection client = new IrbisConnection())
                {
                    client.ParseConnectionString(ConnectionString);
                    client.Connect();

                    MarcRecord targetRecord = Fst.Execute
                                              (
                        client,
                        taskInfo.Record
                                              );
                    if (targetRecord != null)
                    {
                        targetRecord.SetSubField(463, 'w', taskInfo.CurrentIssue);
                        targetRecord.SetSubField(463, 'c', taskInfo.Magazine.Title);

                        lock (SyncRoot)
                        {
                            RecordCount++;
                            //Buffer.Append(targetRecord);
                            client.WriteRecord(targetRecord, false, true);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                WriteLogLine("EXCEPTION: {0}", ex);
            }
        }
Пример #2
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);
        }