public SuggestionResponse Suggest(SearchRequest request)
{
SuggestionResponse result = new SuggestionResponse();
result.Suggestions = _searchService.GetSearchSuggestions(request.SearchQuery);
return(result);
}
public async Task <ActionResult> One()
{
var state = Session["SuggestionState"] as SuggestionState?;
if (state == SuggestionState.QuestionAnswered)
{
var user = await GetUser();
var suggestion = GetSuggestion(user);
if (suggestion == null)
{
return(GetErrorPage());
}
var model = new SuggestionResponse()
{
Id = suggestion.Id,
Text = suggestion.Text,
Description = suggestion.Description
};
return(View(model));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public async Task PutAsyncTest()
{
// Arrange
var mockSuggestionRepository = GetDefaultISuggestionRepositoryInstance();
var mockUserRepository = GetDefaultIUserRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
Suggestion suggestion = new Suggestion();
int suggestionId = 1;
suggestion.Id = suggestionId;
suggestion.Message = "mejorar";
Suggestion suggestionExpected = new Suggestion();
suggestionExpected.Message = "es bueno";
mockSuggestionRepository.Setup(r => r.FindById(suggestionId))
.Returns(Task.FromResult <Suggestion>(suggestion));
var service = new SuggestionService(mockSuggestionRepository.Object,
mockUnitOfWork.Object, mockUserRepository.Object);
// Act
SuggestionResponse result = await service.UpdateASync(suggestionId, suggestionExpected);
// Assert
Assert.AreEqual(suggestionExpected.Message, result.Resource.Message);
}
private static void HandleSuggestionResponse(SuggestionResponse packet)
{
if (packet.Successful)
{
MessageBox.Show("Thank you for your suggestion!", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("There was an error submitting your suggestion.", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public IActionResult SuggestionForm(SuggestionResponse appResponse)
{
if (ModelState.IsValid)
{
TempStorage.AddApplication(appResponse);
return(View("Confirmation", appResponse));
}
else
{
return(View(appResponse));
}
}
public IActionResult SubmitSuggestion(SuggestionResponse suggestionResponse)
{
if (ModelState.IsValid)
{
AddedSuggestions.AddSuggestions(suggestionResponse);
return(View("Confirmation", suggestionResponse));
}
else
{
return(View());
}
}
public IActionResult Suggestions(SuggestionResponse suggResponse)
{
if (ModelState.IsValid)
{
Storage.AddSuggestion(suggResponse);
return(View("Confirmation", suggResponse));
}
else
{
return(View());
}
}
public virtual async Task <SuggestionResponse> Suggest(SearchRequest request)
{
SuggestionResponse result = new SuggestionResponse();
int tenantID = GetAppTenantID();
result.Suggestions = await Task.Factory.StartNew <List <string> >(new Func <List <string> >(() =>
{
List <string> rawResult = new List <string>();
rawResult.AddRange(_searchService.GetSearchSuggestions(request.SearchQuery, tenantID));
return(rawResult);
}));
return(result);
}
public ActionResult Create(ConnectorModel connectorModel)
{
try
{
if (connectorModel.CK_Id > 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Providing custom CK_Id is not allowed, Connector.CK_Id is Auto-Generated !"));
}
var connector = _Mapper.Map <Connector>(connectorModel);
connector = _ConnectorService.CreateConnector(connector);
return(Ok(_Mapper.Map <ConnectorModel>(connector)));
}
catch (ConnectorMaxCurrentExceedGroupCapacityException ex)
{
return(StatusCode(StatusCodes.Status400BadRequest, ex.Message));
}
catch (ConnectorsMaxCurrentExceedGroupCapacityException ex)
{
//get chargeStation
var chargeStation = _ChargeStationService.GetChargeStation(connectorModel.ChargeStationId);
//get connectors of group
var connectorsOFGroup = _ConnectorService.GetConnectorsByGroup(chargeStation.GroupId);
//get suggestions
var suggestions = _Suggester.GetSuggestions(connectorsOFGroup, connectorModel.MaxCurrent);
//Create suggestionResponse
var response = new SuggestionResponse {
ErrorMessage = ex.Message
};
response.Suggestions = _Mapper.Map <List <SuggestionModel> >(suggestions);
return(BadRequest(response));
}
catch (DataException ex)
{
return(StatusCode(StatusCodes.Status400BadRequest, ex.Message));
}
catch (DomainValidationException ex)
{
return(StatusCode(StatusCodes.Status400BadRequest, ex.Message));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task SaveAsyncWhenFacultiesReturnsSuccess()
{
var mockSuggestionRepository = GetDefaultISuggestionRepositoryInstance();
var mockUserRepository = GetDefaultIUserRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
Suggestion suggestion = new Suggestion();
mockSuggestionRepository.Setup(r => r.AddAsync(suggestion))
.Returns(Task.FromResult <Suggestion>(suggestion));
var service = new SuggestionService(mockSuggestionRepository.Object,
mockUnitOfWork.Object, mockUserRepository.Object);
SuggestionResponse result = await service.SaveAsync(suggestion);
var message = result.Message;
message.Should().Be("");
}
private void ParserBaiduSearchResult(string str, out List <string> similarWords)
{
similarWords = new List <string>();
if (str.Length < 19)
{
return;
}
str = str.Substring(17);
str = str.Substring(0, str.Length - 2);
str = "{\"sr\":" + str + "}";
SuggestionResponse sr = new SuggestionResponse(str);
foreach (var i in sr.similarWords)
{
similarWords.Add(i.ToString());
}
}
public async Task GetAsyncTestUnhappy()
{
// Arrange
var mockSuggestionRepository = GetDefaultISuggestionRepositoryInstance();
var mockUserRepository = GetDefaultIUserRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
int suggestionId = 1;
var service = new SuggestionService(mockSuggestionRepository.Object,
mockUnitOfWork.Object, mockUserRepository.Object);
// Act
SuggestionResponse result = await service.GetByIdAsync(suggestionId);
var message = result.Message;
// Assert
message.Should().Be("Suggestion not found");
}
//[ValidateAntiForgeryToken]
public async Task <ActionResult> One(SuggestionResponse model)
{
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated)
{
var user = await GetUser();
var val = db.UserSuggestions.Find(user.Id, model.Id);
if (val != null && val.Status == SuggestionStatus.NotToday)
{
val.Status = SuggestionStatus.Completed;
db.Entry(val).State = System.Data.Entity.EntityState.Modified;
}
else
{
db.UserSuggestions.Add(new UserSuggestion()
{
Status = model.Status,
UserId = user.Id,
SuggestionId = model.Id
}
);
}
db.SaveChanges();
Session["SuggestionState"] = SuggestionState.Start;
//if (model.Status == SuggestionStatus.Completed)
// Session["SuggestionState"] = SuggestionState.SuggestionCompleted;
}
}
if (model.Status == SuggestionStatus.NeverAsk || model.Status == SuggestionStatus.NotToday)
{
return(RedirectToAction("One", "Proposition"));
}
else
{
return(RedirectToAction("Ask", "Inquiry"));
}
}
public static Clue RespondToSuggestion(int playerId, int suggestionID, int clueID = -1, string ClueType = "")
{
Clue responseClue = new Clue();
SuggestionResponse response;
ClueLessContext db = new ClueLessContext();
if (clueID > 0)
{
responseClue = RevealClue(playerId, clueID, ClueType, suggestionID);
response = new SuggestionResponse
{
SuggestionID = suggestionID,
Response = "Revealed Clue",
RevealedClueID = clueID,
RevealedClueTable = ClueType
};
db.SaveChanges();
}
else
{
response = new SuggestionResponse
{
SuggestionID = suggestionID,
Response = "Pass"
};
db.SaveChanges();
Database.DataModels.Suggestion suggestion = db.Suggestions.Where(x => x.ID == suggestionID).FirstOrDefault();
int nextPlayerID = FindNextResponder(suggestionID);
Database.DataModels.Player currentResponder = db.Players.Where(x => x.ID == suggestion.PlayerID).FirstOrDefault();
currentResponder.IsCurrentRespondingPlayer = false;
db.SaveChanges();
if (nextPlayerID != suggestion.PlayerID)
{
Database.DataModels.Player nextResponder = db.Players.Where(x => x.ID == nextPlayerID).FirstOrDefault();
nextResponder.IsCurrentRespondingPlayer = true;
db.SaveChanges();
}
}
return(responseClue);
}
public ActionResult SuggestionConfirmation()
{
var state = Session["SuggestionState"] as SuggestionState?;
if (state == SuggestionState.SuggestionSelected)
{
var suggestionId = Session["SuggestionId"] as int?;
if (suggestionId != null)
{
SuggestionResponse suggestion = new SuggestionResponse(db.Suggestions.Find(suggestionId));
return(View(suggestion));
}
}
else
{
return(RedirectToAction("Index", "Home"));
}
return(GetErrorPage());
}
public async Task GetAsyncTestHappy()
{
// Arrange
var mockSuggestionRepository = GetDefaultISuggestionRepositoryInstance();
var mockUserRepository = GetDefaultIUserRepositoryInstance();
var mockUnitOfWork = GetDefaultIUnitOfWorkInstance();
Suggestion suggestion = new Suggestion();
int suggestionId = 1;
suggestion.Id = suggestionId;
mockSuggestionRepository.Setup(r => r.FindById(suggestionId))
.Returns(Task.FromResult <Suggestion>(suggestion));
var service = new SuggestionService(mockSuggestionRepository.Object,
mockUnitOfWork.Object, mockUserRepository.Object);
// Act
SuggestionResponse result = await service.GetByIdAsync(suggestionId);
// Assert
Assert.AreEqual(suggestion, result.Resource);
}
public IActionResult AddSuggestions(SuggestionResponse suggestionResponse)
{
SuggestionStorage.AddSuggestion(suggestionResponse);
return(View("SuggestionConfirmation", suggestionResponse)); // pass in the object with the model
}
public ActionResult PostOne(SuggestionResponse model)
{
Session["SuggestionState"] = SuggestionState.SuggestionSelected;
Session["SuggestionId"] = model.Id;
return(RedirectToAction("SuggestionConfirmation"));
}
