public void Equals_should_return_false_if_value_is_no_identical_on_instance_being_compared_against()
{
var instance =
new MetadataItem("Foo", new object());
var results =
instance.Equals(new MetadataItem("Foo", string.Empty));
results.ShouldBeFalse();
}
private static void AddChildren(MetadataItem model, PageViewModel result)
{
if (model.Items != null && model.Items.Count > 0)
{
foreach (var item in model.Items)
{
result.Items.Add(ItemViewModel.FromModel(item));
AddChildren(item, result);
}
}
}
public void AddMetadata_should_add_metadata_to_convention()
{
this.conventionBuilder
.AddMetadata("Foo", "Bar");
var convention =
this.conventionBuilder.GetBuiltInstance();
var expectedMetadata =
new MetadataItem("Foo", "Bar");
convention.Metadata.First().Equals(expectedMetadata).ShouldBeTrue();
}
public void AddMetadata_should_set_metadata_on_convention_from_anonymous_type()
{
this.conventionBuilder
.AddMetadata(new {Foo = "Bar"});
var convention =
this.conventionBuilder.GetBuiltInstance();
var expectedMetadata =
new MetadataItem("Foo", "Bar");
convention.Metadata.First().Equals(expectedMetadata).ShouldBeTrue();
}
private static ParseResult TryExportYamlMetadataFile(MetadataItem doc, string folder, UriKind uriKind, out string filePath)
{
filePath = Path.Combine(folder, doc.Name).FormatPath(uriKind, folder);
try
{
using (StreamWriter writer = new StreamWriter(filePath))
{
YamlUtility.Serialize(writer, doc);
return(new ParseResult(ResultLevel.Success, "Successfully generated metadata {0} for {1}", filePath, doc.Name));
}
}
catch (Exception e)
{
return(new ParseResult(ResultLevel.Error, e.Message));
}
}
private MetadataItem createMetadataItem()
{
MetadataItem meta = new MetadataItem();
meta.Benutzer = _benutzer;
meta.Bezeichnung = _bezeichnung;
meta.Erfassungsdatum = _erfassungsdatum;
meta.Extension = _extension;
meta.Filename = _filename;
meta.OriginalPath = _filePath;
meta.SelectedTypItem = _selectedTypItem;
meta.ValutaDatum = _valutaDatum;
var temp = _valutaDatum.GetValueOrDefault();
meta.ValutaYear = temp.Year.ToString();
return(meta);
}
/// <summary>
/// Syncs the collections on a bound PSCloudJobSchedule with its wrapped OM object
/// </summary>
internal static void BoundJobScheduleSyncCollections(PSCloudJobSchedule jobSchedule)
{
if (jobSchedule != null)
{
jobSchedule.omObject.Metadata = CreateSyncedList(jobSchedule.Metadata,
(m) =>
{
MetadataItem metadata = new MetadataItem(m.Name, m.Value);
return(metadata);
});
if (jobSchedule.JobSpecification != null)
{
JobSpecificationSyncCollections(jobSchedule.JobSpecification);
}
}
}
public void CloudJobSchedule_WhenReturnedFromServer_HasExpectedBoundProperties()
{
const string jobScheduleId = "id-123";
const string displayName = "DisplayNameFoo";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
DateTime creationTime = DateTime.Now;
var cloudJobSchedule = new Models.CloudJobSchedule
{
Id = jobScheduleId,
DisplayName = displayName,
Metadata = new[]
{
new Models.MetadataItem {
Name = metadataItem.Name, Value = metadataItem.Value
}
},
CreationTime = creationTime,
JobSpecification = new Models.JobSpecification
{
OnAllTasksComplete = Models.OnAllTasksComplete.TerminateJob,
OnTaskFailure = Models.OnTaskFailure.PerformExitOptionsJobAction
}
};
CloudJobSchedule boundJobSchedule = client.JobScheduleOperations.GetJobSchedule(
jobScheduleId,
additionalBehaviors: InterceptorFactory.CreateGetJobScheduleRequestInterceptor(cloudJobSchedule));
Assert.Equal(jobScheduleId, boundJobSchedule.Id); // reading is allowed from a jobSchedule that is returned from the server.
Assert.Equal(creationTime, boundJobSchedule.CreationTime);
Assert.Equal(displayName, boundJobSchedule.DisplayName);
Assert.Equal(OnAllTasksComplete.TerminateJob, boundJobSchedule.JobSpecification.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.PerformExitOptionsJobAction, boundJobSchedule.JobSpecification.OnTaskFailure);
Assert.Throws <InvalidOperationException>(() => boundJobSchedule.DisplayName = "cannot-change-display-name");
Assert.Throws <InvalidOperationException>(() => boundJobSchedule.Id = "cannot-change-id");
boundJobSchedule.JobSpecification.OnAllTasksComplete = OnAllTasksComplete.TerminateJob;
boundJobSchedule.JobSpecification.OnTaskFailure = OnTaskFailure.NoAction;
Assert.Equal(OnAllTasksComplete.TerminateJob, boundJobSchedule.JobSpecification.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.NoAction, boundJobSchedule.JobSpecification.OnTaskFailure);
}
public void CloudJobSchedule_WhenSendingToTheServer_HasExpectedUnboundProperties()
{
const string jobScheduleId = "id-123";
const string displayName = "DisplayNameFoo";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
using BatchClient client = ClientUnitTestCommon.CreateDummyClient();
CloudJobSchedule jobSchedule = client.JobScheduleOperations.CreateJobSchedule();
jobSchedule.Id = jobScheduleId;
jobSchedule.DisplayName = displayName;
jobSchedule.Metadata = new List <MetadataItem> {
metadataItem
};
jobSchedule.JobSpecification = new JobSpecification
{
OnAllTasksComplete = OnAllTasksComplete.TerminateJob,
OnTaskFailure = OnTaskFailure.PerformExitOptionsJobAction
};
Assert.Equal(jobSchedule.Id, jobScheduleId); // can set an unbound object
Assert.Equal(jobSchedule.Metadata.First().Name, metadataItem.Name);
Assert.Equal(jobSchedule.Metadata.First().Value, metadataItem.Value);
Assert.Equal(OnAllTasksComplete.TerminateJob, jobSchedule.JobSpecification.OnAllTasksComplete);
Assert.Equal(OnTaskFailure.PerformExitOptionsJobAction, jobSchedule.JobSpecification.OnTaskFailure);
jobSchedule.Commit(additionalBehaviors: InterceptorFactory.CreateAddJobScheduleRequestInterceptor());
// writing isn't allowed for a jobSchedule that is in an read only state.
Assert.Throws <InvalidOperationException>(() => jobSchedule.Id = "cannot-change-id");
Assert.Throws <InvalidOperationException>(() => jobSchedule.DisplayName = "cannot-change-display-name");
//Can still read though
Assert.Equal(jobScheduleId, jobSchedule.Id);
Assert.Equal(displayName, jobSchedule.DisplayName);
jobSchedule.Refresh(additionalBehaviors:
InterceptorFactory.CreateGetJobScheduleRequestInterceptor(
new Models.CloudJobSchedule()
{
JobSpecification = new Models.JobSpecification()
}));
jobSchedule.JobSpecification.OnAllTasksComplete = OnAllTasksComplete.NoAction;
jobSchedule.JobSpecification.OnTaskFailure = OnTaskFailure.NoAction;
}
protected override DataTemplate OnSelectTemplate(object item, BindableObject container)
{
MetadataItem annotation = (MetadataItem)item;
bool isValueJson = true;
try
{
JObject.Parse(annotation.Value);
}
catch (JsonReaderException)
{
isValueJson = false;
}
return(isValueJson ? this.Popup : this.Basic);
}
public async Task <IEnumerable <MetadataItem> > RetreiveMetadata(string addToQueueMessage)
{
var result = await _metadataProviderFactory.GetProvider().GetMetadata();
var metadataItems = new List <MetadataItem>();
foreach (var comicItem in result)
{
var item = new MetadataItem()
{
emailTo = addToQueueMessage, comicItem = comicItem
};
metadataItems.Add(item);
}
return(metadataItems);
}
public void MetadataItemConstructor_SetsPropertiesCorrectly()
{
// Act
var metadataItem = new MetadataItem(id: 1,
movieId: 2,
title: "Test",
language: "AnotherTest",
duration: TimeSpan.Parse("10:10:10"),
releaseYear: 2019);
// Assert
Assert.AreEqual(metadataItem.Id, 1);
Assert.AreEqual(metadataItem.MovieId, 2);
Assert.AreEqual(metadataItem.Title, "Test");
Assert.AreEqual(metadataItem.Duration, TimeSpan.Parse("10:10:10"));
Assert.AreEqual(metadataItem.ReleaseYear, 2019);
}
public bool SaveXml(string destPath, string guid, IGetFileName getName, IMessage mb, ISerializer ser)
{
if (!IsFileSelected())
{
mb.ShowMessage("Keine Datei ausgewählt!");
return(false);
}
if (AreRequiredFieldsValid())
{
var newItem = new MetadataItem(guid, Bezeichnung, (DateTime)ValutaDatum, SelectedTypItem, Stichwoerter, Erfassungsdatum, Benutzer);
var fileName = getName.GetMetadataName(destPath, guid);
ser.SerializeFile(newItem, fileName);
return(true);
}
mb.ShowMessage("Es müssen alle Pflichtfelder ausgefüllt werden!");
return(false);
}
} // createQueryBuilder(...)
//
internal void buildBindingList(bool loadDefaultDatabaseOnly, bool loadSystemObjects, bool withFields)
{
this._colQnBindingList = new BindingList <ColumnQN>();
using (SQLContext sqlContext = new SQLContext())
{
sqlContext.Assign(this._qb.SQLContext);
sqlContext.MetadataContainer.LoadingOptions.LoadDefaultDatabaseOnly = loadDefaultDatabaseOnly;
sqlContext.MetadataContainer.LoadingOptions.LoadSystemObjects = loadSystemObjects;
using (MetadataList xList = new MetadataList(sqlContext.MetadataContainer))
{
xList.Load(MetadataType.Server, false);
foreach (MetadataItem srv in xList)
{
}
xList.Load(MetadataType.Database, false);
foreach (MetadataItem db in xList)
{
using (MetadataList schemasList = new MetadataList(db))
{
schemasList.Load(MetadataType.Schema, false);
foreach (MetadataItem sch in schemasList)
{
using (MetadataList tablesList = new MetadataList(sch))
{
tablesList.Load(MetadataType.Table, false);
foreach (MetadataItem tbl in tablesList)
{
using (MetadataList columnsList = new MetadataList(tbl))
{
columnsList.Load(MetadataType.Field, false);
foreach (MetadataItem col in columnsList)
{
MetadataItem mdi = col;
this.TreatField(mdi);
}
}
}
}
}
}
}
}
}
} // buildBindingList(...)
/// <summary>
/// Syncs the collections on a bound PSCloudJob with its wrapped OM object
/// </summary>
internal static void BoundJobSyncCollections(PSCloudJob job)
{
if (job != null)
{
job.omObject.Metadata = CreateSyncedList(job.Metadata,
(m) =>
{
MetadataItem metadata = new MetadataItem(m.Name, m.Value);
return(metadata);
});
if (job.PoolInformation != null)
{
PoolInformationSyncCollections(job.PoolInformation);
}
}
}
public void CreateXml_IsFileCreated_FileExists()
{
// arrange
var exportService = new ExportService();
var TestItem = new MetadataItem(Guid.Parse("3fc6a223-369b-4efd-a0c4-f563ee6d67f8"), "Username",
"Dokumenten Bezeichnung", DateTime.Parse("01.01.2020 19:00:00"), "Verträge", "Notiz",
DateTime.Parse("30.06.2020 00:00:00"), "document.docx");
// act
var result = exportService.CreateXml(TestItem);
var IsFileExist =
File.Exists(
"C:\\Temp\\UnitTestingOfPhilipp\\Repository\\2020\\3fc6a223-369b-4efd-a0c4-f563ee6d67f8_Metadata.xml");
// assert
Assert.That(IsFileExist, Is.EqualTo(true));
}
public void Pool_WhenReturnedFromServer_HasExpectedUnboundProperties()
{
const string cloudPoolId = "id-123";
const string osFamily = "2";
const string virtualMachineSize = "4";
const string cloudPoolDisplayName = "pool-display-name-test";
MetadataItem metadataItem = new MetadataItem("foo", "bar");
BatchSharedKeyCredentials credentials = ClientUnitTestCommon.CreateDummySharedKeyCredential();
using (BatchClient client = BatchClient.Open(credentials))
{
CloudPool cloudPool = client.PoolOperations.CreatePool(cloudPoolId, virtualMachineSize, new CloudServiceConfiguration(osFamily));
cloudPool.DisplayName = cloudPoolDisplayName;
cloudPool.Metadata = new List <MetadataItem> {
metadataItem
};
Assert.Equal(cloudPoolId, cloudPool.Id); // can set an unbound object
Assert.Equal(cloudPool.Metadata.First().Name, metadataItem.Name);
Assert.Equal(cloudPool.Metadata.First().Value, metadataItem.Value);
cloudPool.Commit(additionalBehaviors: InterceptorFactory.CreateAddPoolRequestInterceptor());
// writing isn't allowed for a cloudPool that is in an readonly state.
Assert.Throws <InvalidOperationException>(() => cloudPool.AutoScaleFormula = "Foo");
Assert.Throws <InvalidOperationException>(() => cloudPool.DisplayName = "Foo");
Assert.Throws <InvalidOperationException>(() => cloudPool.CloudServiceConfiguration = null);
Assert.Throws <InvalidOperationException>(() => cloudPool.ResizeTimeout = TimeSpan.FromSeconds(10));
Assert.Throws <InvalidOperationException>(() => cloudPool.Metadata = null);
Assert.Throws <InvalidOperationException>(() => cloudPool.TargetDedicated = 5);
Assert.Throws <InvalidOperationException>(() => cloudPool.VirtualMachineConfiguration = null);
Assert.Throws <InvalidOperationException>(() => cloudPool.VirtualMachineSize = "small");
//read is allowed though
Assert.Null(cloudPool.AutoScaleFormula);
Assert.Equal(cloudPoolDisplayName, cloudPool.DisplayName);
Assert.NotNull(cloudPool.CloudServiceConfiguration);
Assert.Null(cloudPool.ResizeTimeout);
Assert.Equal(1, cloudPool.Metadata.Count);
Assert.Null(cloudPool.TargetDedicated);
Assert.Null(cloudPool.VirtualMachineConfiguration);
Assert.Equal(virtualMachineSize, cloudPool.VirtualMachineSize);
}
}
/// <summary>
/// Creates a new WorkItem
/// </summary>
/// <param name="parameters">The parameters to use when creating the WorkItem</param>
public void CreateWorkItem(NewWorkItemParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (string.IsNullOrWhiteSpace(parameters.WorkItemName))
{
throw new ArgumentNullException("WorkItemName");
}
using (IWorkItemManager wiManager = parameters.Context.BatchOMClient.OpenWorkItemManager())
{
ICloudWorkItem workItem = wiManager.CreateWorkItem(parameters.WorkItemName);
if (parameters.Schedule != null)
{
workItem.Schedule = parameters.Schedule.omObject;
}
if (parameters.JobSpecification != null)
{
Utils.Utils.JobSpecificationSyncCollections(parameters.JobSpecification);
workItem.JobSpecification = parameters.JobSpecification.omObject;
}
if (parameters.JobExecutionEnvironment != null)
{
Utils.Utils.JobExecutionEnvironmentSyncCollections(parameters.JobExecutionEnvironment);
workItem.JobExecutionEnvironment = parameters.JobExecutionEnvironment.omObject;
}
if (parameters.Metadata != null)
{
workItem.Metadata = new List <IMetadataItem>();
foreach (DictionaryEntry d in parameters.Metadata)
{
MetadataItem metadata = new MetadataItem(d.Key.ToString(), d.Value.ToString());
workItem.Metadata.Add(metadata);
}
}
WriteVerbose(string.Format(Resources.NBWI_CreatingWorkItem, parameters.WorkItemName));
workItem.Commit(parameters.AdditionalBehaviors);
}
}
public void MetadataItem_FilePath_GetSetTestingText()
{
// Arrange
var metadataItem = new MetadataItem(_testDateTime, TestType)
{
FilePath = TestFilePath
};
// Act
var filePath = metadataItem.FilePath;
var valutaDate = metadataItem.ValueDate;
var type = metadataItem.Type;
// Assert
Assert.That(filePath, Is.EqualTo(TestFilePath));
Assert.That(valutaDate, Is.EqualTo(_testDateTime));
Assert.That(type, Is.EqualTo(TestType));
}
protected void rptrPlatforms_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e.IsItem())
{
MetadataItem platform = (MetadataItem)e.Item.DataItem;
Literal litPlatform = e.FindControlAs <Literal>("litPlatform");
if (e.Item.ItemIndex == 0)
{
litPlatform.Text = platform.ContentTitle.Raw;
}
else
{
litPlatform.Text = ", " + platform.ContentTitle.Raw;
}
}
}
public void MetadateItem_Erfassungsdatum_GetTestDateTime()
{
// Arrange
var metadataItem = new MetadataItem(_testDateTime, TestType)
{
DateOfCreation = _testDateTime
};
// Act
var creationDate = metadataItem.DateOfCreation;
var type = metadataItem.Type;
var valutaDate = metadataItem.ValueDate;
// Assert
Assert.That(creationDate, Is.EqualTo(_testDateTime));
Assert.That(valutaDate, Is.EqualTo(_testDateTime));
Assert.That(type, Is.EqualTo(TestType));
}
public void MetadataItem_SetIsRemoveFileEnabled_GetTrue()
{
// Arrange
var metadataItem = new MetadataItem(_testDateTime, TestType)
{
IsRemoveFileEnabled = true
};
// Act
var isRemoveEnabled = metadataItem.IsRemoveFileEnabled;
var valutaDate = metadataItem.ValueDate;
var type = metadataItem.Type;
// Assert
Assert.That(isRemoveEnabled, Is.True);
Assert.That(valutaDate, Is.EqualTo(_testDateTime));
Assert.That(type, Is.EqualTo(TestType));
}
public void MetadataItem_Bezeichnung_GetSetTestingText()
{
// Arrange
var metadataItem = new MetadataItem(_testDateTime, TestType)
{
Description = TestDescription
};
// Act
var name = metadataItem.Description;
var valutaDate = metadataItem.ValueDate;
var type = metadataItem.Type;
// Assert
Assert.That(name, Is.EqualTo(TestDescription));
Assert.That(valutaDate, Is.EqualTo(_testDateTime));
Assert.That(type, Is.EqualTo(TestType));
}
public void MetadataItem_Benutzer_GetSetTestingText()
{
// Arrange
var metadataItem = new MetadataItem(_testDateTime, TestType)
{
UserName = TestUserName
};
// Act
var username = metadataItem.UserName;
var valutaDate = metadataItem.ValueDate;
var type = metadataItem.Type;
// Arrange
Assert.That(username, Is.EqualTo(TestUserName));
Assert.That(valutaDate, Is.EqualTo(_testDateTime));
Assert.That(type, Is.EqualTo(TestType));
}
public void XmlService_Deserialize_MetadataItem()
{
// Arrange
var xmlService = new XmlService();
var fs = File.Create("text.txt");
const string expectedXml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><MetadataItem xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><Stichwoerter /><Erfassungsdatum>0001-01-01T00:00:00</Erfassungsdatum><IsRemoveFileEnabled>false</IsRemoveFileEnabled><Type>Test</Type><ValutaDatum>0001-01-01T00:00:00</ValutaDatum></MetadataItem>";
fs.Close();
File.WriteAllText(fs.Name, expectedXml);
// Act
var deserializedObject = xmlService.DeseralizeMetadataItem(fs.Name);
var expectedResult = new MetadataItem(DateTime.MinValue, "Test");
// Assert
Assert.That(deserializedObject.ValutaDatum, Is.EqualTo(expectedResult.ValutaDatum));
Assert.That(deserializedObject.Type, Is.EqualTo(expectedResult.Type));
}
public static PageViewModel FromModel(MetadataItem model)
{
if (model == null)
{
return null;
}
var result = new PageViewModel();
result.Items.Add(ItemViewModel.FromModel(model));
if (model.Type.AllowMultipleItems())
{
AddChildren(model, result);
}
foreach (var item in model.References)
{
result.References.Add(ReferenceViewModel.FromModel(item));
}
return result;
}
public void Save_CheckIfMetadataItemValid_RetrunFalse()
{
// arrange
var dataBaseHandlerStub = A.Fake <IDataBaseHandler>();
var metaDataControl = new MetaDataControl();
var metadataItem = new MetadataItem(true);
metadataItem.Bezeichung = "";
metadataItem.ValutaDatum = DateTime.Now;
metadataItem.DokumentTyp = "Beleg";
metadataItem.Stichwoerter = "Test01";
bool result;
// act
result = metaDataControl.Save(metadataItem, "target", "guid", dataBaseHandlerStub);
// assert
Assert.That(result, Is.False);
}
public void MetadataItem_Bezeichnung_GetSetTestingText()
{
// Arrange
var metadataItem = new MetadataItem(TESTING_TEXT, _testDateTime)
{
Bezeichnung = TESTING_TEXT
};
// Act
var name = metadataItem.Bezeichnung;
var valutaDate = metadataItem.ValutaDatum;
var keyword = metadataItem.Stichwoerter;
// Assert
Assert.That(name, Is.EqualTo(TESTING_TEXT));
Assert.That(valutaDate, Is.EqualTo(_testDateTime));
Assert.That(keyword, Is.EqualTo(null));
}
public MetadataServiceTest()
{
_metadataMock = new MetadataItem()
{
FileEnding = ".test",
CreationTime = DateTime.Now,
FileName = "test",
Keywords = "test",
Typ = "test",
Username = "******",
Valuta = DateTime.Now
};
_appSettings = new AppSettings()
{
RepositoryPath = @"C:\temp"
};
}
protected void rptSkillsChecklist_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
if (e.IsItem())
{
MetadataItem issue = e.Item.DataItem as MetadataItem;
if (issue != null)
{
Literal litSkill = e.FindControlAs <Literal>("litSkill");
HtmlInputCheckBox inputSkill = e.FindControlAs <HtmlInputCheckBox>("inputSkill");
HtmlGenericControl issueLabel = e.FindControlAs <HtmlGenericControl>("issueLabel");
inputSkill.Attributes.Add("data-id", issue.ID.ToString());
litSkill.Text = issue.ContentTitle;
issueLabel.Attributes.Add("for", inputSkill.ID);
}
}
}
public void TestCollectionToThreadSafeCollectionNullItem()
{
IEnumerable <Protocol.Models.MetadataItem> collection = new List <Protocol.Models.MetadataItem>()
{
null
};
IEnumerable <MetadataItem> result = UtilitiesInternal.CollectionToThreadSafeCollectionIModifiable(
collection,
objectCreationFunc: o => new MetadataItem(o));
Assert.NotNull(result);
Assert.Equal(1, result.Count());
MetadataItem protoItem = result.First();
Assert.Null(protoItem);
}
void DBView_ItemDoubleClick(object sender, MetadataStructureItem clickedItem)
{
if (clickedItem.MetadataItem == null)
{
return;
}
// Adding a table to the currently active query.
if ((MetadataType.Objects & clickedItem.MetadataItem.Type) == 0 &&
(MetadataType.ObjectMetadata & clickedItem.MetadataItem.Type) == 0)
{
return;
}
if (ActiveMdiChild == null)
{
ChildForm childWindow = CreateChildForm();
if (childWindow == null)
{
return;
}
childWindow.Show();
childWindow.Activate();
}
ChildForm window = (ChildForm)ActiveMdiChild;
if (window == null)
{
return;
}
MetadataItem metadataItem = clickedItem.MetadataItem;
if (metadataItem == null)
{
return;
}
if ((metadataItem.Type & MetadataType.Objects) <= 0 && metadataItem.Type != MetadataType.Field)
{
return;
}
using (var qualifiedName = metadataItem.GetSQLQualifiedName(null, true))
{
window.QueryView.AddObjectToActiveUnionSubQuery(qualifiedName.GetSQL());
}
}
public void TestSpeichern()
{
var docDetailViewModel = new DocumentDetailViewModel("simon", null);
var m = new MetadataItem();
m.Stichwoerter = "asdasd";
m.ValutaDatum = new DateTime(2020, 12, 12);
m.Typ = "Verträge";
docDetailViewModel.M = m;
docDetailViewModel.Bezeichnung = "Simon";
docDetailViewModel.ValutaDatum = new DateTime(2020, 12, 12);
docDetailViewModel.SelectedTypItem = "Verträge";
docDetailViewModel.Stichwoerter = "asdasdasd";
docDetailViewModel.Erfassungsdatum = new DateTime(2020, 12, 12);
docDetailViewModel.Benutzer = "Simon";
docDetailViewModel.FilePath = "C:\\Users\\Simon Scherer\\Desktop\\testSave.pdf";
docDetailViewModel.Speichern();
Assert.That(docDetailViewModel.M.Bezeichnung, Is.EqualTo("Simon"));
}
public override void LoadForeignKeys(MetadataList foreignKeys, MetadataLoadingOptions loadingOptions)
{
if (!Connected)
{
Connect();
}
// load FKs
try
{
MetadataItem obj = foreignKeys.Parent.Object;
MetadataItem database = obj.Database;
string[] restrictions = new string[2];
restrictions[0] = database != null ? database.Name : string.Empty;
restrictions[1] = obj.Name;
DataTable schemaTable = _connection.GetSchema("Foreign Key Columns", restrictions);
MetadataForeignKeysFetcherFromDatatable mrf = new MetadataForeignKeysFetcherFromDatatable(foreignKeys, loadingOptions);
if (foreignKeys.SQLContext.SyntaxProvider.IsSupportSchemas())
{
mrf.PkSchemaFieldName = "TABLE_SCHEMA";
}
else
{
mrf.PkDatabaseFieldName = "TABLE_SCHEMA";
}
mrf.PkNameFieldName = "TABLE_NAME";
mrf.PkFieldName = "COLUMN_NAME";
mrf.FkFieldName = "REFERENCED_COLUMN_NAME";
mrf.OrdinalFieldName = "ORDINAL_POSITION";
mrf.Datatable = schemaTable;
mrf.LoadMetadata();
}
catch (Exception exception)
{
throw new QueryBuilderException(exception.Message, exception);
}
}
public void XmlSer_testSerialize_Returnfalse()
{
//arrange
const string guid = "eb31d4ff-be0b-4366-9838-994ed803dd69";
const string title = "TestBezeichnung";
DateTime valutaDate = new DateTime(2010, 09, 10);
const string type = "Quittungen";
const string notes = "TestStichwort";
DateTime entryDate = new DateTime(2020, 09, 10);
const string username = "******";
MetadataItem testItem = new MetadataItem(guid, title, valutaDate, type, notes, entryDate, username);
XmlSer ser = new XmlSer();
//act
bool result = ser.SerializeFile(testItem, "Testordner");
//assert
Assert.That(result, Is.False);
}
public static TocItemViewModel FromModel(MetadataItem item)
{
var result = new TocItemViewModel
{
Uid = item.Name,
Name = item.DisplayNames.GetLanguageProperty(SyntaxLanguage.Default),
Href = item.Href,
};
var nameForCSharp = item.DisplayNames.GetLanguageProperty(SyntaxLanguage.CSharp);
if (nameForCSharp != result.Name)
{
result.NameForCSharp = nameForCSharp;
}
var nameForVB = item.DisplayNames.GetLanguageProperty(SyntaxLanguage.VB);
if (nameForVB != result.Name)
{
result.NameForVB = nameForVB;
}
if (item.Items != null)
{
result.Items = TocViewModel.FromModel(item);
}
return result;
}
private MetadataItem(MetadataItem metadataItem)
{
Key = metadataItem.Key;
Value = metadataItem.Value;
}
public static ItemViewModel FromModel(MetadataItem model)
{
if (model == null)
{
return null;
}
var result = new ItemViewModel
{
Uid = model.Name,
Parent = model.Parent?.Name,
Children = model.Items?.Select(x => x.Name).OrderBy(s => s).ToList(),
Href = model.Href,
Type = model.Type,
Source = model.Source,
Documentation = model.Documentation,
AssemblyNameList = model.AssemblyNameList,
NamespaceName = model.NamespaceName,
Summary = model.Summary,
Remarks = model.Remarks,
Examples = model.Examples,
Syntax = SyntaxDetailViewModel.FromModel(model.Syntax),
Overridden = model.Overridden,
Exceptions = model.Exceptions,
Sees = model.Sees,
SeeAlsos = model.SeeAlsos,
Inheritance = model.Inheritance,
Implements = model.Implements,
InheritedMembers = model.InheritedMembers,
};
result.Id = model.Name.Substring((model.Parent?.Name?.Length ?? -1) + 1);
result.Name = model.DisplayNames.GetLanguageProperty(SyntaxLanguage.Default);
var nameForCSharp = model.DisplayNames.GetLanguageProperty(SyntaxLanguage.CSharp);
if (result.Name != nameForCSharp)
{
result.NameForCSharp = nameForCSharp;
}
var nameForVB = model.DisplayNames.GetLanguageProperty(SyntaxLanguage.VB);
if (result.Name != nameForVB)
{
result.NameForVB = nameForVB;
}
result.FullName = model.DisplayQualifiedNames.GetLanguageProperty(SyntaxLanguage.Default);
var fullnameForCSharp = model.DisplayQualifiedNames.GetLanguageProperty(SyntaxLanguage.CSharp);
if (result.FullName != fullnameForCSharp)
{
result.FullNameForCSharp = fullnameForCSharp;
}
var fullnameForVB = model.DisplayQualifiedNames.GetLanguageProperty(SyntaxLanguage.VB);
if (result.FullName != fullnameForVB)
{
result.FullNameForVB = fullnameForVB;
}
return result;
}
public void AddMetadata_should_set_metadata_on_convention_when_called_with_a_function()
{
this.conventionBuilder
.AddMetadata(() => new[] {new KeyValuePair<string, object>("Foo", "Bar")});
var convention =
this.conventionBuilder.GetBuiltInstance();
var expectedMetadata =
new MetadataItem("Foo", "Bar");
convention.Metadata.First().Equals(expectedMetadata).ShouldBeTrue();
}
private void btnNext_Click(object s, System.EventArgs e)
{
if (String.IsNullOrEmpty(txtName.Text) && workitem == null)
{
// don't check TVM Size because it has a default
MessageBox.Show("Pool name cannot be empty");
return;
}
try
{
if (pool != null)
{
pool = new Pool(txtName.Text, "small" /*temporary*/);
}
else if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool = new PoolUserSpec();
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format(
"{0} Caught\nName is a required field. Please enter a valid name", ex));
}
try
{
if (Time.CanParse(dataTableResize))
{
TimeSpan span = Time.ParseTimeSpan(dataTableResize);
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.
ResizeTimeout = span;
}
else if (pool != null)
{
pool.ResizeTimeout = span;
}
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("{0}", ex));
}
try
{
string size = (rbtnXLarge.IsChecked == true) ? "extralarge" :
(rbtnLarge.IsChecked == true) ? "large" : "small";
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.TVMSize = size;
}
else if (pool != null)
{
pool.TVMSize = size;
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format(
"{0} Caught\nA TVM size is required", ex));
}
try
{
if (rbtnAuto.IsChecked == true)
{
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.EnableAutoScale = true;
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.AutoScaleFormula = txtAutoScale.Text;
}
else if (pool != null)
{
pool.EnableAutoScale = true;
pool.AutoScaleFormula = txtAutoScale.Text;
}
}
else if (rbtnTD.IsChecked == true)
{
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.EnableAutoScale = false;
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.TargetDedicated = int.Parse(txtTD.Text);
}
else if (pool != null)
{
pool.EnableAutoScale = false;
pool.TargetDedicated = int.Parse(txtTD.Text);
}
}
else
{
System.Windows.MessageBox.Show("Something is wrong with the Autoscale/TD buttons");
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format(
"{0} Caught\nThis is not a proper Autoscale/TD argument.", ex));
}
try
{
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.Communication = (rbtnComT.IsChecked == true) ? true :
(rbtnComF.IsChecked == true) ? false : false;
}
else if (pool != null)
{
pool.Communication = (rbtnComT.IsChecked == true) ? true :
(rbtnComF.IsChecked == true) ? false : false;
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format(
"{0} Caught\nThis is not a proper Communication argument.", ex));
}
try
{
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.StorageAccountAffinity = txtSAA.Text;
}
else if (pool != null)
{
pool.StorageAccountAffinity = txtSAA.Text;
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(string.Format(
"{0} Caught\nThis is not a proper Storage Account Affinity", ex));
}
try
{
List<MetadataItem> metadata = new List<MetadataItem>();
foreach (DataRowView row in dataView)
{
string key = row.Row.ItemArray[0].ToString();
string value = row.Row.ItemArray[1].ToString();
if (!String.IsNullOrEmpty(key) &&
!String.IsNullOrEmpty(value))
{
MetadataItem item = new MetadataItem();
item.Name = key;
item.Value = value;
metadata.Add(item);
}
}
if (metadata.Count > 0)
{
if (workitem != null)
{
workitem.JobExecutionEnvironment.AutoPoolSpecification.Pool.Metadata = metadata.ToArray();
}
else if (pool != null)
{
pool.Metadata = metadata.ToArray();
}
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Pool Metadata:\n{0}", ex));
}
try
{
if (pool != null && chkStartTask.IsChecked == true)
{
CreatePoolP2 p2 = new CreatePoolP2(this.Sender, pool);
NavigationService.Navigate(p2);
}
else if (pool != null && chkStartTask.IsChecked == false)
{
(Sender as BatchTreeViewItem).AddPool(pool, pool.Name);
(this.Parent as NavigationWindow).Close();
}
else if (workitem != null && chkStartTask.IsChecked == true)
{
CreatePoolP2 p7 = new CreatePoolP2(this.Sender, workitem);
NavigationService.Navigate(p7);
}
else if (workitem != null && chkStartTask.IsChecked == false)
{
(Sender as BatchTreeViewItem).AddWorkItem(workitem);
(this.Parent as NavigationWindow).Close();
}
else
{
MessageBox.Show("Improper pool/workitem argument passed into CreatePoolP1");
}
}
catch (Exception ex)
{
MessageBox.Show(Utils.ExtractExceptionMessage(ex));
}
}
private void setStuff(ref MetadataItem item, PropertyItem propItem, string tag, string caption)
{
try
{
item.Caption = caption;
item.Hex = tag;
string proptext = propItem.Id.ToString("x");
if (proptext == tag)
{
System.Text.ASCIIEncoding Value = new System.Text.ASCIIEncoding();
item.DisplayValue = Value.GetString(propItem.Value);
}
}
catch (Exception)
{ }
}
/// <summary>
/// Creates a new workitem
/// </summary>
/// <param name="parameters">The parameters to use when creating the workitem</param>
public void CreateWorkItem(NewWorkItemParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
using (IWorkItemManager wiManager = parameters.Context.BatchOMClient.OpenWorkItemManager())
{
ICloudWorkItem workItem = wiManager.CreateWorkItem(parameters.WorkItemName);
if (parameters.Schedule != null)
{
workItem.Schedule = parameters.Schedule.omObject;
}
if (parameters.JobSpecification != null)
{
Utils.Utils.JobSpecificationSyncCollections(parameters.JobSpecification);
workItem.JobSpecification = parameters.JobSpecification.omObject;
}
if (parameters.JobExecutionEnvironment != null)
{
Utils.Utils.JobExecutionEnvironmentSyncCollections(parameters.JobExecutionEnvironment);
workItem.JobExecutionEnvironment = parameters.JobExecutionEnvironment.omObject;
}
if (parameters.Metadata != null)
{
workItem.Metadata = new List<IMetadataItem>();
foreach (DictionaryEntry d in parameters.Metadata)
{
MetadataItem metadata = new MetadataItem(d.Key.ToString(), d.Value.ToString());
workItem.Metadata.Add(metadata);
}
}
WriteVerbose(string.Format(Resources.NBWI_CreatingWorkItem, parameters.WorkItemName));
workItem.Commit(parameters.AdditionalBehaviors);
}
}
internal abstract void Evaluate(EdmModelValidationContext context, MetadataItem item);
/// <summary>
/// Creates a new job schedule.
/// </summary>
/// <param name="parameters">The parameters to use when creating the job schedule.</param>
public void CreateJobSchedule(NewJobScheduleParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
JobScheduleOperations jobScheduleOperations = parameters.Context.BatchOMClient.JobScheduleOperations;
CloudJobSchedule jobSchedule = jobScheduleOperations.CreateJobSchedule();
jobSchedule.Id = parameters.JobScheduleId;
jobSchedule.DisplayName = parameters.DisplayName;
if (parameters.Schedule != null)
{
jobSchedule.Schedule = parameters.Schedule.omObject;
}
if (parameters.JobSpecification != null)
{
Utils.Utils.JobSpecificationSyncCollections(parameters.JobSpecification);
jobSchedule.JobSpecification = parameters.JobSpecification.omObject;
}
if (parameters.Metadata != null)
{
jobSchedule.Metadata = new List<MetadataItem>();
foreach (DictionaryEntry d in parameters.Metadata)
{
MetadataItem metadata = new MetadataItem(d.Key.ToString(), d.Value.ToString());
jobSchedule.Metadata.Add(metadata);
}
}
WriteVerbose(string.Format(Resources.CreatingJobSchedule, parameters.JobScheduleId));
jobSchedule.Commit(parameters.AdditionalBehaviors);
}
/// <summary>
/// Creates a new job.
/// </summary>
/// <param name="parameters">The parameters to use when creating the job.</param>
public void CreateJob(NewJobParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
CloudJob job = jobOperations.CreateJob();
job.Id = parameters.JobId;
job.DisplayName = parameters.DisplayName;
job.Priority = parameters.Priority;
if (parameters.CommonEnvironmentSettings != null)
{
List<EnvironmentSetting> envSettings = new List<EnvironmentSetting>();
foreach (DictionaryEntry d in parameters.CommonEnvironmentSettings)
{
EnvironmentSetting envSetting = new EnvironmentSetting(d.Key.ToString(), d.Value.ToString());
envSettings.Add(envSetting);
}
job.CommonEnvironmentSettings = envSettings;
}
if (parameters.Constraints != null)
{
job.Constraints = parameters.Constraints.omObject;
}
if (parameters.UsesTaskDependencies != null)
{
job.UsesTaskDependencies = parameters.UsesTaskDependencies;
}
if (parameters.JobManagerTask != null)
{
Utils.Utils.JobManagerTaskSyncCollections(parameters.JobManagerTask);
job.JobManagerTask = parameters.JobManagerTask.omObject;
}
if (parameters.JobPreparationTask != null)
{
Utils.Utils.JobPreparationTaskSyncCollections(parameters.JobPreparationTask);
job.JobPreparationTask = parameters.JobPreparationTask.omObject;
}
if (parameters.JobReleaseTask != null)
{
Utils.Utils.JobReleaseTaskSyncCollections(parameters.JobReleaseTask);
job.JobReleaseTask = parameters.JobReleaseTask.omObject;
}
if (parameters.Metadata != null)
{
job.Metadata = new List<MetadataItem>();
foreach (DictionaryEntry d in parameters.Metadata)
{
MetadataItem metadata = new MetadataItem(d.Key.ToString(), d.Value.ToString());
job.Metadata.Add(metadata);
}
}
if (parameters.PoolInformation != null)
{
Utils.Utils.PoolInformationSyncCollections(parameters.PoolInformation);
job.PoolInformation = parameters.PoolInformation.omObject;
}
if (parameters.OnAllTasksComplete != null)
{
job.OnAllTasksComplete = parameters.OnAllTasksComplete;
}
if (parameters.OnTaskFailure != null)
{
job.OnTaskFailure = parameters.OnTaskFailure;
}
WriteVerbose(string.Format(Resources.CreatingJob, parameters.JobId));
job.Commit(parameters.AdditionalBehaviors);
}
