public void OpenPanel()
{
//If the only child is "Title", make sure to instantiate the data fields
if (DecisionCard.transform.childCount <= 1)
{
InitDecisionPanel(FindObjectOfType <GameManager>().ChosenCards[0]);
}
StringPanel.SetActive(false);
NumberPanel.SetActive(false);
TitlePanel.SetActive(false);
AskButton.SetActive(false);
InstructionText.SetActive(true);
DecisionPanel.SetActive(true);
DecisionResponse.SetActive(false);
}
public async Task <ActionResult <DecisionResponse> > TokenProvisioning(DecisionRequest model, CancellationToken ct)
{
var response = new DecisionResponse
{
AcctId = model.AcctId,
BusinessAcctId = model.BusinessAcctId,
Last4CardNumber = model.Last4CardNumber
};
var settings = await _responseSettingsStorage
.Get(model.BusinessAcctId, model.AcctId, ct);
if (settings == null)
{
await SaveTokenProvisioning(model, 404, 0, null);
return(NotFound());
}
if (!SecretsAreEqual(settings.SharedSecret))
{
await SaveTokenProvisioning(model, 403, 0, null);
return(StatusCode(403, "SharedSecret in Authorization header doesn't match the one configured"));
}
await Task
.Delay(settings.DelayMls, ct);
var customResult = GetCustomResult(settings.StatusCode);
if (customResult != null)
{
await SaveTokenProvisioning(model, settings.StatusCode, settings.DelayMls, null);
return(customResult);
}
response.Contacts = settings.ContactsJson.DeserializeTo <List <ContactItem> >();
await SaveTokenProvisioning(model, settings.StatusCode, settings.DelayMls, response);
return(response);
}
public DecisionResponse GetDecision(CreditCardApplication application)
{
var decision = new DecisionResponse {
Result = DecisionResult.Declined
};
if (application.HomeAddress.State == "OK")
{
decision.Result = DecisionResult.Declined;
return(decision);
}
var creditReport = _creditService.CheckCreditHistory(new CreditCardApplication());
var isQualified = CreditRating.FromScore(creditReport.CreditScore).Qualified;
decision.Result = isQualified ? DecisionResult.Approved : DecisionResult.Declined;
return(decision);
}
public void SetFlagInfos(DecisionResponse response)
{
IsPanic = response.Panic;
foreach (var campaign in response.Campaigns)
{
foreach (var keyValue in campaign.Variation.Modifications.Value)
{
if (!FlagInfos.ContainsKey(keyValue.Key))
{
FlagInfos.Add(keyValue.Key, new FlagInfo
{
CampaignId = campaign.Id,
VariationGroupId = campaign.VariationGroupId,
VariationId = campaign.Variation.Id,
Reference = campaign.Variation.Reference,
Value = keyValue.Value
});
}
}
}
}
private async Task SaveTokenProvisioning(DecisionRequest model, int statusCode, int delay, DecisionResponse response)
{
var entity = new TokenProvisioningEntity
{
SharedSecret = GetSharedSecretFromHeaders(),
StatusCode = statusCode,
DelayMls = delay,
RequestJson = model.ToJson(),
ResponseJson = response.ToJson()
};
await _tokenProvisioningStorage
.Insert(model.AcctId, entity, CancellationToken.None);
}
public async Task <DecisionResponse> GetResponse(DecisionRequest request)
{
var response = new DecisionResponse()
{
VisitorID = request.VisitorId,
Campaigns = new HashSet <Model.Campaign>()
};
if (configuration == null)
{
logger.Log(LogLevel.WARN, LogCode.BUCKETING_NOT_LOADED);
return(response);
}
response.Panic = configuration.Panic;
if (configuration.Panic)
{
logger.Log(LogLevel.WARN, LogCode.BUCKETING_PANIC_MODE_ENABLED);
return(response);
}
sender.SendEvent(new EventRequest(this.environmentId, request.VisitorId, EventType.CONTEXT, request.Context)).ContinueWith((Task t) =>
{
logger.Log(LogLevel.DEBUG, LogCode.CONTEXT_SENT_TRACKING, new { request.Context });
});
foreach (var campaign in configuration.Campaigns ?? new List <Model.Bucketing.Campaign>().AsEnumerable())
{
foreach (var vg in campaign.VariationGroups)
{
var match = vg.Targeting.TargetingGroups.Any(tg => tg.Targetings.All(t =>
{
switch (t.Key)
{
case "fs_users":
return(targetingMatch.Match(request.VisitorId, t.Operator, t.Value));
case "fs_all_users":
return(true);
default:
if (request.Context.ContainsKey(t.Key))
{
return(targetingMatch.Match(request.Context[t.Key], t.Operator, t.Value));
}
return(false);
}
}));
if (match)
{
var variation = variationAllocation.GetVariation(vg, request.VisitorId);
if (variation != null)
{
response.Campaigns.Add(new Model.Campaign()
{
Id = campaign.Id,
Variation = new Model.Variation()
{
Id = variation.Id,
Reference = variation.Reference,
Modifications = variation.Modifications
},
VariationGroupId = vg.Id
});
}
}
}
}
return(response);
}
public static IFlagshipVisitor Create(string environmentId, string apiKey, string visitorId, IDictionary <string, object> context, DecisionResponse mockResponse, HttpClient customClient = null)
{
var mockClient = new Mock <IDecisionManager>();
mockClient.Setup(foo => foo.GetResponse(It.IsAny <DecisionRequest>())).Returns(Task.FromResult(mockResponse));
var logger = new DefaultLogger();
var errorHandler = new DefaultExceptionHandler();
var flagshipContext = new FlagshipContext(environmentId, apiKey);
var sender = new Sender(flagshipContext);
if (customClient != null)
{
var senderClient = sender.GetType().GetField("httpClient", System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.Instance);
senderClient.SetValue(sender, customClient);
}
var contextSender = flagshipContext.GetType().GetField("Sender", System.Reflection.BindingFlags.Public
| System.Reflection.BindingFlags.Instance);
contextSender.SetValue(flagshipContext, sender);
var flagshipVisitorService = new FlagshipVisitorService(flagshipContext);
var decisionManager = flagshipVisitorService.GetType().GetField("decisionManager", System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.Instance);
decisionManager.SetValue(flagshipVisitorService, mockClient.Object);
var flagship = new FlagshipClient(flagshipContext);
var fsVisService = flagship.GetType().GetField("fsVisitorService", System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.Instance);
fsVisService.SetValue(flagship, flagshipVisitorService);
var flagshipVisitor = flagship.NewVisitor(visitorId, context);
return(flagshipVisitor);
}
public void Ask()
{
string oprtr = "equals";
object guess = "";
switch (selectedPanel)
{
case Panel.StringPanel:
guess = stringDropdown.options[stringDropdown.value].text;
break;
case Panel.NumberPanel:
guess = float.Parse(numberInput.text);
switch (numberDropdown.value)
{
case 0:
oprtr = "less than";
break;
case 1:
oprtr = "equals";
break;
case 2:
oprtr = "greater than";
break;
}
break;
case Panel.TitlePanel:
guess = titleDropdown.options[titleDropdown.value].text;
break;
}
if (selectedPanel == Panel.TitlePanel && (string)guess == gm.ChosenCards[(gm.CurrentPlayerID + 1) % GameManager.NumberOfPlayers].title)
{
//TODO: Win condition?
}
else
{
bool correct;
object data = gm.ChosenCards[(gm.CurrentPlayerID + 1) % GameManager.NumberOfPlayers].data[selectedData];
switch (oprtr)
{
case "less than":
correct = (float)data < (float)guess;
break;
case "equals":
correct = data == guess;
break;
case "greater than":
correct = (float)data > (float)guess;
break;
default:
throw new Exception("Unexpected operator name: " + oprtr);
}
string not = (correct) ? "IS" : "is NOT";
DecisionResponse.GetComponentInChildren <Text>().text = "Their " + gm.ChosenCards[(gm.CurrentPlayerID + 1) % GameManager.NumberOfPlayers].datatype + "'s " + selectedData + " " + not + " " + oprtr + " " + guess;
DecisionResponse.SetActive(true);
DecisionPanel.SetActive(false);
gm.nextTurnButton.SetActive(true);
}
}
