public IActionResult RegisterUser([FromBody] RequestUser requestUser)
{
//Check if model is valid
if (!ModelState.IsValid)
{
return(BadRequest());
}
//Check if username is avaliable
var userWithProvidedUsername = _context
.Users
.SingleOrDefault(u => u.Username == requestUser.Username);
if (userWithProvidedUsername != null)
{
return(Ok(new { error = "Ta nazwa użytkownika jest już zajęta!" }));
}
User newUser = new User()
{
Username = requestUser.Username,
Name = requestUser.Name,
Surname = requestUser.Surname,
Email = requestUser.Email,
PasswordHash = BCrypt.Net.BCrypt.HashPassword(requestUser.Password)
};
_context.Users.Add(newUser);
_context.SaveChanges();
return(Ok(new { message = "Pomyślnie zarejestrowano!" }));
}
public ResponseData PostValidateUser(RequestUser user)
{
var response = new ResponseData();
response.Message = facade.ValidateManager(user.PasswordHash, user.Name);
return(response);
}
public ResponseData PostUser(RequestUser user)
{
var response = new ResponseData();
response.Message = facade.UserManager(user);
return(response);
}
private async Task <List <ReturnableViewModel> > GetReturnables(RequestUser requestUser, CancellationToken token)
{
return(await _context.Returnables
.Where(c => c.ProducerId == requestUser.Id && !c.RemovedOn.HasValue)
.ProjectTo <ReturnableViewModel>(_configurationProvider)
.ToListAsync(token));
}
public async Task <Session> LoginAsync(RequestUser user)
{
if (user == null)
{
return(null);
}
var userFromStorage = await _storage.GetUserByUserNameAsync(user.UserName);
if (userFromStorage == null)
{
return(null);
}
if (!_hashGenerator.AreEqual(user.Password, userFromStorage.PasswordHash))
{
return(null);
}
//get user token
var token = _tokenGenerator.GenerateToken(userFromStorage.UserName, userFromStorage.PasswordHash);
//create session
return(new Session
{
UserName = userFromStorage.UserName,
GamerInfo = userFromStorage.GamerInfo,
Token = token
});
}
public async Task <Session> RegisterAsync(RequestUser userForRegister)
{
if (userForRegister == null)
{
return(null);
}
//generate password hash
var passwordHash = _hashGenerator.GenerateHash(userForRegister.Password);
//create user
var user = new User
{
UserName = userForRegister.UserName,
GamerInfo = new GamerInfo(userForRegister.UserName),
PasswordHash = passwordHash
};
//try to add new user
if (!await _storage.TryAddUserAsync(user))
{
return(null);
}
//get token for new user
var token = _tokenGenerator.GenerateToken(user.UserName, user.PasswordHash);
//return new session with token
return(new Session
{
UserName = user.UserName,
GamerInfo = user.GamerInfo,
Token = token
});
}
private void refreshButton_Click(object sender, EventArgs e)
{
RequestUser request = new RequestUser();
request.id = this.id;
//Making the register request
ResponseUser response = (ResponseUser)WebRequestPost.makeRequest <ResponseUser>("/users/get", request);
if (response.error.Equals("1"))
{
MessageBox.Show(
response.message,
"Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else if (!response.error.Equals("0"))
{
MessageBox.Show(
"What??",
"Seriously, what?",
MessageBoxButtons.OK,
MessageBoxIcon.Question);
}
ticketsList.Items.Clear();
foreach (TroubleTicket ticket in response.userTickets)
{
this.addTickets(ticket.id, ticket.title, ticket.state);
}
}
public UserResponse UpdateProfile(RequestUser req)
{
UserResponse objRes = new UserResponse();
try
{
var query = objlovesnwishesEntities.tblUsers.Where(x => x.Id == req.Id).FirstOrDefault();
if (query != null)
{
query.FirstName = req.FirstName;
query.LastName = req.LastName;
query.MobileNo = req.MobileNo;
objlovesnwishesEntities.SaveChanges();
objRes.UserId = query.Id;
}
else
{
objRes.UserId = 0;
}
}
catch (Exception ex)
{
}
return(objRes);
}
public List <UserTable> GetByCondition(RequestUser user)
{
List <UserTable> list = _dbcontext.UserTable.WhereIf(!string.IsNullOrWhiteSpace(user.LoginName), t => t.LoginName.Contains(user.LoginName))
.WhereIf(!string.IsNullOrWhiteSpace(user.RealName), t => t.RealName.Contains(user.RealName)).ToList();
return(list);
}
private IEnumerable <RequestUser> GetRequestUserModel(IEnumerable <RequestUserViewModel> requestUserViewlModels)
{
var requestUsers = new List <RequestUser>();
if (requestUserViewlModels != null)
{
foreach (RequestUserViewModel requestUserVM in requestUserViewlModels)
{
var requestUser = new RequestUser()
{
Id = requestUserVM.id,
EmpNo = requestUserVM.empNo,
EmpName = requestUserVM.empName,
EmpId = requestUserVM.empId,
Manager = requestUserVM.manager,
TeamId = requestUserVM.teamId,
Email = requestUserVM.email,
Position = requestUserVM.position,
Phone = requestUserVM.phone,
HiredDate = requestUserVM.hiredDate,
Version = 1
};
requestUsers.Add(requestUser);
}
}
return(requestUsers);
}
// PUT api/<controller>/5
public IHttpActionResult ChangePassword(RequestUser request)
{
UserResponse objResponse = new UserResponse();
try
{
objResponse = objUserService.ChangePassword(request);
if (objResponse != null && objResponse.UserId > 0)
{
return(Ok <APIResponse>(new APIResponse(true, objResponse, "Password updated successfully.")));
}
else if (objResponse.UserId == 0)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new APIResponse(false, objResponse, "Password updated failed."))));
}
else
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.ExpectationFailed, objResponse)));
}
}
catch (Exception ex)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.InternalServerError, new APIResponse(false, objResponse, "Unexpected error occured."))));
}
}
public IActionResult Notify(PspEventKind EventType, long date, string resourceId = null, string ressourceId = null)
{
var requestUser = new RequestUser("hook", _httpContextAccessor.HttpContext.TraceIdentifier);
var identifier = ressourceId ?? resourceId;
switch (EventType)
{
case PspEventKind.KYC_SUCCEEDED:
case PspEventKind.KYC_FAILED:
case PspEventKind.KYC_OUTDATED:
case PspEventKind.KYC_VALIDATION_ASKED:
_sheaftMediatr.Post(new RefreshDocumentStatusCommand(requestUser, identifier));
break;
case PspEventKind.UBO_DECLARATION_REFUSED:
case PspEventKind.UBO_DECLARATION_VALIDATED:
case PspEventKind.UBO_DECLARATION_INCOMPLETE:
case PspEventKind.UBO_DECLARATION_VALIDATION_ASKED:
_sheaftMediatr.Post(new RefreshDeclarationStatusCommand(requestUser, identifier));
break;
case PspEventKind.PAYIN_NORMAL_SUCCEEDED:
case PspEventKind.PAYIN_NORMAL_FAILED:
_sheaftMediatr.Post(new RefreshPayinStatusCommand(requestUser, identifier));
break;
case PspEventKind.TRANSFER_NORMAL_SUCCEEDED:
case PspEventKind.TRANSFER_NORMAL_FAILED:
_sheaftMediatr.Post(new RefreshTransferStatusCommand(requestUser, identifier));
break;
case PspEventKind.PAYOUT_NORMAL_SUCCEEDED:
case PspEventKind.PAYOUT_NORMAL_FAILED:
_sheaftMediatr.Post(new RefreshPayoutStatusCommand(requestUser, identifier));
break;
case PspEventKind.PAYIN_REFUND_SUCCEEDED:
case PspEventKind.PAYIN_REFUND_FAILED:
_sheaftMediatr.Post(new RefreshPayinRefundStatusCommand(requestUser, identifier));
break;
case PspEventKind.USER_KYC_LIGHT:
case PspEventKind.USER_KYC_REGULAR:
_sheaftMediatr.Post(new RefreshLegalValidationCommand(requestUser, identifier));
break;
case PspEventKind.PREAUTHORIZATION_PAYMENT_CANCELED:
case PspEventKind.PREAUTHORIZATION_PAYMENT_EXPIRED:
case PspEventKind.PREAUTHORIZATION_PAYMENT_VALIDATED:
case PspEventKind.PREAUTHORIZATION_PAYMENT_WAITING:
_sheaftMediatr.Post(new RefreshPreAuthorizationStatusCommand(requestUser, identifier));
break;
default:
_logger.LogInformation($"{EventType:G)} is not a supported Psp EventType for resource: {identifier} executed on: {GetExecutedOn(date)}.");
return(BadRequest());
}
return(Ok());
}
public UserResponse Registration(RequestUser req)
{
UserResponse objRes = new UserResponse();
try
{
var query = objlovesnwishesEntities.tblUsers.Where(x => x.Email.ToLower() == req.Email.ToLower()).FirstOrDefault();
if (query == null)
{
tblUser objtblUser = new tblUser()
{
Email = req.Email,
FirstName = req.FirstName,
LastName = req.LastName,
MobileNo = req.MobileNo,
Password = req.Password,
ProfileImageUrl = req.PhotoUrl,
};
objlovesnwishesEntities.tblUsers.Add(objtblUser);
objlovesnwishesEntities.SaveChanges();
objRes.UserId = objtblUser.Id;
}
else
{
objRes.UserId = 0;
}
}
catch (Exception ex)
{
}
return(objRes);
}
// POST api/<controller>
public IHttpActionResult Post(RequestUser request)
{
UserResponse objResponse = new UserResponse();
try
{
objResponse = objUserService.Registration(request);
if (objResponse != null && objResponse.UserId > 0)
{
return(Ok <APIResponse>(new APIResponse(true, objResponse, "User registered successfully.")));
}
else if (objResponse.UserId == 0)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, new APIResponse(false, objResponse, "Email already exists in the event."))));
}
else
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.ExpectationFailed, objResponse)));
}
}
catch (Exception ex)
{
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.InternalServerError, new APIResponse(false, objResponse, "Unexpected error occured."))));
}
}
public GenericResponse <string> GetUserId([FromBody] RequestUser requestUser)
{
try
{
RequestAuthorization requestAuthorization = new RequestAuthorization()
{
Password = Request.Headers.ToList().FirstOrDefault(x => x.Key == "pws").Value.ToString(),
UserName = Request.Headers.ToList().FirstOrDefault(x => x.Key == "username").Value.ToString()
};
var secure = this.Authorize(requestAuthorization);
if (secure.Data.SessionId != null)
{
var idUsuario = this.GetUserIdByName(requestUser, secure.Data);
this.CloseSession(secure.Data);
return(Mapper <string> .MapGenericResponse(idUsuario.Data, HttpStatusCode.OK, HttpStatusCode.OK.ToString(), $"Id for User: { requestUser.UserName }", string.Empty));
}
else
{
return(Mapper <string> .MapGenericResponse(string.Empty, HttpStatusCode.Unauthorized, HttpStatusCode.Unauthorized.ToString(), "Wrong username or password", "Verify credentials"));
}
}
catch (Exception ex)
{
return(Mapper <string> .MapGenericResponse("ERROR", HttpStatusCode.OK, HttpStatusCode.OK.ToString(), $"ERROR: { ex.Message }", string.Empty));
}
}
private void InitializeWithholdingsSheet(ExcelPackage package, RequestUser user, DateTimeOffset from,
DateTimeOffset to, IEnumerable <Withholding> withholdings, CancellationToken token)
{
var withholdingsWorksheet = package.Workbook.Worksheets.Add("Paiements");
withholdingsWorksheet.Cells[1, 1, 1, 5].Value = $"Vos paiements du {from:dd-MM-yyyy} au {to:dd-MM-yyyy}";
withholdingsWorksheet.Cells[1, 1, 1, 5].Merge = true;
withholdingsWorksheet.Cells[2, 1].Value = "Nom du destinataire";
withholdingsWorksheet.Cells[2, 2].Value = "Email du destinataire";
withholdingsWorksheet.Cells[2, 3].Value = "Date d'éxécution";
withholdingsWorksheet.Cells[2, 4].Value = "Montant TTC";
withholdingsWorksheet.Cells[2, 5].Value = "Raison";
var i = 3;
foreach (var withholding in withholdings)
{
withholdingsWorksheet.Cells[i, 1].Value = withholding.DebitedWallet.User.Name;
withholdingsWorksheet.Cells[i, 2].Value = withholding.DebitedWallet.User.Email;
withholdingsWorksheet.Cells[i, 3].Value = withholding.ExecutedOn.Value.ToString("dd/MM/yyyy");
withholdingsWorksheet.Cells[i, 4].Value = withholding.Debited;
withholdingsWorksheet.Cells[i, 5].Value = "Validation de vos documents de paiements";
i++;
}
}
public async Task <IProductsFileImporter> GetImporterAsync(RequestUser requestUser, CancellationToken token)
{
var user = await _context.Users.SingleAsync(e => e.Id == requestUser.Id, token);
var setting = user.GetSetting(SettingKind.ProductsImporter);
return(InstanciateImporter(requestUser, setting?.Value ?? _options.ProductsImporter));
}
public async Task <IBillingsFileExporter> GetExporterAsync(RequestUser requestUser, CancellationToken token)
{
var user = await _context.Users.SingleAsync(e => e.Id == requestUser.Id, token);
var setting = user.GetSetting(SettingKind.DeliveriesExporter);
return(InstanciateExporter(requestUser, setting?.Value ?? _options.BillingsExporter));
}
public string UserManager(RequestUser user)
{
var us = new Repository.User();
us.Name = user.Name;
us.PasswordHash = user.PasswordHash;
us.TypeRoleID = user.TypeRoleID;
return(userLogic.PostUser(user));
}
private byte[] CreateExcelUserTransactionsFileAsync(ExcelPackage package, RequestUser user, DateTimeOffset from,
DateTimeOffset to, IEnumerable <Payout> payouts, IEnumerable <Withholding> withholdings,
CancellationToken token)
{
InitializePayoutsSheet(package, user, from, to, payouts, token);
InitializeWithholdingsSheet(package, user, from, to, withholdings, token);
return(package.GetAsByteArray());
}
public static bool IsInRole(this RequestUser user, string roleName)
{
if (user == null || user.Roles?.Any() != true)
{
return(false);
}
return(user.Roles.Contains(roleName));
}
public bool ValidateAccessRights(RequestUser requestUser)
{
if (_context.SessionTokens.Any(x => x.UserId == requestUser.UserId && x.AccessToken == requestUser.AccessToken))
{
return(true);
}
return(false);
}
public override Conversation Build(string userId, OnlineJudger onlineJudger)
{
DisplayName = GetDisplayName(userId);
DisplayImagePath = GetDisplayImagePath(userId);
AnotherUserId = SpecialUser(userId).Id;
RequestUser.Build(onlineJudger);
TargetUser.Build(onlineJudger);
return(this);
}
protected Request ConvertToRequest(RequestModel <TUserModel> requestModel, Action <RequestUserAssoc, TUserModel> requestUserAssocAddedCallback = null)
{
requestModel.Users.ForEach(r => r.Snp = r.Snp.Trim());
requestModel.Users = ClearUsersDuplicates(requestModel.Users);
var request = new Request
{
IdRequest = requestModel.IdRequest,
IdRequestType = requestModel.IdRequestType,
Description = requestModel.Description,
RequestUserAssoc = new List <RequestUserAssoc>()
};
foreach (var user in requestModel.Users)
{
var requestUser = new RequestUser
{
Snp = user.Snp,
Login = user.Login,
Post = user.Post,
Department = user.Department,
Unit = user.Unit,
Office = user.Office,
Phone = user.Phone
};
var requestUserAssoc = new RequestUserAssoc
{
RequestUser = requestUser,
Request = request,
Description = user.Description
};
request.RequestUserAssoc.Add(requestUserAssoc);
if (requestUserAssocAddedCallback != null)
{
requestUserAssocAddedCallback(requestUserAssoc, user);
}
if (user.Rights != null)
{
requestUserAssoc.RequestUserRightAssocs = new List <RequestUserRightAssoc>();
foreach (var right in user.Rights)
{
var requestUserRightAssoc = new RequestUserRightAssoc
{
RequestUserAssoc = requestUserAssoc,
Descirption = right.Description,
IdRequestRightGrantType = right.IdRequestRightGrantType,
IdResourceRight = right.IdResourceRight
};
requestUserAssoc.RequestUserRightAssocs.Add(requestUserRightAssoc);
}
}
}
return(request);
}
public IActionResult UserRetrieved(RequestUser request)
{
try
{
return(Ok());
}
catch (Exception ex)
{
return(NotFound(ex.Message));
}
}
internal static void SetLogin(User user, bool rememberMe)
{
var item = new RequestUser {
Id = user.Id, Name = user.Name
};
var minutes = rememberMe ? 60 * 24 * 365 : 60;
var cookievalue = SerializeHelper.ToJson(item);
CookieExtend.ClearCookieAll(); //清空全部
CookieExtend.SetCookie(CookiesName.UserInfo, cookievalue, minutes); //添加用户信息
}
public async Task <ActionResult> Create(IFormFile fileTemp, string Request, string Message, string FormalizationId = "", string time = "")
{
String error = "";
//Valida el archivo
var adjunto = "";
if (fileTemp != null && fileTemp.Length > 0)
{
try
{
var _path = Path.Combine(_env.ContentRootPath, "Storage");
//Crea la carpeta
var _pathFolder = Path.Combine(_path, "Adjuntos");
if (!Directory.Exists(_pathFolder))
{
Directory.CreateDirectory(_pathFolder);
}
//Carga el archivo
var _fileName = time + "-" + Path.GetFileName(fileTemp.FileName);
var _pathFile = Path.Combine(_pathFolder, _fileName);
using (var fileStream = new FileStream(_pathFile, FileMode.Create))
{
await fileTemp.CopyToAsync(fileStream);
}
adjunto = Path.Combine("Adjuntos", _fileName);
}
catch (Exception e) { error = "Error archivo: " + e.Message; }
}
//Crea la solicitud
try
{
var solicitud = new RequestUser();
solicitud.Request = Request;
solicitud.Message = Message;
solicitud.FormalizationId = FormalizationId != "" ? Int32.Parse(FormalizationId) : 0;
solicitud.File = adjunto;
var user = await userManager.FindByNameAsync(User.Identity.Name);
solicitud.IdUser = user.Id;
solicitud.CreateDate = DateTime.Now;
solicitud.State = RequestUser.ESTADO_NUEVA;
solicitud.AlertAdmin = true;
db.RequestUser.Add(solicitud);
await db.SaveChangesAsync();
}
catch (Exception e) { error = "Error solicitud: " + e.Message; }
return(Json(error));
}
public string PostUser(RequestUser user)
{
var passManager = new PasswordManager();
List <string> passHashed = passManager.GeneratePassword(user.PasswordHash, 36);
user.PasswordHash = passHashed[1];
user.SecuritySalt = passHashed[0];
var userConverted = JsonConvert.DeserializeObject <Repository.User>(JsonConvert.SerializeObject(user));
return(manager.PostUser(userConverted));
}
protected async Task <IActionResult> ExecuteFunction <T>(Func <RequestUser, Task <T> > func)
{
try
{
var requestUser = new RequestUser();
var token = Request.Headers[HeaderNames.Authorization].ToString().Replace("Bearer ", string.Empty);
//var tonkenPrefix = _configuration.GetSection(nameof(JWTAuthenticaion)).Get<JWTAuthenticaion>();
string secret = "372F78BC6B66F3CEAF705FE57A91F369A5BE956692A4DA7DE16CAD71113CF046";
var key = Encoding.ASCII.GetBytes(secret);
var handler = new JwtSecurityTokenHandler();
var validations = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
var claims = new ClaimsPrincipal();
try
{
claims = handler.ValidateToken(token, validations, out var tokenSecure);
}
catch (Exception e)
{
return(new UnauthorizedResult());
}
Guid userId = Guid.Empty;
if (Guid.TryParse(claims.Claims.First(claim => claim.Type == "Id").Value, out userId))
{
requestUser.Id = userId;
}
requestUser.Fullname = claims.Claims.First(claim => claim.Type == "Fullname").Value;
var roles = claims.Claims.First(claim => claim.Type == "Roles").Value;
if (!string.IsNullOrEmpty(roles))
{
var listRoles = roles.Split(",").ToList();
requestUser.Roles = listRoles;
}
var result = await func(requestUser);
return(new OkObjectResult(new GenericResult(result, true, "success!!!")));
}
catch (Exception ex)
{
return(new OkObjectResult(new GenericResult(false, ex.InnerException != null ? ex.InnerException.Message : ex.Message)));
}
}
public ActionResult GetRequestUser(int requestUserId)
{
try
{
RequestUser requestUser = database.RequestUsers.AsNoTracking().SingleOrDefault(i => i.ID == requestUserId);
return(Json(requestUser));
}
catch (Exception ex)
{
return(Json(ex.Message));
}
}
void Start()
{
// customer
RequestUser user = new RequestUser();
user.username = "******";
user.password = "******";
// serialize to a string
Serializer serializer = new Serializer(typeof(RequestUser));
//**** JSON Text ****
string jsonText = serializer.Serialize(user);
Debug.Log(jsonText);
// **** JSON to object
RequestUser deserializedUser = (RequestUser) serializer.Deserialize(jsonText);
Debug.Log("Username: "******" Password: " + deserializedUser.password);
}
void LoginScreen()
{
// Make a background box
GUI.backgroundColor = Color.black;
GUI.Box(new Rect(Screen.width/2-110,Screen.height/2-100,300,140), "Welcome, Please Log In");
// Make login text fields
GUI.backgroundColor = Color.gray;
UserName = GUI.TextField(new Rect(Screen.width/2-60, Screen.height/2-60, 200, 20),UserName, 50);
//Password = GUI.TextField(new Rect(Screen.width/2-60, Screen.height/2-30, 200, 20),Password, 50);
Password = GUI.PasswordField(new Rect(Screen.width/2-60, Screen.height/2-30, 200, 20),Password,"*"[0], 50);
// Make the first button.
if (GUI.Button(new Rect(Screen.width/2,Screen.height/2,80,20), "Login")) {
// Create a request object
RequestUser user = new RequestUser();
user.username = UserName;
user.password = Password;
// Serialize to a string
string jsonText = RequestUtils.serialize(user, typeof(RequestUser));
HttpWebResponse httpResponse = SendHttpRequestToCortex.SendPostRequest(authUrl,jsonText);
Debug.Log(httpResponse.StatusCode);
if (httpResponse.StatusCode == HttpStatusCode.OK) {
// Change application behavior once authenticated
stage = 1;
// Get JSON string from response
string responseJSON = SendHttpRequestToCortex.GetResponseBody(httpResponse);
auth = (ResponseAuthentication) RequestUtils.deserialize(responseJSON, typeof(ResponseAuthentication));
} else {
GUI.Box(new Rect(Screen.width/2+30,Screen.height/2+30,80,20), "Invalid Password, Please try Again");
}
}
}
