ExportFile
Container class for all export settings
using FileNaming.CustomFileNaming;
using kCura.WinEDDS.Exporters;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.CompilerServices;
using Relativity.DataExchange;
using Relativity.DataExchange.Service;
using System;
using System.Collections.Specialized;
using System.Data;
using System.Net;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Text;
using System.Web;
namespace kCura.WinEDDS
{
[Serializable]
public class ExportFile : ISerializable
{
public enum ExportType
{
Production,
ArtifactSearch,
ParentSearch,
AncestorSearch
}
public enum ExportedFilePathType
{
Relative,
Absolute,
Prefix
}
public enum ImageType
{
Select = -1,
SinglePage,
MultiPageTiff,
Pdf
}
public class ImageTypeParser
{
public ImageType? Parse(string s)
{
if (!string.IsNullOrEmpty(s)) {
ImageType? result = null;
if (Operators.CompareString(s, "Single-page TIF/JPG", false) == 0)
result = ImageType.SinglePage;
else if (Operators.CompareString(s, "Multi-page TIF", false) == 0) {
result = ImageType.MultiPageTiff;
} else if (Operators.CompareString(s, "PDF", false) == 0) {
result = ImageType.Pdf;
}
return result;
}
return null;
}
}
protected string _loadFilesPrefix;
protected int _startAtDocument;
private int _artifactTypeId;
[CompilerGenerated]
private Pair[] _ImagePrecedence;
[CompilerGenerated]
private CaseInfo _CaseInfo;
[CompilerGenerated]
private DataTable _DataTable;
[CompilerGenerated]
private HybridDictionary _ArtifactAvfLookup;
[CompilerGenerated]
private char _NestedValueDelimiter;
[CompilerGenerated]
private ExportType _TypeOfExport;
[CompilerGenerated]
private string _FolderPath;
[CompilerGenerated]
private int _ArtifactID;
[CompilerGenerated]
private int _ViewID;
[CompilerGenerated]
private bool _Overwrite;
[CompilerGenerated]
private char _RecordDelimiter;
[CompilerGenerated]
private char _QuoteDelimiter;
[CompilerGenerated]
private char _NewlineDelimiter;
[CompilerGenerated]
private char _MultiRecordDelimiter;
[CompilerGenerated]
private NetworkCredential _Credential;
[CompilerGenerated]
private CookieContainer _CookieContainer;
[CompilerGenerated]
private bool _ExportFullText;
[CompilerGenerated]
private bool _ExportFullTextAsFile;
[CompilerGenerated]
private bool _ExportNative;
[CompilerGenerated]
private bool _ExportPdf;
[CompilerGenerated]
private LoadFileType.FileFormat? _LogFileFormat;
[CompilerGenerated]
private bool _RenameFilesToIdentifier;
[CompilerGenerated]
private string _IdentifierColumnName;
[CompilerGenerated]
private string _LoadFileExtension;
[CompilerGenerated]
private VolumeInfo _VolumeInfo;
[CompilerGenerated]
private bool _ExportImages;
[CompilerGenerated]
private ExportNativeWithFilenameFrom _ExportNativesToFileNamedFrom;
[CompilerGenerated]
private string _FilePrefix;
[CompilerGenerated]
private ExportedFilePathType _TypeOfExportedFilePath;
[CompilerGenerated]
private ImageType? _TypeOfImage;
[CompilerGenerated]
private bool _AppendOriginalFileName;
[CompilerGenerated]
private bool _LoadFileIsHtml;
[CompilerGenerated]
private ViewFieldInfo[] _AllExportableFields;
[CompilerGenerated]
private ViewFieldInfo[] _SelectedViewFields;
[CompilerGenerated]
private bool _MulticodesAsNested;
[CompilerGenerated]
private ViewFieldInfo[] _SelectedTextFields;
[CompilerGenerated]
private Encoding _LoadFileEncoding;
[CompilerGenerated]
private Encoding _TextFileEncoding;
[CompilerGenerated]
private int _VolumeDigitPadding;
[CompilerGenerated]
private int _SubdirectoryDigitPadding;
[CompilerGenerated]
private DocumentField _FileField;
[CompilerGenerated]
private string _ObjectTypeName;
[CompilerGenerated]
private bool _UseCustomFileNaming;
[CompilerGenerated]
private CustomFileNameDescriptorModel _CustomFileNaming;
public int ArtifactTypeID => _artifactTypeId;
public string LoadFilesPrefix {
get {
return _loadFilesPrefix;
}
set {
_loadFilesPrefix = Utility.GetFilesystemSafeName(value);
}
}
public Pair[] ImagePrecedence { get; set; }
[ReadFromExisting]
public CaseInfo CaseInfo { get; set; }
public int CaseArtifactID => CaseInfo.ArtifactID;
[ReadFromExisting]
public DataTable DataTable { get; set; }
[ReadFromExisting]
public HybridDictionary ArtifactAvfLookup { get; set; }
public char NestedValueDelimiter { get; set; }
[ReadFromExisting]
public ExportType TypeOfExport { get; set; }
public string FolderPath { get; set; }
public int ArtifactID { get; set; }
public int ViewID { get; set; }
public bool Overwrite { get; set; }
public char RecordDelimiter { get; set; }
public char QuoteDelimiter { get; set; }
public char NewlineDelimiter { get; set; }
public char MultiRecordDelimiter { get; set; }
[ReadFromExisting]
public NetworkCredential Credential { get; set; }
[ReadFromExisting]
public CookieContainer CookieContainer { get; set; }
public bool ExportFullText { get; set; }
public bool ExportFullTextAsFile { get; set; }
public bool ExportNative { get; set; }
public bool ExportPdf { get; set; }
public LoadFileType.FileFormat? LogFileFormat { get; set; }
public bool RenameFilesToIdentifier { get; set; }
public string IdentifierColumnName { get; set; }
public string LoadFileExtension { get; set; }
public VolumeInfo VolumeInfo { get; set; }
public bool ExportImages { get; set; }
public ExportNativeWithFilenameFrom ExportNativesToFileNamedFrom { get; set; }
public string FilePrefix { get; set; }
public ExportedFilePathType TypeOfExportedFilePath { get; set; }
public ImageType? TypeOfImage { get; set; }
public bool AppendOriginalFileName { get; set; }
public bool LoadFileIsHtml { get; set; }
[ReadFromExisting]
public ViewFieldInfo[] AllExportableFields { get; set; }
public ViewFieldInfo[] SelectedViewFields { get; set; }
public bool MulticodesAsNested { get; set; }
public ViewFieldInfo[] SelectedTextFields { get; set; }
public Encoding LoadFileEncoding { get; set; }
public Encoding TextFileEncoding { get; set; }
public int VolumeDigitPadding { get; set; }
public int SubdirectoryDigitPadding { get; set; }
public int StartAtDocumentNumber {
get {
return _startAtDocument;
}
set {
_startAtDocument = value;
}
}
[ReadFromExisting]
public DocumentField FileField { get; set; }
public bool HasFileField => FileField != null;
public string ObjectTypeName { get; set; }
public bool UseCustomFileNaming { get; set; }
public CustomFileNameDescriptorModel CustomFileNaming { get; set; }
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("ArtifactID", ArtifactID, typeof(int));
info.AddValue("LoadFilesPrefix", HttpUtility.HtmlEncode(LoadFilesPrefix), typeof(string));
info.AddValue("NestedValueDelimiter", (int)NestedValueDelimiter, typeof(int));
info.AddValue("TypeOfExport", (int)TypeOfExport, typeof(int));
info.AddValue("FolderPath", FolderPath, typeof(string));
info.AddValue("ViewID", ViewID, typeof(int));
info.AddValue("Overwrite", Overwrite, typeof(bool));
info.AddValue("RecordDelimiter", (int)RecordDelimiter, typeof(int));
info.AddValue("QuoteDelimiter", (int)QuoteDelimiter, typeof(int));
info.AddValue("NewlineDelimiter", (int)NewlineDelimiter, typeof(int));
info.AddValue("MultiRecordDelimiter", (int)MultiRecordDelimiter, typeof(int));
info.AddValue("ExportFullText", ExportFullText, typeof(bool));
info.AddValue("ExportFullTextAsFile", ExportFullTextAsFile, typeof(bool));
info.AddValue("ExportNative", ExportNative, typeof(bool));
object value;
int value2;
if (!LogFileFormat.HasValue)
value = string.Empty;
else {
value2 = (int)LogFileFormat.Value;
value = value2.ToString();
}
info.AddValue("LogFileFormat", value, typeof(string));
info.AddValue("RenameFilesToIdentifier", RenameFilesToIdentifier, typeof(bool));
info.AddValue("IdentifierColumnName", IdentifierColumnName, typeof(string));
info.AddValue("LoadFileExtension", LoadFileExtension, typeof(string));
info.AddValue("ExportImages", ExportImages, typeof(bool));
info.AddValue("ExportNativesToFileNamedFrom", (int)ExportNativesToFileNamedFrom, typeof(int));
info.AddValue("FilePrefix", FilePrefix, typeof(string));
info.AddValue("TypeOfExportedFilePath", (int)TypeOfExportedFilePath, typeof(int));
object value3;
if (!TypeOfImage.HasValue)
value3 = string.Empty;
else {
value2 = (int)TypeOfImage.Value;
value3 = value2.ToString();
}
info.AddValue("TypeOfImage", value3, typeof(string));
info.AddValue("AppendOriginalFileName", AppendOriginalFileName, typeof(bool));
info.AddValue("LoadFileIsHtml", LoadFileIsHtml, typeof(bool));
info.AddValue("MulticodesAsNested", MulticodesAsNested, typeof(bool));
info.AddValue("LoadFileEncoding", (LoadFileEncoding == null) ? (-1) : LoadFileEncoding.CodePage, typeof(int));
info.AddValue("TextFileEncoding", (TextFileEncoding == null) ? (-1) : TextFileEncoding.CodePage, typeof(int));
info.AddValue("VolumeDigitPadding", VolumeDigitPadding, typeof(int));
info.AddValue("SubdirectoryDigitPadding", SubdirectoryDigitPadding, typeof(int));
info.AddValue("StartAtDocumentNumber", StartAtDocumentNumber, typeof(int));
info.AddValue("VolumeInfo", VolumeInfo, typeof(VolumeInfo));
info.AddValue("SelectedTextFields", SelectedTextFields, typeof(ViewFieldInfo[]));
info.AddValue("ImagePrecedence", ImagePrecedence, typeof(Pair[]));
info.AddValue("SelectedViewFields", SelectedViewFields, typeof(ViewFieldInfo[]));
info.AddValue("ObjectTypeName", ObjectTypeName, typeof(string));
info.AddValue("UseCustomFileNaming", UseCustomFileNaming, typeof(bool));
info.AddValue("CustomFileNaming", CustomFileNaming, typeof(CustomFileNameDescriptorModel));
info.AddValue("ExportPdf", ExportPdf, typeof(bool));
}
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
this.GetObjectData(info, context);
}
protected ExportFile(SerializationInfo info, StreamingContext context)
{
_startAtDocument = 0;
ExportNativesToFileNamedFrom = ExportNativeWithFilenameFrom.Identifier;
ArtifactID = info.GetInt32("ArtifactID");
LoadFilesPrefix = HttpUtility.HtmlDecode(info.GetString("LoadFilesPrefix"));
NestedValueDelimiter = Strings.ChrW(info.GetInt32("NestedValueDelimiter"));
TypeOfExport = (ExportType)info.GetInt32("TypeOfExport");
FolderPath = info.GetString("FolderPath");
ViewID = info.GetInt32("ViewID");
Overwrite = info.GetBoolean("Overwrite");
RecordDelimiter = Strings.ChrW(info.GetInt32("RecordDelimiter"));
QuoteDelimiter = Strings.ChrW(info.GetInt32("QuoteDelimiter"));
NewlineDelimiter = Strings.ChrW(info.GetInt32("NewlineDelimiter"));
MultiRecordDelimiter = Strings.ChrW(info.GetInt32("MultiRecordDelimiter"));
ExportFullText = info.GetBoolean("ExportFullText");
ExportFullTextAsFile = info.GetBoolean("ExportFullTextAsFile");
ExportNative = info.GetBoolean("ExportNative");
int? nullable = NullableTypesHelper.ToNullableInt32(info.GetString("LogFileFormat"));
LogFileFormat = null;
if (nullable.HasValue)
LogFileFormat = (LoadFileType.FileFormat)nullable.Value;
RenameFilesToIdentifier = info.GetBoolean("RenameFilesToIdentifier");
IdentifierColumnName = info.GetString("IdentifierColumnName");
LoadFileExtension = info.GetString("LoadFileExtension");
ExportImages = info.GetBoolean("ExportImages");
ExportNativesToFileNamedFrom = (ExportNativeWithFilenameFrom)info.GetInt32("ExportNativesToFileNamedFrom");
FilePrefix = info.GetString("FilePrefix");
TypeOfExportedFilePath = (ExportedFilePathType)info.GetInt32("TypeOfExportedFilePath");
int? nullable2 = NullableTypesHelper.ToNullableInt32(info.GetString("TypeOfImage"));
TypeOfImage = null;
if (nullable2.HasValue)
TypeOfImage = (ImageType)nullable2.Value;
AppendOriginalFileName = info.GetBoolean("AppendOriginalFileName");
LoadFileIsHtml = info.GetBoolean("LoadFileIsHtml");
MulticodesAsNested = info.GetBoolean("MulticodesAsNested");
int int = info.GetInt32("LoadFileEncoding");
LoadFileEncoding = ((int > 0) ? Encoding.GetEncoding(int) : null);
int = info.GetInt32("TextFileEncoding");
TextFileEncoding = ((int > 0) ? Encoding.GetEncoding(int) : null);
VolumeDigitPadding = info.GetInt32("VolumeDigitPadding");
SubdirectoryDigitPadding = info.GetInt32("SubdirectoryDigitPadding");
StartAtDocumentNumber = info.GetInt32("StartAtDocumentNumber");
VolumeInfo = (VolumeInfo)info.GetValue("VolumeInfo", typeof(VolumeInfo));
try {
SelectedTextFields = (ViewFieldInfo[])info.GetValue("SelectedTextFields", typeof(ViewFieldInfo[]));
} catch (Exception projectError) {
ProjectData.SetProjectError(projectError);
ViewFieldInfo viewFieldInfo = (ViewFieldInfo)info.GetValue("SelectedTextField", typeof(ViewFieldInfo));
SelectedTextFields = ((viewFieldInfo == null) ? null : new ViewFieldInfo[1] {
viewFieldInfo
});
ProjectData.ClearProjectError();
}
ImagePrecedence = (Pair[])info.GetValue("ImagePrecedence", typeof(Pair[]));
SelectedViewFields = (ViewFieldInfo[])info.GetValue("SelectedViewFields", typeof(ViewFieldInfo[]));
ObjectTypeName = info.GetString("ObjectTypeName");
try {
UseCustomFileNaming = info.GetBoolean("UseCustomFileNaming");
} catch (SerializationException ex) {
ProjectData.SetProjectError(ex);
SerializationException ex2 = ex;
UseCustomFileNaming = false;
ProjectData.ClearProjectError();
}
try {
CustomFileNaming = (CustomFileNameDescriptorModel)info.GetValue("CustomFileNaming", typeof(CustomFileNameDescriptorModel));
} catch (SerializationException ex3) {
ProjectData.SetProjectError(ex3);
SerializationException ex4 = ex3;
CustomFileNaming = null;
ProjectData.ClearProjectError();
}
try {
ExportPdf = info.GetBoolean("ExportPdf");
} catch (Exception projectError2) {
ProjectData.SetProjectError(projectError2);
ExportPdf = false;
ProjectData.ClearProjectError();
}
}
public ExportFile(int artifactTypeID)
{
_startAtDocument = 0;
ExportNativesToFileNamedFrom = ExportNativeWithFilenameFrom.Identifier;
RecordDelimiter = '';
QuoteDelimiter = 'þ';
NewlineDelimiter = '®';
MultiRecordDelimiter = ';';
NestedValueDelimiter = '\\';
MulticodesAsNested = true;
_artifactTypeId = artifactTypeID;
}
}
}