/// <summary>
/// 请求 所有设备的 信息
/// </summary>
/// <param name="documents"></param>
/// <returns></returns>
public Status getAll(out List <Device> devices)
{
devices = new List <Device>();
try
{
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
List <DeviceVO> deviceVolist = deviceDao.getAll <DeviceVO>();
foreach (DeviceVO deviceVo in deviceVolist)
{
devices.Add(
new Device
{
deviceID = deviceVo.deviceID,
IMEI = deviceVo.IMEI,
deviceIndex = deviceVo.deviceIndex,
deviceFreezeState = deviceVo.deviceState
});
}
return(Status.SUCCESS);
}
catch (Exception e)
{
Log.ErrorInfo(e.StackTrace);
return(Status.SERVER_EXCEPTION);
}
}
/// <summary>
/// 创建设备
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
public Status create(CreateDevice device)
{
try
{
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
Dictionary <string, object> wherelist = new Dictionary <string, object>();
Log.DebugInfo(device.ToString());
//创建设备ID
int deviceID = DeviceDAO.getID();
//插入数据
if (deviceDao.insert <DeviceVO>(
new DeviceVO
{
deviceID = deviceID,
deviceIndex = device.deviceIndex,
IMEI = device.IMEI,
deviceState = 0
}) < 0)
{
return(Status.NAME_EXIST);
}
return(Status.SUCCESS);
}
catch (Exception e)
{
Log.ErrorInfo(e.StackTrace);
return(Status.SERVER_EXCEPTION);
}
}
public void GivenDeviceNameShouldReturnDevice()
{
var data = new List <Device>
{
new Device()
{
Id = 0, Name = "A", UserId = 0
},
new Device()
{
Id = 1, Name = "B", UserId = 1
},
new Device()
{
Id = 2, Name = "C", UserId = 0
}
}.AsQueryable();
var mockContext = new Mock <UserDataContext>();
var mockSet = SetupDbSet(data);
mockContext.Setup(c => c.Device).Returns(mockSet.Object);
var dao = new DeviceDAO(mockContext.Object);
var result = dao.GetByName("A");
Assert.AreEqual("A", result.Name);
}
/// <summary>
/// 更新时，请求 指定设备的 信息
/// </summary>
/// <param name="device"></param>
/// <param name="deviceID"></param>
/// <returns></returns>
public Status getOneForUpdate(out UpdateDevice device, int deviceID)
{
device = new UpdateDevice();
try
{
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
DeviceVO deviceVo = deviceDao.getOne <DeviceVO>(deviceID);
if (deviceVo == null)
{
return(Status.NONFOUND);
}
device.deviceID = deviceVo.deviceID;
device.IMEI = deviceVo.IMEI;
device.deviceIndex = deviceVo.deviceIndex;
return(Status.SUCCESS);
}
catch (Exception e)
{
Log.ErrorInfo(e.StackTrace);
return(Status.SERVER_EXCEPTION);
}
}
/// <summary>
/// 更新时，提交 更新设备的 信息
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
public Status update(UpdateDevice device)
{
Log.DebugInfo(device.ToString());
try
{
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
var deviceVo = deviceDao.getOne <DeviceVO>(device.deviceID);
if (deviceVo == null)
{
return(Status.NONFOUND);
}
Dictionary <string, object> setlist = new Dictionary <string, object>();
setlist.Add("IMEI", device.IMEI);
setlist.Add("deviceIndex", device.deviceIndex);
if (deviceDao.update(
setlist, device.deviceID) < 0)
{
return(Status.NAME_EXIST);
}
return(Status.SUCCESS);
}
catch (Exception e)
{
Log.ErrorInfo(e.StackTrace);
return(Status.FAILURE);
}
}
/// <summary>
/// Create an Event Cluster
/// </summary>
/// <param name="eventObj">EventClusterCreationModel</param>
/// <returns>EventClusterModel</returns>
public async Task <EventClusterModel> CreateEventCluster(EventClusterCreationModel eventObj)
{
//If device doesn't exist, throw exception
DeviceDAO deviceEntity = await _repoDevices.GetItemAsync(eventObj.DeviceId);
if (deviceEntity == null)
{
throw new Exception($"No device found that matches DeviceId: {eventObj.DeviceId}");
}
EventClusterDAO eventCluster = new EventClusterDAO()
{
Id = eventObj.EventClusterId.ToString(),
Device = _mapper.Map <EventClusterDeviceDAOObject>(deviceEntity),
EventType = eventObj.EventType.ToLower(),
EventCount = 1,
Events = new EventDAOObject[] { _mapper.Map <EventDAOObject>(eventObj) },
StartDate = eventObj.Date
};
eventCluster.Id = await _repoEventClusters.CreateItemAsync(eventCluster);
if (_repoEventClusters.IsDocumentKeyNull(eventCluster))
{
throw new Exception($"An error occured when creating a new cluster id for DeviceId: {eventObj.DeviceId}");
}
return(_mapper.Map <EventClusterModel>(eventCluster));
}
public void GivenValidObjectWithUserIdShouldAddObject()
{
var data = new List <Device>().AsQueryable();
var mockContext = new Mock <UserDataContext>();
var mockSet = SetupDbSet(data);
mockContext.Setup(c => c.Device).Returns(mockSet.Object);
mockContext.Setup(c => c.DeviceType.Find(0)).Returns(new DeviceType()
{
Id = 1, Type = "Temperature"
});
mockContext.Setup(c => c.User.Find(0)).Returns(new User()
{
Id = 0, UserId = "ABCDEF"
});
mockSet.Setup(c => c.Add(It.IsAny <Device>())).Returns(new Device()
{
Id = 1, DeviceTypeId = 1, UserId = 1
});
var dao = new DeviceDAO(mockContext.Object);
var newUserType = dao.Add(new Device()
{
DeviceTypeId = 1, UserId = 1
});
mockSet.Verify(m => m.Add(It.IsAny <Device>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
/// <summary>
/// Update the LastAccessTime of a device
/// </summary>
/// <param name="deviceId">Device Id</param>
/// <returns>DeviceHeartbeatUpdatedModel</returns>
public async Task <DeviceHeartbeatUpdatedModel> UpdateHeartbeat(Guid deviceId)
{
if (deviceId == Guid.Empty)
{
throw new Exception($"No device found that matches DeviceId: {deviceId}");
}
DeviceDAO deviceDAO = await _repoDevices.GetItemAsync(deviceId);
string etag = deviceDAO.ETag;
deviceDAO.LastAccessTime = DateTime.UtcNow;
try
{
await _repoDevices.UpdateItemAsync(deviceDAO);
return(new DeviceHeartbeatUpdatedModel()
{
Device = _mapper.Map <DeviceModel>(deviceDAO),
NeedsUpdate = deviceDAO.Enabled
});
}
catch (DocumentClientException e)
{
//Update concurrency issue, retrying
if (e.StatusCode == HttpStatusCode.PreconditionFailed)
{
return(await UpdateHeartbeat(deviceId));
}
throw e;
}
}
public DeviceModel RegisterDevice(string deviceType)
{
try
{
DeviceType type = DeviceTypeDAO.GetByTypeName(deviceType);
if (type == null)
{
throw new Exception("Invalid Device Type");
}
UserData.DAL.Device device = new UserData.DAL.Device()
{
DeviceType = type,
DeviceTypeId = type.Id
};
var insertedDevice = DeviceDAO.Add(device);
return(new DeviceModel()
{
Id = insertedDevice.Id,
DeviceType = insertedDevice.DeviceType.Type
});
}
catch (Exception ex)
{
throw new WebFaultException <string>(ex.Message, HttpStatusCode.MethodNotAllowed);
}
}
public void GivenDeviceTypeShouldReturnAllDeviceOfType()
{
var data = new List <Device>
{
new Device()
{
Id = 0, Name = "A", DeviceTypeId = 0
},
new Device()
{
Id = 1, Name = "B", DeviceTypeId = 1
},
new Device()
{
Id = 2, Name = "C", DeviceTypeId = 0
}
}.AsQueryable();
var mockContext = new Mock <UserDataContext>();
var mockSet = SetupDbSet(data);
mockContext.Setup(c => c.Device).Returns(mockSet.Object);
var dao = new DeviceDAO(mockContext.Object);
var results = dao.GetAllDevicesOfType(new DeviceType()
{
Id = 0
});
Assert.AreEqual(2, results.Count);
Assert.AreEqual("A", results[0].Name);
Assert.AreEqual("C", results[1].Name);
}
/// <summary>
/// Delete a mobile device
/// </summary>
/// <param name="registrationId">RegistrationId</param>
/// <returns>True if the device was successfully deleted</returns>
public async Task <bool> DeleteMobileDevice(string registrationId)
{
DeviceDAO device = await _repoDevices.GetItemAsync(d => (string)d.Custom["RegistrationId"] == registrationId);
if (device != null)
{
return(await _repoDevices.DeleteItemAsync(device.Id));
}
return(true);
}
/// <summary>
/// Create or update a device
/// </summary>
/// <param name="deviceTwinObj">DeviceTwinModel</param>
/// <returns>DeviceModel</returns>
public async Task <DeviceModel> CreateOrUpdateDevice(DeviceTwinModel deviceTwinObj)
{
if (deviceTwinObj.DeviceId == Guid.Empty)
{
throw new Exception($"No device found that matches DeviceId: {deviceTwinObj.DeviceId}");
}
DeviceDAO deviceDAO = await _repoDevices.GetItemAsync(deviceTwinObj.DeviceId);
//Create
if (deviceDAO == null)
{
return(await CreateDevice(deviceTwinObj));
}
//Update
deviceDAO.IoTDevice = true;
if (deviceTwinObj.Properties?.Desired != null)
{
deviceDAO.Desired = deviceTwinObj.Properties.Desired;
}
if (deviceTwinObj.Properties?.Reported != null)
{
deviceDAO.Reported = deviceTwinObj.Properties.Reported;
}
if (deviceTwinObj.Tags != null)
{
deviceDAO.DeviceType = deviceTwinObj.Tags.DeviceType;
deviceDAO.Enabled = deviceTwinObj.Tags.Enabled;
deviceDAO.Custom = deviceTwinObj.Tags.Custom;
deviceDAO.Name = deviceTwinObj.Tags.Name;
deviceDAO.Location1 = deviceTwinObj.Tags.Location1;
deviceDAO.Location2 = deviceTwinObj.Tags.Location2;
deviceDAO.Location3 = deviceTwinObj.Tags.Location3;
deviceDAO.SSID = deviceTwinObj.Tags.SSID;
deviceDAO.Sensor = deviceTwinObj.Tags.Sensor;
deviceDAO.Geolocation = _mapper.Map <GeolocationDAOObject>(deviceTwinObj.Tags.Geolocation);
}
try
{
await _repoDevices.UpdateItemAsync(deviceDAO);
}
catch (DocumentClientException e)
{
//Update concurrency issue, retrying
if (e.StatusCode == HttpStatusCode.PreconditionFailed)
{
return(await CreateOrUpdateDevice(deviceTwinObj));
}
throw e;
}
return(_mapper.Map <DeviceModel>(deviceDAO));
}
/// <summary>
/// Get a mobile device from a user id
/// </summary>
/// <param name="userId">User Id</param>
/// <returns>DeviceModel</returns>
public async Task <DeviceModel> GetMobileDeviceFromUserId(string userId)
{
if (string.IsNullOrEmpty(userId))
{
throw new Exception($"UserId not found");
}
DeviceDAO deviceEntity = await _repoDevices.GetItemAsync(p => p.DeviceType == "Mobile" && p.Custom != null &&
p.Custom["Email"] != null && (string)p.Custom["Email"] == userId);
return(_mapper.Map <DeviceModel>(deviceEntity));
}
/// <summary>
/// Create a device
/// </summary>
/// <param name="deviceTwinObj">DeviceTwinModel</param>
/// <returns>DeviceModel</returns>
public async Task <DeviceModel> CreateDevice(DeviceTwinModel deviceTwinObj)
{
//If device doesn't exist, throw exception
DeviceDAO deviceEntity = _mapper.Map <DeviceDAO>(deviceTwinObj);
deviceEntity.Id = await _repoDevices.CreateItemAsync(deviceEntity);
if (_repoDevices.IsDocumentKeyNull(deviceEntity))
{
throw new Exception($"An error occured when creating a new device: {deviceTwinObj.DeviceId}");
}
return(_mapper.Map <DeviceModel>(deviceEntity));
}
public void AddRawMetric(string id, string date, string value)
{
IDictionary <string, Object> paramMap = new Dictionary <string, Object>();
paramMap[Constants.Context.PROVIDER_URL] = ConfigurationManager.AppSettings["jmsProviderUrl"].ToString();
IContext jmsContext = ContextFactory.CreateContext(paramMap);
IConnectionFactory cf = jmsContext.LookupConnectionFactory(ConfigurationManager.AppSettings["jmsConnectionFactory"].ToString());
IQueue queue = (IQueue)jmsContext.LookupDestination(ConfigurationManager.AppSettings["jmsQueue"].ToString());
IConnection connection;
try
{
if (date == null || date.Length == 0 || value == null || value.Length == 0)
{
throw new Exception("Missing raw metrics parameters.");
}
var device = DeviceDAO.Get(int.Parse(id));
if (device == null)
{
throw new Exception("Device doesn't exist.");
}
connection = cf.CreateConnection();
connection.Start();
ISession producerSession = connection.CreateSession(Constants.SessionMode.AUTO_ACKNOWLEDGE);
IMessageProducer producer = producerSession.CreateProducer(queue);
producer.DeliveryMode = Constants.DeliveryMode.PERSISTENT;
MetricModel model = new MetricModel()
{
DeviceId = int.Parse(id), Date = date, Value = value
};
ITextMessage jmsMessage = producerSession.CreateTextMessage(JsonConvert.SerializeObject(model));
producer.Send(jmsMessage);
}
catch (Exception ex)
{
throw new WebFaultException <string>(ex.Message, HttpStatusCode.MethodNotAllowed);
}
connection.Close();
}
private void SetInstance(string deviceType)
{
_device = null;
_deviceDAO = null;
if (deviceType.CompareTo(DeviceType.HH.ToString()) == 0)
{
_deviceDAO = new HandheldDAO();
_device = new IHF.BusinessLayer.BusinessClasses.Handheld();
}
else
{
_deviceDAO = new DeviceDAO();
_device = new Device();
}
}
/// <summary>
/// 获取指定会议的参会人员
/// </summary>
/// <param name="meetingID"></param>
/// <param name="delegates"></param>
/// <returns></returns>
public Status getAll(int meetingID, out List <DelegateInfo> delegates)
{
delegates = new List <DelegateInfo>();
DelegateDAO delegateDao = Factory.getInstance <DelegateDAO>();
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
PersonDAO personDao = Factory.getInstance <PersonDAO>();
Dictionary <string, object> wherelist = new Dictionary <string, object>();
wherelist.Add("meetingID", meetingID);
List <DelegateVO> delegateVos = delegateDao.getAll <DelegateVO>(wherelist);
if (delegateVos == null)
{
return(Status.NONFOUND);
}
foreach (DelegateVO delegateVo in delegateVos)
{
//获取设备信息
DeviceVO deviceVo = deviceDao.getOne <DeviceVO>(delegateVo.deviceID);
//获取用户信息
PersonVO personVo = personDao.getOne <PersonVO>(delegateVo.personID);
if (deviceVo == null || personVo == null)
{
return(Status.FAILURE);
}
delegates.Add(
new DelegateInfo
{
delegateID = delegateVo.delegateID,
userDepartment = personVo.personDepartment,
meetingID = meetingID,
userName = personVo.personName,
userJob = personVo.personJob,
userMeetingRole = delegateVo.personMeetingRole,
deviceID = deviceVo.deviceID,
deviceIndex = deviceVo.deviceIndex
});
}
return(Status.SUCCESS);
}
/// <summary>
/// Create or update a mobile device
/// </summary>
/// <param name="deviceMobile">DeviceMobileModel</param>
/// <returns>DeviceMobileModel</returns>
public async Task <DeviceMobileModel> CreateOrUpdateDevice(DeviceMobileModel deviceMobile)
{
if (deviceMobile.DeviceId == Guid.Empty && string.IsNullOrEmpty(deviceMobile.MobileId))
{
throw new Exception($"Invalid DeviceId and/or MobileId");
}
DeviceDAO deviceDAO = null;
if (deviceMobile.DeviceId != Guid.Empty)
{
deviceDAO = await _repoDevices.GetItemAsync(deviceMobile.DeviceId);
}
else if (!string.IsNullOrEmpty(deviceMobile.MobileId))
{
deviceDAO = await _repoDevices.GetItemAsync(
d => (string)d.Custom["MobileId"] == deviceMobile.MobileId);
}
if (deviceDAO == null)
//Create
{
deviceDAO = await CreateMobileDevice(deviceMobile);
}
else
//Update
{
deviceDAO.Custom = deviceMobile.Custom;
try
{
await _repoDevices.UpdateItemAsync(deviceDAO);
}
catch (DocumentClientException e)
{
//Update concurrency issue, retrying
if (e.StatusCode == HttpStatusCode.PreconditionFailed)
{
return(await CreateOrUpdateDevice(deviceMobile));
}
throw e;
}
}
return(_mapper.Map <DeviceMobileModel>(deviceDAO));
}
public void GivenIdShouldRemoveFromDb()
{
Device d = new Device()
{
Id = 0, Name = "A"
};
var mockContext = new Mock <UserDataContext>();
mockContext.Setup(c => c.Device.Find(0)).Returns(d);
var dao = new DeviceDAO(mockContext.Object);
dao.Remove(0);
mockContext.Verify(m => m.Device.Remove(It.IsAny <Device>()), Times.Once());
}
public void GivenObjectWithInvalidTypeIdShouldThrowException()
{
var data = new List <Device>().AsQueryable();
var mockContext = new Mock <UserDataContext>();
var mockSet = SetupDbSet(data);
mockContext.Setup(c => c.Device).Returns(mockSet.Object);
mockContext.Setup(c => c.DeviceType.Find(0)).Returns((DeviceType)null);
var dao = new DeviceDAO(mockContext.Object);
var ex = Assert.Throws <Exception>(() => dao.Add(new Device()
{
DeviceTypeId = 0
}));
Assert.AreEqual("Device.TypeId doesn't exist.", ex.Message);
}
public void GivenIdShouldReturnObject()
{
Device d1 = new Device()
{
Id = 0, Name = "A"
};
Device d2 = new Device()
{
Id = 1, Name = "B"
};
var mockContext = new Mock <UserDataContext>();
mockContext.Setup(c => c.Device.Find(0)).Returns(d1);
var dao = new DeviceDAO(mockContext.Object);
var result = dao.Get(0);
Assert.AreEqual(d1, result);
}
public void LinkDeviceToUser(string userId, string deviceId)
{
try
{
if (userId == null || userId.Length == 0 || deviceId.Length == 0)
{
throw new WebFaultException <string>("LinkDeviceToUser missing parameter.", HttpStatusCode.BadRequest);
}
DeviceDAO.AddDeviceOwner(int.Parse(deviceId), userId);
}
catch (WebFaultException)
{
throw;
}
catch (Exception ex)
{
throw new WebFaultException <string>(ex.Message, HttpStatusCode.InternalServerError);
}
}
public void GivenValidObjectShouldUpdateInDb()
{
Device d = new Device()
{
Id = 0, Name = "A"
};
Device dUpd = new Device()
{
Id = 0, Name = "A", UserId = 0
};
var mockContext = new Mock <UserDataContext>();
mockContext.Setup(c => c.Device.Find(0)).Returns(d);
var dao = new DeviceDAO(mockContext.Object);
var updatedObj = dao.Update(dUpd);
Assert.AreEqual("A", updatedObj.Name);
Assert.AreEqual(0, updatedObj.UserId);
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
/// <summary>
///
/// </summary>
/// <param name="deviceID"></param>
/// <param name="available"></param>
/// <returns></returns>
public Status UpdateDeviceAvailable(int deviceID, int available)
{
try
{
//数据库操作
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
Dictionary <string, object> setlist = new Dictionary <string, object>();
setlist.Add("deviceState", available);
if (deviceDao.update(setlist, deviceID) < 0)
{
return(Status.FAILURE);
}
return(Status.SUCCESS);
}
catch (Exception e)
{
Log.ErrorInfo(e.StackTrace);
return(Status.SERVER_EXCEPTION);
}
}
public void ShouldReturnAllDevices()
{
var data = new List <Device>
{
new Device()
{
Name = "A"
},
new Device()
{
Name = "B"
}
}.AsQueryable();
var mockContext = new Mock <UserDataContext>();
mockContext.Setup(c => c.Device).Returns(SetupDbSet(data).Object);
var dao = new DeviceDAO(mockContext.Object);
var results = dao.All();
Assert.AreEqual(2, results.Count);
}
public List <DeviceModel> GetNoLinkedDevices()
{
try
{
var devices = DeviceDAO.GetNoLinkedDevices();
if (devices != null)
{
List <DeviceModel> rDevices = new List <DeviceModel>();
foreach (var d in devices)
{
rDevices.Add(new DeviceModel()
{
Id = d.Id, Name = d.Name, DeviceType = d.DeviceType.Type
});
}
return(rDevices);
}
return(null);
}
catch (Exception)
{
throw;
}
}
public List <DeviceModel> GetDevices()
{
try
{
var devices = DeviceDAO.All();
var results = new List <DeviceModel>();
foreach (var device in devices)
{
results.Add(new DeviceModel()
{
Id = device.Id,
Name = device.Name,
DeviceType = device.DeviceType.Type
});
}
return(results);
}
catch (Exception ex)
{
throw new WebFaultException <string>(ex.Message, HttpStatusCode.InternalServerError);
}
}
public Status getAllForDelegate(DateTime start, DateTime end, out List <DeviceForDelegate> list)
{
list = new List <DeviceForDelegate>();
MeetingDAO meetingDao = Factory.getInstance <MeetingDAO>();
DelegateDAO delegateDao = Factory.getInstance <DelegateDAO>();
DeviceDAO deviceDao = Factory.getInstance <DeviceDAO>();
Dictionary <string, object> wherelist = new Dictionary <string, object>();
List <MeetingVO> meetingVolist = meetingDao.getAll <MeetingVO>();
int dx;
if (ConfigurationManager.AppSettings["DeviceOccupyTimeInterval"] == null)
{
dx = 30;
}
else
{
dx = Int32.Parse(ConfigurationManager.AppSettings["DeviceOccupyTimeInterval"]);
if (dx < 1)
{
dx = 30;
}
}
var tempMeetings = meetingVolist
.Where( //包括与本次会议在几乎同一时间开启或结束的会议
m => (Math.Abs((m.meetingToStartTime - start).TotalMinutes) < dx ||
Math.Abs((m.meetingToStartTime - end).TotalMinutes) < dx ||
Math.Abs((m.meetingStartedTime - start).TotalMinutes) < dx ||
Math.Abs((m.meetingStartedTime - end).TotalMinutes) < dx)
) //包括已开或正在开启的会议
.Where(m => m.meetingStatus == 1 || m.meetingStatus == 2);
wherelist.Clear();
//只允许未冻结的设备作为参会设备
wherelist.Add("deviceState", 0);
var deviceVolist = deviceDao.getAll <DeviceVO>(wherelist);
if (tempMeetings != null && deviceVolist != null)
{
var meetinglist = tempMeetings.ToList();
foreach (var meetingvo in meetinglist)
{
wherelist.Clear();
wherelist.Add("meetingID", meetingvo.meetingID);
var delegateVolist = delegateDao.getAll <DelegateVO>(wherelist);
if (delegateVolist != null)
{
foreach (var delegateVo in delegateVolist)
{
for (int i = 0; i < deviceVolist.Count; i++)
{
if (deviceVolist[i].deviceID == delegateVo.deviceID)
{
//去除已使用的设备
deviceVolist.RemoveAt(i);
break;
}
}
}
}
}
}
if (deviceVolist != null)
{
foreach (var devicevo in deviceVolist)
{
list.Add(new DeviceForDelegate
{
deviceID = devicevo.deviceID,
deviceIndex = devicevo.deviceIndex
});
}
}
return(Status.SUCCESS);
}
/// <summary>
/// Update the geolocation of a mobile device
/// </summary>
/// <param name="geolocation">Geolocation of the device</param>
/// <param name="userId">UserId</param>
/// <returns>DeviceGeolocationUpdateResultModel</returns>
public async Task <DeviceGeolocationUpdateResultModel> UpdateMobileGeolocation(Geolocation geolocation, string userId)
{
if (geolocation == null)
{
throw new Exception($"No Geolocation found: {geolocation}");
}
if (string.IsNullOrEmpty(userId))
{
throw new Exception($"UserId not found");
}
DeviceDAO deviceDAO = await _repoDevices.GetItemAsync(p => p.DeviceType == "Mobile" && p.Custom != null &&
p.Custom["Email"] != null && (string)p.Custom["Email"] == userId);
if (deviceDAO != null)
{
if (deviceDAO.Geolocation != null)
{
if (geolocation.Latitude == deviceDAO.Geolocation.Latitude &&
geolocation.Longitude == deviceDAO.Geolocation.Longitude)
{
return new DeviceGeolocationUpdateResultModel()
{
Success = true
}
}
;
}
string etag = deviceDAO.ETag;
deviceDAO.LastAccessTime = DateTime.UtcNow;
deviceDAO.Geolocation = _mapper.Map <GeolocationDAOObject>(geolocation);
try
{
var result = await _repoDevices.UpdateItemAsync(deviceDAO);
if (result)
{
return(new DeviceGeolocationUpdateResultModel()
{
Success = true,
Device = deviceDAO.Enabled ? _mapper.Map <DeviceModel>(deviceDAO) : null
});
}
throw new Exception($"Error while updating device geolocation: {userId}.");
}
catch (DocumentClientException e)
{
//Update concurrency issue, retrying
if (e.StatusCode == HttpStatusCode.PreconditionFailed)
{
return(await UpdateMobileGeolocation(geolocation, userId));
}
throw e;
}
}
return(new DeviceGeolocationUpdateResultModel()
{
Success = false
});
}
/// <summary>
/// Get a device from a device id
/// </summary>
/// <param name="deviceId">Device Id</param>
/// <returns>DeviceModel</returns>
public async Task <DeviceModel> GetDevice(Guid deviceId)
{
DeviceDAO deviceEntity = await _repoDevices.GetItemAsync(deviceId);
return(_mapper.Map <DeviceModel>(deviceEntity));
}
