public async Task <IActionResult> ResponseAsync(IFormCollection answer)
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
var userId = applicationUser.Id;
var listOfAnswers = new List <Answer>();
for (int i = 0; i < (answer.Count - 2) / 2; i++)
{
var answerGuid = Guid.NewGuid();
string questionId = $"{i} questionId";
string value = $"{i}";
listOfAnswers.Add(new Answer {
AnswerId = answerGuid, MarketResearchId = Guid.Parse(answer["marketId"]), PersonId = userId, QuestionId = Guid.Parse(answer[questionId]), Value = answer[value],
});
}
int result = await _dataAccessQuestions.AddAnswers(listOfAnswers);
Responders responders = _context.Responders.SingleOrDefault(x => x.MarketResearchId == listOfAnswers[0].MarketResearchId && x.PersonId == listOfAnswers[0].PersonId);
responders.MarketResearchCompleted = true;
_context.Responders.Update(responders);
await _context.SaveChangesAsync();
var thankyouVm = new ThankYouResponderVm();
//thankyouVm.Organization= await _context.Organizations.Include(x=>x.MarketResearches).SingleAsync(x=>x.OrganizationId==)
thankyouVm.Person = await _context.Persons.SingleAsync(x => x.PersonId == userId);
//thankyouVm.MarketResearch=await _context.MarketResearches.SingleAsync(x=>x.MarketResearchId)
return(View(thankyouVm));
}
public static void Register <T> (Action <T> responder)
{
if (responder == null)
{
throw new ArgumentNullException("responder");
}
Action <object> realResponder;
if (SynchronizationContext.Current == null)
{
realResponder = o => responder((T)o);
}
else
{
SynchronizationContext context = SynchronizationContext.Current;
realResponder = o => {
context.Send(s => responder((T)s), o);
};
}
List <Action <object> > respondersForType = Responders.GetOrAdd(typeof(T), t => new List <Action <object> >());
lock (respondersForType)
respondersForType.Add(realResponder);
}
public bool AnyEntities()
{
return((Activities != null && Activities.Any()) ||
(MoodPrompts != null && MoodPrompts.Any()) ||
(Responders != null && Responders.Any()) ||
(MoodResponses != null && MoodResponses.Any()));
}
public void SubscribeToNotResponded(ResponderEventHandler subscriber)
{
Responders.Each(r =>
{
r.NotResponded += subscriber;
});
}
public void ResetModel()
{
var newRequests = new ObservableCollection <ResponderRequestModel>(Responders.Select(responderRequest => new ResponderRequestModel(responderRequest.DepartmentType)));
Responders = newRequests;
FullyAttendedTime = null;
ReceivedTime = DateTime.Now;
}
public void ResetModel()
{
var newRequests = Responders.Select(responderRequest => new ResponderRequestModel(responderRequest.DepartmentType)).ToList();
Responders = newRequests;
FullyAttendedTime = null;
ReceivedTime = DateTime.Now;
}
private void ComposePlugins()
{
var directoryCatalog = new DirectoryCatalog("bin");
Container = new CompositionContainer(directoryCatalog);
Container.ComposeParts(this, Responders);
//wireup converters into serializer
Responders.RegisterConverters();
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var responder = Responders.FirstOrDefault(i => i.Matcher(request, i.State));
if (responder == null)
{
Assert.Fail($"responder was not found that matched the request: {request}");
}
return(Task.FromResult(responder.MockResponse(request, responder.State)));
}
public IActionResult ShowQuestionsForResponder(Responders responders)
{
if (!ModelState.IsValid)
{
return(View());
}
var viewModelAllQuestions = GetQuestions(responders.MarketResearchId);
return(View(viewModelAllQuestions));
}
public void SubscribeToNotResponded <T>(ResponderEventHandler subscriber) where T : class, IResponder
{
Responders.Each(r =>
{
T responder = r as T;
if (responder != null)
{
responder.NotResponded += subscriber;
}
});
}
private static void PreSendRequestHeaders(object sender, EventArgs e)
{
HttpApplication httpApplication;
if (!sender.IsValidRequest(out httpApplication, Configuration, true))
{
return;
}
var json = Responders.StandardResponse(httpApplication);
Persist(json, httpApplication);
}
protected void Response(string id)
{
if (Responders.TryGetValue(id, out var responder))
{
if (responder != null)
{
if (Send(id, responder))
{
Responders.TryUpdate(id, null, responder);
}
}
}
}
public static void Send <T> (T message)
{
List <Action <object> > respondersForType;
if (!Responders.TryGetValue(typeof(T), out respondersForType))
{
return;
}
lock (respondersForType) {
foreach (Action <object> action in respondersForType)
{
action(message);
}
}
}
private void ComposePlugins()
{
var aggregateCatalog = new AggregateCatalog();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var directoryCatalog = new DirectoryCatalog(@"\");
var configuredDirectoryCatalog = new DirectoryCatalog(Configuration.PluginPath);
aggregateCatalog.Catalogs.Add(assemblyCatalog);
aggregateCatalog.Catalogs.Add(directoryCatalog);
aggregateCatalog.Catalogs.Add(configuredDirectoryCatalog);
Container = new CompositionContainer(aggregateCatalog);
Container.ComposeParts(this, Responders);
//wireup converters into serializer
Responders.RegisterConverters();
}
private void ComposePlugins(HttpApplication application)
{
var batch = new CompositionBatch();
Container.ComposeParts(this, Responders);
Container.Compose(batch);
Plugins = Container.GetExports <IGlimpsePlugin, IGlimpsePluginRequirements>();
var store = application.Context.GetWarnings();
store.AddRange(DirectoryCatalog.Exceptions.Select(exception => new ExceptionWarning(exception)));
//wireup converters into serializer
Responders.RegisterConverters();
}
private void ComposePlugins(HttpApplication context)
{
var directoryCatalog = new SafeDirectoryCatalog("bin");
Container = new CompositionContainer(directoryCatalog);
Container.ComposeParts(this, Responders);
var store = context.GetWarningStore();
foreach (var exception in directoryCatalog.Exceptions)
{
store.Add(new[] { exception.GetType().Name, exception.Message });
}
//wireup converters into serializer
Responders.RegisterConverters();
}
private static void BeginRequest(object sender, EventArgs e)
{
HttpApplication httpApplication;
if (!sender.IsValidRequest(out httpApplication, Configuration, false, false))
{
return;
}
var responder = Responders.GetResponderFor(httpApplication);
if (responder != null)
{
responder.Respond(httpApplication, Configuration);
return;
}
httpApplication.InitGlimpseContext();
}
private void BeginRequest(object sender, EventArgs e)
{
HttpApplication httpApplication;
if (!sender.IsValidRequest(out httpApplication, Configuration, false, false))
{
return;
}
var responder = Responders.GetResponderFor(httpApplication);
if (responder != null)
{
responder.Respond(httpApplication, Configuration);
return;
}
httpApplication.SetData(new Dictionary <string, object>());
}
protected async Task <Dictionary <string, Message[]> > Message(ServiceContext context)
{
var id = GetId(context);
if (Responders.TryRemove(id, out var responder))
{
responder?.TrySetResult(null);
}
if (Timers.TryRemove(id, out var timer))
{
timer.TrySetResult(false);
}
responder = new TaskCompletionSource <Dictionary <string, Message[]> >();
if (!Send(id, responder))
{
Responders.AddOrUpdate(id, responder, (_, oldResponder) => {
oldResponder?.TrySetResult(null);
return(responder);
});
if (Timeout > TimeSpan.Zero)
{
using (CancellationTokenSource source = new CancellationTokenSource()) {
#if NET40
var delay = TaskEx.Delay(Timeout, source.Token);
var task = await TaskEx.WhenAny(responder.Task, delay).ConfigureAwait(false);
#else
var delay = Task.Delay(Timeout, source.Token);
var task = await Task.WhenAny(responder.Task, delay).ConfigureAwait(false);
#endif
source.Cancel();
if (task == delay)
{
responder.TrySetResult(emptyMessage);
DoHeartBeat(id);
}
}
}
}
return(await responder.Task.ConfigureAwait(false));
}
internal async Task GetRespondersToMarketResearch(MarketResearch marketResearch)
{
List <Person> respondersToFill = new List <Person>();
if (_questionContext.Persons.ToList().Count != 0)
{
var responders = _questionContext.Persons.Where(x =>
//( marketResearch.Gender == null || marketResearch.Gender == x.Gender) &&
(marketResearch.MinAge == null || marketResearch.MinAge < x.Age) &&
(marketResearch.MaxAge == null || marketResearch.MaxAge > x.Age) &&
(marketResearch.OnGoing == true) && x.OrganizationId == null).ToList(); //&&
//(marketResearch.Area == null || marketResearch.Area == x.City)).ToList();
if (responders.Count < marketResearch.NumberOfResponders)
{
int missingResponders = marketResearch.NumberOfResponders - responders.Count;
if (_questionContext.Persons.ToList().Count < missingResponders)
{
respondersToFill = _questionContext.Persons.ToList();
foreach (var resp in respondersToFill)
{
if (resp.OrganizationId == null)
{
responders.Add(resp);
}
}
}
else
{
for (int i = 0; i < missingResponders; i++)
{
respondersToFill = _questionContext.Persons.Where(x => x.OrganizationId == null).OrderBy(r => Guid.NewGuid()).Take(missingResponders).ToList();
}
foreach (var filInResponder in respondersToFill)
{
responders.Add(filInResponder);
}
}
foreach (var responder in responders)
{
var resp = new Responders();
resp.Persons = responder;
resp.MarketResearchs = marketResearch;
resp.MarketResearchCompleted = false;
_questionContext.Add(resp);
await _questionContext.SaveChangesAsync();
}
}
else if (responders.Count == marketResearch.NumberOfResponders)
{
foreach (var responder in responders)
{
var resp = new Responders();
resp.Persons = responder;
resp.MarketResearchs = marketResearch;
resp.MarketResearchCompleted = false;
_questionContext.Add(resp);
await _questionContext.SaveChangesAsync();
}
}
else
{
for (int i = 0; i < marketResearch.NumberOfResponders; i++)
{
var respondersToAdd = responders.OrderBy(r => Guid.NewGuid()).Take(marketResearch.NumberOfResponders).ToList();
foreach (var responder in respondersToAdd)
{
var resp = new Responders();
resp.Persons = responder;
resp.MarketResearchs = marketResearch;
resp.MarketResearchCompleted = false;
_questionContext.Add(resp);
await _questionContext.SaveChangesAsync();
}
}
}
}
}
