/// <summary> /// Create or Update an Event Cluster /// </summary> /// <param name="eventObj">EventClusterCreationModel</param> /// <returns>EventClusterModel</returns> public async Task <EventClusterModel> CreateOrUpdateEventCluster(EventClusterCreationModel eventObj) { //Look for existing cluster that matches DeviceId + EventType and hasn't ended yet. EventClusterDAO eventCluster = await _repoEventClusters.GetItemAsync(eventObj.EventClusterId); //Create if (eventCluster == null) { return(await CreateEventCluster(eventObj)); } eventCluster.Events = eventCluster.Events.Append(_mapper.Map <EventDAOObject>(eventObj)).OrderByDescending(p => p.Date).ToArray(); eventCluster.EventCount++; try { await _repoEventClusters.UpdateItemAsync(eventCluster); } catch (DocumentClientException e) { //Update concurrency issue, retrying if (e.StatusCode == HttpStatusCode.PreconditionFailed) { return(await CreateOrUpdateEventCluster(eventObj)); } throw e; } var output = _mapper.Map <EventClusterModel>(eventCluster); output.Events = output.Events.Take(3); return(output); }
public async Task <IActionResult> UpdateCustomGroup([FromBody] CustomGroupModel customGroup) { logger.LogInformation("Update custom group called"); //Ensure the current user is allowed to edit this template var customGroupItem = await _GroupsRepo.GetItemAsync(customGroup.Id); if (customGroupItem == null) { logger.LogError("Update custom group - Exception: Custom group with id {0} was not found.", customGroup.Id); return(StatusCode(StatusCodes.Status500InternalServerError)); } var groupDetails = _DeviceServiceDB.GetDevicesTwinInfoAsync(new DeviceQueryConfiguration() { ItemsPerPage = 1, Where = customGroup.Where }); customGroup.Count = groupDetails.ItemsCount; //Update Custom Group bool status = await _GroupsRepo.UpdateItemAsync(customGroup.Id, customGroup); if (!status) { logger.LogError("Update custom group - Exception: There was an error while updating the custom group {0}", customGroup.Id); return(StatusCode(StatusCodes.Status500InternalServerError)); } return(Ok(status)); }
/// <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)); }
public async Task <IActionResult> EditUserTemplate([FromBody] Template template) { Domain.Model.User currentUser = await EnsureCurrentUser(); string userId = currentUser.Id.ToLower(); //Ensure user values and unique ID are set server side. template.DocType = TemplateDocumentType.User; template.UserId = userId; template.ModifiedDate = DateTime.Now; //Ensure the current user is allowed to edit this template Template userTemplate = await _templateRepo.GetItemAsync(template.Id); if (userTemplate == null || userTemplate.UserId == null || userTemplate.UserId.ToLower() != userId) { logger.LogError("API EditUserTemplate error: Template with id {TemplateId} was found but the user {UserId} does not match.", template.Id, userId); return(StatusCode(StatusCodes.Status500InternalServerError)); } if (userTemplate.DocType != TemplateDocumentType.User) { logger.LogError("API EditUserTemplate error: Template with id {TemplateId} is not a user template.", template.Id, userId); return(StatusCode(StatusCodes.Status500InternalServerError)); } //Create new user template bool status = await _templateRepo.UpdateItemAsync(template.Id, template); if (!status) { Log.Error("API EditUserTemplate error: There was an error while creating the template {TemplateId}", template.Id); return(StatusCode(StatusCodes.Status500InternalServerError)); } return(Ok(status)); }
/// <summary> /// Update an action plan /// </summary> /// <param name="actionPlanObj">ActionPlanUpdateModel</param> /// <returns>ActionPlanModel</returns> public async Task <ActionPlanModel> UpdateActionPlan(ActionPlanUpdateModel actionPlanObj) { ActionPlanDAO plan = await _repoActionPlans.GetItemAsync(actionPlanObj.ActionPlanId); if (plan == null) { throw new Exception($"No action plan found that matches responseid: {actionPlanObj.ActionPlanId}"); } string etag = plan.ETag; DateTime creationDate = plan.CreationDate; plan = _mapper.Map <ActionPlanDAO>(actionPlanObj); plan.ETag = etag; plan.CreationDate = creationDate; try { await _repoActionPlans.UpdateItemAsync(plan); } catch (DocumentClientException e) { //Update concurrency issue, retrying if (e.StatusCode == HttpStatusCode.PreconditionFailed) { return(await UpdateActionPlan(actionPlanObj)); } throw e; } var output = _mapper.Map <ActionPlanModel>(plan); return(output); }
public async Task UpdateEvent(EventModel eventObj) { await _repoEvents.UpdateItemAsync(eventObj.Id, eventObj); if (_config.UseCache) { await GetEvent(eventObj.Id, true); } }
public async Task <DeliveryModel> UpdateDeliveryForEvent(string eventId, DeliveryModel delivery) { await _repoDeliveries.UpdateItemAsync(delivery.Id, delivery); if (_config.UseCache) { await GetDeliveryForEvent(eventId, delivery.DeliveryId, true); } return(await GetDeliveryForEvent(eventId, delivery.DeliveryId)); }
public async Task <ActionResult> EditAsync([Bind("Id,Name,Description,Completed")] Item item) { if (ModelState.IsValid) { await _cosmosDBRepository.UpdateItemAsync(item.Id, item); return(RedirectToAction("Index")); } return(View(item)); }
private async Task <bool> UpdateRegistrationUserInfo(string eventId, string locationId, string firstName, string lastName, string zipCode, RegistrationModel registration) { try { if (registration.Events.Find(p => p.EventId == eventId && p.LocationId == locationId) != null && string.Equals(registration.FirstName, firstName) && string.Equals(registration.LastName, lastName) && string.Equals(registration.ZipCode, zipCode)) { // no change to the registration return(true); } if (registration.Events.Find(p => p.EventId == eventId && p.LocationId == locationId) == null) { registration.Events.Add(CreateNewRegistrationEvent(eventId, locationId)); } registration.FirstName = firstName; registration.LastName = lastName; registration.ZipCode = zipCode; return(await _repoRegistrations.UpdateItemAsync(registration.Id, registration)); } catch (DocumentClientException dCE) { if (dCE.StatusCode == HttpStatusCode.PreconditionFailed) { registration = await _repoRegistrations.GetItemAsync(registration.Id); return(await UpdateRegistrationUserInfo(eventId, locationId, firstName, lastName, zipCode, registration)); } throw new Exception(dCE.Message, dCE); } catch (Exception e) { throw new Exception(e.Message, e); } }
private async Task SaveUpdatedRoute(RouteModel route) { RouteModel prev = await _repoRoutes.GetItemAsync(p => p.RouteId == route.RouteId); if (prev == null) { await _repoRoutes.CreateItemAsync(route); } else { route.Id = prev.Id; await _repoRoutes.UpdateItemAsync(prev.Id, route); } }
public async Task <bool> AddConversationReference(ConversationReference conversationReference) { ChatUserSessionDAO newDAO = Mapper.Map <ChatUserSessionDAO>(conversationReference); ChatUserSessionDAO oldDAO = await _repoChatUserSessions.GetItemAsync(newDAO.Id); if (oldDAO == null) { string id = await _repoChatUserSessions.CreateItemAsync(newDAO); return(!string.IsNullOrEmpty(id)); } else { oldDAO.BotId = newDAO.BotId; oldDAO.BotName = newDAO.BotName; oldDAO.ChannelId = newDAO.ChannelId; oldDAO.ConversationId = newDAO.ConversationId; oldDAO.ServiceUrl = newDAO.ServiceUrl; oldDAO.Name = newDAO.Name; oldDAO.Role = newDAO.Role; try { return(await _repoChatUserSessions.UpdateItemAsync(oldDAO)); } catch (DocumentClientException e) { //Update concurrency issue, retrying if (e.StatusCode == HttpStatusCode.PreconditionFailed) { return(await AddConversationReference(conversationReference)); } throw e; } } }
public async Task <ChatReportModel> CreateOrUpdateChatReport(ChatReportLogCreationModel reportLogObj) { if (string.IsNullOrEmpty(reportLogObj.User?.Id)) { throw new Exception($"No userId found."); } ChatReportDAO reportDAO = await _repoChatReports.GetItemAsync(p => p.User.Id == reportLogObj.User.Id && p.EndDate.Value == null); //Create if (reportDAO == null) { return(await CreateChatReport(reportLogObj)); } //Update ReportLogDAOObject reportLogDAO = Mapper.Map <ReportLogDAOObject>(reportLogObj.Message); reportDAO.ReportLogs.Add(reportLogDAO); try { await _repoChatReports.UpdateItemAsync(reportDAO); } catch (DocumentClientException e) { //Update concurrency issue, retrying if (e.StatusCode == HttpStatusCode.PreconditionFailed) { return(await CreateOrUpdateChatReport(reportLogObj)); } throw e; } return(Mapper.Map <ChatReportModel>(reportDAO)); }
/// <summary> /// Set the safe status of a user /// </summary> /// <param name="response">ResponseDAO</param> /// <param name="userId">User Id</param> /// <param name="isSafe">True if the user is safe</param> /// <returns>true if the call succeeded</returns> public async Task <bool> SetSafeStatus(ResponseDAO response, string userId, bool isSafe) { try { if (response.SafeUsers == null) { response.SafeUsers = new List <string>(); } if (isSafe && !response.SafeUsers.Contains(userId)) { response.SafeUsers.Add(userId); } else if (!isSafe && response.SafeUsers.Contains(userId)) { response.SafeUsers.Remove(userId); } else { return(true); //no reason to update } await _repoResponses.UpdateItemAsync(response); return(true); } catch (DocumentClientException e) { //Update concurrency issue, retrying if (e.StatusCode == HttpStatusCode.PreconditionFailed) { response = await _repoResponses.GetItemAsync(response.Id); } return(await SetSafeStatus(response, userId, isSafe)); throw e; } }
public async Task <Patient> UpdateAsync(string id, Patient updatedpatient) { var item = await Respository.UpdateItemAsync(id, updatedpatient); return((Patient)(dynamic)item); }
public async Task <Doctor> UpdateAsync(string id, Doctor updateddoctor) { var item = await Respository.UpdateItemAsync(id, updateddoctor); return((Doctor)(dynamic)item); }
public async Task <Appointment> UpdateAsync(Guid id, Appointment updatedappointment) { var item = await Respository.UpdateItemAsync(id.ToString(), updatedappointment); return((Appointment)(dynamic)item); }