private async Task SendResults(IDialogContext context, DocumentSearchResult results)
{
var message = context.MakeMessage();
if (results.Results.Count == 0)
{
await context.PostAsync("There were no results found for \"" + searchText + "\".");
context.Done <object>(null);
}
else
{
SearchHitStyler searchHitStyler = new SearchHitStyler();
searchHitStyler.Apply(
ref message,
"Here are the results that I found:",
results.Results.Select(r => ResultMapper.ToSearchHit(r)).ToList().AsReadOnly());
await context.PostAsync(message);
context.Done <object>(null);
}
}
public void BeautifyShouldReturnCorrectResultsIfUsernameExists()
{
ResultMapper resultMapper = new ResultMapper();
string result = resultMapper.BeautifyErrorMessage("Error is:DuplicateUserName");
string expected = "Ez a felhasználónév létezik";
Assert.Equal(expected, result);
}
public void BeautifyShouldReturnCorrectResultsIfEmailExists()
{
ResultMapper resultMapper = new ResultMapper();
string result = resultMapper.BeautifyErrorMessage("Error is:DuplicateEmail");
string expected = "Ez az email cím már létezik";
Assert.Equal(expected, result);
}
public void BeautifyShouldReturnCorrectResultsIfPwTooShort()
{
ResultMapper resultMapper = new ResultMapper();
string result = resultMapper.BeautifyErrorMessage("Error is:PasswordTooShort");
string expected = "Túl rövid jelszó, legalább 6 karakterből kell állnia";
Assert.Equal(expected, result);
}
public void BeautifyShouldReturnCorrectResultsIfInvalidUsername()
{
ResultMapper resultMapper = new ResultMapper();
string result = resultMapper.BeautifyErrorMessage("Error is:InvalidUserName");
string expected = "Kérem csak A-Z és 0-9 karaktereket adjon meg névnek";
Assert.Equal(expected, result);
}
public void BeautifyShouldReturnCorrectResultsIfDifferentError()
{
ResultMapper resultMapper = new ResultMapper();
string result = resultMapper.BeautifyErrorMessage("Error is: Different error occured");
string expected = "Server error";
Assert.Equal(expected, result);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TScalar"></typeparam>
/// <param name="command"></param>
/// <returns></returns>
public virtual TScalar ExecuteScalar <TScalar>(DbCommand command)
{
using (var subsitute = GetConnection(command))
{
command.Connection = subsitute.Connection;
return(new CommandQueryResult <TScalar>(command
, ResultMapper <TScalar> .Create(), Log).FirstOrDefault());
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="EntityType"></typeparam>
/// <param name="command"></param>
/// <returns></returns>
public virtual EntityType[] ExecuteEntities <EntityType>(DbCommand command) where EntityType : class
{
using (var subsitute = GetConnection(command))
{
command.Connection = subsitute.Connection;
return(new CommandQueryResult <EntityType>(
command
, ResultMapper <EntityType> .Create()
, Log).ToArray());
}
}
/// <summary>
/// Async returns a ResultMapper
/// </summary>
/// <param name="IAsyncResult "></param>
/// <param name="result"></param>
/// <returns>void</returns>
public static void EndExecuteAndMapResults(IAsyncResult ar, ResultMapper result)
{
SqlCommand command = (SqlCommand)ar.AsyncState;
try
{
SqlDataReader reader = command.EndExecuteReader(ar);
result(new DataRecord(reader));
}
catch (Core.Data.Exceptions.DataException) // Procedure class already wrapped all necessary data
{
throw;
}
finally
{
CloseAsyncConnection(ar);
}
}
public async Task <ActionResult> Register([FromBody] RegisterViewModel model)
{
if (ModelState.IsValid)
{
var _context = new CarpentryWebsiteContext();
var user = new MyUser()
{
UserName = model.UserName, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(new OkObjectResult("Account created"));
}
else
{
ResultMapper resultMapper = new ResultMapper();
string beautifiedErrorMessage = resultMapper.BeautifyErrorMessage(result.ToString());
return(BadRequest(Errors.AddErrorToModelState("register_failure", beautifiedErrorMessage, ModelState)));
}
}
return(new BadRequestObjectResult("Model state error: " + ModelState));
}
public async Task <IApplicationResult <List <ChargeMessage> > > GetAsync(ChargeSearchMessage message)
{
IDomainResult <List <Charge> > domainResult = await ChargeEntityService.GetAsync(message.Cpf, message.ReferenceMonth);
return(ResultMapper.MapFromDomainResult(domainResult, (domain) => ChargeMapper.MapTo(domain)));
}
public async Task <IApplicationResult <bool> > RegisterAsync(List <ChargeMessage> messages)
{
IDomainResult <bool> domainResult = await ChargeEntityService.RegisterAsync(ChargeMapper.MapTo(messages));
return(ResultMapper.MapFromDomainResult(domainResult, (domain) => domain));
}
public async Task <IApplicationResult <ClientMessage> > GetAsync(ClientSearchMessage message)
{
IDomainResult <Client> domainResult = await ClientEntityService.GetAsync(message.Cpf);
return(ResultMapper.MapFromDomainResult(domainResult, (domain) => ClientMapper.MapTo(domain)));
}
public async Task <IApplicationResult <List <ClientMessage> > > GetAllAsync()
{
IDomainResult <List <Client> > domainResult = await ClientEntityService.GetAllAsync();
return(ResultMapper.MapFromDomainResult(domainResult, (domain) => ClientMapper.MapTo(domain)));
}
public async Task <IApplicationResult <bool> > RegisterAsync(ClientMessage message)
{
IDomainResult <bool> domainResult = await ClientEntityService.RegisterAsync(ClientMapper.MapTo(message));
return(ResultMapper.MapFromDomainResult(domainResult, (domain) => domain));
}
public void Setup()
{
_sut = new ResultMapper();
}
/// <summary>
/// Executes a procedure and allows the caller to inject a resultset mapper and an output parameter mapper.
/// </summary>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="parameterMapper"></param>
/// <param name="result"></param>
public static void ExecuteAndMapResults(Database database, string procedureName, StoredProcedureParameterList parameterList, ResultMapper result, OutputParameterMapper outputMapper)
{
try
{
using (SqlConnection connection = database.GetConnection())
{
SqlCommand command = CommandFactory.CreateCommand(connection, database.InstanceName, procedureName, parameterList);
connection.Open();
IRecordSet reader = new DataRecord(command.ExecuteReader(CommandBehavior.CloseConnection));
result(reader);
connection.Close();
if (outputMapper != null)
{
outputMapper(new ParameterSet(command.Parameters));
}
}
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, e);
}
}
/// <summary>
/// Executes a procedure and allows the caller to inject a resultset mapper.
/// </summary>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="result"></param>
/// <param name="parameters"></param>
public static void ExecuteAndMapResults(Database database, string procedureName, ResultMapper result, params object[] parameters)
{
try
{
using (IRecordSet reader = Procedure.Execute(database, procedureName, parameters))
{
result(reader);
}
}
catch (Core.Data.Exceptions.DataException) // Procedure class already wrapped all necessary data
{
throw;
}
catch (Exception e)
{
throw new SafeProcedureException(database, procedureName, e);
}
}
/// <summary>
/// Assembly-scoped class for returning a DataReader.
/// </summary>
/// <param name="database"></param>
/// <param name="procedureName"></param>
/// <param name="parameterMapper"></param>
/// <param name="resultMapper"></param>
/// <returns></returns>
public static void ExecuteAndMapResults(Database database, string procedureName, ParameterMapper parameterMapper, ResultMapper resultMapper)
{
SqlConnection connection = database.GetAsyncConnection();
SqlCommand command = CommandFactory.CreateParameterMappedCommand(connection, procedureName, parameterMapper);
bool isCompleted = false;
try
{
command.Connection.Open();
command.BeginExecuteReader(
delegate(IAsyncResult result)
{
try
{
SqlDataReader reader = command.EndExecuteReader(result);
resultMapper(new DataRecord(reader));
Debug.WriteLine("ExecuteAndMapResults async callback on thread: " + Thread.CurrentThread.ManagedThreadId);
}
finally
{
CloseAsyncConnection(command);
isCompleted = true;
}
}
, command
);
}
catch
{
CloseAsyncConnection(command);
throw;
}
while (!isCompleted)
{
Thread.Sleep(200);
}
}
