public void Create(CodeFileViewModel model)
{
try
{
var codeFile = Read(x => x.ItemType.Equals(model.ItemType) && x.ItemCode.Equals(model.ItemCode));
if (codeFile != null)
{
if (!IsDeleted(codeFile))
{
ValidationDictionary.AddGeneralError(@LocalRes.Resource.MSG_Duplidate);
}
else
{
codeFile.ParentCodeFile = model.ParentCodeFile;
codeFile.CheckFlag = "";
//codeFile.ModUser = model.ModUser;
}
}
else
{
codeFile = ToCreateEntity(model);
Create(codeFile);
}
Save();
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public ValidationDictionary <ViewModelArticleCategory> DeleteArticleCategory(int clientId, int articleCategoryId)
{
var validator = new ValidationDictionary <ViewModelArticleCategory>();
var raw = _articleCategoryRepository.FindBy(o => o.ArticleCategoryId == articleCategoryId && o.ClientId == clientId);
if (raw != null)
{
raw.IsDeleted = true;
_articleCategoryRepository.Update(raw);
var articles = _articleItemRepository.FilterBy(a => a.ArticleCategory.ArticleCategoryId == articleCategoryId).ToList();
foreach (var item in articles)
{
//item.IsDeleted = true;
item.ArticleCategory = null;
_articleItemRepository.Update(item);
}
validator.IsValid = true;
}
else
{
validator.IsValid = false;
validator.AddError("", "The XX is not available in the database");
}
return(validator);
}
public bool SetInfoSetting(SettingView viewModel)
{
InfoSettings infoSettings = new InfoSettings();
var config = new MapperConfiguration(cfg => cfg.CreateMap <InfoSettingView, InfoSettings>());
var mapper = config.CreateMapper();
infoSettings = mapper.Map <InfoSettings>(viewModel.InfoSettingView);
if (viewModel.InfoSettingView.EnvironmentFile != null)
{
foreach (var file in viewModel.InfoSettingView.EnvironmentFile)
{
if (file != null)
{
var fileName = new System.IO.FileInfo(file.FileName).Name;
var s = MobileHis.Misc.Storage.GetStorage(StorageScope.HospitalEnvironment);
fileName = s.Write(fileName, file);
if (!string.IsNullOrEmpty(infoSettings.Hospital_Environment))
{
infoSettings.Hospital_Environment += ";";
}
infoSettings.Hospital_Environment += fileName;
}
}
}
if (!ValidationDictionary.IsValid())
{
return(false);
}
SetGroupSetting(SettingTypes.Info, infoSettings);
Save();
return(true);
}
public void Delete(int ID)
{
try
{
var rooms = db.Repository <Room>().ReadAll();
var relatedRooms = rooms.Where(a => a.Guardian_ID == ID);
foreach (var room in relatedRooms)
{
room.Guardian_ID = null;
}
var educationFiles = db.Repository <HealthEdu_File>().ReadAll();
var relatedFiles = educationFiles.Where(a => a.HealthEdu_ID == ID);
foreach (var file in relatedFiles)
{
var s = Storage.GetStorage(StorageScope.GuardianUpload);
s.Delete(file.FileName, file.HealthEdu_ID);
db.Repository <HealthEdu_File>().Delete(file);
}
var education = db.Repository <HealthEdu>().Read(a => a.ID == ID);
db.Repository <HealthEdu>().Delete(education);
Save();
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
private ValidationDictionary <ViewModelNewsCategory> SaveNewsCategory(int clientId, ViewModelNewsCategory viewModelNewsCategory)
{
var validator = new ValidationDictionary <ViewModelNewsCategory>();
if (viewModelNewsCategory == null)
{
validator.IsValid = false;
validator.AddError("", "The XX you're trying to save is null");
return(validator);
}
// rule based here
var existingWithSameName = _newsCategoryRepository
.FilterBy(o => o.NewsCategoryName.ToLower() == viewModelNewsCategory.NewsCategoryName.ToLower() &&
o.ClientId == clientId &&
!o.IsDeleted)
.ToList();
if (existingWithSameName.Any())
{
var haveSameId = viewModelNewsCategory.NewsCategoryId <= 0 ||
(viewModelNewsCategory.NewsCategoryId > 0 &&
existingWithSameName.Any(o => o.NewsCategoryId != viewModelNewsCategory.NewsCategoryId));
if (haveSameId)
{
validator.IsValid = false;
validator.AddError("", "News Category with same name is already existed");
return(validator);
}
}
NewsCategory newsCategory;
if (viewModelNewsCategory.NewsCategoryId > 0)
{
newsCategory = _newsCategoryRepository.FindBy(o => o.NewsCategoryId == viewModelNewsCategory.NewsCategoryId);
var dateCreated = newsCategory.DateCreated;
newsCategory.InjectFrom(viewModelNewsCategory);
newsCategory.ClientId = clientId;
newsCategory.DateLastUpdated = DateTime.UtcNow;
newsCategory.DateCreated = dateCreated;
_newsCategoryRepository.Update(newsCategory);
}
else
{
newsCategory = new NewsCategory();
newsCategory.InjectFrom(viewModelNewsCategory);
newsCategory.DateCreated = DateTime.UtcNow;
newsCategory.DateLastUpdated = DateTime.UtcNow;
newsCategory.ClientId = clientId;
_newsCategoryRepository.Add(newsCategory);
}
var rawPinged = _newsCategoryRepository.FindBy(o => o.NewsCategoryId == newsCategory.NewsCategoryId && o.ClientId == clientId);
var pinged = new ViewModelNewsCategory().InjectFrom(rawPinged) as ViewModelNewsCategory;
validator.IsValid = true;
validator.RelatedObject = pinged;
return(validator);
}
public void GetValidationError_All_Item_2()
{
// Arrange
var propertyName1 = "Item1";
var errorMessage1_1 = "ErrorMessage1_1.";
var errorMessage1_2 = "ErrorMessage1_2.";
var propertyName2 = "Item2";
var errorMessage2_1 = "ErrorMessage2_1.";
var errorMessage2_2 = "ErrorMessage2_2.";
var inner = new Dictionary <string, List <string> >
{
{ propertyName1, new List <string> {
errorMessage1_1, errorMessage1_2
} },
{ propertyName2, new List <string> {
errorMessage2_1, errorMessage2_2
} },
};
var dictionary = new ValidationDictionary(inner);
// Act
var actual = dictionary.GetValidationError(null);
// Assert
var expected = new List <string>
{
errorMessage1_1,
errorMessage1_2,
errorMessage2_1,
errorMessage2_2,
};
Assert.True(TestHelper.IsSameCollection(expected, actual));
}
public void Update(RoomModel model)
{
try
{
var item = Read(a => a.ID == model.ID);
if (item != null)
{
//item = _mapper.Map(model, item);
ToUpdateEntity(model, item);
var dept2Room = db.Repository <Dept2Room>().ReadAll().Where(a => a.Room_id == model.ID).ToList();
if (dept2Room != null)
{
db.Repository <Dept2Room>().Delete(dept2Room);
}
if (!model.AllowDept.IsNullOrEmpty())
{
CreateByText(model.AllowDept, model.ID);
}
}
Save();
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public ValidationDictionary <ViewModelPage> DeletePage(int clientId, int pageId)
{
var expression = _dynamicPageFilters.Init()
.GetByPageId(pageId)
.GetByClientId(clientId)
.GetNotDeleted()
.FilterExpression;
var dPage = _pageRepository.FindBy(expression);
var validator = new ValidationDictionary <ViewModelPage>();
if (dPage != null)
{
dPage.IsDeleted = true;
_pageRepository.Update(dPage);
validator.IsValid = true;
}
else
{
validator.IsValid = false;
validator.AddError("", "The Page is not found in the database");
}
return(validator);
}
public BaseResponseModel SignUp(SignUpInputModel inputModel)
{
var vm = new AuthResponseModel();
// Validate request
var validationState = new ValidationDictionary();
inputModel.ValidateRequest(validationState);
var user = new User
{
Email = inputModel.Email,
Role = Role.Member
};
UserService.GenerateUserPassword(user, inputModel.Password);
if (UserService.ValidateUser(user, validationState))
{
UserService.CreateUser(user);
// Authenticate to create token
user = UserService.Authenticate(user.Email, inputModel.Password);
_auth.DoAuth(user.Email, false);
vm.Success = true;
vm.Token = user.AuthToken.Token;
vm.Expires = user.AuthToken.Expires;
}
vm.Errors = validationState.Errors;
return(vm);
}
public void Update_Failed_Email_In_Use()
{
// Arrange
var existing = new Mock <User>();
existing.SetupProperty(u => u.Id, 2);
existing.SetupProperty(u => u.Email, "*****@*****.**");
existing.SetupProperty(u => u.HashedPassword, new byte[] { 0, 1, 2 });
var userList = new List <User>()
{
existing.Object
};
var userRepository = new Mock <IUserRepository>();
var permissionRepository = new Mock <IPermissionRepository>();
userRepository.Setup(u => u.FindAll()).Returns(userList.AsQueryable());
var userService = CreateUserService(userRepository.Object);
var validationDictionary = new ValidationDictionary();
var user = new Mock <User>();
user.SetupProperty(u => u.Id, 1);
user.SetupProperty(u => u.Email, "*****@*****.**");
user.SetupProperty(u => u.HashedPassword, new byte[] { 0, 1, 2 });
// Act
var result = userService.ValidateUser(user.Object, validationDictionary);
// Assert
Assert.IsFalse(result);
}
public ValidationDictionary <ViewModelPage> SavePage(int clientId, ViewModelPage viewModelPage)
{
// validation first
var validator = new ValidationDictionary <ViewModelPage>();
if (viewModelPage == null)
{
validator.IsValid = false;
validator.AddError("", "Page you're trying to save is null");
return(validator);
}
// rule based
if (viewModelPage.IsHomePage)
{
}
DynamicPage dPage;
if (viewModelPage.PageId <= 0)
{
// prepare object to save
dPage = new DynamicPage();
dPage.InjectFrom(viewModelPage);
dPage.ClientId = clientId;
dPage.DateCreated = DateTime.UtcNow;
dPage.DateLastUpdated = DateTime.UtcNow;
_pageRepository.Add(dPage);
}
else
{
var gExpression = _dynamicPageFilters.Init()
.GetByPageId(viewModelPage.PageId)
.GetByClientId(clientId)
.GetNotDeleted()
.FilterExpression;
dPage = _pageRepository.FindBy(gExpression);
if (dPage != null)
{
// excluded fields
var createdDate = dPage.DateCreated;
// update data
dPage.InjectFrom(viewModelPage);
dPage.DateCreated = createdDate;
dPage.DateLastUpdated = DateTime.UtcNow;
dPage.IsDeleted = false;
_pageRepository.Update(dPage);
}
}
var pingedPaged = GetPage(clientId, dPage.PageId);
validator.IsValid = true;
validator.RelatedObject = pingedPaged;
return(validator);
}
public async Task <ReferralCodeServiceResult> GenerateReferralCodeForUserAsync(string userId)
{
Debug.Assert(!String.IsNullOrEmpty(userId));
var code = GuidEncoder.Encode(Guid.NewGuid().ToString());
bool success = false;
try
{
db.Referrals.Add(new Referral()
{
Code = code,
UserId = userId,
IsRedeemed = false,
DateCreated = DateTime.Now
});
success = (await db.SaveChangesAsync()) > 0;
}
catch (DbUpdateException ex)
{
Log.Error("UserService.GenerateReferralCodeForUserAsync", ex, new { userId, code });
ValidationDictionary.AddError(Guid.NewGuid().ToString(), ErrorMessages.ReferralCodeNotGenerated);
}
return(success ? ReferralCodeServiceResult.Success(code) : ReferralCodeServiceResult.Failed(ErrorMessages.ReferralCodeNotGenerated));
}
public bool Add(string code, string name, string type)
{
try
{
if (db.Repository <ICD10>().ReadAll().Any(a => a.ICD10Code == code))
{
ValidationDictionary.AddGeneralError("Duplicated");
return(false);
}
db.Repository <ICD10>().Create(new ICD10
{
ICD10Code = code,
StdName = name,
Type = type
});
Save();
return(true);
}
catch (Exception ex)
{
ValidationDictionary.AddPropertyError <ICD10ViewModel>(
i => i.ICD10Code, ex.Message);
return(false);
}
}
private void ValidateUserName(string name, int id)
{
if (UnitOfWork.UserRepository.GetAllNoTracking().Any(u => u.Username == name && u.Id != id))
{
ValidationDictionary.AddError("UserName", "This user name already exists");
}
}
public void RemoveErrorByKey2_1()
{
// Arrange
var propertyName1 = "Item1";
var errorMessage1_1 = "ErrorMessage1_1.";
var errorMessage1_2 = "ErrorMessage1_2.";
var propertyName2 = "Item2";
var errorMessage2_1 = "ErrorMessage2_1.";
var errorMessage2_2 = "ErrorMessage2_2.";
var inner = new Dictionary <string, List <string> >
{
{ propertyName1, new List <string> {
errorMessage1_1, errorMessage1_2
} },
{ propertyName2, new List <string> {
errorMessage2_1, errorMessage2_2
} },
};
var dictionary = new ValidationDictionary(inner);
// Act
dictionary.RemoveErrorByKey(propertyName1);
// Assert
Assert.False(inner.ContainsKey(propertyName1));
Assert.True(inner.ContainsKey(propertyName2));
}
public void Create(RoomModel model)
{
try
{
var item = Read(a => a.RoomNo.Equals(
model.RoomNo, StringComparison.CurrentCultureIgnoreCase));
if (item != null)
{
DuplicatedError();
}
else
{
//item =_mapper.Map<Room>(model);
item = ToCreateEntity(model);
item.RoomNo = model.RoomNo;
Create(item);
if (!model.AllowDept.IsNullOrEmpty())
{
CreateByText(model.AllowDept, item.ID);
}
Save();
}
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public ValidationDictionary<DynamicPageDto> DeletePage(int clientId, int pageId)
{
var expression = _dynamicPageFilters.Init()
.GetByPageId(pageId)
.GetByClientId(clientId)
.GetNotDeleted()
.FilterExpression;
var dPage = _pageRepository.FindBy(expression);
var validator = new ValidationDictionary<DynamicPageDto>();
if (dPage != null)
{
dPage.IsDeleted = true;
_pageRepository.Update(dPage);
validator.IsValid = true;
}
else
{
validator.IsValid = false;
validator.AddError("", "The Page is not found in the database");
}
return validator;
}
public void Create(AccountCreateView model)
{
try
{
model.Email = model.Email + Config.AppSetting("EmailDomain");
if (db.Repository <Account>().ReadAll()
.Any(x => x.Email.Equals(model.Email, StringComparison.InvariantCultureIgnoreCase) ||
x.UserNo.Equals(model.UserNo, StringComparison.InvariantCultureIgnoreCase)))
{
ValidationDictionary.AddPropertyError <AccountCreateView>(a => a.Email, "Email Duplicated.");
}
else
{
model.MapTo(out Account account);
account.Password = Config.Md5Salt(model.Password);
Array.ForEach(
model.DepartmentIDs.OrEmptyIfNull().Concat(model.BureauDepartmentIDs.OrEmptyIfNull()).ToArray()
, a => account.Account2Dept.Add(new Account2Dept(a)));
Array.ForEach(model.RoleIDs.OrEmptyIfNull().ToArray()
, a => account.Account2Role.Add(new Account2Role(a)));
Create(account);
Save();
}
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public void ChangePassword(ChangePasswordView model)
{
try
{
string md5SaltPassword = Config.Md5Salt(model.Password);
var account = Read(x =>
x.Email.Equals(_principal.Email, StringComparison.InvariantCultureIgnoreCase) &&
x.Password == md5SaltPassword);
//判斷是否存在
if (account == null)
{
ValidationDictionary.AddGeneralError("Account ID or password error");
}
else
{
account.Password = Config.Md5Salt(model.newPassword);
account.ModDate = System.DateTime.Now;
Save();
}
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public void Edit(AccountEditView model)
{
try
{
var account = Read(a => a.ID == model.ID);
if (!account.HasValue())
{
ValidationDictionary.AddPropertyError <Account>(a => a.ID, "ID not found.");
return;
}
if (ReadAll()
.Any(x => (x.Email.Equals(model.Email, StringComparison.InvariantCultureIgnoreCase) ||
x.UserNo.Equals(model.UserNo, StringComparison.InvariantCultureIgnoreCase)
) && x.ID != model.ID))
{
ValidationDictionary.AddPropertyError <AccountEditView>(a => a.Email, "Email Duplicated."); //.AddGeneralError("Email Duplicated");
}
else
{
model.MapTo(account);
db.Repository <Account2Dept>().Delete(a => a.AccountId == model.ID);
Array.ForEach(
model.DepartmentIDs.OrEmptyIfNull().Concat(model.BureauDepartmentIDs.OrEmptyIfNull()).ToArray()
, a => account.Account2Dept.Add(new Account2Dept(a)));
db.Repository <Account2Role>().Delete(a => a.Account_id == model.ID);
Array.ForEach(model.RoleIDs.OrEmptyIfNull().ToArray()
, a => account.Account2Role.Add(new Account2Role(a)));
Save();
}
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public BaseResponseModel ResetPassword(ResetPasswordInputModel inputModel)
{
// Get existing user
var vm = new BaseResponseModel();
var validationState = new ValidationDictionary();
inputModel.ValidateRequest(validationState);
if (validationState.IsValid)
{
var user = UserService.GetUserByResetToken(inputModel.ResetToken);
if (user != null)
{
UserService.ResetPassword(user, inputModel.Password);
vm.Success = true;
}
else
{
validationState.AddError("ResetToken", "Invalid reset token.");
}
}
vm.Errors = validationState.Errors;
return(vm);
}
private void ValidateEmail(string email, int id)
{
if (UnitOfWork.UserRepository.GetAllNoTracking().Any(u => u.Email == email && u.Id != id))
{
ValidationDictionary.AddError("Email", "This email address is already registered to a user");
}
}
public void DeleteIMG(int ID)
{
try
{
var file = db.Repository <HealthEdu_File>().Read(a => a.ID == ID);
var files = file.Guardian.HealthEdu_File
.Where(a => a.ID != file.ID)
.OrderByDescending(a => a.IsUsed)
.ThenBy(a => a.Show_Order).ToList();
db.Repository <HealthEdu_File>().Delete(file);
for (int i = 0; i < files.Count; i++)
{
var g = files[i];
g.Show_Order = i + 1;
}
var s = Storage.GetStorage(StorageScope.GuardianUpload);
s.Delete(file.FileName, file.HealthEdu_ID);
Save();
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public bool IsValid()
{
if (ValidationDictionary == null)
{
return(false);
}
return(!ValidationDictionary.Any());
}
public override void Update(Project project)
{
if (Repository.Get(t => t.ProjectNumber == project.ProjectNumber && t.Id != project.Id).Any())
{
ValidationDictionary.AddError("ProjectNumber", "Unique project number required");
}
else
{
base.Update(project);
}
}
public void IsValidTrue()
{
// Arrange
var dictionary = new ValidationDictionary();
// Act
var actual = dictionary.IsValid;
// Assert
Assert.True(actual);
}
/// <summary>
/// Validate form-level request
/// </summary>
/// <param name="validationDictionary"></param>
public bool ValidateRequest(IValidationDictionary validationDictionary)
{
var requestDictionary = new ValidationDictionary();
if (Password != ConfirmPassword)
{
requestDictionary.AddError("Password", "Passwords do not match.");
}
validationDictionary.Merge(requestDictionary);
return(requestDictionary.IsValid);
}
public override void Update(ComponentSeries component)
{
if (Repository.GetAllNoTracking().Any(t => t.Name == component.Name && t.VendorId == component.VendorId && t.Id != component.Id))
{
ValidationDictionary.AddError("SeriesName", "Unique name required");
}
else
{
base.Update(component);
}
}
public ValidationDictionary <ViewModelDailyBreadItem> SaveDailyBreadItem(int clientId, ViewModelDailyBreadItem viewModelDailyBread)
{
var validator = new ValidationDictionary <ViewModelDailyBreadItem>();
if (viewModelDailyBread == null)
{
validator.IsValid = false;
validator.AddError("", "The XX you're trying to save is null");
return(validator);
}
// rule based here
DailyBreadItem dailyBreadItem;
if (viewModelDailyBread.DailyBreadId <= 0)
{
dailyBreadItem = new DailyBreadItem();
dailyBreadItem.InjectFrom(viewModelDailyBread);
dailyBreadItem.DateCreated = DateTime.UtcNow;
dailyBreadItem.DateLastUpdated = DateTime.UtcNow;
dailyBreadItem.ClientId = clientId;
_dailyBreadItemRepository.Add(dailyBreadItem);
}
else
{
dailyBreadItem = _dailyBreadItemRepository.FindBy(o => !o.IsDeleted &&
o.DailyBreadId == viewModelDailyBread.DailyBreadId &&
o.ClientId == clientId);
if (dailyBreadItem != null)
{
var createdDate = dailyBreadItem.DateCreated;
dailyBreadItem.InjectFrom(viewModelDailyBread);
dailyBreadItem.DateLastUpdated = DateTime.UtcNow;
dailyBreadItem.DateCreated = createdDate;
dailyBreadItem.IsDeleted = false;
_dailyBreadItemRepository.Update(dailyBreadItem);
}
}
UpdateDailyBreadUrl(dailyBreadItem.DailyBreadId);
var pinged = GetDailyBreadItem(clientId, dailyBreadItem.DailyBreadId);
validator.IsValid = true;
validator.RelatedObject = pinged;
return(validator);
}
public void Create(EducationModel model)
{
try
{
var education = ToCreateEntity(model);
Create(education);
Save();
}
catch (Exception ex)
{
ValidationDictionary.AddGeneralError(ex.Message);
}
}
public ValidationDictionary <ViewModelNewsItem> SaveNewsItem(int clientId, ViewModelNewsItem viewModelNews)
{
var validator = new ValidationDictionary <ViewModelNewsItem>();
if (viewModelNews == null)
{
validator.IsValid = false;
validator.AddError("", "The News you're trying to save is null");
return(validator);
}
// rule based here
viewModelNews.DateExpired = viewModelNews.DateExpired.DatePart();
viewModelNews.DatePublished = viewModelNews.DatePublished.DatePart();
NewsItem newsItem;
if (viewModelNews.NewsId <= 0)
{
newsItem = new NewsItem();
newsItem.InjectFrom <CloneInjection>(viewModelNews);
newsItem.DateCreated = DateTime.UtcNow;
newsItem.DateLastUpdated = DateTime.UtcNow;
newsItem.ClientId = clientId;
_newsRepository.Add(newsItem);
}
else
{
newsItem = _newsRepository.FindBy(o => !o.IsDeleted && o.NewsId == viewModelNews.NewsId && o.ClientId == clientId);
if (newsItem != null)
{
var createdDate = newsItem.DateCreated;
newsItem.InjectFrom <CloneInjection>(viewModelNews);
newsItem.DateLastUpdated = DateTime.UtcNow;
newsItem.DateCreated = createdDate;
newsItem.IsDeleted = false;
_newsRepository.Update(newsItem);
}
}
// update news url
UpdateNewsUrl(newsItem.NewsId);
var pingedNews = GetNewsItem(clientId, newsItem.NewsId);
validator.IsValid = true;
validator.RelatedObject = pingedNews;
return(validator);
}
public ValidationDictionary<DailyBreadItemDto> DeleteDailyBreadItem(int clientId, int dailybreadId)
{
var validator = new ValidationDictionary<DailyBreadItemDto>();
var raw = _dailyBreadItemRepository.FindBy(o => o.DailyBreadId == dailybreadId && o.ClientId == clientId);
if (raw != null)
{
raw.IsDeleted = true;
_dailyBreadItemRepository.Update(raw);
validator.IsValid = true;
}
else
{
validator.IsValid = false;
validator.AddError("", "The Daily Bread is not available in the database");
}
return validator;
}
public void Validation_Success_With_Valid_Resource()
{
// Arrange
var resource = CreateResource(1);
var resourceRepository = new Mock<IResourceRepository>();
var resourceService = CreateResourceService(resourceRepository.Object);
var validationDictionary = new ValidationDictionary();
// Act
resourceService.ValidateResource(resource, validationDictionary);
// Assert
Assert.IsTrue(validationDictionary.IsValid);
}
public void Validation_Fails_Missing_Name()
{
// Arrange
var resource = new Mock<Resource>();
resource.SetupProperty(l => l.Id, 1);
resource.SetupProperty(l => l.Value, "penguin");
resource.SetupProperty(l => l.Type, ResourceType.Html);
resource.SetupProperty(l => l.Category, ResourceCategory.Content);
var resourceRepository = new Mock<IResourceRepository>();
var resourceService = CreateResourceService(resourceRepository.Object);
var validationDictionary = new ValidationDictionary();
// Act
resourceService.ValidateResource(resource.Object, validationDictionary);
// Assert
Assert.IsFalse(validationDictionary.IsValid);
}
public ValidationDictionary<DynamicPageDto> SavePage(int clientId, DynamicPageDto pageDto, bool setAsHomePage)
{
// validation first
var validator = new ValidationDictionary<DynamicPageDto>();
if (pageDto == null)
{
validator.IsValid = false;
validator.AddError("", "Page you're trying to save is null");
return validator;
}
// rule based
if (setAsHomePage)
{
// get previous homepage, update it to another url path
}
DynamicPage dPage;
if (pageDto.PageId <= 0)
{
// prepare object to save
dPage = new DynamicPage();
dPage.PageName = pageDto.PageName;
dPage.PageMenuName = pageDto.PageMenuName;
dPage.PageUrl = pageDto.PageUrl;
dPage.PageDescription = pageDto.PageDescription;
dPage.PageContent = pageDto.PageContent;
dPage.MetaTitle = pageDto.MetaTitle;
dPage.MetaDescription = pageDto.MetaDescription;
dPage.ClientId = clientId;
dPage.DateCreated = DateTime.UtcNow;
dPage.DateLastUpdated = DateTime.UtcNow;
_pageRepository.Add(dPage);
}
else
{
var gExpression = _dynamicPageFilters.Init()
.GetByPageId(pageDto.PageId)
.GetByClientId(clientId)
.GetNotDeleted()
.FilterExpression;
dPage = _pageRepository.FindBy(gExpression);
if (dPage != null)
{
dPage.PageName = pageDto.PageName;
dPage.PageMenuName = pageDto.PageMenuName;
dPage.PageUrl = pageDto.PageUrl;
dPage.PageDescription = pageDto.PageDescription;
dPage.PageContent = pageDto.PageContent;
dPage.MetaTitle = pageDto.MetaTitle;
dPage.MetaDescription = pageDto.MetaDescription;
dPage.DateLastUpdated = DateTime.UtcNow;
dPage.IsDeleted = false;
_pageRepository.Update(dPage);
}
}
dPage = dPage ?? new DynamicPage();
var pingedPaged = GetPage(clientId, dPage.PageId);
validator.IsValid = true;
validator.RelatedObject = pingedPaged;
return validator;
}
public ValidationDictionary<DailyBreadItemDto> SaveDailyBreadItem(int clientId, DailyBreadItemDto dailyBreadDto)
{
var validator = new ValidationDictionary<DailyBreadItemDto>();
if (dailyBreadDto == null)
{
validator.IsValid = false;
validator.AddError("", "The XX you're trying to save is null");
return validator;
}
// rule based here
DailyBreadItem dailyBreadItem;
if (dailyBreadDto.DailyBreadId <= 0)
{
dailyBreadItem = new DailyBreadItem();
dailyBreadItem.DailyBreadTitle = dailyBreadDto.DailyBreadTitle;
dailyBreadItem.DailyBreadUrl = dailyBreadDto.DailyBreadUrl;
dailyBreadItem.DailyBreadSummary = dailyBreadDto.DailyBreadSummary;
dailyBreadItem.DatePublished = dailyBreadDto.DatePublished;
dailyBreadItem.DailyBreadBook = dailyBreadDto.DailyBreadBook;
dailyBreadItem.DailyBreadBookChapter = dailyBreadDto.DailyBreadBookChapter;
dailyBreadItem.DailyBreadBookVerse1 = dailyBreadDto.DailyBreadBookVerse1;
dailyBreadItem.DailyBreadBookVerse2 = dailyBreadDto.DailyBreadBookVerse2;
dailyBreadItem.DailyBreadBookContent = dailyBreadDto.DailyBreadBookContent;
dailyBreadItem.DailyBreadContent = dailyBreadDto.DailyBreadContent;
dailyBreadItem.DateCreated = DateTime.UtcNow;
dailyBreadItem.DateLastUpdated = DateTime.UtcNow;
dailyBreadItem.DailyBreadBookLang = dailyBreadDto.DailyBreadBookLang;
dailyBreadItem.ClientId = clientId;
_dailyBreadItemRepository.Add(dailyBreadItem);
}
else
{
dailyBreadItem = _dailyBreadItemRepository.FindBy(o => !o.IsDeleted
&& o.DailyBreadId == dailyBreadDto.DailyBreadId
&& o.ClientId == clientId);
if (dailyBreadItem != null)
{
dailyBreadItem.DailyBreadTitle = dailyBreadDto.DailyBreadTitle;
dailyBreadItem.DailyBreadUrl = dailyBreadDto.DailyBreadUrl;
dailyBreadItem.DailyBreadSummary = dailyBreadDto.DailyBreadSummary;
dailyBreadItem.DatePublished = dailyBreadDto.DatePublished;
dailyBreadItem.DailyBreadBook = dailyBreadDto.DailyBreadBook;
dailyBreadItem.DailyBreadBookChapter = dailyBreadDto.DailyBreadBookChapter;
dailyBreadItem.DailyBreadBookVerse1 = dailyBreadDto.DailyBreadBookVerse1;
dailyBreadItem.DailyBreadBookVerse2 = dailyBreadDto.DailyBreadBookVerse2;
dailyBreadItem.DailyBreadBookContent = dailyBreadDto.DailyBreadBookContent;
dailyBreadItem.DailyBreadContent = dailyBreadDto.DailyBreadContent;
dailyBreadItem.DateLastUpdated = DateTime.UtcNow;
dailyBreadItem.DailyBreadBookLang = dailyBreadDto.DailyBreadBookLang;
dailyBreadItem.IsDeleted = false;
_dailyBreadItemRepository.Update(dailyBreadItem);
}
}
dailyBreadItem = dailyBreadItem ?? new DailyBreadItem();
UpdateDailyBreadUrl(dailyBreadItem.DailyBreadId);
var pinged = GetDailyBreadItem(clientId, dailyBreadItem.DailyBreadId);
validator.IsValid = true;
validator.RelatedObject = pinged;
return validator;
}
public void Update_Failed_Email_In_Use()
{
// Arrange
var existing = new Mock<User>();
existing.SetupProperty(u => u.Id, 2);
existing.SetupProperty(u => u.Email, "*****@*****.**");
existing.SetupProperty(u => u.HashedPassword, new byte[] { 0, 1, 2 });
var userList = new List<User>()
{
existing.Object
};
var userRepository = new Mock<IUserRepository>();
var permissionRepository = new Mock<IPermissionRepository>();
userRepository.Setup(u => u.FindAll()).Returns(userList.AsQueryable());
var userService = CreateUserService(userRepository.Object);
var validationDictionary = new ValidationDictionary();
var user = new Mock<User>();
user.SetupProperty(u => u.Id, 1);
user.SetupProperty(u => u.Email, "*****@*****.**");
user.SetupProperty(u => u.HashedPassword, new byte[] { 0, 1, 2 });
// Act
var result = userService.ValidateUser(user.Object, validationDictionary);
// Assert
Assert.IsFalse(result);
}
public void User_Validation_Fails_Missing_Email()
{
// Arrange
var userRepository = new Mock<IUserRepository>();
var userService = CreateUserService(userRepository.Object);
var validationDictionary = new ValidationDictionary();
var user = new Mock<User>();
user.SetupProperty(u => u.Id, 1);
user.SetupProperty(u => u.HashedPassword, new byte[] { 0, 1, 2 });
// Act
var result = userService.ValidateUser(user.Object, validationDictionary);
// Assert
Assert.IsFalse(result);
}
public void User_Validation_Fails_Missing_Password()
{
// Arrange
var userRepository = new Mock<IUserRepository>();
var userService = CreateUserService(userRepository.Object);
var validationDictionary = new ValidationDictionary();
var user = new Mock<User>();
user.SetupProperty(u => u.Id, 1);
user.SetupProperty(u => u.Email, "*****@*****.**");
// Act
var result = userService.ValidateUser(user.Object, validationDictionary);
// Assert
Assert.IsFalse(result);
}
public void Validation_Success_With_Valid_Info()
{
// Arrange
var userRepository = new Mock<IUserRepository>();
var userService = CreateUserService(userRepository.Object);
var validationDictionary = new ValidationDictionary();
var user = new Mock<User>();
user.SetupProperty(u => u.Id, 1);
user.SetupProperty(u => u.Email, "*****@*****.**");
user.SetupProperty(u => u.HashedPassword, new byte[] { 0, 1, 2 });
// Act
var result = userService.ValidateUser(user.Object, validationDictionary);
// Assert
Assert.IsTrue(result);
}
