public async Task <IActionResult> UpdateUser([FromBody] UpdateUserDto updateUser, [FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var userId = User.Claims.FirstOrDefault(p => p.Type == ClaimTypes.NameIdentifier)?.Value;
if (id.ToString() != userId)
{
return(BadRequest());
}
var isUser = _userManager.Users.Any(u => u.Id == id.ToString());
if (!isUser)
{
return(NotFound());
}
var updatedUser = await _userService.UpdateUserAsync(id, updateUser).ConfigureAwait(false);
var saved = await _userService.SaveAsync().ConfigureAwait(false);
if (!saved)
{
return(BadRequest());
}
var profileUser = new ProfileDto(updatedUser);
return(Ok(profileUser));
}
public async Task <IActionResult> Post(ProfileDto model)
{
_logger.LogInformation($"{JsonConvert.SerializeObject(model)} has been submitted!");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
try
{
await _submission.SubmitAsync(
new SubmissionModel
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
MobilePhone = model.MobilePhone
});
}
catch (Exception exception)
{
_logger.LogError(exception, "An error occured while submitting subscription.");
return(StatusCode(
500,
new
{
error = "A server error has occured and the request could not be submitted."
}));
}
return(Ok());
}
public async Task <Result> AddProfileAsync(ProfileDto profileDto)
{
using var context = _contextFactory.CreateDbContext();
var profile = await context.Profiles.FindAsync(profileDto.Id);
if (profile != null)
{
return(Result.Failure("Profile already exists"));
}
profile = new Profile
{
Name = profileDto.Name,
Description = profileDto.Description,
ServerName = profileDto.ServerName,
ServerPort = profileDto.ServerPort,
UserName = profileDto.UserName,
Password = profileDto.Password,
AuthBaseUri = profileDto.AuthBaseUri,
ApiBaseUri = profileDto.ApiBaseUri
};
await context.Profiles.AddAsync(profile);
return(Result.Success());
}
public void CreateProfileTest_ArgumentNullException(ProfileDto profile)
{
var exc = Assert.Throws <ArgumentNullException>(() => _testObject.CreateProfile(profile));
Assert.AreEqual("profile", exc.ParamName);
_profileProvider.DidNotReceiveWithAnyArgs().Create(Arg.Any <UserProfile>());
}
public async Task <ProfileDto> GetProfileByUserId(string userId)
{
if (userId is null)
{
throw new ArgumentNullException(nameof(userId));
}
var profiles = await _repository.GetAll().AsNoTracking().ToListAsync();
var profileDataModel = profiles.FirstOrDefault(c => c.UserId.Equals(userId));
if (profileDataModel is null)
{
return(new ProfileDto());
}
var profile = new ProfileDto
{
UserId = profileDataModel.UserId,
FirstName = profileDataModel.FirstName,
LastName = profileDataModel.LastName,
MiddleName = profileDataModel.MiddleName,
};
profile.Id = profileDataModel.Id;
return(profile);
}
public async Task <IActionResult> GetMyProfile()
{
var user = await _userManager.FindByIdAsync(this.User.Identity.Name);
var userWithPhotos = await _dbContext.Users.Where(q => q.Id == user.Id).Include(q => q.Photos).FirstAsync();
var ret = new ProfileDto
{
Age = user.Age,
Description = user.Description,
Gender = user.Gender,
Id = user.Id,
Job = user.Job,
Name = user.Name,
School = user.School,
};
foreach (var item in userWithPhotos.Photos)
{
ret.Photos.Add(new PhotoDto {
Id = item.Id, Url = item.Url, Main = item.Main, Extenstion = item.Extenstion, FileName = item.FileName
});
}
return(Ok(ret));
}
public IActionResult Put([FromBody] ProfileDto profileDto)
{
_unitOfWork.ProfilesRepository.Update(_dtoProfileMapper.Map(profileDto));
_unitOfWork.Save();
return(Ok());
}
public async Task <IActionResult> Put([FromBody] ProfileDto profileDto)
{
try
{
var actualUserId = _firebaseTokenService.GetTokenData(HttpContext).UserId;
if (profileDto.UserId != actualUserId)
{
return(Unauthorized());
}
var profile = await _profileService.GetProfile(profileDto.UserId);
if (profile == null)
{
return(NotFound());
}
await _profileService.EditProfile(profileDto);
return(NoContent());
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public async Task <IActionResult> Profile(ProfileViewModel model)
{
model = model ?? throw new ArgumentNullException(nameof(model));
if (ModelState.IsValid)
{
var profileDto = new ProfileDto
{
UserId = User.GetUserIdByClaimsPrincipal(),
Name = model.Name,
BirthDate = model.BirthDate,
Gender = model.Gender,
Address = model.Address,
};
if (model.AvatarFile is not null)
{
byte[] imageData = null;
using (var binaryReader = new BinaryReader(model.AvatarFile.OpenReadStream()))
{
imageData = binaryReader.ReadBytes((int)model.AvatarFile.Length);
}
profileDto.Avatar = imageData;
}
await _profileManager.UpdateProfileAsync(profileDto);
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public IHttpActionResult ModifyProfile([FromBody] ProfileDto profile)
{
if (profile == null)
{
return(BadRequest(Resources.EmtyData));
}
var userClaims = HttpContext.Current.User.Identity as ClaimsIdentity
?? throw new ArgumentNullException(nameof(HttpContext.Current.User.Identity));
var idUser = Convert.ToInt64(userClaims.Claims.FirstOrDefault(x => x.Type == Resources.ClaimTypeId)?.Value);
if (idUser < 1 || !ModelState.IsValid)
{
return(BadRequest(ShowErrorsHelper.ShowErrors(ModelState)));
}
try
{
profile.AccountId = idUser;
var user = _userService.ModifyProfile(profile);
return(Ok(user));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
catch (NotFoundUserException ex)
{
return(BadRequest(ex.Message));
}
catch (AddAccountException ex)
{
return(BadRequest(ex.Message));
}
}
private void SetOutBoundConnectionState(ToolStripMenuItem item, ProfileDto profile)
{
item.CheckState =
firewallService.OutboundConnectionsAllowedOn(profile)
? CheckState.Checked
: CheckState.Unchecked;
}
public ActionResult InitialProfileSetup(ProfileViewModel profile)
{
if (ModelState.IsValid)
{
var insert = new ProfileDto()
{
UserId = User.Identity.GetUserId(),
FirstName = profile.FirstName,
LastName = profile.LastName,
Title = profile.Title,
Summary = profile.Summary,
Location = profile.Location,
Mobile = profile.Mobile,
Phone = profile.Phone,
IsAvailable = profile.IsAvailable,
AvailableFromDate = profile.AvailableFromDate,
ImageUrl = profile.ImageUrl,
PortfolioUrl = profile.PortfolioUrl,
LinkedInUrl = profile.LinkedInUrl
};
var isAdded = _profileService.InsertProfile(User.Identity.GetUserId(), insert);
if (isAdded)
{
return(RedirectToAction("Overview", "Portal"));
}
}
return(View(profile));
}
public async Task <IActionResult> Profile_1_0(ApiVersion apiVersion)
{
var identity = HttpContext.User.Identity;
if (identity == null)
{
return(Unauthorized());
}
var user = await _userManager.FindByNameAsync(identity.Name);
if (user == null)
{
return(Unauthorized());
}
var roles = await _userManager.GetRolesAsync(user);
var profile = new ProfileDto {
Name = user.Name,
Nickname = user.Nickname,
Email = user.Email,
Username = user.UserName,
Roles = new List <string>(roles)
};
return(Ok(profile));
}
public bool OutboundConnectionsAllowedOn(ProfileDto profileDto)
{
var profile = (NET_FW_PROFILE_TYPE2_)profileDto;
var action = firewallPolicy.get_DefaultOutboundAction(profile);
return(action == NET_FW_ACTION_.NET_FW_ACTION_ALLOW);
}
public async Task <bool> Consume(string message)
{
UserEvent userEvent = JsonConvert.DeserializeObject <UserEvent>(message);
if (userEvent == null)
{
return(false);
}
Profile profile = new Profile
{
Id = userEvent.Id,
Avatar = userEvent.Avatar,
DisplayName = userEvent.DisplayName,
DateOfCreation = userEvent.DateOfCreation,
Email = userEvent.Email,
GoogleId = userEvent.GoogleId
};
await _context.Profiles.AddAsync(profile);
bool success = await _context.SaveChangesAsync() > 0;
if (!success)
{
return(false);
}
ProfileDto profileDto = _mapper.Map <ProfileDto>(profile);
CreateProfileEvent(profileDto);
return(true);
}
public async Task <ActionResult> HomePageCallToApi()
{
var claims = User as ClaimsPrincipal;
ProfileDto profile = null;
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization
= new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", claims.FindFirst("token")?.Value ?? "");
var response = await httpClient.GetAsync("http://localhost:53866/api/profiles");
if (response.IsSuccessStatusCode)
{
var profileString = await response.Content.ReadAsStringAsync();
profile = Newtonsoft.Json.JsonConvert.DeserializeObject <ProfileDto>(profileString);
}
else
{
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
return(Content(System.Net.HttpStatusCode.Unauthorized.ToString()));
}
}
}
return(View(profile));
}
public async Task <bool> UpdateStudentDetailsAsync(ProfileDto modUser, string studentId)
{
try
{
var user = (from a in context.ModelUsers
where a.Id == studentId
select a).SingleOrDefault();
if (user != null)
{
user.Id = modUser.id;
user.Email = modUser.Email;
user.FirstName = modUser.FirstName;
user.LastName = modUser.LastName;
user.PhoneNumber = modUser.PhoneNumber;
await context.SaveChangesAsync();
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public async Task <ApiResponse> uploadProfle([FromForm] ProfileDto dto)
{
try
{
if (dto.Id == Guid.Empty)
{
return(new ApiResponse("Không tìm thấy Id: ", dto.Id, 400));
}
var user = await _userService.GetByIdAsync(dto.Id);
if (user == null)
{
return(new ApiResponse("User không tồn tại", user, 404));
}
MemoryStream ms = new MemoryStream();
dto.ImageUser.CopyTo(ms);
user.ImageUser = ms.ToArray();
ms.Close();
ms.Dispose();
user.UpdatedDate = DateTime.Now;
await _userService.UpdateAsync(user);
var userViewModel = _mapper.Map <UserViewModel>(user);
return(new ApiResponse("Update date user success: ", userViewModel, 200));
}
catch (Exception ex)
{
return(new ApiResponse($"{ex}", ex, 200));
}
}
public IActionResult Put(int id, ProfileDto profileDto)
{
try
{
var tools = new SixTools(_httpContextAccessor);
var user = _userService.GetById(tools.GetUserTokenId());
if (user == null)
{
return(BadRequest(new { StatusCode = HttpStatusCode.BadRequest, message = "Usuário não localizado" }));
}
if (!user.Profile.Update)
{
return(BadRequest(new { StatusCode = HttpStatusCode.BadRequest, message = "Usuário não possui permissão para realizar esta operacao" }));
}
var profile = _profileService.GetById(id);
if (profile == null)
{
return(BadRequest(new { StatusCode = HttpStatusCode.BadRequest, message = "Profile não localizado" }));
}
profile.Name = profileDto.Name;
profile.Create = profileDto.Create;
profile.Update = profileDto.Update;
profile.Delete = profileDto.Delete;
profile.IsAdmin = profileDto.IsAdmin;
profile.UpdatedAt = DateTime.Now;
_profileService.Update(profile);
return(Ok(_mapper.Map <ProfileDto>(profile)));
}
catch (Exception e)
{
return(BadRequest(new { StatusCode = HttpStatusCode.PreconditionFailed, message = e.Message }));
}
}
public IHttpActionResult Profile(ProfileDto profileToUpdate)
{
var userId = GetUserIdFromContext();
var dto = _accountService.UpdateProfile(userId, profileToUpdate);
return(Ok(dto));
}
public bool UpdateMentorDetails(ProfileDto modUser, string mentorId)
{
try
{
var user = (from a in context.MODUsers
where a.Id == mentorId
select a).SingleOrDefault();
if (user != null)
{
user.Id = modUser.id;
user.Email = modUser.Email;
user.FirstName = modUser.FirstName;
user.LastName = modUser.LastName;
user.PhoneNumber = modUser.PhoneNumber;
user.Skills = modUser.Skills;
user.Experience = modUser.Experience;
context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
return(false);
}
}
public void ProfileDtoIsValid_WhenMissingData_ShouldReturnFalse()
{
this.profileDto = new ProfileDto();
string msg = null;
Assert.IsFalse(profileDto.IsValid(ref msg));
Assert.AreEqual(msg, ErrorMessages.MissingFirstName);
this.profileDto.FirstName = "FirstName";
Assert.IsFalse(profileDto.IsValid(ref msg));
Assert.AreEqual(msg, ErrorMessages.MissingLastName);
this.profileDto.LastName = "LastName";
Assert.IsFalse(profileDto.IsValid(ref msg));
Assert.AreEqual(msg, ErrorMessages.MissingEmail);
this.profileDto.Email = "Email";
Assert.IsFalse(profileDto.IsValid(ref msg));
Assert.AreEqual(msg, ErrorMessages.MissingPassword);
this.profileDto.Password = "******";
Assert.IsFalse(profileDto.IsValid(ref msg));
Assert.AreEqual(msg, ErrorMessages.MissingAreaCode);
this.profileDto.AreaCode = "AreaCode";
Assert.IsFalse(profileDto.IsValid(ref msg));
Assert.AreEqual(msg, ErrorMessages.MissingPhoneNumber);
}
public ProfileDto GetUserProfileByUserId(string userId)
{
var profile = _context.Profiles.FirstOrDefault(x => x.UserId == userId);
if (profile == null)
{
return(null);
}
var result = new ProfileDto
{
Id = profile.Id,
UserId = profile.UserId,
FirstName = profile.FirstName,
LastName = profile.LastName,
Title = profile.Title,
Summary = profile.Summary,
Location = profile.Location,
Mobile = profile.Mobile,
Phone = profile.Phone,
IsAvailable = profile.IsAvailable,
AvailableFromDate = profile.AvailableFromDate,
ImageUrl = profile.ImageUrl,
PortfolioUrl = profile.PortfolioUrl,
LinkedInUrl = profile.LinkedInUrl,
JoinDate = profile.CreateDate
};
return(result);
}
public bool UpdateProfile(ProfileDto profile)
{
var record = _context.Profiles.FirstOrDefault(x => x.UserId == profile.UserId);
if (record == null)
{
return(false);
}
record.FirstName = profile.FirstName;
record.LastName = profile.LastName;
record.Title = profile.Title;
record.Summary = profile.Summary;
record.Location = profile.Location;
record.Mobile = profile.Mobile;
record.Phone = profile.Phone;
record.IsAvailable = profile.IsAvailable;
record.AvailableFromDate = profile.AvailableFromDate;
record.ImageUrl = profile.ImageUrl;
record.PortfolioUrl = profile.PortfolioUrl;
record.LinkedInUrl = profile.LinkedInUrl;
_context.Profiles.AddOrUpdate(record);
return(_context.SaveChanges() == 1);
}
public bool UpdateStudentDetails(ProfileDto ModUser, string studentId)
{
try
{
var user = (from a in context.MODUsers
where a.Id == studentId
select a).SingleOrDefault();
if (user != null)
{
user.Id = ModUser.id;
user.Email = ModUser.Email;
user.FirstName = ModUser.FirstName;
user.LastName = ModUser.LastName;
user.PhoneNumber = ModUser.PhoneNumber;
user.Skill = ModUser.Skill;
user.Experience = ModUser.Experience;
context.SaveChanges();
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
return(false);
}
throw new NotImplementedException();
}
private static void CreateProfiles()
{
var client = new DataServiceClient.DataServiceClient();
var profile1 = new ProfileDto
{
Id = 0,
Name = "Administrator"
};
var profile2 = new ProfileDto
{
Id = 0,
Name = "Operator"
};
var profile3 = new ProfileDto
{
Id = 0,
Name = "Customer"
};
client.SaveProfile(profile1);
client.SaveProfile(profile2);
client.SaveProfile(profile3);
}
public async Task <IActionResult> ProfileInfo()
{
User user = (User)await this._manager.FindByNameAsync(HttpContext.User.Identity.Name);
ProfileDto profile = new ProfileDto()
{
Email = user.Email,
Street = user.Street,
Age = user.Age,
City = user.City,
};
var orders = (from o in this._context.Orders
where o.UserId.Equals(user.Id)
join book in this._context.Books on o.Id equals book.OrderId
select new { o, book }).ToList();
int countbooks = orders.Count;
double totalsum = orders.Sum(o => o.book.Price);
UserStatistic statistic = new UserStatistic()
{
TotalSum = totalsum,
CountBooks = countbooks,
CountOrders = user.Orders.Count
};
ViewData["statistic"] = statistic;
return(View(profile));
}
public new async Task <ActionResult> Profile([Bind(Include = "Id,Name,Index,FirstName,LastName,School,Street,City,Country,Average,Passed,Subjects")] ProfileDto profile)
{
if (ModelState.IsValid)
{
Student dbStudent = await GetLoggedInStudent();
dbStudent.Index = profile.Index;
dbStudent.FirstName = profile.FirstName;
dbStudent.LastName = profile.LastName;
dbStudent.School = profile.School;
dbStudent.Street = profile.Street;
dbStudent.City = profile.City;
dbStudent.Country = profile.Country;
db.Entry(dbStudent).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Profile"));
}
ProfileDto profileDto = new ProfileDto()
{
Index = profile.Index,
FirstName = profile.FirstName,
LastName = profile.LastName,
School = profile.School,
Street = profile.Street,
City = profile.City,
Country = profile.Country,
Average = profile.Average,
Passed = profile.Passed,
Subjects = profile.Subjects
};
return(View(profileDto));
}
public IEnumerable <RuleDto> ReadRules(ProfileDto profile, RuleDirectionDto direction)
{
int p = (int)profile, dir = (int)direction;
var rules = rulesRepository
.Read(r => r.Direction == dir && r.Profile == p);
return(mapper.Map <IEnumerable <RuleDto> >(rules));
}
public CommentDto(Comment comment)
{
Body = comment.Body;
CreatedAt = comment.CreatedAt;
UpdatedAt = comment.UpdatedAt;
Id = comment.CommentId;
Author = new ProfileDto(comment.Author);
}
