/// <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)); }
/// <summary> /// Create a new response /// </summary> /// <param name="responseObj">ResponseCreationModel</param> /// <returns>ResponseModel</returns> public async Task <ResponseModel> CreateResponse(ResponseCreationModel responseObj) { //Instantiate the actions InstantiateResponseActions(responseObj.ActionPlan.OpenActions); InstantiateResponseActions(responseObj.ActionPlan.CloseActions); ResponseDAO response = new ResponseDAO() { ActionPlan = _mapper.Map <ResponseActionPlanDAOObject>(responseObj.ActionPlan), ResponderUserId = responseObj.ResponderUserId, ResponseState = RESPONSE_STATE_ACTIVE, PrimaryEventClusterId = responseObj.PrimaryEventClusterId, Geolocation = _mapper.Map <GeolocationDAOObject>(responseObj.Geolocation) }; response.Id = await _repoResponses.CreateItemAsync(response); if (_repoResponses.IsDocumentKeyNull(response)) { throw new Exception($"An error occured when creating a new response"); } ResponseModel output = _mapper.Map <ResponseModel>(response); return(output); }
/// <summary> /// Create a notification /// </summary> /// <param name="notification">NotificationCreationModel</param> /// <returns>NotificationModel</returns> public async Task <NotificationModel> CreateNotification(NotificationCreationModel notification) { var date = DateTime.UtcNow; NotificationDAO notificationDao = new NotificationDAO() { NotificationText = notification.NotificationText, CreationDate = date, UpdateDate = date, ResponseId = notification.ResponseId.ToString(), Status = notification.Status, Tags = notification.Tags, Title = notification.Title, User = notification.User }; notificationDao.Id = await _repoNotifications.CreateItemAsync(notificationDao); if (_repoNotifications.IsDocumentKeyNull(notificationDao)) { throw new Exception($"An error occured when creating a new notification"); } NotificationModel output = _mapper.Map <NotificationModel>(notificationDao); return(output); }
/// <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 async Task InitializeDB() { ConsoleHelper.WriteInfo($"Create Saga Collection"); await _repoSagas.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create Bot Collection"); await _repoBot.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create ChatReports Collection"); await _repoChatReports.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create Devices Collection"); await _repoDevices.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create Responses Collection"); await _repoResponses.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create EventClusters Collection"); await _repoEventClusters.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create Notifications Collection"); await _repoNotifications.EnsureDatabaseAndCollectionExists(); ConsoleHelper.WriteInfo($"Create ActionPlans Collection"); await _repoActionPlans.EnsureDatabaseAndCollectionExists(); foreach (var actionPlanDAO in ActionPlanDB.GetActionPlans()) { await _repoActionPlans.CreateItemAsync(actionPlanDAO); } await Task.Delay(5000); }
public async Task <Doctor> CreateAsync(Doctor newdoctor) { newdoctor.CreatedDate = DateTime.UtcNow; newdoctor.EntityId = Guid.NewGuid(); var item = await Respository.CreateItemAsync(newdoctor, newdoctor.Speciality.Id); return((Doctor)(dynamic)item); }
public async Task <Patient> CreateAsync(Patient newpatient) { newpatient.CreatedDate = DateTime.UtcNow; newpatient.EntityId = Guid.NewGuid(); newpatient.Address.EntityId = Guid.NewGuid(); var item = await Respository.CreateItemAsync(newpatient, newpatient.Address.ZipCode); return((Patient)(dynamic)item); }
private async Task CreateTemplateDocument(ICosmosDBRepository <Template> templateRepository, Template template) { Template templateObj = await templateRepository.GetItemAsync(template.Id); if (templateObj == null) { await templateRepository.CreateItemAsync(template); } }
private async Task CreateCategoryDocument(ICosmosDBRepository <Category> categoryRepository, Category category) { Category categoryObj = await categoryRepository.GetItemAsync(category.Id); if (categoryObj == null) { await categoryRepository.CreateItemAsync(category); } }
public async Task <Appointment> CreateAsync(Appointment newappointment) { newappointment.CreatedDate = DateTime.UtcNow; newappointment.HasConflict = false; newappointment.EntityId = Guid.NewGuid(); var item = await Respository.CreateItemAsync(newappointment, newappointment.DoctorId); return((Appointment)item); }
public async Task <string> CreateNoteTemplate(NoteTemplateModel noteTemplate) { string result = await _repoNoteTemplates.CreateItemAsync(noteTemplate); if (_config.UseCache) { await GetNotesFromEvent(noteTemplate.EventId, true); } return(result); }
public async Task <ActionResult> CreateAsync([Bind("Id,Name,Description,Completed")] Item item) { if (ModelState.IsValid) { await _cosmosDBRepository.CreateItemAsync(item); return(RedirectToAction("Index")); } return(View(item)); }
public async Task <DeliveryModel> CreateDeliveryForEvent(string eventId, DeliveryModel delivery) { await _repoDeliveries.CreateItemAsync(delivery); if (_config.UseCache) { await GetDeliveriesForEvent(eventId, true); } return(await GetDeliveryForEvent(eventId, delivery.DeliveryId)); }
public static async Task Run( EventGridEvent eventGridEvent, ICosmosDBRepository <Item> cosmosDBRepository, ILogger log) { log.LogInformation("TodoFunction function started processing a request."); log.LogInformation(eventGridEvent.Data.ToString()); var item = JsonConvert.DeserializeObject <Item>(eventGridEvent.Data.ToString()); cosmosDBRepository.Initialize(); await cosmosDBRepository.CreateItemAsync(item); }
/// <summary> /// Create an action plan /// </summary> /// <param name="actionPlanObj">ActionPlanCreationModel</param> /// <returns>ActionPlanModel</returns> public async Task <ActionPlanModel> CreationActionPlan(ActionPlanCreationModel actionPlanObj) { ActionPlanDAO plan = _mapper.Map <ActionPlanDAO>(actionPlanObj); plan.Id = await _repoActionPlans.CreateItemAsync(plan); if (_repoActionPlans.IsDocumentKeyNull(plan)) { throw new Exception($"An error occured when creating a new action plan"); } return(_mapper.Map <ActionPlanModel>(plan)); }
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); } }
private async Task <string> CreateNewRegistration(string eventId, string locationId, string email, string firstName, string lastName, string zipCode) { string newId = await _repoRegistrations.CreateItemAsync(new RegistrationModel() { Email = email, FirstName = firstName, LastName = lastName, ZipCode = zipCode, Events = new List <RegistrationEventModel>() { CreateNewRegistrationEvent(eventId, locationId) } }); return(newId); }
public async Task <ChatReportModel> CreateChatReport(ChatReportLogCreationModel reportLogObj) { ReportLogDAOObject reportLogDAO = Mapper.Map <ReportLogDAOObject>(reportLogObj.Message); ChatReportDAO newReportDAO = new ChatReportDAO() { ChannelId = reportLogObj.ChannelId, ReportLogs = new List <ReportLogDAOObject>() { reportLogDAO }, User = Mapper.Map <ChatUserDAOObject>(reportLogObj.User) }; newReportDAO.Id = await _repoChatReports.CreateItemAsync(newReportDAO); if (string.IsNullOrEmpty(newReportDAO.Id)) { throw new Exception($"An error occured when creating a new chat report: {reportLogObj.User.Id}"); } return(Mapper.Map <ChatReportModel>(newReportDAO)); }
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 <string> CreateEvent(EventModel eventObj) { eventObj.EventLocations = new List <EventLocationModel>() { new EventLocationModel() { Id = "Location1", Goal = 1000, LocationName = "Room 1" } }; eventObj.EventSentiments = new List <EventSentimentModel>() { new EventSentimentModel() { Name = "Sentiment1" }, new EventSentimentModel() { Name = "Sentiment2" }, new EventSentimentModel() { Name = "Sentiment3" } }; eventObj.EventViews = new List <EventViewModel>(); eventObj.PayPalApi = new EventPayPalApiModel(); eventObj.PayPalApi.MerchantInfo = new PayPalMerchantInfo(); string result = await _repoEvents.CreateItemAsync(eventObj); if (_config.UseCache) { await GetEvent(result, true); } return(result); }
public async Task <IActionResult> CreateUserTemplate([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.BaseTemplateId = template.Id; template.Id = Guid.NewGuid().ToString(); template.DocType = TemplateDocumentType.User; template.UserId = userId; template.CreationDate = DateTime.Now; template.ModifiedDate = DateTime.Now; //Create new user template string newId = await _templateRepo.CreateItemAsync(template); if (string.IsNullOrEmpty(newId)) { logger.LogError("API CreateUserTemplate error: There was an error while creating the template {TemplateName}", template.Name); return(StatusCode(StatusCodes.Status500InternalServerError)); } return(Ok(newId)); }
public async Task <IActionResult> CreateCustomGroup([FromBody] CustomGroupModel customGroup) { logger.LogInformation("Create custom group called"); //New Guid customGroup.Id = Guid.NewGuid().ToString(); customGroup.Count = 0; //Get number of custom groups IEnumerable <CustomGroupModel> customGroupsEnum = await _GroupsRepo.GetItemsAsync(); if (customGroupsEnum != null) { List <CustomGroupModel> customGroups = new List <CustomGroupModel>(); IEnumerator <CustomGroupModel> enumator = customGroupsEnum.GetEnumerator(); while (enumator.MoveNext()) { customGroups.Add(enumator.Current); } customGroup.Order = customGroups.Count; } { customGroup.Order = 0; } //Create new user template string newId = await _GroupsRepo.CreateItemAsync(customGroup); if (string.IsNullOrEmpty(newId)) { logger.LogError("Create custom group - Exception: {0}", customGroup.Name); return(StatusCode(StatusCodes.Status500InternalServerError)); } return(Ok(newId)); }
public void Post([FromBody] models.product value) { _cosmosDBRepository.CreateItemAsync(value).Wait(); }