// PUT api/UserDevice/5
public async Task<IHttpActionResult> PutUserDevice(int id, UserDevice userdevice)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != userdevice.Id)
{
return BadRequest();
}
db.Entry(userdevice).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserDeviceExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public async Task<UserInformation> AddUserDevice(UserDevice newUserDevice, ICredentialRetrieverService credentialRetrieverService)
{
newUserDevice.CheckIfNull ("newUserDevice");
credentialRetrieverService.CheckIfNull ("credentialRetrieverService");
using (
var authenticatedClient = new AuthenticatedHttpClient(
this.baseUrl,
credentialRetrieverService.GetNetworkCredential()))
{
try
{
var content = new StringContent(this.serializer.Serialize(newUserDevice), Encoding.UTF8, ApplicationJson);
var response = await authenticatedClient.Client.PostAsync(PostUserDevice, content);
response.EnsureSuccessStatusCode();
var userInformation = await response.Content.ReadAsStringAsync();
return this.serializer.Deserialize<UserInformation>(userInformation);
}
catch (HttpRequestException e)
{
var message = e.Message;
MvxTrace.Trace(() => message);
}
}
return null;
}
public async Task<IHttpActionResult> PostUserDevice(UserDevice userdevice)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.UserDevices.Add(userdevice);
await db.SaveChangesAsync();
return CreatedAtRoute("DefaultApi", new { id = userdevice.Id }, userdevice);
}
public GarminViewModel(
IGetFitWebService getFitWebService,
ICredentialRetrieverService credentialRetrieverService,
ILoggedInUserService loggedInUserService)
: base(UserDeviceSelections.Garmin)
{
getFitWebService.CheckIfNull("getFitWebService");
loggedInUserService.CheckIfNull("loggedInUserService");
credentialRetrieverService.CheckIfNull("credentialRetrieverService");
this.getFitWebService = getFitWebService;
this.loggedInUserService = loggedInUserService;
this.credentialRetrieverService = credentialRetrieverService;
this.newModel = new UserDevice
{
UserId = loggedInUserService.LoggedInUser.UserId,
DeviceSelection = UserDeviceSelections.Garmin,
};
this.AddCommand = new MvxCommand(this.AddExecute, this.CanAdd);
}
public async Task<IHttpActionResult> Post(UserDevice userDevice)
{
if (this.User == null)
{
return this.NotFound();
}
var userName = this.User.Identity.Name;
var userInformation =
await
this.getFitContext.UserInformations
.FirstOrDefaultAsync(
information => information.UserName == userName);
if (userInformation == null)
{
return this.NotFound();
}
userInformation.UserDevices.Add(userDevice);
await this.getFitContext.SaveChangesAsync();
return this.Ok(userInformation);
}
public string CodeVerification(int userId, string codeEntered)
{
SignInResult result = new SignInResult();
LoginUser loginUser = LoginUser.Anonymous;
try
{
Users users = new Users(loginUser);
users.LoadByUserID(userId);
result.UserId = userId;
if (users.Count > 0)
{
result.OrganizationId = users[0].OrganizationID;
string codeSent = users[0].verificationCode;
codeEntered = codeEntered.Trim();
codeEntered = codeEntered.Replace(" ", string.Empty);
if (codeSent == codeEntered)
{
if (users[0].verificationCodeExpirationUtc > DateTime.UtcNow)
{
users[0].verificationCode = null;
users[0].verificationCodeExpiration = null;
users.Save();
UserDevices devices = new UserDevices(loginUser);
UserDevice device = devices.AddNewUserDevice();
device.DateActivated = DateTime.UtcNow;
device.IsActivated = true;
device.DeviceID = Guid.NewGuid().ToString();
device.UserID = users[0].UserID;
devices.Save();
EmailPosts.SendNewDevice(loginUser, users[0].UserID);
HttpCookie deviceCookie = new HttpCookie("di", device.DeviceID);
deviceCookie.Expires = DateTime.Now.AddYears(14);
HttpContext.Current.Response.Cookies.Add(deviceCookie);
result.Result = LoginResult.Success;
string authenticateResult = AuthenticateUser(users[0].UserID, users[0].OrganizationID, false, false);
}
else
{
result.Error = "Verification Code has expired.";
result.Result = LoginResult.Fail;
}
}
else
{
result.Error = "Invalid Verification Code.";
result.Result = LoginResult.Fail;
}
}
else
{
result.Error = "User not found.";
result.Result = LoginResult.Fail;
}
}
catch (Exception ex)
{
result.Error = ex.Message;
result.Result = LoginResult.Fail;
}
return(JsonConvert.SerializeObject(result));
}
public UserDevice CreateDevice(string deviceName, bool power, Dictionary <int, Slider> Sliders)
{
UserDevice tempUserDevice = new UserDevice(deviceName, power, Sliders);
return(tempUserDevice);
}
void ShowDeviceInfo(UserDevice ud)
{
if (ud == null)
{
// clean everything here.
ControlsHelper.SetText(DiCapFfStateTextBox, "");
ControlsHelper.SetText(DiCapButtonsTextBox, "");
ControlsHelper.SetText(DiCapPovsTextBox, "");
ControlsHelper.SetText(ActuatorsTextBox, "");
ControlsHelper.SetText(DiCapAxesTextBox, "");
ControlsHelper.SetText(DiSlidersTextBox, "");
ControlsHelper.SetText(DeviceVidTextBox, "");
ControlsHelper.SetText(DevicePidTextBox, "");
ControlsHelper.SetText(DeviceRevTextBox, "");
ControlsHelper.SetText(DeviceProductNameTextBox, "");
ControlsHelper.SetText(DeviceVendorNameTextBox, "");
ControlsHelper.SetText(DeviceProductGuidTextBox, "");
ControlsHelper.SetText(DeviceInstanceGuidTextBox, "");
ControlsHelper.SetText(DeviceTypeTextBox, "");
if (DiEffectsTable.Rows.Count > 0)
{
DiEffectsTable.Rows.Clear();
}
return;
}
// This must be done for the first time device is connected in order to retrieve
// Force feedback information.
// XInput must be unloaded in case it tries to lock the device exclusively.
if (DiEffectsTable.Rows.Count > 0)
{
DiEffectsTable.Rows.Clear();
}
var effects = ud.DeviceEffects;
if (effects != null)
{
foreach (var eff in ud.DeviceEffects)
{
DiEffectsTable.Rows.Add(
eff.Name,
eff.StaticParameters.ToString(),
eff.DynamicParameters.ToString()
);
}
}
var forceFeedbackState = ((DeviceFlags)ud.CapFlags).HasFlag(DeviceFlags.ForceFeedback) ? "YES" : "NO";
ControlsHelper.SetText(DiCapFfStateTextBox, forceFeedbackState);
ControlsHelper.SetText(DiCapButtonsTextBox, ud.CapButtonCount.ToString());
ControlsHelper.SetText(DiCapPovsTextBox, ud.CapPovCount.ToString());
var objects = ud.DeviceObjects;
DiObjectsDataGridView.DataBindingComplete += DataGridView_DataBindingComplete;
DiObjectsDataGridView.DataSource = objects;
if (objects != null)
{
var actuators = objects.Where(x => x.Flags.HasFlag(DeviceObjectTypeFlags.ForceFeedbackActuator));
ControlsHelper.SetText(ActuatorsTextBox, actuators.Count().ToString());
var slidersCount = objects.Where(x => x.Type.Equals(SharpDX.DirectInput.ObjectGuid.Slider)).Count();
// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.dijoystate2(v=vs.85).aspx
ControlsHelper.SetText(DiCapAxesTextBox, (ud.CapAxeCount - slidersCount).ToString());
ControlsHelper.SetText(DiSlidersTextBox, slidersCount.ToString());
}
// Update PID and VID always so they wont be overwritten by load settings.
short vid = BitConverter.ToInt16(ud.ProductGuid.ToByteArray(), 0);
short pid = BitConverter.ToInt16(ud.ProductGuid.ToByteArray(), 2);
ControlsHelper.SetText(DeviceVidTextBox, "0x{0:X4}", vid);
ControlsHelper.SetText(DevicePidTextBox, "0x{0:X4}", pid);
ControlsHelper.SetText(DeviceProductNameTextBox, ud.ProductName);
ControlsHelper.SetText(DeviceVendorNameTextBox, "{0}", ud.HidManufacturer);
ControlsHelper.SetText(DeviceRevTextBox, "0x{0:X4}", ud.DevRevision);
ControlsHelper.SetText(DeviceProductGuidTextBox, ud.ProductGuid.ToString());
ControlsHelper.SetText(DeviceInstanceGuidTextBox, ud.InstanceGuid.ToString());
ControlsHelper.SetText(DeviceTypeTextBox, ((SharpDX.DirectInput.DeviceType)ud.CapType).ToString());
}
private void UserControl_Unloaded(object sender, RoutedEventArgs e)
{
_UserDevice = null;
_PadSetting = null;
}
// Xbox One gamepads are equipped with a total of four independent vibration motors:
// Two large motors located in the gamepad body:
// - Left motor provides rough, high-amplitude vibration.
// - Right motor provides gentler, more subtle vibration.
// Two small motors located inside each trigger,
// that provide sharp bursts of vibration directly to the user's trigger fingers.
public bool SetDeviceForces(UserDevice ud, Device device, PadSetting ps, Vibration v)
{
var motorsChanged = Changed(ref old_ForceSwapMotor, ps.ForceSwapMotor);
bool swapMotor = false;
if (motorsChanged)
{
// Find and assign actuators.
var actuators = ud.DeviceObjects.Where(x => x.Flags.HasFlag(DeviceObjectTypeFlags.ForceFeedbackActuator)).ToList();
DeviceObjectItem xMotor = null;
// If actuator available then...
if (actuators.Count > 0)
{
// Try to find left actuator.
xMotor = actuators.FirstOrDefault(x => x.Type == ObjectGuid.XAxis);
//var actuator = actuators[0];
// If default actuator not found then take default.
if (xMotor == null)
{
xMotor = actuators[0];
}
actuators.Remove(xMotor);
}
DeviceObjectItem yMotor = null;
// If actuator available then...
if (actuators.Count > 0)
{
// Try to find right actuator.
yMotor = actuators.FirstOrDefault(x => x.Type == ObjectGuid.YAxis);
//var actuator = actuators[0];
// If default actuator not found then take default.
if (yMotor == null)
{
yMotor = actuators[0];
}
actuators.Remove(yMotor);
}
swapMotor = TryParse(ps.ForceSwapMotor) == 1;
// Allow to swap if both motors exist.
if (swapMotor && xMotor != null && yMotor != null)
{
actuatorL = yMotor;
actuatorR = xMotor;
}
else
{
actuatorL = xMotor;
actuatorR = yMotor;
}
}
// Return if force feedback actuators not found.
if (actuatorL == null)
{
return(false);
}
Effect effectL = null;
Effect effectR = null;
// If device already have effects then...
if (device.CreatedEffects.Count > 0)
{
effectL = device.CreatedEffects[0];
effectL.Download();
}
if (device.CreatedEffects.Count > 1)
{
effectR = device.CreatedEffects[1];
effectL.Download();
}
// Effect type changed.
bool forceChanged = Changed(ref old_ForceType, ps.ForceType);
ForceEffectType forceType = 0;
if (motorsChanged || forceChanged)
{
// Update values.
forceType = (ForceEffectType)TryParse(ps.ForceType);
if (forceType.HasFlag(ForceEffectType.PeriodicSine))
{
GUID_Force = EffectGuid.Sine;
}
else if (forceType.HasFlag(ForceEffectType.PeriodicSawtooth))
{
GUID_Force = EffectGuid.SawtoothDown;
}
else
{
GUID_Force = EffectGuid.ConstantForce;
}
// Force change requires to dispose old effects.
// Stop old effects.
if (effectL != null)
{
effectL.Stop();
effectL.Dispose();
effectL = null;
}
// Stop old effects.
if (effectR != null)
{
effectR.Stop();
effectR.Dispose();
effectR = null;
}
}
// If device already do not have effects then.
if (paramsL != null && device.CreatedEffects.Count < 1)
{
forceChanged = true;
}
if (paramsR != null && device.CreatedEffects.Count < 2)
{
forceChanged = true;
}
// Tells which effect parameters to modify.
var flagsL = EffectParameterFlags.None;
var flagsR = EffectParameterFlags.None;
if (motorsChanged || forceChanged)
{
// If 2 actuators available
if (actuatorR != null)
{
paramsL = GetParameters();
paramsR = GetParameters();
// Unfortunately SpeedLink GamePad needs both axis specified in order to operate motors separately.
// Which is counter-intuitive.
if (forceType.HasFlag(ForceEffectType._Type2))
{
// Note: Second axis direction will be set to zero i.e. motor will be not used by effect.
// Directions must be set to 'Positive' on both first axis via force feedback settings interface.
paramsL.Axes = new int[2] {
actuatorL.ObjectId, actuatorR.ObjectId
};
paramsR.Axes = new int[2] {
actuatorR.ObjectId, actuatorL.ObjectId
};
// There is no need to set this flag or DIERR_ALREADYINITIALIZED error will be thrown.
//flagsR |= EffectParameterFlags.Axes;
}
// Used for normal devices like Logitech. Use one axis per Effect/Parameter.
else
{
paramsL.Axes = new int[1] {
actuatorL.ObjectId
};
paramsR.Axes = new int[1] {
actuatorR.ObjectId
};
// There is no need to set this flag or DIERR_ALREADYINITIALIZED error will be thrown.
//flagsR |= EffectParameterFlags.Axes;
}
}
// If one actuator available.
else if (actuatorL != null)
{
paramsL = GetParameters();
paramsL.Axes = new int[1] {
actuatorL.ObjectId
};
}
}
// Direction changed.
// Right-handed Cartesian direction:
// x: -1 = left, 1 = right, 0 - no direction
// y: -1 = backward, 1 = forward, 0 - no direction
// z: -1 = down, 1 = up, 0 - no direction
var directionLChanged = Changed(ref old_LeftDirection, ps.LeftMotorDirection);
var directionRChanged = Changed(ref old_RightDirection, ps.RightMotorDirection);
// Direction needs to be updated when force or direction change.
if (motorsChanged || forceChanged || directionLChanged)
{
var directionL = TryParse(old_LeftDirection);
var dirL = new int[paramsL.Axes.Length];
dirL[0] = directionL;
paramsL.Directions = dirL;
flagsL |= EffectParameterFlags.Direction;
}
// Direction needs to be updated when force or direction change.
if (actuatorR != null && (motorsChanged || forceChanged || directionRChanged))
{
var directionR = TryParse(old_RightDirection);
var dirR = new int[paramsR.Axes.Length];
dirR[0] = directionR;
paramsR.Directions = dirR;
flagsR |= EffectParameterFlags.Direction;
}
var strengthChanged = Changed(ref old_OveralStrength, ps.ForceOverall);
var strengthLChanged = Changed(ref old_LeftStrength, ps.LeftMotorStrength);
var strengthRChanged = Changed(ref old_RightStrength, ps.RightMotorStrength);
if (motorsChanged || forceChanged || strengthChanged || strengthLChanged)
{
int overalStrength = ConvertHelper.ConvertRange(0, 100, 0, DI_FFNOMINALMAX, ps.GetForceOverall());
int leftGain = ConvertHelper.ConvertRange(0, 100, 0, overalStrength, ps.GetLeftMotorStrength());
paramsL.Gain = leftGain;
flagsL |= EffectParameterFlags.Gain;
}
if (actuatorR != null && (motorsChanged || forceChanged || strengthChanged || strengthRChanged))
{
int overalStrength = ConvertHelper.ConvertRange(0, 100, 0, DI_FFNOMINALMAX, ps.GetForceOverall());
int rightGain = ConvertHelper.ConvertRange(0, 100, 0, overalStrength, ps.GetRightMotorStrength());
paramsR.Gain = rightGain;
flagsR |= EffectParameterFlags.Gain;
}
var periodLChanged = Changed(ref old_LeftPeriod, ps.LeftMotorPeriod);
var periodRChanged = Changed(ref old_RightPeriod, ps.RightMotorPeriod);
var speedLChanged = Changed(ref old_LeftMotorSpeed, v.LeftMotorSpeed);
var speedRChanged = Changed(ref old_RightMotorSpeed, v.RightMotorSpeed);
// Convert speed into magnitude/amplitude.
int leftMagnitudeAdjusted;
int rightMagnitudeAdjusted = 0;
int leftPeriod;
int rightPeriod = 0;
// If device have only one force feedback actuator (probably wheel).
var combine = actuatorR == null;
// Get right values first for possible combine later.
if (motorsChanged || forceChanged || periodRChanged || speedRChanged || combine)
{
rightMagnitudeAdjusted = ConvertHelper.ConvertRange(short.MinValue, short.MaxValue, 0, DI_FFNOMINALMAX, old_RightMotorSpeed);
rightPeriod = TryParse(old_RightPeriod) * 1000;
if (actuatorR != null)
{
// Update force values.
if (GUID_Force == EffectGuid.ConstantForce)
{
ConstantForceR.Magnitude = rightMagnitudeAdjusted;
}
else
{
PeriodicForceR.Magnitude = rightMagnitudeAdjusted;
PeriodicForceR.Period = rightPeriod;
}
// Update flags to indicate that specific force parameters changed.
flagsR |= EffectParameterFlags.TypeSpecificParameters;
}
}
// Calculate left later for possible combine.
if (motorsChanged || forceChanged || periodLChanged || speedLChanged || combine)
{
// Convert speed into magnitude/amplitude.
leftMagnitudeAdjusted = ConvertHelper.ConvertRange(short.MinValue, short.MaxValue, 0, DI_FFNOMINALMAX, old_LeftMotorSpeed);
leftPeriod = TryParse(old_LeftPeriod) * 1000;
// If device have only one force feedback actuator (probably wheel).
if (combine)
{
// Forces must be combined.
var combinedMagnitudeAdjusted = Math.Max(leftMagnitudeAdjusted, rightMagnitudeAdjusted);
var combinedPeriod = 0;
// If at least one speed is specified then...
if (leftMagnitudeAdjusted > 0 || rightMagnitudeAdjusted > 0)
{
// Get combined period depending on magnitudes.
combinedPeriod =
((leftPeriod * leftMagnitudeAdjusted) + (rightPeriod * rightMagnitudeAdjusted))
/ (leftMagnitudeAdjusted + rightMagnitudeAdjusted);
}
// Update force properties.
leftMagnitudeAdjusted = combinedMagnitudeAdjusted;
leftPeriod = combinedPeriod;
}
// Update force values.
if (GUID_Force == EffectGuid.ConstantForce)
{
ConstantForceL.Magnitude = leftMagnitudeAdjusted;
}
else
{
PeriodicForceL.Magnitude = leftMagnitudeAdjusted;
PeriodicForceL.Period = leftPeriod;
}
// Update flags to indicate that specific force parameters changed.
flagsL |= EffectParameterFlags.TypeSpecificParameters;
}
// Recreate effects if force changed.
if (motorsChanged || forceChanged)
{
// Update Left force
paramsL.Parameters = GUID_Force == EffectGuid.ConstantForce
? ConstantForceL as TypeSpecificParameters : PeriodicForceL;
// Note: Device must be acquired in exclusive mode before effect can be created.
effectL = new Effect(device, GUID_Force, paramsL);
if (actuatorR != null)
{
// Update Right force
paramsR.Parameters = GUID_Force == EffectGuid.ConstantForce
? ConstantForceR as TypeSpecificParameters : PeriodicForceR;
effectR = new Effect(device, GUID_Force, paramsR);
}
}
if (flagsL != EffectParameterFlags.None)
{
SetParamaters(effectL, paramsL, flagsL);
}
if (flagsR != EffectParameterFlags.None)
{
SetParamaters(effectR, paramsR, flagsR);
}
return(true);
}
public void Display()
{
Controls.Clear();
if (Page != null)
{
deviceDictionary = (IDictionary <int, Device>)Page.Session["Devices"];
}
string tempPower;
userDevicePlaceHolder = new PlaceHolder();
userDevicePlaceHolder.ID = "userDevicePlaceHolder" + i;
userDeviceErrPlaceHolder = new PlaceHolder();
userDeviceErrPlaceHolder.ID = "userDeviceErrPlaceHolder" + i;
Controls.Add(userDevicePlaceHolder);
if (deviceDictionary[i].Power)
{
tempPower = "включен";
}
else
{
tempPower = "выключен";
}
userDeviceDelButton = MyButton("");
userDeviceDelButton.ID = "userDeviceDelButton" + i;
userDeviceDelButton.CssClass = "delButton";
userDeviceDelButton.Click += UserDeviceDelButton_Click;
userDevicePlaceHolder.Controls.Add(userDeviceDelButton);
userDevicePlaceHolder.Controls.Add(Span("Устройство: " + deviceDictionary[i].Name + "<br />"));
userDevicePlaceHolder.Controls.Add(Span("Состояние: " + tempPower + "<br />"));
UserDevice tempDevice = (UserDevice)deviceDictionary[i];
userDeviceBounds = new List <TextBox>();
int number = i + 10;
foreach (var x in tempDevice.Sliders)
{
SliderExtender userDeviceSliderExtender = SliderExtender(x.Value.MinValue, x.Value.MaxValue);
userDeviceTarget = TextBox();
userDeviceBound = TextBox();
userDeviceTarget.Text = x.Value.CurrentValue.ToString();
userDeviceBound.Text = x.Value.CurrentValue.ToString();
userDeviceBounds.Add(userDeviceBound);
Table userDeviceTable = MyTable(x.Value.SliderName + ": ", userDeviceBound, userDeviceTarget);
userDeviceTable.ID = "userDeviceTable" + number;
userDeviceTarget.ID = "Target" + number;
userDeviceBound.ID = "Bound" + number;
userDeviceSliderExtender.TargetControlID = userDeviceTarget.ID;
userDeviceSliderExtender.BoundControlID = userDeviceBound.ID;
userDevicePlaceHolder.Controls.Add(userDeviceTable);
userDevicePlaceHolder.Controls.Add(userDeviceSliderExtender);
userDevicePlaceHolder.Controls.Add(Span("<br />"));
number++;
}
if (tempDevice.Sliders.Count != 0)
{
userDeviceApplyButton = MyButton("Применить");
userDeviceApplyButton.ID = "applyButton" + i;
userDeviceApplyButton.Click += UserDeviceApplyButton_Click;
userDeviceApplyButton.CssClass = "applyButton";
userDevicePlaceHolder.Controls.Add(userDeviceApplyButton);
}
userDeviceOnOffButton = MyButton("Вкл/Выкл");
userDeviceOnOffButton.ID = "userDeviceOnOffButton" + i;
userDeviceOnOffButton.Click += UserDeviceOnOffButton_Click;
userDeviceOnOffButton.CssClass = "onOffButton";
userDevicePlaceHolder.Controls.Add(userDeviceOnOffButton);
userDevicePlaceHolder.Controls.Add(Span("<br />"));
userDevicePlaceHolder.Controls.Add(userDeviceErrPlaceHolder);
}
/// <summary>
/// 更新设备授权码
/// </summary>
/// <param name="device"></param>
public static void SetDeviceToken(UserDevice device)
{
SupportData.SetDeviceToken(device);
}
/// <inheritdoc />
public async Task UpdateDevicePublicKey(UserDevice device, string publicKey) {
GuardDevice(device);
device.PublicKey = publicKey;
await _dbContext.SaveChangesAsync();
}
/// <inheritdoc />
public async Task UpdateDevicePassword(UserDevice device, string passwordHash) {
GuardDevice(device);
device.Password = passwordHash;
await _dbContext.SaveChangesAsync();
}
/// <inheritdoc /> public PasswordVerificationResult VerifyHashedPassword(UserDevice device, string hashedPassword, string providedPassword) => _passwordHasher.VerifyHashedPassword(null, hashedPassword, providedPassword);
void UpdateDiDevices(DirectInput manager)
{
if (!UpdateDevicesPending)
{
return;
}
UpdateDevicesPending = false;
// Make sure that interface handle is created, before starting device updates.
UserDevice[] deleteDevices;
// Add connected devices.
var insertDevices = new List <UserDevice>();
// List of connected devices (can be a very long operation).
var devices = new List <DeviceInstance>();
// Controllers.
var controllerInstances = manager.GetDevices(DeviceClass.GameControl, DeviceEnumerationFlags.AllDevices).ToList();
foreach (var item in controllerInstances)
{
devices.Add(item);
}
// Pointers.
var pointerInstances = manager.GetDevices(DeviceClass.Pointer, DeviceEnumerationFlags.AllDevices).ToList();
foreach (var item in pointerInstances)
{
devices.Add(item);
}
// Keyboards.
var keyboardInstances = manager.GetDevices(DeviceClass.Keyboard, DeviceEnumerationFlags.AllDevices).ToList();
foreach (var item in keyboardInstances)
{
devices.Add(item);
}
if (Program.IsClosing)
{
return;
}
// List of connected devices.
var deviceInstanceGuid = devices.Select(x => x.InstanceGuid).ToList();
// List of current devices.
var uds = SettingsManager.UserDevices.ItemsToArraySynchronized();
var currentInstanceGuids = uds.Select(x => x.InstanceGuid).ToArray();
deleteDevices = uds.Where(x => !deviceInstanceGuid.Contains(x.InstanceGuid)).ToArray();
var addedDevices = devices.Where(x => !currentInstanceGuids.Contains(x.InstanceGuid)).ToArray();
var updatedDevices = devices.Where(x => currentInstanceGuids.Contains(x.InstanceGuid)).ToArray();
// Must find better way to find Device than by Vendor ID and Product ID.
DeviceInfo[] devInfos = null;
DeviceInfo[] intInfos = null;
if (addedDevices.Length > 0 || updatedDevices.Length > 0)
{
devInfos = DeviceDetector.GetDevices();
//var classes = devInfos.Select(x=>x.ClassDescription).Distinct().ToArray();
intInfos = DeviceDetector.GetInterfaces();
//var intclasses = intInfos.Select(x => x.ClassDescription).Distinct().ToArray();
}
//Joystick = new Guid("6f1d2b70-d5a0-11cf-bfc7-444553540000");
//SysMouse = new Guid("6f1d2b60-d5a0-11cf-bfc7-444553540000");
//SysKeyboard = new Guid("6f1d2b61-d5a0-11cf-bfc7-444553540000");
for (int i = 0; i < addedDevices.Length; i++)
{
var device = addedDevices[i];
var ud = new UserDevice();
DeviceInfo hid;
RefreshDevice(manager, ud, device, devInfos, intInfos, out hid);
var isVirtual = false;
if (hid != null)
{
DeviceInfo p = hid;
do
{
p = devInfos.FirstOrDefault(x => x.DeviceId == p.ParentDeviceId);
// If ViGEm hardware found then...
if (p != null && VirtualDriverInstaller.ViGEmBusHardwareIds.Any(x => string.Compare(p.HardwareIds, x, true) == 0))
{
isVirtual = true;
break;
}
} while (p != null);
}
if (!isVirtual)
{
insertDevices.Add(ud);
}
}
//if (insertDevices.Count > 0)
//{
// CloudPanel.Add(CloudAction.Insert, insertDevices.ToArray(), true);
//}
for (int i = 0; i < updatedDevices.Length; i++)
{
var device = updatedDevices[i];
var ud = uds.First(x => x.InstanceGuid.Equals(device.InstanceGuid));
DeviceInfo hid;
// Will refresh device and fill more values with new x360ce app if available.
RefreshDevice(manager, ud, device, devInfos, intInfos, out hid);
}
if (Program.IsClosing)
{
return;
}
// Remove disconnected devices.
for (int i = 0; i < deleteDevices.Length; i++)
{
lock (SettingsManager.UserDevices.SyncRoot)
deleteDevices[i].IsOnline = false;
}
for (int i = 0; i < insertDevices.Count; i++)
{
var ud = insertDevices[i];
lock (SettingsManager.UserDevices.SyncRoot)
SettingsManager.UserDevices.Items.Add(ud);
}
// Enable Test instances.
TestDeviceHelper.EnableTestInstances();
RefreshDevicesCount++;
var ev = DevicesUpdated;
if (ev != null)
{
ev(this, new DInputEventArgs());
}
// var game = CurrentGame;
// if (game != null)
// {
// // Auto-configure new devices.
// AutoConfigure(game);
// }
}
/// <inheritdoc />
public async Task UpdateLastSignInDate(UserDevice device) {
GuardDevice(device);
device.LastSignInDate = DateTimeOffset.UtcNow;
await _dbContext.SaveChangesAsync();
}
public async Task<UserInformation> DeleteUserDevice(UserDevice existingUserDevice, ICredentialRetrieverService credentialRetrieverService)
{
existingUserDevice.CheckIfNull("existingUserDevice");
credentialRetrieverService.CheckIfNull("credentialRetrieverService");
using (
var authenticatedClient = new AuthenticatedHttpClient(
this.baseUrl,
credentialRetrieverService.GetNetworkCredential()))
{
try
{
var deleteUrl = string.Format(DeleteUserDeviceTemplate, existingUserDevice.Id);
var response = await authenticatedClient.Client.DeleteAsync(deleteUrl);
response.EnsureSuccessStatusCode();
var userInformation = await response.Content.ReadAsStringAsync();
return this.serializer.Deserialize<UserInformation>(userInformation);
}
catch (HttpRequestException e)
{
var message = e.Message;
MvxTrace.Trace(() => message);
}
}
return null;
}
private static void GuardDevice(UserDevice device) {
if (device == null) {
throw new ArgumentNullException(nameof(device), $"Parameter {nameof(device)} cannot be null.");
}
}
/// <summary>
///
/// </summary>
/// <param name="operatorInfo"></param>
/// <returns></returns>
/// <exception cref="FriendlyException"></exception>
public async Task <OperatorInfoViewModel> GetOperatorInfoAsync(OperatorInfoViewModel operatorInfo)
{
string debugStr = "";
Logger.WriteDebug("GetOperatorInfoAsync called.");
try
{
if (!operatorInfo.Agreed)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (string.IsNullOrWhiteSpace(operatorInfo.DeviceGuid))
{
throw new FriendlyException(FriendlyExceptionType.DeviceIsNotSupported);
}
if (!operatorInfo.Validating && string.IsNullOrWhiteSpace(operatorInfo.Badge))
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
//if (!operatorInfo.Validating && string.IsNullOrWhiteSpace(operatorInfo.CardNumber))
// throw new FriendlyException(FriendlyExceptionType.AccessDenied);
if (operatorInfo.Validating && string.IsNullOrWhiteSpace(operatorInfo.DeviceSessionId))
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedSessionMismatch);
}
// --------------------------------------some sanity check!
if ((operatorInfo.FirstName?.Length ?? 0) > 255)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied, "FirstName is too long.");
}
if ((operatorInfo.LastName?.Length ?? 0) > 255)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied, "LastName is too long.");
}
if ((operatorInfo.Badge?.Length ?? 0) > 10)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied, "Badge is too long.");
}
//if ((operatorInfo.CardNumber?.Length ?? 0) > 25)
// throw new FriendlyException(FriendlyExceptionType.AccessDenied, "Card number is too long.");
//----------------------------------------
var badge = operatorInfo.Badge?.Trim().PadLeft(6, '0');
debugStr = "Before getting Demo User for badge: " + badge;
var user = await RestroomUnitOfWork.Get <User>().FirstOrDefaultAsync(m => m.Badge == badge);
if (user == null)
{
throw new FriendlyException(FriendlyExceptionType.AccessHasBeenRevoked, "", debugStr);
}
if (!user.Active)
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive, "", debugStr);
}
//var demoUser = await IsDemoUserAsync(operatorInfo.FirstName, operatorInfo.LastName, badge);
var demoUser = user.IsDemo.GetValueOrDefault(false);
debugStr = "After getting Demo User: "******"After getting Employee, DemoUser: {demoUser}, Found:{(employee != null)}";
if (employee == null && !demoUser)
{
var s = $"GetOperatorInfo. Employee not found." + $"debugStr: {debugStr}";
Logger.Write(s);
WriteLog(operatorInfo, s);
//await InvalidateOperatorAsync(badge);
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
else if (employee != null && (
!string.Equals(employee.LastName, operatorInfo.LastName, StringComparison.OrdinalIgnoreCase) ||
//!string.Equals(employeeCardNumber, cardNumber, StringComparison.OrdinalIgnoreCase) ||
//!employee.SecurityCardEnabled.GetValueOrDefault(false) || // After the issue raise with one of the employees "Joseph Seibel", Michael decided to disabled this check
(!string.Equals(employee.FirstName, operatorInfo.FirstName, StringComparison.OrdinalIgnoreCase) &&
!string.Equals(employee.MiddleName, operatorInfo.FirstName, StringComparison.OrdinalIgnoreCase)))
)
{
//var s = $"GetOperatorInfo. Employee badge: {badge} found but names or card # {cardNumber} were not match.";
var s = $"GetOperatorInfo. Employee badge: {badge} found but names were not match.";
s += $"Entered: FirstName: {employee?.FirstName??""}, LastName: {employee?.LastName??""}";
Logger.Write(s);
WriteLog(operatorInfo, s);
//await InvalidateOperatorAsync(badge);
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (demoUser)
{
CurrentUserName = "******";
}
else
{
CurrentUserName = employee.Name;
}
var device = await RestroomUnitOfWork.Get <Device>()
.FirstOrDefaultAsync(m => m.DeviceGuid == operatorInfo.DeviceGuid);
//User user = await RestroomUnitOfWork.Get<User>().FirstOrDefaultAsync(m => m.Badge == badge);
//if (!string.Equals(user?.LastName, operatorInfo.LastName) ||
// (!string.Equals(user?.FirstName, operatorInfo.FirstName) &&
// !string.Equals(user?.MiddleName, operatorInfo.FirstName)))
// user = null;
//debugStr = $"after getting device and user. DeviceGuid:{operatorInfo.DeviceGuid}, Badge: {badge}";
if (!demoUser)
{
if (operatorInfo.Validating && device == null)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied, "", debugStr);
}
if (device != null && !device.Active)
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive,
$"debugStr: {debugStr}");
}
}
//if (user != null && !user.Active)
// throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive,"", debugStr);
if (operatorInfo.Validating && (device == null || !device.Active ||
device.DeviceSessionId != operatorInfo.DeviceSessionId))
{
if (device == null)
{
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (!device.Active)
{
throw new FriendlyException(FriendlyExceptionType.AccessDeniedNotActive);
}
throw new FriendlyException(FriendlyExceptionType.AccessDeniedSessionMismatch);
}
if (operatorInfo.Validating && (user == null || !user.Active))
{
throw new FriendlyException(user == null
? FriendlyExceptionType.AccessHasBeenRevoked
: FriendlyExceptionType.AccessDeniedNotActive);
}
UserDevice userDevice = null;
if (device != null)
{
userDevice = await RestroomUnitOfWork.Get <UserDevice>()
.FirstOrDefaultAsync(m => m.DeviceId == device.DeviceId && m.UserId == user.UserId);
}
if (device == null)
{
device = new Device
{
Active = true, //demoUser,
DeviceGuid = operatorInfo.DeviceGuid,
DeviceModel = operatorInfo.DeviceModel,
DeviceOS = operatorInfo.DeviceOS,
LastUsed = DateTime.Now
};
device.DeviceSessionId = Guid.NewGuid().ToString(); //CreateDeviceSessionId(operatorInfo);
}
else
{
//try
//{
if (operatorInfo.Validating && device.DeviceSessionId != operatorInfo.DeviceSessionId)
{
Logger.WriteError($"Badge:{badge}, Validating but sessions are not match!");
throw new FriendlyException(FriendlyExceptionType.AccessDenied);
}
if (device.DeviceSessionId != operatorInfo.DeviceSessionId)
{
device.DeviceSessionId = Guid.NewGuid().ToString();
}
//var ticket = FormsAuthentication.Decrypt(device.DeviceSessionId);
//if (ticket == null || ticket.Name != operatorInfo.DeviceGuid)
// throw new FriendlyException(FriendlyExceptionType.AccessDenied);
//if (ticket.Expired)
// device.DeviceSessionId = CreateDeviceSessionId(operatorInfo);
//}
//catch (Exception ex)
//{
// Logger.WriteError(ex.Message);
// throw new FriendlyException(FriendlyExceptionType.AccessDenied);
//}
}
if (user == null)
{
user = new User
{
Active = true,
Badge = badge,
};
}
user.SecurityCardFormatted = employee?.SecurityCardFormatted;
user.FirstName = demoUser?"Demo":(employee?.FirstName ?? "");
user.LastName = demoUser?"User":(employee?.LastName ?? "");
user.MiddleName = employee?.MiddleName ?? "";
var confirmation = new Confirmation
{
Badge = badge,
Agreed = operatorInfo.Agreed,
IncidentDateTime = operatorInfo.IncidentDateTime,
DeviceId = operatorInfo.DeviceGuid,
Active = true
};
device.LastUsed = DateTime.Now;
user = RestroomUnitOfWork.PrepUser(user);
device = RestroomUnitOfWork.PrepDevice(device);
confirmation = RestroomUnitOfWork.PrepConfirmation(confirmation);
await RestroomUnitOfWork.SaveChangesAsync();
if (userDevice == null)
{
userDevice = new UserDevice();
userDevice.Active =
true; //demoUser || device.DeviceId==default(long) || (!string.IsNullOrWhiteSpace(operatorInfo.DeviceSessionId) && operatorInfo.DeviceSessionId == device.DeviceSessionId);
}
userDevice.LastLogon = DateTime.Now;
userDevice.UserId = user.UserId;
userDevice.DeviceId = device.DeviceId;
userDevice = await RestroomUnitOfWork.SaveUserDeviceAsync(userDevice);
operatorInfo.DeviceSessionId = device.DeviceSessionId;
operatorInfo.SessionApproved = user.Active && userDevice.Active && device.Active;
}
catch (FriendlyException ex)
{
Logger.WriteError("debugStr:" + debugStr + ", Error:" + ex.Message);
if (ex.ExceptionType != FriendlyExceptionType.AccessDeniedNotActive)
{
throw;
}
operatorInfo.SessionApproved = false;
}
catch (DbEntityValidationException ex)
{
Logger.WriteError("DbEntityValidationException, debugStr:" + debugStr + ", Error:" + ex.Message);
foreach (var eve in ex.EntityValidationErrors)
{
Logger.WriteError($"Entity of type \"{eve.Entry.Entity.GetType().Name}\" in state \"{eve.Entry.State}\" has the following validation errors:");
foreach (var ve in eve.ValidationErrors)
{
Logger.WriteError($"- Property: \"{ve.PropertyName}\", Error: \"{ve.ErrorMessage}\"");
}
}
operatorInfo.SessionApproved = false;
}
catch (Exception ex)
{
Logger.WriteError("debugStr:" + debugStr + ", Error:" + ex.Message);
operatorInfo.SessionApproved = false;
}
return(operatorInfo);
}
public async Task <IActionResult> CreateUserByDeviceId([FromBody] UserDevice userDevice)
{
if (string.IsNullOrEmpty(userDevice?.DeviceId))
{
return(BadRequest("DeviceId was invalid."));
}
// NOTE: We may want to enable this again later
// Check if DeviceId exists
//var dbUser = await m_CoreDbContext.Users
// .Where(dbu => dbu.DeviceId == userDevice.DeviceId)
// .SingleOrDefaultAsync();
// If it does not exist, create a new user
//if (dbUser == null)
//{
var userId = Guid.NewGuid().ToString();
var authToken = Guid.NewGuid().ToString();
// User data
var dbUser = new DbUser
{
UserId = userId,
DeviceId = userDevice.DeviceId,
AuthToken = authToken
};
// Users default profile
var dbUserProfile = new DbUserProfile
{
UsersProfileId = Guid.NewGuid().ToString(),
UserId = userId,
Name = m_ConfigDbContext.UserDefaults.Profile.Name,
Xp = m_ConfigDbContext.UserDefaults.Profile.Xp,
CreateDate = DateTime.UtcNow,
LastSeenDate = DateTime.UtcNow,
LastDailyRewardDate = DateTime.UtcNow,
GoldMineDaysRemaining = 0,
GemMineDaysRemaining = 0,
Level = 0,
FriendCount = 0,
};
// Users default wallet
var dbUserWallet = new DbUserWallet
{
UsersWalletId = Guid.NewGuid().ToString(),
UserId = userId,
HappyTokens = m_ConfigDbContext.UserDefaults.Wallet.HappyTokens,
Gems = m_ConfigDbContext.UserDefaults.Wallet.Gems,
Gold = m_ConfigDbContext.UserDefaults.Wallet.Gold,
};
// User default happiness
var dbUserHappiness = new DbUserHappiness
{
UsersHappinessId = Guid.NewGuid().ToString(),
UserId = userId,
Wealth = m_ConfigDbContext.UserDefaults.Happiness.Wealth,
Experience = m_ConfigDbContext.UserDefaults.Happiness.Experience,
Health = m_ConfigDbContext.UserDefaults.Happiness.Health,
Skill = m_ConfigDbContext.UserDefaults.Happiness.Skill,
Social = m_ConfigDbContext.UserDefaults.Happiness.Social
};
// Create default avatars (Avatars give happiness, allocate based on Level1)
var dbUsersAvatars = new List <DbUserAvatar>();
foreach (var avatarType in m_ConfigDbContext.UserDefaults.AvatarTypes)
{
var userAvatar = new DbUserAvatar()
{
UsersAvatarId = Guid.NewGuid().ToString(),
UserId = userId,
AvatarType = avatarType,
Level = 1,
Pieces = 0
};
// Grab the default avatar config
var avatar = m_ConfigDbContext.Avatars.Avatars.Find(i => i.AvatarType == avatarType);
// Add the happiness gained from Level1 to the users Happiness
var happinessType = avatar.HappinessType;
var happinessAmount = avatar.Levels[0].Happiness;
dbUserHappiness.Add(happinessType, happinessAmount);
dbUsersAvatars.Add(userAvatar);
}
// Create default buildings (Buildings give happiness, allocate based on Level1)
var dbUsersBuildings = new List <DbUserBuilding>();
foreach (var buildingType in m_ConfigDbContext.UserDefaults.BuildingTypes)
{
var userBuilding = new DbUserBuilding()
{
UsersBuildingId = Guid.NewGuid().ToString(),
UserId = userId,
BuildingType = buildingType,
Level = 1
};
// Grab the default avatar config
var building = m_ConfigDbContext.Buildings.Buildings.Find(i => i.BuildingType == buildingType);
// Add the happiness gained from Level1 to the users Happiness
var happinessType = building.HappinessType;
var happinessAmount = building.Levels[0].Happiness;
dbUserHappiness.Add(happinessType, happinessAmount);
dbUsersBuildings.Add(userBuilding);
}
// Add the new user
await m_CoreDbContext.Users.AddAsync(dbUser);
await m_CoreDbContext.UsersProfiles.AddAsync(dbUserProfile);
await m_CoreDbContext.UsersWallets.AddAsync(dbUserWallet);
await m_CoreDbContext.UsersHappiness.AddAsync(dbUserHappiness);
await m_CoreDbContext.UsersAvatars.AddRangeAsync(dbUsersAvatars);
await m_CoreDbContext.UsersBuildings.AddRangeAsync(dbUsersBuildings);
// Save changes
await m_CoreDbContext.SaveChangesAsync();
// Create the user to send back to the client
var response = new UserAuthPair
{
UserId = userId,
AuthToken = authToken
};
return(Ok(response));
// }
// User with this DeviceId already exists
// return Forbid();
}
public static UserDeviceView ConvertToUserDeviceView(this UserDevice model)
{
return(Mapper.Map <UserDevice, UserDeviceView>(model));
}
public async Task <IActionResult> Get(string id)
{
UserDevice res = await udevRepo.FindUserDevicesAsync(id);
return(Ok(res));
}
public async Task <UserLogined> SignInAndSignUpCustomerAsync(CustomerLoginDTO model)
{
// GET roleCustomerUser
var roleCustomerUser = await _context.Roles.FirstOrDefaultAsync(role => role.RoleName.Equals(RoleTypeHelper.RoleCustomerUser));
User userCreate = new User();
// CheckUserExist
var userExist = await _context.Users
.Include(u => u.UserToRoles)
.ThenInclude(x => x.Role)
.Where(u => u.UserToRoles.Any(x => x.RoleId == roleCustomerUser.Id))
.FirstOrDefaultAsync(u => u.Email.ToLower().Equals(model.Email.ToLower()) &&
u.UseExternalSignIns.Count > 0 && u.UserDevices.Count > 0);
// case login lần sau:
if (userExist != null)
{
// if exist then update user
// update To UserDevices
// update To UserExternalSignIns
userCreate = userExist;
_context.Entry(userCreate).State = EntityState.Modified;
userCreate.LastLogin = DateTime.UtcNow;
// check appId & currentUserId Exist
if (!_context.UserDevices.Any(uc => uc.CurrentUserId == userCreate.Id && uc.CodeDevice == model.AppId))
{
// Add to UserDevices
var userDevice = new UserDevice
{
Id = Guid.NewGuid().ToString(),
IsVerified = (int)TypeVerified.Verified,
VerifiedCode = (int)(DateTime.Now.Ticks >> 23),
CodeDevice = model.AppId,
CurrentUserId = userCreate.Id,
LastLogin = DateTime.UtcNow,
TimeCode = 20
};
userCreate.UserDevices.Add(userDevice);
}
else
{
// Update to UserDevices
var userDevice = _context.UserDevices.FirstOrDefault(uc => uc.CurrentUserId == userExist.Id && uc.CodeDevice == model.AppId);
if (userDevice != null)
{
_context.Entry(userDevice).State = EntityState.Modified;
userDevice.LastLogin = DateTime.UtcNow;
// save tp db
await _context.SaveChangesAsync();
}
}
// check exist UseExternalSignIns
if (!_context.ExternalSignIns.Any(ue => ue.UserId == userCreate.Id && ue.TypeLogin == model.TypeLogin))
{
var newUSERExternalSignIn = new ExternalSignIn
{
Id = Guid.NewGuid().ToString(),
IsVerified = (int)TypeVerified.Verified,
LastLogin = DateTime.UtcNow,
TimeLifeToken = 3600,
TokenLogin = model.TokenLogin,
TypeLogin = model.TypeLogin,
UserId = userExist.Id
};
userCreate.UseExternalSignIns.Add(newUSERExternalSignIn);
}
else
{
// update To UserExternalSignIns
var userExternalSignIn = _context.ExternalSignIns.FirstOrDefault(ue => ue.UserId == userExist.Id && ue.TypeLogin == model.TypeLogin);
if (userExternalSignIn != null)
{
_context.Entry(userExternalSignIn).State = EntityState.Modified;
userExternalSignIn.LastLogin = DateTime.UtcNow;
// save tp db
await _context.SaveChangesAsync();
}
}
// save to db
await _context.SaveChangesAsync();
}
else
{
// if not exist then create user
userCreate.Id = Guid.NewGuid().ToString();
userCreate.FirstName = model.FirstName;
userCreate.LastLogin = DateTime.UtcNow;
userCreate.LastName = model.LastName;
userCreate.Email = model.Email;
userCreate.UserName = model.Email;
userCreate.PhoneNumber = model.PhoneNumber;
var userDevice = new UserDevice
{
Id = Guid.NewGuid().ToString(),
CodeDevice = model.AppId,
CurrentUserId = userCreate.Id,
IsVerified = (int)TypeVerified.Verified,
LastLogin = DateTime.UtcNow,
TimeCode = 20,
VerifiedCode = (int)(DateTime.Now.Ticks >> 23)
};
// Save to UserDevices
userCreate.UserDevices.Add(userDevice);
var externalSign = new ExternalSignIn
{
Id = Guid.NewGuid().ToString(),
IsVerified = (int)TypeVerified.Verified,
LastLogin = DateTime.UtcNow,
TimeLifeToken = 3600,
TokenLogin = model.TokenLogin,
TypeLogin = model.TypeLogin,
UserId = userCreate.Id
};
// Save to ExternalSignIns
userCreate.UseExternalSignIns.Add(externalSign);
// Save to UserToRole
var userToRole = new UserToRole();
userToRole.Role = roleCustomerUser;
userToRole.User = userCreate;
roleCustomerUser.UserToRoles.Add(userToRole);
_context.Users.Add(userCreate);
// Save All To Database
await _context.SaveChangesAsync();
}
// create token
string currentUserId = Guid.NewGuid().ToString();
var userLogined = CreateToken(userCreate, currentUserId);
// save to login
await SaveToUserLoginAsync(userCreate, userLogined, currentUserId);
// save to login
// return
return(userLogined);
}
public async Task <IActionResult> Post([FromBody] UserDevice value)
{
await udevRepo.InsertUserDeviceAsync(value);
return(Ok());
}
public static JoystickState GetCurrentState(UserDevice ud)
{
if (watch == null)
{
watch = new Stopwatch();
watch.Start();
}
var elapsed = watch.Elapsed;
// Restart timer if out of limits.
if (elapsed.TotalMilliseconds > int.MaxValue)
{
watch.Restart();
elapsed = watch.Elapsed;
}
// Acquire values.
var ts = (int)elapsed.TotalSeconds;
var tm = (int)elapsed.TotalMilliseconds;
var state = new JoystickState();
// Set Buttons.
for (int i = 0; i < ud.CapButtonCount; i++)
{
var currentLocation = ts % ud.CapButtonCount;
// Enable button during its index.
state.Buttons[i] = currentLocation == i;
}
var busy = 4000;
var half = busy / 2;
var idle = 2000;
// Do action for 4 seconds, then stay for 2 seconds idle.
// 6 = 4 + 2.
var time = tm % (busy + idle);
var invert = tm % ((busy + idle) * 2) > (busy + idle);
// Set POVs.
for (int i = 0; i < ud.CapPovCount; i++)
{
// Rotate POVs 360 degrees in 4 seconds forward and back.
var degree = -1;
if (time < busy)
{
// Shift busy value by half so movement starts from the centre.
var value = (time + busy / 2) % busy;
if (time <= half)
{
// Convert [ 0-1999] to [0-35999].
degree = ConvertHelper.ConvertRange(0, half - 1, 0, 35999, value);
}
else
{
// Convert [2000-3999] to [35999-0].
degree = ConvertHelper.ConvertRange(half, busy - 1, 35999, 0, value);
}
}
state.PointOfViewControllers[i] = degree;
}
// Set Axis.
var axis = CustomDiState.GetAxisFromState(state);
// Get information about axis.
var axisObjects = ud.DeviceObjects
.Where(x => x.Flags.HasFlag(DeviceObjectTypeFlags.AbsoluteAxis) || x.Flags.HasFlag(DeviceObjectTypeFlags.RelativeAxis)).ToArray();
for (int i = 0; i < axisObjects.Count(); i++)
{
var ao = axisObjects[i];
//var axisMask = CustomDiState.GetAxisMask();
//
var isEven = i % 2 == 0;
var position = isEven
// Default position is in the center.
? ushort.MaxValue - short.MaxValue
// Default position is at the bottom.
: 0;
// Move axis in 4 seconds, then stay for 2 seconds idle.
if (time < busy)
{
if (isEven)
{
// Convert [0-3999] to [0-2Pi].
var angle = time * 2 * Math.PI / busy;
var sine = Math.Sin(angle);
if (invert && isEven)
{
sine *= -1f;
}
var range = ConvertHelper.ConvertToShort((float)sine);
position = ConvertHelper.ConvertRange(short.MinValue, short.MaxValue, ushort.MinValue, ushort.MaxValue, range);
}
else
{
position = time < half
// Move up.
? ConvertHelper.ConvertRange(0, half - 1, ushort.MinValue, ushort.MaxValue, time)
// Move down.
: ConvertHelper.ConvertRange(half, busy - 1, ushort.MaxValue, ushort.MinValue, time);
}
}
axis[i] = position;
}
CustomDiState.SetStateFromAxis(state, axis);
// Get sliders array.
var sliders = CustomDiState.GetSlidersFromState(state);
// Set sliders.
for (int i = 0; i < sliders.Length; i++)
{
var isEven = i % 2 == 0;
var position = isEven
// Default position is in the center.
? ushort.MaxValue - short.MaxValue
// Default position is at the bottom.
: 0;
// Move slider in 4 seconds, then stay for 2 seconds idle.
if (time < busy)
{
if (isEven)
{
// Convert [0-3999] to [0-2Pi].
var angle = time * 2 * Math.PI / busy;
var sine = Math.Sin(angle);
if (invert && isEven)
{
sine *= -1f;
}
var range = ConvertHelper.ConvertToShort((float)sine);
position = ConvertHelper.ConvertRange(short.MinValue, short.MaxValue, ushort.MinValue, ushort.MaxValue, range);
}
else
{
position = time < half
// Move up.
? ConvertHelper.ConvertRange(0, half - 1, ushort.MinValue, ushort.MaxValue, time)
// Move down.
: ConvertHelper.ConvertRange(half, busy - 1, ushort.MaxValue, ushort.MinValue, time);
}
}
sliders[i] = position;
}
CustomDiState.SetStateFromSliders(state, sliders);
// Return state.
return(state);
}
void UpdateDiDevices()
{
if (!UpdateDevicesEnabled)
{
return;
}
UpdateDevicesEnabled = false;
// Make sure that interface handle is created, before starting device updates.
UserDevice[] deleteDevices;
// Add connected devices.
var insertDevices = new List <UserDevice>();
var updateDevices = new List <KeyValuePair <UserDevice, DeviceInstance> >();
// List of connected devices (can be a very long operation).
var devices = new List <DeviceInstance>();
// Controllers.
var controllerInstances = Manager.GetDevices(DeviceClass.GameControl, DeviceEnumerationFlags.AllDevices).ToList();
foreach (var item in controllerInstances)
{
devices.Add(item);
}
// Pointers.
var pointerInstances = Manager.GetDevices(DeviceClass.Pointer, DeviceEnumerationFlags.AllDevices).ToList();
foreach (var item in pointerInstances)
{
devices.Add(item);
}
// Keyboards.
var keyboardInstances = Manager.GetDevices(DeviceClass.Keyboard, DeviceEnumerationFlags.AllDevices).ToList();
foreach (var item in keyboardInstances)
{
devices.Add(item);
}
if (Program.IsClosing)
{
return;
}
// List of connected devices.
var deviceInstanceGuid = devices.Select(x => x.InstanceGuid).ToList();
// List of current devices.
var currentInstanceGuids = SettingsManager.UserDevices.Items.Select(x => x.InstanceGuid).ToArray();
deleteDevices = SettingsManager.UserDevices.Items.Where(x => !deviceInstanceGuid.Contains(x.InstanceGuid)).ToArray();
var addedDevices = devices.Where(x => !currentInstanceGuids.Contains(x.InstanceGuid)).ToArray();
var updatedDevices = devices.Where(x => currentInstanceGuids.Contains(x.InstanceGuid)).ToArray();
// Must find better way to find Device than by Vendor ID and Product ID.
if (addedDevices.Length > 0)
{
//Joystick = new Guid("6f1d2b70-d5a0-11cf-bfc7-444553540000");
//SysMouse = new Guid("6f1d2b60-d5a0-11cf-bfc7-444553540000");
//SysKeyboard = new Guid("6f1d2b61-d5a0-11cf-bfc7-444553540000");
DeviceInfo[] devInfos = DeviceDetector.GetDevices();
DeviceInfo[] intInfos = null;
// Controllers.
var controllers = addedDevices
.Where(x => x.Type != SharpDX.DirectInput.DeviceType.Mouse && x.Type != SharpDX.DirectInput.DeviceType.Keyboard)
.Select(x => new Joystick(Manager, x.InstanceGuid)).ToArray();
// Get interfaces.
var interfacePaths = controllers.Select(x => x.Properties.InterfacePath).ToArray();
intInfos = DeviceDetector.GetInterfaces(interfacePaths);
for (int i = 0; i < addedDevices.Length; i++)
{
var device = addedDevices[i];
var ud = new UserDevice();
RefreshDevice(ud, device);
DeviceInfo hid = null;
DeviceInfo dev = null;
if (device.IsHumanInterfaceDevice)
{
// Get interface info for added devices.
hid = intInfos.FirstOrDefault(x => x.DevicePath == ud.Device.Properties.InterfacePath);
// Get device info for added devices.
dev = devInfos.FirstOrDefault(x => x.DeviceId == ud.HidDeviceId);
}
ud.LoadHidDeviceInfo(hid);
ud.LoadDevDeviceInfo(dev);
var isVirtual = false;
if (hid != null)
{
DeviceInfo p = hid;
do
{
p = DeviceDetector.GetParentDevice(Guid.Empty, JocysCom.ClassLibrary.Win32.DIGCF.DIGCF_ALLCLASSES, p.DeviceId);
if (p != null && string.Compare(p.HardwareId, VirtualDriverInstaller.ViGEmBusHardwareId, true) == 0)
{
isVirtual = true;
break;
}
} while (p != null);
}
if (!isVirtual)
{
insertDevices.Add(ud);
}
}
}
//if (insertDevices.Count > 0)
//{
// CloudPanel.Add(CloudAction.Insert, insertDevices.ToArray(), true);
//}
for (int i = 0; i < updatedDevices.Length; i++)
{
var device = updatedDevices[i];
var di = SettingsManager.UserDevices.Items.First(x => x.InstanceGuid.Equals(device.InstanceGuid));
updateDevices.Add(new KeyValuePair <UserDevice, DeviceInstance>(di, device));
}
if (Program.IsClosing)
{
return;
}
// Remove disconnected devices.
for (int i = 0; i < deleteDevices.Length; i++)
{
deleteDevices[i].IsOnline = false;
}
for (int i = 0; i < insertDevices.Count; i++)
{
var ud = insertDevices[i];
SettingsManager.UserDevices.Items.Add(ud);
}
for (int i = 0; i < updateDevices.Count; i++)
{
var kv = updateDevices[i];
RefreshDevice(kv.Key, kv.Value);
}
// Enable Test instances.
TestDeviceHelper.EnableTestInstances();
RefreshDevicesCount++;
var ev = DevicesUpdated;
if (ev != null)
{
ev(this, new DInputEventArgs());
}
// var game = CurrentGame;
// if (game != null)
// {
// // Auto-configure new devices.
// AutoConfigure(game);
// }
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
if (ModelState.IsValid)
{
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await _signInManager.PasswordSignInAsync(Input.Email, Input.Password, Input.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
var userId = "";
var user = _context.Users.ToList().SingleOrDefault(x => string.Equals(x.UserName, Input.Email, StringComparison.CurrentCultureIgnoreCase));
if (user != null)
{
userId = user.Id;
}
if (user != null && user.Blocked)
{
await _signInManager.SignOutAsync();
return(RedirectToAction("Blocked", "Home", new { userId = user.Id }));
}
var isNew = _info.IsDeviceNew(userId, Input.AuthCookies, Input.Ip);
var groupNumber = _info.GetDeviceGroupNumber(userId, Input.AuthCookies, Input.Ip);
Console.WriteLine(user != null
? $"User logged: {user.FirstName} {user.LastName}, IP: {Input.Ip} -------------------------------------"
: $"User logged: is null, IP: {Input.Ip} -------------------------------------");
var device = new UserDevice()
{
Activity = EnumList.Activity.LoginActivity, Ip = Input.Ip, OperatingSystem = Input.OperatingSystem, DeviceType = Input.DeviceType, AuthCookies = Input.AuthCookies, User = user,
New = isNew, GroupNumber = groupNumber
};
_context.Add(device);
await _context.SaveChangesAsync();
_logger.LogInformation("User logged in.");
return(LocalRedirect(returnUrl));
}
if (result.RequiresTwoFactor)
{
return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe }));
}
if (result.IsLockedOut)
{
_logger.LogWarning("User account locked out.");
return(RedirectToPage("./Lockout"));
}
else
{
ModelState.AddModelError("wrongPassword", "{{$t('message.wrongPassword')}}");
Console.WriteLine($"User:{Input.Email}. With wrong password: ({Input.Password}) -------------------------------------");
return(Page());
}
}
// If we got this far, something failed, redisplay form
ModelState.AddModelError("wrongPassword", "{{$t('message.errorRefresh')}}");
return(Page());
}
public void AddorUpdate(UserDevice userDevice)
{
_repository.InsertOrOverwrite(userDevice);
}
void ShowDeviceInfo(Joystick device, UserDevice dInfo)
{
if (device == null)
{
// clean everything here.
AppHelper.SetText(DeviceProductNameTextBox, "");
AppHelper.SetText(DeviceVendorNameTextBox, "");
AppHelper.SetText(DeviceProductGuidTextBox, "");
AppHelper.SetText(DeviceInstanceGuidTextBox, "");
AppHelper.SetText(DiCapFfStateTextBox, "");
AppHelper.SetText(DiCapAxesTextBox, "");
AppHelper.SetText(DiCapButtonsTextBox, "");
AppHelper.SetText(DiCapDPadsTextBox, "");
if (DiEffectsTable.Rows.Count > 0)
{
DiEffectsTable.Rows.Clear();
}
return;
}
lock (MainForm.XInputLock)
{
var isLoaded = XInput.IsLoaded;
if (isLoaded)
{
XInput.FreeLibrary();
}
device.Unacquire();
device.SetCooperativeLevel(MainForm.Current.Handle, CooperativeLevel.Foreground | CooperativeLevel.Exclusive);
effects = new List <EffectInfo>();
try
{
device.Acquire();
var forceFeedback = device.Capabilities.Flags.HasFlag(DeviceFlags.ForceFeedback);
forceFeedbackState = forceFeedback ? "YES" : "NO";
effects = device.GetEffects(EffectType.All);
}
catch (Exception)
{
forceFeedbackState = "ERROR";
}
DiEffectsTable.Rows.Clear();
foreach (var eff in effects)
{
DiEffectsTable.Rows.Add(new object[] {
eff.Name,
((EffectParameterFlags)eff.StaticParameters).ToString(),
((EffectParameterFlags)eff.DynamicParameters).ToString()
});
}
device.Unacquire();
device.SetCooperativeLevel(MainForm.Current.Handle, CooperativeLevel.Background | CooperativeLevel.NonExclusive);
if (isLoaded)
{
Exception error;
XInput.ReLoadLibrary(XInput.LibraryName, out error);
}
}
AppHelper.SetText(DiCapFfStateTextBox, forceFeedbackState);
AppHelper.SetText(DiCapButtonsTextBox, device.Capabilities.ButtonCount.ToString());
AppHelper.SetText(DiCapDPadsTextBox, device.Capabilities.PovCount.ToString());
var objects = AppHelper.GetDeviceObjects(device);
DiObjectsDataGridView.DataSource = objects;
var actuators = objects.Where(x => x.Flags.HasFlag(DeviceObjectTypeFlags.ForceFeedbackActuator));
AppHelper.SetText(ActuatorsTextBox, actuators.Count().ToString());
var di = device.Information;
var slidersCount = objects.Where(x => x.GuidValue.Equals(SharpDX.DirectInput.ObjectGuid.Slider)).Count();
// https://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.reference.dijoystate2(v=vs.85).aspx
AppHelper.SetText(DiCapAxesTextBox, (device.Capabilities.AxeCount - slidersCount).ToString());
AppHelper.SetText(SlidersTextBox, slidersCount.ToString());
// Update PID and VID always so they wont be overwritten by load settings.
short vid = BitConverter.ToInt16(di.ProductGuid.ToByteArray(), 0);
short pid = BitConverter.ToInt16(di.ProductGuid.ToByteArray(), 2);
AppHelper.SetText(DeviceVidTextBox, "0x{0:X4}", vid);
AppHelper.SetText(DevicePidTextBox, "0x{0:X4}", pid);
AppHelper.SetText(DeviceProductNameTextBox, di.ProductName);
AppHelper.SetText(DeviceVendorNameTextBox, dInfo == null ? "" : dInfo.HidManufacturer);
AppHelper.SetText(DeviceRevTextBox, "0x{0:X4}", dInfo == null ? 0 : dInfo.HidRevision);
AppHelper.SetText(DeviceProductGuidTextBox, di.ProductGuid.ToString());
AppHelper.SetText(DeviceInstanceGuidTextBox, di.InstanceGuid.ToString());
AppHelper.SetText(DeviceTypeTextBox, di.Type.ToString());
}
/// <summary> /// Creates a new instace of <see cref="DeviceInfo"/> from a <see cref="UserDevice"/> object. /// </summary> /// <param name="device">The device instance.</param> public static DeviceInfo FromUserDevice(UserDevice device) => new()
/// <summary>
/// Refresh device.
/// </summary>
void RefreshDevice(DirectInput manager, UserDevice ud, DeviceInstance instance, DeviceInfo[] allDevices, DeviceInfo[] allInterfaces, out DeviceInfo hid)
{
hid = null;
if (Program.IsClosing)
{
return;
}
// If device added then...
if (ud.Device == null)
{
try
{
// Lock to avoid Exception: Collection was modified; enumeration operation may not execute.
lock (SettingsManager.UserDevices.SyncRoot)
{
Device device;
//if (instance.Type == DeviceType.Mouse)
// device = new Mouse(manager);
//else if (instance.Type == DeviceType.Keyboard)
// device = new Keyboard(manager);
//else
device = new Joystick(manager, instance.InstanceGuid);
ud.Device = device;
ud.IsExclusiveMode = null;
ud.LoadCapabilities(device.Capabilities);
}
}
catch (Exception) { }
}
// Lock to avoid Exception: Collection was modified; enumeration operation may not execute.
lock (SettingsManager.UserDevices.SyncRoot)
{
ud.LoadInstance(instance);
}
// If device is set as offline then make it online.
if (!ud.IsOnline)
{
lock (SettingsManager.UserDevices.SyncRoot)
ud.IsOnline = true;
}
// Get device info for added devices.
var dev = allDevices.FirstOrDefault(x => x.DeviceId == ud.HidDeviceId);
// Lock to avoid Exception: Collection was modified; enumeration operation may not execute.
lock (SettingsManager.UserDevices.SyncRoot)
{
ud.LoadDevDeviceInfo(dev);
if (dev != null)
{
ud.ConnectionClass = DeviceDetector.GetConnectionDevice(dev, allDevices)?.ClassGuid ?? Guid.Empty;
}
}
// InterfacePath is available for HID devices.
if (instance.IsHumanInterfaceDevice && ud.Device != null)
{
var interfacePath = ud.Device.Properties.InterfacePath;
// Get interface info for added devices.
hid = allInterfaces.FirstOrDefault(x => x.DevicePath == interfacePath);
// Lock to avoid Exception: Collection was modified; enumeration operation may not execute.
lock (SettingsManager.UserDevices.SyncRoot)
{
ud.LoadHidDeviceInfo(hid);
if (hid != null)
{
ud.ConnectionClass = DeviceDetector.GetConnectionDevice(hid, allDevices)?.ClassGuid ?? Guid.Empty;
}
// Workaround:
// Override Device values and description from the Interface,
// because it is more accurate and present.
// Note 1: Device fields below, probably, should not be used.
// Note 2: Available when device is online.
ud.DevManufacturer = ud.HidManufacturer;
ud.DevDescription = ud.HidDescription;
ud.DevVendorId = ud.HidVendorId;
ud.DevProductId = ud.HidProductId;
ud.DevRevision = ud.HidRevision;
}
}
}
/// <summary>
/// 添加UserDevice
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool AddUserDevice(UserDevice model)
{
return(UsersController.AddUserDevice(model));
}
/// <summary>
/// 注册用户设备信息
/// </summary>
/// <param name="device"></param>
public static void RegisterDevice(UserDevice device)
{
SupportData.RegisterDevice(device);
}
/// <summary>
/// 更新UserDevice
/// </summary>
/// <param name="userSession"></param>
/// <returns></returns>
public bool UpdateUserDevice(UserDevice userSession)
{
return(UsersController.UpdateUserDevice(userSession));
}
private async void DeleteExecute()
{
// call delete
var newUserInformation = await this.getFitWebService.DeleteUserDevice(this.selectedUserDevice, this.credentialRetrieverService);
if (newUserInformation == null)
{
this.Message = string.Format(Properties.Resources.RemoveUserDeviceErrorMessage, this.selectedUserDevice.DeviceSelection);
return;
}
this.selectedUserDevice = null;
this.UserDevices.Clear();
this.UserDevices.Add (new NullUserDevice ());
}
public ActionResult <Response> PushDeviceId([FromQuery(Name = "lang")] string lang, [FromBody] UserDevice userDevice)
{
try
{
string user_id = new UserService(lang).CheckAccessTokenUser(userDevice.accessToken);
if (user_id != null)
{
return(new UserService(lang).PushDeviceId(userDevice, user_id));
}
else
{
return(new Response(false, Messages.GetMessage(lang, Messages.TypeM.DEFAULT, Messages.defaultM.WRONG_ACCESS_TOKEN)));
}
}
catch (Exception ex)
{
return(new Response(false, Messages.GetMessage(lang, Messages.TypeM.DEFAULT, Messages.defaultM.UNEXPERROR), ex.Message));
}
}
