public async Task UpdateUserValidId()
{
using (var client = new TestClientProvider().Client)
{
var data = await client.GetAsync("/v1/api/users");
string json = await data.Content.ReadAsStringAsync();
IEnumerable <UserDTO> users = JsonConvert.DeserializeObject <IEnumerable <UserDTO> >(json);
var maxId = users.Max(u => u.Id);
var user = users.FirstOrDefault(u => u.Id == maxId);
var response = await client.PutAsync($"/v1/api/users/{maxId}", new StringContent(
JsonConvert.SerializeObject(new UserInputModel()
{
FirstName = "Aragorn",
LastName = "Legolasson",
Email = "*****@*****.**",
Phone = "6969691",
Address = "Isengard 20"
}),
Encoding.UTF8, "application/json"));
var updateResponse = await client.GetAsync($"/v1/api/users/{maxId}");
string updatedUserJson = await updateResponse.Content.ReadAsStringAsync();
UserDetailDTO updatedUser = JsonConvert.DeserializeObject <UserDetailDTO>(updatedUserJson);
Assert.AreNotEqual(user.FirstName, updatedUser.FirstName);
}
}
public UserDetailDTO GetUserDetail(long userId)
{
var res = from u in dbContext.User where u.Id == userId
join a in dbContext.UserArc on u.Id equals a.UserId
join g in dbContext.UserLoginLog on u.Id equals g.UserId
orderby g.LoginTime descending
select new { u.Id, Name = a.ArcName, a.ArcNo, a.KycStatus, u.Level, u.Gender, a.Country,
u.Birthday, a.PassportId, a.ArcIssueDate, a.ArcExpireDate, a.BackSequence,
u.Phone, g.LoginTime, g.Address, a.IdImageA, a.IdImageB };
UserDetailDTO dto = new UserDetailDTO();
foreach (var r in res.Take(1))
{
dto.Id = (int)r.Id;
dto.Name = r.Name;
dto.ArcNo = r.ArcNo;
dto.KycStatus = r.KycStatus;
dto.Level = r.Level;
dto.Gender = (byte)r.Gender;
dto.Country = r.Country;
dto.Birthday = r.Birthday;
dto.PassportId = r.PassportId;
dto.ArcIssueDate = r.ArcIssueDate;
dto.ArcExpireDate = r.ArcExpireDate;
dto.BackSequence = r.BackSequence;
dto.Phone = r.Phone;
dto.LoginTime = (long)((DateTime)r.LoginTime).Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;
dto.Address = r.Address;
dto.IdImageA = r.IdImageA;
dto.IdImageB = r.IdImageB;
}
return(dto);
}
public UserDetailDTO Login(string username)
{
UserDetailDTO userDetail = (from u in _unitOfWork.User.FindAll().Where(u => u.Username == username)
//join ur in _context.UserRole on u.ID equals ur.UserID
//join r in _context.Role on ur.RoleID equals r.ID
join e in _context.Employee on u.Username equals e.EmployeeNo
join d in _context.Department on e.DepartmentID equals d.ID
join c in _context.Company on d.CompanyID equals c.ID
select new UserDetailDTO
{
UserID = u.ID,
Username = u.Username,
PasswordHash = u.PasswordHash,
// Role = r.Name,
Email = u.Email,
EmployeeNo = e.EmployeeNo,
EmployeeName = e.FirstName + " " + e.LastName,
EmployeePhoto = e.PhotoContent,
CompanyID = c.ID,
CompanyName = c.Name,
CompanyLogo = c.LogoContent,
Department = d.Name
}).FirstOrDefault();
if (userDetail != null)
{
userDetail.Role = string.Join(", ", (from ur in _unitOfWork.UserRole.FindAll().Where(ur => ur.UserID == userDetail.UserID)
join r in _context.Role on ur.RoleID equals r.ID
select(r.Name)));
}
return(userDetail);
}
public UserDetailDTO Authenticate(string username, string password)
{
UserDetailDTO userDetail = new UserDetailDTO();
var user = _userInformationRepo.GetUserDetail(username, password);
if (user == null)
{
return(null);
}
else
{
var claims = new[]
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.Role, user.Role?.RoleName)
};
userDetail.Id = user.UserDetailId;
userDetail.FirstName = user.FirstName;
userDetail.LastName = user.LastName;
userDetail.UserName = user.UserName;
userDetail.RoleName = user.Role?.RoleName;
userDetail.DiscountPrice = user.Role?.DiscountPrice;
userDetail.Token = _jwtTokenManager.GenerateTokens(claims, DateTime.Now);
}
return(userDetail);
}
public IHttpActionResult PostUser(UserDetailDTO userDTO)
{
User authorizedUser = new Authorize().GetAuthorizedUser(Request.Headers.GetCookies("user").FirstOrDefault());
if (!ModelState.IsValid || !userDTO.Validate(true, null))
{
return(BadRequest());
}
if (authorizedUser == null && !userDTO.NewRole.Equals("Student"))
{
return(Unauthorized());
}
User user = userDTO.Create();
userDTO.UpdateRole(user);
string error = db.Update(user, Added);
if (error != null)
{
return(BadRequest(error));
}
UserListDTO result = new UserListDTO(user);
return(CreatedAtRoute("DefaultApi", new { id = userDTO.Id }, result));
}
public async Task Save(UserDetailDTO item)
{
using (var uow = this.UnitOfWorkProvider.Create()) {
var mgr = this.AppUserManagerFactory();
var usr = await mgr.FindByIdAsync(item.Id.ToString());
// Enable or disable user
usr.Enabled = item.Enabled;
await mgr.UpdateAsync(usr);
// Update roles
await mgr.RemoveFromRolesAsync(usr, Role.AllRoles);
if (item.IsAdministrator)
{
await mgr.AddToRoleAsync(usr, Role.Administrators);
}
if (item.IsOrganizer)
{
await mgr.AddToRoleAsync(usr, Role.Organizers);
}
await uow.CommitAsync();
}
}
public ActionResult Create(UserDTOComposite userDTOComposite)
{
var user = userDTOComposite.UserDTO;
if (ModelState.IsValid)
{
var userDetail = new UserDetailDTO
{
Logo = "",
Name = user.UserDetail.Name,
CreatedBy = this.User.Id,
ModifiedBy = this.User.Id,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now,
IsActive = true,
Version = 1
};
//userDetail = this._IUserDetailService.Create(userDetail);
user.UserDetail = userDetail;
//user.UserDetailId = userDetail.Id;
user.Status = UserStatusEnum.Available;
user.Password = Ingenious.Infrastructure.GlobalMessage.DefaultPasswordFormat.ToMD5String();
user.CreatedBy = user.ModifiedBy = this.User.Id;
user = this._IUserService.Create(user);
return(RedirectToAction("Index"));
}
this.DataBind();
var model = new UserDTOComposite();
model.DepartmentDTOList = this._IDepartmentService.GetAll();
model.UserDTO = user;
return(View(model));
}
public async Task UpdateUserInvalidInputData()
{
using (var client = new TestClientProvider().Client)
{
var data = await client.GetAsync("/v1/api/users");
string json = await data.Content.ReadAsStringAsync();
IEnumerable <UserDTO> users = JsonConvert.DeserializeObject <IEnumerable <UserDTO> >(json);
var maxId = users.Max(u => u.Id);
var user = users.FirstOrDefault(u => u.Id == maxId);
var response = await client.PutAsync($"/v1/api/users/{maxId}", new StringContent(
JsonConvert.SerializeObject(new UserInputModel()
{
FirstName = "Gandalf"
}),
Encoding.UTF8, "application/json"));
var updateResponse = await client.GetAsync($"/v1/api/users/{maxId}");
string updatedUserJson = await updateResponse.Content.ReadAsStringAsync();
UserDetailDTO updatedUser = JsonConvert.DeserializeObject <UserDetailDTO>(updatedUserJson);
Assert.AreEqual(user.FirstName, updatedUser.FirstName);
}
}
public IActionResult GetById(string id)
{
var user = _userService.GetUserDetail(id);
UserDetailDTO result = BsonSerializer.Deserialize <UserDetailDTO>(user.ToJson());
return(Ok(result));
}
public void Update(UserDetailDTO userDetailDTO, DateTime dateStamp)
{
if (userDetailDTO == null)
{
throw new ArgumentNullException("UserDetail model is null.");
}
tblM_UserDetail userDetail = userDetailFactory.CreateFromDbAndUpdateFromDTO(userDetailDTO, dateStamp);
}
public MessageModel <UserDetailDTO> GetUserDetail([FromRoute, SwaggerParameter("id,可從/useradmin取得", Required = true)] int id)
{
UserDetailDTO userDetail = userAdminService.GetUserDetail(id);
return(new MessageModel <UserDetailDTO>
{
Data = userDetail
});
}
public static (KuhmunityResponse response, string sessionTicket, UserDetailDTO userDetail) Login(
string ApiUrl,
string campaignID,
string email,
string password,
string isPersistentCookie,
string sessionTicket,
UserDetailDTO userDetail)
{
KuhmunityResponse response = new KuhmunityResponse
{
IsSuccessful = false
};
var KuhmunityViewModel = new
{
campaignID,
email,
password,
isPersistentCookie
};
using (var client = new WebClient())
{
try
{
var data = JsonConvert.SerializeObject(KuhmunityViewModel);
client.Headers.Add(HttpRequestHeader.ContentType, "application/json");
var apiResponse = client.UploadString(new Uri(ApiUrl + "Login?output=json"), "POST", data);
if (!string.IsNullOrWhiteSpace(apiResponse))
{
var receivedData = JsonConvert.DeserializeObject <UserLoginResultDTO>(apiResponse);
if (receivedData.Status.Equals("OK"))
{
response.IsSuccessful = true;
response.Body = receivedData.UserDetailDTO;
userDetail = receivedData.UserDetailDTO;
sessionTicket = receivedData.SessionTicket;
}
else
{
response.Message = receivedData.Status;
}
}
return(response, sessionTicket, userDetail);
}
catch (Exception ex)
{
response.Message = ResponseMessages.SERVER_ERROR;
response.ErrorMessage = ex.Message;
return(response, sessionTicket, userDetail);
}
}
}
public tblM_UserDetail Insert(UserDetailDTO userDetailDTO, DateTime dateStamp)
{
if (userDetailDTO == null)
{
throw new ArgumentNullException("UserDetail model is null.");
}
tblM_UserDetail userDetail = userDetailFactory.CreateFromDTO(userDetailDTO, dateStamp);
return(Db.tblM_UserDetail.Add(userDetail));
}
/// <summary>
/// Basic constructor
/// </summary>
public WorkPkgController()
{
var data = new DataContext();
RepositoryBase.InitRepository(data);
this._workPackageRepository = WorkPackageRepository.GetInstance();
var userRepository = UserRepository.GetInstance();
this._currentUser = userRepository.GetLoggedUser();
this._currentUserDto = Mapper.Map<UserDetailDTO>(this._currentUser);
}
public void DeleteUser(UserDetailDTO userDTO)
{
//sterge user
User user = new User()
{
Username = userDTO.Username, Password = userDTO.Password, Email = userDTO.Email, Role = userDTO.Role
};
_dataAccess.UserRepository.Delete(user);
}
public UserDetailDTO GetByPrimaryKey(int primaryKey)
{
UserDetailDTO record = GetQuery().FirstOrDefault(u => u.UserDetail_PK == primaryKey);
var userDetail = Db.tblM_UserDetail.Find(primaryKey);
if (userDetail != null && userDetail.FilePhoto != null)
{
record.FilePhotoInBase64 = new WebImageConverter().GetBase64FromBytes(userDetail.FilePhoto);
}
return(record);
}
public UserDetailDTO AlreadyExistEmail(string UserEmail, int boundaryId)
{
var IsValid = _identityRepository.ValidateEmail(UserEmail);
UserDetailDTO user = null;
if (IsValid)
{
user = _identityRepository.GetUserProfileByUsername(UserEmail, boundaryId);
}
return(user);
}
public async Task <BaseResponse> SignupAsync(UserDetailDTO userDetail)
{
try
{
return(await _iAccountRepository.SignUpAsync(userDetail));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(StatusBuilder.ResponseFailStatus(null, ex.Message));
}
}
public IHttpActionResult PutUser(int id, UserDetailDTO userDTO)
{
User authorizedUser = new Authorize().GetAuthorizedUser(Request.Headers.GetCookies("user").FirstOrDefault());
if (userDTO == null)
{
return(BadRequest());
}
if (authorizedUser == null)
{
return(Unauthorized());
}
if (userDTO.NewUserIdentifier != null)
{
User otherUser = new Authorize().GetUserByIdentifier(userDTO.NewUserIdentifier);
if (otherUser == null)
{
return(NotFound());
}
id = otherUser.Id;
}
User user = db.Users.Find(id);
if (user == null || !ModelState.IsValid || !userDTO.Validate(false, authorizedUser.Id != id ? authorizedUser : null))
{
return(BadRequest(ModelState));
}
bool logoutNecessary = false;
if (authorizedUser.Id == id)
{
userDTO.Update(user);
}
if (userDTO.NewRole != null)
{
if (authorizedUser.GetTeacher() == null)
{
return(Unauthorized());
}
userDTO.UpdateRole(user);
}
string error = db.Update(user, Modified);
if (error != null)
{
return(BadRequest(error));
}
if (logoutNecessary)
{
return(Redirect("https://" + Request.RequestUri.Host + ":" + Request.RequestUri.Port + "/Logout"));
}
return(Redirect("https://" + Request.RequestUri.Host + ":" + Request.RequestUri.Port + "/Users/" + authorizedUser.Id));
}
public async Task <IHttpActionResult> PostUserMaster(UserDetailDTO user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//db.UserMasters.Add(userMaster);
//try
//{
// await db.SaveChangesAsync();
//}
//catch (DbUpdateException)
//{
// if (UserMasterExists(userMaster.Id))
// {
// return Conflict();
// }
// else
// {
// throw;
// }
//}
Guid id = user.Id;
int EntityStateId = 0;
if (id == Guid.Empty)
{
id = Guid.NewGuid();
// user.Id = id;
EntityStateId = (int)EntityState.Added;
}
else
{
EntityStateId = (int)EntityState.Modified;
}
int result = await _UserService.SaveUser(user, id, EntityStateId);
user.Id = id;
if (result == -1)
{
return(StatusCode(HttpStatusCode.NotModified));
}
else if (result == 0)
{
return(StatusCode(HttpStatusCode.NotAcceptable));
}
return(Ok(id));
}
private UserDetailEntryModel GetCreateStateModel()
{
UserDetailEntryFormData formData = new UserDetailEntryFormData();
List <Control> formControls = CreateFormControls(0);
UserDetailDTO userDetailDTO = new UserDetailDTO();
return(new UserDetailEntryModel()
{
FormData = formData,
FormControls = formControls,
Model = new UserDetailDTO(),
});
}
/// <summary>
/// Cautare user dupa id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public UserDetailDTO GetUser(int id)
{
User user = _dataAccess.UserRepository.FindFirstBy(u => u.UserID == id);
UserDetailDTO userDTO = new UserDetailDTO();
userDTO.Username = user.Username;
userDTO.Password = user.Password;
userDTO.Email = user.Email;
userDTO.Role = user.Role;
userDTO.UserID = user.UserID;
return(userDTO);
}
public async Task <ActionResult <UserDetailDTO> > GetUser(int id)
{
var user = await _usersRepository.GetById(id);
if (user == null)
{
return(NotFound());
}
var result = new UserDetailDTO(user);
return(result);
}
public async Task GetUserByValidID()
{
using (var client = new TestClientProvider().Client)
{
var response = await client.GetAsync("/v1/api/users/1");
response.EnsureSuccessStatusCode();
string data = await response.Content.ReadAsStringAsync();
UserDetailDTO user = JsonConvert.DeserializeObject <UserDetailDTO>(data);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(1, user.Id);
}
}
/// <summary>
/// Cautare user dupa id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public UserDetailDTO GetUser(int id)
{
var user = _dataAccess.UserRepository.FindFirstBy(u => u.UserID == id);
var userDto = new UserDetailDTO
{
Username = user.Username,
Password = user.Password,
Email = user.Email,
Role = user.Role,
UserID = user.UserID
};
return(userDto);
}
/// <summary>
/// This method is use for new user signup
/// </summary>
/// <param name="userDetailDTO"></param>
/// <returns></returns>
public async Task <BaseResponse> SignUpAsync(UserDetailDTO userDetailDTO)
{
try
{
//string ConnectionString = _config[_iStringConstants.MyConnectionString];
BaseResponse baseResponse = new BaseResponse();
UserTokenDTO userTokenAC = new UserTokenDTO();
using (DeepakdbContext deepakDBContext = new DeepakdbContext())
{
//deepakDBContext.Query<T>().AsTracking().
var data = await Task.Run(() => deepakDBContext
.Database.ExecuteSqlRaw("spInsertUserDetail @FirstName=@p0, @LastName=@p1,@Email=@p2,@Password=@p3,@MobileNumber=@p4,@Address_Line1=@p5,@Address_Line2=@p6, @ZipCode=@p7, @CreatedBy=@p8",
parameters: new [] { userDetailDTO.FirstName, userDetailDTO.LastName, userDetailDTO.Email,
PasswordHashUtill.HashPassword(userDetailDTO.Password), userDetailDTO.MobileNumber,
userDetailDTO.AddressLine1, userDetailDTO.AddressLine2, userDetailDTO.ZipCode.ToString(),
userDetailDTO.CreatedBy }
/*new SqlParameter("@FirstName", userDetailDTO.FirstName),
* new SqlParameter("@LastName", userDetailDTO.FirstName),
* new SqlParameter("@Email", userDetailDTO.Email),
* new SqlParameter("@Password",PasswordHashUtill.HashPassword( userDetailDTO.Password)),
* new SqlParameter("@MobileNumber", userDetailDTO.MobileNumber),
* new SqlParameter("@Address_Line1", userDetailDTO.AddressLine1),
* new SqlParameter("@Address_Line2", userDetailDTO.AddressLine2),
* new SqlParameter("@ZipCode", userDetailDTO.ZipCode),
* new SqlParameter("@CreatedBy", userDetailDTO.CreatedBy)*/
));
if (data != null)
{
baseResponse.StatusCode = 1;
baseResponse.Message = _iStringConstants.AddedSuccessfully;
// Need to ask how to get DBCONTEXT status code from store procedure
}
if (baseResponse.StatusCode == 1)
{
return(StatusBuilder.ResponseSuccessStatus(null, baseResponse.Message));
}
return(StatusBuilder.ResponseFailStatus(null, baseResponse.Message));
}
}
catch (Exception ex)
{
throw ex;
}
}
public KuhmunityResponse Login()
{
var status = KuhmunityLoginHelper.Login(
GetKuhmunityApiEndpoint(),
CampaignID,
Email,
Password,
IsPersistentCookie,
SessionTicket,
UserDetail);
SessionTicket = status.sessionTicket;
UserDetail = status.userDetail;
return(status.response);
}
public async Task <IActionResult> Me()
{
try
{
var user = await _userRepo.GetUser(User.GetUserId());
if (user == null)
{
return(BadRequest("Kayıt bulunamadı."));
}
var model = new UserDetailDTO()
{
UserId = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PhotoUrl = user.Photo,
IsBusiness = user.IsBusinessAccount,
FollowersCount = user.Followers.Count,
FollowingsCount = user.Followings.Count,
Settings = new UserSettingInfoDTO()
{
Language = user.Setting.Language,
Theme = user.Setting.Theme
},
Business = new BusinessInfoDTO()
{
Type = user.Business.BusinessType,
ExpireAt = user.Business.ExpireDate,
IsAgeAnalysis = user.Business.IsAgeAnalysis,
IsAttendedUserAnalysis = user.Business.IsAttendedUserAnalysis,
IsChatBotSupport = user.Business.IsChatBotSupport,
IsCommentAnalysis = user.Business.IsCommentAnalysis,
IsSendNotificationUsers = user.Business.IsSendNotificationUsers
}
};
return(Ok(model));
}
catch (Exception ex)
{
_logHelper.Log("AccountController", 500, "GetMe", ex.Message);
return(null);
}
}
/// <summary>
/// Stergere utilizator
/// </summary>
/// <param name="userDTO"></param>
public void DeleteUser(UserDetailDTO userDTO)
{
if (userDTO.Username == "Admin")
{
throw new Exception("'Admin' cannot be deleted");
}
User user = new User()
{
Username = userDTO.Username,
Password = userDTO.Password,
Email = userDTO.Email,
Role = userDTO.Role
};
_dataAccess.UserRepository.Delete(user);
}
private UserDetailEntryModel GetUpdateStateModel(int userDetailPK)
{
UserDetailEntryFormData formData = new UserDetailEntryFormData();
List <Control> formControls = CreateFormControls(userDetailPK);
UserDetailDTO userDetailDTO = userDetailQuery.GetByPrimaryKey(userDetailPK);
if (userDetailDTO == null)
{
throw new KairosException($"Record with primary key '{userDetailDTO.UserDetail_PK}' is not found.");
}
return(new UserDetailEntryModel()
{
FormData = formData,
FormControls = formControls,
Model = userDetailDTO,
});
}
public HttpResponseMessage Get(int id)
{
HttpResponseMessage responseMessage;
JSendMessage json;
UserDetailDTO userDetail = userModel.GetUser(id);
if (userDetail != null)
{
responseMessage = Request.CreateResponse(HttpStatusCode.OK, userDetail);
}
else
{
json = new JSendMessage("fail", "No items found");
responseMessage = Request.CreateResponse(HttpStatusCode.NoContent, json);
}
return(responseMessage);
}
