private void Dispatch(UpdateSet update)
{
lock (_thisLock)
{
if (update != null)
{
// ok. next version please
_version = update.version;
if (UpdateSet != null)
{
UpdateSet(this, new UpdateSetEventArgs(update));
}
foreach (PropertyFilterUpdate pfu in update.filterSet)
{
if (_filterUpdates.ContainsKey(pfu.filter.Value))
{
_filterUpdates[pfu.filter.Value](this, new PropertyFilterUpdateEventArgs(pfu));
}
}
}
}
}
/// <inheritdoc />
public int Update <T>(UpdateSet <T> updateSet)
{
if (updateSet == null)
{
throw new ArgumentNullException(nameof(updateSet));
}
var updateStatement = this.DatabaseContext.RepositoryAdapter.CreateUpdateStatement(updateSet);
try
{
// Always use ToArray()!
this.DatabaseContext.OpenSharedConnection();
return(this.DatabaseContext.Execute(updateStatement, updateSet.PropertyValues.ToArray()));
}
catch (InvalidOperationException ex)
{
throw new RepositoryException(updateSet, ex.Message, ex);
}
catch (DataException ex)
{
throw new RepositoryException(updateSet, ex.Message, ex);
}
catch (DbException ex)
{
throw new RepositoryException(updateSet, ex.Message, ex);
}
}
private SetResponse SaveSet(string key = null)
{
var updateBuilder = new UpdateSet.Builder(DefaultAdds, null)
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithTimeout(TimeSpan.FromMilliseconds(20000));
if (!string.IsNullOrEmpty(key))
{
updateBuilder.WithKey(key);
}
UpdateSet cmd = updateBuilder.Build();
RiakResult rslt = client.Execute(cmd);
Assert.IsTrue(rslt.IsSuccess, rslt.ErrorMessage);
SetResponse response = cmd.Response;
Keys.Add(response.Key);
Assert.True(EnumerableUtil.NotNullOrEmpty(response.Context));
return(response);
}
/// <inheritdoc />
public async Task <int> UpdateAsync <T>(UpdateSet <T> updateSet, CancellationToken cancellationToken)
{
if (updateSet == null)
{
throw new ArgumentNullException(nameof(updateSet));
}
var updateStatement = this.DatabaseContext.RepositoryAdapter.CreateUpdateStatement(updateSet);
try
{
// Always use ToArray()!
await this.DatabaseContext.OpenSharedConnectionAsync(cancellationToken).ConfigureAwait(false);
return(await this.DatabaseContext.ExecuteAsync(updateStatement, cancellationToken, updateSet.PropertyValues.ToArray())
.ConfigureAwait(false));
}
catch (InvalidOperationException ex)
{
throw new RepositoryException(updateSet, ex.Message, ex);
}
catch (DataException ex)
{
throw new RepositoryException(updateSet, ex.Message, ex);
}
catch (DbException ex)
{
throw new RepositoryException(updateSet, ex.Message, ex);
}
}
/// <summary>
/// Saves a domain model to the repository as an entity.
/// </summary>
/// <param name="model">
/// The model to save.
/// </param>
/// <param name="cancellationToken">
/// The cancellation token for this task.
/// </param>
/// <returns>
/// The saved data entity.
/// </returns>
private async Task <TEntity> SaveEntityAsync(TModel model, CancellationToken cancellationToken)
{
var entity = new TEntity();
this.EntityMapper.MapTo(model, entity);
if (await this.ContainsAsync(entity, cancellationToken).ConfigureAwait(false))
{
var updateSet = new UpdateSet <TEntity>()
.Set(entity, this.RepositoryProvider.EntityDefinitionProvider)
.Where(set => set.MatchKey(entity, this.RepositoryProvider.EntityDefinitionProvider));
await this.RepositoryProvider.UpdateAsync(updateSet, cancellationToken).ConfigureAwait(false);
}
else
{
entity = await this.RepositoryProvider.InsertAsync(entity, cancellationToken).ConfigureAwait(false);
}
if (entity == null)
{
throw new OperationException(model, $"The underlying provider returned a null entity when inserting '{model}'.");
}
return(entity);
}
/// <summary>
/// Saves a domain model to the repository as an entity.
/// </summary>
/// <param name="model">
/// The model to save.
/// </param>
/// <returns>
/// The saved data entity.
/// </returns>
private TEntity SaveEntity(TModel model)
{
var entity = new TEntity();
this.EntityMapper.MapTo(model, entity);
if (this.Contains(entity))
{
var updateSet = new UpdateSet <TEntity>()
.Set(entity, this.RepositoryProvider.EntityDefinitionProvider)
.Where(set => set.MatchKey(entity, this.RepositoryProvider.EntityDefinitionProvider));
this.RepositoryProvider.Update(updateSet);
}
else
{
entity = this.RepositoryProvider.Insert(entity);
}
if (entity == null)
{
throw new OperationException(model, $"The underlying provider returned a null entity when inserting '{model}'.");
}
return(entity);
}
private void PropertyManager_WaitForUpdatesDone(IAsyncResult ar)
{
lock (_thisLock)
{
_asyncResult = null;
try
{
UpdateSet update = Connection.Service.EndWaitForUpdates(ar);
Dispatch(update);
}
catch (Exception x)
{
ReportException(x);
}
try
{
// Restart the listening loop
StartListening();
}
catch (Exception x)
{
ReportException(x);
}
}
}
void handleUpdate(UpdateSet update) {
ArrayList vmUpdates = new ArrayList();
ArrayList hostUpdates = new ArrayList();
PropertyFilterUpdate[] pfus = update.filterSet;
for(int pfui=0; pfui<pfus.Length; ++ pfui) {
ObjectUpdate[] ous = pfus[pfui].objectSet;
for(int oui=0; oui<ous.Length; ++oui) {
if(ous[oui].obj.type.Equals("VirtualMachine")) {
vmUpdates.Add(ous[oui]);
} else if(ous[oui].obj.type.Equals("HostSystem")) {
hostUpdates.Add(ous[oui]);
}
}
}
if(vmUpdates.Count > 0) {
Console.WriteLine("Virtual Machine updates:");
for (IEnumerator vmi = vmUpdates.GetEnumerator(); vmi.MoveNext(); )
{
handleObjectUpdate((ObjectUpdate)vmi.Current);
}
}
if(hostUpdates.Count > 0) {
Console.WriteLine("Host updates:");
for (IEnumerator vmi = hostUpdates.GetEnumerator(); vmi.MoveNext(); )
{
handleObjectUpdate((ObjectUpdate)vmi.Current);
}
}
}
public void Set_RaisedRelatedDataSpecificSetValuesFromItem_MatchesExpected()
{
var match = new DataRow
{
NormalColumn = "NormalColumn",
RelatedAlias = new FakeRelatedRow
{
RelatedProperty = "Related"
},
NullableColumn = "CouldHaveBeenNull",
ValueColumn = 2,
NullableValueColumn = null,
};
var baseline = new DataRow
{
FakeDataId = 10
};
var boundary = new DataRow
{
FakeDataId = 20
};
var target = new DataRow
{
NormalColumn = "UpdatedNormalColumn",
NullableColumn = null
};
var updateSet = new UpdateSet <DataRow>().Set(target, row => row.NormalColumn, row => row.NullableColumn)
.From(
set => set.InnerJoin(row => row.FakeDataId, row => row.Related.FakeDataId)
.InnerJoin(row => row.Related.RelatedId, row => row.DependencyEntity.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.OtherAlias.FakeDataId)
.InnerJoin(row => row.OtherAlias.RelatedId, row => row.RelatedDependency.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.RelatedAlias.FakeDataId)
.LeftJoin <SubDataRow>(row => row.FakeDataId, row => row.FakeSubDataId))
.Where(
set => set.AreEqual(row => row.ValueColumn, match.ValueColumn)
.AreEqual(row => row.NullableColumn, match.NullableColumn)
.AreEqual(row => row.NullableValueColumn, match.NullableValueColumn)
.AreEqual(row => row.RelatedAlias.RelatedProperty, "Related")
.Between(baseline, boundary, row => row.FakeDataId));
var expected = new object[]
{
"UpdatedNormalColumn",
2,
"CouldHaveBeenNull",
"Related",
10,
20
};
var actual = updateSet.PropertyValues.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Set_RaisedDirectData_MatchesExpected()
{
var match = new DataRow
{
NormalColumn = "NormalColumn",
NullableColumn = "CouldHaveBeenNull",
ValueColumn = 2,
NullableValueColumn = null,
AnotherValueColumn = 12,
AnotherColumn = "Some Other Value"
};
var baseline = new DataRow
{
FakeDataId = 10
};
var boundary = new DataRow
{
FakeDataId = 20
};
var updateSet = new UpdateSet <DataRow>().Set(match, new DataAnnotationsDefinitionProvider())
.From(
set => set.InnerJoin(row => row.FakeDataId, row => row.Related.FakeDataId)
.InnerJoin(row => row.Related.RelatedId, row => row.DependencyEntity.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.OtherAlias.FakeDataId)
.InnerJoin(row => row.OtherAlias.RelatedId, row => row.RelatedDependency.ComplexEntityId)
.InnerJoin(row => row.FakeDataId, row => row.RelatedAlias.FakeDataId)
.LeftJoin <SubDataRow>(row => row.FakeDataId, row => row.FakeSubDataId))
.Where(
set => set.AreEqual(row => row.ValueColumn, match.ValueColumn)
.AreEqual(row => row.NullableColumn, match.NullableColumn)
.AreEqual(row => row.NullableValueColumn, match.NullableValueColumn)
.Between(baseline, boundary, row => row.FakeDataId));
var expected = new object[]
{
"NormalColumn",
"CouldHaveBeenNull",
2,
12,
"Some Other Value",
2,
"CouldHaveBeenNull",
10,
20
};
var actual = updateSet.PropertyValues.ToArray();
CollectionAssert.AreEqual(
expected,
actual,
"Expected: {0}{1}Actual: {2}",
string.Join(",", expected),
Environment.NewLine,
string.Join(",", actual));
}
/// <inheritdoc />
public int Update <TItem>(UpdateSet <TItem> updateSet)
{
if (updateSet == null)
{
throw new ArgumentNullException(nameof(updateSet));
}
return(this.RepositoryProvider.Update(updateSet as UpdateSet <TEntity> ?? updateSet.MapSet <TEntity>()));
}
/// <inheritdoc />
public async Task <int> UpdateAsync <TItem>(UpdateSet <TItem> updateSet, CancellationToken cancellationToken)
{
if (updateSet == null)
{
throw new ArgumentNullException(nameof(updateSet));
}
return(await this.RepositoryProvider.UpdateAsync(updateSet as UpdateSet <TEntity> ?? updateSet.MapSet <TEntity>(), cancellationToken)
.ConfigureAwait(false));
}
private void updateSet(object sender, UpdateSet e)
{
SendMessages = false;
foreach (var m in e.Models)
{
updateModel(sender, new UpdateModel()
{
Id = m.Id, Model = m
});
}
SendMessages = true;
}
public void MapSet_DirectDataUpdateSetFromDtoToRow_PropertiesMatchExpected()
{
var expected = new UpdateSet <DocumentDto>().Set(dto => dto.Identifier, "foo123-35")
.Set(dto => dto.VersionNumber, 35)
.Where(set => set.AreEqual(dto => dto.Identifier, "foo123-34"));
var actual = expected.MapSet <DocumentRow>();
CollectionAssert.AreEqual(expected.Filters.ToList(), actual.Filters.ToList());
CollectionAssert.AreEqual(expected.AttributesToSet.ToList(), actual.AttributesToSet.ToList());
Assert.AreEqual(typeof(DocumentRow), actual.EntityType);
CollectionAssert.AreEqual(expected.PropertyValues.ToList(), actual.PropertyValues.ToList());
}
/// <summary>
/// Open set rename dialog
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void OnRenameBtnClickEventRaised(object sender, EventArgs e)
{
//TODO: Check why SetListbox doesn't update after renaming set
if (SetModel.SelectedSet != null)
{
//Check for illegal characters
SetNameUpdater _setNameUpdater = StaticFactory.CreateSetNameUpdater();
_setNameUpdater.inputNewSetTitle.TextChanged += (o, a) =>
{
string illegalChars = "^[\\w ]+$";
Regex regex = new Regex(illegalChars);
if (_setNameUpdater.inputNewSetTitle.Text == "" || !regex.IsMatch(_setNameUpdater.inputNewSetTitle.Text))
{
_setNameUpdater.SetNameUpdaterBtnSubmit.Visible = false;
_setNameUpdater.WarningLabel.Visible = true;
}
else
{
_setNameUpdater.SetNameUpdaterBtnSubmit.Visible = true;
_setNameUpdater.WarningLabel.Visible = false;
}
};
//Create setNameUpdater window &
_setNameUpdater.StartPosition = FormStartPosition.Manual;
_setNameUpdater.Location = new System.Drawing.Point(this._mainView.Location.X + 430, this._mainView.Location.Y + 400);
DialogResult updateDialog = _setNameUpdater.ShowDialog(_mainView);
//If submit btn = pressed, rename set folder name
if (updateDialog == DialogResult.OK)
{
if (_setlistboxPresenter._setlistboxView.HomeSetList.SelectedItem != null)
{
//Rename set folder name
UpdateSet.Update(_setlistboxPresenter._setlistboxView.HomeSetList.SelectedItem.Text, _setNameUpdater.inputNewSetTitle.Text);
//Rebuild setlistbox item list
_setlistboxPresenter._setlistboxView.HomeSetList.Items.Clear();
_setModels = StaticFactory.CreateAllSets();
SetListboxInit();
_setlistboxPresenter._setlistboxView.HomeSetList.SelectedIndex = 0;
}
}
}
}
/// <summary>
/// Mark the input properties as modified
/// </summary>
public static UpdateSet <T> UpdateProps <T>(this DbContext db,
T entity, params string[] properties)
where T : class
{
var result = new UpdateSet <T>(db, entity);
var entry = result.Entry;
for (var i = 0; i < properties.Length; ++i)
{
entry.Property(properties[i]).IsModified = true;
}
return(result);
}
public void CheckForUpdates()
{
lock (_thisLock)
{
try
{
UpdateSet update = Connection.Service.CheckForUpdates(Context.propertyCollector, _version);
Dispatch(update);
}
catch (Exception x)
{
ReportException(x);
}
}
}
public async Task <IActionResult> Update(int id, [FromBody] UpdateSet model)
{
var Set = _mapper.Map <Set>(model);
Set.Id = id;
try
{
await _setService.Update(Set);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <bool> UpdateSet(UpdateSet set, long id)
{
var setJson = JsonConvert.SerializeObject(set);
var uri = new Uri(string.Format(DELETE_UPDATE_SET, id));
using (var _client = HttpClientHelper.GetAuthenticatedHttpClient())
{
var content = new StringContent(setJson, Encoding.UTF8, "application/json");
var result = await _client.PutAsync(uri, content);
if (result.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
}
public void Should_Build_DtUpdateReq_Correctly()
{
var updateSetCommandBuilder = new UpdateSet.Builder(DefaultAdds, DefaultRemoves);
var q1 = new Quorum(1);
var q2 = new Quorum(2);
var q3 = new Quorum(3);
updateSetCommandBuilder
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(Key)
.WithW(q3)
.WithPW(q1)
.WithDW(q2)
.WithReturnBody(true)
.WithIncludeContext(false)
.WithContext(Context)
.WithTimeout(TimeSpan.FromSeconds(20));
UpdateSet updateSetCommand = updateSetCommandBuilder.Build();
DtUpdateReq protobuf = (DtUpdateReq)updateSetCommand.ConstructPbRequest();
Assert.AreEqual(Encoding.UTF8.GetBytes(BucketType), protobuf.type);
Assert.AreEqual(Encoding.UTF8.GetBytes(Bucket), protobuf.bucket);
Assert.AreEqual(Encoding.UTF8.GetBytes(Key), protobuf.key);
Assert.AreEqual(q3, protobuf.w);
Assert.AreEqual(q1, protobuf.pw);
Assert.AreEqual(q2, protobuf.dw);
Assert.IsTrue(protobuf.return_body);
Assert.IsFalse(protobuf.include_context);
Assert.AreEqual(20000, protobuf.timeout);
SetOp setOpMsg = protobuf.op.set_op;
Assert.AreEqual(DefaultAdds, setOpMsg.adds);
Assert.AreEqual(DefaultRemoves, setOpMsg.removes);
}
void handleUpdate(UpdateSet update)
{
ArrayList vmUpdates = new ArrayList();
ArrayList hostUpdates = new ArrayList();
PropertyFilterUpdate[] pfus = update.filterSet;
for (int pfui = 0; pfui < pfus.Length; ++pfui)
{
ObjectUpdate[] ous = pfus[pfui].objectSet;
for (int oui = 0; oui < ous.Length; ++oui)
{
if (ous[oui].obj.type.Equals("VirtualMachine"))
{
vmUpdates.Add(ous[oui]);
}
else if (ous[oui].obj.type.Equals("HostSystem"))
{
hostUpdates.Add(ous[oui]);
}
}
}
if (vmUpdates.Count > 0)
{
Console.WriteLine("Virtual Machine updates:");
for (IEnumerator vmi = vmUpdates.GetEnumerator(); vmi.MoveNext();)
{
handleObjectUpdate((ObjectUpdate)vmi.Current);
}
}
if (hostUpdates.Count > 0)
{
Console.WriteLine("Host updates:");
for (IEnumerator vmi = hostUpdates.GetEnumerator(); vmi.MoveNext();)
{
handleObjectUpdate((ObjectUpdate)vmi.Current);
}
}
}
/// <summary>
/// Waits until any of the expected values of an object property has
/// reached.
/// </summary>
/// <param name="task">ManagedObjectReference representing the task
/// </param>
/// <param name="filterProps">properties list to filter</param>
/// <param name="endWaitProps">properties list to check for expected
/// values, these are properties of a property in the filter properties
/// list</param>
/// <param name="expectedVals">expected values</param>
/// <returns>task result</returns>
public object[] Wait(ManagedObjectReference task,
string[] filterProps,
string[] endWaitProps,
object[][] expectedVals)
{
// version is initially empty
var version = "";
var endVals = new object[endWaitProps.Length];
var filterVals = new object[filterProps.Length];
var propFilterSpec = PropertyFilterSpec(task, filterProps);
var filterMoref = vimConnection.VimPortType.CreateFilter(
vimConnection.ServiceContent.propertyCollector,
propFilterSpec, true);
var reached = false;
UpdateSet updateset = null;
while (!reached)
{
updateset = vimConnection.VimPortType.WaitForUpdatesEx(
vimConnection.ServiceContent.propertyCollector,
version,
new WaitOptions());
if (updateset == null || updateset.filterSet == null)
{
continue;
}
version = updateset.version;
foreach (var filterUpdate in updateset.filterSet)
{
foreach (var objUpdate in filterUpdate.objectSet)
{
// TODO: Handle all "kind"s of updates.
if (objUpdate.kind == ObjectUpdateKind.modify ||
objUpdate.kind == ObjectUpdateKind.enter ||
objUpdate.kind == ObjectUpdateKind.leave)
{
foreach (var propChange in objUpdate.changeSet)
{
UpdateValues(
endWaitProps, endVals, propChange);
UpdateValues(
filterProps, filterVals, propChange);
}
}
}
}
// check if we have reached the expected values
for (var chgi = 0; chgi < endVals.Length && !reached; chgi++)
{
for (var vali = 0;
vali < expectedVals[chgi].Length && !reached; vali++)
{
reached = expectedVals[chgi][vali].Equals(
endVals[chgi]);
}
}
}
// destroy the filter when we are done
vimConnection.VimPortType.DestroyPropertyFilter(filterMoref);
return(filterVals);
}
private void Dispatch(UpdateSet update)
{
lock (_thisLock)
{
if (update != null)
{
// ok. next version please
_version = update.version;
if (UpdateSet != null)
{
UpdateSet(this, new UpdateSetEventArgs(update));
}
foreach (PropertyFilterUpdate pfu in update.filterSet)
{
if (_filterUpdates.ContainsKey(pfu.filter.Value))
{
_filterUpdates[pfu.filter.Value](this, new PropertyFilterUpdateEventArgs(pfu));
}
}
}
}
}
public UpdateSetEventArgs(UpdateSet updateSet)
{
_updateSet = updateSet;
}
private void getUpdates()
{
ManagedObjectReference vmRef
= cb.getServiceUtil().GetDecendentMoRef(null, "VirtualMachine",
cb.get_option("vmname"));
if (vmRef == null)
{
Console.WriteLine("Virtual Machine " + cb.get_option("vmname")
+ " Not Found");
return;
}
String[][] typeInfo =
{
new String[] { "VirtualMachine", "name", "summary.quickStats", "runtime" }
};
PropertySpec[] pSpecs = cb.getServiceUtil().BuildPropertySpecArray(typeInfo);
ObjectSpec[] oSpecs = null;
oSpecs = new ObjectSpec[] { new ObjectSpec() };
Boolean oneOnly = vmRef != null;
oSpecs[0].obj = oneOnly ? vmRef : cb.getConnection().ServiceContent.rootFolder;
oSpecs[0].skip = !oneOnly;
if (!oneOnly)
{
SelectionSpec[] selectionSpecs = cb.getServiceUtil().buildFullTraversal();
oSpecs[0].selectSet = selectionSpecs;
}
PropertyFilterSpec pSpec = new PropertyFilterSpec();
pSpec.objectSet = new ObjectSpec[] { oSpecs[0] };
pSpec.propSet = new PropertySpec[] { pSpecs[0] };
ManagedObjectReference propColl = cb.getConnection().PropCol;
ManagedObjectReference propFilter = cb.getConnection()._service.CreateFilter(propColl, pSpec, false);
String version = "";
do
{
UpdateSet update = cb.getConnection()._service.CheckForUpdates(propColl,
version);
if (update != null && update.filterSet != null)
{
handleUpdate(update);
version = update.version;
}
else
{
Console.WriteLine("No update is present!");
}
Console.WriteLine("");
Console.WriteLine("Press <Enter> to check for updates");
Console.WriteLine("Enter 'exit' <Enter> to exit the program");
String line = Console.ReadLine();
if (line.Trim().Equals("exit"))
{
break;
}
}while(true);
cb.getConnection()._service.DestroyPropertyFilter(propFilter);
}
/// <inheritdoc />
public Task <int> UpdateAsync <TItem>(UpdateSet <TItem> updateSet)
{
throw new NotImplementedException();
}
public void CitiesSetAddRemoveAndView()
{
var adds = new HashSet <string> {
"Toronto", "Montreal"
};
var builder = new UpdateSet.Builder()
.WithBucketType("sets")
.WithBucket("travel")
.WithKey("cities")
.WithAdditions(adds);
UpdateSet cmd = builder.Build();
RiakResult rslt = client.Execute(cmd);
CheckResult(rslt);
SetResponse response = cmd.Response;
Assert.Contains("Toronto", response.AsStrings.ToArray());
Assert.Contains("Montreal", response.AsStrings.ToArray());
var removes = new HashSet <string> {
"Montreal"
};
adds = new HashSet <string> {
"Hamilton", "Ottawa"
};
Assert.True(EnumerableUtil.NotNullOrEmpty(response.Context));
builder
.WithAdditions(adds)
.WithRemovals(removes)
.WithContext(response.Context);
cmd = builder.Build();
rslt = client.Execute(cmd);
CheckResult(rslt);
response = cmd.Response;
var responseStrings = response.AsStrings.ToArray();
Assert.Contains("Toronto", responseStrings);
Assert.Contains("Hamilton", responseStrings);
Assert.Contains("Ottawa", responseStrings);
foreach (var value in response.AsStrings)
{
Console.WriteLine("Cities Set Value: {0}", value);
}
Console.WriteLine("Cities Set Size: {0}", responseStrings.Length);
bool includesVancouver = response.AsStrings.Any(v => v == "Vancouver");
bool includesOttawa = response.AsStrings.Any(v => v == "Ottawa");
Assert.False(includesVancouver);
Assert.True(includesOttawa);
}
/// <inheritdoc />
public async Task <int> UpdateAsync <T>(UpdateSet <T> updateSet)
{
return(await this.UpdateAsync(updateSet, CancellationToken.None).ConfigureAwait(false));
}
public UpdateSetEventArgs(UpdateSet updateSet)
{
_updateSet = updateSet;
}
public async void Save(object sender, RoutedEventArgs e)
{
var error = false;
if (string.IsNullOrEmpty(Title))
{
error = true;
ShowTitleError = true;
}
foreach (var termDef in TermsDefinitions)
{
if (string.IsNullOrEmpty(termDef.Term) || string.IsNullOrEmpty(termDef.Definition))
{
termDef.Valid = false;
error = true;
}
}
if (!error && !EditMode)
{
// save the set...
var terms = new List <string>();
var definitions = new List <string>();
foreach (var termDef in TermsDefinitions)
{
terms.Add(termDef.Term);
definitions.Add(termDef.Definition);
}
var setToCreate = new CreateSet()
{
Title = Title,
LangDefinitions = SelectedDefinitionLanguage.CountryCode,
LangTerms = SelectedTermLanguage.CountryCode,
Definitions = definitions.ToArray(),
Terms = terms.ToArray(),
Visibility = EveryoneOrMe ? Models.QuizletTypes.Uploading.Visibility.Everyone : Models.QuizletTypes.Uploading.Visibility.OnlyMe,
};
var result = await _quizletApi.CreateNewSet(setToCreate);
if (result)
{
//Get new updated sets and save them locally
await SaveCreatedOrUpdatedSets();
//Navigate back
NavigationService.Navigate(typeof(Views.MySetsPage));
}
else
{
var dialog = new MessageDialog("Error: and error occured while creating the set.");
await dialog.ShowAsync();
}
}
if (!error && EditMode)
{
var terms = new List <string>();
var definitions = new List <string>();
foreach (var termDef in TermsDefinitions)
{
terms.Add(termDef.Term);
definitions.Add(termDef.Definition);
}
var setToUpdate = new UpdateSet()
{
Definitions = definitions.ToArray(),
Terms = terms.ToArray(),
TermIds = TermIds.ToArray(),
Title = Title,
LangDefinitions = SelectedDefinitionLanguage.CountryCode,
LangTerms = SelectedTermLanguage.CountryCode,
Visibility = EveryoneOrMe ? Models.QuizletTypes.Uploading.Visibility.Everyone : Models.QuizletTypes.Uploading.Visibility.OnlyMe,
};
var result = await _quizletApi.UpdateSet(setToUpdate, SetId);
if (result)
{
await SaveCreatedOrUpdatedSets();
NavigationService.Navigate(typeof(Views.MySetsPage));
}
else
{
var dialog = new MessageDialog("Error: and error occured while creating the set.");
await dialog.ShowAsync();
}
}
}
/// <summary>
/// Handle Updates for a single object.
/// waits till expected values of properties to check are reached
/// Destroys the ObjectFilter when done.
/// </summary>
/// <param name="objmor">MOR of the Object to wait for</param>
/// <param name="filterProps">Properties list to filter</param>
/// <param name="endWaitProps">
/// Properties list to check for expected values
/// these be properties of a property in the filter properties list
/// </param>
/// <param name="expectedVals">values for properties to end the wait</param>
/// <returns>true indicating expected values were met, and false otherwise</returns>
public object[] WaitForValues(
ManagedObjectReference objmor, string[] filterProps,
string[] endWaitProps, object[][] expectedVals
)
{
// version string is initially null
string version = "";
object[] endVals = new object[endWaitProps.Length];
object[] filterVals = new object[filterProps.Length];
PropertyFilterSpec spec = new PropertyFilterSpec();
spec.objectSet = new ObjectSpec[] { new ObjectSpec() };
spec.objectSet[0].obj = objmor;
spec.propSet = new PropertySpec[] { new PropertySpec() };
spec.propSet[0].pathSet = filterProps;
spec.propSet[0].type = objmor.type;
spec.objectSet[0].selectSet = null;
spec.objectSet[0].skip = false;
spec.objectSet[0].skipSpecified = true;
ManagedObjectReference filterSpecRef =
_connection.Service.CreateFilter(
_connection.PropCol, spec, true
);
bool reached = false;
UpdateSet updateset = null;
PropertyFilterUpdate[] filtupary = null;
PropertyFilterUpdate filtup = null;
ObjectUpdate[] objupary = null;
ObjectUpdate objup = null;
PropertyChange[] propchgary = null;
PropertyChange propchg = null;
while (!reached)
{
updateset =
_connection.Service.WaitForUpdates(
_connection.PropCol, version
);
version = updateset.version;
if (updateset == null || updateset.filterSet == null)
{
continue;
}
// Make this code more general purpose when PropCol changes later.
filtupary = updateset.filterSet;
filtup = null;
for (int fi = 0; fi < filtupary.Length; fi++)
{
filtup = filtupary[fi];
objupary = filtup.objectSet;
objup = null;
propchgary = null;
for (int oi = 0; oi < objupary.Length; oi++)
{
objup = objupary[oi];
// TODO: Handle all "kind"s of updates.
if (objup.kind == ObjectUpdateKind.modify ||
objup.kind == ObjectUpdateKind.enter ||
objup.kind == ObjectUpdateKind.leave
)
{
propchgary = objup.changeSet;
for (int ci = 0; ci < propchgary.Length; ci++)
{
propchg = propchgary[ci];
UpdateValues(endWaitProps, endVals, propchg);
UpdateValues(filterProps, filterVals, propchg);
}
}
}
}
object expctdval = null;
// Check if the expected values have been reached and exit the loop if done.
// Also exit the WaitForUpdates loop if this is the case.
for (int chgi = 0; chgi < endVals.Length && !reached; chgi++)
{
for (int vali = 0; vali < expectedVals[chgi].Length && !reached; vali++)
{
expctdval = expectedVals[chgi][vali];
reached = expctdval.Equals(endVals[chgi]) || reached;
}
}
}
// Destroy the filter when we are done.
_connection.Service.DestroyPropertyFilter(filterSpecRef);
return(filterVals);
}
