protected virtual void OnEnable()
{
stamp = new Stamp();
wave = new Wave2D();
currCameraData = default;
validator.Reset();
validator.SetCheckers(() => !transform.hasChanged && currCameraData.Equals(GetCamera()));
validator.Validation += () => {
currCameraData = GetCamera();
if (GetCamera() == null)
{
return;
}
Vector2Int reqSize = GetResolution();
wave.SetSize(reqSize.x, reqSize.y);
wave.SetBoundary(data.boundary);
wave.Params = data.paramset;
transform.hasChanged = false;
Debug.Log($"{wave}");
};
validator.Validated += () => {
Validated?.Invoke();
};
}
/// <summary>
/// Runs the validation process.
/// </summary>
public ValidationStatus Validate()
{
var handler = Validator;
if (handler != null)
{
Validating?.Invoke();
var args = new ValidatorEventArgs(value);
handler(args);
if (Status != args.Status)
{
Status = args.Status;
if (args.Status == ValidationStatus.Success)
{
ValidationSucceeded?.Invoke(new ValidationSucceededEventArgs());
}
else if (args.Status == ValidationStatus.Error)
{
ValidationFailed?.Invoke(new ValidationFailedEventArgs(args.ErrorText));
}
Validated?.Invoke(new ValidatedEventArgs(Status, args.ErrorText));
StateHasChanged();
}
}
return(Status);
}
//-------------------------------------------------------------------------------
//-------------------------------------------------------------------------------
internal XbrlFragment(XbrlDocument ParentDocument, INamespaceManager namespaceManager, INode XbrlRootNode)
{
this.Document = ParentDocument;
this.NamespaceManager = namespaceManager;
this.XbrlRootNode = XbrlRootNode;
this.Schemas = new XbrlSchemaCollection();
this.ValidationErrors = new List <ValidationError>();
CreateNamespaceManager();
//---------------------------------------------------------------------------
// Load.
//---------------------------------------------------------------------------
ReadSchemaLocationAttributes();
ReadLinkbaseReferences();
ReadTaxonomySchemaReferences();
ReadRoleReferences();
ReadArcroleReferences();
ReadContexts();
ReadUnits();
ReadFacts();
ReadFootnoteLinks();
Loaded?.Invoke(this, null);
//---------------------------------------------------------------------------
// Validate.
//---------------------------------------------------------------------------
var validator = new Xbrl2Dot1Validator();
validator.Validate(this);
Validated?.Invoke(this, null);
}
/// <summary>
/// Clears the validation status.
/// </summary>
public void Clear()
{
Status = ValidationStatus.None;
Validated?.Invoke(new ValidatedEventArgs(Status, string.Empty));
StateHasChanged();
}
/// <summary>
/// Runs the validation process.
/// </summary>
public ValidationStatus Validate()
{
if (UsePattern && patternRegex != null)
{
var matchStatus = patternRegex.IsMatch(value?.ToString() ?? string.Empty)
? ValidationStatus.Success
: ValidationStatus.Error;
if (Status != matchStatus)
{
Status = matchStatus;
if (matchStatus == ValidationStatus.Success)
{
ValidationSucceeded?.Invoke(new ValidationSucceededEventArgs());
}
else if (matchStatus == ValidationStatus.Error)
{
ValidationFailed?.Invoke(new ValidationFailedEventArgs(null));
}
Validated?.Invoke(new ValidatedEventArgs(Status, null));
StateHasChanged();
}
}
else
{
var handler = Validator;
if (handler != null)
{
Validating?.Invoke();
var args = new ValidatorEventArgs(value);
handler(args);
if (Status != args.Status)
{
Status = args.Status;
if (args.Status == ValidationStatus.Success)
{
ValidationSucceeded?.Invoke(new ValidationSucceededEventArgs());
}
else if (args.Status == ValidationStatus.Error)
{
ValidationFailed?.Invoke(new ValidationFailedEventArgs(args.ErrorText));
}
Validated?.Invoke(new ValidatedEventArgs(Status, args.ErrorText));
StateHasChanged();
}
}
}
return(Status);
}
private async Task ValidateAsync()
{
if (IsValidating)
{
return;
}
IsValidating = true;
await Task.Run(() =>
{
try
{
ValidateUnknown();
ValidateRootProperties();
ValidateSections();
Validated?.Invoke(this, EventArgs.Empty);
}
catch (Exception ex)
{
Telemetry.TrackException("Validate", ex);
}
finally
{
_hasChanged = false;
IsValidating = false;
}
});
}
public void OnValidated(IEnumerable <IValidationResult> results)
{
IEnumerable <IValidationResult> reValidatedResults = _tracker.Validate(ValidationResults);
ValidationResults.Clear();
ValidationResults.UnionWith(reValidatedResults);
ValidationResults.UnionWith(results);
Validated?.Invoke(this, new DataEventArgs <IEnumerable <IValidationResult> >(ValidationResults));
}
private void ParticleSystemTest_Destroyed(GameObject go)
{
systems.Remove(go);
if (systems.Count == 0)
{
Validated?.Invoke(this);
}
}
private async void ValidatePin()
{
var pd = await ProgressDialog.Show("Validating you Transaction PIN...please wait!");
string endpoint = "Switch/TPin";
string url = BaseURL + endpoint;
var encrypted = _crypto.Encrypt(Pin);
var tpinModel = new TransactionPinModel()
{
UserID = GlobalStaticFields.Customer.Email,
TransactionPIN = encrypted
};
try
{
var apirequest = new ApiRequest();
var response = await apirequest.Post(tpinModel, "", BaseURL, endpoint, "TransactionPinPage");
if (response.StatusCode == HttpStatusCode.OK)
{
await pd.Dismiss();
var jsonString = await response.Content.ReadAsStringAsync();
bool isValid = false;
bool.TryParse(jsonString, out isValid);
if (isValid)
{
Validated?.Invoke(this, isValid);
await Navigation.PopAsync();
}
else
{
Pin = string.Empty;
UpdateDots(0);
MessageDialog.Show("Transaction Pin", "Wrong Transaction Pin, please verify and try again.", DialogType.Error, "OK", null);
}
}
else
{
await pd.Dismiss();
MessageDialog.Show("Transaction Pin", "Error validating Transaction Pin, please try again later.", DialogType.Error, "OK", null);
await BusinessLogic.Log(response.StatusCode.ToString(), "Response Code is not OK while getting validating Transaction Pin", url, "", response.ToString(), "TransactionPinPage");
}
}
catch (Exception ex)
{
await pd.Dismiss();
MessageDialog.Show("Transaction Pin", "Error validating Transaction Pin, please try again later.", DialogType.Error, "OK", null);
await BusinessLogic.Log(ex.ToString(), "Exception while getting card limits", url, "", "", "TransactionPinPage");
}
}
// Events appling
internal void ApplyEvent(Event @event)
{
Applying?.Invoke(this, new EventArgs <Event>(@event));
Validate(@event);
Validated?.Invoke(this, new EventArgs <Event>(@event));
Handle(@event);
Handled?.Invoke(this, new EventArgs <Event>(@event));
pendingEvents.Push(@event);
Pendent?.Invoke(this, new EventArgs <Event>(@event));
}
public string Validate()
{
string output = inputText.ToString();
cursorIndex = 0;
cursorPosition.X = 0;
Clear();
Validated?.Invoke(output.Trim(), this);
return(output);
}
public void Validate(decimal balance)
{
if (balance > _top)
{
Validated?.Invoke(this, new AccountArgs {
Message = "Try opening a savings account"
});
}
else if (balance < 0)
{
Validated?.Invoke(this, new AccountArgs {
Message = "You are going overdrawn"
});
}
}
public virtual ViewModelResult Validate()
{
if (Rules == null)
{
return(null);
}
Rules.Target = this;
var result = Rules.Validate().FirstOrDefault();
ValidationResult = result;
Validated?.Invoke(this, result);
return(result);
}
private async void DocumentParsedAsync(object sender, EventArgs e)
{
if (!EditorConfigPackage.ValidationOptions.EnableValidation)
{
// Don't run the logic unless the user changed the settings since last run
if (_prevEnabled != EditorConfigPackage.ValidationOptions.EnableValidation)
{
ClearAllErrors();
Validated?.Invoke(this, EventArgs.Empty);
}
}
else
{
await RequestValidationAsync(false);
}
_prevEnabled = EditorConfigPackage.ValidationOptions.EnableValidation;
}
public virtual NetworkValidationResult ValidateLicense()
{
var networkValidationResult = new NetworkValidationResult();
var license = _licenseService.CurrentLicense;
if (license == null)
{
return(networkValidationResult);
}
networkValidationResult.MaximumConcurrentUsers = license.GetMaximumConcurrentLicenses();
Log.Info("Checking for other licenses, maximum number of concurrent users allowed is '{0}'", networkValidationResult.MaximumConcurrentUsers);
try
{
CreateLicenseListeningSockets();
var timeout = SearchTimeout.TotalMilliseconds > 0 ? (int)SearchTimeout.TotalMilliseconds : 2000;
var licenseUsages = new List <NetworkLicenseUsage>();
foreach (var ipAddress in GetIpAddresses())
{
var usages = BroadcastMessage(ipAddress, license.Signature, timeout);
licenseUsages.AddRange(usages);
}
networkValidationResult.CurrentUsers.AddRange(licenseUsages.GroupBy(x => x.ComputerId).Select(group => group.First()));
Log.Debug("Found {0}", networkValidationResult);
Validated?.Invoke(this, new NetworkValidatedEventArgs(networkValidationResult));
}
catch (Exception ex)
{
Log.Error(ex, "Failed to check for maximum number of concurrent users");
}
return(networkValidationResult);
}
void OnValidate()
{
noiseLayers = Mathf.Clamp(noiseLayers, 1, 16);
if (noiseScale.x == 0 || noiseScale.y == 0 || noiseScale.z == 0)
{
return;
}
Validated?.Invoke();
if (CombinedVoxelMesh.instances.Count > 0)
{
CombinedVoxelMesh inst = CombinedVoxelMesh.instances[0];
if (coro != null)
{
inst.StopCoroutine(coro);
coro = null;
}
coro = inst.StartCoroutine(InspectorRegen());
}
}
/// <summary>
/// Runs the validation process.
/// </summary>
public ValidationStatus Validate()
{
var handler = Validator;
//Status = ValidationStatus.None;
if (handler != null)
{
Validating?.Invoke();
var args = new ValidatorEventArgs(value);
handler(args);
if (Status != args.Status)
{
Status = args.Status;
if (args.Status == ValidationStatus.Success)
{
ValidationSucceeded?.Invoke(new ValidationSucceededEventArgs());
}
else if (args.Status == ValidationStatus.Error)
{
ValidationFailed?.Invoke(new ValidationFailedEventArgs(args.ErrorText));
}
Validated?.Invoke(new ValidatedEventArgs(Status, args.ErrorText));
StateHasChanged();
}
}
// force the reload of all child components
//StateHasChanged();
return(Status);
}
protected internal virtual void OnValidated(EventArgs e)
{
Validated?.Invoke(this, e);
}
private void NotifyValidated() => Validated?.Invoke();
/// <summary>
/// Called after the validation operation is completed
/// </summary>
protected void OnValidated(ValidationResult res)
{
Validated?.Invoke(this, res);
}
private void Validate_OnClick(object sender, RoutedEventArgs e) => Validated?.Invoke(this, EventArgs.Empty);
private void RaiseValidated(IEnumerable <IValidationResult> validationResults)
{
Validated?.Invoke(this, new DataEventArgs <IEnumerable <IValidationResult> >(validationResults));
}
private void Edit_Validated(object sender, EventArgs e)
{
Validated?.Invoke(this, e);
}
