public UserDeviceModel GetDeviceUniqueId()
{
IDevice device = DependencyService.Get <IDevice>();
UserDeviceModel deviceIdentifier = device.GetIdentifier(0);
return(deviceIdentifier);
}
public UserDeviceModel RegisterDevice([FromBody] UserDeviceModel model)
{
var device = _userDeviceRepository.GetAll()
.Where(u => u.UserId == _workContext.CurrentUser.Id && u.Platform == model.Platform && u.DeviceType == model.DeviceType)
.FirstOrDefault();
if (device != null)
{
if (device.DeviceToken != model.DeviceToken)
{
device.DeviceToken = model.DeviceToken;
}
_userDeviceRepository.UpdateAndCommit(device);
}
else
{
device = new UserDevice
{
UserId = _workContext.CurrentUser.Id,
Platform = model.Platform,
DeviceType = model.DeviceType,
DeviceToken = model.DeviceToken
};
_userDeviceRepository.InsertAndCommit(device);
}
return(model);
}
public UserDeviceModel GetIdentifier(int simSlot)
{
UserDeviceModel info = new UserDeviceModel();
try
{
var UniqueID = UIDevice.CurrentDevice.IdentifierForVendor;
if (UniqueID != null)
{
info.DeviceInformation.UniqueID = UniqueID.Description;
}
}
catch (Exception)
{
info.DeviceInformation.UniqueID = "000000000000";
}
// string device_id = UIDevice.CurrentDevice.IdentifierForVendor?.
//var query = new SecRecord(SecKind.GenericPassword);
//query.Service = NSBundle.MainBundle.BundleIdentifier;
//query.Account = "UniqueID";
//NSData uniqueId = SecKeyChain.QueryAsData(query);
//if (uniqueId == null)
//{
// query.ValueData = NSData.FromString(System.Guid.NewGuid().ToString());
// var err = SecKeyChain.Add(query);
// if (err != SecStatusCode.Success && err != SecStatusCode.DuplicateItem)
// throw new Exception("Cannot store Unique ID");
// return query.ValueData.ToString();
//}
//else
//{
// return uniqueId.ToString();
//}
//string serial = string.Empty;
//uint platformExpert = IOServiceGetMatchingService(0, IOServiceMatching("IOPlatformExpertDevice"));
//NSString key = (NSString)"IOPlatformSerialNumber";
//IntPtr serialNumber = IORegistryEntryCreateCFProperty(platformExpert, key.Handle, IntPtr.Zero, 0);
//if (serialNumber != IntPtr.Zero)
//{
// serial = NSString.FromHandle(serialNumber);
//}
//IOObjectRelease(platformExpert);
return(info);
}
public bool GetUser(string username, out UserDeviceModel user, out string error)
{
user = dbContext.Users.Include(u => u.Devices).FirstOrDefault(e => e.Username == username)?.ToUserDeviceRespone();
if (user == null)
{
error = "User not exist";
return(false);
}
error = "";
return(true);
}
public HttpResponseMessage Post(UserDeviceModel device)
{
if (!ModelState.IsValid)
{
return(this.ModelStateResult());
}
Device item = this.DeviceReposiotry.GetAll()
.FirstOrDefault(d => d.Name == device.Name &&
d.Platform == device.Platform &&
d.Uuid == device.Uuid);
if (item == null)
{
ModelState.AddModelError("DeviceNotFound", DataAnnotations.DeviceNotFound);
return(this.ModelStateResult());
}
bool deviceExists = this.repository.GetByIds(CurrentUser.Id, item.Id) != null;
if (deviceExists)
{
ModelState.AddModelError("DeviceExists", DataAnnotations.DeviceExists);
return(this.ModelStateResult());
}
UserDevice userDevice = new UserDevice()
{
DeviceId = item.Id,
UserId = CurrentUser.Id,
ApprovalStatus = ApprovalStatus.Pending
};
this.repository.Save(userDevice);
return(Request.CreateResponse(
HttpStatusCode.Created,
new
{
userDevice.UserId,
userDevice.DeviceId,
userDevice.ApprovalStatus,
Name = item.Name
}));
}
public UserDeviceModel GetIdentifier(int simSlot)
{
UserDeviceModel info = new UserDeviceModel();
try
{
TelephonyManager IMEI_telManager = (TelephonyManager)Forms.Context.GetSystemService(Context.TelephonyService);
if (IMEI_telManager != null)
{
info.DeviceInformation.IMEI = IMEI_telManager.GetDeviceId(simSlot);
info.DeviceInformation.PhoneNumber = IMEI_telManager.Line1Number;
}
}
catch (Exception)
{
}
return(info);
}
public async Task <bool> RegisterUserDevice(UserDeviceModel model, CommonUser user)
{
var deviceAlreadyExists = await CommonContext.CommonUserDevices.SingleOrDefaultAsync(m => m.DeviceToken == model.DeviceToken && m.UserId == user.Id);
if (deviceAlreadyExists != null)
{
deviceAlreadyExists.IsLogin = true;
deviceAlreadyExists.UpdateUserId = user.Id;
deviceAlreadyExists.DevicePublicKey = model.DevicePublicKey;
using (var tx = CommonContext.Database.BeginTransaction())
{
CommonContext.CommonUserDevices.Update(deviceAlreadyExists);
await CommonContext.SaveChangesAsync();
tx.Commit();
}
}
else
{
CommonUserDevice userDevice = new CommonUserDevice()
{
DeviceName = model.DeviceName,
DeviceToken = model.DeviceToken,
DeviceType = model.DeviceType,
DevicePublicKey = model.DevicePublicKey,
UserId = user.Id,
IsLogin = true,
CreateUserId = user.Id
};
using (var tx = CommonContext.Database.BeginTransaction())
{
CommonContext.CommonUserDevices.Add(userDevice);
await CommonContext.SaveChangesAsync();
tx.Commit();
}
}
return(true);
}
public IHttpActionResult AddUserDevice(UserDeviceModel Model)
{
long ret = 0;
try
{
using (AppDBContext context = new AppDBContext())
{
ret = new UserDeviceRepository(context).Add(
new UserDevice
{
UserId = Model.UserId,
DeviceToken = Model.DeviceToken,
DeviceId = Model.DeviceId
});
}
return(Ok(ret));
}
catch (Exception ex)
{
Logger.Log(typeof(UserController), ex.Message + ex.StackTrace, LogType.ERROR);
return(InternalServerError());
}
}
public Task <BaseResponseMessage> UpdateUserDevice(UserDeviceModel userDevice, Guid userId)
{
throw new NotImplementedException();
}
