public void makeAll_MessageWithGroupRSPK11Created_MessageDefinitionGiven() { // Arrange var baseFolder = GetBaseFolder(); var version = GetVersion(); var source = new MessageProviderMock(); var messageTargetFolder = GetTargetFolder("Message"); var groupTargetFolder = GetTargetFolder("Group"); var message = new MessageDefinitionContainerMock(); message.Message = "RSP_K11"; message.Chapter = "5.3.1.2"; // Refer to page 5-16 of V2.5/CH05.pdf on how the below structure was message.Segments.Add(new SegmentDef("MSH", "", true, false, "Message Header")); message.Segments.Add(new SegmentDef("SFT", "", false, true, "Software Segment")); message.Segments.Add(new SegmentDef("MSA", "", true, false, "Message Acknowledgment")); message.Segments.Add(new SegmentDef("ERR", "", false, false, "Error")); message.Segments.Add(new SegmentDef("QAK", "", true, false, "Query Acknowledgment")); message.Segments.Add(new SegmentDef("QPD", "", true, false, "Query Parameter Definition")); message.Segments.Add(new SegmentDef("[", "ROW_DEFINITION", true, false, "")); message.Segments.Add(new SegmentDef("RDF", "", true, false, "Table Row Definition")); message.Segments.Add(new SegmentDef("RDT", "", false, true, "Table Row Data")); message.Segments.Add(new SegmentDef("]", "ROW_DEFINITION", true, false, "")); message.Segments.Add(new SegmentDef("DSC", "", false, false, "Continuation Pointer")); source.Messages.Add(message); DataProviderFactory.Instance.SetProvider(source); // Act MessageGenerator.makeAll(baseFolder, version); // Assert Assert.IsTrue(File.Exists($"{messageTargetFolder}RSP_K11.cs")); Assert.IsTrue(File.Exists($"{groupTargetFolder}RSP_K11_ROW_DEFINITION.cs")); }
public void GetRegistedClient() { MessageGenerator generator = new MessageGenerator("CLIENTS", this.name); generator.AddReceiver(this.dispatchServerName); base.Send(generator.GetMessage()); }
private static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Console() .WriteTo.File(@"\Logs\EventExperiment-Services.log", rollingInterval: RollingInterval.Day, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:u3}] {Message:lj} {NewLine}{Exception}") .CreateLogger(); Log.Logger.Information($"Welcome to the messaging service using events."); var messageGenerator = new MessageGenerator(Log.Logger); var messageService = new MessageService(Log.Logger); var messageTypeService = new MessageTypeSwitchService(Log.Logger); var eventContainer = new EventPubSubContainer(messageService, messageTypeService) .SetUpEventConnections(); Parallel.For(1, 100, (x) => { Log.Logger.Information($"Item: {x}."); var message = messageGenerator.GenerateNewMessage(); messageService.SendMessageEvent(message); var messageDetail = $"Type: {message.MessageTypes:G}, Messages: {string.Join(",", message.MessageList)}."; Log.Logger.Information(Constants.LogMessageTemplate, message.MessageId, "Program", "Main", messageDetail); }); Console.WriteLine("Press any key to continue."); Log.CloseAndFlush(); Console.ReadKey(); }
public void GenerateDirectory(List <string> inputDirectory, string inputPath, string outputPath) { OnLoadInfo(inputDirectory.Count); foreach (string str in inputDirectory) { string[] splited = (str.Replace(inputPath, outputPath)).Split('\\'); string directory = ""; for (int i = 0; i < splited.Length - 1; i++) { directory += splited[i].Substring(0, 1).ToUpper() + splited[i].Remove(0, 1) + "//"; } directory = directory.Remove(directory.Length - 1); directory = directory.Replace(inputPath, outputPath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } try { MessageParser parser = new MessageParser(File.ReadAllText(str, new UTF8Encoding())); MessageGenerator generator = new MessageGenerator(parser.GetClass(), directory); } catch { } OnFileTranslated(); } }
static void Main() { string input = File.ReadAllText(@"X:\Development\SoftUni\Files, Directories and Exceptions\Exercises\Advertisement Message\input.txt"); File.WriteAllText(@"X:\Development\SoftUni\Files, Directories and Exceptions\Exercises\Advertisement Message\outout.txt", MessageGenerator.GenerateMessages(int.Parse(input))); }
public void Unregister() { MessageGenerator generator = new MessageGenerator("UNREG", this.name); generator.AddReceiver(this.dispatchServerName); base.Send(generator.GetMessage()); }
public async Task <string> UpdateUnverifyAsync(SocketGuildUser user, SocketGuild guild, string time, SocketUser fromUser) { var task = Queue.Get <UnverifyBackgroundTask>(o => o.GuildId == guild.Id && o.UserId == user.Id); if (task == null) { throw new NotFoundException("Aktualizace času nelze pro hledaného uživatele provést. Unverify nenalezeno."); } if (task.CanProcess() || (task.At - DateTime.Now).TotalSeconds < 30.0D) { throw new ValidationException("Aktualizace data a času již není možná. Vypršel čas, nebo zbývá méně, než půl minuty."); } var endDateTime = TimeParser.Parse(time, minimumMinutes: 10); await UnverifyLogger.LogUpdateAsync(DateTime.Now, endDateTime, guild, fromUser, user); var userEntity = await GrillBotRepository.UsersRepository.GetUserAsync(guild.Id, user.Id, UsersIncludes.Unverify); userEntity.Unverify.EndDateTime = endDateTime; userEntity.Unverify.StartDateTime = DateTime.Now; await GrillBotRepository.CommitAsync(); task.At = endDateTime; var pmMessage = MessageGenerator.CreateUpdatePMMessage(guild, endDateTime); await user.SendPrivateMessageAsync(pmMessage); return(MessageGenerator.CreateUpdateChannelMessage(user, endDateTime)); }
public void MergeMessages_ReturnsExpectedResult() { // Arrange var original = CheckResultsGenerator <object> .Generate(includeSuccess : true); // Keep this one for comparison. var result = (CheckResults <object>)original.Clone(); // Clone to working instance. result.Should().BeEquivalentTo(original); result.Should().NotBeSameAs(original); var input = new List <Message <object> > { MessageGenerator <object> .Generate(MessageLevel.Suggestion), MessageGenerator <object> .Generate(MessageLevel.Error), MessageGenerator <object> .Generate() }; // Act result.Merge(input); // Assert Assert.That(() => result.Should().BeEquivalentTo(original), Throws.TypeOf <AssertionException>()); Assert.That(result.Messages.Count, Is.EqualTo(original.Messages.Count + input.Count)); }
public override void Execute() { NHapi.Base.NormativeDatabase.Instance.OpenNewConnection(ConnectionString); Console.WriteLine("Using Database:{0}", NHapi.Base.NormativeDatabase.Instance.Connection.ConnectionString); Console.WriteLine("Base Path:{0}", BasePath); switch (MessageTypeToBuild) { case MessageType.All: SourceGenerator.makeAll(BasePath, Version); break; case MessageType.EventMapping: SourceGenerator.MakeEventMapping(BasePath, Version); break; case MessageType.Segment: SegmentGenerator.makeAll(BasePath, Version); break; case MessageType.Message: MessageGenerator.makeAll(BasePath, Version); break; } }
static void Main(string[] args) { if(args.Length != 4) { Console.WriteLine("usage: DeviceSender sb-namespace event-hub-name sas-policy sas-key"); return; } var details = new ConnectionDetails(args[0], args[1], args[2], args[3]); var deviceDetails = new DeviceSendingDetails() { FailureConditions = new[] { new FailedDeviceSettings(3, 0.1F), new FailedDeviceSettings(6, 0.2F), new FailedDeviceSettings(9, 0.3F), new FailedDeviceSettings(12, 0.05F), new FailedDeviceSettings(15, 0.07F), new FailedDeviceSettings(18, 0.15F), new FailedDeviceSettings(21, 0.25F) }, IterationSeconds = 30, NumberOfDevices = 50, TemperatureMax = 28.9F, TemperatureMin = 19.6F, MillisecondDelay = 1000 }; var generator = new MessageGenerator(deviceDetails); generator.SendMessages(details); Console.WriteLine("Finished sending all messages. Press any key to exit ..."); Console.Read(); }
public void Execute() { if (!string.IsNullOrEmpty(ConnectionString)) { ConfigurationSettings.ConnectionString = ConnectionString; } Console.WriteLine("Using Database:{0}", NormativeDatabase.Instance.Connection.ConnectionString); Console.WriteLine("Base Path:{0}", BasePath); switch (MessageTypeToBuild) { case MessageType.All: SourceGenerator.MakeAll(BasePath, Version); break; case MessageType.EventMapping: SourceGenerator.MakeEventMapping(BasePath, Version); break; case MessageType.Segment: SegmentGenerator.MakeAll(BasePath, Version); break; case MessageType.Message: MessageGenerator.MakeAll(BasePath, Version); break; case MessageType.DataType: DataTypeGenerator.MakeAll(BasePath, Version); break; } }
public async Task SendNotification(NotificationParameter parameter) { var payLoad = string.Empty; switch (parameter.Flatform) { case MessageGenerator.Flatform.GCM: payLoad = MessageGenerator.getAndroidMessage(parameter); break; case MessageGenerator.Flatform.APNS_SANDBOX: payLoad = MessageGenerator.getAppledMessage(parameter); break; case MessageGenerator.Flatform.APNS: payLoad = MessageGenerator.getAppledMessage(parameter); break; default: break; } ; await connection.Send(payLoad); }
public Msg ProcessMessage(Msg message) { if (message.OperationType != "Login") { Msg tokenCheck = loginService.ProcessMessage(MessageGenerator.SetOperation(message, "CheckToken")); if (!tokenCheck.StatutOp) { return(tokenCheck); } } switch (message.OperationType) { case "Login": return(loginService.ProcessMessage(message)); case "Decrypt": return(decryptService.ProcessMessage(message)); case "DecryptDone": return(completedDecryptionService.ProcessMessage(message)); default: return(MessageGenerator.GenerateError(message, "Unrecognized operation type!", this.GetType().ToString())); } }
public MessageTagger(string filePath, MessageGenerator service, ITextBuffer buffer) { m_buffer = buffer; m_service = service; m_service.SubscribeTagger(this); Update(false); }
/// <summary> /// Generate an email based off a Razor template /// </summary> /// <param name="templateName">The name of the template directory</param> /// <param name="model">The model to pass into the template</param> /// <returns>Email Message with generated content</returns> /// <exception cref="RazorEmailCoreConfigurationException">Invalid Configuration Exception</exception> /// <exception cref="MessageGenerationException">Error in razor template, message generation failed.</exception> public virtual Email CreateEmail(string templateName, object model) { Config = MessageSettingsProvider.LoadByTemplateName(templateName); string htmlMessage = null; string textMessage = null; if (!string.IsNullOrWhiteSpace(Config.HtmlEmailTemplate)) { htmlMessage = MessageGenerator.GenerateMessageBody(Config.HtmlEmailTemplate, model); } if (!string.IsNullOrWhiteSpace(Config.PlainTextEmailTemplate)) { textMessage = MessageGenerator.GenerateMessageBody(Config.PlainTextEmailTemplate, model); } var result = new Email { HtmlBody = htmlMessage, PlainTextBody = textMessage, Subject = Config.Subject, Sender = Config.From }; Config.Cc?.Split(new[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries).ToList().ForEach(n => result.Cc.Add(n)); Config.Bcc?.Split(new[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries).ToList().ForEach(n => result.Bcc.Add(n)); return(result); }
public void DisplayMessageShouldReturnValidString() { string expected = "Hello world!"; string programResult = MessageGenerator.displayMessage(); Assert.Equal(expected, programResult); }
/// <summary> /// Рабочий поток /// </summary> public void Process() { var traceSource = new TraceSource("DeliveryService"); while (!stopped) { try { // откроем подключение к БД using (var connection = new SqlConnection( ConfigurationManager.ConnectionStrings[ "Croc.IncidentTracker.Notification.DeliveryService.Properties.Settings.IT" ].ConnectionString)) { connection.Open(); // создадим экземпляр рассылщика уведомлений var messageGenerator = new MessageGenerator( new ApplicationInstallation[] { new ApplicationInstallation("Internal", Properties.Settings.Default.InternalUri.ToString()), new ApplicationInstallation("External", Properties.Settings.Default.ExternalUri.ToString()) }, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Properties.Settings.Default.XslFormatterFilePath), Properties.Settings.Default.DigestInterval, Properties.Settings.Default.MaxMessagesPerDigest, Properties.Settings.Default.MaxMessagesPerOnce, connection, new MessageMailer( Properties.Settings.Default.SMTPHost, Properties.Settings.Default.SMTPPort, Properties.Settings.Default.SMTPTimeout, Properties.Settings.Default.MailFrom, Properties.Settings.Default.TestMail ) ); try { while (!stopped && messageGenerator.Run() > 0) { ; } } catch (ThreadAbortException) { } catch (Exception e) { traceSource.TraceEvent( TraceEventType.Error, 0, "Во время работы сервиса возникло исключение:\n{0}", e); } if (!stopped) { lock (idleLock) { Monitor.Wait(idleLock, Properties.Settings.Default.DeliveryIdle); } } } } catch (ThreadAbortException) { } }
public MessageGeneratorImpl(Game game, MessageGenerator messageGenerator, string mainMessage, string resultMessage) { _game = game ?? throw new ArgumentNullException(nameof(game)); _messageGenerator = messageGenerator ?? throw new ArgumentNullException(nameof(messageGenerator)); _mainMessage = mainMessage ?? throw new ArgumentNullException(nameof(mainMessage)); _resultMessage = resultMessage ?? throw new ArgumentNullException(nameof(resultMessage)); }
// Génère un token utilisateur private Msg LogInUser(Msg message) { string token = Convert.ToBase64String(Guid.NewGuid().ToByteArray()); tokens.Add(token); return(MessageGenerator.SetData(message, new object[] { token })); }
public TenantCreatedHandler(MessageGenerator <EmailTemplate, EmailMessage> emailMsgGenerator, IEmailDispatcher emailDispatcher, IConfigurationProvider configProvider) { this.emailMsgGenerator = emailMsgGenerator; this.emailDispatcher = emailDispatcher; this.configProvider = configProvider; }
private async Task <byte[]> SendInitRequestAsync() { var msg = MessageGenerator.GenerateRequestMessage(); _logger.Info($"Sending request message: {msg}"); await _transport.WriteBytesAsync(msg); return(msg); }
// Use this for initialization void Start() { User user1 = User.UserGenerator(random); for (int i = 0; i < 10; i++) { print(MessageGenerator.GenerateCompliment(random)); } print("HELLO"); }
public void SaysHelloToPerson() { //Arrange //Act var greeting = MessageGenerator.GreetPerson("FakeName"); //Assert Assert.Equal("Hello FakeName", greeting); }
public void Register(string ip, int port) { MessageGenerator generator = new MessageGenerator("REG", this.name); generator.AddReceiver(this.dispatchServerName); generator.AddReceiver(this.name); generator.AddParameter("IP", ip); generator.AddParameter("Port", port.ToString()); base.Send(generator.GetMessage()); }
private Msg FindUser(Msg message) { Msg newMessage = MessageGenerator.UpdateMessage(message, new Dictionary <string, object> { { "data", new object[] { $"SELECT count(*) FROM users WHERE username = '******' AND password = '******'" } }, { "operationName", "SendQuery" } }); return(dbConnector.ProcessMessage(newMessage)); }
public async Task ConcurrencyTest2() //TODO Not a fair comparison { var messages = MessageGenerator.GenerateMessages(200); var headers = MessageGenerator.GenerateMessageHeaders(messages, "Topic1", 1); var stopWatch = new Stopwatch(); var container = new MessageContainer[headers.Length]; var semaphore = new Semaphore(1, 1); for (var i = 0; i < headers.Length; i++) { container[i] = new MessageContainer { Header = headers[i], Messages = messages.ToList() }; } var data = new byte[headers.Length][]; for (int i = 0; i < container.Length; i++) { data[i] = LZ4MessagePackSerializer.Serialize(container[i]); } var tasks = new Task[data.Length]; var sockets = new BrokerSocket[data.Length]; for (int i = 0; i < data.Length; i++) { var i1 = i; sockets[i] = new BrokerSocket(); tasks[i] = new Task(async() => { await sockets[i1].SendMessage(data[i1]); }); } stopWatch.Start(); for (int i = 0; i < data.Length; i++) { await sockets[i].ConnectToBroker("ws://localhost:5000/ws"); tasks[i].Start(); } stopWatch.Stop(); await Task.Delay(2 * 1000); for (int i = 0; i < data.Length; i++) { await sockets[i].DeleteConnection(); } _testOutputHelper.WriteLine($"Time: {stopWatch.ElapsedTicks}"); }
/// <inheritdoc/> public override async Task <bool> PublishAsync(Service service, EventData eventData) { Log.Debug($"Publishing event '{eventData.Event.Id}' for service '{service.Uuid}'"); if (!this.RegisteredServices.ContainsKey(service.Uuid)) { throw new ServiceNotRegisteredException($"Service '{service.Uuid}' was not registered via this MSB client connected to '{this.MsbUrl}'"); } if (!service.Events.Contains(eventData.Event)) { throw new EventNotExistException($"Event '{eventData.Event.Id}' not added to service '{service.Uuid}'"); } if (this.IsConnected()) { this.receivedIOPublished = false; var publishTask = Task.Run(() => { string message = MessageGenerator.GenerateEventMessage(service, eventData, this.UseSockJs); Log.Debug($"Event published '{message}' for service '{service.Uuid}'"); this.webSocket.Send(message); CancellationTokenSource source = new CancellationTokenSource(); while (!this.receivedIOPublished && !source.IsCancellationRequested) { Thread.Sleep(10); } }); if (await Task.WhenAny(publishTask, Task.Delay(this.WaitForPublishInMilliseconds, default(CancellationToken))) == publishTask) { await publishTask; this.receivedIOPublished = false; this.EventPublished?.Invoke(this, EventArgs.Empty); return(true); } else { this.CacheEvent(service, eventData); Log.Warn($"Publish try for event '{eventData.Event.Id}' of service ' {service.Uuid}' timed out. Event added to cache."); return(false); } } else if (eventData.ShouldBeCached) { this.CacheEvent(service, eventData); return(false); } else { Log.Debug($"Caching disabled, event '{eventData.Event.Id}' was discarded"); return(false); } }
public Msg ProcessMessage(Msg message) { switch (message.OperationName) { case "DecryptFile": return(DecryptFile(message)); default: return(MessageGenerator.GenerateError(message, $"{message.OperationName}: Unrecognized operation name", this.GetType().ToString())); } }
public void ConstrcutorShouldThrowExceptionIfErrorChanceIsIncorrect(double chance) { // Arrange // Act TestDelegate testDelegate = () => _messageGenerator = new MessageGenerator(_networkMock.Object, _messageCreatorMock.Object, chance); // Assert Assert.That(testDelegate, Throws.ArgumentException); }
public void ConstructorShouldThrowExceptionIfMessageSizeIsLessOrEqualZero() { // Arrange // Act TestDelegate testDelegate = () => _messageGenerator = new SpecifiedSizeMessageGenerator(_networkMock.Object, _messageCreatorMock.Object, 0.5, -1); // Assert Assert.That(testDelegate, Throws.ArgumentException); }
public Msg ProcessMessage(Msg message) { switch (message.OperationName) { case "SendQuery": return(SendQuery(message)); default: return(MessageGenerator.GenerateError(message, $"{message.OperationName}: Unrecognized operation", this.GetType().ToString())); } }
static void say_hello_using(MessageGenerator generator,string message) { generator(message); }