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