private void ResolveParentId(AnswerModel model, CommentEntity from)
{
if (from.Parent is AnswerEntity)
{
model.AnswerId = from.Parent.Id;
}
if (from.Parent is QuestionEntity)
{
model.QuestionId = from.Parent.Id;
}
}
public IActionResult MarkAnswerAccepted(int answerID)
{
AnswerModel answer = Idao.GetAnswerById(answerID);
QuestionModel question = Idao.GetQuestionById(answer.Question_Id);
question.AcceptedAnswerID = answer.Id;
Idao.GetUserById(answer.User_Id).IncreaseReputation(15);
Idao.UpdateQuestionAcceptedAnswer(question);
return(View("Question", question));
}
public void AddAnswer(AnswerModel item)
{
string sql = "INSERT INTO Answers (AnswerContent, QuestionId, IsCorrect) VALUES (@answerContent, @questionId, @isCorrect);";
_sqlDataAccess.SaveData(sql, new
{
answerContent = item.AnswerContent,
questionId = item.QuestionId,
isCorrect = item.IsCorrect
});
}
public AnswerModel Execute(CommentEntity from)
{
var model = new AnswerModel();
model.KindOf = (int)AnswerKind.Comment;
model.Id = from.Id;
model.Body = from.Body;
model.UserId = from.UserId;
ResolveParentId(model, from);
return(model);
}
public IHttpActionResult PostAnswer([FromBody] AnswerModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = _gameService.UpdateModel(model);
return(Json(result));
}
/// <summary>
/// Description: TEST CODE FOR POSTING ANSWER TO API WORKS
/// Status: NEED TO CREATE NEW CODE
/// </summary>
/// <param name="data"></param>
public static void PostAnswer(AnswerModel data)
{
const string medType = "application/json";
var postData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, medType);
var response = client.PostAsync(Route("Module"), postData).Result;
if (response.IsSuccessStatusCode != true)
{
throw new Exception($"Response from server API Failed for POST {Route("Module")} no id, check IP config");
}
}
public IActionResult Put(int id, [FromBody] AnswerModel model)
{
var answer = ModelFactory.Map(model);
answer.AnswerId = id;
if (!DataService.Update(answer))
{
return(NotFound());
}
return(Ok());
}
public void Handle(ClaimsIdentity result)
{
if (result == null)
{
answer = new AnswerModel(400, null, "Invalid Username or Password");
}
else
{
answer = new AnswerModel(200, null, "Succeeded");
}
}
public void Handle(User result)
{
if (result == null)
{
answer = new AnswerModel(400, null, "This user doesn't have yet");
}
else
{
answer = new AnswerModel(200, null, "Succeeded");
}
}
public void Handle(SignInResult result)
{
if (!result.Succeeded)
{
answer = new AnswerModel(400, null, "Invalid Username or Password");
}
else
{
answer = new AnswerModel(200, null, "Succeeded");
}
}
public void Handle(IdentityResult error)
{
if (error.ToString() != "Succeeded")
{
answer = new AnswerModel(400, null, error.ToString());
}
else
{
answer = new AnswerModel(200, null, "Succeeded");
}
}
private LikeAnswer BuildAnswerLike(AnswerModel model, ApplicationUser user)
{
var answer = _questionImplementation.GetAnswerById(model.AnswerId);
return(new LikeAnswer
{
Answer = answer,
IsLike = true,
User = user
});
}
public string SingleFormQuestion(string answer)
{
AnswerModel a = new AnswerModel();
a.AnswerText = answer;
db.SetAnswers.Add(a);
db.SaveChanges();
return(answer.ToString());
}
public async Task <IActionResult> AddLikeAnswer(AnswerModel model)
{
var userId = _userManager.GetUserId(User);
var user = await _userManager.FindByIdAsync(userId);
var likeAnswer = BuildAnswerLike(model, user);
await _questionImplementation.AddAnswerLike(likeAnswer);
return(RedirectToAction("Index", "Question", new { id = model.QuestionId }));
}
public async Task <AnswerModel> GetAnswer(int AssignmentID, int UserID)
{
var Param = new SqlParameter[]
{
new SqlParameter("@AssignmentID", AssignmentID),
new SqlParameter("@UserID", UserID)
};
AnswerModel answer = await _AnswerRepository.ExecSPToSingleAsync("bn_RecDB_GetAnswer @AssignmentID, @UserID", Param);
return(answer);
}
public static void HandleRequestError(AnswerModel response, Action <AnswerModel> errorMethod)
{
Debug.Log("Error");
if (response.Errors != null)
{
Debug.Log(response.Errors);
}
if (errorMethod != null)
{
errorMethod(response);
}
}
public JsonResult getTableRow(int id_q, int id_a)
{
if (id_a == 0)
{
return(Json(db.SetTableRows.Where(u => u.TableID == id_q).ToList(), JsonRequestBehavior.AllowGet));
}
else
{
AnswerModel tmp = db.SetAnswers.FirstOrDefault(u => u.Id == id_a);
return(Json(db.SetTableRows.Where(u => u.TableID == id_q && (u.IndexRow == tmp.Index || u.IndexRow == null)).ToList(), JsonRequestBehavior.AllowGet));
}
}
public GameModel UpdateModel(AnswerModel answer)
{
string mask = GetMask(answer.HiddenNumber, answer.Value);
return(new GameModel
{
Mask = mask,
HiddenNumber = answer.HiddenNumber,
AttemptsCount = answer.AttemptsCount + 1,
Success = answer.HiddenNumber == answer.Value
});
}
private static bool CheckAllWordsAnswer(
string userAnswer,
IEnumerable <AnswerModel> allWordAnswers,
bool exactAnswer,
out AnswerModel validAnswer)
{
validAnswer = null;
var splittedUserAnswer = userAnswer.SplitStringByDelimiter(" ");
if (splittedUserAnswer.Count == 1)
{
return(false);
}
foreach (var answer in allWordAnswers)
{
var rightWords = answer.AllWordsInside.Select(a => a).ToIList();
if (!rightWords.Any())
{
continue;
}
foreach (var userAnswerWord in splittedUserAnswer.TakeWhile(userAnswerWord => rightWords.Any()))
{
string rightWord;
if (exactAnswer)
{
rightWord =
rightWords.FirstOrDefault(
w => string.Equals(w, userAnswerWord, StringComparison.OrdinalIgnoreCase));
}
else
{
rightWord =
rightWords.FirstOrDefault(
w => userAnswerWord.IndexOf(w, StringComparison.OrdinalIgnoreCase) >= 0);
}
if (!string.IsNullOrEmpty(rightWord))
{
rightWords.Remove(rightWord);
}
}
if (!rightWords.Any())
{
validAnswer = answer;
break;
}
}
return(validAnswer != null);
}
public IActionResult Put(int id, [FromBody] AnswerModel resposta)
{
if (id != resposta.QuestionId)
{
return(BadRequest());
}
var answer = _mapper.Map <Answer>(resposta);
_answerService.Add(answer);
return(Ok());
}
public async Task <IActionResult> Create([Bind("Id,AnswerOption,QuestionId")] AnswerModel answerModel)
{
if (ModelState.IsValid)
{
_context.Add(answerModel);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "Question"));
}
ViewData["QuestionId"] = new SelectList(_context.Questions, "Id", "Question", answerModel.QuestionId);
return(View(answerModel));
}
private void Start()
{
instance = this;
if (SceneManager.GetActiveScene().name.Contains("4"))
{
SetupAnswerArray(4);
}
else
{
SetupAnswerArray(6);
}
}
public ActionResult UserCreateAnswer(AnswerModel model)
{
model.Id = Guid.NewGuid();
_unitOfWorkAsync.Repository <AnswerModel>().Insert(model);
_unitOfWorkAsync.SaveChanges();
if (Request.IsAjaxRequest())
{
var _objects = _questionManager.GetAnswers(model.QuestionId.Value);
return(PartialView("Answers/_Answers", _objects));
}
return(RedirectToAction("Index"));
}
public ActionResult Create([Bind(Include = "Id,Body,ApprovedAnswer,DateAnswered,UserId,PostId")] AnswerModel answerModel)
{
if (ModelState.IsValid)
{
db.Answers.Add(answerModel);
db.SaveChanges();
int detailInt = (int)TempData["PostId"];
return(RedirectToAction("Details", "Post", new { Id = detailInt }));
}
return(View(answerModel));
}
public async Task <Answer> Create(AnswerModel answerModel)
{
var userId = string.Empty;
var role = string.Empty;
if (HttpContext.User.Identity is ClaimsIdentity identity)
{
userId = identity.FindFirst(ClaimTypes.Name)?.Value;
role = identity.FindFirst(ClaimTypes.Role)?.Value;
}
return(await _answerService.Create(answerModel, userId));
}
private void LoadCommentEntityToModel(AnswerEntity entity, AnswerModel model)
{
entity.Comments.ToList().ForEach(comment =>
{
var newComment = _commentFactory.Execute(comment);
if (newComment.Id == Guid.Empty)
{
newComment.Id = Guid.NewGuid();
}
model.Comments.Add(newComment);
});
}
public async Task <AnswerModel> CheckServer()
{
AnswerModel result = new AnswerModel();
Uri baseAddress = new Uri(DOMAIN);
CookieContainer cookieContainer = new CookieContainer();
using (var handler = new HttpClientHandler()
{
CookieContainer = cookieContainer
})
{
using (var client = new HttpClient(handler)
{
BaseAddress = baseAddress
})
{
cookieContainer.Add(baseAddress, new Cookie(NAME, App.UserToken));
HttpResponseMessage answer = null;
try
{
answer = await client.GetAsync(DOMAIN + "Alive");
answer.EnsureSuccessStatusCode();
}
catch (HttpRequestException ex)
{
result.errorMessageList.Add(ex.Message);
}
catch (SocketException ex)
{
result.errorMessageList.Add(ex.Message);
}
catch (WebException ex)
{
WebExceptionStatus status = ex.Status;
if (status == WebExceptionStatus.ProtocolError)
{
HttpWebResponse httpResponse = (HttpWebResponse)ex.Response;
result.errorMessageList.Add(string.Format("Статусный код ошибки: {0} - {1}", (int)httpResponse.StatusCode, httpResponse.StatusCode));
}
}
if (answer != null && answer.StatusCode == HttpStatusCode.OK)
{
result.Result = true;
}
}
}
return(await Task.FromResult(result));
}
public AnswerModel Execute(AnswerEntity from)
{
var model = new AnswerModel();
model.Id = from.Id;
model.KindOf = (int)from.Kind;
model.QuestionId = from.Parent.Id;
model.Body = from.Body;
model.UserId = from.UserId;
LoadCommentEntityToModel(from, model);
return(model);
}
public AnswerModel Solve()
{
AnswerModel answer = new AnswerModel();
// Keep track of current frequency.
int frequency = 0;
// Keep track of visited frequencies.
HashSet <int> frequencyVisited = new HashSet <int>();
// True if frequency is passed twice.
bool revisit = false;
// False when full input is parsed for first time.
bool firstRun = true;
// Loop until frequency is passed twice.
while (!revisit)
{
// Itterate over every input line.
foreach (string line in _input)
{
// Parse input to integer.
int value = int.Parse(line);
// Add input to current frequency.
frequency += value;
// Only check for revisit if not yet found.
if (!revisit)
{
// If we cant add the frequency then a revisit occurs.
revisit = !frequencyVisited.Add(frequency);
if (revisit)
{
// Save the answer for part B.
answer.PartB = $"{frequency}";
}
}
}
// If the first run is completed save the answer for part A.
if (firstRun)
{
answer.PartA = frequency;
firstRun = false;
}
}
// Return the answer.
return(answer);
}
public async Task GetAll()
{
// arrange
var modelChild = new AnswerModel
{
Id = 1,
FirstName = "First Name",
LastName = "Last Name",
GenderId = 1
};
_context.Answer.Add(modelChild);
var modelParent = new AnswerModel
{
Id = 2,
FirstName = "2First Name",
LastName = "2Last Name",
GenderId = 1
};
_context.Answer.Add(modelParent);
var model = new AnswerModel
{
Id = 3,
FirstName = "3First Name",
LastName = "3Last Name",
GenderId = 1
};
_context.Answer.Add(model);
_context.AnswerParentChild.Add(new AnswerParentChildModel {
Child = modelChild, Parent = model
});
_context.AnswerParentChild.Add(new AnswerParentChildModel {
Child = model, Parent = modelParent
});
await _context.SaveChangesAsync();
// act
var response = await _client.GetAsync($"{_address}");
// assert
response.EnsureSuccessStatusCode();
var result = JsonConvert.DeserializeObject <List <AnswerViewModel> >(await response.Content.ReadAsStringAsync()).OrderBy(x => x.Info.Id).ToList();
Assert.Equal(modelChild.Id, result[0].Info.Id);
Assert.Equal(modelParent.Id, result[1].Info.Id);
Assert.Equal(model.Id, result[2].Info.Id);
}
