public override void OnDelete(DeleteMessage message) { if (message.Reason != MediaFiles.DeleteMediaFileReason.Upgrade) { _traktService.RemoveMovieFromCollection(Settings, message.Movie, message.MovieFile); } }
private Task DeleteFile(FileInfo fileInfo) { var message = new DeleteMessage(fileInfo.Name); _messageCollection.Add(message, _cancellationToken); return(Task.FromResult(0)); }
public ActionResult DeleteMessage(int messageId, int groupId) { var action = new DeleteMessage(_db, groupId, Requester(), messageId); action.Execute(); return(RedirectToAction("Messages", new { id = groupId })); }
public void Multiple_Local_Services_Should_Be_Available() { ManualResetEvent _updateEvent = new ManualResetEvent(false); LocalBus.Subscribe <UpdateMessage>(msg => _updateEvent.Set()); ManualResetEvent _deleteEvent = new ManualResetEvent(false); LocalBus.Subscribe <DeleteMessage>( delegate { _deleteEvent.Set(); }); DeleteMessage dm = new DeleteMessage(); LocalBus.Publish(dm); UpdateMessage um = new UpdateMessage(); LocalBus.Publish(um); Assert.That(_deleteEvent.WaitOne(TimeSpan.FromSeconds(4), true), Is.True, "Timeout expired waiting for message"); Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(4), true), Is.True, "Timeout expired waiting for message"); }
public void Multiple_messages_should_be_delivered_to_the_appropriate_remote_subscribers() { ManualResetEvent _updateEvent = new ManualResetEvent(false); RemoteBus.Subscribe <UpdateMessage>( delegate { _updateEvent.Set(); }); ManualResetEvent _deleteEvent = new ManualResetEvent(false); RemoteBus.Subscribe <DeleteMessage>( delegate { _deleteEvent.Set(); }); DeleteMessage dm = new DeleteMessage(); LocalBus.Publish(dm); UpdateMessage um = new UpdateMessage(); LocalBus.Publish(um); Assert.That(_deleteEvent.WaitOne(TimeSpan.FromSeconds(6), true), Is.True, "Timeout expired waiting for message"); Assert.That(_updateEvent.WaitOne(TimeSpan.FromSeconds(6), true), Is.True, "Timeout expired waiting for message"); }
protected void DeleteInstance_Click(object sender, EventArgs e) { if (ReportViewControl.SelectedRowIndex != -1) { DeleteMessage.Show(); } }
public string SubjectDelete([FromUri] string applicationId, [FromUri] string subjectId, [FromUri] string emailAddress) { try { GDPRMessage msg = new GDPRMessage(); DeleteMessage dm = new DeleteMessage(); dm.ApplicationId = applicationId; dm.ApplicationSubjectId = subjectId; dm.Direction = "in"; msg = dm; GDPRSubject s = new GDPRSubject(); s.Email = emailAddress; msg.Subject = s; MasterGDPRHelper.SendMessage(msg); } catch { return("Failure"); } return("Success"); }
void PropagateRequest(DeleteMessage request) { var client = new RestClient(request.Cooperator); var requestToSend = new RestRequest($"queues/{request.QueueName}/messages/{request.MessageId}", Method.DELETE); client.Execute(requestToSend); }
void ForceDelete(IDbConnection connection, DeleteMessage request) { connection.UpdateOnly(new QueueMessage { Readed = true }, message => new { message.Readed }, message => message.Id == request.MessageId); }
public Task Run() { Core.Instance.Log.InfoFormat("Starting DeleteFileProtocol: {0}", _fileEntry); return(Task.Factory.StartNew(() => { var msg = new DeleteMessage(_fileEntry.GetFileId()); Core.Instance.MCChannel.Send(msg); })); }
private void OnIngredientDeleted(DeleteMessage <IngredientWrapper> message) { var ingredient = IngredientDetailViewModels.SingleOrDefault(i => i.Model.Id == message.Id); if (ingredient != null) { IngredientDetailViewModels.Remove(ingredient); } }
private void OnRecipeDeleted(DeleteMessage <RecipeWrapper> message) { var recipe = RecipeDetailViewModels.SingleOrDefault(i => i.Model.Id == message.Id); if (recipe != null) { RecipeDetailViewModels.Remove(recipe); } }
public void Should_throw_error_when_message_is_not_found() { var cmd = new DeleteMessage { MessageId = 999 }; Assert.That(() => Repository.Execute(cmd), Throws.TypeOf <DomainException>().With.Message.EqualTo($"Message with ID {999} was not found")); }
public Task <Unit> Handle(DeleteMessage request, CancellationToken cancellationToken) { if (request is null) { throw new ArgumentNullException(nameof(request)); } return(DeleteMessageInternalAsync(request.MesssageId, cancellationToken)); }
// methods private DeleteFlags BuildDeleteFlags(DeleteMessage message) { var flags = DeleteFlags.None; if (!message.IsMulti) { flags |= DeleteFlags.Single; } return flags; }
// methods private DeleteFlags BuildDeleteFlags(DeleteMessage message) { var flags = DeleteFlags.None; if (!message.IsMulti) { flags |= DeleteFlags.Single; } return(flags); }
public void Should_throw_error_when_message_id_is_invalid(int id) { new MessageBuilder().With(cr => cr.Id, id) .BuildAndSave(); var cmd = new DeleteMessage { MessageId = id }; Assert.That(() => Repository.Execute(cmd), Throws.TypeOf <DomainException>().With.Message.EqualTo("Message Id must be greater than 0")); }
/// <summary> /// A client can send this request to delete a message from a DECT phone. /// If the message which has to be deleted is still buffered in the OMM, it is removed from the queue, in this case this request has the same semantic as <see cref="CancelMessageAsync"/>. /// If the request is accepted by the OMM, it is put into the same queue as a message which had to be sent would have been put. /// The response to this request is always sent immediately, but it will take a while until the delete request can be actually forwarded to a DECT phone. /// For that reason the progress of deleting a message is reported using Events /// </summary> /// <param name="id">Message ID.</param> /// <param name="sendTime">Original send time of the message to be deleted.</param> /// <param name="toAddr">Recipient address of the message to be deleted. Must have the same scheme as the original message (e.g. "tel:" or "ppn:").</param> /// <param name="cancellationToken"></param> /// <returns></returns> public Task DeleteMessageAsync(uint id, uint sendTime, string toAddr, CancellationToken cancellationToken) { var delete = new DeleteMessage { Id = id, SendTime = sendTime, ToAddr = toAddr }; return(SendAsync <DeleteMessage, DeleteMessageResp>(delete, cancellationToken)); }
public async Task <bool> DeleteMessageAsync(DeleteMessage deleteMessage) { try { return(await _AWSSQSHelper.DeleteMessageAsync(deleteMessage.ReceiptHandle)); } catch (Exception ex) { throw ex; } }
public async Task Execute(IJobExecutionContext context) { _logger.LogInformation("__________Let's delete_______________"); var mesage = new DeleteMessage() { Message = "Let's delete" }; await _publisher.PublishDeleteMessage(mesage); }
private void onDeleteStatus(DeleteMessage deleteMessage) { try { using (var context = new TwitterContext()) { context.Upsert(new DeleteEvent(deleteMessage.UserId, deleteMessage.Id, deleteMessage.Timestamp.LocalDateTime, null, DeleteEventType.Status)); context.Upsert(new ActiveTime(deleteMessage.UserId, deleteMessage.Timestamp.LocalDateTime)); context.SaveChanges(); } } catch (Exception e) { Console.Out.WriteLine($"onDeleteStatus : {e.Message}"); } }
/// <summary> /// Deletes documents from the collection according to the spec. /// </summary> /// <remarks>An empty document will match all documents in the collection and effectively truncate it. /// </remarks> public void Delete(Document selector) { DeleteMessage dm = new DeleteMessage(); dm.FullCollectionName = this.FullName; dm.Selector = selector; try{ this.connection.SendMessage(dm); }catch (IOException ioe) { throw new MongoCommException("Could not delete document, communication failure", this.connection, ioe); } }
public void displayAttacks() { if (ScanningKiddie.attackCountered == false && ScanningKiddie.attackEffect != "") { attackDisplayed.text = " WARNING : " + ScanningKiddie.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (PhishingKiddie.attackCountered == false && PhishingKiddie.attackEffect != "") { attackDisplayed.text = " WARNING : " + PhishingKiddie.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (MafiaAPTPCOffices.attackCountered == false && MafiaAPTPCOffices.attackEffect != "") { attackDisplayed.text = " WARNING : " + MafiaAPTPCOffices.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (MafiaAPTServerOffices.attackCountered == false && MafiaAPTServerOffices.attackEffect != "") { attackDisplayed.text = " WARNING : " + MafiaAPTServerOffices.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (MafiaAPTServerPlant.attackCountered == false && MafiaAPTServerPlant.attackEffect != "") { attackDisplayed.text = " WARNING : " + MafiaAPTServerPlant.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (MafiaDisruptionController.attackCountered == false && MafiaDisruptionController.attackEffect != "") { attackDisplayed.text = " WARNING : " + MafiaDisruptionController.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (HackingKiddie.attackCountered == false && HackingKiddie.attackEffect != "") { attackDisplayed.text = " WARNING : " + HackingKiddie.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } if (DoSKiddie.attackCountered == false && DoSKiddie.attackEffect != "") { attackDisplayed.text = " WARNING : " + DoSKiddie.attackEffect + " " + attackDisplayed.text; attackDisplayed.gameObject.SetActiveRecursively(true); StartCoroutine(DeleteMessage.coroutineD()); } }
void TryDelete(IDbConnection connection, DeleteMessage request) { var firstMessageInQueue = connection.FirstOrDefault(FirstMessageQuery.make(connection)); if (firstMessageInQueue == null || firstMessageInQueue.Id != request.MessageId) { throw new ArgumentException("Provided message was not first in queue"); } firstMessageInQueue.Readed = true; connection.Update(firstMessageInQueue); Propagators.ScheduleQueueOperation(request.QueueName, () => PropagateRequest(request)); }
public void WriteMessage_should_encode_flags_correctly(int flags, bool isMulti) { var message = new DeleteMessage(__requestId, __collectionNamespace, __query, isMulti); using (var stream = new MemoryStream()) { var subject = new DeleteMessageBinaryEncoder(stream, null); subject.WriteMessage(message); var bytes = stream.ToArray(); bytes[__flagsOffset].Should().Be((byte)flags); } }
// static constructor static DeleteMessageJsonEncoderTests() { __testMessage = new DeleteMessage(__requestId, __collectionNamespace, __query, __isMulti); __testMessageJson = "{ " + "\"opcode\" : \"delete\", " + "\"requestId\" : 1, " + "\"database\" : \"d\", " + "\"collection\" : \"c\", " + "\"query\" : { \"x\" : 1 }, " + "\"isMulti\" : false" + " }"; }
public void Should_throw_error_when_message_not_owned_by_player_is_not_found() { new MessageBuilder() .With(m => m.Id, 61) .With(m => m.Receiver, new PlayerBuilder() .With(p => p.Id, 3).BuildAndSave()) .BuildAndSave(); var cmd = new DeleteMessage { MessageId = 61, OwnerId = 4 }; Assert.That(() => Repository.Execute(cmd), Throws.TypeOf <DomainException>().With.Message.EqualTo("Message 61 not owned by player 4")); }
public void Should_throw_error_when_owner_not_set() { new MessageBuilder() .With(m => m.Id, 61) .With(m => m.Receiver, new PlayerBuilder() .With(p => p.Id, 3).BuildAndSave()) .BuildAndSave(); var cmd = new DeleteMessage { MessageId = 61 }; Assert.That(() => Repository.Execute(cmd), Throws.TypeOf <DomainException>().With.Message.EqualTo("OwnerId is required to delete a message")); }
private void OnFilmDeleted(DeleteMessage <FilmWrapper> message) { var film = FilmDetailViewModels.SingleOrDefault(i => i.Model.Id == message.Id); if (film != null) { FilmDetailViewModels.Remove(film); if (FilmDetailViewModels.Any()) { _mediator.Send(new SelectedMessage <FilmWrapper> { Id = FilmDetailViewModels.Last().Model.Id }); } } }
private static async Task ContactUs(TelegramBotAbstract telegramBotClient, MessageEventArgs e) { await DeleteMessage.DeleteIfMessageIsNotInPrivate(telegramBotClient, e); var lang2 = new Language(new Dictionary <string, string> { { "it", telegramBotClient.GetContactString() }, { "en", telegramBotClient.GetContactString() } }); await telegramBotClient.SendTextMessageAsync(e.Message.Chat.Id, lang2, e.Message.Chat.Type, e.Message.From.LanguageCode, ParseMode.Default, new ReplyMarkupObject(ReplyMarkupEnum.REMOVE), e.Message.From.Username ); }
private void OnPersonDeleted(DeleteMessage <PersonWrapper> message) { var person = PersonDetailViewModels.SingleOrDefault(i => i.Model.Id == message.Id); if (person != null) { PersonDetailViewModels.Remove(person); if (PersonDetailViewModels.Any()) { _mediator.Send(new SelectedMessage <PersonWrapper> { Id = PersonDetailViewModels.Last().Model.Id }); } } }
/// <summary> /// Writes the message. /// </summary> /// <param name="message">The message.</param> public void WriteMessage(DeleteMessage message) { Ensure.IsNotNull(message, nameof(message)); var messageDocument = new BsonDocument { { "opcode", "delete" }, { "requestId", message.RequestId }, { "database", message.CollectionNamespace.DatabaseNamespace.DatabaseName }, { "collection", message.CollectionNamespace.CollectionName }, { "query", message.Query ?? new BsonDocument() }, { "isMulti", message.IsMulti } }; var jsonWriter = CreateJsonWriter(); var messageContext = BsonSerializationContext.CreateRoot(jsonWriter); BsonDocumentSerializer.Instance.Serialize(messageContext, messageDocument); }
/// <summary> /// Writes the message. /// </summary> /// <param name="message">The message.</param> public void WriteMessage(DeleteMessage message) { Ensure.IsNotNull(message, "message"); var binaryWriter = CreateBinaryWriter(); var stream = binaryWriter.BsonStream; var startPosition = stream.Position; stream.WriteInt32(0); // messageSize stream.WriteInt32(message.RequestId); stream.WriteInt32(0); // responseTo stream.WriteInt32((int)Opcode.Delete); stream.WriteInt32(0); // reserved stream.WriteCString(message.CollectionNamespace.FullName); stream.WriteInt32((int)BuildDeleteFlags(message)); var context = BsonSerializationContext.CreateRoot(binaryWriter); BsonDocumentSerializer.Instance.Serialize(context, message.Query ?? new BsonDocument()); stream.BackpatchSize(startPosition); }
public abstract DeleteMessage OnDeleteDestructive(DeleteMessage mes);
public abstract void OnDelete(DeleteMessage mes);
public override void OnDelete(DeleteMessage mes) { try { if (hasid == null) { hasid = scope.TryGetVariable("OnDelete", out id); } if (hasid ?? false) id(mes); } catch (Exception e) { ins.LogError("プラグイン " + Name + "でエラーが発生しました : " + e.Message); ins.SaveLog(); } }
public override DeleteMessage OnDeleteDestructive(DeleteMessage mes) { try { if (hasidD == null) { hasidD = scope.TryGetVariable("OnDeleteDestructive", out idD); } if (hasidD ?? false) { return idD(mes); } else { return mes; } } catch (Exception e) { ins.LogError("プラグイン " + Name + "でエラーが発生しました : " + e.Message); ins.SaveLog(); return mes; } }
public override void OnDelete(DeleteMessage mes) { try { var f = lua["OnDelete"] as Action<DeleteMessage>; if (f != null) f(mes); } catch (Exception e) { ins.LogError("プラグイン " + Name + "でエラーが発生しました : " + e.Message); ins.SaveLog(); } }
private void Process(DeleteMessage deleteMessage) { this._ExchangeDataManager.ProcessDeleteMessage(deleteMessage); }
public override DeleteMessage OnDeleteDestructive(DeleteMessage mes) { try { var f = lua["OnDeleteDestructive"] as Func<DeleteMessage, DeleteMessage>; if (f != null) { return f(mes); } else { return mes; } } catch (Exception e) { ins.LogError("プラグイン " + Name + "でエラーが発生しました : " + e.Message); ins.SaveLog(); return mes; } }
public async void DeleteNote(DeleteMessage message) { var dialog = new MessageDialog("Do you want to remove this note?"); dialog.Title = "Confirmation"; dialog.Commands.Add(new UICommand { Label = "Delete", Id = 0 }); dialog.Commands.Add(new UICommand { Label = "Cancel", Id = 1 }); var res = await dialog.ShowAsync(); if ((int)res.Id == 0) { await dataService.DeleteNote(message.Content); RaisePropertyChanged(nameof(Notes)); } }
private static Message Convert(string exchangeCode, DeleteCommand deleteCommand) { List<Transaction> transactionList = new List<Transaction>(); List<Order> orderList = new List<Order>(); List<OrderRelation> orderRelationList = new List<OrderRelation>(); XmlNode transactionNodes = deleteCommand.Content["AffectedOrders"]; if (transactionNodes != null) { foreach (XmlNode transactionNode in transactionNodes.ChildNodes) { Transaction[] transactions; Order[] orders; OrderRelation[] orderRelations; CommandConvertor.Parse(exchangeCode,transactionNode, out transactions, out orders, out orderRelations); transactionList.AddRange(transactions); orderList.AddRange(orders); orderRelationList.AddRange(orderRelations); } } Guid deletedOrderId = Guid.Empty; Guid accountId = Guid.Empty; Guid instrumentId = Guid.Empty; XmlNode deletedOrderNode = deleteCommand.Content["DeletedOrder"]; if (deletedOrderNode != null) { deletedOrderId = new Guid(deletedOrderNode.Attributes["ID"].Value); instrumentId = new Guid(deletedOrderNode.Attributes["InstrumentID"].Value); accountId = new Guid(deletedOrderNode.Attributes["AccountID"].Value); } DeleteMessage deleteMessage = new DeleteMessage(exchangeCode,deletedOrderId,instrumentId, transactionList.ToArray(), orderList.ToArray(), orderRelationList.ToArray()); return deleteMessage; }