public JsonResult UpdateUser(int?UserID, string Username, string Fullname, string Password, int RoleID, int SubscriptionID)
{
bool flag = false;
var CheckExistsUser = _dbContext.Users.SingleOrDefault(u => u.UserID == UserID);
string encode_password = StringHash.crypto(Password);
if (CheckExistsUser != null)
{
CheckExistsUser.Username = Username;
CheckExistsUser.Fullname = Fullname;
if (Password != CheckExistsUser.Password)
{
CheckExistsUser.Password = encode_password;
}
CheckExistsUser.RoleID = RoleID;
CheckExistsUser.SubscriptionID = SubscriptionID;
_dbContext.SaveChanges();
flag = true;
}
else
{
flag = true;
}
return(Json(new { status = flag }, JsonRequestBehavior.AllowGet));
}
public T GetComponent <T>(bool recursive = false)
{
StringHash type = new StringHash(typeof(T).Name);
IntPtr nativeComponent = Node_GetComponent(NativeInstance, type, recursive);
return((T)Activator.CreateInstance(typeof(T), nativeComponent, context_));
}
// public Node(Context context) : this(Node_Node(context.NativeInstance), context) { }
public T CreateComponent <T>(CreateMode mode = CreateMode.REPLICATED, uint id = 0)
{
StringHash type = new StringHash(typeof(T).Name);
IntPtr nativeComponent = Node_CreateComponent(NativeInstance, type, mode, id);
return((T)Activator.CreateInstance(typeof(T), nativeComponent, context_));
}
// public ResourceCache(Context context) : this(ResourceCache_ResourceCache(context.NativeInstance), context) { }
public T GetResource <T>(string name, bool sendEventOnFailure = true)
{
StringHash type = new StringHash(typeof(T).Name);
IntPtr nativeResource = ResourceCache_GetResource(NativeInstance, type, name, sendEventOnFailure);
return((T)Activator.CreateInstance(typeof(T), nativeResource, context_));
}
// public UIElement(Context context) : this(UIElement_UIElement(context.NativeInstance), context) { }
public T CreateChild <T>(string name = "", uint index = Math.M_MAX_UNSIGNED)
{
StringHash type = new StringHash(typeof(T).Name);
IntPtr nativeChild = UIElement_CreateChild(NativeInstance, type, name, index);
return((T)Activator.CreateInstance(typeof(T), nativeChild, context_));
}
public static async Task <string> EditUserInfo(User user)
{
string hashedToken = StringHash.HashedPassword(user.userToken);
var response = await UserAPI_Logic.EditUserData(hashedToken, user);
return(response);
}
public Vector4 GetVector4(StringHash key, Vector4? @default = null)
{
var result = @default.GetValueOrDefault(Vector4.Zero);
Urho3D_Object_Event_GetVector4(_map, key.Hash, ref result);
return(result);
}
public Quaternion GetQuaternion(StringHash key, Quaternion? @default = null)
{
var result = @default.GetValueOrDefault(Quaternion.Identity);
Urho3D_Object_Event_GetQuaternion(_map, key.Hash, ref result);
return(result);
}
public Matrix4 GetMatrix4(StringHash key, Matrix4? @default = null)
{
var result = @default.GetValueOrDefault(Matrix4.Zero);
Urho3D_Object_Event_GetMatrix4(_map, key.Hash, ref result);
return(result);
}
protected virtual StringHash <object> getValues(object obj)
{
var hash = new StringHash <object>(false);
foreach (var memberInfo in equatableInfo)
{
switch (memberInfo)
{
case FieldInfo fieldInfo:
{
var value = fieldInfo.GetValue(obj);
if (value is not null)
{
hash[fieldInfo.Name] = value;
}
}
break;
case PropertyInfo propertyInfo:
{
var value = propertyInfo.GetValue(obj);
if (value is not null)
{
hash[propertyInfo.Name] = value;
}
}
break;
}
}
return(hash);
}
public T GetSubsystem <T>()
{
StringHash type = new StringHash(typeof(T).Name);
IntPtr nativeSubsystem = Context_GetSubsystem(NativeInstance, type);
return((T)Activator.CreateInstance(typeof(T), nativeSubsystem, this));
}
public T CreateChild <T> (StringHash code, string name = "", uint index = UInt32.MaxValue) where T : UIElement
{
Runtime.ValidateRefCounted(this);
var ptr = UIElement_CreateChild(handle, code.Code, name, index);
return(Runtime.LookupObject <T> (ptr));
}
/// <summary>
/// Adds entity if Id is 0. Otherwise Updates it
/// </summary>
/// <exception cref="EntityException">Contains EF Exception and a standart HTTP-responce for client side</exception>
public Guid AddOrUpdate <T>(T entity) where T : class, IEntity
{
if (entity is null)
{
throw new ArgumentNullException(nameof(entity));
}
try
{
if (entity.Id == Guid.Empty)
{
if (entity is Human)
{
(entity as Human).Passhash = StringHash.GetStringSha256Hash((entity as Human).Passhash);
}
db.Add(EntitySecurityAdapter.Encrypt(entity));
}
else
{
db.Update(EntitySecurityAdapter.Encrypt(entity)); //todo: bugfix user can not change his password or account is lost
}
db.SaveChanges();
return(entity.Id);
}
catch (Exception E)
{
throw new EntityException(E, entity);
}
}
public void SearchCursor()
{
var one = "one";
var two = "two";
var three = "three";
var set = new StringSet(4);
// pretend that we have some hash collisions
var hash = StringHash.GetHash(one);
set.Add(one, hash);
set.Add(two, hash);
set.Add(three, hash);
var cursor = set.GetSearchCursor(hash);
// add one more with the same hash to make sure the cursor doesn't change
set.Add("four", hash);
Assert.AreEqual(4, set.Count);
Assert.AreEqual(4, set.MaxSize); // hash collisions shouldn't cause the set to grow
Assert.True(cursor.MightHaveMore);
Assert.AreSame(three, cursor.NextString());
Assert.True(cursor.MightHaveMore);
Assert.AreSame(two, cursor.NextString());
Assert.True(cursor.MightHaveMore);
Assert.AreSame(one, cursor.NextString());
Assert.False(cursor.MightHaveMore);
}
public IntRect GetIntRect(StringHash key, IntRect? @default = null)
{
var result = @default.GetValueOrDefault(IntRect.Zero);
Urho3D_Object_Event_GetIntRect(_map, key.Hash, ref result);
return(result);
}
public Color GetColor(StringHash key, Color? @default = null)
{
var result = @default.GetValueOrDefault(Color.Transparent);
Urho3D_Object_Event_GetColor(_map, key.Hash, ref result);
return(result);
}
public object GetObject(StringHash key, object @default = null)
{
IntPtr result = IntPtr.Zero;
var type = 0;
Urho3D_Object_Event_GetObject(_map, key.Hash, ref type, ref result);
if (result == IntPtr.Zero)
{
return(@default);
}
if (type == 1)
{
// Managed object
@default = GCHandle.FromIntPtr(result).Target;
}
else if (type == 2)
{
// Native object
@default = NativeObject.GetManagedInstanceGeneric <RefCounted>(result);
}
else
{
throw new Exception();
}
return(@default);
}
public JsonResult Register(string username, string password, string email, string address, string cellphone)
{
var check_email = _dbContext.Customers.Where(x => x.CustomerEmail == email).FirstOrDefault();
if (check_email == null)
{
string hash_password = StringHash.crypto(password);
Customer customer = new Customer
{
CustomerID = RandomString.getRandomString(5),
CustomerName = username,
CustomerPassword = hash_password,
CustomerEmail = email,
CustomerAddress = address,
CustomerCellphone = cellphone
};
var register = _dbContext.Customers.Add(customer);
if (register != null)
{
_dbContext.SaveChanges();
return(Json(new { data = "Đăng ký thành công", status = true }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { data = "Đăng ký thất bại", status = false }, JsonRequestBehavior.AllowGet));
}
}
else
{
return(Json(new { data = "Email đã tồn tại, vui lòng nhập lại", status = false }, JsonRequestBehavior.AllowGet));
}
}
protected Adapters(DataGroups dataGroups, StringHash <Adapter <T> > adapters, StringSet validAdapters,
Predicate <string> isValidAdapterName)
{
this.dataGroups = dataGroups;
this.adapters = new StringHash <Adapter <T> >(true, adapters);
this.validAdapters = new StringSet(true, validAdapters);
this.isValidAdapterName = isValidAdapterName;
}
public static async void GetAddresses()
{
string token = "";
using (SQLiteConnection conn = new SQLiteConnection(App.DatabaseLocation))
{
conn.CreateTable <UserPost>();
var userD = conn.Table <UserPost>().First();
token = userD.Token;
string hashedToken = StringHash.HashedPassword(token);
var rep = await UserAPI_Logic.GetUserAddresses(hashedToken);
if (rep != null)
{
int count = rep.Count;
for (int i = 0; i < count; i++)
{
UserAddressPost post = new UserAddressPost()
{
Id = rep[i].id,
Name = rep[i].name,
Address = rep[i].address,
Postal_code = (int)Convert.ToUInt64(rep[i].postal_code),
Phone_number = (int)Convert.ToUInt64(rep[i].phone_number),
City = rep[i].city
};
conn.CreateTable <UserAddressPost>();
int rows = conn.InsertOrReplace(post);
if (rows > 0)
{
//success++;
}
else
{
//fail++;
}
}
var apiLast = rep.Last().id;
var apiCount = rep.Count;
var posts = conn.Table <UserAddressPost>().ToList();
var dbLast = posts.Last().Id;
int dbCount = posts.Count;
if (apiLast != dbLast && dbCount != apiCount)
{
foreach (var a in posts)
{
if (!rep.Any(n => n.id == a.Id))
{
conn.Delete <UserAddressPost>(a.Id);
}
}
}
}
conn.Close();
}
}
public object GetVariable(StringHash nameHash)
{
if (nameHash == OWNER)
{
return(_owner);
}
return(null);
}
public async Task <bool> MasterKeySucessfulyDecrypted(string password, CancellationToken cancellationToken)
{
var masterKey = await privateCertRepository.GetMasterKeyAsync();
var passwordHashed = StringHash.GetHash(password);
var passwordHashedString = StringHash.GetHashString(passwordHashed);
return(masterKey == passwordHashedString);
}
public void StringHashTest()
{
var hash = new StringHash <int>(true)
{
["alpha"] = 0, ["bravo"] = 1, ["charlie"] = 2
};
hash.Must().HaveKeyOf("Bravo").OrThrow();
}
public object GetVariable(StringHash nameHash)
{
if (nameHash == new StringHash("Owner"))
{
return(gameObject);
}
return(null);
}
public void HandleUpdate(StringHash eventType, IntPtr eventData)
{
VariantMap data = new VariantMap(eventData);
// Take the frame time step, which is stored as a float
float timeStep = data["TimeStep"].GetFloat();
// Move the camera, scale movement with time step
MoveCamera(timeStep);
}
T GetResource <T> (StringHash type, string name, bool sendEventOnFailure) where T : UrhoObject
{
var ptr = ResourceCache_GetResource(handle, type.Code, name, sendEventOnFailure);
if (ptr == IntPtr.Zero)
{
return(null);
}
return(Runtime.LookupObject <T> (ptr));
}
public ResourceRefList GetResourceRefList(StringHash key, ResourceRefList @default = null)
{
IntPtr instance = IntPtr.Zero;
Urho3D_Object_Event_GetResourceRefList(_map, key.Hash, ref instance);
if (instance == IntPtr.Zero)
{
return(@default);
}
return(ResourceRefList.GetManagedInstance(instance));
}
public async Task <IActionResult> Register([FromBody] UserViewModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User _newUser = Mapper.Map <UserViewModel, User>(user);
_newUser.Salt = StringHash.SaltGen();
_newUser.Confirmation = _newUser.Salt;
_newUser.isConfirmed = false;
_newUser.Password = StringHash.GetHash(_newUser.Password + _newUser.Salt);
_userRepository.Add(_newUser);
await _userRepository.Commit();
var callbackUrl = "http://localhost:58969/" + Url.Action("Confirmation", "Customer", new { UserId = _newUser.Id, Code = _newUser.Confirmation });
await _mailSender.SendEmail(_newUser.Email, "Confirm your account",
$"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
var identity = new ClaimsIdentity(
new GenericIdentity(_newUser.UserName, "Token"),
new[]
{
new Claim("Username", _newUser.UserName)
});
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, _newUser.UserName),
new Claim(JwtRegisteredClaimNames.Jti, await _jwtOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_jwtOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("Username")
};
var jwt = new JwtSecurityToken(
issuer: _jwtOptions.Issuer,
audience: _jwtOptions.Audience,
claims: claims,
notBefore: _jwtOptions.NotBefore,
expires: _jwtOptions.Expiration,
signingCredentials: _jwtOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var result = new
{
Status = "Registration Success",
Confirmed = false,
access_token = encodedJwt,
expires_in = (int)_jwtOptions.ValidFor.TotalDays
};
var json = JsonConvert.SerializeObject(result, _serializerSettings);
return(new OkObjectResult(json));
}
public static ExpressionFunction GetFunction(StringHash h)
{
if (functions.TryGetValue(h, out var ty))
{
return((ExpressionFunction)Activator.CreateInstance(ty));
}
else
{
throw new Exception("Can't find function " + h.GetOriginalString());
}
}
public void SetObject(StringHash key, object value)
{
if (value is RefCounted obj)
{
Urho3D_Object_Event_SetObject(_map, key.Hash, 2, obj.NativeInstance);
}
else
{
Urho3D_Object_Event_SetObject(_map, key.Hash, 1, GCHandle.ToIntPtr(GCHandle.Alloc(value)));
}
}
