public HttpResponseMessage Create(UserApiModel model)
{
//System.Threading.Thread.Sleep(2000); // test api latency
var command = new CreateUser(User, model.Name)
{
PersonDisplayName = model.PersonDisplayName,
};
try
{
_createUser.Handle(command);
}
catch (ValidationException ex)
{
var badRequest = Request.CreateResponse(HttpStatusCode.BadRequest,
ex.Errors.First().ErrorMessage, "text/plain");
return badRequest;
}
var response = Request.CreateResponse(HttpStatusCode.Created, "User was successfully created.");
var url = Url.Link(null, new
{
controller = "Users",
action = "GetOne",
userId = command.CreatedUserId,
});
Debug.Assert(url != null);
response.Headers.Location = new Uri(url);
return response;
}
public async Task <IActionResult> SetUserProfile([FromBody] UserApiModel model)
{
UserApiModelValidator validator = new UserApiModelValidator(_resourceManager);
var validResult = validator.Validate(model);
if (!validResult.IsValid)
{
return(BadRequest(new MessageApiModel()
{
Message = validResult.ToString()
}));
}
var id = User.FindFirst("id")?.Value;
model.Id = id;
var result = await _userService.UpdateUserAsync(model);
return(Ok(result));
}
/// <summary>
/// 创建提现申请
/// </summary>
/// <returns></returns>
public int Create(WithdrawApplyApiModel applyModel)
{
if (applyModel == null)
{
return(0);
}
if (applyModel.UserNo <= 0)
{
return(0);
}
LoanMarketWithdrawApply model = new LoanMarketWithdrawApply();
model.Id = GuidTool.GenerateKey();
model.Amount = applyModel.Amount;
model.ApplyWithwrawAmount = applyModel.ApplyWithwrawAmount;
model.CreateTime = DateTime.Now;
model.Status = "提交申请";
model.UpdateTime = DateTime.Now;
model.UserNo = applyModel.UserNo;
UserBLL userBLL = new UserBLL();
UserApiModel userInfo = userBLL.GetUserInfo(applyModel.UserNo);
model.UserNickName = userInfo.NickName;
model.UserRealName = userInfo.RealName;
model.ZFBAccount = applyModel.ZFBAccount;
int res = withdrawApply.Create(model);
UserApiModel updateUserWithdrawAmount = new UserApiModel()
{
No = applyModel.UserNo,
WithdrawAmount = applyModel.Amount - applyModel.ApplyWithwrawAmount
};
if (userBLL.UpdateWithdrawAmount(updateUserWithdrawAmount) > 0)
{
return(res);
}
else
{
return(0);
}
}
public async Task <ResponseMessage <UserApiResponse> > AddUserApiAsync(UserApiModel model)
{
ResponseMessage <UserApiResponse> responseMessage;
try
{
var response = await _httpClient.PostAsJsonAsync("user/register", model);
response.EnsureSuccessStatusCode();
var userApiResponse = await response.Content.ReadAsAsync <UserApiResponse>();
responseMessage = ResponseMessage <UserApiResponse> .Ok(userApiResponse);
}
catch (Exception ex)
{
responseMessage = ResponseMessage <UserApiResponse> .Fault(ex.Message);
}
return(responseMessage);
}
public IHttpActionResult LogIn(string username, string password)
{
User user = new Models.User();
foreach (var item in db.Users)
{
if (item.Password == password && item.UserName == username)
{
user = item;
UserApiModel model = new UserApiModel()
{
Id = user.Id,
Name = user.Name,
Password = user.Password,
Phone = user.Phone,
UserName = user.UserName
};
return(Ok(model));
}
}
return(BadRequest("Login Failed"));
}
public string UserApiToString(UserApiModel model)
{
if (model.ApiKey == null)
{
return(null);
}
// Ensure that the API key is at least 16 bytes
var apiKeySize = model.ApiKey.Length;
if (apiKeySize < 16)
{
return(null);
}
var data = new byte[16 + apiKeySize];
Array.Copy(model.Id.ToByteArray(), 0, data, 0, 16);
Array.Copy(model.ApiKey, 0, data, 16, apiKeySize);
return(Base64UrlEncoder.Encode(data));
}
// GET api/users
//跨域请求精确控制
//[EnableCors(origins: "*", headers: "*", methods: "*")]
public Object Get(UserQuery query)
{
string msg;
try
{
if (query == null)
{
query = new UserQuery();
}
List <User> dbList = BusinessService.GetUserListByQuery(query);
List <UserApiModel> vmList = UserApiModel.FromUserList(dbList);
msg = string.Format(XiaoluResources.MSG_SINGLE_ACTION_SUCCESS, "获取", "用户列表");
return(new { IsSuccess = true, Message = msg, Obj = vmList });
}
catch (Exception e)
{
msg = string.Format(XiaoluResources.MSG_SINGLE_ACTION_FAIL, "获取", "用户列表") + string.Format(XiaoluResources.STR_FAIL_RESAON, ExceptionHelper.GetInnerExceptionInfo(e));
return(new { IsSuccess = false, Message = msg });
}
}
public async Task <ActionResult> UpdateUserApiSettings(UserApiModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_ApiPartial", model));
}
var user = await UserManager.FindByIdAsync(User.Id());
var oldKey = user.ApiKey;
user.ApiKey = model.Key;
user.ApiSecret = model.Secret;
user.IsApiEnabled = model.IsEnabled;
await UserManager.UpdateAsync(user);
ApiKeyStore.InvalidateApiKey(oldKey);
ApiKeyStore.GetApiAuthKey(user.ApiKey);
return(PartialView("_ApiPartial", model));
}
public async Task <IActionResult> GetUsers(string username, string claimType, string claimValue, [FromQuery] PagingApiModel pagingApiModel)
{
if (!this.ModelState.IsValid)
{
return(new UnprocessableEntityResult());
}
var pagingResult =
await this.usersRepository.QueryUsers(
username,
claimType,
claimValue,
new Paging(pagingApiModel.Page, pagingApiModel.PageSize));
var result = new PagingResultApiModel <UserApiModel>
{
Paging = PageDetailsApiModel.FromDomain(pagingResult.Paging),
Items = pagingResult.Items.Select(u => UserApiModel.FromDomainModel(u))
};
return(this.Ok(result));
}
public async Task <IHttpActionResult> Post([FromBody] UserApiModel value)
{
try
{
using (DbContextTransaction tx =
dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
UserModel user = await UserManager.FindByIdAsync(value.Id);
if (user != null)
{
tx.Rollback();
return(Conflict());
}
user = new UserModel();
user.UserName = value.UserName;
user.Name = value.Name;
user.Email = value.Email;
user.Enabled = value.Enabled;
IdentityResult result = await UserManager.CreateAsync(user, value.NewPassword);
if (!result.Succeeded)
{
tx.Rollback();
AddErrors(result);
return(BadRequest(ModelState.GetErrorsDelprefix("value")));
}
tx.Commit();
return(Created(Request.RequestUri + "/" + user.Id, user));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
/// <summary>
/// Gets a user for the web api based on the username provided. This is after determining if the user has valid payment status and updating the user in the database.
/// </summary>
/// <returns>
/// User in the form of web api model
/// </returns>
/// <param name="username">Username of the user trying to access their info in the database.</param>
public UserApiModel GetUser(string username)
{
try
{
// Gets a user from the DAL
var user = _db.GetUserDb(username);
// Sends a request for a list of invoices from Visma
var invoiceList = GetInvoiceListFromVisma();
// Determines the payment status of the user trying to access their information from the database
var paymentStatus = DeterminePaymentStatus(user, invoiceList);
// Alters the user from database model to the web api model
var outUser = new UserApiModel()
{
Username = user.Username,
Name = user.Name,
ValidPayment = user.ValidPayment,
Membership = user.Membership
};
// Updates the payment status of the user in the database
_db.UpdatePaymentDetails(user, paymentStatus);
return(outUser);
}
catch (Exception e)
{
// Creates a new error filer object
var errorLog = new ErrorFiler();
// Logs the error to the error log, with the name of the exception and where it occured
errorLog.WriteError(e.GetType().FullName, "NasBLL, UserApiModel GetUser(string username)");
return(null);
}
}
public HttpResponseMessage POST(UserMngmnt_User_CUD_DTO userMngmnt_User_CUD_DTO)
{
TransactionalInformation transaction = new TransactionalInformation();
UserApiModel userApiModel = new UserApiModel();
UserBusinessService userBusinessService = new UserBusinessService(userDataService);
userBusinessService.User_CreateUpdateDelete(userMngmnt_User_CUD_DTO.UserId, userMngmnt_User_CUD_DTO.UserName, userMngmnt_User_CUD_DTO.Password, userMngmnt_User_CUD_DTO.FullName, userMngmnt_User_CUD_DTO.MobileNumber, userMngmnt_User_CUD_DTO.EmailId, userMngmnt_User_CUD_DTO.CreatedBy, userMngmnt_User_CUD_DTO.LastModifiedBy, userMngmnt_User_CUD_DTO.InfoId, userMngmnt_User_CUD_DTO.OperationType, userMngmnt_User_CUD_DTO.AllowLogin, userMngmnt_User_CUD_DTO.TempUser_CUD, userMngmnt_User_CUD_DTO.IsSendMail, userMngmnt_User_CUD_DTO.PasswordQuestion, userMngmnt_User_CUD_DTO.PasswordAnswer, userMngmnt_User_CUD_DTO.SecurityQuestion, userMngmnt_User_CUD_DTO.SecurityAnswer, out transaction);
userApiModel.ReturnMessage = transaction.ReturnMessage;
userApiModel.ReturnStatus = transaction.ReturnStatus;
if (transaction.ReturnStatus == false)
{
userApiModel.ValidationErrors = transaction.ValidationErrors;
return(Request.CreateResponse <UserApiModel>(HttpStatusCode.BadRequest, userApiModel));
}
else
{
return(Request.CreateResponse <UserApiModel>(HttpStatusCode.OK, userApiModel));
}
}
public async Task <IActionResult> Post(Guid?teamId, [FromBody] UserApiModel userApiModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!teamId.HasValue)
{
return(BadRequest("TeamId parameter wasn't set. The route is teams/{id}"));
}
var user = await GetRemoteUserAsync(userApiModel.Id);
var userDto = _mapper.Map <UserDto>(user);
await _teamService.AddParticipantAsync(CurrentUserId, teamId.Value, userDto);
_logger.LogInformation(
$"New participant is added to team with id: {teamId}. Participant id: {userDto?.Id}");
return(Ok());
}
public async Task <IActionResult> Register([FromBody] UserApiModel model)
{
try
{
if (!UtilCommon.IsValidEmail(model.Email))
{
return(GetBadRequestResult(ErrorMessageCode.EMAIL_INVALID));
}
var error = _userService.ValidateAddUserData(model);
if (!string.IsNullOrEmpty(error))
{
return(GetBadRequestResult(error));
}
return(GetResult(await _userService.CreateUser(model)));
}
catch (Exception ex)
{
return(GetServerErrorResult(ex.ToString()));
}
}
public IHttpActionResult Create(UserApiModel userApiModel)
{
if (userApiModel == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userParameters = new UserCommand.CreateOrEditParameters
{
Username = userApiModel.Username,
Password = userApiModel.Password,
Lastname = userApiModel.Lastname,
Firstname = userApiModel.Firstname,
Email = userApiModel.Email,
EmailAlternative = userApiModel.EmailAlternative,
InternalNumber = userApiModel.InternalNumber,
PhoneNumber = userApiModel.PhoneNumber,
MobileNumber = userApiModel.MobileNumber,
Role = RoleEnum.User
};
try
{
UserCommand.NewRegister(userParameters);
return(Ok());
}
catch (UserUsernameUniqueException e)
{
ModelState.AddModelError("UserApiModel.Username", Translations.UserUsernameUniqueException);
return(BadRequest(ModelState));
}
}
public async Task <ResponseModel> CreateUser(UserApiModel model)
{
var response = new ResponseModel();
try
{
var user = model.ToEntity(new User());
user.Salt = Guid.NewGuid().ToString().Replace("-", "");
user.PassCode = UtilCommon.GeneratePasscode(model.PassWord, user.Salt);
user.Role = UserRole.Student;
var insert = await _userRepo.InsertAsync(user);
if (insert > -1)
{
response.Data = insert;
response.IsSuccess = true;
response.Status = HttpStatusCode.OK;
return(response);
}
else
{
response.IsSuccess = false;
response.Error = ErrorMessageCode.SERVER_ERROR;
response.Status = HttpStatusCode.InternalServerError;
return(response);
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Error = ex.ToString();
response.Status = HttpStatusCode.InternalServerError;
return(response);
}
}
public IHttpActionResult SignUp(UserApiModel user)
{
try
{
var httpRequest = HttpContext.Current.Request;
//if (httpRequest.Files.Count < 1)
//{
// return (IHttpActionResult)Request.CreateResponse(HttpStatusCode.BadRequest);
//}
// var postedFile = httpRequest.Files[0];
// var filePath = HttpContext.Current.Server.MapPath("~/UploadedFiles" + postedFile.FileName);
// postedFile.SaveAs(filePath);
// user.ProfilePicture = filePath;
int userType = (int)Enum.Parse(typeof(Common.UserTypeEnum), user.UserType, true);
bool userExists = _userBussiness.CheckIfUserExist(user.Email, userType);
if (userExists)
{
return(Ok("User Already exists"));
}
else
{
int id = _userBussiness.CreateUser(user);
if (id > 0)
{
return(Ok("User Created Successfully"));
}
else
{
return(Ok("User not created"));
}
}
}
catch (Exception ex)
{
return(Json(ex));
}
}
public UserApiModel getUserInfoByName(String userName)
{
UserApiModel user = new UserApiModel();
var req = WebRequest.Create(Server.ApiUrl + "/users/name/" + userName);
req.Method = "GET";
req.ContentType = "application/json";
var resp = (HttpWebResponse)req.GetResponse();
using (var reader = new StreamReader(resp.GetResponseStream()))
{
var userData = reader.ReadToEnd();
dynamic userApiModel = JsonConvert.DeserializeObject <dynamic>(userData);
if ((int)userApiModel.state == 0)
{
user.UserId = userApiModel.userId;
user.Name = userApiModel.name;
user.EmailAddress = userApiModel.emailAddress;
user.UserRole = userApiModel.userRole;
}
}
return(user);
}
public async Task <IHttpActionResult> Get(int id, [FromUri] BaseApiParameterModel param)
{
try
{
if (id <= 0)
{
return(BadRequest(Messages.ApiIllegalParameter));
}
UserModel user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
UserApiModel result = Mapper.Map <UserApiModel>(user);
return(Ok(result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> GetUser(String email)
{
User user = await UserManager.FindByEmailAsync(email);
UserApiModel userModel = new UserApiModel();
userModel.firstname = user.firstname;
userModel.lastname = user.lastname;
userModel.email = user.Email;
userModel.id = user.Id;
var role = await RoleManager.FindByIdAsync(user.Roles.FirstOrDefault().RoleId);
userModel.role = role.Name;
if (user == null)
{
return(NotFound());
}
return(Ok(userModel));
}
public IActionResult Insert(UserApiModel model)
{
if (string.IsNullOrEmpty(model.Password))
{
ModelState.AddModelError("", "Password is required");
}
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
if (ModelState.IsValid)
{
var userapi = model.ToEntity();
var keys = HashPassword(model.Password);
userapi.Password = keys.hashpassword;
userapi.PrivateKey = keys.privatekey;
_userApiService.InsertUserApi(userapi);
return(new NullJsonResult());
}
return(ErrorForKendoGridJson(ModelState));
}
internal ApiResultUserApiModel(UserApiModel data)
{
Data = data;
}
public async Task <LoginResult> Login([FromBody] LoginApiModel model, string returnUrl)
{
try
{
if (ModelState.IsValid)
{
var user = await UserManager.FindAsync(model.UserName, model.Password);
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : true, true);
if (User.Identity.IsAuthenticated)
{
var LoggedInUser = await UserManager.FindByEmailAsync(User.Identity.Name);
CurrentUser = new UserApiModel
{
Id = LoggedInUser.Id,
Role = RoleManager.FindByIdAsync(LoggedInUser.Roles.FirstOrDefault().RoleId).Result.Name,
};
}
return(new LoginResult()
{
IsOk = true,
ResultCode = LoginEnumResult.Failure,
ResultText = LoginEnumResult.Failure.ToString(),
Message = new Message("Invalid Login Attempt, User Not Found", MessageType.Error),
Token = null
});
}
else
{
return(new LoginResult()
{
IsOk = true,
ResultCode = LoginEnumResult.Failure,
ResultText = LoginEnumResult.Failure.ToString(),
Message = new Message("Invalid Login Attempt, User Not Found", MessageType.Error),
Token = null
});
}
}
else
{
List <string> errors = new List <string>();
foreach (var item in ModelState.Values)
{
foreach (var error in item.Errors)
{
errors.Add(error.ErrorMessage);
}
}
return(new LoginResult()
{
IsOk = true,
Message = new Message(errors.ToString(), MessageType.Error),
ResultCode = LoginEnumResult.Failure,
ResultText = LoginEnumResult.Failure.ToString(),
Token = null,
});
}
}
catch (Exception ex)
{
return(new LoginResult()
{
IsOk = false,
Message = new Message(ex.Message + " " + ex.InnerException?.Message, MessageType.Error),
ResultCode = LoginEnumResult.Failure,
ResultText = LoginEnumResult.Failure.ToString(),
Token = null
});
}
}
public static UserApi ToEntity(this UserApiModel model, UserApi destination)
{
return(model.MapTo(destination));
}
internal MeApiModel(CompanyApiModel company, UserApiModel user)
{
Company = company;
User = user;
}
public async Task <ActionResult <ListOfAddresesWithCountModel> > AddressesFetch(UserApiModel inputModel)
{
var currentUser = await this._usersService
.GetUserByIdAsync(inputModel.Id);
if (currentUser == null)
{
_logger.LogWarning($"Get current user from DB - NOT FOUND");
return(this.NotFound());
}
var count = _addressesService
.CountOfAddressesPerUser(currentUser);
var listModel = new ListOfAddresesWithCountModel();
listModel.CountOfAddresses = count;
var addressesPerUser = _addressesService
.ListOfAddressesByUser(currentUser.UserName);
if (addressesPerUser == null)
{
_logger.LogWarning($"Get list of addresses for user {currentUser.Id} from DB - NOT FOUND");
return(this.NotFound());
}
if (addressesPerUser.Count() > 0)
{
foreach (var address in addressesPerUser)
{
var shortAddress = new ApiAddressModel
{
Id = address.Id,
Country = address.Country,
Region = address.Region,
Town = address.Town,
StreetName = address.StreetName,
Number = address.Number,
AddressType = address.AddressType.Value
};
listModel.ListOfAdresses.Add(shortAddress);
}
}
return(listModel);
}
public HttpResponseMessage InitializeApplication()
{
TransactionalInformation transaction = new TransactionalInformation();
UserApiModel userApiModel = new UserApiModel();
try
{
var data = mainDataservice.GetUserName(connectionString, SessionToken, Properties.Settings.Default.DocAppGroup, out transaction);
if (string.IsNullOrWhiteSpace(data.AccountInformation.name))
{
userApiModel.name = data.AccountInformation.email;
}
else
{
userApiModel.name = data.AccountInformation.name;
if (!String.IsNullOrEmpty(data.AccountInformation.Title))
{
userApiModel.name = String.Format("{0} {1}", data.AccountInformation.Title, userApiModel.name);
}
}
if (data.AccountInformation.role == Properties.Settings.Default.ACDocAccountDocApp || data.AccountInformation.role == Properties.Settings.Default.ACPracticeAccountDocApp)
{
userApiModel.isOpRole = false;
}
else if (data.AccountInformation.role == Properties.Settings.Default.OPDocAccountDocApp || data.AccountInformation.role == Properties.Settings.Default.OPPracticeAccountDocApp)
{
userApiModel.isOpRole = true;
}
userApiModel.canAddPreexaminations = mainDataservice.CanAddPreexaminations(data.PracticeID, connectionString, SessionToken, out transaction);
userApiModel.ReturnMessage.Add("Application has been initialized.");
userApiModel.ReturnMessage = transaction.ReturnMessage;
userApiModel.ReturnStatus = transaction.ReturnStatus;
userApiModel.IsAuthenicated = transaction.IsAuthenicated;
userApiModel.IsException = transaction.IsException;
userApiModel.isDoctor = data.AccountInformation.role == Properties.Settings.Default.OPDocAccountDocApp || data.AccountInformation.role == Properties.Settings.Default.ACDocAccountDocApp;
userApiModel.id = userApiModel.isDoctor ? data.DoctorID : data.PracticeID;
userApiModel.loginEmail = userLoginEmail = data.AccountInformation.email;
}
catch (Exception ex)
{
transaction.ReturnMessage.Add(ex.Message);
transaction.logoutUrl = GlobalProperties.LOGIN_PAGE;
transaction.ReturnStatus = false;
}
var sessionToken = SessionToken;
if (!SignalRNotifier.Instance.userSessionTokens.Any(t => t == sessionToken))
{
SignalRNotifier.Instance.userSessionTokens.Add(sessionToken);
}
var timeout = 5000;
try
{
timeout = Convert.ToInt32(ConfigurationManager.AppSettings["notificationTimeoutInMiliseconds"]);
}
catch
{
timeout = 5000;
}
if (!SignalRNotifier.Instance.usersThatAreAlreadyReceievingNotifications.Contains(userLoginEmail))
{
SignalRNotifier.Instance.usersThatAreAlreadyReceievingNotifications.Add(userLoginEmail);
sessionTimer = new Timer(new TimerCallback(verifySessionAndUpdateNotifications), state, 0, timeout);
}
if (transaction.ReturnStatus)
{
return(Request.CreateResponse <UserApiModel>(HttpStatusCode.OK, userApiModel));
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized, transaction));
}
public UserApiModel EditUser(UserApiModel model)
{
return(_userService.EditUser(model));
}
public UserApiModel AddUser(UserApiModel model)
{
return(_userService.AddUser(model));
}
public async Task <IActionResult> GetUser(string clientId, string groupId, string userId)
{
var user = await this.clientUsersRepository.GetUser(clientId, groupId, userId);
return(this.Ok(UserApiModel.FromDomain(user)));
}
public async Task <IActionResult> AddUserToGroup(string clientId, string groupId, [FromBody] UserApiModel user)
{
if (!this.ModelState.IsValid)
{
return(this.HttpBadRequest());
}
await this.clientUsersRepository.AddUserToGroup(clientId, groupId, user.ToDomain());
return(this.Ok());
}
public HttpResponseMessage ValidateName(int userId, UserApiModel model)
{
//System.Threading.Thread.Sleep(10000); // test api latency
model.Id = userId;
var command = new CreateUser(User, model.Name);
var validationResult = _createValidator.Validate(command);
var propertyName = command.PropertyName(y => y.Name);
Func<ValidationFailure, bool> forName = x => x.PropertyName == propertyName;
if (validationResult.Errors.Any(forName))
return Request.CreateResponse(HttpStatusCode.BadRequest,
validationResult.Errors.First(forName).ErrorMessage, "text/plain");
return Request.CreateResponse(HttpStatusCode.OK);
}
