public UsersSecretsApplication(
IUsersSecretsDomain services,
ITokens tokens,
ISettingsUserSecrests settings,
ISocial social,
IRedisCache redisCache,
ICryptograhic crypto,
IResult result,
IErrorMessages errors,
ISettingsTokens settingsTokens,
ISettingsUserSecrests settingsSecrets,
IUserInfo userInfo
)
{
_services = services;
_tokens = tokens;
_settings = settings;
_social = social;
_redisCache = redisCache;
_crypto = crypto;
_result = result;
_errors = errors;
_settingsSecrets = settingsSecrets;
_settingsTokens = settingsTokens;
_userInfo = userInfo;
}
/// <summary>
/// Initializes a new instance of the BotConnectorDirectLineAPIV30
/// class.
/// </summary>
public BotConnectorDirectLineAPIV30()
: base()
{
this._conversations = new Conversations(this);
this._tokens = new Tokens(this);
this._baseUri = new Uri("https://directline.botframework.com");
}
/// <summary>
/// Initializes a new instance of the BotConnectorDirectLineAPIV30
/// class.
/// </summary>
/// <param name='rootHandler'>
/// Optional. The http client handler used to handle http transport.
/// </param>
/// <param name='handlers'>
/// Optional. The set of delegating handlers to insert in the http
/// client pipeline.
/// </param>
public BotConnectorDirectLineAPIV30(HttpClientHandler rootHandler, params DelegatingHandler[] handlers)
: base(rootHandler, handlers)
{
this._conversations = new Conversations(this);
this._tokens = new Tokens(this);
this._baseUri = new Uri("https://directline.botframework.com");
}
/// <summary>
/// Generate a token for a new conversation
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='tokenParameters'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Conversation> GenerateTokenForNewConversationAsync(this ITokens operations, TokenParameters tokenParameters = default(TokenParameters), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.GenerateTokenForNewConversationWithHttpMessagesAsync(tokenParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public OperationResult InhibitedUse(string tokenInternalID)
{
OperationResult result;
try
{
string assemb = new TokensValidatorDAO().DeployAssemblyNameByTokenID(tokenInternalID);
ITokens _tokens = TokensFactory.LoadAssembly(assemb);
if (_tokens == null)
{
SAFLOGGER.Write(SAFLOGGER.LOGGEREventID.ERROR, "SAFCORE", new string[]
{
"http://sfexpand.SAFCore.PREProcessorTokens.softfinanca.com/",
"[ITokens]::" + assemb.Trim(),
"Invalid or null typename!"
});
result = OperationResult.Error;
}
else
{
result = _tokens.InhibitedUse(tokenInternalID);
}
}
catch (Exception ex)
{
SAFLOGGER.Write(SAFLOGGER.LOGGEREventID.EXCEPTION, "SAFCORE", new string[]
{
"http://sfexpand.SAFCore.PREProcessorTokens.softfinanca.com/",
Assembly.GetExecutingAssembly().FullName.ToString(),
ex.ToString()
});
result = OperationResult.Error;
}
return(result);
}
/// <summary>
/// Refresh a token
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Conversation> RefreshTokenAsync(this ITokens operations, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.RefreshTokenWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public ActionResult <RequestResult> Token(string token, [FromServices] ITokens tokens, [FromServices] IConfiguration config)
{
var result = new RequestResult();
Console.WriteLine("TOKEN");
if (!string.IsNullOrEmpty(token))
{
tokens.AndroidToken = token;
result.Status = ResultStatus.Success;
result.ResultMessage = "Token Received Successfully";
var dict = new Dictionary <string, object>()
{
{ "Token", tokens.AndroidToken }
};
var response = Utilities.FirebaseUtilities.Notify(config, tokens.AndroidToken, "RetrieveConversations", dict);
return(Ok(result));
}
else
{
result.Status = ResultStatus.Failure;
result.ErrorMessage = "Failure. Null or Empty token string";
return(BadRequest(result));
}
}
/// <summary>
/// Initializes client properties.
/// </summary>
private void Initialize()
{
Conversations = new Conversations(this);
Tokens = new Tokens(this);
BaseUri = new Uri("https://directline.botframework.com");
SerializationSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
DateFormatHandling = DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = DateTimeZoneHandling.Utc,
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
DeserializationSettings = new JsonSerializerSettings
{
DateFormatHandling = DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = DateTimeZoneHandling.Utc,
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
CustomInitialize();
}
public Table(IDeck deck, IPile discardPile, ITokens informationTokens, ITokens fuseTokens, Dictionary <Suite, IPile> playedCards)
{
Deck = deck;
DiscardPile = discardPile;
InformationTokens = informationTokens;
FuseTokens = fuseTokens;
PlayedCards = playedCards;
}
/// <param name='operations'>
/// Reference to the ConsoleApplication2.ITokens.
/// </param>
public static Conversation RefreshToken(this ITokens operations)
{
return(Task.Factory.StartNew((object s) =>
{
return ((ITokens)s).RefreshTokenAsync();
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public OpenIdUserInfo(
ITokens tokens,
ISettingsTokens settings,
IResult result,
IErrorMessages errors
)
{
_tokens = tokens;
_settings = settings;
_result = result;
_errors = errors;
}
public ActionResult <RequestResult> RetrieveMessageList([FromServices] ITokens tokens,
[FromServices] IConfiguration config, [FromServices] MessageData messageData, int conversationID)
{
var result = new RequestResult();
if (messageData.ConversationToMessages.ContainsKey(conversationID) && messageData.ConversationToMessages[conversationID] != null)
{
var clientDict = new Dictionary <string, object>
{
{ "Token", tokens.ClientToken },
{ "ConversationID", Convert.ToString(conversationID) }
};
var clientResponse =
Utilities.FirebaseUtilities.Notify(config, tokens.ClientToken, "MessageList", clientDict);
if (clientResponse.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully notified client of message list availability";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = clientResponse.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
else
{
var dict = new Dictionary <string, object>()
{
{ "Token", tokens.AndroidToken },
{ "ConversationID", Convert.ToString(conversationID) }
};
var response =
Utilities.FirebaseUtilities.Notify(config, tokens.AndroidToken, "RetrieveMessageList", dict);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully sent retrieveConversations request to firebase";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
}
public UsersSecretsRepository(
ICosmosDB contextCosmosDB,
ISettingsUserSecrests settings,
ITokens tokens,
ICryptograhic crypto,
IResult result,
IErrorMessages errors
)
{
_contextCosmosDB = contextCosmosDB;
_settings = settings;
_tokens = tokens;
_crypto = crypto;
_result = result;
_errors = errors;
}
public OperationResult Cancel(string tokenInternalID)
{
OperationResult result;
try
{
string typeName = new TokensValidatorDAO().DeployAssemblyNameByTokenID(tokenInternalID);
ITokens tokens = TokensFactory.LoadAssembly(typeName);
result = tokens.Cancel(tokenInternalID);
}
catch (Exception innerException)
{
throw new Exception("SF.Expand.SAF.Core.PREProcessorTokens::Cancel[]", innerException);
}
return(result);
}
public OperationResult Create(string tokenVendorID, DateTime expirationDate, string supplierSerialNumber, string creationLotID, string pin, out TokenInfoCore tokenInfoCore)
{
OperationResult result;
try
{
string typeName = new TokensValidatorDAO().DeployAssemblyNameByTokenParamsID(tokenVendorID);
ITokens tokens = TokensFactory.LoadAssembly(typeName);
result = tokens.Create(tokenVendorID, expirationDate, supplierSerialNumber, creationLotID, pin, out tokenInfoCore);
}
catch (Exception innerException)
{
throw new Exception("SF.Expand.SAF.Core.PREProcessorTokens::Create[]", innerException);
}
return(result);
}
public ActionResult <RequestResult> ConversationList([FromServices] ITokens tokens, [FromServices] IConfiguration config,
[FromServices] MessageData data, [FromBody] ConversationList conversations)
{
Console.WriteLine("CONVERSATIONLIST");
var result = new RequestResult();
// Update state
data.Conversations = conversations.Conversations;
data.SortConversations();
// Preload 5 most recent conversations
for (int i = 0; i < 5 && data.Conversations.Count >= i; i++)
{
Conversation curr = data.Conversations[i];
if (!data.ConversationToMessages.ContainsKey(curr.ConversationID))
{
var msgDict = new Dictionary <string, object>()
{
{ "Token", tokens.AndroidToken },
{ "ConversationID", Convert.ToString(curr.ConversationID) }
};
Utilities.FirebaseUtilities.Notify(config, tokens.AndroidToken, "RetrieveMessageList", msgDict);
}
}
// Notify the client that the data has been updated and is ready to retrieve
var dict = new Dictionary <string, object>()
{
{ "Token", tokens.ClientToken }
};
var response = Utilities.FirebaseUtilities.Notify(config, tokens.ClientToken, "ConversationList", dict);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully sent Bulk Messages to firebase";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
public OperationResult CheckStatus(string tokenInternalID, out TokenStatus tokenStatus)
{
OperationResult result;
try
{
string typeName = new TokensValidatorDAO().DeployAssemblyNameByTokenID(tokenInternalID);
ITokens tokens = TokensFactory.LoadAssembly(typeName);
result = tokens.CheckStatus(tokenInternalID, out tokenStatus);
}
catch (Exception)
{
tokenStatus = TokenStatus.Undefined;
result = OperationResult.Error;
}
return(result);
}
public ActionResult <RequestResult> Token([FromServices] ITokens tokens, string token)
{
var result = new RequestResult();
if (!string.IsNullOrEmpty(token))
{
tokens.ClientToken = token;
result.Status = ResultStatus.Success;
result.ResultMessage = "Token Received Successfully";
return(Ok(result));
}
else
{
result.Status = ResultStatus.Failure;
result.ErrorMessage = "Failure. Null or Empty token string";
return(BadRequest(result));
}
}
public ActionResult <RequestResult> SentMessageStatus([FromServices] ITokens tokens,
[FromServices] IConfiguration config, [FromServices] MessageData messageData, [FromBody] MessageStatus messageStatus)
{
var result = new RequestResult();
const string firebaseFuncName = "SentMessageStatus";
var client = new RestClient(config["FirebaseLink"]);
var clientToken = tokens.ClientToken;
var req = new RestRequest(firebaseFuncName, Method.POST);
var dict = new Dictionary <string, object>
{
{ "Token", clientToken },
{ "MessageID", messageStatus.MessageID },
{ "MessageStatus", messageStatus.Status }
};
// GUID stuff
if (messageData.UnsentMessageGuids.ContainsKey(messageStatus.MessageID))
{
messageData.UnsentMessageGuids[messageStatus.MessageID].sentSuccessfully = true;
messageData.UnsentMessageGuids.Remove(messageStatus.MessageID);
}
req.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(dict), ParameterType.RequestBody);
var response = client.Execute(req);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully sent SMS Message result to firebase";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
public OperationResult Create(string tokenVendorID, DateTime expirationDate, string supplierSerialNumber, string creationLotID, string pin, out TokenInfoCore tokenInfoCore)
{
tokenInfoCore = new TokenInfoCore();
OperationResult result;
try
{
string assemb = new TokensValidatorDAO().DeployAssemblyNameByTokenParamsID(tokenVendorID);
ITokens _tokens = TokensFactory.LoadAssembly(assemb);
if (_tokens == null)
{
SAFLOGGER.Write(SAFLOGGER.LOGGEREventID.ERROR, "SAFCORE", new string[]
{
"http://sfexpand.SAFCore.PREProcessorTokens.softfinanca.com/",
"[ITokens]::" + assemb.Trim(),
"Invalid or null typename!"
});
tokenInfoCore = new TokenInfoCore();
result = OperationResult.Error;
}
else
{
result = _tokens.Create(tokenVendorID, expirationDate, supplierSerialNumber, creationLotID, pin, out tokenInfoCore);
}
}
catch (Exception ex)
{
SAFLOGGER.Write(SAFLOGGER.LOGGEREventID.EXCEPTION, "SAFCORE", new string[]
{
"http://sfexpand.SAFCore.PREProcessorTokens.softfinanca.com/",
Assembly.GetExecutingAssembly().FullName.ToString(),
ex.ToString()
});
tokenInfoCore = new TokenInfoCore();
result = OperationResult.Error;
}
return(result);
}
public ActionResult <RequestResult> RetrieveConversations([FromServices] ITokens tokens,
[FromServices] IConfiguration config, [FromServices] MessageData data)
{
var result = new RequestResult();
var dict = new Dictionary <string, object>()
{
{ "Token", tokens.AndroidToken }
};
if (data.Conversations == null || data.Conversations.Count == 0)
{
var response = Utilities.FirebaseUtilities.Notify(config, tokens.AndroidToken, "RetrieveConversations", dict);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully sent retrieveConversations request to firebase";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
else
{
var clientDict = new Dictionary <string, object>()
{
{ "Token", tokens.ClientToken }
};
var response = Utilities.FirebaseUtilities.Notify(config, tokens.ClientToken, "ConversationList", clientDict);
return(Ok(result));
}
}
public ActionResult <RequestResult> MessageList([FromServices] ITokens tokens, [FromServices] IConfiguration config,
[FromServices] MessageData data, [FromBody] MessageListRequest messages)
{
var result = new RequestResult();
Console.WriteLine($"Messages for Conversation {messages.ConversationID} have been loaded");
foreach (var message in messages.Messages)
{
message.sentSuccessfully = true;
}
// Update state
data.ConversationToMessages[messages.ConversationID] = messages.Messages;
data.ConversationToMessages[messages.ConversationID].Sort();
// Notify the client that the data has been updated and is ready to retrieve
var dict = new Dictionary <string, object>()
{
{ "Token", tokens.ClientToken },
{ "ConversationID", messages.ConversationID.ToString() }
};
var response = Utilities.FirebaseUtilities.Notify(config, tokens.ClientToken, "MessageList", dict);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully notified client of message list availability";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
public ActionResult <RequestResult> NewMessageReceived([FromServices] ITokens tokens,
[FromServices] IConfiguration config, [FromServices] MessageData messageData, [FromBody] Message message)
{
// Update the ConversationList information when a new message is received
var wasConversationFound = false;
foreach (var c in messageData.Conversations.Where(c => c.ConversationID == message.ConversationID))
{
c.MostRecent = message.MessageBody;
c.MostRecentTimestamp = message.TimeStamp;
wasConversationFound = true;
}
messageData.SortConversations();
if (!wasConversationFound)
{
messageData.Conversations.Add(new Conversation()
{
ConversationID = message.ConversationID,
MostRecent = message.MessageBody,
MostRecentTimestamp = message.TimeStamp,
// Consider refactoring this because really this /could/ be different
Participants = new List <string> {
message.Sender
}
});
}
// Update the MessageList information when a new message is received
if (messageData.ConversationToMessages.TryGetValue(message.ConversationID, out var messageList))
{
messageList.Add(message);
}
else
{
messageData.ConversationToMessages.Add(message.ConversationID, new List <Message>
{
message
});
}
var result = new RequestResult();
const string firebaseFuncName = "newMessageReceived";
var client = new RestClient(config["FirebaseLink"]);
var clientToken = tokens.ClientToken;
var req = new RestRequest(firebaseFuncName, Method.POST);
var dict = new Dictionary <string, object>
{
{ "Token", clientToken },
{ "Message", JsonConvert.SerializeObject(message) },
};
req.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(dict), ParameterType.RequestBody);
var response = client.Execute(req);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully notified client of new message";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
/// <param name='operations'>
/// Reference to the ConsoleApplication2.ITokens.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
public static async Task <Conversation> RefreshTokenAsync(this ITokens operations, CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
Microsoft.Rest.HttpOperationResponse <ConsoleApplication2.Models.Conversation> result = await operations.RefreshTokenWithOperationResponseAsync(cancellationToken).ConfigureAwait(false);
return(result.Body);
}
/// <summary>
/// Refresh a token
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
public static Conversation RefreshToken(this ITokens operations)
{
return(operations.RefreshTokenAsync().GetAwaiter().GetResult());
}
/// <summary>
/// Generate a token for a new conversation
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='tokenParameters'>
/// </param>
public static Conversation GenerateTokenForNewConversation(this ITokens operations, TokenParameters tokenParameters = default(TokenParameters))
{
return(Task.Factory.StartNew(s => ((ITokens)s).GenerateTokenForNewConversationAsync(tokenParameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <summary>
/// Generate a token for a new conversation
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
public static Conversation GenerateTokenForNewConversation(this ITokens operations)
{
return(operations.GenerateTokenForNewConversationAsync().GetAwaiter().GetResult());
}
public ActionResult <RequestResult> SendMessage([FromServices] ITokens tokens, [FromServices] IConfiguration config, [FromServices] MessageData messageData, MessageSendRequest messageSendRequest)
{
var result = new RequestResult();
const string firebaseFuncName = "SendMessage";
var client = new RestClient(config["FirebaseLink"]);
var androidToken = tokens.AndroidToken;
var req = new RestRequest(firebaseFuncName, Method.POST);
var message = messageSendRequest.Message;
var recipients = messageSendRequest.Recipients;
var messageID = messageSendRequest.MessageID;
foreach (var conversation in messageData.Conversations.Where(conversation => conversation.ConversationID == messageSendRequest.ConversationID))
{
conversation.MostRecent = message;
}
Message newMsg = new Message();
newMsg.ConversationID = messageSendRequest.ConversationID;
newMsg.sentSuccessfully = false;
newMsg.Sender = "";
newMsg.IsSender = true;
newMsg.TimeStamp = DateTime.Now;
newMsg.MessageBody = message;
// GUID stuff
messageData.UnsentMessageGuids[messageID] = newMsg;
if (messageData.ConversationToMessages.TryGetValue(messageSendRequest.ConversationID, out var msgList))
{
messageData.ConversationToMessages[messageSendRequest.ConversationID].Add(newMsg);
}
else
{
messageData.ConversationToMessages[messageSendRequest.ConversationID] = new List <Message>();
messageData.ConversationToMessages[messageSendRequest.ConversationID].Add(newMsg);
}
var dict = new Dictionary <string, object>()
{
{ "Token", androidToken },
{ "Message", message },
{ "Recipients", JsonConvert.SerializeObject(recipients) },
{ "MessageID", messageID }
};
req.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(dict), ParameterType.RequestBody);
req.RequestFormat = DataFormat.Json;
var response = client.Execute(req);
if (response.StatusCode == HttpStatusCode.OK)
{
result.ResultMessage = "Successfully sent SendMessage request to firebase";
result.Status = ResultStatus.Success;
return(Ok(result));
}
else
{
result.ErrorMessage = response.ErrorMessage;
result.Status = ResultStatus.Failure;
return(BadRequest(result));
}
}
public HtmlSerializerSettings(int indentCount, bool useParrentIndent, bool useCompactStyle, ITokens tokens)
{
IndentCount = indentCount;
UseParrentIndent = useParrentIndent;
UseCompactStyle = useCompactStyle;
Tokens = tokens ?? throw new ArgumentNullException(nameof(tokens));
}
public TFIDFToken(ITokens sources, int wordHash)
{
Sources = sources; WordHash = wordHash;
}
