public FormEntity()
{
InitializeComponent();
tbName.TextChanged += (s, e) => NameChanged.RaiseEventEx(this);
buttonCreateTable.Click += (s, e) => CreateNewTableFromEntity.RaiseEventEx(this);
buttonRemoveEntity.Click += (s, e) => RemoveEntity.RaiseEventEx(this);
buttonNewProperty.Click += (s, e) => AddNewProperty.RaiseEventEx(this);
throw new NotImplementedException("TODO: ddiscriminator stuff");
//comboBoxDiscriminatorColumn.SelectedIndexChanged += (s, e) => RecalculateDiscriminator();
//comboBoxDiscriminatorOperation.SelectedIndexChanged += (s, e) => RecalculateDiscriminator();
//textBoxDiscriminatorValue.TextChanged += (s, e) => RecalculateDiscriminator();
buttonClearDiscriminator.Click += buttonClearDiscriminator_Click;
comboBoxParentEntity.SelectedIndexChanged += comboBoxParentEntity_SelectedIndexChanged;
comboBoxParentEntity.DropDownStyle = ComboBoxStyle.DropDownList;
using (Stream editImageStream = GetType().Assembly.GetManifestResourceStream("ArchAngel.Providers.EntityModel.Resources.edit_16_h.png"))
{
if (editImageStream == null)
{
return;
}
editImage = Image.FromStream(editImageStream);
}
}
/// <summary>
/// Invoke the Changed event; called whenever list changes
/// </summary>
/// <param name="oldName"></param>
protected virtual void OnChanged(String oldName)
{
if (!this.Name.Equals(oldName))
{
NameChanged?.Invoke(this, oldName);
}
}
public bool SetName(string newName, bool force = false)
{
string oldName = Name;
if (!force)
{
if (oldName == newName)
{
NameChanged?.Invoke(oldName, newName);
return(true);
}
if (string.IsNullOrEmpty(newName) || OwnerFile.itemDict.ContainsKey(newName))
{
return(false);
}
if (!string.IsNullOrEmpty(oldName) && OwnerFile.itemDict.ContainsKey(oldName))
{
OwnerFile.itemDict.Remove(oldName);
}
}
OwnerFile.itemDict.Add(newName, this);
Name = newName;
NameChanged?.Invoke(oldName, newName);
return(true);
}
private void TextBoxName_EnterPressed(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Enter)
{
NameChanged?.Invoke(sender, e);
}
}
public void can_apply_name_changes()
{
//given
var user1 = new UserRegistered(Guid.NewGuid(), "Mike", "smith", "*****@*****.**");
var user2 = new UserRegistered(Guid.NewGuid(), "Robert", "Jones", "*****@*****.**");
var user3 = new UserRegistered(Guid.NewGuid(), "Ben", "smith", "*****@*****.**");
var nameChange = new NameChanged(user2.UserId, "John", "Doe");
var usersRM = new RegisteredUsers(() => null, null);
//when
usersRM.Apply(user1);
usersRM.Apply(user2);
usersRM.Apply(user3);
usersRM.Apply(nameChange);
//then
var displayNames = usersRM.Current;
Assert.Collection(
displayNames,
displayName => {
Assert.Equal(user1.UserId, displayName.UserId);
Assert.Equal($"{user1.LastName}, {user1.FirstName}", displayName.DisplayName);
},
displayName => {
Assert.Equal(user2.UserId, displayName.UserId);
Assert.Equal($"{nameChange.LastName}, {nameChange.FirstName}", displayName.DisplayName);
},
displayName => {
Assert.Equal(user3.UserId, displayName.UserId);
Assert.Equal($"{user3.LastName}, {user3.FirstName}", displayName.DisplayName);
});
}
public void Handle(NameChanged e)
{
_elastic.Update <Responses.Index, Object>(x => x.
Id(e.AccountId)
.Doc(new { Name = e.Name })
.RetryOnConflict(3)
.Refresh()
);
var results = _elastic.Search <Responses.Index>(x => x
.Query(q => q.Term(t => t.ParentId, e.AccountId)));
foreach (var result in results.Documents.Select(x => x.Id))
{
_elastic.Update <Responses.Index, Object>(x => x
.Id(result)
.Doc(new { Parent = e.Name })
.RetryOnConflict(3)
.Refresh()
);
}
var index = _elastic.Get <Responses.Index>(e.AccountId);
_manager.PublishAll(results.Documents);
_manager.Publish(index.Source);
}
private void TextBox1_LostFocus(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(textBox.Text))
{
textBox.Text = "Name";
label1.Text = "Name";
}
var text = textBox.Text.Trim(' ');
TextBox_TextChanged(this, null);
var nvc = Parent as NetworkViewControl;
if (nvc != null)
{
if (nvc.NameExists(text))
{
textBox.Text = label1.Text;
return;
}
}
textBox.Text = text;
label1.Text = text;
NameChanged?.Invoke(parentElement.Name, textBox.Text);
parentElement.Name = textBox.Text;
}
public void PreLoadUserData()
{
var userId = Guid.NewGuid();
var registered = new UserRegistered(
userId,
"Mike",
"Jones",
"*****@*****.**");
var namechange = new NameChanged(
userId,
"Micheal",
"Jones");
var eventData = new[] {
new EventData(
Guid.NewGuid(),
nameof(UserRegistered),
true,
Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(registered)),
null),
new EventData(
Guid.NewGuid(),
nameof(NameChanged),
true,
Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(namechange)),
null),
};
var stream = $"user-{userId}";
// conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, eventData).Wait();
}
private void ModelSystemModel_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (sender == ModelSystemModel && e.PropertyName == "Name")
{
NameChanged?.Invoke(this, e);
}
}
public void MergeFrom(CounterEvent other)
{
if (other == null)
{
return;
}
if (other.Id.Length != 0)
{
Id = other.Id;
}
if (other.Version != 0UL)
{
Version = other.Version;
}
switch (other.EventCase)
{
case EventOneofCase.Added:
if (Added == null)
{
Added = new global::CounterAdded();
}
Added.MergeFrom(other.Added);
break;
case EventOneofCase.Decremented:
if (Decremented == null)
{
Decremented = new global::CounterDecremented();
}
Decremented.MergeFrom(other.Decremented);
break;
case EventOneofCase.Incremented:
if (Incremented == null)
{
Incremented = new global::CounterIncremented();
}
Incremented.MergeFrom(other.Incremented);
break;
case EventOneofCase.NameChanged:
if (NameChanged == null)
{
NameChanged = new global::CounterNameChanged();
}
NameChanged.MergeFrom(other.NameChanged);
break;
case EventOneofCase.Removed:
if (Removed == null)
{
Removed = new global::CounterRemoved();
}
Removed.MergeFrom(other.Removed);
break;
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
private void NameTextBox_Leave(object sender, EventArgs e)
{
if (CurrentAsset != null)
{
CurrentAsset.Name = NameTextBox.Text;
NameChanged?.Invoke(this, CurrentAsset);
}
}
public void FireNameChanged()
{
if (parent_ != null)
{
parent_.FireModifierNameChanged(Modifier);
}
NameChanged?.Invoke(Modifier);
}
public void Handle(NameChanged e)
{
_elastic.Update <Responses.Index, Object>(x => x
.Id(e.AccountTypeId)
.Doc(new { Name = e.Name })
.RetryOnConflict(3)
.Refresh()
);
}
protected virtual void OnNameChanged()
{
if (_setting)
{
return;
}
PropertyName = GetName();
NameChanged?.Invoke(this, PropertyName);
}
public async Task Handle(NameChanged e, IMessageHandlerContext ctx)
{
var get = await _uow.Get <presentationUsers.Models.AuUserResponse>(e.UserId);
get.Name = e.Name;
_uow.Save(get);
ctx.Update(get, ChangeType.Change);
}
public async Task Handle(NameChanged e, IHandleContext ctx)
{
var get = await _uow.Get <presentationUsers.Models.AU_UserResponse>(e.UserId);
get.Name = e.Name;
_uow.Save(get);
ctx.UpdateAsync(get, ChangeType.CHANGE);
}
private void OnNameChanged(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(FullName))
{
throw new MochaException("At least one of the names and extensions must not be empty!");
}
//Invoke.
NameChanged?.Invoke(this, new EventArgs());
}
public bool TryNameChange(string newName)
{
try {
NameChanged?.Invoke(this, newName);
Name = newName;
return(true);
} catch (Exception e) {
SetError(e.Message);
return(false);
}
}
protected async Task SetUsernameAsync(string name)
{
await NameChanging.InvokeAsync(name);
if (!string.IsNullOrEmpty(name))
{
await Identity.SetUsernameAsync(name);
await NameChanged.InvokeAsync(name);
}
}
protected virtual void OnNameChanged(string oldFirstName, string oldLastName)
{
NameChanged?.Invoke(this,
new NameChangeEventArgs()
{
OldFirstName = oldFirstName,
OldLastName = oldLastName,
NewFirstName = FirstName,
NewLastName = LastName
});
}
public void Handle(NameChanged e)
{
using (var session = _store.OpenSession())
{
var get = session.Load <Responses.Get>(e.CurrencyId);
get.Name = e.Name;
session.SaveChanges();
_manager.Publish(get);
}
}
public void Handle(NameChanged e)
{
using (IDocumentSession session = _store.OpenSession())
{
var user = session.Load <User>(e.UserId);
user.Name = e.Name;
session.Store(user);
session.SaveChanges();
}
}
public MainView()
{
InitializeComponent();
button1.Click += (sender, args) => AddDate?.Invoke(this, EventArgs.Empty);
button2.Click += (sender, args) => ShowDetails?.Invoke(this, EventArgs.Empty);
textBox1.TextChanged += (sender, args) =>
{
textBox1.DataBindings[0].WriteValue();
NameChanged?.Invoke(this, EventArgs.Empty);
};
}
public void Handle(NameChanged e)
{
_elastic.Update <Responses.Index, Object>(x => x
.Id(e.CurrencyId)
.Doc(new { Name = e.Name })
.RetryOnConflict(3)
.Refresh()
);
var index = _elastic.Get <Responses.Index>(e.CurrencyId);
_manager.Publish(index.Source);
}
public override void LoadSettingsFromStorage()
{
Debug.WriteLine("LoadSettingsFromStorage");
vm.Load();
base.LoadSettingsFromStorage();
if (saved)
{
NameChanged?.Invoke(this, new TabNameEventArgs(GetNames()));
saved = false;
}
}
public void TestInCSharp()
{
var eventA = new NameChanged {
EntityName = "1234", Name = "Bob", OccurredOn = DateTime.UtcNow
};
var eventB = new NameChanged {
EntityName = "1234", Name = "Jimmy", OccurredOn = DateTime.UtcNow.AddDays(1)
};
var markovA = MarkovEvent.Build("NameChanged", eventA, eventA.OccurredOn);
var markovB = MarkovEvent.Build("NameChanged", eventB, eventB.OccurredOn);
var trunk = new Trunk();
var braidDiscriminators = new BraidLinkDiscriminators();
braidDiscriminators.AddDiscriminator(x => BraidLinkDiscriminationResult.ISaidYes);
var chainLongitudinalEvaluators = LongitudinalEvaluators.Build();
chainLongitudinalEvaluators.AddEvaluator(LongitudinalEvaluator.Build("Identity", () => JsonConvert.SerializeObject(0), (a, s) =>
{
var state = JsonConvert.DeserializeObject <int>(s);
Console.WriteLine(state);
state++;
s = JsonConvert.SerializeObject(state);
var result = new EvaluationResult();
result.Value.X = JsonConvert.SerializeObject(a);
result.Value.Y = JsonConvert.SerializeObject(a.OccurredOn);
result.State = s;
return(result);
}, (a, b, e, s) => JsonConvert.SerializeObject(a.OccurredOn - b.OccurredOn)));
var chainBuilder = ChainBuilder.Build(x => ChainIdentity.Build(x.Payload["EntityName"].ToString()), chainLongitudinalEvaluators);
var braidBuilder = BraidBuilder.Build("Initial", braidDiscriminators, chainBuilder, LongitudinalEvaluators.Build());
trunk.AddBraid(braidBuilder);
trunk.Accept(markovA);
trunk.Accept(markovB);
}
private void ModelSystemModel_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (sender == ModelSystemModel)
{
switch (e.PropertyName)
{
case "Name":
NameChanged?.Invoke(this, e);
break;
case "Root":
ProjectWasExternallySaved?.Invoke(this, new ProjectWasExternallySavedEventArgs(this.ModelSystemModel));
break;
}
}
}
private void Apply(NameChanged @event)
{
try {
foreach (var user in Model)
{
if (user.UserId == @event.UserId)
{
user.DisplayName = $"{@event.LastName}, {@event.FirstName}";
break;
}
}
}
catch (Exception) {
// read models don't throw
}
}
private void SetCommand(ICommand command)
{
if (ReferenceEquals(_command, command))
{
return;
}
if (_command != null)
{
_command.NameChanged -= OnCommandNameChanged;
_command.CanExecuteChanged -= OnCommandCanExecuteChanged;
}
_command = command;
_command.NameChanged += OnCommandNameChanged;
_command.CanExecuteChanged += OnCommandCanExecuteChanged;
NameChanged?.Invoke(this, EventArgs.Empty);
CanExecuteChanged?.Invoke(this, EventArgs.Empty);
}
void IBMDSwitcherInputCallback.Notify(_BMDSwitcherInputEventType eventType)
{
switch (eventType)
{
case _BMDSwitcherInputEventType.bmdSwitcherInputEventTypeLongNameChanged:
NameChanged?.Invoke(this, null);
break;
case _BMDSwitcherInputEventType.bmdSwitcherInputEventTypeIsProgramTalliedChanged:
ProgramChanged?.Invoke(this, null);
break;
case _BMDSwitcherInputEventType.bmdSwitcherInputEventTypeIsPreviewTalliedChanged:
PreviewChanged?.Invoke(this, null);
break;
}
}
private void Apply(NameChanged e)
{
Name = new CustomerName(e.CustomerName);
}
