public async Task ExecuteAsync()
{
if (Validate())
{
ChangePasswordResponse response = await Api.ChangePasswordAsync(new ChangePasswordRequest(Current, New));
if (response.IsSuccess)
{
Current = null;
New = null;
ConfirmNew = null;
IsChanged = true;
StateHasChanged();
await Task.Delay(2 * 1000);
Hide();
IsChanged = false;
StateHasChanged();
}
else
{
ErrorMessages.AddRange(response.ErrorMessages);
}
}
}
public void AddErrors(List <string> messages)
{
if (ErrorMessages is null)
{
ErrorMessages = new List <string>();
}
ErrorMessages.AddRange(messages);
}
public ErrorResponse(List <string> errorMessages)
{
if (errorMessages == null)
{
return;
}
ErrorMessages.AddRange(errorMessages);
}
public RulesExceptionDto(RulesException rulesException) : this()
{
Data = rulesException.Data;
Errors = rulesException.GetErrorDictionary();
if (!string.IsNullOrEmpty(rulesException.ErrorMessage))
{
ErrorMessages.Add(rulesException.ErrorMessage);
}
ErrorMessages.AddRange(rulesException.ErrorMessages);
}
public override void SetInputErrorMessages()
{
if (Name.IsEmpty())
{
NameInput.ErrorMessage.Add("name_required_error_message");
ErrorMessages.AddRange(NameInput.ErrorMessage);
}
if (Project.IsEmpty())
{
ProjectInput.ErrorMessage.Add("project_required_error_message");
ErrorMessages.AddRange(ProjectInput.ErrorMessage);
}
}
public override void SetInputErrorMessages()
{
if (Name.IsEmpty())
{
NameInput.ErrorMessage.Add("name_required_error_message");
ErrorMessages.AddRange(NameInput.ErrorMessage);
}
if (Url.IsNotEmpty() &&
Url.IsNotUrl())
{
UrlInput.ErrorMessage.Add("url_is_not_valid_error_message");
ErrorMessages.AddRange(UrlInput.ErrorMessage);
}
}
public async Task ExecuteAsync(UserProfileDto userProfile)
{
var errors = UserProfileValidator.ValidateUserProfile(userProfile);
if (errors.Count > 0)
{
ErrorMessages.AddRange(errors);
return;
}
var currencies = await _currencyRepository.ListAllAsync();
var user = UserTranslator.ToDomain(userProfile, currencies);
await _userRepository.AddAsync(user);
this.SuccessMessage = string.Format(SuccessMessages.USER_REGISTRATION_SUCCESS, user.FirstName, user.Id.ToString());
}
public override bool Validate(T itemToValidate)
{
var inValidState = true;
foreach (var validator in Validators)
{
var wasValid = validator.Validate(itemToValidate);
if (wasValid == false)
{
inValidState = wasValid;
ErrorMessages.AddRange(validator.ErrorMessages);
}
}
return(inValidState);
}
public async Task ExecuteAsync(CurrencyExchangeDto currencyExchangeDto)
{
_currencies = await _currencyRepository.ListAllAsync();
var errors = CurrencyExchangeValidator.ValidateCurrencyExchange(currencyExchangeDto, _currencies);
if (errors.Count > 0)
{
ErrorMessages.AddRange(errors);
return;
}
var currencyExchange = CurrencyExchangeTranslator.ToDomain(currencyExchangeDto, _currencies);
await _currencyExchangeRepository.AddAsync(currencyExchange);
this.SuccessMessage = string.Format(SuccessMessages.CURRENCY_EXCHANGE_POST_SUCCESS);
}
public override void SetInputErrorMessages()
{
if (Email.IsEmpty())
{
EmailInput.ErrorMessage.Add("email_required_error_message");
ErrorMessages.AddRange(EmailInput.ErrorMessage);
}
if (Email.IsNotEmail())
{
EmailInput.ErrorMessage.Add("email_is_not_valid_error_message");
ErrorMessages.AddRange(EmailInput.ErrorMessage);
}
if (FirstName.IsEmpty())
{
FirstNameInput.ErrorMessage.Add("first_name_required_error_message");
ErrorMessages.AddRange(FirstNameInput.ErrorMessage);
}
if (LastName.IsEmpty())
{
LastNameInput.ErrorMessage.Add("last_name_required_error_message");
ErrorMessages.AddRange(LastNameInput.ErrorMessage);
}
if (OrganizationName.IsEmpty())
{
OrganizationNameInput.ErrorMessage.Add("organization_name_required_error_message");
ErrorMessages.AddRange(OrganizationNameInput.ErrorMessage);
}
if (Password.IsNotValidPassword())
{
OrganizationNameInput.ErrorMessage.Add("password_is_not_valid_error_message");
ErrorMessages.AddRange(OrganizationNameInput.ErrorMessage);
}
if (!IsTermsAccepted)
{
OrganizationNameInput.ErrorMessage.Add("you_must_accept_terms_error_message");
ErrorMessages.AddRange(OrganizationNameInput.ErrorMessage);
}
}
public void MergeResponse(LoggingResponse response)
{
if (response.HasLogMessages)
{
LogMessages.AddRange(response.LogMessages);
}
if (response.HasWarningMessages)
{
WarningMessages.AddRange(response.WarningMessages);
}
if (response.HasErrorMessages)
{
ErrorMessages.AddRange(response.ErrorMessages);
}
if (response.HasExceptionMessages)
{
ExceptionMessages.AddRange(response.ExceptionMessages);
}
}
protected override void OnExit(ExitEventArgs e)
{
var messages = new ErrorMessages();
if (Globals.CurrentExceptionsCollection.Count > 0)
{
messages.AddRange(
Globals.CurrentExceptionsCollection.Select(exception => new ErrorMessage
(exception, Assembly.GetExecutingAssembly())
{
CurrentUser = Globals.MainUser.UserName,
UsesWebservice = Globals.MainUser.WebserviceUsed
}));
messages.WriteExceptions2File(null, true);
}
base.OnExit(e);
Component.Dispose();
}
public async Task RegisterAsync()
{
RegisterResponse response = await Api.RegisterAsync(new RegisterRequest(UserName, Password));
if (response.IsSuccess)
{
if (await UserState.LoginAsync(UserName, Password))
{
Navigator.OpenTimeline();
}
UserName = null;
Password = null;
}
else
{
ErrorMessages.AddRange(response.ErrorMessages);
}
}
public override void SetInputErrorMessages()
{
if (Label.IsEmpty())
{
LabelInput.ErrorMessage.Add("name_required_error_message");
ErrorMessages.AddRange(LabelInput.ErrorMessage);
}
if (Language.IsEmpty())
{
LanguageInput.ErrorMessage.Add("language_required_error_message");
ErrorMessages.AddRange(LanguageInput.ErrorMessage);
}
if (LabelTranslation.IsEmpty())
{
LabelTranslationInput.ErrorMessage.Add("label_translation_required_error_message");
ErrorMessages.AddRange(LabelTranslationInput.ErrorMessage);
}
}
public bool Validate()
{
bool valid = true;
ErrorMessages.Clear();
IList <string> messages;
var obj = Token as JObject;
if (!obj.IsValid(Schema, out messages))
{
ErrorMessages.AddRange(messages.Select(x => ValidationErrorMessage.Parse(x)));
valid = false;
}
;
OnValidated?.Invoke(this, EventArgs.Empty);
return(valid);
}
public override void SetInputErrorMessages()
{
if (Name.IsEmpty())
{
NameInput.ErrorMessage.Add("name_required_error_message");
ErrorMessages.AddRange(NameInput.ErrorMessage);
}
if (IsoCode2.IsEmpty())
{
IsoCode2Input.ErrorMessage.Add("iso_code_2_required_error_message");
ErrorMessages.AddRange(IsoCode2Input.ErrorMessage);
}
if (IsoCode3.IsEmpty())
{
IsoCode3Input.ErrorMessage.Add("iso_code_3_required_error_message");
ErrorMessages.AddRange(IsoCode3Input.ErrorMessage);
}
}
/// <summary>
/// Triggers the workflows.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="triggerType">Type of the trigger.</param>
/// <param name="personId">The person id.</param>
/// <returns></returns>
private bool TriggerWorkflows(IEntity entity, WorkflowTriggerType triggerType, int?personId)
{
foreach (var trigger in TriggerCache.Instance.Triggers(entity.TypeName, triggerType))
{
if (triggerType == WorkflowTriggerType.PreSave || triggerType == WorkflowTriggerType.PreDelete)
{
var workflowTypeService = new WorkflowTypeService();
var workflowType = workflowTypeService.Get(trigger.WorkflowTypeId);
if (workflowType != null)
{
var workflow = Rock.Model.Workflow.Activate(workflowType, trigger.WorkflowName);
List <string> workflowErrors;
if (!workflow.Process(entity.Dto, out workflowErrors))
{
ErrorMessages.AddRange(workflowErrors);
return(false);
}
else
{
if (workflowType.IsPersisted)
{
var workflowService = new Rock.Model.WorkflowService();
workflowService.Add(workflow, personId);
workflowService.Save(workflow, personId);
}
}
}
}
else
{
var transaction = new Rock.Transactions.WorkflowTriggerTransaction();
transaction.Trigger = trigger;
transaction.Dto = entity.Dto;
transaction.PersonId = personId;
Rock.Transactions.RockQueue.TransactionQueue.Enqueue(transaction);
}
}
return(true);
}
public bool Validate(string groupName, string groupDescription)
{
if (WasAlreadyUsed)
{
Reset();
}
WasAlreadyUsed = true;
if (!_validateGroupName.Validate(groupName))
{
ErrorMessages.AddRange(_validateGroupName.GetErrorMessages());
}
if (!_validateGroupDescription.Validate(groupDescription))
{
ErrorMessages.AddRange(_validateGroupDescription.GetErrorMessages());
}
return(!ErrorMessages.Any());
}
public void AddErrorMessages(List <string> messages)
{
ErrorMessages.AddRange(messages);
IsSuccess = false;
}
public IActionResult OnPostSubmit()
{
Domain.CBS requestDirector = new Domain.CBS(Startup.ConnectionString);
if (requestDirector.FindStandingTeeTimeRequest(userManager.GetUserId(User)) != null)
{
return(Redirect("/MaxStandingTeeTimeRequest"));
}
ErrorMessages.Clear();
bool isError = false;
var errors = from error in ModelState
where (error.Key == nameof(SuppliedMemberNumbers) || error.Key == nameof(StartDate) || error.Key == nameof(EndDate)) &&
error.Value.ValidationState == Microsoft.AspNetCore.Mvc.ModelBinding.ModelValidationState.Invalid && error.Value.Errors.Any()
select error.Value.Errors;
if (errors.Any())
{
ErrorMessages.AddRange(from errorMessage in errors select errorMessage into messages from m in messages select m.ErrorMessage);
isError = true;
}
var signedInMember = userManager.FindByNameAsync(User.Identity.Name).GetAwaiter().GetResult();
requestDirector = new Domain.CBS(signedInMember.Id, Startup.ConnectionString);
StartDate = (DateTime)TempData.Peek(nameof(StartDate));
EndDate = (DateTime)TempData.Peek(nameof(EndDate));
StandingTeeTime requestedStandingTeeTime = new StandingTeeTime()
{
StartDate = StartDate, EndDate = EndDate, RequestedTime = DateTime.Parse(TempData.Peek("selectedTime").ToString())
};
SuppliedMemberNumbers = SuppliedMemberNumbers.Where(s => !string.IsNullOrEmpty(s)).ToArray();
for (int i = 0; i < SuppliedMemberNumbers.Length; i++)
{
SuppliedMemberNumbers[i] = SuppliedMemberNumbers[i].Trim();
}
var userIds = (from user in dbContext.Users where SuppliedMemberNumbers.Contains(user.MemberNumber) select user.Id).ToList();
if (userIds.Count() != SuppliedMemberNumbers.Count())
{
ErrorMessages.Add("One or more supplied member numbers do not exist");
isError = true;
}
if (SuppliedMemberNumbers.Contains(signedInMember.MemberNumber))
{
ErrorMessages.Add("Do not enter your own member number");
isError = true;
}
if (StartDate.DayOfWeek != EndDate.DayOfWeek)
{
ErrorMessages.Add($"Day of week for start date ({StartDate.DayOfWeek}) must match day of week for end date ({EndDate.DayOfWeek})");
isError = true;
}
string currentUser = userManager.GetUserId(User);
requestedStandingTeeTime.Members = userIds.Append(currentUser).ToList();
requestedStandingTeeTime.SubmittedBy = userManager.GetUserId(User);
if (isError)
{
TempData.Put(nameof(ErrorMessages), ErrorMessages);
return(Redirect(Request.Headers["Referer"]));
}
if (!requestDirector.RequestStandingTeeTime(requestedStandingTeeTime, out string message))
{
ErrorMessages.Add(message);
TempData.Put(nameof(ErrorMessages), ErrorMessages);
return(Redirect(Request.Headers["Referer"]));
}
Confirmation = true;
return(Page());
}
public virtual Result Merge(Result result)
{
ErrorMessages.AddRange(result.ErrorMessages);
InformationMessages.AddRange(result.InformationMessages);
return(this);
}
/// <summary>
/// Triggers the workflows.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="triggerType">Type of the trigger.</param>
/// <param name="personId">The person id.</param>
/// <returns></returns>
private bool TriggerWorkflows(IEntity entity, WorkflowTriggerType triggerType, int?personId)
{
Dictionary <string, PropertyInfo> properties = null;
foreach (var trigger in TriggerCache.Triggers(entity.TypeName, triggerType).Where(t => t.IsActive == true))
{
bool match = true;
if (!string.IsNullOrWhiteSpace(trigger.EntityTypeQualifierColumn))
{
if (properties == null)
{
properties = new Dictionary <string, PropertyInfo>();
foreach (PropertyInfo propertyInfo in entity.GetType().GetProperties())
{
properties.Add(propertyInfo.Name.ToLower(), propertyInfo);
}
}
match = (properties.ContainsKey(trigger.EntityTypeQualifierColumn.ToLower()) &&
properties[trigger.EntityTypeQualifierColumn.ToLower()].GetValue(entity, null).ToString()
== trigger.EntityTypeQualifierValue);
}
if (match)
{
if (triggerType == WorkflowTriggerType.PreSave || triggerType == WorkflowTriggerType.PreDelete)
{
var workflowTypeService = new WorkflowTypeService();
var workflowType = workflowTypeService.Get(trigger.WorkflowTypeId);
if (workflowType != null)
{
var workflow = Rock.Model.Workflow.Activate(workflowType, trigger.WorkflowName);
List <string> workflowErrors;
if (!workflow.Process(entity, out workflowErrors))
{
ErrorMessages.AddRange(workflowErrors);
return(false);
}
else
{
if (workflowType.IsPersisted)
{
var workflowService = new Rock.Model.WorkflowService();
workflowService.Add(workflow, personId);
workflowService.Save(workflow, personId);
}
}
}
}
else
{
var transaction = new Rock.Transactions.WorkflowTriggerTransaction();
transaction.Trigger = trigger;
transaction.Entity = entity.Clone();
transaction.PersonId = personId;
Rock.Transactions.RockQueue.TransactionQueue.Enqueue(transaction);
}
}
}
return(true);
}
public void RecordErrors(params string[] errors)
{
ErrorMessages.AddRange(errors);
}
public virtual void Merge(ServiceResult result)
{
ErrorMessages.AddRange(result.ErrorMessages);
InformationMessages.AddRange(result.InformationMessages);
}
