public static bool MirrorDataSetTo(WCFStandardsNS.WCFStandards TargetDataBase, DataSet DataSetToMirror)
{
if (DataSetToMirror == null)
return true;
foreach (DataTable SourceTable in DataSetToMirror.Tables)
{
DataTable DeletedRows = SourceTable.GetChanges(DataRowState.Deleted);
if (DeletedRows != null)
foreach (DataRow ToDelete in DeletedRows.Rows)
{
if (TargetDataBase.GetCommonDataSet
("Select ID from " + SourceTable.TableName
+ " where ID = '" + ToDelete["ID"].ToString() + "'")
.Tables[SourceTable.TableName].Rows.Count > 0)
{
String DeleteCommand = "Delete from " + SourceTable.TableName
+ " where ID = '" + ToDelete["ID"].ToString() + "'";
TargetDataBase.RunSQLBatch(DeleteCommand);
}
}
List<String> SourceIDs = new List<string>();
foreach (DataRow SourceRow in SourceTable.Rows)
if (SourceRow.RowState != DataRowState.Deleted)
SourceIDs.Add(SourceRow["ID"].ToString());
if (SourceIDs.Count == 0)
continue;
String WhereClause = " where (ID = '" + String.Join("' or ID = '", SourceIDs.ToArray()) + "') ";
DataSet TargetDataSet = TargetDataBase.GetCommonDataSet("Select * from "
+ SourceTable.TableName + WhereClause);
if (TargetDataSet == null)
{
WMB.Basics.ReportErrorToEventViewer("MBRStatics.MirrorDataSetTo",
"Bei der Table \"" + SourceTable.TableName + "\" konnte nichts gelesen werden");
return false;
}
foreach (DataRow SourceRow in SourceTable.Rows)
{
DataRow[] TargetRows = TargetDataSet.Tables[SourceTable.TableName]
.Select("ID = '" + SourceRow["ID"].ToString() + "'");
if (TargetRows.Length > 1)
{
WMB.Basics.ReportErrorToEventViewer("MBRStatics.MirrorDataSetTo",
"Bei der Table \"" + SourceTable.TableName + "\" für die ID \""
+ SourceRow["ID"].ToString() + "\" gibt es mehr als einen Record!!!");
return false;
}
if (TargetRows.Length > 1)
{
WMB.Basics.ReportErrorToEventViewer("MBRStatics.MirrorDataSetTo",
"Bei der Tabelle \"" + SourceTable.TableName + "\"\r\n"
+ "Bei der ID \"" + SourceRow["ID"].ToString() +
"\" tritt ein Datenbank Fehler auf.\r\n"
+ "Mehr als ein Record für diese ID");
continue;
}
DataRow TargetRow = null;
if (TargetRows.Length < 1)
{
TargetRow = TargetDataSet.Tables[SourceTable.TableName].NewRow();
TargetRow["ID"] = SourceRow["ID"].ToString();
TargetRow["LastUpdateToken"] = WMB.Basics.GetNextLastUpdateTokenHelper();
TargetDataSet.Tables[SourceTable.TableName].Rows.Add(TargetRow);
}
else
{
TargetRow = TargetRows[0];
}
foreach (DataColumn Col in TargetDataSet.Tables[SourceTable.TableName].Columns)
{
if (Col.ColumnName != "ID")
if (String.Compare(TargetRow[Col.ColumnName].ToString(),
SourceRow[Col.ColumnName].ToString()) != 0)
{
if (Convert.IsDBNull(SourceRow[Col.ColumnName]) == true)
TargetRow[Col.ColumnName] = Convert.DBNull;
else
TargetRow[Col.ColumnName] = SourceRow[Col.ColumnName].ToString();
}
}
}
String ReturnMessage = TargetDataBase.SetCommonDataSet(TargetDataSet);
if (!String.IsNullOrEmpty(ReturnMessage))
{
WMB.Basics.ReportErrorToEventViewer("MBRStatics.MirrorDataSetTo",
"Bei der Table \"" + SourceTable.TableName + "\" kam es zu folgendem Fehler:\r\n"
+ ReturnMessage);
return false;
}
}
return true;
}
public void MakePersistent (WCFStandardsNS.WCFStandards CorrespondingDataBase)
{
DataSet Changed = BasisRow.Table.DataSet.GetChanges ();
if (Changed != null)
{
CorrespondingDataBase.SetCommonDataSet (Changed);
BasisRow.Table.DataSet.AcceptChanges();
}
}
bool GetVideoFileEntry (WCFStandardsNS.WCFStandards WPMediaDataBase,
String ArchiveID, String ArchiveSubPathAndFileName, String InsertEntryAs,
double PlayableLengthInSeconds, bool CheckFileParameter,
DataRow BeitragsTypenRow = null)
{
// ------------------------------------------------------------------------------------
//WMB.Basics.ReportInformationToEventViewer("Eingang von GetVideoFileEntry\r\n"
// + "ArchiveID = \"" + ArchiveID + "\"\r\n"
// + "ArchiveSubPathAndFileName = \"" + ArchiveSubPathAndFileName + "\"");
bool DataSetMustBeWrittenBack = false;
bool StructuredMaterialDataBaseMustBeWrittenBack = false;
bool NewVideoFileInserted = false;
String MaterialType = GetTechnicalTypFromFileName (ArchiveSubPathAndFileName);
if (String.IsNullOrEmpty (InsertEntryAs))
InsertEntryAs = MaterialType;
List<String> MaterialTypenArray = GetMaterialTypenArray(WPMediaDataBase);
String CoreName = CVM.CommonValues.GetPureCoreName(ArchiveSubPathAndFileName, MaterialTypenArray, BeitragsTypenRow);
DataSet ResultedVideoFileEntry = null;
if (String.IsNullOrEmpty (InsertEntryAs))
{
ResultedVideoFileEntry = WPMediaDataBase.GetCommonDataSet (String.Format
("Select * from VideoFiles where FoldedArchivePath = '{0}'",
CoreName.ToUpper ()));
}
else
{
ResultedVideoFileEntry = WPMediaDataBase.GetCommonDataSet (String.Format
("Select * from VideoFiles where FoldedArchivePath = '{0}' and BeitragsTyp = '{1}'",
CoreName.ToUpper (), InsertEntryAs));
}
/*
bool OnlyCheckCall = true;
if (MaterialTypenArray.Contains (InsertEntryAs))
OnlyCheckCall = false;
if (OnlyCheckCall == true)
{
foreach (DataRow CheckVideoFileRow in ResultedVideoFileEntry.Tables ["VideoFiles"].Rows)
{
CheckVideoFileRow ["ModifyTimeStamp"] = RenewConversionStatus (CheckVideoFileRow);
}
m_DataBase.SetCommonDataSet (ResultedVideoFileEntry);
return true;
}
if ((String.IsNullOrEmpty(ArchiveID))
&& (String.IsNullOrEmpty(InsertEntryAs)))
{
foreach (DataRow EmptyVideoFileRow in ResultedVideoFileEntry.Tables ["VideoFiles"].Rows)
{
EmptyVideoFileRow ["ModifyTimeStamp"] = RenewConversionStatus (EmptyVideoFileRow);
}
m_DataBase.SetCommonDataSet (ResultedVideoFileEntry);
return true;
}
*/
DataRow VideoFileRow = null;
String ProcessedFileID = String.Empty;
if (ResultedVideoFileEntry.Tables ["VideoFiles"].Rows.Count == 0)
{
// ------------------------------------------------------------------------------------
//WMB.Basics.ReportInformationToEventViewer("ResultedVideoFileEntry.Tables [\"VideoFiles\"].Rows.Count == 0\r\n"
// + "ArchiveID = \"" + ArchiveID + "\"\r\n"
// + "ArchiveSubPathAndFileName = \"" + ArchiveSubPathAndFileName + "\"");
DataSetMustBeWrittenBack = true;
VideoFileRow = ResultedVideoFileEntry.Tables ["VideoFiles"].NewRow ();
ProcessedFileID = System.Guid.NewGuid ().ToString ();
VideoFileRow ["FileID"] = ProcessedFileID;
VideoFileRow ["Type"] = PGM_BEITRAG;
VideoFileRow ["Availability"] = "archived";
VideoFileRow ["Name"] = CoreName;
VideoFileRow ["FoldedArchivePath"] = CoreName.ToUpper ();
VideoFileRow ["BeitragsTyp"] = GetBeitragsTypFromTechnicalTyp (InsertEntryAs);
VideoFileRow ["ConversionStatus"] = " ";
NewVideoFileInserted = true;
VideoFileRow ["LengthInSeconds"] = Convert.ToString (PlayableLengthInSeconds);
VideoFileRow ["ModifyTimeStamp"] = System.DateTime.Now;
ResultedVideoFileEntry.Tables ["VideoFiles"].Rows.Add (VideoFileRow);
WPMediaDataBase.SetCommonDataSet (ResultedVideoFileEntry);
ResultedVideoFileEntry = WPMediaDataBase.GetCommonDataSet (String.Format
("Select * from VideoFiles where FileID = '{0}'",
ProcessedFileID));
VideoFileRow = ResultedVideoFileEntry.Tables ["VideoFiles"].Rows [0];
}
else
{
// ------------------------------------------------------------------------------------
//WMB.Basics.ReportInformationToEventViewer("vor RemoveUnusedVideoFileEntries\r\n"
// + "ArchiveID = \"" + ArchiveID + "\"\r\n"
// + "ArchiveSubPathAndFileName = \"" + ArchiveSubPathAndFileName + "\"");
RemoveUnusedVideoFileEntries(WPMediaDataBase, ResultedVideoFileEntry.Tables["VideoFiles"], ArchiveID);
if (ResultedVideoFileEntry.Tables ["VideoFiles"].Rows.Count == 0)
{
WMB.Basics.ReportErrorToEventViewer ("WPMediaCentralServices::InsertOrCheckStructuredMaterial",
"Beim RemoveUnusedVideoFileEntries für \"" + ArchiveSubPathAndFileName + "\" kamen 0 Rows zurück");
// VideoFileRow ["LengthInSeconds"] = 0;
WPMediaDataBase.SetCommonDataSet (ResultedVideoFileEntry);
return false;
}
VideoFileRow = ResultedVideoFileEntry.Tables ["VideoFiles"].Rows [0];
ProcessedFileID = VideoFileRow ["FileID"].ToString ();
}
double LengthInSeconds = -1;
try
{
//if (PlayableLengthInSeconds == 0)
// {
// System.Drawing.Rectangle AVIRect = new System.Drawing.Rectangle();
// PlayableLengthInSeconds = ManagedProgrammManagement.GetDurationOfWMVFileInSeconds(FileName, ref AVIRect);
// }
LengthInSeconds = InsertOrCheckStructuredMaterial(WPMediaDataBase, ProcessedFileID,
ArchiveID, ArchiveSubPathAndFileName, MaterialType, BeitragsTypenRow);
}
catch (Exception Excp)
{
WMB.Basics.ReportErrorToEventViewer("Bei InsertOrCheckStructuredMaterial\r\n"
+ "ArchiveID = \"" + ArchiveID + "\"\r\n"
+ "ArchiveSubPathAndFileName = \"" + ArchiveSubPathAndFileName + "\"\r\n"
+ "MaterialType = \"" + MaterialType + "\"\r\ntart folgender Fehler auf:\r\n"
+ Excp.ToString ());
}
VideoFileRow ["LengthInSeconds"] = Convert.ToString (LengthInSeconds);
VideoFileRow ["ModifyTimeStamp"] = RenewConversionStatus (WPMediaDataBase, VideoFileRow);
double LengthInSecondsFromRenewConversionStatus = Convert.ToDouble (VideoFileRow ["LengthInSeconds"]);
if ((LengthInSeconds <= 0.1)
&& (LengthInSecondsFromRenewConversionStatus <= 0.1))
VideoFileRow ["LengthInSeconds"] = Convert.ToString (PlayableLengthInSeconds);
WPMediaDataBase.SetCommonDataSet (ResultedVideoFileEntry);
return true;
}
double InsertOrCheckStructuredMaterial (WCFStandardsNS.WCFStandards WPMediaDataBase, String FileID,
String ArchiveID, String ArchiveSubPathAndFileName,
String InsertEntryAs, DataRow BeitragsTypenRow = null)
{
String FullFileName = CheckAccessabilityOfThisFile (WPMediaDataBase, ArchiveID, ArchiveSubPathAndFileName);
if (FullFileName == "")
{
WMB.Basics.ReportErrorToEventViewer ("WPMediaCentralServices::InsertOrCheckStructuredMaterial",
"Der VideoFile \"" + FullFileName + "\" War nicht existent oder nicht zugreifbar");
return 0;
}
FileInfo Info = new FileInfo (FullFileName);
int LengthInKB = (int) (Info.Length / 1024);
DateTime LastWriteTime = Info.LastWriteTime;
double PlayableFileLength = GetPlayableLengthOfThisFileViaFullName (FullFileName);
if (PlayableFileLength < 0)
{
WMB.Basics.ReportErrorToEventViewer ("WPMediaCentralServices::InsertOrCheckStructuredMaterial",
"Für den FileNamen \"" + FullFileName
+ "\" konnte keine Länge ermittelt werden");
return 0;
}
String PlayableFileLengthString = Convert.ToString (PlayableFileLength);
String FileSizeInkB = Convert.ToString (LengthInKB);
DataSet StructuredDataBaseDataSet = WPMediaDataBase.GetCommonDataSet (String.Format
("Select * from StructuredMaterialDataBase where FileID = '{0}'",
FileID));
DataTable StructuredDataBaseDataTable = StructuredDataBaseDataSet.
Tables ["StructuredMaterialDataBase"];
bool StructuredMaterialDataBaseMustBeWrittenBack = true;
bool MaterialFound = false;
foreach (DataRow StructuredMaterial in StructuredDataBaseDataTable.Rows)
{
if (String.Compare (StructuredMaterial [PATH_SUB_PATH_AND_NAME].ToString (), ArchiveSubPathAndFileName, true) == 0)
{
MaterialFound = true;
StructuredMaterialDataBaseMustBeWrittenBack = false;
if (StructuredMaterial ["FileSizeInkB"].ToString () != FileSizeInkB)
{
StructuredMaterial ["FileSizeInkB"] = FileSizeInkB;
StructuredMaterialDataBaseMustBeWrittenBack = true;
}
if (StructuredMaterial ["PlayingDurationInSeconds"].ToString () != PlayableFileLengthString)
{
StructuredMaterial ["PlayingDurationInSeconds"] = PlayableFileLengthString;
StructuredMaterialDataBaseMustBeWrittenBack = true;
}
if ((Convert.IsDBNull (StructuredMaterial ["ModifyTimeStamp"]))
|| (Convert.ToDateTime (StructuredMaterial ["ModifyTimeStamp"]) != LastWriteTime))
{
StructuredMaterial ["ModifyTimeStamp"] = LastWriteTime;
StructuredMaterialDataBaseMustBeWrittenBack = true;
}
if (StructuredMaterialDataBaseMustBeWrittenBack == true)
StructuredMaterial ["LastFoundTimeStamp"] = DateTime.Now;
break;
}
}
if (!MaterialFound)
{
List<String> MaterialTypenArray = GetMaterialTypenArray(WPMediaDataBase);
DataRow NewStructuredMaterial = StructuredDataBaseDataTable.NewRow();
NewStructuredMaterial ["ID"] = System.Guid.NewGuid ();
NewStructuredMaterial ["FileID"] = FileID;
NewStructuredMaterial ["ArchiveID"] = ArchiveID;
NewStructuredMaterial [PATH_SUB_PATH_AND_NAME] = ArchiveSubPathAndFileName;
NewStructuredMaterial ["FoldedArchivePath"] = CVM.CommonValues.GetPureCoreName
(ArchiveSubPathAndFileName, MaterialTypenArray, BeitragsTypenRow).ToUpper ();
NewStructuredMaterial ["FileSizeInkB"] = FileSizeInkB;
NewStructuredMaterial ["PlayingDurationInSeconds"] = PlayableFileLengthString;
NewStructuredMaterial ["ModifyTimeStamp"] = LastWriteTime;
NewStructuredMaterial ["TechnicalTyp"] = InsertEntryAs;
NewStructuredMaterial ["LastFoundTimeStamp"] = DateTime.Now;
StructuredDataBaseDataTable.Rows.Add (NewStructuredMaterial);
StructuredMaterialDataBaseMustBeWrittenBack = true;
}
if (StructuredMaterialDataBaseMustBeWrittenBack)
{
WPMediaDataBase.SetCommonDataSet (StructuredDataBaseDataSet);
}
return PlayableFileLength;
}
public void ActualizeFileDataBaseEntries (WCFStandardsNS.WCFStandards WPMediaDataBase,
WCFStandardsNS.WCFStandards WPMediaAddOnDataBase,
String ArchiveIDs, String BeitragsTypToSearchFor,
DateTime DateBack, DataSet EntriesToClearBeforeActualize)
{
List<String> AutoControlFileBeitragsTypen = GetAutoControlFileBeitragsTypen (WPMediaDataBase);
if (EntriesToClearBeforeActualize != null)
{
DataTable EntriesToActualize = EntriesToClearBeforeActualize.Tables ["EntriesToActualize"];
if ((EntriesToActualize != null)
&& (EntriesToActualize.Rows.Count > 0))
{
String [] FileIDs = new String [ (EntriesToActualize.Rows.Count)];
int Index = 0;
foreach (DataRow Entry in EntriesToActualize.Rows)
{
if (Entry != null)
{
FileIDs [Index] = Entry ["FileID"].ToString ();
Index++;
}
}
String SelectString = "Select * from VideoFiles where FileID = '"
+ System.String.Join ("' OR FileID = '", FileIDs) + "'";
DataSet EntriesToSetToZero = WPMediaDataBase.GetCommonDataSet (SelectString);
foreach (DataRow Entry in EntriesToSetToZero.Tables ["VideoFiles"].Rows)
Entry ["ModifyTimeStamp"] = DateBack.AddHours (-1);
WPMediaDataBase.SetCommonDataSet (EntriesToSetToZero);
}
}
DataSet ActualizingDataSet = new DataSet();
ActualizingDataSet.DataSetName = "Actualizing";
int NumberOfUpdatedRows = 0;
if (String.IsNullOrEmpty (ArchiveIDs))
return;
// ------------------- Get searchable Extensions, SubPaths and SystemPaths
Char [] Delimitter = new Char [] {';', ',', ':'};
DataTable TypenDataTable = WPMediaDataBase.GetCommonDataSet
("Select * from BeitragsTypen where BeitragsTyp = '"
+ BeitragsTypToSearchFor + "'").Tables ["BeitragsTypen"];
if (TypenDataTable.Rows.Count != 1)
{
WMB.Basics.ReportErrorToEventViewer ("WPMediaCentralService::ActualizeFileDataBaseEntries",
"Es wurde für den BeitragsTyp \"" + BeitragsTypToSearchFor + "\" kein Eintrag gefunden");
return;
}
List<String> SearchSubPaths = InsertSenderParameterizedEntries(WPMediaDataBase, WPMediaAddOnDataBase,
TypenDataTable.Rows[0][PGM_BEITRAG_SUB_PATH].ToString());
List<String> SearchSystemPaths = InsertSenderParameterizedEntries(WPMediaDataBase, WPMediaAddOnDataBase,
TypenDataTable.Rows[0][PGM_BEITRAG_SYSTEM_PATH].ToString());
String [] Extensions = TypenDataTable.Rows [0] ["FileExtension"].ToString ().Split (Delimitter);
List<String> MaterialTypenArray = GetMaterialTypenArray (WPMediaDataBase);
String [] ArchiveIDsToProcess = ArchiveIDs.Split (';');
List<String> CombinedSearchPaths = new List<string> ();
foreach (String SearchPath in SearchSystemPaths)
foreach (String SearchSubPath in SearchSubPaths)
{
if (!String.IsNullOrEmpty (SearchSubPath))
{
if (!String.IsNullOrEmpty (SearchPath))
{
CombinedSearchPaths.Add (Path.Combine (SearchPath, SearchSubPath));
}
else
{
CombinedSearchPaths.Add (SearchSubPath);
}
}
else
{
CombinedSearchPaths.Add (SearchPath);
}
}
foreach (String ArchiveIDToProcess in ArchiveIDsToProcess)
{
//if (WMB.Basics.IsTestRun == true)
// WMB.Basics.ReportInformationToEventViewer ("WPMediaCentralService::ActualizeFileDataBaseEntries",
// "ArchiveIDToProcess = \"" + ArchiveIDToProcess + "\"");
FillAndAddNewTableToDataSetAccordingToSqlStatement
(WPMediaDataBase, ActualizingDataSet,
String.Format ("Select * from PhysicalArchivePaths where ArchiveID = '{0}'", ArchiveIDToProcess));
if (ActualizingDataSet.Tables ["PhysicalArchivePaths"].Rows.Count == 0)
{
WMB.Basics.ReportErrorToEventViewer ("WPMediaCentralService::ActualizeFileDataBaseEntries",
"Es wurde für den ArchiveID-Eintrag \"" + ArchiveIDToProcess + "\" keine physische Adresse gefunden");
continue;
}
//String ArchivePathRoot = ActualizingDataSet.Tables ["PhysicalArchivePaths"].
// Rows [0] ["ArchivePhysicalPath"].ToString ();
if (BeitragsTypToSearchFor != "PlayingPackage")
{
FillAndAddNewTableToDataSetAccordingToSqlStatement
(WPMediaDataBase, ActualizingDataSet, String.Format
("Select * from VideoFiles where ModifyTimeStamp > " +
WMB.Basics.GetSQLFormattedDateTime (DateBack)
+ " and BeitragsTyp = '{0}'", BeitragsTypToSearchFor));
}
String PhysicalArchivePathName = ActualizingDataSet.Tables["PhysicalArchivePaths"].Rows[0]
[PATH_HANDLING_ARCHIVE_PHYSICAL_PATH].ToString ();
List<FileInfo> ExistingFileInfoEntriesToCheck = new List<FileInfo> ();
foreach (String SearchSubPath in CombinedSearchPaths)
{
if (WMB.Basics.IsTestRun == true)
WMB.Basics.ReportInformationToEventViewer("WPMediaCentralService::ActualizeFileDataBaseEntries",
"SearchSubPath = \"" + SearchSubPath + "\",\r\nBeitragsTypToSearchFor = \"" + BeitragsTypToSearchFor + "\"");
if (BeitragsTypToSearchFor == "PlayingPackage")
{
FillAndAddNewTableToDataSetAccordingToSqlStatement
(WPMediaDataBase, ActualizingDataSet, String.Format ("Select * from VideoFiles where ModifyTimeStamp > " +
WMB.Basics.GetSQLFormattedDateTime(DateBack) + " and BeitragsTyp = '{0}' and Name like '{1}%'",
BeitragsTypToSearchFor, Path.GetFileName(SearchSubPath)));
}
String BeitragsSearchPath;
if (!String.IsNullOrEmpty (SearchSubPath))
BeitragsSearchPath = Path.Combine(PhysicalArchivePathName, SearchSubPath);
else
BeitragsSearchPath = PhysicalArchivePathName;
ExistingFileInfoEntriesToCheck.AddRange (WMB.Basics.GetFileInfoEntriesFromDirectory
(BeitragsSearchPath, Extensions, -1,
DateBack, false));
if (ExistingFileInfoEntriesToCheck.Count > 0)
{
DataView EntriesForThisBeitragsIDAndTyp = null;
try
{
if (ActualizingDataSet.Tables ["VideoFiles"] == null)
{
WMB.Basics.ReportErrorToEventViewer ("Bei SearchSubPath = \"" + SearchSubPath
+ "\",\r\nBeitragsTypToSearchFor = \"" + BeitragsTypToSearchFor +
"\" war keine \"VideoFiles\" Tabelle vorhanden");
continue;
}
EntriesForThisBeitragsIDAndTyp = new DataView(ActualizingDataSet.Tables["VideoFiles"],
"", "", System.Data.DataViewRowState.CurrentRows);
}
catch (Exception Excp)
{
WMB.Basics.ReportErrorToEventViewer ("Bei SearchSubPath = \"" + SearchSubPath
+ "\",\r\nBeitragsTypToSearchFor = \"" + BeitragsTypToSearchFor + "\" trat folgender Fehler auf:\r\n"
+ Excp.ToString ());
continue;
}
try
{
ActualizeFileDataBaseEntryGroup(WPMediaDataBase, "Beitrag", BeitragsTypToSearchFor, ExistingFileInfoEntriesToCheck,
EntriesForThisBeitragsIDAndTyp, ActualizingDataSet, ArchiveIDToProcess,
PhysicalArchivePathName, MaterialTypenArray, TypenDataTable.Rows[0]);
ExistingFileInfoEntriesToCheck.Clear();
}
catch (Exception Excp)
{
WMB.Basics.ReportErrorToEventViewer ("Bei SearchSubPath = \"" + SearchSubPath
+ "\",\r\nBeitragsTypToSearchFor = \"" + BeitragsTypToSearchFor + "\"\r\nArchiveIDToProcess = \""
+ ArchiveIDToProcess + "\"\r\ntrat folgender Fehler auf:\r\n"
+ Excp.ToString ());
continue;
}
}
}
}
}
