public void Test_PostWithBadHostnameAndGetMessage_StatusIsFailed()
{
// Create message
var postRequest = new CreateMessage
{
ApplicationId = 1,
Bcc = new[] { "*****@*****.**" },
Body = "This is a test email.",
Cc = new[] { "*****@*****.**" },
Connection = new Connection
{
EnableSsl = false,
Host = "nonexistant",
Port = 25
},
Credential = new Credential(),
From = "*****@*****.**",
ReplyTo = new[] { "*****@*****.**" },
Sender = "*****@*****.**",
Subject = "Test Message",
To = new[] { "*****@*****.**" }
};
var client = new JsonServiceClient("http://localhost:59200/");
var postResponse = client.Post(postRequest);
// Get message
var getRequest = new GetMessage
{
Id = postResponse.Id
};
var getResponse = client.Get(getRequest);
Assert.Equal(3, getResponse.Status.TypeMessageStatusId);
Assert.Equal(postResponse.Id, getResponse.Id);
}
private static void Register(byte identifier, CreateMessage creator)
{
if (creator == null)
throw new ArgumentNullException(nameof(creator));
lock (MessageDict)
MessageDict.Add(identifier, creator);
}
public static void Register(byte identifier, CreateMessage creator)
{
if (creator == null)
throw new ArgumentNullException("creator");
lock (messageDict)
messageDict.Add(identifier, creator);
}
public GameLobby CreateGame(string gameType, [FromBody] CreateMessage body)
{
return(lobby.Create(
gameType,
context.Connection.RemoteIpAddress.ToString(),
body.port,
HttpUtility.UrlPathEncode(body.name),
body.hidden,
body.meta));
}
public static void Register(byte identifier, CreateMessage creator)
{
if (creator == null)
{
throw new ArgumentNullException(nameof(creator));
}
lock (MessageDict)
MessageDict.Add(identifier, creator);
}
public void SendMessageTest()
{
// TODO: add unit test for the method 'SendMessage'
int? restaurantId = null; // TODO: replace null with proper value
string reservationId = null; // TODO: replace null with proper value
CreateMessage createMessageContract = null; // TODO: replace null with proper value
var response = instance.SendMessage(restaurantId, reservationId, createMessageContract);
Assert.IsInstanceOf <Message> (response, "response is Message");
}
public static GatewayStrategy Resolve(TweakTestDataEntities db, CreateMessage message)
{
var item = message.Item;
if (item is House)
{
return new CreateHouseStrategy(db);
}
return null;
}
private static void Register(byte identifier, CreateMessage creator)
{
if (creator == null)
{
throw new ArgumentNullException("creator");
}
lock (messageDict)
messageDict.Add(identifier, creator);
}
public static GatewayStrategy Resolve(TweakTestDataEntities db, CreateMessage message)
{
var item = message.Item;
if (item is House)
{
return(new CreateHouseStrategy(db));
}
return(null);
}
public async Task <ActionResult <ReadMessage> > PostMessage(CreateMessage createMessage)
{
var message = mapper.Map <Message>(createMessage);
await messagesService.MessagesRepository.CreateAsync(message);
var result = mapper.Map <ReadMessage>(message);
return(CreatedAtRoute("GetMessageByGuid", new { messageId = result.Guid }, result));
}
private void RpcIncrementPlayersDone()
{
finishedPlayers++;
if (finishedPlayers == 2)
{
CreateMessage message = gameObject.GetComponent <CreateMessage>();
message.enableWinObjects();
Debug.Log("game is done!");
}
}
/// <summary>
/// Instantiates a persistent object from the <see cref="ShapeCache"/>.
/// The new object is assigned the given <paramref name="id"/>
/// </summary>
/// <param name="id">The ID of the new object. Must non be zero (for persistent objects).</param>
/// <returns>The instantiated object or -1 on failure.</returns>
protected virtual int CreateShape(ShapeCache cache, CreateMessage shape, int multiShapeChainIndex,
Matrix4x4 parentTransform)
{
Matrix4x4 transform = Matrix4x4.identity;
DecodeTransform(shape.Attributes, out transform);
int index = cache.CreateShape(shape, transform, multiShapeChainIndex);
cache.SetParentTransformByIndex(index, parentTransform);
return(index);
}
public void CanEmit()
{
// Arrange
var clientMock = new Mock <IElmahioAPI>();
var messagesMock = new Mock <IMessages>();
clientMock.Setup(x => x.Messages).Returns(messagesMock.Object);
var sink = new ElmahIoSink(null, clientMock.Object);
CreateMessage loggedMessage = null;
messagesMock
.Setup(x => x.CreateAndNotify(It.IsAny <Guid>(), It.IsAny <CreateMessage>()))
.Callback <Guid, CreateMessage>((logId, msg) =>
{
loggedMessage = msg;
});
var now = DateTimeOffset.Now;
var exception = Exception();
#if !DOTNETCORE
var principalMock = new Mock <IPrincipal>();
var identityMock = new Mock <IIdentity>();
identityMock.Setup(x => x.Name).Returns("User");
principalMock.Setup(x => x.Identity).Returns(identityMock.Object);
Thread.CurrentPrincipal = principalMock.Object;
#endif
// Act
sink.Emit(
new LogEvent(
now,
LogEventLevel.Error,
exception,
new MessageTemplate("Simple test", new List <MessageTemplateToken>()), new List <LogEventProperty>
{
new LogEventProperty("name", new ScalarValue("value"))
}
)
);
// Assert
Assert.That(loggedMessage != null);
Assert.That(loggedMessage.Severity, Is.EqualTo(Severity.Error.ToString()));
Assert.That(loggedMessage.DateTime, Is.EqualTo(now.DateTime.ToUniversalTime()));
Assert.That(loggedMessage.Detail, Is.EqualTo(exception.ToString()));
Assert.That(loggedMessage.Data != null);
Assert.That(loggedMessage.Data.Count, Is.EqualTo(1));
Assert.That(loggedMessage.Data.First().Key, Is.EqualTo("name"));
Assert.That(loggedMessage.Type, Is.EqualTo(typeof(DivideByZeroException).FullName));
Assert.That(loggedMessage.Hostname, Is.EqualTo(Environment.MachineName));
#if !DOTNETCORE
Assert.That(loggedMessage.User, Is.EqualTo("User"));
#endif
}
public void SendMessageTest()
{
// TODO: add unit test for the method 'SendMessage'
int? restaurantId = null; // TODO: replace null with proper value
int? waitingItemId = null; // TODO: replace null with proper value
string origin = null; // TODO: replace null with proper value
CreateMessage createMessage = null; // TODO: replace null with proper value
var response = instance.SendMessage(restaurantId, waitingItemId, origin, createMessage);
Assert.IsInstanceOf <Message> (response, "response is Message");
}
public void SaveUserSettigs(Project project, CreateMessage model)
{
SetImportsByProject(project, model.Imports);
SetConstructorParametersByProject(project, model.ConstructorParameters);
SetBooleanByProject(project, MediatRSettingsKey.ShouldCreateFolder, model.ShouldCreateFolder);
SetBooleanByProject(project, MediatRSettingsKey.ShouldCreateValidationFile, model.ShouldCreateValidationFile);
SetBooleanByProject(project, MediatRSettingsKey.ShouldCreateAutomapperFile, model.ShouldCreateAutomapperFile);
SetBooleanByProject(project, MediatRSettingsKey.OneFileStyle, model.OneFileStyle);
SetBooleanByProject(project, MediatRSettingsKey.OneClassStyle, model.OneClassStyle);
}
public Message CreateAndNotify(Guid logId, CreateMessage message)
{
OnMessage?.Invoke(this, new MessageEventArgs(message));
message = Obfuscate(message);
return(Task.Factory.StartNew(s =>
{
return
CreateWithHttpMessagesAsync(logId.ToString(), message)
.ContinueWith(MessagesCreated(message));
}, this, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
private ProjectItems GetOrCreateFolderProjectItems(DteWrapper dteWrapper, CreateMessage model)
{
if (!model.ShouldCreateFolder)
{
return(dteWrapper.SelectedItemProjectItems);
}
var folderItem = dteWrapper.SelectedItemProjectItems.AddFolder(model.InputFileName);
return(folderItem.ProjectItems);
}
public override void OnClientConnect(NetworkConnection NC) //Called on the client and sent to the server
{
ClientScene.Ready(NC);
//base.OnClientConnect(NC);
CreateMessage characterMessage = new CreateMessage {
name = SteamClient.Name.ToString(), id = SteamClient.SteamId.ToString()
}; //On create message for client connections
//Request to spawn with specified info
NC.Send(characterMessage);
}
/// <summary>
/// Create a new shape instance for <paramref name="shape"/>.
/// </summary>
/// <param name="shape">Core data for the new shape.</param>
/// <param name="transform">The world transform for the new shape.</param>
/// <returns>The index value for the object. This should not be used after new shapes are added or removed</returns>
/// <remarks>
/// The extracted from <c>shape.ID</c>. Which must not already be present. The ID can only be zero for a
/// transient cache.
/// </remarks>
/// <exception cref="DuplicateIDException">Thrown whn an object with the same ID already exists and the case is not
/// transient.</exception>
public int CreateShape(CreateMessage shape, Matrix4x4 transform, int multiShapeChainIndex = -1)
{
int shapeIndex = AssignNewShapeIndex(shape.ObjectID);
_shapes[shapeIndex] = shape;
_transforms[shapeIndex] = transform;
_parentTransforms[shapeIndex] = Matrix4x4.identity;
_multiShapeChain[shapeIndex] = multiShapeChainIndex;
return(shapeIndex);
}
public static void SendMessage(long channelId, string content)
{
CreateMessage message = new CreateMessage()
{
ChannelId = channelId,
Content = content,
TTS = false,
Method = "POST"
};
message.Send();
}
public void Should_throw_exception_if_text_is_blank()
{
var cmd = new CreateMessage
{
SenderId = playerBob.Id,
ReceiverId = 34745,
Text = ""
};
Assert.That(() => Repository.Execute(cmd),
Throws.TypeOf <DomainException>().With.Message.EqualTo("Text must not be empty or null"));
}
void GetAllRecords()
{
List <Customer> customers = e.Customers.ToList();
foreach (Customer c in customers)
{
CreateMessage cm = new CreateMessage();
cm.ApplicationSubjectId = c.CustomerId.ToString();
cm.ApplicationId = this.ApplicationId.ToString();
MasterGDPRHelper.SendMessage(cm);
}
}
public async Task CreateMessageAsync(CreateMessage command, Account account)
{
var message = new Message {
Content = command.Content
};
await _context.Messages.AddAsync(message);
account.Messages.Add(message);
await _context.SaveChangesAsync();
}
private MoveRequest CreateRequestFromMessage(CreateMessage message)
{
var repo = RepositoryFactory.GetMoveRequestRepository();
var entity = repo.Create(new MoveRequest()
{
UsersName = message.UsersName,
FromStationNumber = message.FromStationNumber,
ToStationNumber = message.ToStationNumber,
//State = MoveRequestState.Requested
});
return entity;
}
void Create(IDbConnection connection, CreateMessage request)
{
connection.Insert(new QueueMessage
{
Content = request.Content,
Readed = false
});
if (!string.IsNullOrEmpty(request.Cooperator))
{
Propagators.ScheduleQueueOperation(request.QueueName, () => PropagateRequest(request));
}
}
private CodeClass CreateMessageRequest(ProjectItems projectItems, CreateMessage model, string classTemplate)
{
ThreadHelper.ThrowIfNotOnUIThread();
var requestProjectItem = projectItems.AddFromTemplate(classTemplate, $"{model.MessageName.FullName}");
(requestProjectItem.FileCodeModel as FileCodeModel2).AddNotExistingImports(model.DefaultRequestImports);
var codeClass = requestProjectItem.FindCodeClassByName(model.MessageName.Name);
codeClass.Access = vsCMAccess.vsCMAccessPublic;
codeClass.InsertInterfaceToTheEnd(model.RequestInterface);
return(codeClass);
}
public void Should_throw_exception_if_receiver_is_not_found()
{
var cmd = new CreateMessage
{
SenderId = playerBob.Id,
ReceiverId = 34745,
Text = "Message!"
};
Assert.That(() => Repository.Execute(cmd),
Throws.TypeOf <DomainException>().With.Message
.EqualTo("Receiving player with Id 34745 could not be found"));
}
/// <summary>
/// Message handler for <see cref="CreateMessage"/>
/// </summary>
/// <param name="msg">The incoming message.</param>
/// <param name="packet">The buffer containing the message.</param>
/// <param name="reader">The reader from which the message came.</param>
/// <returns>An error code on failure.</returns>
/// <remarks>
/// Creates either a persistent or transient object depending on the incoming
/// message ObjectID. An ID of zero signifies a transient object.
/// Solid or wire shapes are assigned according to the message flags.
/// </remarks>
protected virtual Error HandleMessage(CreateMessage msg, PacketBuffer packet, BinaryReader reader)
{
int shapeIndex = -1;
ShapeCache cache = (msg.ObjectID == 0) ? _transientCache : _shapeCache;
_lastTransientIndex = -1;
try
{
// Check for replacement.
if (msg.ObjectID != 0 && (msg.Flags & (ushort)ObjectFlag.Replace) != 0)
{
if (cache.GetShapeIndex(msg.ObjectID) >= 0)
{
// Simulate a destroy message.
HandleMessage(new DestroyMessage {
ObjectID = msg.ObjectID
});
}
}
// Handle multi-shape message.
if ((msg.Flags & (ushort)ObjectFlag.MultiShape) != 0)
{
// Read the item count.
uint itemCount = (uint)reader.ReadUInt32();
uint blockItemCount = (uint)reader.ReadUInt16();
// Real code.
Error error = ReadMultiShapeBlock(cache, shapeIndex, msg, packet, reader, blockItemCount, ref shapeIndex);
if (error.Failed)
{
return(error);
}
}
// Create the primary shape, the first link in the chain, last.
shapeIndex = CreateShape(cache, msg, shapeIndex, Matrix4x4.identity);
}
catch (Tes.Exception.DuplicateIDException)
{
return(new Error(ErrorCode.DuplicateShape, msg.ObjectID));
}
if (msg.ObjectID == 0)
{
_lastTransientIndex = shapeIndex;
}
return(PostHandleMessage(msg, packet, reader, cache, shapeIndex));
}
public void CanEmitCustomFields()
{
// Arrange
var clientMock = new Mock <IElmahioAPI>();
var messagesMock = new Mock <IMessages>();
clientMock.Setup(x => x.Messages).Returns(messagesMock.Object);
var sink = new ElmahIoSink(null, clientMock.Object);
CreateMessage loggedMessage = null;
messagesMock
.Setup(x => x.CreateAndNotify(It.IsAny <Guid>(), It.IsAny <CreateMessage>()))
.Callback <Guid, CreateMessage>((logId, msg) =>
{
loggedMessage = msg;
});
var now = DateTimeOffset.Now;
// Act
sink.Emit(
new LogEvent(
now,
LogEventLevel.Error,
null,
new MessageTemplate("{type} {hostname} {application} {user} {source} {method} {version} {url} {statusCode}", new List <MessageTemplateToken>()), new List <LogEventProperty>
{
new LogEventProperty("type", new ScalarValue("type")),
new LogEventProperty("hostname", new ScalarValue("hostname")),
new LogEventProperty("application", new ScalarValue("application")),
new LogEventProperty("user", new ScalarValue("user")),
new LogEventProperty("source", new ScalarValue("source")),
new LogEventProperty("method", new ScalarValue("method")),
new LogEventProperty("version", new ScalarValue("version")),
new LogEventProperty("url", new ScalarValue("url")),
new LogEventProperty("statusCode", new ScalarValue(400)),
}
)
);
// Assert
Assert.That(loggedMessage != null);
Assert.That(loggedMessage.Type, Is.EqualTo("type"));
Assert.That(loggedMessage.Hostname, Is.EqualTo("hostname"));
Assert.That(loggedMessage.Application, Is.EqualTo("application"));
Assert.That(loggedMessage.User, Is.EqualTo("user"));
Assert.That(loggedMessage.Source, Is.EqualTo("source"));
Assert.That(loggedMessage.Method, Is.EqualTo("method"));
Assert.That(loggedMessage.Version, Is.EqualTo("version"));
Assert.That(loggedMessage.Url, Is.EqualTo("url"));
Assert.That(loggedMessage.StatusCode, Is.EqualTo(400));
}
public async Task Announce([Remainder] string content)
{
var config = GlobalUserAccounts.GetAllAccounts();
foreach (var userAcc in config)
{
SocketUser user = Global.Client.GetUser(userAcc.Id);
await CreateMessage.CreateAndSendMessageAsync("Nayu Announcement!", content, DateTime.Now, user);
GlobalUserAccounts.SaveAccounts(userAcc.Id);
}
await ReplyAsync($"Sent \n`{content}`\n to everyone");
}
/// <summary>
/// Create a new shape cache.
/// </summary>
/// <param name="initialCapacity">Sets the initial storage capcity. Use zero to set the default capacity.</param>
/// <param name="transient">True to create a transient cache.</param>
public ShapeCache(int initialCapacity, bool transient)
{
_capacity = (initialCapacity > 0) ? initialCapacity : 1024;
_shapes = new CreateMessage[_capacity];
_transforms = new Matrix4x4[_capacity];
_parentTransforms = new Matrix4x4[_capacity];
_multiShapeChain = new int[_capacity];
if (!transient)
{
// Non-transient cache. Use the ID map.
_idMap = new Dictionary <uint, int>();
_freeList = new List <int>();
}
}
/// <summary>
/// Overridden to read information about mesh parts.
/// </summary>
/// <param name="msg"></param>
/// <param name="packet"></param>
/// <param name="reader"></param>
/// <returns></returns>
protected override Error HandleMessage(CreateMessage msg, PacketBuffer packet, BinaryReader reader)
{
GameObject obj = null;
if (msg.ObjectID == 0)
{
// Cannot support transient objects: we need to get point data through additional
// messages which requires a valid object id.
return(new Error(ErrorCode.InvalidObjectID, 0));
}
else
{
obj = CreateObject(msg.ObjectID);
if (!obj)
{
// Object already exists.
return(new Error(ErrorCode.DuplicateShape, msg.ObjectID));
}
}
ShapeComponent shapeComp = obj.GetComponent <ShapeComponent>();
if (shapeComp)
{
shapeComp.Category = msg.Category;
shapeComp.ObjectFlags = msg.Flags;
shapeComp.Colour = ShapeComponent.ConvertColour(msg.Attributes.Colour);
}
obj.transform.SetParent(Root.transform, false);
DecodeTransform(msg.Attributes, obj.transform);
// Read additional attributes.
PointsComponent pointsComp = obj.AddComponent <PointsComponent>();
// Read the mesh ID to render points from.
pointsComp.MeshID = reader.ReadUInt32();
// Read the number of indices (zero implies show entire mesh).
pointsComp.IndexCount = reader.ReadUInt32();
pointsComp.PointSize = reader.ReadByte();
if (pointsComp.IndexCount == 0)
{
// Not expecting any index data messages.
// Register the mesh now.
RegisterForMesh(pointsComp);
}
return(new Error());
}
public async void OnActionExecuted(ActionExecutedContext context)
{
if (_hostingEnviroment.IsDevelopment())
{
var data = new
{
Version = "v1.0",
User = context.HttpContext.User.Identity.Name,
IP = context.HttpContext.Connection.RemoteIpAddress.ToString(),
Hostname = context.HttpContext.Request.Host.ToString(),
AreaAccessed = context.HttpContext.Request.GetDisplayUrl(),
Action = context.ActionDescriptor.DisplayName,
TimeStamp = DateTime.Now
};
try
{
_logger.LogInformation(1, data.ToString(), "Log de Auditoria");
}
catch
{
}
}
if (_hostingEnviroment.IsProduction())
{
var message = new CreateMessage
{
Version = "v1.0",
Application = "Eventos.IO",
Source = "GlobalActionLoggerFilter",
User = context.HttpContext.User.Identity.Name,
Hostname = context.HttpContext.Request.Host.Host,
Url = context.HttpContext.Request.GetDisplayUrl(),
DateTime = DateTime.Now,
Method = context.HttpContext.Request.Method,
StatusCode = context.HttpContext.Response.StatusCode,
Cookies = context.HttpContext.Request?.Cookies?.Keys.Select(k => new Item(k, context.HttpContext.Request.Cookies[k])).ToList(),
Form = Form(context.HttpContext),
ServerVariables = context.HttpContext.Request?.Headers?.Keys.Select(k => new Item(k, context.HttpContext.Request.Headers[k])).ToList(),
QueryString = context.HttpContext.Request?.Query?.Keys.Select(k => new Item(k, context.HttpContext.Request.Query[k])).ToList(),
Data = context.Exception?.ToDataList(),
Detail = JsonConvert.SerializeObject(new { DadoExtra = "Dados a mais", DadoInfo = "Pode ser um Json" })
};
var client = ElmahioAPI.Create("0b8f6c34-6e07-4dae-8d6b-5f35f84e52a7");
await client.Messages.CreateAsync(new Guid("ae189cd6-4491-49ae-8f38-bf49f5f36627").ToString(), message);
}
}
public void TakeDamage(int amount)
{
if (!isServer)
{
return;
}
maxHealth -= amount;
if (maxHealth <= 0)
{
CreateMessage message = gameObject.GetComponent <CreateMessage>();
message.enableLoseObjects();
//Destroy (this.gameObject);
}
}
/// <summary>
/// Iterate the current shapes collecting their transforms (for rendering).
/// </summary>
/// <param name="transforms">List to populate with shape transforms.</param>
/// <param name="parentTransforms">List to populate with parent transforms.</param>
/// <param name="shapes">List of shapes collected</param>
/// <param name="collectType">Defines what kind of shapes to collect.</param>
/// <remarks>
/// This method is used to collect shapes for rendering, collecting each valid shape's transform, parent transform
/// and core shape data in the relevant lists.
/// </remarks>
public void Collect(List <Matrix4x4> transforms, List <Matrix4x4> parentTransforms,
List <CreateMessage> shapes, CollectType collectType)
{
// Walk the _headers and _transforms arrays directly. We can tell which indices are valid by investigating the
// _headers[].ID value. A zero value is not in use.
// TODO: (KS) consider storing a high water mark to limit iterating the arrays.
bool transientCache = IsTransientCache;
int itemLimit = (transientCache) ? _currentCount : _capacity;
for (int i = 0; i < itemLimit; ++i)
{
CreateMessage shape = _shapes[i];
// Transient cached we know everything up to the item limit is valid. All IDs will be zero.
// Non transient cache, we look for shapes with non-Render IDs.
// A transient cache has all IDs set to zero. A non-transient cache has all valid IDs as non-zero.
if ((transientCache || shape.ObjectID != 0))
{
bool add = false;
// Don't visualise multi-shape entries; they are essentially the parent transform for a set of other shapes
// not bearing this flag.
if ((shape.Flags & (ushort)Tes.Net.ObjectFlag.MultiShape) == 0)
{
if ((shape.Flags & (ushort)Tes.Net.ObjectFlag.Wireframe) != 0)
{
// Collecting wireframe.
add = collectType == CollectType.Wireframe;
}
else if ((shape.Flags & (ushort)Tes.Net.ObjectFlag.Transparent) != 0)
{
// Collecting transparent.
add = collectType == CollectType.Transparent;
}
else if (collectType == CollectType.Solid)
{
// Collecting solid.
add = true;
}
}
if (add)
{
transforms.Add(_transforms[i]);
parentTransforms.Add(_parentTransforms[i]);
shapes.Add(shape);
}
}
}
}
public HttpResult Post(CreateMessage request)
{
// POST does not support update
//if (request.Id > 0)
// return new HttpResult(HttpStatusCode.NotFound, "POST does not support updating idividual messages.");
//var id = request.Id;
var ds = new DataStore();
var id = ds.InsertMessage(request);
var client = new EmailClient();
var emailResult = client.Send(request);
var response = new MessageResponse
{
Id = id,
Success = true
};
if (emailResult.Success)
{
ds.InsertMessageStatus(id, 2);
}
else
{
ds.InsertMessageStatus(id, 3, emailResult.Message, emailResult.SmtpException);
response.Result = emailResult.Message;
response.Success = false;
}
var result = new HttpResult(response)
{
StatusCode = HttpStatusCode.Created,
StatusDescription = RequestContext.AbsoluteUri.CombineWith(id)
};
return result;
}
private static void Main(string[] args)
{
string input;
int choice;
object response;
var client = new JsonServiceClient("http://*****:*****@test.com"},
Body = "This is a test email.",
Cc = new[] {"*****@*****.**"},
Connection = new Connection
{
EnableSsl = false,
Host = "localhost",
Port = 25
},
Credential = new Credential(),
From = "*****@*****.**",
ReplyTo = new[] {"*****@*****.**"},
Sender = "*****@*****.**",
Subject = "Test Message",
To = new[] {"*****@*****.**"}
};
response = client.Post(request);
response.PrintDump();
break;
case 3:
response = client.Get(new Messages {ApplicationId = 1});
response.PrintDump();
break;
}
} while (input != null);
}
public int InsertMessage(CreateMessage message)
{
int id = -1;
// TODO: refactor this out of here?
using (var conn = new SqlConnection(SqlBase.ConnectionString))
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
using (var cmd = new SqlCommand("MessageInsert", conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", id).DbType = DbType.Int32;
cmd.Parameters["@Id"].Direction = ParameterDirection.Output;
cmd.Parameters.AddWithValue("@ApplicationId", message.ApplicationId).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@From", message.From).DbType = DbType.String;
cmd.Parameters.AddWithValue("@Sender", message.Sender).DbType = DbType.String;
cmd.Parameters.AddWithValue("@Subject", message.Subject).DbType = DbType.String;
cmd.Parameters.AddWithValue("@Body", message.Body).DbType = DbType.String;
cmd.Parameters.AddWithValue("@Host", message.Connection.Host).DbType = DbType.String;
cmd.Parameters.AddWithValue("@Port", message.Connection.Port).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@EnableSsl", message.Connection.EnableSsl).DbType =
DbType.Boolean;
cmd.Parameters.AddWithValue("@CreateDate", DateTime.UtcNow).DbType = DbType.DateTime;
cmd.ExecuteNonQuery();
id = (int) cmd.Parameters["@Id"].Value;
}
if (message.Credential != null && !string.IsNullOrWhiteSpace(message.Credential.Username))
{
using (var cmd = new SqlCommand("CredentialInsert", conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@MessageId", id).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@Username", message.Credential.Username).DbType =
DbType.String;
cmd.Parameters.AddWithValue("@Password", message.Credential.Password).DbType =
DbType.String;
cmd.Parameters.AddWithValue("@Domain", message.Credential.Domain).DbType = DbType.String;
cmd.ExecuteNonQuery();
}
}
foreach (var to in message.To)
{
using (var cmd = new SqlCommand("MessageToInsert", conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@MessageId", id).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@To", to).DbType = DbType.String;
cmd.ExecuteNonQuery();
}
}
foreach (var cc in message.Cc)
{
using (var cmd = new SqlCommand("MessageCcInsert", conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@MessageId", id).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@Cc", cc).DbType = DbType.String;
cmd.ExecuteNonQuery();
}
}
foreach (var bcc in message.Bcc)
{
using (var cmd = new SqlCommand("MessageBccInsert", conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@MessageId", id).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@Bcc", bcc).DbType = DbType.String;
cmd.ExecuteNonQuery();
}
}
foreach (var replyTo in message.ReplyTo)
{
using (var cmd = new SqlCommand("MessageReplyToInsert", conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@MessageId", id).DbType = DbType.Int32;
cmd.Parameters.AddWithValue("@ReplyTo", replyTo).DbType = DbType.String;
cmd.ExecuteNonQuery();
}
}
}
catch
{
trans.Rollback();
throw;
}
trans.Commit();
}
}
return id;
}
private void OnReceivedCreateMessage(CreateMessage message)
{
Sender.Tell(CreateRequestFromMessage(message));
}
