public ActionResult Edit([Bind(Include = "MemberID,MemberSubscriptionTypeID,FirstName,LastName,IdentityType,EmailAddress,TelephoneHome,TelephoneOffice,TelephoneMobile,CountryID,StateID,Gender,Ethnicity,DateOfBirth,ActiveIndicator,RenewalDate,AddressID,DateInserted,DateUpdated,USR")] Member member)
{
MemberValidator validator = new MemberValidator();
if (ModelState.IsValid && validator.Validate(member).IsValid)
{
db.Entry(member).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ValidationResult results = validator.Validate(member);
IList <ValidationFailure> failures = results.Errors;
StringBuilder sb = new StringBuilder();
foreach (var e in results.Errors)
{
ModelState.AddModelError(e.PropertyName + "Error", e.ErrorMessage);
sb.AppendLine(e.ErrorMessage);
}
ViewBag.CountryID = new SelectList(db.Countries, "CountryID", "CountryName", member.CountryID);
ViewBag.StateID = new SelectList(db.CountryStates, "StateID", "StateName", member.StateID);
ViewBag.AddressID = new SelectList(db.Addresses, "AddressID", "AddressType", member.AddressID);
ViewBag.MemberSubscriptionTypeID = new SelectList(db.MemberSubscriptionTypes, "MemberSubscriptionTypeID", "MemberSubscriptionTypeCode", member.MemberSubscriptionTypeID);
return(View(member));
}
public async Task <int> Create(Member newMember)
{
if (newMember is null)
{
throw new ArgumentNullException(nameof(newMember));
}
var validator = new MemberValidator();
var validationResult = await validator.ValidateAsync(newMember);
if (!validationResult.IsValid)
{
var errors = validationResult.ToString(", ");
throw new InvalidOperationException(errors);
}
var existedMember = await _membersRepository.Get(newMember.YouTubeUserId);
if (existedMember != null)
{
var updatedMember = _mapper.Map(newMember, existedMember);
updatedMember.Id = existedMember.Id;
await _membersRepository.Update(updatedMember);
return(existedMember.Id);
}
return(await _membersRepository.Add(newMember));
}
public async Task <int> Create(Member member)
{
var validator = new MemberValidator();
var validatorResult = await validator.ValidateAsync(member);
if (!validatorResult.IsValid)
{
var errros = validatorResult.ToString(", ");
throw new InvalidOperationException(errros);
}
var exisredMember = await _membersRepository.Get(member.YouTubeAccountId);
if (exisredMember is not null)
{
throw new InvalidOperationException("Member already exists");
}
var memberId = await _membersRepository.Add(member);
if (memberId != default)
{
return(memberId);
}
else
{
return(default);
public Result Edit(int id, MemberDto dto)
{
dto.Id = id;
var validator = new MemberValidator(_memberRepository);
var result = validator.ValidateResult(dto);
if (!result.Success)
{
return(result);
}
var entity = _memberRepository.AsNoTracking
.FirstOrDefault(s => s.Id == dto.Id);
if (entity == null)
{
return(new Result().SetBlankRedirect());
}
Mapper.Map <Member>(dto, entity);
if (!string.IsNullOrEmpty(dto.Password))
{
entity.Salt = SecurityHelper.GenerateSalt();
entity.Password = SecurityHelper.GenerateHash(dto.Password, entity.Salt);
}
_memberRepository.Update(entity);
_unitOfWork.Commit();
MemberCacheManager.ClearCache();
return(result.SetSuccess(Messages.RecordSaved));
}
public void SetUp()
{
_memberRepository = new Mock <IJsonRepository <Member> >();
_memberValidator = new MemberValidator();
_subscriberService = new SubscriberService();
_eventPublisher = new EventPublisher(_subscriberService);
_memberService = new MemberService(_memberRepository.Object, _memberValidator, _eventPublisher);
}
public HomeController(ILogger <HomeController> logger,
ICacheManager <MemoryCacheManager> cacheManager, ICategoryService categoryService, IMemoryCache memoryCache)
{
_logger = logger;
_memberValidator = new MemberValidator("#EditForm");
_cacheManager = cacheManager;
_categoryService = categoryService;
_memoryCache = memoryCache;
}
public void Should_AddRule_SingleRule()
{
var memberValidator = new MemberValidator();
var rule = new ValidRule<int>(c => true);
memberValidator.AddRule(rule);
Assert.Single(memberValidator.Rules);
Assert.Same(rule, memberValidator.Rules.Single());
}
public IActionResult AddMember([FromBody] Member member)
{
var validator = new MemberValidator();
if (validator.Validate(member).IsValid)
{
_memberService.AddMember(member);
return(Ok());
}
return(BadRequest());
}
public IActionResult UpdateMember([FromBody] Member member, int id)
{
var validator = new MemberValidator();
if (validator.Validate(member).IsValid)
{
member.Id = id;
_memberService.UpdateMember(member);
return(Ok());
}
return(BadRequest());
}
public void SetUp()
{
_memberRepository = new Mock <IJsonRepository <Member> >();
_accountRepository = new Mock <IJsonRepository <Account> >();
_memberValidator = new MemberValidator();
_subscriberService = new SubscriberService();
_eventPublisher = new EventPublisher(_subscriberService);
_memberService = new MemberService(_memberRepository.Object, _memberValidator, _eventPublisher);
_accountService = new AccountService(_accountRepository.Object, _memberRepository.Object);
_transactionService = new TransactionService(_accountService, _memberService);
}
public async Task <IActionResult> UpdateMember(JObject objData)
{
dynamic jsonData = objData;
StringBuilder sb = new StringBuilder();
try
{
JObject identityCard = jsonData.IdentityCard;
JObject member = jsonData.Member;
var memberM = member.ToObject <Member>();
var validatorm = new MemberValidator();
var resultv = await validatorm.ValidateAsync(memberM);
if (resultv != null)
{
sb.Append(string.Join(",", resultv));
}
var identityCardM = identityCard.ToObject <IdentityCard>();
var validatoric = new IdentityCardValidator();
var result = await validatoric.ValidateAsync(identityCardM);
if (result != null)
{
sb.Append(string.Join(",", result));
}
if (sb.Length > 0)
{
return(BadRequest("Errors: " + sb.ToString()));
}
await _discoRepository.UpdateMember(memberM, identityCardM);
return(Ok("Member updated"));
}
catch (Exception ex)
{
//log Exception
return(BadRequest());
}
}
public ActionResult Create([Bind(Include = "ASPUserId,MemberID,MemberSubscriptionTypeID,FirstName, LastName,IdentityType,EmailAddress,TelephoneHome,TelephoneOffice,TelephoneMobile,CountryID,StateID,Gender,Ethnicity,DateOfBirth,ActiveIndicator,RenewalDate,AddressID,DateInserted,DateUpdated,USR")] Member member)
{
MemberValidator validator = new MemberValidator();
if (ModelState.IsValid && validator.Validate(member).IsValid)
{
member.AddressID = -1;
member.DateInserted = DateTime.Today;
member.DateUpdated = DateTime.Today;
member.ASPUserId = User.Identity.GetUserId();
member.USR = User.Identity.GetUserName();
member.ActiveIndicator = true;
db.Members.Add(member);
try
{
db.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
System.Diagnostics.Debug.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
}
return(RedirectToAction("Index", "Home"));
}
ValidationResult results = validator.Validate(member);
IList <ValidationFailure> failures = results.Errors;
StringBuilder sb = new StringBuilder();
foreach (var e in results.Errors)
{
ModelState.AddModelError(e.PropertyName, e.ErrorMessage);
ModelState.AddModelError(e.PropertyName + "Error", e.ErrorMessage);
sb.AppendLine(e.ErrorMessage);
}
ViewBag.CountryID = new SelectList(db.Countries, "CountryID", "CountryName", member.CountryID);
ViewBag.StateID = new SelectList(db.CountryStates, "StateID", "StateName", member.StateID);
ViewBag.MemberSubscriptionTypeID = new SelectList(db.MemberSubscriptionTypes, "MemberSubscriptionTypeID", "MemberSubscriptionTypeCode", member.MemberSubscriptionTypeID);
return(View(member));
}
public async Task <MemberDto> Handle(EditMemberCommand request, CancellationToken cancellationToken)
{
var memberEntity = await _dbContext
.Members
.SingleOrDefaultAsync(m => m.MemberId == request.MemberId, cancellationToken);
if (memberEntity is null)
{
throw new NullReferenceException($"Member [memberId: {request.MemberId}] not found");
}
var memberBeforeChange = memberEntity;
var editedMember = request.Member;
editedMember.ApplyTo(memberEntity, ModelState);
memberEntity.BirthDate = BirthDayDateCalculator.ExtractFromPesel(memberEntity.Pesel);
var memberAfterChange = memberEntity;
var validator =
new MemberValidator(_dbContext, new Tuple <Member, Member>(memberBeforeChange, memberAfterChange));
var validationResult = await validator.ValidateAsync(memberEntity, cancellationToken);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors.ToList());
}
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var patchedMemberEntity = await _dbContext
.Members
.SingleOrDefaultAsync(m => m.MemberId == request.MemberId, cancellationToken);
if (patchedMemberEntity is null)
{
throw new NullReferenceException($"Failed to fetch patched membership [Id: {request.MemberId}]");
}
_editMemberSender.EditMember(patchedMemberEntity);
var patchedMemberDto = patchedMemberEntity.Adapt <MemberDto>();
return(patchedMemberDto);
}
public void Should_AddRule_MultipleRules()
{
var memberValidator = new MemberValidator();
var rule1 = new ValidRule<int>(c => true);
var rule2 = new AsRelativeRule<object>(c => true);
var rule3 = new AsModelRule<object>();
memberValidator.AddRule(rule1);
memberValidator.AddRule(rule2);
memberValidator.AddRule(rule3);
Assert.Equal(3, memberValidator.Rules.Count);
Assert.Same(rule1, memberValidator.Rules.ElementAt(0));
Assert.Same(rule2, memberValidator.Rules.ElementAt(1));
Assert.Same(rule3, memberValidator.Rules.ElementAt(2));
}
public async Task Validate_TwoMembers(bool valid, string email1, string email2)
{
using (var provider = await CreateProvider())
{
var context = provider.GetRequiredService <IContext>();
var access = provider.GetRequiredService <IContextLock>();
var worlds = provider.GetRequiredService <IWorldRepository>();
var entries = provider.GetRequiredService <IEntryRepository>();
IValidator <Member> validator = new MemberValidator(entries, worlds);
var world = new World();
using (var handle = await access.Write())
{
var one = new Member {
World = world,
Email = new EmailAddress(email1)
};
world.Members = new HashSet <Member> {
one
};
context.Add(one);
await handle.Finish();
}
using (await access.Read())
{
var two = new Member {
World = world,
Email = new EmailAddress(email2)
};
var target = new ValidationTarget <Member>(two);
validator.Validate(target);
Assert.Equal(valid, !target.GetResult().HasErrors);
}
}
}
public async Task Validate_OneMember()
{
using (var provider = await CreateProvider())
{
var access = provider.GetRequiredService <IContextLock>();
var worlds = provider.GetRequiredService <IWorldRepository>();
var entries = provider.GetRequiredService <IEntryRepository>();
IValidator <Member> validator = new MemberValidator(entries, worlds);
var member = new Member {
World = new World()
};
using (await access.Read())
{
var target = new ValidationTarget <Member>(member);
validator.Validate(target);
Assert.False(target.GetResult().HasErrors);
}
}
}
public Result Create(MemberDto dto)
{
var validator = new MemberValidator(_memberRepository);
var result = validator.ValidateResult(dto);
if (!result.Success)
{
return(result);
}
dto.CreatedSource = (int)MemberCreatedSource.Admin;
var entity = Mapper.Map <Member>(dto);
entity.Salt = SecurityHelper.GenerateSalt();
entity.Password = SecurityHelper.GenerateHash(dto.Password, entity.Salt);
entity.IsActive = true;
entity.LastLoginAt = DateTime.Now;
_memberRepository.Insert(entity);
_unitOfWork.Commit();
MemberCacheManager.ClearCache();
result.Id = entity.Id;
return(result.SetSuccess(Messages.RecordSaved));
}
public FormValidationController()
{
_memberValidator = new MemberValidator("#EditForm");
}
/// <summary>
/// Creates a list of new DataTypes, creating as well a list of new Tables with all members of type as columns
/// <para xml:lang="es">
/// Crea una lista de tipos de datos nuevos, creando así una lista de nuevas tablas con todos los miembros de tipo como columnas
/// </para>
/// </summary>
public static IEnumerable<DataType> DefaultMap(IEnumerable<Type> types)
{
//we will store here all types that are actually persistent
List<DataType> persistentTypes = new List<DataType>();
Random random = new Random();
//map primary keys first, so we allow to foreign keys and inheritance to be correctly mapped
foreach (Type type in types)
{
//skip enums and interfaces
if (type.GetTypeInfo().IsEnum || type.GetTypeInfo().IsInterface)
{
continue;
}
//ignore types with no primary key
var pk = GetMappableMembers(type).Where(m => DataMember.IsPrimaryKey(m));
if (pk.Count() == 0)
{
continue;
}
DataType dtype = new DataType(type);
AllDataTypes.Add(dtype);
foreach (var memberInfo in pk)
{
//create datamember
dtype.AddMember(memberInfo.Name);
}
persistentTypes.Add(dtype);
}
foreach (DataType dtype in persistentTypes)
{
//create inheritance foreign keys
if (dtype.BaseDataType != null)
{
ForeignKey foreignKey = new ForeignKey();
foreignKey.Table = dtype.Table;
foreignKey.RemoteTable = dtype.BaseDataType.Table;
foreignKey.Name = "FK_" + dtype.Name + "_" + dtype.BaseDataType.Name + "_" + random.Next();
//we asume that primary keys on parent and child tables have the same number and order of related columns
for (int i = 0; i < dtype.PrimaryKey.Count(); i++)
{
DataMember pk = dtype.PrimaryKey.ToArray()[i];
DataMember basePk = dtype.BaseDataType.PrimaryKey.ToArray()[i];
foreignKey.Columns.Add(new Tuple<Column, Column>(pk.Column, basePk.Column));
}
dtype.Table.ForeignKeys.Add(foreignKey);
}
//map non primary key members now
foreach (var memberInfo in GetMappableMembers(dtype.InnerType).Where(m => !DataMember.IsPrimaryKey(m)))
{
Type returnType = MemberExpression.GetReturnType(memberInfo);
//is this a collection of a mapped type? if so, ignore since this must be a 1-1, 1-many or many-many relationship and must be mapped somewhere else
if (DataType.IsCollection(returnType) && IsMapped(returnType.GetCollectionItemType()))
{
continue;
}
//its a persistent type, with it's own table, map as a foreign key with one or more columns for the primary key
if (IsMapped(returnType))
{
//we asume this datatype is already mapped along with it's primery key
DataType returnDataType = returnType;
ForeignKey foreignKey = new ForeignKey();
foreignKey.Table = dtype.Table;
foreignKey.RemoteTable = returnDataType.Table;
foreignKey.Name = "FK_" + dtype.Name + "_" + memberInfo.Name + "_" + random.Next();
foreach (DataMember pk in returnDataType.PrimaryKey.ToList())
{
DataMember dmember = dtype.AddMember(memberInfo.Name + "." + pk.Expression);
dmember.Column.Name = memberInfo.Name + "_" + pk.Expression.Expression.Replace('.', '_');
dmember.Column.IsPrimaryKey = false;
dmember.Column.IsNullable = !RequiredValidator.IsRequired(memberInfo);
foreignKey.Columns.Add(new Tuple<Column, Column>(dmember.Column, pk.Column));
}
dtype.Table.ForeignKeys.Add(foreignKey);
}
//just map as a atomic value
else
{
//create datamember
dtype.AddMember(memberInfo.Name);
}
}
foreach (var memberInfo in GetMappableMembers(dtype.InnerType))
{
foreach (var att in memberInfo.GetCustomAttributes())
{
var validator = att as ValidatorBase;
if (validator == null)
{
continue;
}
MemberValidator memberValidator = new MemberValidator(new MemberExpression(memberInfo.DeclaringType, memberInfo.Name), validator);
dtype.Validators.Add(memberValidator);
}
}
yield return dtype;
}
}
public MemberService(IJsonRepository <Member> memberRepository, MemberValidator membervalidator, IEventPublisher eventPublisher)
{
_memberRepository = memberRepository;
_membervalidator = membervalidator;
_eventPublisher = eventPublisher;
}
public MemberController()
{
_memberRepo = new MemberRepo();
_validator = new MemberValidator();
}
/// <summary>
/// Author: Ramesh Adhikari
/// Created On: 01/30/2019
/// Create new member and check for the validation
/// </summary>
private void CreateMember()
{
string firstName = txtFirstName.Text.Trim();
string lastName = txtLastName.Text.Trim();
string phoneNumber = txtPhoneNumber.Text.Trim();
string email = txtEmail.Text.Trim();
string password = txtPassword.Password.Trim();
string active = txtActive.IsEnabled.ToString();
if (txtFirstName.Text == "" ||
txtLastName.Text == "" ||
txtEmail.Text == "" ||
txtPhoneNumber.Text == ""
)
{
MessageBox.Show("Please Fill Out the Form");
}
// Validate the phone number
else if (!Regex.IsMatch(txtPhoneNumber.Text, @"^\(?\d{3}\)?[\s\-]?\d{3}\-?\d{4}$"))
{
MessageBox.Show("Please Enter Valid Phone Number");
txtPhoneNumber.Select(0, txtPhoneNumber.Text.Length);
txtPhoneNumber.Focus();
}
else if (!ValidateEmailAddress())
{
MessageBox.Show("Please Enter Valid Email");
txtEmail.Select(0, txtEmail.Text.Length);
txtEmail.Focus();
}
else
{
MemberValidator.ValidateEmail(new Member()
{
Email = email
});
MemberValidator.ValidatePhoneNumber(new Member()
{
PhoneNumber = phoneNumber
});
// New member
try
{
_newMember = new Member
{
FirstName = firstName,
LastName = lastName,
PhoneNumber = phoneNumber,
Email = email,
Password = password,
//Active = active,
};
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
/// <summary>
/// Validates Form Fields data
/// </summary>
/// <returns>If Validation succed, returns True. If not, returns false.</returns>
private void ValidatedFields(MemberModel model)
{
var validator = new MemberValidator();
validator.ValidateAndThrow(model);
}
public void Should_AddRule_ThrowException_When_NullRule()
{
var memberValidator = new MemberValidator();
Assert.Throws<ArgumentNullException>(() => { memberValidator.AddRule(null); });
}
