public async Task AppendSurveyAnswerIdToAnswersListGetTheAnswersListBlob()
{
var mockSurveyAnswerContainerFactory = new Mock <AzureBlobContainerFactory <Tailspin.SurveyAnswerService.Models.SurveyAnswer> >();
var mockSurveyAnswerListContainerFactory = new Mock <AzureBlobContainerFactory <List <string> > >();
var mockSurveyAnswerContainer = new Mock <IAzureBlobContainer <Tailspin.SurveyAnswerService.Models.SurveyAnswer> >();
var mockSurveyAnswerListContainer = new Mock <IAzureBlobContainer <List <string> > >();
var service = new SurveyAnswerService(
this.CreateServiceContext(),
mockSurveyAnswerContainerFactory.Object,
mockSurveyAnswerListContainerFactory.Object,
new Mock <ISurveyAnalysisService>().Object);
mockSurveyAnswerContainerFactory.Setup(f => f(It.IsAny <string>()))
.Returns(mockSurveyAnswerContainer.Object);
mockSurveyAnswerListContainerFactory.Setup(f => f(It.IsAny <string>()))
.Returns(mockSurveyAnswerListContainer.Object);
var surveyAnswer = new SurveyAnswer()
{
SlugName = "slug-name"
};
await service.SaveSurveyAnswerAsync(surveyAnswer);
mockSurveyAnswerListContainer.Verify(f => f.SaveAsync(It.Is <string>(s => s == surveyAnswer.SlugName),
It.IsAny <List <string> >()), Times.Once);
}
public async Task SaveSurveyAnswerSavesAnswerInBlobContainerWithId()
{
var mockSurveyAnswerContainerFactory = new Mock <AzureBlobContainerFactory <Tailspin.SurveyAnswerService.Models.SurveyAnswer> >();
var mockSurveyAnswerListContainerFactory = new Mock <AzureBlobContainerFactory <List <string> > >();
var mockSurveyAnswerContainer = new Mock <IAzureBlobContainer <Tailspin.SurveyAnswerService.Models.SurveyAnswer> >();
var service = new SurveyAnswerService(
this.CreateServiceContext(),
mockSurveyAnswerContainerFactory.Object,
mockSurveyAnswerListContainerFactory.Object,
new Mock <ISurveyAnalysisService>().Object);
mockSurveyAnswerContainerFactory.Setup(f => f(It.IsAny <string>()))
.Returns(mockSurveyAnswerContainer.Object);
mockSurveyAnswerListContainerFactory.Setup(f => f(It.IsAny <string>()))
.Returns(new Mock <IAzureBlobContainer <List <string> > >().Object);
var surveyAnswer = new SurveyAnswer()
{
SlugName = "slug-name"
};
await service.SaveSurveyAnswerAsync(surveyAnswer);
mockSurveyAnswerContainer.Verify(f => f.SaveAsync(It.Is <string>(s => s.Length == 19),
It.IsAny <Tailspin.SurveyAnswerService.Models.SurveyAnswer>()));
}
private static void AddCompanyAnswer(PropertyInfo propertyInfo, SurveyAnswer answer, Interviewee interviewee)
{
var companyName =
propertyInfo.GetCustomAttribute <CompanyNameAttribute>()?.Name
?? propertyInfo.GetCustomAttribute <JsonPropertyAttribute>()?.PropertyName
?? propertyInfo.Name;
var propertyValue = (SurveyCompanyAnswer)propertyInfo.GetValue(answer.CompaniesQuestion);
if (propertyValue == null)
{
return;
}
if (!Companies.ContainsKey(companyName))
{
var c = new Company {
Id = Guid.NewGuid(), Name = companyName
};
Companies.Add(c.Name, c);
}
Answers.Add(new CompanyAnswer
{
Id = Guid.NewGuid(),
IntervieweeId = interviewee.Id,
CompanyId = Companies[companyName].Id,
IsKnown = propertyValue.ЗнаюСлышал,
IsGood = propertyValue.Готоврекомендовать?.Any() ?? false,
IsWanted = propertyValue.Хочуработать?.Any() ?? false
});
}
public ActionResult PostAnswers([FromBody] SurveyAnswerRequest req) {
SurveyTaker taker = new SurveyTaker();
taker.Uid = Guid.NewGuid().ToString();
taker.Turk = req.Turk;
taker.SurveyUid = req.SurveyUid;
var answerList = req.AnswerList;
_context.SurveyTaker.Add(taker);
for (int i = 0; i < answerList.Length; i++)
{
if (answerList[i] != null)
{
SurveyAnswer answer = new SurveyAnswer();
answer.Uid = Guid.NewGuid().ToString();
answer.SurveyTakerUid = taker.Uid;
answer.SurveyUid = req.SurveyUid;
answer.Answer = answerList[i];
answer.DateCompleted = DateTime.Now;
answer.Qid = i;
_context.SurveyAnswer.Add(answer);
}
}
_context.SaveChanges();
return Ok(new { message = "Success!" });
}
public ActionResult BrowseResponses(string tenant, string surveySlug, string answerId)
{
SurveyAnswer surveyAnswer = null;
if (string.IsNullOrEmpty(answerId))
{
answerId = this.surveyAnswerStore.GetFirstSurveyAnswerId(tenant, surveySlug);
}
if (!string.IsNullOrEmpty(answerId))
{
surveyAnswer = this.surveyAnswerStore.GetSurveyAnswer(tenant, surveySlug, answerId);
}
var surveyAnswerBrowsingContext = this.surveyAnswerStore.GetSurveyAnswerBrowsingContext(tenant, surveySlug, answerId);
var browseResponsesModel = new BrowseResponseModel
{
SurveyAnswer = surveyAnswer,
PreviousAnswerId = surveyAnswerBrowsingContext.PreviousId,
NextAnswerId = surveyAnswerBrowsingContext.NextId
};
var model = this.CreateTenantPageViewData(browseResponsesModel);
model.Title = surveySlug;
return(this.View(model));
}
private List <SurveyAnswer> method_0()
{
SurveyAnswer surveyAnswer = new SurveyAnswer();
surveyAnswer.QUESTION_NAME = this.QuestionName;
surveyAnswer.CODE = this.SelectedCode;
surveyAnswer.MULTI_ORDER = 0;
surveyAnswer.BEGIN_DATE = new DateTime?(this.QInitDateTime);
surveyAnswer.MODIFY_DATE = new DateTime?(DateTime.Now);
List <SurveyAnswer> list = new List <SurveyAnswer>();
list.Add(surveyAnswer);
if (this.OtherCode != null && this.OtherCode != "")
{
list.Add(new SurveyAnswer
{
QUESTION_NAME = this.QuestionName + "_OTH",
CODE = this.FillText,
MULTI_ORDER = 0,
BEGIN_DATE = new DateTime?(this.QInitDateTime),
MODIFY_DATE = new DateTime?(DateTime.Now)
});
}
return(list);
}
public async Task <IActionResult> PutSurveyAnswer(int id, SurveyAnswer surveyAnswer)
{
if (id != surveyAnswer.Id)
{
return(BadRequest());
}
_context.Entry(surveyAnswer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SurveyAnswerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task DisplayWhenPostThrowsIfSaveSurveyAnswersReadFromSurveyStoreHaveDifferentCountToTheSurveyAnswerParameter()
{
var surveyWith1Question = new ClientModels.Survey()
{
Questions = new List <ClientModels.Question>()
{
new ClientModels.Question()
}
};
var mockSurveyManagementService = new Mock <ISurveyManagementService>();
mockSurveyManagementService.Setup(r => r.GetSurveyAsync(It.IsAny <string>()))
.ReturnsAsync(surveyWith1Question);
var surveyAnswerWithoutQuestions = new SurveyAnswer();
using (var controller = new SurveysController(
mockSurveyManagementService.Object,
new Mock <ISurveyAnswerService>().Object,
new Mock <ISurveyResponseService>().Object))
{
await AssertEx.ThrowsExceptionAsync <ArgumentException>(
async() => await controller.Display(string.Empty, surveyAnswerWithoutQuestions),
string.Empty, null);
}
}
public async Task <ActionResult> Display(string tenantId, string surveySlug, SurveyAnswer contentModel)
{
var surveyAnswer = await this.CallGetSurveyAndCreateSurveyAnswerAsync(tenantId, surveySlug);
if (surveyAnswer.QuestionAnswers.Count != contentModel.QuestionAnswers.Count)
{
throw new ArgumentException("The survey answers received have different amount of questions than the survey to be filled.");
}
for (int i = 0; i < surveyAnswer.QuestionAnswers.Count; i++)
{
surveyAnswer.QuestionAnswers[i].Answer = contentModel.QuestionAnswers[i].Answer;
}
if (!this.ModelState.IsValid)
{
var model = new TenantPageViewData <SurveyAnswer>(surveyAnswer);
model.Title = surveyAnswer.Title;
return(this.View(model));
}
await this.surveyAnswerStore.SaveSurveyAnswerAsync(surveyAnswer);
return(this.RedirectToAction("ThankYou"));
}
public ActionResult TakeSurvey(FormCollection form)
{
//SurveyAnswer surveyAnswer[] = new SurveyAnswer();
List <SurveyAnswer> surveyAnswer = new List <SurveyAnswer>();
var count = (form.Count) - 1;
var SurveyId = Int32.Parse(form["sId"]);
for (int i = 0; i < count; i++)
{
SurveyAnswer s = new SurveyAnswer();
surveyAnswer.Add(s);
}
//To know which user is logged in
var usermail = User.Identity.GetUserName();
var cId = (from c in db.Candidate where c.Email == usermail select c.CandidateId).ToList();
List <UserQuestion> uq = db.UserQuestion.Where(u => u.SurveyId == SurveyId).ToList();
var cid = cId.ElementAt(0);
for (int i = 1; i <= count; i++)
{
surveyAnswer.ElementAt(i - 1).SurveyId = SurveyId;
surveyAnswer.ElementAt(i - 1).CandidateId = cid;
surveyAnswer.ElementAt(i - 1).SurveyQuesNo = i;
surveyAnswer.ElementAt(i - 1).UQuestionId = uq.ElementAt(i - 1).UQuestionId;
surveyAnswer.ElementAt(i - 1).Answer = form["Ans" + i];
db.SurveyAnswer.Add(surveyAnswer.ElementAt(i - 1));
db.SaveChanges();
}
return(RedirectToAction("SurveyList", "Surveys"));
}
public void DisplayWhenPostReturnsSurveyTitleAsTitleInTheModelWhenModelIsNotValid()
{
var mockSurveyStore = new Mock <ISurveyStore>();
var survey = new Survey
{
Title = "title",
Questions = new List <Question>(new[] { new Question() })
};
mockSurveyStore.Setup(r => r.GetSurveyByTenantAndSlugName(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(survey);
var surveyAnswer = new SurveyAnswer
{
QuestionAnswers = new List <QuestionAnswer>(new[] { new QuestionAnswer() })
};
using (var controller = new SurveysController(mockSurveyStore.Object, default(ISurveyAnswerStore)))
{
controller.ModelState.AddModelError("error for test", "invalid model state");
var result = controller.Display(string.Empty, string.Empty, surveyAnswer) as ViewResult;
var model = result.ViewData.Model as TenantMasterPageViewData;
Assert.AreSame("title", model.Title);
}
}
public void RunAddsTheSurveyAnswerToTheSummary()
{
var mockTenantSurveyProcessingInfo = new Mock <TenantSurveyProcessingInfo>("tenant", "slug-name");
var mockTenantSurveyProcessingInfoObj = mockTenantSurveyProcessingInfo.Object;
var mockTenantSurveyProcessingInfoCache = new Mock <IDictionary <string, TenantSurveyProcessingInfo> >();
var mockSurveyAnswerStore = new Mock <ISurveyAnswerStore>();
var command = new UpdatingSurveyResultsSummaryCommand(mockTenantSurveyProcessingInfoCache.Object, mockSurveyAnswerStore.Object, new Mock <ISurveyAnswersSummaryStore>().Object);
mockTenantSurveyProcessingInfoCache.Setup(c => c.ContainsKey("tenant-slug-name")).Returns(true);
mockTenantSurveyProcessingInfoCache.Setup(c => c["tenant-slug-name"]).Returns(mockTenantSurveyProcessingInfoObj);
var surveyAnswer = new SurveyAnswer()
{
Tenant = "tenant", SlugName = "slug-name"
};
mockSurveyAnswerStore.Setup(r => r.GetSurveyAnswer(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(surveyAnswer);
var message = new SurveyAnswerStoredMessage
{
Tenant = "tenant",
SurveySlugName = "slug-name",
AppendedToAnswers = true
};
command.Run(message);
Assert.AreEqual(1, mockTenantSurveyProcessingInfoObj.AnswersSummary.TotalAnswers);
}
public async Task DisplayWhenPostReturnsModelWithTheAnswersReadFromTheParameterWhenModelIsNotValid()
{
var mockSurveyManagementService = new Mock <ISurveyManagementService>();
var survey = new Tailspin.SurveyManagementService.Client.Models.Survey()
{
Questions = new List <Tailspin.SurveyManagementService.Client.Models.Question>()
{
new Tailspin.SurveyManagementService.Client.Models.Question()
}
};
mockSurveyManagementService.Setup(r => r.GetSurveyAsync(It.IsAny <string>()))
.ReturnsAsync(survey);
var surveyAnswer = new SurveyAnswer
{
QuestionAnswers = new List <QuestionAnswer>()
{
new QuestionAnswer
{
Answer = "answer"
}
}
};
using (var controller = new SurveysController(mockSurveyManagementService.Object, new Mock <ISurveyAnswerService>().Object))
{
controller.ModelState.AddModelError("error for test", "invalid model state");
var result = await controller.Display(string.Empty, surveyAnswer) as ViewResult;
var model = result.ViewData.Model as PageViewData <SurveyAnswer>;
Assert.AreEqual("answer", model.ContentModel.QuestionAnswers.First().Answer);
}
}
public void DisplayWhenPostCallsSaveSurveyAnswerFromSurveyAnswerStoreWithAnswerReadFromTheParameterWhenModelIsValid()
{
var survey = new Survey
{
Questions = new List <Question>(new[] { new Question() })
};
var mockSurveyStore = new Mock <ISurveyStore>();
mockSurveyStore.Setup(r => r.GetSurveyByTenantAndSlugName(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(survey);
var mockSurveyAnswerStore = new Mock <ISurveyAnswerStore>();
var surveyAnswer = new SurveyAnswer
{
QuestionAnswers = new List <QuestionAnswer>(new[] { new QuestionAnswer {
Answer = "answer"
} })
};
using (var controller = new SurveysController(mockSurveyStore.Object, mockSurveyAnswerStore.Object))
{
controller.Display(string.Empty, string.Empty, surveyAnswer);
}
mockSurveyAnswerStore.Verify(
r => r.SaveSurveyAnswer(
It.Is <SurveyAnswer>(sa => "answer" == sa.QuestionAnswers[0].Answer)),
Times.Once());
}
// GET: Surveys/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Survey survey = db.Surveys.Find(id);
if (survey == null)
{
return(HttpNotFound());
}
ViewBag.NumResponse = db.SurveyResponses.Where(sr => sr.SurveyID == survey.SurveyID).Count();
var questions = survey.SurveyQuestions;
var surveyResponse = from sr in db.SurveyResponses
where sr.SurveyID == survey.SurveyID
select sr;
//select new ResponseAndAnswer { response = sr, answers = SurveyAnswer.FromDB(sr.SurveyMAAs, sr.SurveyMCAs, sr.SurveySAAs)};
var s = surveyResponse.ToList().Select(sr => {
return(new ResponseAndAnswer(sr, SurveyAnswer.FromDB(sr.SurveyMAAs, sr.SurveyMCAs, sr.SurveySAAs)));
});
ViewBag.Questions = questions;
ViewBag.SurveyResponse = s.ToList();
return(View(survey));
}
public async Task DisplayWhenPostCallsSaveSurveyAnswerFromSurveyAnswerStoreWithAnswerReadFromTheParameterWhenModelIsValid()
{
var survey = new Tailspin.SurveyManagementService.Client.Models.Survey()
{
Questions = new List <Tailspin.SurveyManagementService.Client.Models.Question>()
{
new Tailspin.SurveyManagementService.Client.Models.Question()
}
};
var mockSurveyManagementService = new Mock <ISurveyManagementService>();
mockSurveyManagementService.Setup(r => r.GetSurveyAsync(It.IsAny <string>()))
.ReturnsAsync(survey);
var mockSurveyAnswerService = new Mock <ISurveyAnswerService>();
var surveyAnswer = new SurveyAnswer()
{
QuestionAnswers = new List <QuestionAnswer>()
{
new QuestionAnswer()
{
Answer = "answer"
}
}
};
using (var controller = new SurveysController(mockSurveyManagementService.Object, mockSurveyAnswerService.Object))
{
await controller.Display(string.Empty, surveyAnswer);
}
mockSurveyAnswerService.Verify(r => r.SaveSurveyAnswerAsync(
It.Is <Tailspin.SurveyAnswerService.Client.Models.SurveyAnswer>(sa => "answer" == sa.QuestionAnswers[0].Answer)),
Times.Once);
}
public string ReadAnswerByQuestionName(string string_0, string string_1)
{
string text = "";
SurveyAnswer one = this.oSurveyAnswerDal.GetOne(string_0, string_1);
return(one.CODE);
}
public static MsCrmResult AnswerSurvey(SurveyAnswer answer, IOrganizationService service)
{
MsCrmResult returnValue = new MsCrmResult();
try
{
Entity ent = new Entity("new_surveyanswer");
ent["new_name"] = answer.PortalUser.Name + "-" + DateTime.Now.ToString("dd.MM.yyyy HH:mm");
ent["new_portalid"] = answer.Portal;
ent["new_userid"] = answer.PortalUser;
ent["new_surveyid"] = answer.Survey;
ent["new_surveychoiceid"] = answer.SurveyChoice;
returnValue.CrmId = service.Create(ent);
returnValue.Success = true;
returnValue.Result = "M053"; //"Anket cevabınız alınmıştır. <br /> Katılımınız için teşekkür ederiz.";
}
catch (Exception ex)
{
returnValue.Result = ex.Message;
}
return returnValue;
}
public async Task <ActionResult> AnswerSurvey(Guid surveyId, [FromBody] SurveyAnswer answer)
{
var survey = surveys.SingleOrDefault(t => t.Id == surveyId);
if (survey == null)
{
return(NotFound());
}
if (((IExpirable)survey).IsExpired)
{
return(StatusCode(400, "This survey hasexpired"));
}
// WARNING: this isn’t thread safe since we store answers in a List!
survey.Answers.Add(new SurveyAnswer
{
SurveyId = surveyId,
Option = answer.Option
});
await hubContext.Clients.Group(surveyId.ToString()).SurveyUpdated(survey);
return(new JsonResult(survey));
}
public async Task DisplayWhenPostReturnsEmptyViewNameWhenModelIsNotValid()
{
var mockSurveyManagementService = new Mock <ISurveyManagementService>();
var survey = new ClientModels.Survey()
{
Questions = new List <ClientModels.Question>()
{
new ClientModels.Question()
}
};
mockSurveyManagementService.Setup(r => r.GetSurveyAsync(It.IsAny <string>()))
.ReturnsAsync(survey);
var surveyAnswer = new SurveyAnswer()
{
QuestionAnswers = new List <QuestionAnswer>()
{
new QuestionAnswer()
}
};
using (var controller = new SurveysController(
mockSurveyManagementService.Object,
new Mock <ISurveyAnswerService>().Object,
new Mock <ISurveyResponseService>().Object))
{
controller.ModelState.AddModelError("error for test", "invalid model state");
var result = await controller.Display(string.Empty, surveyAnswer) as ViewResult;
Assert.IsNull(result.ViewName);
}
}
public async Task DisplayWhenPostReturnsSurveyTitleAsTitleInTheModelWhenModelIsNotValid()
{
var mockSurveyManagementService = new Mock <ISurveyManagementService>();
var survey = new Tailspin.SurveyManagementService.Client.Models.Survey()
{
Title = "title",
Questions = new List <Tailspin.SurveyManagementService.Client.Models.Question>()
{
new Tailspin.SurveyManagementService.Client.Models.Question()
}
};
mockSurveyManagementService.Setup(r => r.GetSurveyAsync(It.IsAny <string>()))
.ReturnsAsync(survey);
var surveyAnswer = new SurveyAnswer()
{
QuestionAnswers = new List <QuestionAnswer>()
{
new QuestionAnswer()
}
};
using (var controller = new SurveysController(mockSurveyManagementService.Object, new Mock <ISurveyAnswerService>().Object))
{
controller.ModelState.AddModelError("error for test", "invalid model state");
var result = await controller.Display(string.Empty, surveyAnswer) as ViewResult;
var model = result.ViewData.Model as MasterPageViewData;
Assert.AreSame("title", model.Title);
}
}
public async Task SaveSurveyAnswerAsync(SurveyAnswer surveyAnswer)
{
var tenant = await this.tenantStore.GetTenantAsync(surveyAnswer.TenantId).ConfigureAwait(false);
if (tenant != null)
{
var surveyAnswerBlobContainer = this.surveyAnswerContainerFactory.Create(surveyAnswer.TenantId, surveyAnswer.SlugName);
await surveyAnswerBlobContainer.EnsureExistsAsync().ConfigureAwait(false);
surveyAnswer.CreatedOn = DateTime.UtcNow;
var blobId = surveyAnswer.CreatedOn.GetFormatedTicks();
await surveyAnswerBlobContainer.SaveAsync(blobId, surveyAnswer).ConfigureAwait(false);
var queue = SubscriptionKind.Premium.Equals(tenant.SubscriptionKind)
? this.premiumSurveyAnswerStoredQueue
: this.standardSurveyAnswerStoredQueue;
await queue.AddMessageAsync(new SurveyAnswerStoredMessage
{
SurveyAnswerBlobId = blobId,
TenantId = surveyAnswer.TenantId,
SurveySlugName = surveyAnswer.SlugName
}).ConfigureAwait(false);
}
}
public static bool SureyAnswerAddOrUpdate(SurveyAnswer surans)
{
int res = -1;
try
{
var thissurans = database.Query <SurveyAnswer>("SELECT * FROM SurveyAnswer WHERE SeqLNr = ? AND SubNr = ?", new object[] { surans.SeqLNr, surans.SubNr });
if (thissurans != null)
{
res = thissurans.Count;
}
else
{
res = -1;
}
if (res == 0)
{
res = database.Insert(surans);
}
else if (res == 1)
{
res = database.Update(surans);
}
else
{
return(false);
}
}
catch { return(false); }
return(true);
}
public void DisplayWhenPostReturnsModelWithTheAnswersReadFromTheParameterWhenModelIsNotValid()
{
var mockSurveyStore = new Mock <ISurveyStore>();
var survey = new Survey
{
Questions = new List <Question>(new[] { new Question() })
};
mockSurveyStore.Setup(r => r.GetSurveyByTenantAndSlugName(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(survey);
var surveyAnswer = new SurveyAnswer
{
QuestionAnswers = new List <QuestionAnswer>(new[] { new QuestionAnswer {
Answer = "answer"
} })
};
using (var controller = new SurveysController(mockSurveyStore.Object, default(ISurveyAnswerStore)))
{
controller.ModelState.AddModelError("error for test", "invalid model state");
var result = controller.Display(string.Empty, string.Empty, surveyAnswer) as ViewResult;
var model = result.ViewData.Model as TenantPageViewData <SurveyAnswer>;
Assert.AreEqual("answer", model.ContentModel.QuestionAnswers.First().Answer);
}
}
private List <SurveyAnswer> method_0()
{
List <SurveyAnswer> list = new List <SurveyAnswer>();
DateTime now = DateTime.Now;
int num = 0;
foreach (classMultipleAnswers classMultipleAnswers in this.SelectedCodes)
{
string text = this.QuestionName + "_R" + this.QCircleDetails[num].CODE;
SurveyAnswer surveyAnswer = new SurveyAnswer();
for (int i = 0; i < classMultipleAnswers.Answers.Count; i++)
{
list.Add(new SurveyAnswer
{
QUESTION_NAME = text + "_A" + (i + 1).ToString(),
CODE = classMultipleAnswers.Answers[i].ToString(),
MULTI_ORDER = i + 1,
BEGIN_DATE = new DateTime?(this.QInitDateTime),
MODIFY_DATE = new DateTime?(now)
});
}
text = this.CircleQuestionName + "_R" + this.QCircleDetails[num].CODE;
list.Add(new SurveyAnswer
{
QUESTION_NAME = text,
CODE = this.QCircleDetails[num].CODE,
MULTI_ORDER = 0,
BEGIN_DATE = new DateTime?(this.QInitDateTime),
MODIFY_DATE = new DateTime?(now)
});
num++;
}
return(list);
}
public void AddNewMultipleChoiceAnswerCallsMergeWithNewSummary()
{
var surveyAnswersSummary = new StubSurveyAnswersSummary();
var questionAnswer = new QuestionAnswer
{
QuestionType = QuestionType.MultipleChoice,
QuestionText = "multiple choice",
Answer = "choice 1",
PossibleAnswers = "possible answers"
};
var surveyAnswer = new SurveyAnswer();
surveyAnswer.QuestionAnswers.Add(questionAnswer);
surveyAnswersSummary.AddNewAnswer(surveyAnswer);
var questionAnswersSummary = surveyAnswersSummary.MergeParameter.QuestionAnswersSummaries.First();
Assert.AreEqual("multiple choice", questionAnswersSummary.QuestionText);
Assert.AreEqual("possible answers", questionAnswersSummary.PossibleAnswers);
Assert.AreEqual(QuestionType.MultipleChoice, questionAnswersSummary.QuestionType);
var actualSummary = new JavaScriptSerializer().Deserialize <Dictionary <string, int> >(questionAnswersSummary.AnswersSummary);
Assert.AreEqual(1, actualSummary.Keys.Count);
Assert.AreEqual(1, actualSummary["choice 1"]);
}
public async Task DisplayWhenPostCallsSaveSurveyAnswerFromSurveyAnswerStoreWithQuestionTypeReadFromTheSurveyWhenModelIsValid()
{
var survey = new Survey
{
Questions = new List <Question>(
new[]
{
new Question {
Type = QuestionType.SimpleText
},
})
};
var mockSurveyStore = new Mock <ISurveyStore>();
mockSurveyStore.Setup(r => r.GetSurveyByTenantAndSlugNameAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()))
.ReturnsAsync(survey);
var mockSurveyAnswerStore = new Mock <ISurveyAnswerStore>();
var surveyAnswer = new SurveyAnswer
{
QuestionAnswers = new List <QuestionAnswer>(new[] { new QuestionAnswer() })
};
using (var controller = new SurveysController(mockSurveyStore.Object, mockSurveyAnswerStore.Object))
{
await controller.Display(string.Empty, string.Empty, surveyAnswer);
}
mockSurveyAnswerStore.Verify(
r => r.SaveSurveyAnswerAsync(
It.Is <SurveyAnswer>(sa => QuestionType.SimpleText == sa.QuestionAnswers[0].QuestionType)),
Times.Once());
}
public async Task BrowseResponsesSetsTheAnswerFromTheStoreInTheModel()
{
var mockSurveyAnswerStore = new Mock <ISurveyAnswerStore>();
var surveyAnswer = new SurveyAnswer();
mockSurveyAnswerStore.Setup(r => r.GetSurveyAnswerBrowsingContextAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(new SurveyAnswerBrowsingContext {
PreviousId = string.Empty, NextId = string.Empty
});
mockSurveyAnswerStore.Setup(r => r.GetSurveyAnswerAsync("tenant", "survey-slug", "answer id"))
.ReturnsAsync(surveyAnswer);
var mockTenantStore = new Mock <ITenantStore>();
mockTenantStore.Setup(r => r.GetTenantAsync(It.IsAny <string>()))
.ReturnsAsync(new Tenant());
using (var controller = new SurveysController(null, mockSurveyAnswerStore.Object, null, mockTenantStore.Object, null))
{
var result = await controller.BrowseResponses("tenant", "survey-slug", "answer id") as ViewResult;
var model = result.ViewData.Model as TenantPageViewData <BrowseResponseModel>;
Assert.AreSame(surveyAnswer, model.ContentModel.SurveyAnswer);
}
}
protected override void OnSaveStateComplete(EventArgs e)
{
try
{
var allControls = QuestionsPanel.Controls;
foreach (var usercontrol in allControls)
{
if (usercontrol is QuestionControl)
{
var questionControl = (usercontrol as QuestionControl);
if (!string.IsNullOrWhiteSpace(questionControl.SurveyQuestionId.Text) &&
!string.IsNullOrWhiteSpace(questionControl.AnswerOptions.SelectedValue))
{
var id = questionControl.ID;
var surveyQuestionId = int.Parse(questionControl.SurveyQuestionId.Text);
SurveyAnswer answerResponse = new SurveyAnswer()
{
SurveyQuestion = surveyQuestionId,
Student = globals.LoggedIn.UserMapping ?? 0,
Answer = questionControl.AnswerOptions.SelectedValue
};
db.SurveyAnswers.InsertOnSubmit(answerResponse);
db.SubmitChanges();
// warningtext.Text = "Answer Saved Successfully!";
}
}
}
}
catch (Exception)
{
warningtext.Text = "Error in saving survey, admin cannot submit survey answers";
}
}
// Survey Answers
#region public Task<bool> CreateSurveyAnswersAsync(DTOSurvey paramDTOSurvey)
public Task <bool> CreateSurveyAnswersAsync(DTOSurvey paramDTOSurvey)
{
try
{
List <SurveyAnswer> SurveyAnswers = new List <SurveyAnswer>();
foreach (var SurveyItem in paramDTOSurvey.SurveyItem)
{
// Delete possible existing answer
var ExistingAnswers = _context.SurveyAnswer
.Where(x => x.SurveyItemId == SurveyItem.Id)
.Where(x => x.UserId == paramDTOSurvey.UserId)
.ToList();
if (ExistingAnswers != null)
{
_context.SurveyAnswer.RemoveRange(ExistingAnswers);
_context.SaveChanges();
}
// Save Answer
if (SurveyItem.ItemType != "Multi-Select Dropdown")
{
SurveyAnswer NewSurveyAnswer = new SurveyAnswer();
NewSurveyAnswer.AnswerValue = SurveyItem.AnswerValueString;
NewSurveyAnswer.AnswerValueDateTime = SurveyItem.AnswerValueDateTime;
NewSurveyAnswer.SurveyItemId = SurveyItem.Id;
NewSurveyAnswer.UserId = paramDTOSurvey.UserId;
_context.SurveyAnswer.Add(NewSurveyAnswer);
_context.SaveChanges();
}
if (SurveyItem.AnswerValueList != null)
{
foreach (var item in SurveyItem.AnswerValueList)
{
SurveyAnswer NewSurveyAnswerValueList = new SurveyAnswer();
NewSurveyAnswerValueList.AnswerValue = item;
NewSurveyAnswerValueList.SurveyItemId = SurveyItem.Id;
NewSurveyAnswerValueList.UserId = paramDTOSurvey.UserId;
_context.SurveyAnswer.Add(NewSurveyAnswerValueList);
_context.SaveChanges();
}
}
}
return(Task.FromResult(true));
}
catch
{
DetachAllEntities();
throw;
}
}
public async Task SaveSurveyResponseAsync(SurveyAnswer surveyAnswer)
{
var jsonSurveyAnswer = JsonConvert.SerializeObject(surveyAnswer);
HttpResponseMessage response = await httpClient.PostAsync($"api/surveyresponses?PartitionKey={defaultPartitionKey}&PartitionKind={defaultPartitionKind}", new StringContent(jsonSurveyAnswer, Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
}
public MsCrmResult AnswerSurvey(string token, SurveyAnswer answer)
{
MsCrmResult returnValue = new MsCrmResult();
LoginSession ls = new LoginSession();
try
{
if (!string.IsNullOrEmpty(token))
{
#region | CHECK SESSION |
MsCrmResultObject sessionResult = GetUserSession(token);
if (!sessionResult.Success)
{
returnValue.Result = sessionResult.Result;
return returnValue;
}
else
{
ls = (LoginSession)sessionResult.ReturnObject;
}
#endregion
IOrganizationService service = MSCRM.GetOrgService(true);
returnValue = SurveyHelper.AnswerSurvey(answer, service);
}
else
{
returnValue.Success = false;
returnValue.Result = "M003"; //"Eksik parametre!-AnswerSurvey";
}
}
catch (Exception ex)
{
returnValue.Result = ex.Message;
}
return returnValue;
}
