public void ValidationOneWorkWithFluentValidationAndShouldBeFailureTest()
{
var model1 = new GanglvToni()
{
Name = "", Age = 11
};
var model2 = new GanglvToni()
{
Name = "11111111111", Age = 11
};
var model3 = new GanglvToni()
{
Name = "Good", Age = 9
};
var model4 = new GanglvToni()
{
Name = "", Age = -9
};
var validator = new FluentValidator <GanglvToniValidator, GanglvToni>();
validator.VerifyOne(typeof(GanglvToni), model1.Name, "Name").IsValid.Should().BeFalse();
validator.VerifyOne(typeof(GanglvToni), model1.Age, "Age").IsValid.Should().BeTrue();
validator.VerifyOne(typeof(GanglvToni), model2.Name, "Name").IsValid.Should().BeFalse();
validator.VerifyOne(typeof(GanglvToni), model2.Age, "Age").IsValid.Should().BeTrue();
validator.VerifyOne(typeof(GanglvToni), model3.Name, "Name").IsValid.Should().BeTrue();
validator.VerifyOne(typeof(GanglvToni), model3.Age, "Age").IsValid.Should().BeFalse();
validator.VerifyOne(typeof(GanglvToni), model4.Name, "Name").IsValid.Should().BeFalse();
validator.VerifyOne(typeof(GanglvToni), model4.Age, "Age").IsValid.Should().BeFalse();
}
public void ValidationModelWorkWithFluentValidationAndShouldBeFailureTest()
{
var model1 = new GanglvToni()
{
Name = "", Age = 11
};
var model2 = new GanglvToni()
{
Name = "11111111111", Age = 11
};
var model3 = new GanglvToni()
{
Name = "What", Age = 9
};
var model4 = new GanglvToni()
{
Name = "", Age = -9
};
var validator = new FluentValidator <GanglvToniValidator, GanglvToni>();
var r1 = validator.Verify(model1);
var r2 = validator.Verify(model2);
var r3 = validator.Verify(model3);
var r4 = validator.Verify(model4);
r1.IsValid.ShouldBeFalse();
r2.IsValid.ShouldBeFalse();
r3.IsValid.ShouldBeFalse();
r4.IsValid.ShouldBeFalse();
r1.MemberNames.Should().HaveCount(1);
r2.MemberNames.Should().HaveCount(1);
r3.MemberNames.Should().HaveCount(1);
r4.MemberNames.Should().HaveCount(2);
}
public AddModel <CategoryModel> Add(AddModel <CategoryModel> addModel)
{
var validator = new FluentValidator <CategoryModel, CategoryValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _repositoryLanguage.Get(e => e.Id == addModel.Item.Language.Id);
if (language == null)
{
throw new ParentNotFoundException();
}
var line = addModel.Item.CreateMapped <CategoryModel, CategoryLanguageLine>();
var item = new Category
{
Code = addModel.Item.Code,
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
Creator = _serviceMain.IdentityUser,
LastModificationTime = DateTime.Now,
LastModifier = _serviceMain.IdentityUser
};
var affectedItem = _repositoryCategory.Add(item, true);
var maxLineDisplayOrder = _repositoryCategoryLanguageLine.Get().Where(x => x.Language.Id == addModel.Item.Language.Id).Max(e => e.DisplayOrder);
line.Id = GuidHelper.NewGuid();
line.Version = 1;
line.DisplayOrder = maxLineDisplayOrder + 1;
line.CreationTime = DateTime.Now;
line.Language = language;
line.Category = affectedItem;
line.LastModificationTime = DateTime.Now;
line.Creator = _serviceMain.IdentityUser;
line.LastModifier = _serviceMain.IdentityUser;
_repositoryCategoryLanguageLine.Add(line, true);
addModel.Item = affectedItem.CreateMapped <Category, CategoryModel>();
addModel.Item.Creator = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.Language = new IdCodeName(language.Id, language.Code, language.Name);
return(addModel);
}
public void ValidateUsingFluentValidator()
{
var v = new FluentValidator();
v.Validate(m2);
v.Validate(m3);
v.Validate(m4);
}
public AddModel <ParameterModel> Add(AddModel <ParameterModel> addModel)
{
var validator = new FluentValidator <ParameterModel, ParameterValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var parent = _repositoryParameterGroup.Get(e => e.Id == addModel.Item.ParameterGroup.Id);
if (parent == null)
{
throw new ParentNotFoundException();
}
var item = addModel.Item.CreateMapped <ParameterModel, Parameter>();
if (_repositoryParameter.Get().FirstOrDefault(e => e.Key == item.Key) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Key));
}
item.Id = GuidHelper.NewGuid();
item.Version = 1;
item.CreationTime = DateTime.Now;
item.LastModificationTime = DateTime.Now;
item.ParameterGroup = parent;
item.DisplayOrder = 1;
item.Creator = _serviceMain.IdentityUser ?? throw new IdentityUserException(Messages.DangerIdentityUserNotFound);
item.LastModifier = _serviceMain.IdentityUser;
_repositoryParameter.Add(item, true);
var maxDisplayOrder = _repositoryParameter.Get().Max(e => e.DisplayOrder);
item.DisplayOrder = maxDisplayOrder + 1;
var affectedItem = _repositoryParameter.Update(item, true);
addModel.Item = affectedItem.CreateMapped <Parameter, ParameterModel>();
addModel.Item.Creator = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.ParameterGroup = new IdCodeName(parent.Id, parent.Code, parent.Name);
return(addModel);
}
public UpdateModel <LanguageModel> Update(UpdateModel <LanguageModel> updateModel)
{
IValidator validator = new FluentValidator <LanguageModel, LanguageValidationRules>(updateModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var item = _repositoryLanguage.Join(x => x.Creator.Person)
.Join(x => x.LastModifier.Person)
.FirstOrDefault(e => e.Id == updateModel.Item.Id);
if (item == null)
{
throw new NotFoundException(Messages.DangerRecordNotFound);
}
if (updateModel.Item.Code != item.Code)
{
if (_repositoryLanguage.Get().Any(p => p.Code == updateModel.Item.Code))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Code));
}
}
var version = item.Version;
var itemHistory = item.CreateMapped <Language, LanguageHistory>();
itemHistory.Id = GuidHelper.NewGuid();
itemHistory.ReferenceId = item.Id;
itemHistory.CreatorId = IdentityUser.Id;
itemHistory.Version = version + 1;
_repositoryLanguageHistory.Add(itemHistory, true);
item.Code = updateModel.Item.Code;
item.Name = updateModel.Item.Name;
item.Description = updateModel.Item.Description;
item.IsApproved = updateModel.Item.IsApproved;
item.LastModificationTime = DateTime.Now;
item.LastModifier = IdentityUser;
item.Version = version + 1;
var affectedItem = _repositoryLanguage.Update(item, true);
updateModel.Item = affectedItem.CreateMapped <Language, LanguageModel>();
updateModel.Item.Creator = new IdCodeName(item.Creator.Id, item.Creator.Username, item.Creator.Person.DisplayName);
updateModel.Item.LastModifier = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
return(updateModel);
}
/// <summary>
/// Register for Sink Validator for FluentValidation
/// </summary>
/// <param name="registrar"></param>
/// <param name="typeOfValidator"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IFluentValidationRegistrar AndForFluentValidator(this IWaitForMessageValidationRegistrar registrar, Type typeOfValidator)
{
if (registrar is null)
{
throw new ArgumentNullException(nameof(registrar));
}
return(registrar.AndForCustomValidator(FluentValidator.By(typeOfValidator)));
}
/// <summary>
/// Register for Sink Validator for FluentValidation
/// </summary>
/// <param name="registrar"></param>
/// <param name="validator"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IFluentValidationRegistrar AndForFluentValidator <T>(this IValueFluentValidationRegistrar <T> registrar, FluentValidation.IValidator validator)
{
if (registrar is null)
{
throw new ArgumentNullException(nameof(registrar));
}
return(registrar.AndForCustomValidator(FluentValidator.By(validator)));
}
public void ValidateUsingFluentValidator()
{
var v = new FluentValidator();
//v.Validate(m1); // Not applicable here, will throw exception.
v.Validate(m2);
v.Validate(m3);
v.Validate(m4);
}
public bool IsValid()
{
var val = new FluentValidator();
val.Validate(() => UserName).IsNotNull()
.Validate(() => CreateDate).IsAfterToday()
.Validate(() => Email).IsValidEmail()
.Validate(() => MobilePhone).IsValidMobileNumber();
return val.HasErrors;
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var val = new FluentValidator();
val.Validate(() => UserName).IsNotNull()
.Validate(() => CreateDate).IsAfterToday()
.Validate(() => Email).IsValidEmail()
.Validate(() => MobilePhone).IsValidMobileNumber();
return val.Errors;
}
public AddModel <MenuModel> Add(AddModel <MenuModel> addModel)
{
IValidator validator = new FluentValidator <MenuModel, MenuValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var parent = _repositoryMenu.Get(e => e.Id == addModel.Item.ParentMenu.Id);
if (parent == null)
{
throw new NotFoundException(Messages.DangerParentNotFound);
}
var item = addModel.Item.CreateMapped <MenuModel, Menu>();
if (_repositoryMenu.Get().FirstOrDefault(e => e.Code == item.Code) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Code));
}
item.Id = GuidHelper.NewGuid();
item.Version = 1;
item.CreationTime = DateTime.Now;
item.LastModificationTime = DateTime.Now;
item.ParentMenu = parent;
item.DisplayOrder = 1;
item.Creator = IdentityUser ?? throw new IdentityUserException(Messages.DangerIdentityUserNotFound);
item.LastModifier = IdentityUser;
_repositoryMenu.Add(item, true);
var maxDisplayOrder = _repositoryMenu.Get().Max(e => e.DisplayOrder);
item.DisplayOrder = maxDisplayOrder + 1;
var affectedItem = _repositoryMenu.Update(item, true);
var itemHistory = affectedItem.CreateMapped <Menu, MenuHistory>();
itemHistory.Id = GuidHelper.NewGuid();
itemHistory.ReferenceId = affectedItem.Id;
itemHistory.CreatorId = IdentityUser.Id;
_repositoryMenuHistory.Add(itemHistory, true);
addModel.Item = affectedItem.CreateMapped <Menu, MenuModel>();
addModel.Item.Creator = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
addModel.Item.ParentMenu = new IdCodeName(parent.Id, parent.Code, parent.Name);
return(addModel);
}
public override void OnEntry(MethodExecutionArgs args)
{
if (Validator?.BaseType is null)
{
return;
}
var entityType = Validator.BaseType.GetGenericArguments()[0];
var entity = args.Arguments.FirstOrDefault(t => t.GetType() == entityType);
FluentValidator.Validate(Validator, entity);
}
public void ValidationOneWorkWithFluentValidationAndShouldBeSuccessTest()
{
var model = new GanglvToni()
{
Name = "Good", Age = 11
};
var validator = new FluentValidator <GanglvToniValidator, GanglvToni>();
validator.VerifyOne(typeof(GanglvToni), model.Name, "Name").IsValid.Should().BeTrue();
validator.VerifyOne(typeof(GanglvToni), model.Age, "Age").IsValid.Should().BeTrue();
}
protected override void InitRules(FluentValidator rules)
{
rules.RuleFor(user => user.Value).NotNull()
.WithMessage("Required")
.WithName("FirstName")
.When(u => u.Type == UserContactType.Email);
rules.RuleFor(user => user.Value).NotNull()
.WithMessage("Required")
.WithName("FirstName")
.When(u => u.Type == UserContactType.Mobile);
}
protected override void InitRules(FluentValidator rules)
{
rules.RuleFor(user => user.FirstName).NotNull().WithMessage("Required").WithName("FirstName")
.MinimumLength(2).WithMessage("Minimum length is 2").WithName("FirstName")
.MaximumLength(20).WithMessage("Maximum length is 20").WithName("FirstName");
rules.RuleFor(user => user.LastName).NotNull().WithMessage("Required").WithName("LastName")
.MinimumLength(2).WithMessage("Minimum length is 2").WithName("LastName")
.MaximumLength(20).WithMessage("Maximum length is 20").WithName("LastName");
rules.RuleFor(user => user.Gender).NotEqual(Gender.NotSet).WithMessage("Required").WithName("LastName");
}
public SalaryValidator()
{
FluentValidator.RuleFor(x => x.FirstName).NotEmpty().WithName(Resources.FirstNameText);
FluentValidator.RuleFor(x => x.LastName).NotEmpty().WithName(Resources.LastNameText);
FluentValidator.RuleFor(x => x.BirthDate).NotEmpty().WithName(Resources.BirthDateText);
FluentValidator.Custom(delegate(ISalary x)
{
if (string.IsNullOrEmpty(x.FirstName))
{
return(new ValidationFailure(string.Empty, "IMIĘ NIE MOŻE BY PUSTE"));
}
return(null);
});
}
public AddModel <RoleModel> Add(AddModel <RoleModel> addModel)
{
var validator = new FluentValidator <RoleModel, RoleValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var item = addModel.Item.CreateMapped <RoleModel, Role>();
if (_repositoryRole.Get().FirstOrDefault(e => e.Code == item.Code) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Code));
}
item.Id = GuidHelper.NewGuid();
item.Version = 1;
item.CreationTime = DateTime.Now;
item.LastModificationTime = DateTime.Now;
item.DisplayOrder = 1;
item.Creator = _serviceMain.IdentityUser ?? throw new IdentityUserException(Messages.DangerIdentityUserNotFound);
item.LastModifier = _serviceMain.IdentityUser;
_repositoryRole.Add(item, true);
var maxDisplayOrder = _repositoryRole.Get().Max(e => e.DisplayOrder);
item.DisplayOrder = maxDisplayOrder + 1;
var affectedItem = _repositoryRole.Update(item, true);
addModel.Item = affectedItem.CreateMapped <Role, RoleModel>();
addModel.Item.Creator = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
return(addModel);
}
private static void Main(string[] args)
{
var val = new FluentValidator();
var user = new User();
val.Validate(() => user.UserName).IsNotNull()
.Validate(() => user.CreateDate).IsAfterToday()
.Validate(() => user.Email).IsValidEmail()
.Validate(() => user.MobilePhone).IsValidMobileNumber()
.Validate(() => user.CreateDate).Must(BeThisYear, "Creation Date must be this year");
PrintErrors(val.Errors);
//Or call the IsValid method on the model its self
//user.IsIsValid();
}
public SalaryValidator()
{
Func <ISalary, bool> nameValidation = x => !string.IsNullOrEmpty(x.FirstName) || !string.IsNullOrEmpty(x.LastName);
FluentValidator.RuleFor(x => x.FirstName)
.Must((instance, _) => nameValidation(instance))
.WithMessage(Resources.NameValidationErrorText);
FluentValidator.RuleFor(x => x.LastName)
.Must((instance, _) => nameValidation(instance))
.WithMessage(Resources.NameValidationErrorText);
FluentValidator.ObjectRule(x => nameValidation(x) ? null : Resources.NameValidationErrorText);
FluentValidator.RuleFor(x => x.BirthDate).NotEmpty().WithName(Resources.BirthDateText);
}
public void ValidationModelWorkWithFluentValidationAndShouldBeSuccessTest()
{
var model = new GanglvToni()
{
Name = "XiE", Age = 11
};
var validator1 = new GanglvToniValidator();
var validator2 = new FluentValidator(validator1);
var validator3 = new FluentValidator(typeof(GanglvToniValidator));
var validator4 = new FluentValidator <GanglvToniValidator>();
var validator5 = new FluentValidator <GanglvToniValidator, GanglvToni>();
validator1.Validate(model).IsValid.Should().BeTrue();
validator2.Verify(typeof(GanglvToni), model).IsValid.Should().BeTrue();
validator3.Verify(typeof(GanglvToni), model).IsValid.Should().BeTrue();
validator4.Verify(typeof(GanglvToni), model).IsValid.Should().BeTrue();
validator5.Verify(model).IsValid.Should().BeTrue();
}
public AddModel <UserModel> Add(AddModel <UserModel> addModel)
{
IValidator validator = new FluentValidator <UserModel, UserValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var item = addModel.Item.CreateMapped <UserModel, User>();
if (_repositoryUser.Get(e => e.Username == item.Username) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Username));
}
if (_repositoryUser.Get(e => e.Email == item.Email) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Email));
}
if (addModel.Item.BirthDate == DateTime.MinValue)
{
addModel.Item.BirthDate = DateTime.Now;
}
var password = addModel.Item.Password.ToSha512();
// kişi bilgisi veritabanında var mı?
// Kişi bilgisi yoksa yeni kişi bilgisi oluşturuluyor
Person person;
var maxDisplayOrderPerson = _repositoryPerson.Get().Max(e => e.DisplayOrder);
var maxDisplayOrderUser = _repositoryUser.Get().Max(e => e.DisplayOrder);
if (addModel.Item.IdentityCode != null)
{
if (_repositoryPerson.Get(x => x.IdentityCode == addModel.Item.IdentityCode) != null)
{
person = _repositoryPerson.Get(x => x.IdentityCode == addModel.Item.IdentityCode);
}
else
{
person = new Person
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderPerson + 1,
Version = 1,
IsApproved = false,
IdentityCode = addModel.Item.IdentityCode.Trim().Length > 0 ? addModel.Item.IdentityCode : GuidHelper.NewGuid().ToString(),
FirstName = addModel.Item.FirstName,
LastName = addModel.Item.LastName,
Biography = addModel.Item.Biography,
BirthDate = addModel.Item.BirthDate
};
}
}
else
{
person = new Person
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderPerson + 1,
Version = 1,
IsApproved = false,
IdentityCode = GuidHelper.NewGuid().ToString(),
FirstName = addModel.Item.FirstName,
LastName = addModel.Item.LastName,
BirthDate = addModel.Item.BirthDate,
Biography = addModel.Item.Biography
};
}
person.CreatorId = IdentityUser.Id;
person.LastModifierId = IdentityUser.Id;
_repositoryPerson.Add(person, true);
item.Id = GuidHelper.NewGuid();
item.Creator = IdentityUser;
item.CreationTime = DateTime.Now;
item.LastModificationTime = DateTime.Now;
item.LastModifier = IdentityUser;
item.DisplayOrder = maxDisplayOrderUser + 1;
item.Person = person;
item.Version = 1;
var affectedUser = _repositoryUser.Add(item, true);
var personHistory = person.CreateMapped <Person, PersonHistory>();
personHistory.Id = GuidHelper.NewGuid();
personHistory.ReferenceId = person.Id;
personHistory.IsDeleted = false;
personHistory.RestoreVersion = 0;
_repositoryPersonHistory.Add(personHistory, true);
var userHistory = affectedUser.CreateMapped <User, UserHistory>();
userHistory.Id = GuidHelper.NewGuid();
userHistory.ReferenceId = affectedUser.Id;
userHistory.PersonId = affectedUser.Person.Id;
userHistory.CreatorId = IdentityUser.Id;
userHistory.IsDeleted = false;
userHistory.RestoreVersion = 0;
_repositoryUserHistory.Add(userHistory, true);
var role = _repositoryRole.Get(x => x.Code == "DEFAULTROLE");
if (role == null)
{
throw new NotFoundException(Messages.DangerRecordNotFound);
}
var affectedRoleUserLine = _repositoryRoleUserLine.Add(new RoleUserLine
{
Id = GuidHelper.NewGuid(),
User = affectedUser,
Role = role,
Creator = IdentityUser,
CreationTime = DateTime.Now,
DisplayOrder = 1,
LastModifier = IdentityUser,
LastModificationTime = DateTime.Now,
Version = 1
}, true);
var roleUserLineHistory = affectedRoleUserLine.CreateMapped <RoleUserLine, RoleUserLineHistory>();
roleUserLineHistory.Id = GuidHelper.NewGuid();
roleUserLineHistory.ReferenceId = roleUserLineHistory.Id;
roleUserLineHistory.RoleId = affectedRoleUserLine.Role.Id;
roleUserLineHistory.UserId = affectedRoleUserLine.User.Id;
roleUserLineHistory.CreatorId = affectedRoleUserLine.Creator.Id;
_repositoryRoleUserLineHistory.Add(roleUserLineHistory, true);
addModel.Item.Creator = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
addModel.Item.BirthDate = affectedUser.Person.BirthDate;
addModel.Item.IdentityCode = affectedUser.Person.IdentityCode;
addModel.Item.FirstName = affectedUser.Person.FirstName;
addModel.Item.LastName = affectedUser.Person.LastName;
addModel.Item.Biography = affectedUser.Person.Biography;
if (!_serviceMain.ApplicationSettings.SendMailAfterAddUser)
{
return(addModel);
}
var emailUser = new EmailUser
{
Username = affectedUser.Username,
Password = password,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_smtp, _serviceMain);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.Add);
return(addModel);
}
public void FluentValidator_Should_Return_Errors_For_invalide_Validate_Function_()
{
var val = new FluentValidator();
var user = ValideUser;
user.UserName = "******";
val.Validate(() => user.UserName).Must(o => o.ToString().Length > 3, "User name is to short");
val.HasErrors.ShouldBeTrue();
val.Errors.Count.ShouldEqual(1);
}
public void Validate(Product obj)
{
var validator = new ProductValidator();
FluentValidator.Validate(new ProductValidator(), obj);
}
protected override void InitRules(FluentValidator rules)
{
}
public AddModel <CategoryModel> Add(AddModel <CategoryModel> addModel)
{
IValidator validator = new FluentValidator <CategoryModel, CategoryValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _repositoryLanguage.Get(e => e.Id == addModel.Item.Language.Id);
if (language == null)
{
throw new NotFoundException(Messages.DangerParentNotFound);
}
var line = addModel.Item.CreateMapped <CategoryModel, CategoryLanguageLine>();
if (_repositoryCategoryLanguageLine.Get().FirstOrDefault(e => e.Code == line.Code) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Code));
}
var item = new Category
{
Code = GuidHelper.NewGuid().ToString(),
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
Creator = IdentityUser,
LastModificationTime = DateTime.Now,
LastModifier = IdentityUser
};
var affectedItem = _repositoryCategory.Add(item, true);
var itemHistory = affectedItem.CreateMapped <Category, CategoryHistory>();
itemHistory.Id = GuidHelper.NewGuid();
itemHistory.ReferenceId = affectedItem.Id;
itemHistory.CreatorId = IdentityUser.Id;
_repositoryCategoryHistory.Add(itemHistory, true);
var maxLineDisplayOrder = _repositoryCategoryLanguageLine.Get().Where(x => x.Language.Id == addModel.Item.Language.Id).Max(e => e.DisplayOrder);
line.Id = GuidHelper.NewGuid();
line.Version = 1;
line.DisplayOrder = maxLineDisplayOrder + 1;
line.CreationTime = DateTime.Now;
line.Language = language;
line.Category = affectedItem;
line.LastModificationTime = DateTime.Now;
line.Creator = IdentityUser;
line.LastModifier = IdentityUser;
var affectedLine = _repositoryCategoryLanguageLine.Add(line, true);
var lineHistory = affectedLine.CreateMapped <CategoryLanguageLine, CategoryLanguageLineHistory>();
lineHistory.Id = GuidHelper.NewGuid();
lineHistory.ReferenceId = affectedLine.Id;
lineHistory.CreatorId = IdentityUser.Id;
lineHistory.CreationTime = DateTime.Now;
lineHistory.CategoryId = affectedLine.Category.Id;
lineHistory.LanguageId = affectedLine.Language.Id;
_repositoryCategoryLanguageLineHistory.Add(lineHistory, true);
addModel.Item = affectedItem.CreateMapped <Category, CategoryModel>();
addModel.Item.Creator = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
addModel.Item.Language = new IdCodeName(language.Id, language.Code, language.Name);
return(addModel);
}
public UpdateModel <CategoryModel> Update(UpdateModel <CategoryModel> updateModel)
{
IValidator validator = new FluentValidator <CategoryModel, CategoryValidationRules>(updateModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _repositoryLanguage.Get(e => e.Id == updateModel.Item.Language.Id);
if (language == null)
{
throw new NotFoundException(Messages.DangerParentNotFound);
}
var item = _repositoryCategory
.Join(x => x.Creator.Person)
.Join(x => x.LastModifier.Person)
.Join(z => z.CategoryLanguageLines)
.ThenJoin(x => x.Language)
.FirstOrDefault(x => x.Id == updateModel.Item.CategoryId);
if (item == null)
{
throw new NotFoundException(Messages.DangerRecordNotFound);
}
CategoryModel modelItem;
if (item.CategoryLanguageLines == null)
{
modelItem = new CategoryModel();
}
else
{
var itemLine = item.CategoryLanguageLines.FirstOrDefault(x => x.Language.Id == language.Id);
// güncelleme yapılacak
if (itemLine != null)
{
var version = itemLine.Version;
var lineHistory = itemLine.CreateMapped <CategoryLanguageLine, CategoryLanguageLineHistory>();
lineHistory.Id = GuidHelper.NewGuid();
lineHistory.ReferenceId = itemLine.Id;
lineHistory.CreatorId = IdentityUser.Id;
lineHistory.CreationTime = DateTime.Now;
lineHistory.CategoryId = item.Id;
lineHistory.LanguageId = language.Id;
_repositoryCategoryLanguageLineHistory.Add(lineHistory, true);
itemLine.Code = updateModel.Item.Code;
itemLine.Name = updateModel.Item.Name;
itemLine.Description = updateModel.Item.Description;
itemLine.Keywords = updateModel.Item.Keywords;
itemLine.Version = version + 1;
itemLine.IsApproved = updateModel.Item.IsApproved;
itemLine.Category = item;
itemLine.LastModifier = IdentityUser;
itemLine.LastModificationTime = DateTime.Now;
var affectedItemLine = _repositoryCategoryLanguageLine.Update(itemLine, true);
modelItem = affectedItemLine.CreateMapped <CategoryLanguageLine, CategoryModel>();
modelItem.Creator = new IdCodeName(itemLine.Creator.Id, itemLine.Creator.Username, itemLine.Creator.Person.DisplayName);
modelItem.LastModifier = new IdCodeName(IdentityUser.Id, IdentityUser.Username, IdentityUser.Person.DisplayName);
}
// ekleme yapılacak
else
{
modelItem = new CategoryModel();
var maxLineDisplayOrder = _repositoryCategoryLanguageLine.Get().Where(x => x.Language.Id == language.Id).Max(e => e.DisplayOrder);
var line = updateModel.Item.CreateMapped <CategoryModel, CategoryLanguageLine>();
line.Id = GuidHelper.NewGuid();
line.Version = 1;
line.DisplayOrder = maxLineDisplayOrder + 1;
line.CreationTime = DateTime.Now;
line.Language = language;
line.Category = item;
line.LastModificationTime = DateTime.Now;
line.Creator = IdentityUser;
line.LastModifier = IdentityUser;
var affectedLine = _repositoryCategoryLanguageLine.Add(line, true);
var lineHistory = affectedLine.CreateMapped <CategoryLanguageLine, CategoryLanguageLineHistory>();
lineHistory.Id = GuidHelper.NewGuid();
lineHistory.ReferenceId = affectedLine.Id;
lineHistory.CreatorId = IdentityUser.Id;
lineHistory.CreationTime = DateTime.Now;
lineHistory.CategoryId = affectedLine.Category.Id;
lineHistory.LanguageId = affectedLine.Language.Id;
_repositoryCategoryLanguageLineHistory.Add(lineHistory, true);
}
}
var itemHistory = item.CreateMapped <Category, CategoryHistory>();
itemHistory.Id = GuidHelper.NewGuid();
itemHistory.ReferenceId = item.Id;
itemHistory.CreatorId = IdentityUser.Id;
_repositoryCategoryHistory.Add(itemHistory, true);
item.LastModificationTime = DateTime.Now;
item.LastModifier = IdentityUser;
var affectedItem = _repositoryCategory.Update(item, true);
modelItem.CategoryId = affectedItem.Id;
modelItem.Language = new IdCodeName(language.Id, language.Code, language.Name);
updateModel.Item = modelItem;
return(updateModel);
}
public void Register(RegisterModel model)
{
IValidator validator = new FluentValidator <RegisterModel, RegisterModelValidationRules>(model);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
// Kullanıcı adı kullanımda mı?
if (_repositoryUser.Get(e => e.Username == model.Username) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Username));
}
// Email kullanımda mı?
if (_repositoryUser.Get(e => e.Email == model.Email) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Email));
}
var password = model.Password.ToSha512();
// kişi bilgisi veritabanında var mı?
// Kişi bilgisi yoksa yeni kişi bilgisi oluşturuluyor
Person person;
var maxDisplayOrderPerson = _repositoryPerson.Get().Max(e => e.DisplayOrder);
var maxDisplayOrderUser = _repositoryUser.Get().Max(e => e.DisplayOrder);
if (model.IdentityCode != null)
{
if (_repositoryPerson.Get(x => x.IdentityCode == model.IdentityCode) != null)
{
person = _repositoryPerson.Get(x => x.IdentityCode == model.IdentityCode);
}
else
{
person = new Person
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderPerson + 1,
Version = 1,
IsApproved = false,
IdentityCode = model.IdentityCode.Trim().Length > 0
? model.IdentityCode
: GuidHelper.NewGuid().ToString(),
FirstName = model.FirstName,
LastName = model.LastName,
};
}
}
else
{
person = new Person
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderPerson + 1,
Version = 1,
IsApproved = false,
IdentityCode = GuidHelper.NewGuid().ToString(),
FirstName = model.FirstName,
LastName = model.LastName,
};
}
var user = new User
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderUser + 1,
Version = 1,
IsApproved = false,
Username = model.Username,
Password = password,
Email = model.Email,
Language = _serviceMain.DefaultLanguage,
Person = person,
};
person.CreatorId = user.Id;
person.LastModifierId = user.Id;
_repositoryPerson.Add(person, true);
user.Creator = user;
user.LastModifier = user;
var affectedUser = _repositoryUser.Add(user, true);
var role = _repositoryRole.Get(x => x.Code == RoleConstants.Default.Item1);
if (role == null)
{
throw new NotFoundException();
}
_repositoryRoleUserLine.Add(new RoleUserLine
{
Id = GuidHelper.NewGuid(),
User = affectedUser,
Role = role,
Creator = user,
CreationTime = DateTime.Now,
DisplayOrder = 1,
LastModifier = user,
LastModificationTime = DateTime.Now,
Version = 1
}, true);
if (!_serviceMain.ApplicationSettings.SendMailAfterAddUser)
{
return;
}
var emailUser = new EmailUser
{
Id = affectedUser.Id,
Username = affectedUser.Username,
Password = password,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_serviceMain, _smtp);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.Register);
}
public void FluentValidator_Should_Return_No_Errors_For_A_Valid_Entity()
{
var val = new FluentValidator();
var user = ValideUser;
val.Validate(() => user.UserName).IsNotNull()
.Validate(() => user.CreateDate).IsBeforeToday()
.Validate(() => user.Email).IsValidEmail()
.Validate(() => user.MobilePhone).IsValidMobileNumber()
.Validate(() => user.FailedLogonAttemp).IsBetween(0, 5);
val.HasErrors.ShouldBeFalse();
val.Errors.Count.ShouldEqual(0);
}
public UpdateModel <ParameterModel> Update(UpdateModel <ParameterModel> updateModel)
{
IValidator validator = new FluentValidator <ParameterModel, ParameterValidationRules>(updateModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var parent = _repositoryParameterGroup.Get(e => e.Id == updateModel.Item.ParameterGroup.Id);
if (parent == null)
{
throw new ParentNotFoundException();
}
var item = _repositoryParameter
.Join(x => x.Creator.Person)
.Join(x => x.LastModifier.Person).FirstOrDefault(e => e.Id == updateModel.Item.Id);
if (item == null)
{
throw new NotFoundException();
}
if (updateModel.Item.Key != item.Key)
{
if (_repositoryParameter.Get().Any(p => p.Key == updateModel.Item.Key))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Key));
}
}
var itemHistory = item.CreateMapped <Parameter, ParameterHistory>();
itemHistory.Id = GuidHelper.NewGuid();
itemHistory.ReferenceId = item.Id;
itemHistory.CreatorId = _serviceMain.IdentityUser.Id;
itemHistory.CreationTime = DateTime.Now;
_repositoryParameterHistory.Add(itemHistory, true);
var version = item.Version;
item.Key = updateModel.Item.Key;
item.Value = updateModel.Item.Value;
item.Erasable = updateModel.Item.Erasable;
item.Description = updateModel.Item.Description;
item.IsApproved = updateModel.Item.IsApproved;
item.LastModificationTime = DateTime.Now;
item.Version = version + 1;
item.ParameterGroup = parent;
var affectedItem = _repositoryParameter.Update(item, true);
updateModel.Item = affectedItem.CreateMapped <Parameter, ParameterModel>();
updateModel.Item.Creator = new IdName(item.Creator.Id, item.Creator.Person.DisplayName);
updateModel.Item.LastModifier = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
updateModel.Item.ParameterGroup = new IdCodeName(item.ParameterGroup.Id, item.ParameterGroup.Code, item.ParameterGroup.Name);
return(updateModel);
}
public UpdateModel <UserModel> Update(UpdateModel <UserModel> updateModel)
{
IValidator validator = new FluentValidator <UserModel, UserValidationRules>(updateModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _repositoryLanguage.Get(e => e.Id == updateModel.Item.Language.Id);
if (language == null)
{
throw new ParentNotFoundException();
}
var identityUserMinRoleLevel = _serviceMain.IdentityUserMinRoleLevel;
var itemUser = _repositoryUser
.Join(x => x.Person)
.Join(x => x.Language)
.Join(x => x.Creator.Person)
.Join(x => x.LastModifier.Person)
.FirstOrDefault(x => x.Id == updateModel.Item.Id && x.RoleUserLines.All(t => t.Role.Level > identityUserMinRoleLevel));
if (itemUser == null)
{
throw new NotFoundException();
}
var person = itemUser.Person;
if (person == null)
{
throw new ParentNotFoundException();
}
if (updateModel.Item.Username != itemUser.Username)
{
if (_repositoryUser.Get().Any(p => p.Username == updateModel.Item.Username))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Username));
}
}
if (updateModel.Item.Email != itemUser.Email)
{
if (_repositoryUser.Get().Any(p => p.Email == updateModel.Item.Email))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Email));
}
}
var versionUser = itemUser.Version;
var versionPerson = person.Version;
var personHistory = person.CreateMapped <Person, PersonHistory>();
personHistory.Id = GuidHelper.NewGuid();
personHistory.ReferenceId = person.Id;
personHistory.CreatorId = _serviceMain.IdentityUser.Id;
personHistory.CreationTime = DateTime.Now;
_repositoryPersonHistory.Add(personHistory, true);
person.FirstName = updateModel.Item.FirstName;
person.LastName = updateModel.Item.LastName;
person.LastModificationTime = DateTime.Now;
person.LastModifierId = _serviceMain.IdentityUser.Id;
person.Version = versionPerson + 1;
var affectedPerson = _repositoryPerson.Update(person, true);
var userHistory = itemUser.CreateMapped <User, UserHistory>();
userHistory.Id = GuidHelper.NewGuid();
userHistory.ReferenceId = itemUser.Id;
userHistory.PersonId = affectedPerson.Id;
userHistory.LanguageId = language.Id;
userHistory.CreatorId = _serviceMain.IdentityUser.Id;
userHistory.CreationTime = DateTime.Now;
_repositoryUserHistory.Add(userHistory, true);
itemUser.Username = updateModel.Item.Username;
itemUser.Email = updateModel.Item.Email;
itemUser.IsApproved = updateModel.Item.IsApproved;
itemUser.Language = language;
itemUser.Person = affectedPerson;
itemUser.LastModificationTime = DateTime.Now;
itemUser.LastModifier = _serviceMain.IdentityUser;
itemUser.Version = versionUser + 1;
var affectedUser = _repositoryUser.Update(itemUser, true);
foreach (var line in _repositoryRoleUserLine
.Join(x => x.Role)
.Join(x => x.User)
.Where(x => x.User.Id == affectedUser.Id).ToList())
{
var lineHistory = line.CreateMapped <RoleUserLine, RoleUserLineHistory>();
lineHistory.Id = GuidHelper.NewGuid();
lineHistory.ReferenceId = line.Id;
lineHistory.RoleId = line.Role.Id;
lineHistory.UserId = line.User.Id;
lineHistory.CreationTime = DateTime.Now;
lineHistory.CreatorId = _serviceMain.IdentityUser.Id;
_repositoryRoleUserLineHistory.Add(lineHistory, true);
_repositoryRoleUserLine.Delete(line, true);
}
foreach (var idCodeNameSelected in updateModel.Item.Roles)
{
var itemRole = _repositoryRole.Get(x => x.Id == idCodeNameSelected.Id);
var affectedLine = _repositoryRoleUserLine.Add(new RoleUserLine
{
Id = GuidHelper.NewGuid(),
User = affectedUser,
Role = itemRole,
Creator = _serviceMain.IdentityUser,
CreationTime = DateTime.Now,
DisplayOrder = 1,
LastModifier = _serviceMain.IdentityUser,
LastModificationTime = DateTime.Now,
Version = 1
}, true);
var lineHistory = affectedLine.CreateMapped <RoleUserLine, RoleUserLineHistory>();
lineHistory.Id = GuidHelper.NewGuid();
lineHistory.ReferenceId = affectedLine.Id;
lineHistory.RoleId = affectedLine.Role.Id;
lineHistory.UserId = affectedLine.User.Id;
lineHistory.CreatorId = affectedLine.Creator.Id;
_repositoryRoleUserLineHistory.Add(lineHistory, true);
}
updateModel.Item = affectedUser.CreateMapped <User, UserModel>();
updateModel.Item.Creator = new IdName(itemUser.Creator.Id, itemUser.Creator.Person.DisplayName);
updateModel.Item.LastModifier = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
updateModel.Item.Language = new IdName(affectedUser.Language.Id, affectedUser.Language.Name);
updateModel.Item.IdentityCode = itemUser.Person.IdentityCode;
updateModel.Item.FirstName = itemUser.Person.FirstName;
updateModel.Item.LastName = itemUser.Person.LastName;
if (!_serviceMain.ApplicationSettings.SendMailAfterUpdateUserInformation)
{
return(updateModel);
}
var emailUser = new EmailUser
{
Username = affectedUser.Username,
Password = string.Empty,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_serviceMain, _smtp);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.Update);
return(updateModel);
}
public void FluentValidator_Should_Return_Errors_For_Null_Property_Validation_Check()
{
var val = new FluentValidator();
var user = ValideUser;
user.UserName = null;
val.Validate(() => user.UserName).IsNotNull();
val.HasErrors.ShouldBeTrue();
val.Errors.Count.ShouldEqual(1);
}
public void UpdateMyPassword(UpdatePasswordModel model)
{
IValidator validator = new FluentValidator <UpdatePasswordModel, UpdatePasswordModelValidationRules>(model);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var identity = (CustomIdentity)Thread.CurrentPrincipal?.Identity;
var user = _repositoryUser
.Join(x => x.Language)
.Join(x => x.Person)
.FirstOrDefault(e => e.Id == identity.UserId);
if (user == null)
{
throw new NotFoundException();
}
if (model.OldPassword.ToSha512() != user.Password)
{
throw new NotFoundException(Messages.DangerIncorrectOldPassword);
}
var userHistory = user.CreateMapped <User, UserHistory>();
userHistory.Id = GuidHelper.NewGuid();
userHistory.ReferenceId = user.Id;
userHistory.CreatorId = user.Creator.Id;
userHistory.PersonId = user.Person.Id;
userHistory.LanguageId = user.Language.Id;
_repositoryUserHistory.Add(userHistory, true);
var password = model.Password;
user.Password = password.ToSha512();
user.LastModificationTime = DateTime.Now;
user.LastModifier = user;
var version = user.Version;
user.Version = version + 1;
var affectedUser = _repositoryUser.Update(user, true);
if (!_serviceMain.ApplicationSettings.SendMailAfterUpdateUserPassword)
{
return;
}
var emailUser = new EmailUser
{
Username = affectedUser.Username,
Password = password,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_serviceMain, _smtp);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.UpdateMyPassword);
}
public void UpdateMyInformation(UpdateInformationModel model)
{
IValidator validator = new FluentValidator <UpdateInformationModel, UpdateInformationModelValidationRules>(model);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _repositoryLanguage.Get(e => e.Id == model.Language.Id);
if (language == null)
{
throw new ParentNotFoundException();
}
var identity = (CustomIdentity)Thread.CurrentPrincipal?.Identity;
var user = _repositoryUser
.Join(x => x.Creator)
.Join(x => x.Language)
.Join(x => x.Person)
.FirstOrDefault(e => e.Id == identity.UserId);
if (user == null)
{
throw new NotFoundException();
}
var person = user.Person;
if (model.Username != user.Username)
{
if (_repositoryUser.Get().Any(p => p.Username == model.Username))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Username));
}
}
if (model.Email != user.Email)
{
if (_repositoryUser.Get().Any(p => p.Email == model.Email))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Email));
}
}
var personHistory = person.CreateMapped <Person, PersonHistory>();
personHistory.Id = GuidHelper.NewGuid();
personHistory.ReferenceId = user.Id;
personHistory.CreatorId = user.Creator.Id;
_repositoryPersonHistory.Add(personHistory, true);
person.FirstName = model.FirstName;
person.LastName = model.LastName;
person.LastModificationTime = DateTime.Now;
person.LastModifierId = user.Id;
var versionPerson = person.Version;
person.Version = versionPerson + 1;
_repositoryPerson.Update(person, true);
var userHistory = user.CreateMapped <User, UserHistory>();
userHistory.Id = GuidHelper.NewGuid();
userHistory.ReferenceId = user.Id;
userHistory.CreatorId = user.Creator.Id;
userHistory.PersonId = user.Person.Id;
userHistory.LanguageId = user.Language.Id;
_repositoryUserHistory.Add(userHistory, true);
user.Username = model.Username;
user.Email = model.Email;
user.LastModificationTime = DateTime.Now;
user.LastModifier = user;
user.Language = language;
var versionUser = user.Version;
user.Version = versionUser + 1;
var affectedUser = _repositoryUser.Update(user, true);
if (!_serviceMain.ApplicationSettings.SendMailAfterUpdateUserInformation)
{
return;
}
var emailUser = new EmailUser
{
Username = affectedUser.Username,
Password = string.Empty,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_serviceMain, _smtp);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.UpdateMyInformation);
}
public void Login(LoginModel model)
{
IValidator validator = new FluentValidator <LoginModel, LoginModelValidationRules>(model);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var user = _repositoryUser
.Join(x => x.Language)
.Join(x => x.Person)
.Join(x => x.Creator)
.Join(x => x.RoleUserLines)
.ThenJoin(x => x.Role)
.Join(x => x.SessionsCreatedBy)
.FirstOrDefault(x => x.Username == model.Username);
// Kullanıcı sistemde kayıtlı değilse
if (user == null)
{
throw new NotFoundException(Messages.DangerUserNotFound);
}
// Şifresi yanlış ise
if (model.Password.ToSha512() != user.Password)
{
throw new NotFoundException(Messages.DangerIncorrectPassword);
}
// Kullanıcı pasif durumda ise
if (!user.IsApproved)
{
throw new NotApprovedException(Messages.DangerItemNotApproved);
}
// Kullanıcının hiç rolü yoksa
if (user.RoleUserLines.Count <= 0)
{
throw new NotApprovedException(Messages.DangerUserHasNoRole);
}
var sessionIdList = new List <Guid>();
// Açık kalan oturumu varsa
if (user.SessionsCreatedBy?.Count > 0)
{
foreach (var session in user.SessionsCreatedBy)
{
// oturum bilgileri tarihçe tablosuna alınıyor
_repositorySessionHistory.Add(new SessionHistory
{
Id = GuidHelper.NewGuid(),
Creator = session.Creator,
CreationTime = session.CreationTime,
LastModificationTime = DateTime.Now,
LogoutType = SignOutOption.InvalidLogout.ToString()
}, true);
sessionIdList.Add(session.Id);
}
}
// Oturumlar siliniyor
foreach (var i in sessionIdList)
{
_repositorySession.Delete(_repositorySession.Get(e => e.Id == i), true);
}
// Yeni oturum kaydı yapılıyor
_repositorySession.Add(new Session
{
Id = GuidHelper.NewGuid(),
Creator = user,
CreationTime = DateTime.Now
}, true);
var roles = user.RoleUserLines
.Select(
line =>
_repositoryRoleUserLine
.Join(t => t.Role)
.FirstOrDefault(x => x.Id == line.Id).Role)
.Select(role => new KeyValuePair <Guid, string>(role.Id, role.Name)).ToList();
// Kimlik nesnesi
var identity = new CustomIdentity();
// Kullanıcıdaki bilgiler kullanılarak kimlik nesnesinin claim (hak) listesi ayarlanıyor
var claims = new List <Claim>
{
new Claim("UserId", user.Id.ToString()),
new Claim("Username", user.Username),
new Claim("FirstName", user.Person.FirstName),
new Claim("LastName", user.Person.LastName),
new Claim("DisplayName", user.Person.DisplayName),
new Claim("Email", user.Email),
new Claim("LanguageId", user.Language.Id.ToString()),
new Claim("IsAuthenticated", "true", ClaimValueTypes.Boolean),
new Claim("AuthenticationType", "Normal")
};
// claim listesi kimlik nesnesine ekleniyor.
identity.AddClaims(claims);
// Kullanıcının rol id'leri kimlik nesnesine ekleniyor.
foreach (var role in roles)
{
identity.AddClaim(new Claim(ClaimTypes.Role, role.Key.ToString()));
}
// Yetkilendirilme işlemleri için temel nesne oluşturuluyor
var principal = new CustomPrincipal(identity);
// Thread geçerli kimlik bilgisi ayarlanıyor
Thread.CurrentPrincipal = principal;
}
public AddModel <UserModel> Add(AddModel <UserModel> addModel)
{
var validator = new FluentValidator <UserModel, UserValidationRules>(addModel.Item);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _serviceMain.DefaultLanguage;
var item = addModel.Item.CreateMapped <UserModel, User>();
if (_repositoryUser.Get().FirstOrDefault(e => e.Username == item.Username) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Username));
}
if (_repositoryUser.Get(e => e.Email == item.Email) != null)
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Email));
}
var password = addModel.Item.Password.ToSha512();
Person person;
var maxDisplayOrderPerson = _repositoryPerson.Get().Max(e => e.DisplayOrder);
var maxDisplayOrderUser = _repositoryUser.Get().Max(e => e.DisplayOrder);
if (addModel.Item.IdentityCode != null)
{
if (_repositoryPerson.Get(x => x.IdentityCode == addModel.Item.IdentityCode) != null)
{
person = _repositoryPerson.Get(x => x.IdentityCode == addModel.Item.IdentityCode);
}
else
{
person = new Person
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderPerson + 1,
Version = 1,
IsApproved = false,
IdentityCode = addModel.Item.IdentityCode.Trim().Length > 0 ? addModel.Item.IdentityCode : GuidHelper.NewGuid().ToString(),
FirstName = addModel.Item.FirstName,
LastName = addModel.Item.LastName,
};
}
}
else
{
person = new Person
{
Id = GuidHelper.NewGuid(),
CreationTime = DateTime.Now,
LastModificationTime = DateTime.Now,
DisplayOrder = maxDisplayOrderPerson + 1,
Version = 1,
IsApproved = false,
IdentityCode = GuidHelper.NewGuid().ToString(),
FirstName = addModel.Item.FirstName,
LastName = addModel.Item.LastName,
};
}
person.CreatorId = _serviceMain.IdentityUser.Id;
person.LastModifierId = _serviceMain.IdentityUser.Id;
_repositoryPerson.Add(person, true);
item.Id = GuidHelper.NewGuid();
item.Creator = _serviceMain.IdentityUser;
item.CreationTime = DateTime.Now;
item.LastModificationTime = DateTime.Now;
item.LastModifier = _serviceMain.IdentityUser;
item.DisplayOrder = maxDisplayOrderUser + 1;
item.Person = person;
item.Language = language;
item.Version = 1;
var affectedUser = _repositoryUser.Add(item, true);
var role = _repositoryRole.Get(x => x.Code == RoleConstants.Default.Item1);
if (role == null)
{
throw new NotFoundException();
}
_repositoryRoleUserLine.Add(new RoleUserLine
{
Id = GuidHelper.NewGuid(),
User = affectedUser,
Role = role,
Creator = _serviceMain.IdentityUser,
CreationTime = DateTime.Now,
DisplayOrder = 1,
LastModifier = _serviceMain.IdentityUser,
LastModificationTime = DateTime.Now,
Version = 1
}, true);
addModel.Item = affectedUser.CreateMapped <User, UserModel>();
addModel.Item.Creator = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.LastModifier = new IdName(_serviceMain.IdentityUser.Id, _serviceMain.IdentityUser.Person.DisplayName);
addModel.Item.Language = new IdName(affectedUser.Language.Id, affectedUser.Language.Name);
addModel.Item.IdentityCode = affectedUser.Person.IdentityCode;
addModel.Item.FirstName = affectedUser.Person.FirstName;
addModel.Item.LastName = affectedUser.Person.LastName;
if (!_serviceMain.ApplicationSettings.SendMailAfterAddUser)
{
return(addModel);
}
var emailUser = new EmailUser
{
Username = affectedUser.Username,
Password = password,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_serviceMain, _smtp);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.Add);
return(addModel);
}
