public void Jogada(string comando, string mensagem, string jogador, Delegate onTerminadoCallBack = null, Delegate onErroCallback = null)
{
try
{
_ForcaContextStrategy = new ForcaContextStrategy(comando);
var feedBack = _ForcaContextStrategy.ExecutarAcao(Forca, Jogador: jogador, Mensagem: mensagem);
Forca = feedBack.Jogo;
CallbackModel = new CallbackModel
{
UserName = jogador,
Mensagem = feedBack.Mensagem,
ChannelName = BotAppSettings.ChannelName,
JogoEncerrado = (Forca == null)
};
if (CallbackModel.JogoEncerrado)
{
this.Finalizar(onErroCallback: onErroCallback);
}
onTerminadoCallBack?.DynamicInvoke(CallbackModel);
}
catch (Exception e)
{
onErroCallback?.DynamicInvoke(new CallbackModel
{
Mensagem = e.Message,
ChannelName = BotAppSettings.ChannelName
});
}
}
public IActionResult CallBack(object json)
{
CallbackModel data = JsonConvert.DeserializeObject <CallbackModel>(json.ToString());
Log.LogInformation($"Callback with data:{data}");
if (data.Type == "confirmation")
{
return(Ok(Config["VkApi:Confirmation"]));
}
if (data.Type == "message_new")
{
Message message = Message.FromJson(new VkResponse(data.Object));
Log.LogInformation($"Messasge is:{message}");
Log.LogInformation($"UserID is :{message.PeerId}");
User user = Vk.Users.Get(new [] { (long)message.PeerId }).First();
Log.LogInformation($"User is:{user.LastName} {user.FirstName}");
var responce = CommandBinding.ProcessMessage(Vk, message);
Vk.Messages.Send(new VkNet.Model.RequestParams.MessagesSendParams()
{
PeerId = message.PeerId, Message = responce, RandomId = new DateTime().Millisecond
});
}
return(Ok("ok"));
}
protected unsafe void EnableActionModel()
{
iCallbackModel = new CallbackModel(DoModel);
IntPtr ptr = GCHandle.ToIntPtr(iGch);
DvServiceLinnCoUkProduct3EnableActionModel(iHandle, iCallbackModel, ptr);
}
void ExecutarFala(Tuple <FalaModel, Delegate, Delegate> falaTuple)
{
var model = falaTuple.Item1;
var notificarBotCallback = falaTuple.Item2;
var notificarErroBotCallback = falaTuple.Item3;
var _CallbackModel = new CallbackModel
{
ChannelName = BotAppSettings.ChannelName,
Mensagem = string.Empty
};
try
{
base.EncadeiaReacao = false;
this.IsExecutandoAudio = true;
CallBackFalaFinalizada callback = new CallBackFalaFinalizada(FinalizarComentarioCallback);
base.ExecutarAudioSync(model, callbackFalaFinalizada: callback);
}
catch
{
this.IsExecutandoAudio = false;
this.Falas.Remove(falaTuple);
_CallbackModel.Mensagem = $"@{model.Jogador} ruim ao fazer o comentário {EmotesConsts.NotLikeThis}";
notificarErroBotCallback?.DynamicInvoke(_CallbackModel);
}
}
public string CreateCallback([FromBody] CallbackModel callback)
{
var token = TokenEncryption.Encrypt(
JsonConvert.SerializeObject(callback),
DocumentsAPIConfiguration.APITokenKey
);
return(string.Format(DocumentsAPIConfiguration.CallbackURL, WebUtility.UrlEncode(token)));
}
void ErroCallback(CallbackModel model)
{
if (model.JogoEncerrado)
{
Jogo = null;
}
_TwitchClient.SendMessage(BotAppSettings.ChannelName, model.Mensagem);
}
/// <summary>
/// Create from service model
/// </summary>
/// <param name="model"></param>
public CallbackApiModel(CallbackModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Uri = model.Uri;
AuthenticationHeader = model.AuthenticationHeader;
Method = model.Method;
}
private static CallbackModel GetCallbackModel(string state)
{
var model = new CallbackModel
{
Query = GetQuery(state)
};
model.ConversationReference = UrlToken.Decode <ConversationReference>(model.Query["conversationRef"]);
model.Message = model.ConversationReference.GetPostToBotMessage();
return(model);
}
public IActionResult Put(CallbackModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
this.logger.LogInformation("Got response from citizen: {model}", JsonConvert.SerializeObject(model));
var saver = new FileSaver("Download");
saver.SaveFile($"content.{model.ContentType}", model.Content);
model.Attachments?.ForEach(x => saver.SaveFile(x.Name, x.Content));
return(this.Ok());
}
void ExecutarFala(Tuple <FalaModel, Delegate, Delegate> falaTuple)
{
var model = falaTuple.Item1;
var notificarBotCallback = falaTuple.Item2;
var notificarErroBotCallback = falaTuple.Item3;
_CallbackModel = new CallbackModel
{
ChannelName = BotAppSettings.ChannelName
};
try
{
if (model == null)
{
_CallbackModel.Mensagem = $"Não consegui realizar a ação {EmotesConsts.NotLikeThis}";
notificarBotCallback?.DynamicInvoke(_CallbackModel);
this.Falas.Remove(falaTuple);
return;
}
var piada = _PiadaService.ObterPiadaAleatoria();
var promptBuilder = new PromptBuilder(new System.Globalization.CultureInfo("pt-BR"));
promptBuilder.AppendText(piada.Pergunta);
promptBuilder.AppendBreak(PromptBreak.Small);
promptBuilder.AppendText(piada.Resposta);
promptBuilder.AppendBreak(PromptBreak.Small);
CallBackFalaFinalizada callback = new CallBackFalaFinalizada(FinalizarPiadaCallback);
base.EncadeiaReacao = true;
model.TextoPrompFala = promptBuilder;
_CallbackModel.Mensagem = $"{piada.Pergunta} {piada.Resposta} {EmotesConsts.LUL} {EmotesConsts.Kappa}";
notificarBotCallback?.DynamicInvoke(_CallbackModel);
base.ExecutarAudioSync(model, callbackFalaFinalizada: callback);
}
catch
{
this.IsExecutandoAudio = false;
this.Falas.Remove(falaTuple);
_CallbackModel.Mensagem = $"@daniel_dev Deu ruim ao fazer o comentário, ve o log aí {EmotesConsts.NotLikeThis}";
notificarErroBotCallback?.DynamicInvoke(_CallbackModel);
}
}
public void Falar(FalaModel model, Delegate notificarBotCallback = null, Delegate notificarErroBotCallback = null)
{
CallbackModel = new CallbackModel
{
ChannelName = BotAppSettings.ChannelName,
Mensagem = "Eu não sei falar isso ainda"
};
try
{
notificarBotCallback?.DynamicInvoke(CallbackModel);
}
catch
{
CallbackModel.Mensagem = $"deu pau... {EmotesConsts.NotLikeThis}";
notificarErroBotCallback?.DynamicInvoke(CallbackModel);
}
}
/// <summary>
/// Registers a <see cref="Action{T}"/> callback.
/// </summary>
/// <typeparam name="T">
/// The type of data that the <see cref="callback"/> takes as a parameter.
/// </typeparam>
/// <param name="callback">
/// A reference to a callback.
/// </param>
/// <param name="data">
/// The data that will be passed as a parameter when the <see cref="callback"/> is invoked.
/// </param>
/// <param name="priority">A value indicating the execution priority.</param>
/// <exception cref="ArgumentNullException">If callback parameter is null.</exception>
public void Register <T>(Action <T> callback, T data, int priority)
{
if (callback == null)
{
throw new ArgumentNullException("callback");
}
if (this.isRunning)
{
throw new InvalidOperationException("Cannot register new callback while running callbacks.");
}
var modal = new CallbackModel <T> {
Callback = callback, Data = data, Priority = priority
};
this.callbacks.Add(modal);
}
private void SetHTTPClientHeaders()
{
if (_mySession.CSession["SpotifyAccess"] != null)
{
_callback = (CallbackModel)_mySession.CSession["SpotifyAccess"];
}
lock (_httpClient)
{
_httpClient.DefaultRequestHeaders.Clear();
if (MediaTypeWithQualityHeaderValue.TryParse(_sContentType, out MediaTypeWithQualityHeaderValue mtqhv))
{
_httpClient.DefaultRequestHeaders.Accept.Add(mtqhv);
}
if (_callback != null)
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _callback.accessToken);
}
}
}
void ExecutarFala(Tuple <FalaModel, Delegate, Delegate> falaTuple)
{
var model = falaTuple.Item1;
var notificarBotCallback = falaTuple.Item2;
var notificarErroBotCallback = falaTuple.Item3;
var _CallbackModel = new CallbackModel
{
ChannelName = BotAppSettings.ChannelName
};
try
{
int idMeme = 0;
int.TryParse(model.TextoParaFala, out idMeme);
var memeAudio = ObterMeme(idMeme);
if (string.IsNullOrEmpty(memeAudio))
{
_CallbackModel.Mensagem = $"Não achei o audio.... {EmotesConsts.NotLikeThis}";
FinalizarMemeCallback(model);
return;
}
model.TextoParaFala = memeAudio;
CallBackFalaFinalizada callback = new CallBackFalaFinalizada(FinalizarMemeCallback);
this.ExecutarWAVSync(model, callbackFalaFinalizada: callback);
}
catch
{
this.IsExecutandoAudio = false;
this.Falas.Remove(falaTuple);
_CallbackModel.Mensagem = $"@{model.Jogador} Deu ruim ao rodar o meme {EmotesConsts.NotLikeThis}";
notificarErroBotCallback?.DynamicInvoke(_CallbackModel);
}
}
public async Task ObterJogador(string Jogador, Delegate callBackTerminado = null, Delegate callBackErro = null)
{
var _CallbackModel = new CallbackModel
{
ChannelName = BotAppSettings.ChannelName
};
try
{
var jsonData = await LerTexto();
var Ranking = JsonConvert.DeserializeObject <RankingModel>(jsonData);
var resultado = Ranking.Jogadores.SingleOrDefault(j => j.Nome.ToLower() == Jogador.ToLower());
_CallbackModel.Mensagem = (resultado != null) ? $"@{Jogador} você tem {resultado.Moedas} moeda(s)" : $"@{Jogador} você ainda não conquistou nenhuma moeda!";
callBackTerminado?.DynamicInvoke(_CallbackModel);
}
catch
{
_CallbackModel.Mensagem = $"@{Jogador} não consegui ver a quantidade de moedas que você tem {EmotesConsts.NotLikeThis}";
callBackErro?.DynamicInvoke(_CallbackModel);
}
}
protected void Page_Load(object sender, EventArgs e)
{
string error = string.Empty;
SetupVisibleParts();
var requestType = Context.Request.RequestType;
if (requestType.ToUpper() == "POST")
{
var callbackModel = new CallbackModel
{
Saml = Context.Request["saml"],
Jwt = Context.Request["jwt"],
};
if (SuperOfficeAuthHelper.TryLogin(callbackModel, out error))
{
var redirectUr = Context.Session["RedirectUrl"] as string;
Context.Session["RedirectUrl"] = "";
if (!String.IsNullOrEmpty(redirectUr))
{
Context.Response.Redirect(redirectUr);
}
}
else
{
explanationText.Visible = true;
explanationText.InnerText = "Login unsuccessful, reason: " + error;
}
}
else
{
var code = Context.Request["code"];
var state = Context.Request["state"];
var sessionState = Context.Session["state"] as string;
if (sessionState.Equals(state))
{
OidcModel oauthModel = SuperOfficeAuthHelper.GetOAuthModel(code);
if (SuperOfficeAuthHelper.TryLogin(oauthModel, out error))
{
var redirectUr = Context.Session["RedirectUrl"] as string;
Context.Session["RedirectUrl"] = "";
if (!String.IsNullOrEmpty(redirectUr))
{
Context.Response.Redirect(redirectUr);
}
}
}
else
{
explanationText.Visible = true;
explanationText.InnerText = "Login unsuccessful, reason: " + error;
}
}
}
public async Task <string> CreateCallbackAsync(CallbackModel callbackModel)
{
return(await Connection.APICallAsync <string>(HttpMethod.Post, APIEndpoint.QueueCreateCallback,
bodyContent : callbackModel
));
}
static extern void DvServiceLinnCoUkProduct3EnableActionModel(uint aHandle, CallbackModel aCallback, IntPtr aPtr);
public ActionResult Index(CallbackModel callbackModel)
{
if (callbackModel == null)
{
return(RedirectToAction("Index", "Home"));
}
/*
* Here it is up to the partner intercept the callback from SuperID
* and route the user to the correct partner application instance.
*
* This is also the opportunity for the Partner to create a system user
* in the customers superoffice database for future use and storage.
*
* This is where any additional setup or configuration options are input into
* the partners application for future use.
*/
string error = string.Empty;
if (SuperOfficeAuthHelper.TryLogin(callbackModel, out error))
{
var context = SuperOfficeAuthHelper.Context;
//Store the System User Information in the Database
CustomerDataSource dataSource = new CustomerDataSource();
var customer = dataSource.Customers.FirstOrDefault(c => c.ContextIdentifier == context.ContextIdentifier);
//var databaseContext = new PartnerDatabaseContext();
//var customer = databaseContext.Customers.FirstOrDefault(c => c.ContextIdentifier == context.ContextIdentifier);
if (customer == null)
{
dataSource.Customers.Add(new CustomerInfo
{
AssociateID = context.AssociateId,
ContextIdentifier = context.ContextIdentifier,
IsActive = true,
LastSync = new DateTime(2000, 1, 1),
SystemUserToken = context.SystemToken
});
dataSource.Save();
}
// Redirect to original request
var redirectUr = Session["RedirectUrl"] as string;
if (!String.IsNullOrEmpty(redirectUr))
{
return(Redirect(redirectUr));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
return(RedirectToAction("Welcome", "Home", new { Error = error }));
}
}
