public async Task <ValuePair <TokenVm, string> > UserIdPasswordCreateTokenPairAsync(long userId, string password,
string deviceTokenId)
{
byte[] passwordHash = CreateUsersService.GetSha512Hash(password);
using (MessengerDbContext context = contextFactory.Create())
{
User targetUser =
await context.Users.FirstOrDefaultAsync(user => user.Id == userId && user.Sha512Password.SequenceEqual(passwordHash) && !user.Deleted)
.ConfigureAwait(false);
if (targetUser != null)
{
string accessToken = RandomExtensions.NextString(64);
string refreshToken = RandomExtensions.NextString(64);
Token tokenPair = new Token()
{
UserId = userId,
AccessToken = accessToken,
RefreshToken = refreshToken,
AccessTokenExpirationTime = DateTime.UtcNow.AddHours(ACCESS_LIFETIME_HOUR).ToUnixTime(),
RefreshTokenExpirationTime = DateTime.UtcNow.AddHours(REFRESH_LIFETIME_HOUR).ToUnixTime(),
DeviceTokenId = deviceTokenId
};
string newPassword = RandomExtensions.NextString(CreateUsersService.PASSWORD_LENGTH);
targetUser.Sha512Password = CreateUsersService.GetSha512Hash(newPassword);
context.Users.Update(targetUser);
await context.Tokens.AddAsync(tokenPair).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(new ValuePair <TokenVm, string>(TokenConverter.GetTokenVm(tokenPair), newPassword));
}
}
throw new UserNotFoundException();
}
public void RandomString_InvalidArgument_ThrowsException()
{
Assert.ThrowsException <ArgumentNullException>(() => RandomExtensions.RandomString(null, s_chars, 2));
Assert.ThrowsException <ArgumentNullException>(() => _random.RandomString(null, 4));
Assert.ThrowsException <ArgumentException>(() => _random.RandomString(Array.Empty <char>(), 4));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => _random.RandomString(s_chars, -1));
}
public async Task <TokenVm> RefreshTokenPairAsync(long userId, string refreshToken)
{
using (MessengerDbContext context = contextFactory.Create())
{
Token target = await context.Tokens
.FirstOrDefaultAsync(token => token.RefreshToken == refreshToken && token.UserId == userId && !token.User.Deleted)
.ConfigureAwait(false);
if (target != null)
{
target.AccessToken = RandomExtensions.NextString(64);
target.RefreshToken = RandomExtensions.NextString(64);
target.AccessTokenExpirationTime = DateTime.UtcNow.AddHours(ACCESS_LIFETIME_HOUR).ToUnixTime();
target.RefreshTokenExpirationTime = DateTime.UtcNow.AddHours(REFRESH_LIFETIME_HOUR).ToUnixTime();
context.Tokens.Update(target);
await context.SaveChangesAsync().ConfigureAwait(false);
return(TokenConverter.GetTokenVm(target));
}
else
{
throw new InvalidTokenException();
}
}
}
public static bool FindTwinNumbers(Random rand)
{
List <int> randomList = RandomExtensions.GenerateRandomList(rand, -1000, 10000, 10000);
Dictionary <int, int> numbers = new Dictionary <int, int>();
//ShowList(randomList);
foreach (var item in randomList)
{
if (numbers.ContainsKey(item))
{
if (numbers.ContainsKey(item * -1))
{
Console.WriteLine("Found first Pair that sums to zero: " + item + " & " + (item * -1));
return(true);
}
}
else
{
numbers.Add(item, 1);
}
}
Console.WriteLine("No Pair found that sums to zero");
return(false);
}
public async Task <QRCodeContent> CreateQRCodeAsync(long userId, long nodeId)
{
var sequence = RandomExtensions.NextBytes(192);
string sequenceStr = Convert.ToBase64String(sequence);
QRCode qrCode = new QRCode
{
UserId = userId,
SequenceHash = GetSequenceHashSha512(sequenceStr)
};
using (MessengerDbContext context = contextFactory.Create())
{
bool isUserExists = await context.Users.AnyAsync(user => user.Id == userId).ConfigureAwait(false);
if (!isUserExists)
{
throw new ObjectDoesNotExistsException($"User with Id: {userId} does not found.");
}
await context.QRCodes.AddAsync(qrCode).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(new QRCodeContent(qrCode.Id, qrCode.UserId, nodeId, sequenceStr));
}
}
public static void DrawGrid(Model model, Grid2d grid, List <Vector3> uPoints, List <Vector3> vPoints)
{
foreach (var cell in grid.GetCells())
{
var polygon = (Polygon)cell.GetCellGeometry();
foreach (var vertex in polygon.Vertices)
{
Debug.DrawPoint(model, vertex, MagentaMaterial);
}
var color = RandomExtensions.NextColor(random);
foreach (var cellPiece in cell.GetTrimmedCellGeometry())
{
var material = new Material(color.ToString(), new Color(color.Red, color.Green, color.Blue, 0.5), unlit: true);
var poly = (Polygon)cellPiece;
if (poly.Vertices.Count >= 3)
{
model.AddElement(new Panel(poly, material: material));
}
}
}
foreach (var pt in vPoints)
{
Debug.DrawPoint(model, pt, MagentaMaterial);
}
foreach (var pt in uPoints)
{
Debug.DrawPoint(model, pt, MagentaMaterial);
}
}
public ObjectBuildRecord CreateRecord(Type type, IBuilder builder, BuildSession session)
{
var list = new List <TType>();
RandomExtensions.Shuffle <TType>(list, _entries(builder, session), session.Random);
return(new ObjectBuildRecord(type, list, false));
}
IEnumerator Move()
{
while (this._isAlive)
{
yield return(Wait(0.5f));
if (!this._isAlive)
{
yield break;
}
if (Body.velocity.sqrMagnitude >= MinSqrMagnitudeToMove)
{
continue;
}
var preferedRegion = UnityExtensions.CreateRectFromCamera(_camera, PreferedScreenPercentage);
Vector2 moveDirection;
if (preferedRegion.Contains(transform.position))
{
moveDirection = Random.insideUnitCircle;
}
else
{
var targetPosition = RandomExtensions.PointInsideRect(preferedRegion);
moveDirection = targetPosition - new Vector2(transform.position.x, transform.position.y);
}
var impulse = Random.Range(MinImpulseForce, MaxImpulseForce);
this.Body.AddForce(moveDirection.normalized * impulse, ForceMode2D.Impulse);
}
}
public void StartMoving(float speed)
{
float startPos = movementProperties.LeftXPosition;
float endPos = movementProperties.RightXPosition;
// Randomize starting side
if (RandomExtensions.RandomBoolean())
{
startPos = movementProperties.RightXPosition;
endPos = movementProperties.LeftXPosition;
}
//bar.position = bar.position.With(x: startPos);
float totalDist = movementProperties.DistanceBetweenPositions;
float currentDist = Vector2.Distance(bar.localPosition, bar.localPosition.With(x: startPos));
float percentage = currentDist / totalDist;
float duration = speed * percentage;
bar.DOMoveX(startPos, duration)
.SetEase(movementProperties.Easing)
.OnComplete(() =>
bar.DOMoveX(endPos, speed)
.SetEase(movementProperties.Easing)
.SetLoops(-1, LoopType.Yoyo));
//bar.DOMoveX(endPos, speed)
// .SetEase(movementProperties.Easing)
// .SetLoops(-1, LoopType.Yoyo);
}
private static Material _nextMaterial()
{
var color = RandomExtensions.NextColor(_random);
var colorWithAlpha = new Color(color.Red, color.Green, color.Blue, 0.7);
return(new Material(color.ToString(), colorWithAlpha, unlit: true));
}
private void ScrollBackground(float duration, Ease easing)
{
float randomDistance = RandomExtensions.RandomGaussian(distance, variation);
transform.DOKill();
transform.DOMoveY(transform.position.y - randomDistance, duration, false).SetEase(ease).OnComplete(ResetPosition);
}
public async Task CreateOrEditChannel()
{
var editableChannel = fillTestDbHelper.Channels.FirstOrDefault();
var validUser = editableChannel.ChannelUsers.FirstOrDefault(channelUser => channelUser.ChannelUserRole >= ChannelUserRole.Administrator);
var invalidUser = editableChannel.ChannelUsers.FirstOrDefault(channelUser => channelUser.ChannelUserRole == ChannelUserRole.Subscriber);
editableChannel.ChannelName = "Edited channel name";
var actualChannel = await createChannelsService.CreateOrEditChannelAsync(ChannelConverter.GetChannel(editableChannel), validUser.UserId, null);
Assert.True(editableChannel.ChannelName == actualChannel.ChannelName);
await Assert.ThrowsAsync <PermissionDeniedException>(async() =>
await createChannelsService.CreateOrEditChannelAsync(ChannelConverter.GetChannel(editableChannel), invalidUser.UserId, null));
var users = fillTestDbHelper.Users.Skip(1);
var creator = fillTestDbHelper.Users.FirstOrDefault();
var newExpectedChannel = new ChannelVm
{
About = RandomExtensions.NextString(10),
ChannelName = "Created channel",
ChannelUsers = users.Select(user => new ChannelUserVm
{
UserId = user.Id,
ChannelUserRole = ChannelUserRole.Subscriber
}).ToList()
};
var newActualChannel = await createChannelsService.CreateOrEditChannelAsync(newExpectedChannel, creator.Id, newExpectedChannel.ChannelUsers);
Assert.True(newExpectedChannel.ChannelUsers.Count() + 1 == newActualChannel.ChannelUsers.Count());
}
/// <summary>
/// 生成新密钥、初始向量（IV）、验证标记。
/// </summary>
/// <param name="keyMaxSize">给定的密钥最大尺寸（默认以位为单位）。</param>
/// <param name="nonceMaxSize">给定的初始向量（IV）最大尺寸（默认以位为单位）。</param>
/// <param name="tagMaxSize">给定的验证标记最大尺寸（默认以位为单位）。</param>
public virtual void Generate(int keyMaxSize, int nonceMaxSize, int tagMaxSize)
{
base.Generate(keyMaxSize, nonceMaxSize);
Tag = RandomExtensions.GenerateByteArray(GetKeyByteArrayLength(tagMaxSize));
TagMaxSize = tagMaxSize;
}
void LateUpdate()
{
foreach (SpawnInfo spawnInfo in spawnInfos)
{
if (Time.time >= spawnInfo.nextSpawn && spawnInfo.spawned.Count < spawnInfo.maxSpawned)
{
GameObject prefab = RandomExtensions.RandomElement(spawnInfo.prefabs);
// TODO: Set position properly so it doesn't spawn inside the camera's view
Vector2 position = RandomExtensions.RandomInsideBounds(spawnBounds);
GameObject instance = Instantiate(prefab, position, Quaternion.identity);
FloatingComponent component = instance.GetComponent <FloatingComponent>();
component.SpawnTag = new SpawnTag()
{
spawnInfo = spawnInfo, spawner = this
};
// Note, after instantiating this object, start won't be called until next frame. To prevent other objects from running
// into trouble trying to use a non-initialised floating component, the script execution of the spawner is set to be after
// everything else.
// Add as spawned by this spawner
Add(component);
spawnInfo.nextSpawn = Time.time + spawnInfo.spawnRate;
}
}
}
public async Task CreateUser()
{
string password = RandomExtensions.NextString(10);
UserVm user = new UserVm
{
NameFirst = RandomExtensions.NextString(20),
NameSecond = RandomExtensions.NextString(20),
About = RandomExtensions.NextString(50),
Photo = RandomExtensions.NextString(100),
Phones = new List <UserPhoneVm>
{
new UserPhoneVm
{
CountryCode = 7,
SubscriberNumber = 9131743886,
IsMain = true,
UserId = 1000
}
},
Emails = new List <string>
{
"*****@*****.**"
}
};
var actualUser = await createUsersService.CreateNewUserAsync(user, 1, true, password);
Assert.Equal(user.NameFirst, actualUser.FirstValue.NameFirst);
Assert.Equal(user.NameSecond, actualUser.FirstValue.NameSecond);
Assert.Equal(user.About, actualUser.FirstValue.About);
Assert.Equal(user.Photo, actualUser.FirstValue.Photo);
Assert.Equal(user.Phones.FirstOrDefault().FullNumber, actualUser.FirstValue.Phones.FirstOrDefault().FullNumber);
Assert.Equal(user.Emails, actualUser.FirstValue.Emails);
Assert.Equal(password, actualUser.SecondValue);
}
// Update is called once per frame
void Update()
{
if (structure.Weapon)
{
if (acquireTargetCooldown.Check(Time.time))
{
ShipStructure[] potentialTargets = shipManager.FindNearbyShips(structure, maxAcquireDistance).ToArray();
if (potentialTargets.Length > 0)
{
currentTarget = RandomExtensions.RandomElement(potentialTargets);
loseTargetCooldown.Reset(Time.time);
}
}
if (currentTarget && loseTargetCooldown.Check(Time.time) && structure.DistanceTo(currentTarget) > maxAcquireDistance)
{
currentTarget = null;
}
if (currentTarget)
{
structure.Weapon.Aim(currentTarget.transform.position);
structure.Weapon.Fire();
}
}
}
private IEnumerator SpawnCardEvent()
{
SelectCardInDeck(_poolGameCard);
SelectCardInDeck(_poolCardArea);
yield return(new WaitForSeconds(0.3f));
var count = 1;
var arrayRarity = new[] { CardRarity.Common, CardRarity.Rare, CardRarity.Legendary };
var rarity = arrayRarity[RandomExtensions.GetRandomElementDictionary(DropChance.ChanceEvent)];
foreach (var card in _poolCardEvent)
{
if (count > 3)
{
break;
}
if (card.activeSelf)
{
continue;
}
var cardDisplay = card.GetComponent <ActionsWithCards>();
var randomCard = _objectStorage.GetRandomCardByType(SubTypeCard.GameEvent, rarity);
//var randomCard = _objectStorage.GetCardByName("random_event");
cardDisplay.СhangeCardType(randomCard);
cardDisplay.SetIdCard(count);
cardDisplay.CardGame.DisplayCardInGame(card);
cardDisplay.SetDependecies(_publisher, _animaManager);
card.SetActive(true);
_animaManager.SetStateAnimation(card, "dist_num", count);
yield return(new WaitForSeconds(0.2f));
++count;
}
}
public async Task <string> AddNewOperationAsync(long nodeId, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
long currentTime = DateTime.UtcNow.ToUnixTime();
var uncomplededOperation = await context.ChangeUserNodeOperations
.FirstOrDefaultAsync(opt => !opt.Completed && opt.UserId == userId && opt.ExpirationTime > currentTime).ConfigureAwait(false);
if (uncomplededOperation != null)
{
context.Remove(uncomplededOperation);
}
ChangeUserNodeOperation operation = new ChangeUserNodeOperation
{
NodeId = nodeId,
UserId = userId,
OperationId = RandomExtensions.NextString(64),
Completed = false,
RequestTime = currentTime,
ExpirationTime = currentTime + (long)TimeSpan.FromDays(1).TotalSeconds
};
await context.AddAsync(operation).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(operation.OperationId);
}
}
public async Task <FileInfoVm> SaveFileAsync(long?userId, string filename, string url, long fileSize, byte[] fileHash, string storageType, ImageMetadata imageMetadata = null)
{
using (MessengerDbContext context = contextFactory.Create())
{
FileInfo newFile = new FileInfo
{
Id = RandomExtensions.NextString(64),
FileName = filename,
Url = url,
UploaderId = userId,
UploadDate = DateTime.UtcNow.ToUnixTime(),
NodeId = NodeSettings.Configs.Node.Id,
Size = fileSize,
Hash = fileHash,
Storage = storageType,
NumericId = await poolsService.GetFileIdAsync().ConfigureAwait(false),
ImageMetadata = imageMetadata
};
await context.FilesInfo.AddAsync(newFile).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(FileInfoConverter.GetFileInfoVm(newFile, false));
}
}
private async Task <List <Channel> > AddChannelsAsync(int count = 5)
{
List <Channel> channels = new List <Channel>();
for (int i = 0; i < count; i++)
{
var channelCreator = await _context.Users.LastOrDefaultAsync();
channels.Add(new Channel
{
About = RandomExtensions.NextString(20),
Deleted = false,
ChannelName = "Channel " + i,
Tag = RandomExtensions.NextString(10).ToUpper(),
ChannelUsers = _context.Users.ToList().Select(user => new ChannelUser
{
UserId = user.Id,
Banned = false,
Deleted = false,
SubscribedTime = DateTime.UtcNow.ToUnixTime(),
ChannelUserRole = user.Id == channelCreator.Id ? ChannelUserRole.Creator : ChannelUserRole.Subscriber
}).ToList(),
NodesId = RandomExtensions.GetRandomInt64Sequence(10, 0)
});
}
await _context.Channels.AddRangeAsync(channels);
await _context.SaveChangesAsync();
return(channels);
}
public static NodeVm GetNodeVm(Node node)
{
return(node == null
? null
: new NodeVm
{
Id = node.Id,
About = node.About,
Country = node.Country,
Domains = node.DomainNodes?.Select(opt => opt?.Domain).ToList(),
Name = node.Name,
Photo = node.Photo,
Routing = node.Routing ?? true,
StartDay = node.Startday ?? DateTime.MinValue,
Storage = node.Storage ?? true,
Tag = node.Tag ?? RandomExtensions.NextString(10, "N"),
Visible = node.Visible ?? true,
NodeKey = new NodeKeyVm
{
EncPublicKey = node.NodeKeys?.OrderByDescending(opt => opt.GenerationTime).FirstOrDefault()?.PublicKey,
SignPublicKey = node.NodeKeys?.OrderByDescending(opt => opt.GenerationTime).FirstOrDefault()?.SignPublicKey,
ExpiredAt = (node.NodeKeys?.OrderByDescending(opt => opt.GenerationTime).FirstOrDefault()?.ExpirationTime).GetValueOrDefault(),
KeyId = (node.NodeKeys?.OrderByDescending(opt => opt.GenerationTime).FirstOrDefault()?.KeyId).GetValueOrDefault()
},
ClientsPort = node.ClientsPort,
NodesPort = node.NodesPort,
AdminEmail = node.AdminEmail,
SupportEmail = node.SupportEmail,
EncryptionType = node.EncryptionType,
PermanentlyDeleting = node.PermanentlyDeleting,
RegistrationMethod = node.RegistrationMethod,
UserRegistrationAllowed = node.UserRegistrationAllowed
});
}
private IEnumerator GoNewEvent()
{
yield return(new WaitForSeconds(0.4f));
var list = new List <GameEventName>()
{
GameEventName.GoStageAddCardSpell, GameEventName.GoStageAddCardConsumables
};
var newevent = list[RandomExtensions.GetRandomElementDictionary(DropChance.ChanceReward)];
switch (newevent)
{
case GameEventName.GoStageAddCardSpell:
_stageList.Add(GameEventName.GoStageAddCardSpell);
_stageList.Add(GameEventName.GoSelectCardSpell);
_stageList.Add(GameEventName.GoStageAddCardEvent);
_stageList.Add(GameEventName.GoSelectCardEvent);
_publisher.Publish(null, new CustomEventArgs(GameEventName.GoSetNextStage));
Debug.Log("награда");
break;
case GameEventName.GoStageAddCardConsumables:
_stageList.Add(GameEventName.GoStageAddCardConsumables);
_stageList.Add(GameEventName.GoSelectCardConsumables);
_stageList.Add(GameEventName.GoStageAddCardEvent);
_stageList.Add(GameEventName.GoSelectCardEvent);
_publisher.Publish(null, new CustomEventArgs(GameEventName.GoSetNextStage));
Debug.Log("награда");
break;
}
}
private async Task <List <Chat> > AddChatsAsync(int count = 5)
{
List <Chat> chats = new List <Chat>();
for (int i = 0; i < count; i++)
{
var chatCreator = await _context.Users.FirstOrDefaultAsync();
chats.Add(new Chat
{
About = RandomExtensions.NextString(20),
Deleted = false,
Name = "Chat " + i,
Tag = RandomExtensions.NextString(10).ToUpper(),
Type = RandomExtensions.NextInt64() > 0 ? (short)ChatType.Private : (short)ChatType.Public,
ChatUsers = _context.Users.Take(3).ToList().Select(user => new ChatUser
{
UserId = user.Id,
Banned = false,
Deleted = false,
IsMuted = false,
UserRole = user.Id == chatCreator.Id ? UserRole.Creator : UserRole.User
}).ToList()
});
}
await _context.Chats.AddRangeAsync(chats);
await _context.SaveChangesAsync();
return(chats);
}
public void VerifyGetString()
{
var _string = RandomExtensions.GetString();
_string.Should().BeOfType(typeof(string));
_string.Should().NotBeNull();
}
public async Task UpdateSessionKeyAsync()
{
byte[] oldKey = new byte[symmetricKey.Length];
long oldExpired = expiredAt.GetValueOrDefault();
Array.Copy(symmetricKey, oldKey, symmetricKey.Length);
try
{
long keyId = RandomExtensions.NextInt64();
uint ttl = (uint)TimeSpan.FromDays(7).TotalSeconds;
long expired = DateTime.UtcNow.ToUnixTime() + ttl;
var symmetricKey = Encryptor.GetSymmetricKey(256, keyId, ttl, NodeData.Instance.NodeKeys.Password);
var encryptedKey = Encryptor.AsymmetricDataEncrypt(
symmetricKey,
licensorPublicKey,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.Password);
var request = new UpdateSessionKeyRequest(encryptedKey, expired);
await SendRequestAsync(request).ConfigureAwait(false);
this.symmetricKey = symmetricKey;
expiredAt = expired;
await GetResponseAsync(request);
}
catch (Exception ex)
{
symmetricKey = oldKey;
expiredAt = oldExpired;
Console.WriteLine($"Update session key error: {ex.Message}");
Logger.WriteLog(ex);
}
}
void Roam_Update()
{
// Pick random target to roam to, if no current target.
if (!movement.MovementTarget.HasValue)
{
movement.MovementTarget = RandomExtensions.RandomInsideBounds(shipManager.SpawnVolume);
if (shipManager.Ships.Count < minShipsRemainingBeforeAggressionBoost)
{
// Move toward the player when there's only a few boats left
GameObject player = GameObject.FindGameObjectWithTag("Player");
if (player)
{
movement.MovementTarget = (Vector2)player.transform.position + Random.insideUnitCircle * 1;
}
}
}
CheckForPickup(itemCheckDistance);
// Check for nearby weak enemies, if any are found, transition to attack
bool aggressionBoost = shipManager.Ships.Count < minShipsRemainingBeforeAggressionBoost;
if ((shipStructure.Planks.Count > minPlanksToStartFight || aggressionBoost) &&
boatCheckCooldown.Check(Time.time) &&
(attackBackoffTime + attackBackoffTimeout <= Time.time || aggressionBoost) && // Don't attack again too soon, wait for the timeout first
FindNearbyBoatTarget(out ShipStructure target))
{
currentBoatTarget = target;
fsm.ChangeState(States.Attack);
}
}
public void VerifyMaxGetDouble()
{
var maxValue = 55.5;
var number = RandomExtensions.GetDouble(maxValue);
number.Should().BeOfType(typeof(double));
number.Should().BeLessThan(maxValue);
}
public static Equipment RandomOne()
{
return(new Equipment
{
type = RandomExtensions.GetRandomEnum <UnitBuffType>(),
buff = { value = Random.Range(1, 5) }
});
}
public async Task UpdateFileInformation()
{
var file = fillTestDbHelper.Files.FirstOrDefault();
var newFileUrl = RandomExtensions.NextString(10);
await filesService.UpdateFileInformationAsync(newFileUrl, file.Id);
Assert.True(fillTestDbHelper.Files.FirstOrDefault(opt => opt.Id == file.Id).Url == newFileUrl);
}
public void VerifyMaxGetNumber()
{
var maxValue = 100;
var number = RandomExtensions.GetNumber(maxValue);
number.Should().BeOfType(typeof(int));
number.Should().BeLessOrEqualTo(maxValue);
}
