public async Task <CommonResult> UpdateCoverAsync(ClaimsPrincipal claimsPrincipal, UserPhotoUpdateModel criterias)
{
try
{
if (!criterias.CanEdit)
{
throw new UnauthorizedAccessException();
}
var currentUserId = GetCurrentUserId(claimsPrincipal);
var result = await _userPhotoService.UpdateUserPhotoAsync(new UserPhotoUpdateRequest
{
PhotoUrl = criterias.PhotoUrl,
FileName = criterias.FileName,
Width = criterias.Width,
Height = criterias.Height,
Scale = criterias.Scale,
XAxis = criterias.XAxis,
YAxis = criterias.YAxis,
UserPhotoTypeId = (int)UserPictureType.Cover
}, currentUserId);
return(CommonResult.Success(result));
}
catch (Exception)
{
throw;
}
}
public async Task <CommonResult> ForgotPasswordAsync(ForgotPasswordModel criterias)
{
ValidateForgotPassword(criterias);
var user = await _userManager.FindByEmailAsync(criterias.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
throw new CaminoApplicationException("ForgotPasswordConfirmation");
}
var resetPasswordToken = await _userManager.GeneratePasswordResetTokenAsync(user);
var result = await _userManager.SetAuthenticationTokenAsync(user, ServiceProvidersNameConst.CAMINO_API_AUTH, IdentitySettings.RESET_PASSWORD_PURPOSE, resetPasswordToken);
if (!result.Succeeded)
{
var errors = result.Errors.Select(x => new CommonError
{
Message = x.Description,
Code = x.Code
});
return(CommonResult.Failed(errors));
}
await SendPasswordChangeAsync(criterias, user, resetPasswordToken);
return(CommonResult.Success());
}
public async Task <CommonResult> ResetPasswordAsync(ResetPasswordModel criterias)
{
ValidateResetPassword(criterias);
var user = await _userManager.FindByEmailAsync(criterias.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
throw new UnauthorizedAccessException("ResetPasswordFailed");
}
var result = await _userManager.ResetPasswordAsync(user, criterias.Key, criterias.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(x => new CommonError()
{
Message = x.Description,
Code = x.Code
});
return(CommonResult.Failed(errors));
}
await _userManager.RemoveAuthenticationTokenAsync(user, ServiceProvidersNameConst.CAMINO_API_AUTH, criterias.Key);
return(CommonResult.Success());
}
public async Task <CommonResult> Add(UserRatingDto ratingDto)
{
if (string.IsNullOrEmpty(ratingDto.Feedback))
{
return(CommonResult.Failure("Cannot create user without field provided."));
}
if (string.IsNullOrEmpty(ratingDto.UserAssessorId))
{
return(CommonResult.Failure("Cannot create user without userAssessorId provided."));
}
if (string.IsNullOrEmpty(ratingDto.UserEvaluatedId))
{
return(CommonResult.Failure("Cannot create user without userEvaluatedId provided."));
}
if (Enum.IsDefined(typeof(StarNumberType), ratingDto.StarType))
{
return(CommonResult.Failure("Wrong enum value."));
}
await _ratingsRepository.Add(ratingDto);
return(CommonResult.Success());
}
public async Task <ActionResult> Login([FromBody] BKLoginInfo loginInfo)
{
if (HttpContext.Session.GetString("user") != null)
{
return(Ok(CommonResult.Fail("already login")));
}
BkUser user = await _userReposity.GetUserByAccount(loginInfo.Account);
if (user == null)
{
return(Ok(CommonResult.Fail("e - mail address don't exist")));
}
if (await _userInfoReposity.GetState(user.UId) == 0)
{
return(Ok(CommonResult.Fail("you have been banned, please contact administrator first")));
}
if (user.Password == MD5Util.GenerateMD5(loginInfo.Password, user.Salt))
{
HttpContext.Session.SetString("user", user.Account);
return(Ok(CommonResult.Success(user.Account)));
}
else
{
return(Ok(CommonResult.Fail("password error")));
}
}
/*----------------------*/
public CommonResult <IEnumerable <LocationFormDto> > ShowBarsInformaiton(string sortOrder, string searchString = null)
{
if (_db.Locations.Count() == 0)
{
return(CommonResult <IEnumerable <LocationFormDto> >
.Failure <IEnumerable <LocationFormDto> >
("The DB does not contain any location yet..."));
}
var adapter = new SqlDataAdapter();
var con = new SqlConnection();
con.ConnectionString = ConnectionString;
var select = new SqlCommand("SELECT Id, Name, Address, Latitude, Longitude" +
" FROM Locations", con);
// select.Parameters.AddWithValue("@Name", searchString);
adapter.SelectCommand = select;
var ds = new DataSet();
adapter.Fill(ds, "Locations");
var table = ds.Tables[0];
var data = _sorting.Mapping(table, searchString).ToList();
return(CommonResult <IEnumerable <LocationFormDto> >
.Success(_sorting.SortByQuery(data
, sortOrder)));
}
public CommonResult <IQueryable <DrinksInfoDto> > GetDrinksList()
{
IQueryable <DrinksInfoDto> DrinksList;
if (_db.Drinks.Any())
{
return(CommonResult <IQueryable <DrinksInfoDto> >
.Failure <IQueryable <DrinksInfoDto> >("No drinks Yet..."));
}
try
{
DrinksList = from a in _db.Drinks
join b in _db.Locations
on a.LocationOfDrinkId equals b.Id
join c in _db.DrinkTypes
on a.DrinkTypeId equals c.Id
select new DrinksInfoDto
{
Name = a.Name,
Price = a.Price,
Type = c.Name,
Location = b.Name
};
}
catch (Exception ex)
{
return(CommonResult <IQueryable <DrinksInfoDto> >
.Failure <IQueryable <DrinksInfoDto> >("Something Wrong with Db" + ex.Message));
}
return(CommonResult <IQueryable <DrinksInfoDto> >
.Success(DrinksList));
}
public async Task <CommonResult> ActiveAsync(ActiveUserModel criterias)
{
var user = await _userManager.FindByNameAsync(criterias.Email);
if (!await _userManager.IsEmailConfirmedAsync(user))
{
var result = await _userManager.ConfirmEmailAsync(user, criterias.ActiveKey);
if (result.Succeeded)
{
return(CommonResult.Success());
}
var errors = result.Errors.Select(x => new CommonError()
{
Message = x.Description,
Code = x.Code
});
return(CommonResult.Failed(errors));
}
return(CommonResult.Failed(new CommonError()
{
Message = "The user is already confirmed"
}));
}
public async Task <CommonResult <UserWorkPhotoDto> > GetById(int id)
{
var photoDto = await _photosOfWorkRepository.GetById(id);
if (photoDto == null)
{
return(CommonResult <UserWorkPhotoDto> .Failure <UserWorkPhotoDto>("Problem occured during fetching photo url with given id."));
}
return(CommonResult <UserWorkPhotoDto> .Success(photoDto));
}
public async Task <CommonResult <ExperianceDto> > GetById(int id)
{
var person = await _experiancesRepository.GetById(id);
if (person == null)
{
return(CommonResult <ExperianceDto> .Failure <ExperianceDto>("Problem occured during fetching project with given id."));
}
return(CommonResult <ExperianceDto> .Success(person));
}
public async Task <CommonResult <QualificationDto> > GetUser(int id)
{
var person = await _qualificationsRepository.GetById(id);
if (person == null)
{
return(CommonResult <QualificationDto> .Failure <QualificationDto>("Problem occured during fetching qualification with given id."));
}
return(CommonResult <QualificationDto> .Success(person));
}
public async Task <CommonResult <ApplicationUserDto> > GetUser(string id)
{
var person = await _personRepository.GetUser(id);
if (person == null || person.IsDeleted)
{
return(CommonResult <ApplicationUserDto> .Failure <ApplicationUserDto>("Problem occured during fetching project with given id."));
}
return(CommonResult <ApplicationUserDto> .Success(person));
}
public async Task <CommonResult> Update(UserWorkPhotoDto photoDto)
{
var updateApplicationUserDto = await _photosOfWorkRepository.Update(photoDto);
if (updateApplicationUserDto == null)
{
return(CommonResult <UserWorkPhotoDto> .Failure <UserWorkPhotoDto>("Problem occured updating entity."));
}
return(CommonResult <UserWorkPhotoDto> .Success(photoDto));
}
public async Task <CommonResult> Update(ApplicationUserDto user)
{
var updateApplicationUserDto = await _personRepository.UpdateUser(user);
if (updateApplicationUserDto == null || updateApplicationUserDto.IsDeleted)
{
return(CommonResult <ApplicationUserDto> .Failure <ApplicationUserDto>("Problem occured updating entity."));
}
return(CommonResult <ApplicationUserDto> .Success(user));
}
public async Task <CommonResult> Update(QualificationDto qualificationDto)
{
var updateQualificationDto = await _qualificationsRepository.Update(qualificationDto);
if (updateQualificationDto == null)
{
return(CommonResult <QualificationDto> .Failure <QualificationDto>("Problem occured updating entity."));
}
return(CommonResult <QualificationDto> .Success(qualificationDto));
}
public async Task <CommonResult> Update(ExperianceDto experianceDto)
{
var updateExperianceDto = await _experiancesRepository.Update(experianceDto);
if (updateExperianceDto == null)
{
return(CommonResult <ExperianceDto> .Failure <ExperianceDto>("Problem occured updating entity."));
}
return(CommonResult <ExperianceDto> .Success(experianceDto));
}
public async Task <CommonResult> Add(ExperianceDto experianceDto)
{
if (await CheckIfExperianceAlreadyExist(experianceDto.UserId, experianceDto.ExperianceType))
{
return(CommonResult.Failure("This experiance User already has"));
}
await _experiancesRepository.Add(experianceDto);
return(CommonResult.Success());
}
public CommonResult <ProjectDto> GetById(int id)
{
var project = _projectsRepository.GetById(id);
if (project == null || project.IsDeleted)
{
return(CommonResult <ProjectDto> .Failure <ProjectDto>("Problem occured during fetching project with given id."));
}
else
{
return(CommonResult <ProjectDto> .Success <ProjectDto>(project));
}
}
public CommonResult <IEnumerable <LocationFeedbackDto> > GetFeedbackList(int id)
{
IEnumerable <LocationFeedbackDto> loc = _db.LocationFeedbacks.Where(a => a.LocationId == id).Select(a => new LocationFeedbackDto
{
Id = a.Id,
LocationId = a.LocationId,
Feedback = a.Feedback,
User = a.User
});
return(CommonResult <IEnumerable <LocationFeedbackDto> >
.Success <IEnumerable <LocationFeedbackDto> >(loc));
}
public async Task <CommonResult> Add(UserWorkPhotoDto experianceDto)
{
if (string.IsNullOrEmpty(experianceDto.ApplicationUserId))
{
return(CommonResult.Failure("Empty user Id"));
}
if (string.IsNullOrEmpty(experianceDto.PhotoUrl))
{
return(CommonResult.Failure("Cannot create photo without its url address"));
}
await _photosOfWorkRepository.Add(experianceDto);
return(CommonResult.Success());
}
public async Task <CommonResult> Add(QualificationDto qualificationDto)
{
if (string.IsNullOrEmpty(qualificationDto.QualificationField))
{
return(CommonResult.Failure("Cannot create user without field provided."));
}
if (string.IsNullOrEmpty(qualificationDto.ApplicationUserId))
{
return(CommonResult.Failure("Cannot create user without user Id provided."));
}
await _qualificationsRepository.Add(qualificationDto);
return(CommonResult.Success());
}
public async Task <CommonResult> SignupAsync(SignupModel criterias)
{
var user = new ApplicationUser()
{
BirthDate = criterias.BirthDate,
DisplayName = $"{criterias.Lastname} {criterias.Firstname}",
Email = criterias.Email,
Firstname = criterias.Firstname,
Lastname = criterias.Lastname,
GenderId = (byte)criterias.GenderId,
StatusId = (byte)UserStatus.Pending,
UserName = criterias.Email,
};
try
{
var result = await _userManager.CreateAsync(user, criterias.Password);
if (result.Succeeded)
{
user = await _userManager.FindByNameAsync(user.UserName);
var confirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
await SendActiveEmailAsync(user, confirmationToken);
}
else
{
return(CommonResult.Failed(result.Errors.Select(x => new CommonError()
{
Code = x.Code,
Message = x.Description
})));
}
return(CommonResult.Success());
}
catch (Exception ex)
{
return(CommonResult.Failed(new CommonError()
{
Message = ex.Message
}));
}
}
public async Task <CommonResult> DeleteAvatarAsync(ClaimsPrincipal claimsPrincipal, PhotoDeleteModel criterias)
{
try
{
if (!criterias.CanEdit)
{
throw new UnauthorizedAccessException();
}
var currentUserId = GetCurrentUserId(claimsPrincipal);
await _userPhotoService.DeleteUserPhotoAsync(currentUserId, UserPictureType.Avatar);
return(CommonResult.Success(new UserPhotoUpdateRequest()));
}
catch (Exception)
{
throw;
}
}
public CommonResult Add(AddProjectDto project)
{
if (string.IsNullOrEmpty(project.Name))
{
return(CommonResult.Failure("Cannot create project without name provided"));
}
if (string.IsNullOrEmpty(project.Description))
{
return(CommonResult.Failure("Cannot create project without description provided"));
}
var existingProject = _projectRepository.GetByName(project.Name);
if (existingProject != null && existingProject.IsDeleted == false && existingProject.Name == project.Name)
{
return(CommonResult.Failure("Project name already exists"));
}
_projectRepository.Add(project);
return(CommonResult.Success());
}
public CommonResult Add(DrinkDto item)
{
if (string.IsNullOrEmpty(item.Name))
{
return(CommonResult.Failure("No Name is declared"));
}
if (item.Price <= 0)
{
return(CommonResult.Failure("Price is not declared or less or equal then zero!"));
}
if (item.DrinkTypeId <= 0 || item.LocationOfDrinkId <= 0)
{
return(CommonResult.Failure("Wrong data with dropdown element"));
}
_repository.Add(item);
return(CommonResult.Success());
}
public CommonResult Add(AddProjectDto project)
{
if (String.IsNullOrWhiteSpace(project.Name))
{
return(CommonResult.Failure("Project name is empty."));
}
if (String.IsNullOrWhiteSpace(project.Description))
{
return(CommonResult.Failure("Project description is empty."));
}
var existingProject = _projectsRepository.GetByName(project.Name);
if (existingProject != null && !existingProject.IsDeleted && existingProject.Name == project.Name)
{
return(CommonResult.Failure("Project name already exists."));
}
_projectsRepository.Add(project);
return(CommonResult.Success());
}
public CommonResult <DrinkEditDto> Edit(int?id)
{
var drink = _db.Drinks.Where(s => s.Id == id).FirstOrDefault();
if (drink == null)
{
return(CommonResult <DrinkEditDto>
.Failure <DrinkEditDto>
("No match id.."));
}
var editDrink = new DrinkEditDto
{
Name = drink.Name,
Price = drink.Price,
Id = drink.Id,
Ratings = GetRatings(id)
};
return(CommonResult <DrinkRating> .Success(editDrink));
}
public async Task <CommonResult <DrinkRatingDto> > SendRatingAsync(DrinkRatingDto rating)
{
if (rating.DrinkId == 0)
{
return(CommonResult <DrinkRatingDto> .Failure <DrinkRatingDto>("Drink id is 0"));
}
if (rating.Rating == 0)
{
return(CommonResult <DrinkRatingDto> .Failure <DrinkRatingDto>("Drink rating is 0 (not allowed)"));
}
bool RatingSuccess = await SaveChanges(rating);
if (RatingSuccess == true)
{
return(CommonResult <DrinkRating> .Success(rating));
}
return(CommonResult <DrinkRatingDto>
.Failure <DrinkRatingDto>
("Something unexpected happend with db"));
}
public CommonResult ValidateImageUrl(ImageValidationModel criterias)
{
_validationStrategyContext.SetStrategy(new ImageUrlValidationStrategy());
if (criterias == null || string.IsNullOrEmpty(criterias.Url))
{
return(CommonResult.Failed(new CommonError()));
}
bool canUpdate = _validationStrategyContext.Validate(criterias.Url);
if (!canUpdate)
{
_validationStrategyContext.SetStrategy(new Base64ImageValidationStrategy());
canUpdate = _validationStrategyContext.Validate(criterias.Url);
}
if (canUpdate)
{
return(CommonResult.Success());
}
return(CommonResult.Failed(new CommonError()));
}
public async Task <ActionResult> Register([FromBody] BKRegisterInfo info)
{
int count = await _userReposity.CheckUserByAccountAndNickNameAsync(info.Account, info.NickName);
if (count > 0)
{
// 先这样写
return(Ok(CommonResult.Fail("account or nickName have been used")));
}
string salt = "baike";
BkUser user = new BkUser {
Account = info.Account, Password = MD5Util.GenerateMD5(info.Password, salt), Salt = salt
};
BkUserInfo userInfo = new BkUserInfo {
NickName = info.NickName, State = 1, Icon = "user_default.jpg", BackgroundIcon = "back_default.jpg"
};
user.BkUserInfo = userInfo;
_userReposity.AddUser(user);
await _userReposity.SaveAsync();
return(Ok(CommonResult.Success("register success")));
}
