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);
}
