public async Task <ActionResult <IEnumerable <Message> > > GetMessagesBySeries(string series) { var selectedSeries = await _context.Series.FirstOrDefaultAsync(s => s.Name.ToLower() == series.ToLower()); if (selectedSeries == null) { return(NotFound()); } await _context.Entry(selectedSeries).Collection(s => s.Messages).LoadAsync(); selectedSeries.Messages = selectedSeries.Messages.OrderBy(m => m.Date); foreach (var message in selectedSeries.Messages) { await _context.Entry(message).Reference(m => m.Video).LoadAsync(); await _context.Entry(message).Reference(m => m.Audio).LoadAsync(); await _context.Entry(message).Reference(m => m.Notes).LoadAsync(); } var messages = selectedSeries.Messages.ToList(); if (messages == null) { return(NotFound()); } return(messages); }
public async Task <IActionResult> PutConversation(string id, Conversation conversation) { if (id != conversation._id) { return(BadRequest()); } _context.Entry(conversation).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ConversationExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutMessage([FromRoute] long id, [FromBody] Message message) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != message.MessageID) { return(BadRequest()); } _context.Entry(message).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MessageExists(id)) { return(NotFound()); } throw; } return(NoContent()); }
public async Task <IActionResult> PutMessage(int id, Message message) { if (id != message.ID) { return(BadRequest()); } _context.Entry(message).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MessageExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutMessage(UserBlocked message) { if (!message.messageType.Equals("UserBlocked")) { return(BadRequest()); } var data = await _context.Messages.FindAsync(message.data.UserId); if (data == null) { Notifiy(message.data.UserId, "No UserId Found"); return(NotFound()); } _context.Entry(data).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MessageExists(message.data.UserId)) { Notifiy(message.data.UserId, "No User Found"); return(NotFound()); } else { throw; } } Notifiy(message.data.UserId, "Updated"); return(Ok()); }
public async Task <IActionResult> PutUser(int id, User user) { if (id != user.Key) { return(BadRequest()); } _context.Entry(user).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public IHttpActionResult PutMessage(int id, Message message) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != message.Id) { return(BadRequest()); } db.Entry(message).State = EntityState.Modified; try { db.SaveChanges(); } catch (DbUpdateConcurrencyException) { if (!MessageExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task DeleteAsync(T item) { using (MessageContext db = new MessageContext(_options)) { DbSet <T> dbSet = db.Set <T>(); db.Entry(item).State = EntityState.Deleted; await db.SaveChangesAsync(); } }
public ActionResult Edit([Bind(Include = "Id,title,message,from,to")] Messages messages) { if (ModelState.IsValid) { db.Entry(messages).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(messages)); }
public ActionResult Edit(MessageModel messagemodel) { if (ModelState.IsValid) { db.Entry(messagemodel).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(messagemodel)); }
public ActionResult ModifyMessage() { int id = int.Parse(Request.Form["id"]); Message m = messageContext.messageLists.Find(id); String text = Request.Form["text"]; text = text.Replace("#lt;", "<"); text = text.Replace("#gt;", ">"); m.message_reply_content = text; if (ModelState.IsValid) { messageContext.Entry(m).State = EntityState.Modified; messageContext.SaveChanges(); } return(Content("修改成功")); }
public ActionResult Edit([Bind(Include = "Mid,Name")] Message message) { if (ModelState.IsValid) { db.Entry(message).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(message)); }
public async Task <ActionResult> Edit([Bind(Include = "Id,MesaggeTime,MessageUser")] Message message) { if (ModelState.IsValid) { db.Entry(message).State = EntityState.Modified; await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(message)); }
public async Task <IActionResult> PutMessageBoard(long id, MessageBoard messageBoard) { System.Security.Claims.ClaimsPrincipal currentUser = this.User; bool IsModerator = currentUser.IsInRole("Moderator"); // var currmsg = await _context.Messages.FindAsync(id); if (id != messageBoard.Id) { return(BadRequest()); } // if (messageBoard.flagged != currmsg.flagged && !IsModerator) if (messageBoard.Flagged == true && !IsModerator) { return(StatusCode(StatusCodes.Status203NonAuthoritative, new Response { Status = "Error", Message = " Flag modification not allowed(Only Moderator can update flag)" })); } _context.Entry(messageBoard).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MessageBoardExists(id)) { return(NotFound()); } else { throw; } } return(Ok(new Response { Status = "Success", Message = "Record Updated Successfully" })); }
private async Task <BaseResponse <BaseMessage> > import(BaseMessage message) { var response = BaseResponseFactory <BaseMessage> .CreateDefaultBaseResponse(); using (var transaction = await _context.Database.BeginTransactionAsync()) { if (message == null) { _logger.LogInformation("Parameter is null"); response.Errors.Add(new ApiError { description = "Parameter is null" }); return(response); } if (!message.Valid) { _logger.LogInformation("Message {Id} is not valid by provider, so we cannot process it", message.Id); response.Errors.Add(new ApiError { description = "Message is not valid by provider, so we cannot process it" }); return(response); } if (message is MailgunMessage) { var mailgunMessage = (MailgunMessage)message; Mail newMail = null; try { newMail = await _context.Mails .AsNoTracking() .FirstOrDefaultAsync(e => e.BaseMessageId == message.Id); if (newMail == null) { newMail = new Mail(message); await _context.Mails.AddAsync(newMail); await _context.SaveChangesAsync(); } if (newMail.Retries <= 0) { _logger.LogError("Too many reprocessed"); return(response); } bool recipientEmpty = mailgunMessage.Recipient != null?mailgunMessage.Recipient.Equals(string.Empty) : true; bool toEmpty = mailgunMessage.To != null? mailgunMessage.To.Equals(string.Empty) : true; if (recipientEmpty && toEmpty) { _logger.LogInformation("recipient and to email headers are empty"); response.Errors.Add(new ApiError { description = "recipient and to email headers are empty" }); return(response); } var toRecipient = !recipientEmpty ? new MailAddress(mailgunMessage.Recipient) : new MailAddress(mailgunMessage.To); var domainFound = await _domainService.get(toRecipient.Host); if (domainFound == null) { var errorMessage = string.Format("message id: {0} the domain {1} was not found", message.Id, toRecipient.Host); await SetMailError(newMail, errorMessage); _logger.LogError(errorMessage); response.Errors.Add(new ApiError { description = "Domain not found" }); return(response); } var mailboxFound = await _mailboxService.GetMailbox(toRecipient.Address); if (mailboxFound == null) { var newMailbox = _mailboxService.CreateDefaultMailbox(toRecipient, domainFound); mailboxFound = await _mailboxService.CreateMailbox(newMailbox); } var mail = _mapper.Map <Mail>(mailgunMessage); mail.Id = newMail.Id; mail.BaseMessageId = newMail.BaseMessageId; _context.Entry(newMail).State = EntityState.Detached; if (mail.Attachments.NotEmpty()) { var jsonAttachments = mail.Attachments.Replace("\\\"", "\""); var attachments = JsonConvert.DeserializeObject <MailAttachment[]>(jsonAttachments); ICollection <Task <MailAttachment> > getFiles = new List <Task <MailAttachment> >(); attachments.ToList().ForEach(async e => { e = await _mailgunAttachment.get(e); e.MailId = mail.Id; e.Id = Guid.NewGuid(); await _context.AddAsync(e); }); await _context.SaveChangesAsync(); mail.MailAttachmentsJobStatus = JobStats.Done; } mail.ErrorMessage = string.Empty; mail.ErrorDate = null; mail.NextRetry = null; mail.JobStats = JobStats.Done; mail.MailAttachmentsJobStatus = JobStats.Done; _context.Mails.Update(mail); await _context.SaveChangesAsync(); transaction.Commit(); } catch (Exception exception) { transaction.Rollback(); var errorMessage = string.Format("{0} - {1}", exception.Message, exception.StackTrace); await SetMailError(newMail, errorMessage); _logger.LogError(errorMessage); response.Errors.Add(new ApiError { description = errorMessage }); } } } return(response); }
public void UpdateCustomer(Customer Customer) { _context.Entry(Customer).State = EntityState.Modified; }