private CMISFolder determineFolder(SIEEFieldlist fieldlist)
{
CMISFolder folder = cmisClient.GetFolderFromId(selectedFolderId);
if (mySettings.UseSubFolderField)
{
// Get contents of subfolder field into pathExtension
List <SIEEField> match = fieldlist.Where(n => n.Name == mySettings.SubFolderField).ToList();
if (match.Count != 1)
{
throw (new Exception("No field " + mySettings.SubFolderField + " in data"));
}
string pathExtension = match.First().Value;
// Get sub folder type
string ftype = "cmis:folder";
if (mySettings.UseSubFolderType && mySettings.SubFolderTypeFixed)
{
ftype = mySettings.SubFolderType;
}
if (mySettings.UseSubFolderType && mySettings.SubFolderTypeFromField)
{
string newType = fieldlist.Where(n => n.ExternalId == mySettings.SubFolderTypeField).Select(n => n.Value).First();
if (newType != "")
{
ftype = newType;
}
}
// Get the folder
folder = cmisClient.GetSubfolder(folder, pathExtension, ftype);
}
return(folder);
}
public void T08_Password()
{
CMISViewModel vm = getInitializedViewModel();
// Test one: Direct Password set and get on the view model
string pw = "Hello World!";
vm.CT.Password = pw;
Assert.AreEqual(pw, vm.CT.Password);
string encryptedPW = vm.CMISSettings.Password;
Assert.AreNotEqual(pw, encryptedPW);
// Verify password in export
StoreDocumentResult expectedtResult = StoreDocumentResult.DefaultResult();
expectedtResult.Password = pw;
CMISClientMock cmisClient = new CMISClientMock();
CMISExport export = new CMISExport(cmisClient);
SIEEBatch batch = createBatch(expectedtResult.Filename, expectedtResult.DocName);
SIEEFieldlist fieldlist = batch[0].Fieldlist;
// Default document export
vm.LoadPropertiesHandler();
Assert.IsTrue(vm.TT.PropertiesLoaded);
Assert.AreEqual(6, vm.TT.Properties.Count);
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedtResult.Compare(cmisClient.SDR);
}
private void verifyField(string id, string value, SIEEFieldlist fl, List <SPOField> spofl)
{
Assert.AreEqual(
fl.Where(n => n.ExternalId == id).First().Value,
spofl.Where(n => n.InternalName == id).First().Value
);
}
// Add all selected properties to the schema and add the field named for subfolder and subfolder type
public override SIEEFieldlist CreateSchema()
{
SIEEFieldlist schema = new SIEEFieldlist();
foreach (CMISProperty p in Properties)
{
if (p.Selected)
{
schema.Add(new SIEEField()
{
Name = p.Id.Replace(':', '_'),
ExternalId = p.Id,
Cardinality = p.IsMulti ? -1 : 0,
});
}
}
if (UseSubFolderField && SubFolderTypeFixed)
{
schema.Add(new SIEEField()
{
Name = SubFolderField, ExternalId = SubFolderField
});
}
if (UseSubFolderField && SubFolderTypeFromField)
{
schema.Add(new SIEEField()
{
Name = SubFolderTypeField, ExternalId = SubFolderTypeField
});
}
return(schema);
}
public void SetFieldNames(SIEEFieldlist fieldList)
{
List <string> newFieldNames = fieldList.GetScalarFieldNames();
if (!SIEEUtils.StringListEqual(FieldNames, newFieldNames))
{
FieldNames = newFieldNames;
if (FieldNames.Count > 0)
{
SelectedFieldName = FieldNames[0];
}
}
}
public override SIEEFieldlist CreateSchema()
{
SIEEFieldlist schema = new SIEEFieldlist();
foreach (SPOField f in Fields)
{
if (f.Use)
{
schema.Add(new SIEEField {
Name = f.Title, ExternalId = f.InternalName
});
}
}
return(schema);
}
public override SIEEFieldlist CreateSchema()
{
SIEEFieldlist schema = new SIEEFieldlist();
foreach (ColumnDescription col in Columns)
{
if (col.Use && !(col.SqlTypeName == null || col.IsDocument))
{
schema.Add(new SIEEField {
Name = col.Name, ExternalId = col.Name
});
}
}
return(schema);
}
private SIEEBatch createBatch(string filename, string docName)
{
SIEEField field = new SIEEField()
{
Name = "SomeField", ExternalId = "SomeField", Value = "SomeValue"
};
SIEEFieldlist fieldlist = new SIEEFieldlist();
fieldlist.Add(field);
SIEEDocument document = new SIEEDocument();
document.PDFFileName = filename;
document.InputFileName = docName;
document.BatchId = "4711";
document.DocumentId = "0";
document.Fieldlist = fieldlist;
SIEEBatch batch = new SIEEBatch();
batch.Add(document);
return(batch);
}
public void t04_Export()
{
SPOViewModel vm = createViewModel();
vm.LT.SelectedList = new SPOList()
{
Title = "SomeList"
};
vm.LoadFieldsButtonHandler();
SIEEFieldlist schema = vm.Settings.CreateSchema();
Assert.AreEqual(2, schema.Count);
schema.Where(n => n.ExternalId == "Id1").First().Value = "myTitle";
schema.Where(n => n.ExternalId == "Id3").First().Value = "true";
schema.Add(new SIEEField()
{
Name = "SomeName", ExternalId = "xx", Value = "SomeValue"
});
SPOClientMock spoClient = new SPOClientMock();
SPOExport export = new SPOExport(spoClient);
export.Init(vm.Settings);
SIEEDocument document = new SIEEDocument()
{
PDFFileName = "file.pdf"
};
export.ExportDocument(vm.Settings, document, "sub/Document", schema);
Assert.AreEqual("SomeList", spoClient.LastExportResult.ListTitle);
Assert.AreEqual("sub/Document.pdf", spoClient.LastExportResult.DocumentPath);
Assert.AreEqual("file.pdf", spoClient.LastExportResult.FilePath);
verifyField("Id1", "myTitle", schema, spoClient.LastExportResult.Fields);
verifyField("Id3", "true", schema, spoClient.LastExportResult.Fields);
}
public void T04_TypesTab()
{
CMISViewModel vm = getInitializedViewModel();
StoreDocumentResult expectedResult = StoreDocumentResult.DefaultResult();
// Default setting
Assert.AreEqual(0, vm.TT.Properties.Count);
// Select, deselect all
vm.LoadPropertiesHandler();
Assert.IsNull(SIEEMessageBox.LastMessage);
Assert.AreEqual(6, vm.TT.Properties.Count);
foreach (CMISProperty p in vm.TT.Properties)
{
Assert.IsFalse(p.Selected);
}
vm.TT.SelectAllHandler();
foreach (CMISProperty p in vm.TT.Properties)
{
Assert.IsTrue(p.Selected);
}
vm.TT.DeselectAllHandler();
foreach (CMISProperty p in vm.TT.Properties)
{
Assert.IsFalse(p.Selected);
}
// Create schema
SIEEFieldlist fl = vm.Settings.CreateSchema();
Assert.AreEqual(0, fl.Count);
vm.TT.Properties[0].Selected = true;
fl = vm.Settings.CreateSchema();
Assert.AreEqual(1, fl.Count);
Assert.AreEqual(vm.TT.Properties[0].Id, fl[0].Name);
}
public void T03_FolderTab()
{
CMISViewModel vm = getInitializedViewModel();
StoreDocumentResult expectedResult = StoreDocumentResult.DefaultResult();
CMISClientMock cmisClient = new CMISClientMock();
CMISExport export = new CMISExport(cmisClient);
// Default values
Assert.AreEqual("/" + cmisClient.GetRootFolder().DisplayName, vm.FT.SelectedFolderPath);
Assert.IsFalse(vm.FT.UseSubFolderField);
Assert.AreEqual("FolderField", vm.FT.SubFolderField);
Assert.IsFalse(vm.FT.UseSubFolderType);
Assert.IsTrue(vm.FT.SubFolderTypeFixed);
Assert.AreEqual("cmis:folder", vm.FT.SubFolderType);
Assert.IsFalse(vm.FT.SubFolderTypeFromField);
Assert.AreEqual("FolderTypeField", vm.FT.SubFolderTypeField);
Assert.AreEqual(CMISSettings.ConflictHandling.None, vm.FT.SelectedConflictHandling);
Assert.AreEqual(4, vm.FT.NumberOfDigits);
Assert.AreEqual("Collapsed", vm.FT.NumberOfDigitsVisible);
Assert.IsTrue(vm.FT.Major);
Assert.AreEqual("Collapsed", vm.FT.VersioningVisible);
// Visibility checks and logic
vm.FT.SubFolderTypeFromField = true;
Assert.IsFalse(vm.FT.SubFolderTypeFixed);
vm.FT.SubFolderTypeFixed = true;
Assert.IsFalse(vm.FT.SubFolderTypeFromField);
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.Replace;
Assert.AreEqual("Collapsed", vm.FT.NumberOfDigitsVisible);
Assert.AreEqual("Collapsed", vm.FT.VersioningVisible);
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.AddBlurb;
Assert.AreEqual("Collapsed", vm.FT.NumberOfDigitsVisible);
Assert.AreEqual("Collapsed", vm.FT.VersioningVisible);
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.AddNumber;
Assert.AreEqual("Visible", vm.FT.NumberOfDigitsVisible);
Assert.AreEqual("Collapsed", vm.FT.VersioningVisible);
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.AddVersion;
Assert.AreEqual("Collapsed", vm.FT.NumberOfDigitsVisible);
Assert.AreEqual("Visible", vm.FT.VersioningVisible);
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.None;
// Default document export
SIEEBatch batch = createBatch(expectedResult.Filename, expectedResult.DocName);
SIEEFieldlist fieldlist = batch[0].Fieldlist;
vm.LoadPropertiesHandler();
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.Compare(cmisClient.SDR);
// SubFolderField
vm.FT.UseSubFolderField = true;
fieldlist.Add(new SIEEField()
{
Name = "FolderField", Value = "subFolder", ExternalId = "FolderField"
});
expectedResult.FinalFolder += "/subFolder";
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.UsedFolderType = vm.FT.SubFolderType; // Default is what export implements
expectedResult.Compare(cmisClient.SDR);
// SubFolderType
vm.FT.UseSubFolderType = true;
vm.FT.SubFolderType = "cmis:myFolderType";
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.UsedFolderType = "cmis:myFolderType";
expectedResult.Compare(cmisClient.SDR);
// SubFolderFieldType
vm.FT.SubFolderTypeFromField = true;
fieldlist.Add(new SIEEField()
{
Name = vm.FT.SubFolderTypeField,
Value = "cmis:anotherFolderType",
ExternalId = vm.FT.SubFolderTypeField,
});
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch);
expectedResult.UsedFolderType = "cmis:anotherFolderType";
expectedResult.Compare(cmisClient.SDR);
// Conflict Handling : Replace
cmisClient.ExistingDocument = expectedResult.DocName + ".pdf";
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.Replace;
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.Compare(cmisClient.SDR);
// Conflict Handling : None
cmisClient.ExistingDocument = expectedResult.DocName + ".pdf";
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.None;
export.ExportBatch(vm.Settings, batch);
expectedResult.OverwrittenExistingDocument = true;
expectedResult.Compare(cmisClient.SDR);
expectedResult.OverwrittenExistingDocument = false;
cmisClient.SDR.OverwrittenExistingDocument = false;
// Conflict Handling : AddBlurb
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.AddBlurb;
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.ExpectBlurb = true;
expectedResult.Compare(cmisClient.SDR);
expectedResult.ExpectBlurb = false;
// Conflict Handling : AddNumber
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.AddNumber;
vm.FT.NumberOfDigits = 2;
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
string save = expectedResult.DocName;
expectedResult.DocName += "_01";
expectedResult.Compare(cmisClient.SDR);
expectedResult.DocName = save;
// Conflict Handling : AddVersion
vm.FT.SelectedConflictHandling = CMISSettings.ConflictHandling.AddVersion;
vm.FT.Major = true;
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.Updated = true;
expectedResult.Major = true;
expectedResult.CheckInComment = "OCC created version";
expectedResult.Compare(cmisClient.SDR);
vm.FT.Major = false;
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedResult.Major = false;
expectedResult.Compare(cmisClient.SDR);
}
public void T02_BasicExport()
{
CMISViewModel vm = getInitializedViewModel();
vm.CMISSettings.SelectedCultureInfoName = "en-US";
StoreDocumentResult expectedtResult = StoreDocumentResult.DefaultResult();
CMISClientMock cmisClient = new CMISClientMock();
CMISExport export = new CMISExport(cmisClient);
SIEEBatch batch = createBatch(expectedtResult.Filename, expectedtResult.DocName);
SIEEFieldlist fieldlist = batch[0].Fieldlist;
// Default document export
vm.LoadPropertiesHandler();
Assert.IsTrue(vm.TT.PropertiesLoaded);
Assert.AreEqual(6, vm.TT.Properties.Count);
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedtResult.Compare(cmisClient.SDR);
foreach (CMISProperty p in vm.TT.Properties)
{
p.Selected = true;
object objectValue;
string stringValue;
switch (p.Type)
{
case CMISClientType.Boolean:
stringValue = "true";
objectValue = true;
break;
case CMISClientType.Integer:
stringValue = "4711";
objectValue = 4711;
break;
case CMISClientType.Decimal:
stringValue = "1.8";
objectValue = 1.8M;
break;
case CMISClientType.DateTime:
stringValue = "11.03.2017";
objectValue = DateTime.Parse(stringValue, new CultureInfo("en-US"));
break;
default: objectValue = stringValue = "Some string"; break;
}
fieldlist.Add(new SIEEField(p.Id, p.Id, stringValue));
expectedtResult.Properties[p.Id] = objectValue;
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedtResult.Compare(cmisClient.SDR);
if (p.Type != CMISClientType.String)
{
fieldlist.Where(n => n.ExternalId == p.Id).First().Value = "Illegal value";
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsFalse(batch[0].Succeeded);
}
expectedtResult.Compare(cmisClient.SDR);
fieldlist.Remove(fieldlist.Where(n => n.ExternalId == p.Id).First());
expectedtResult.Properties.Remove(p.Id);
}
CMISProperty pror = vm.TT.Properties.Where(n => n.Type == CMISClientType.Decimal).First();
pror.Selected = true;
fieldlist.Add(new SIEEField(pror.Id, pror.Id, "1,8"));
expectedtResult.Properties[pror.Id] = 1.8M;
vm.CMISSettings.SelectedCultureInfoName = "de-DE";
export.Init(vm.Settings);
export.ExportBatch(vm.Settings, batch); Assert.IsTrue(batch[0].Succeeded);
expectedtResult.Compare(cmisClient.SDR);
}
public override void ExportDocument(SIEESettings settings, SIEEDocument document, string targetFileName, SIEEFieldlist fieldlist)
{
List <SPOField> fields = new List <SPOField>();
foreach (SIEEField f in fieldlist)
{
SPOField spof = mySettings.Fields.Where(n => n.InternalName == f.ExternalId).FirstOrDefault();
if (spof != null)
{
spof.Value = f.Value;
fields.Add(spof);
}
}
int itemId = spoClient.AddDocument(
mySettings.SelectedList,
getRelativePath(document) + targetFileName + ".pdf",
document.PDFFileName,
fields);
document.TargetDocumentId = itemId.ToString();
}
public override void ExportDocument(SIEESettings settings, SIEEDocument document, string name, SIEEFieldlist fieldlist)
{
CMISFolder folder = determineFolder(fieldlist);
string docName = name;
// Collision detection and handling (except for version handling)
CMISDocument existingDocument = cmisClient.GetDocument(folder, docName + pdfExtension);
if (existingDocument != null)
{
switch (mySettings.SelectedConflictHandling)
{
case CMISSettings.ConflictHandling.Replace:
{ cmisClient.DeleteDocument(existingDocument); break; }
case CMISSettings.ConflictHandling.AddBlurb:
{ docName = getDocumentNameWithBlurb(docName); break; }
case CMISSettings.ConflictHandling.AddNumber:
{ docName = getDocumentNameWithNumber(docName, folder); break; }
default: break;
}
}
// Create property list
string checkInComment = "OCC created version";
Dictionary <string, object> props = new Dictionary <string, object>();
props["cmis:objectTypeId"] = selectedTypeId;
foreach (SIEEField f in fieldlist)
{
if (f.ExternalId == "cmis:checkinComment")
{
checkInComment = f.Value; continue;
}
if (mySettings.UseSubFolderField &&
mySettings.SubFolderTypeFixed &&
f.ExternalId == mySettings.SubFolderField)
{
continue;
}
if (mySettings.UseSubFolderField &&
mySettings.SubFolderTypeFromField &&
f.ExternalId == mySettings.SubFolderTypeField)
{
continue;
}
try { props[f.ExternalId] = convert(mySettings, f); }
catch (Exception e) { throw new Exception(
"Error converting value for field '" + f.ExternalId + "' Value = '" + f.Value +
"' \nReason: " + e.Message
); }
}
try
{
string dn = docName + pdfExtension;
if (cmisClient.GetDocument(folder, docName + pdfExtension) == null || !versionHandling())
{
bool?v = null;
if (versionHandling())
{
v = mySettings.Major;
}
cmisClient.StoreDocument(folder, document.PDFFileName, dn, props, v);
}
else
{
cmisClient.UpdateDocument(folder, document.PDFFileName, dn, props, mySettings.Major, checkInComment);
}
}
catch (Exception e) { trace.WriteError(e.Message); throw; }
document.TargetDocumentId = folder + ":" + document.PDFFileName;
}
// Simulate some exports and verify the final location
public void t05_SubfolderHandling()
{
SPOViewModel vm = createViewModel();
// Create schema based on mocked SPOList
vm.LT.SelectedList = new SPOList()
{
Title = "SomeList"
};
vm.LoadFieldsButtonHandler();
SIEEFieldlist schema = vm.Settings.CreateSchema();
Assert.AreEqual(2, schema.Count);
schema.Where(n => n.ExternalId == "Id1").First().Value = "myTitle";
schema.Where(n => n.ExternalId == "Id3").First().Value = "true";
schema.Add(new SIEEField()
{
Name = "SomeName", ExternalId = "xx", Value = "SomeValue"
});
SIEEDocument document = new SIEEDocument()
{
PDFFileName = "file.pdf"
};
SPOClientMock spoClient = vm.SPOClient as SPOClientMock; // was: new SPOClientMock();
SPOExport export = new SPOExport(spoClient);
string documentName = "abc/document";
var td = new[]
{
new {
n = 0, folderType = SPOSettings.FolderHandlingType.None,
folder = string.Empty, auxField = false, expError = false,
fieldContent = string.Empty,
result = documentName,
},
new {
n = 1, folderType = SPOSettings.FolderHandlingType.Folder,
folder = "sub/subsub", auxField = false, expError = false,
fieldContent = string.Empty,
result = "sub/subsub/" + documentName,
},
new {
n = 2, folderType = SPOSettings.FolderHandlingType.Folder,
folder = "/sub/subsub/", auxField = false, expError = false,
fieldContent = string.Empty,
result = "sub/subsub/" + documentName,
},
new {
n = 3, folderType = SPOSettings.FolderHandlingType.Folder,
folder = "/", auxField = false, expError = false,
fieldContent = string.Empty,
result = documentName,
},
new {
n = 4, folderType = SPOSettings.FolderHandlingType.Field,
folder = string.Empty, auxField = false, expError = false,
fieldContent = "sub/subsub",
result = "sub/subsub/" + documentName,
},
new {
n = 5, folderType = SPOSettings.FolderHandlingType.Field,
folder = string.Empty, auxField = false, expError = false,
fieldContent = "/sub/subsub/",
result = "sub/subsub/" + documentName,
},
new {
n = 6, folderType = SPOSettings.FolderHandlingType.Field,
folder = string.Empty, auxField = false, expError = false,
fieldContent = "/",
result = documentName,
},
new {
n = 7, folderType = SPOSettings.FolderHandlingType.Field,
folder = string.Empty, auxField = true, expError = false,
fieldContent = "/sub/subsub/",
result = "sub/subsub/" + documentName,
},
new {
n = 8, folderType = SPOSettings.FolderHandlingType.Field,
folder = string.Empty, auxField = true, expError = true,
fieldContent = "/sub/subsub/",
result = "sub/subsub/" + documentName,
},
};
int doOnly = -1;
for (int i = 0; i != td.Length; i++)
{
if (doOnly > 0 && td[i].n != doOnly)
{
continue;
}
vm.FT.FolderHandling = SPOSettings.FolderHandlingType.None;
vm.FT.FolderName = td[i].folder;
vm.FT.FieldName = string.Empty;
document.AuxFields = new SIEEFieldlist();
if (td[i].folderType == SPOSettings.FolderHandlingType.Field)
{
if (td[i].auxField == false)
{
vm.FT.FieldName = "SomeName";
schema.Where(n => n.Name == "SomeName").First().Value = td[i].fieldContent;
}
else
{
vm.FT.FieldName = "auxField" + (td[i].expError ? "-err" : "");
document.AuxFields.Add(new SIEEField("auxField", "", td[i].fieldContent));
}
}
vm.FT.FolderHandling = td[i].folderType;
document.Fieldlist = schema;
export.Init(vm.Settings);
bool exception = false;
try
{
export.ExportDocument(vm.Settings, document, documentName, schema);
} catch { exception = true; }
if (td[i].expError)
{
Assert.IsTrue(exception);
}
else
{
Assert.IsFalse(exception);
Assert.AreEqual(td[i].result + ".pdf", spoClient.LastExportResult.DocumentPath);
}
}
Assert.IsTrue(doOnly < 0, "Not all tests executed");
}
public override void ExportDocument(SIEESettings settings, SIEEDocument document, string name, SIEEFieldlist fieldlist)
{
List <SqlColumn> columns = new List <SqlColumn>();
foreach (ColumnDescription colDes in mySettings.Columns.Where(n => n.SqlTypeName != null))
{
SqlColumn col = new SqlColumn()
{
Name = colDes.Name,
SqlType = SqlTypes.GetSqlType(colDes.SqlTypeName),
IsDocument = colDes.IsDocument,
};
if (colDes.IsDocument)
{
col.ValueString = document.PDFFileName;
}
else
{
SIEEField f = fieldlist.Where(n => n.ExternalId == colDes.Name).FirstOrDefault();
col.ValueString = f == null ? null : f.Value;
}
columns.Add(col);
}
try { sqlClient.SetObjectValues(columns); }
catch (Exception e)
{
document.NonRecoverableError = true;
throw e;
}
sqlClient.Insert(columns);
}
public bool ActivateTab(SIEEFieldlist fieldlist)
{
SetFieldNames(fieldlist);
return(false);
}
