private async Task ClientOnError(
IServerStreamWriter <ResponseEnvelope> responseStream,
Exception ex
)
{
await SendEnvelopeToClient(responseStream, new ResponseEnvelope {
Payload = EnvelopeHelper.Pack(ex),
PayloadType = ex.GetType().FullName,
RxMethod = ResponseEnvelope.Types.RxMethod.Error
});
}
private async Task ClientOnNext(
IServerStreamWriter <ResponseEnvelope> responseStream,
object payload
)
{
await SendEnvelopeToClient(responseStream, new ResponseEnvelope {
Payload = EnvelopeHelper.Pack(payload),
PayloadType = payload.GetType().FullName,
RxMethod = ResponseEnvelope.Types.RxMethod.Next
});
}
private async Task ListenToResponseStream <T>(
Action <T> onNext,
Action onCompleted,
Action <Exception> onError,
CancellationToken token)
{
while (!token.IsCancellationRequested &&
await _streamingCall.ResponseStream.MoveNext(token))
{
var @event = _streamingCall.ResponseStream.Current;
switch (@event.RxMethod)
{
case RxMethod.Next:
var payloadType = _options.TypesToTransfer.FirstOrDefault(t => @event.PayloadType.IndexOf(t.FullName) != -1);
if (payloadType == null)
{
// TODO: Log this (separate gRpc log)
break;
}
var payload = EnvelopeHelper.Unpack <T>(@event.Payload, payloadType);
onNext(payload);
break;
case RxMethod.Completed:
onCompleted();
return;
case RxMethod.Error:
// TODO: Exotic error types aren't supported atm
var ex = EnvelopeHelper.Unpack <Exception>(@event.Payload);
onError(ex);
return;
}
}
var message = token.IsCancellationRequested ? "Subscription was cancelled" : "Stream ended abruptly";
onError(new TaskCanceledException(message));
}
public HttpResponseMessage SendEnvelope(TemplateSend template)
{
HttpResponseMessage responseToClient = new HttpResponseMessage();
try
{
int displayCode = 0;
bool flagRole = true;
System.Collections.Generic.IEnumerable<string> iHeader;
Request.Headers.TryGetValues("AuthToken", out iHeader);
string authToken = iHeader.ElementAt(0);
Envelope envelope = new Envelope();
Dictionary<string, string> roleDic = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
EnvelopeHelperMain objEnvelope = new EnvelopeHelperMain();
EntityCollection<Recipients> recipients = new EntityCollection<Recipients>();
Recipients recipint = new Recipients();
using (var dbContext = new eSignEntities())
{
List<Roles> roleList = new List<Roles>();
UserTokenRepository tokenRepository = new UserTokenRepository(dbContext);
EnvelopeRepository envelopeRepository = new EnvelopeRepository(dbContext);
string userEmail = tokenRepository.GetUserEmailByToken(authToken);
Guid UserId = tokenRepository.GetUserProfileUserIDByID(tokenRepository.GetUserProfileIDByEmail(userEmail));
envelope = envelopeRepository.GetTemplateDetails(template.TemplateCode, UserId);
if (envelope == null)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.NoContent;
responseMessage.StatusMessage = "NoContent";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["NoContent"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.NoContent, responseMessage);
return responseToClient;
}
envelope.Message = template.MailBody;
envelope.Subject = template.MailSubject;
roleList = envelopeRepository.GetRoles(envelope.ID);
envelope.IsEnvelopeComplete = true;
envelope.IsEnvelopePrepare = true;
if (template.Recipients.Count != roleList.Count)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["RolesCount"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return responseToClient;
}
foreach (var recip in template.Recipients)
{
flagRole = EnvelopeHelper.IsEmailValid(recip.EmailAddress);
if (!flagRole)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["Email"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return responseToClient;
}
foreach (var role in roleList)
{
if (role.Name.ToLower() == recip.Role.ToLower())
{
recipint.EmailAddress = recip.EmailAddress;
recipint.Name = recip.Role;
recipint.Order = role.Order;
recipint.RecipientTypeID = role.RecipientTypeID;
roleDic.Add(recipint.Name, recipint.EmailAddress);
}
}
}
foreach (var role in roleList)
{
if (!roleDic.ContainsKey(role.Name))
flagRole = false;
}
if (!flagRole)
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["RolesCount"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return responseToClient;
}
string Password = string.Empty;
if (envelope.PasswordReqdtoSign)
{
Password = ModelHelper.Decrypt(envelope.PasswordtoSign, envelope.PasswordKey, (int)envelope.PasswordKeySize);
envelope.PasswordtoSign = Password;
}
else
envelope.PasswordtoSign = null;
if (envelope.PasswordReqdtoOpen)
{
Password = ModelHelper.Decrypt(envelope.PasswordtoOpen, envelope.PasswordKey, (int)envelope.PasswordKeySize);
envelope.PasswordtoOpen = Password;
}
else
envelope.PasswordtoOpen = null;
roleDic.Add("Sender", userEmail);
objEnvelope.SetApiCallFlag();
bool status = objEnvelope.UpdatedEnvelope(envelope, template.TemplateCode, roleDic, userEmail, out displayCode);
if (status == false)
{
ResponseMessage responseMessageFail = new ResponseMessage();
responseMessageFail.StatusCode = HttpStatusCode.Ambiguous;
responseMessageFail.StatusMessage = "Ambiguous";
responseMessageFail.Message = Convert.ToString(ConfigurationManager.AppSettings["EnvelopeFail"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessageFail);
return responseToClient;
}
}
ResponseMessageWithEnvID responseMessageSuccess = new ResponseMessageWithEnvID();
responseMessageSuccess.StatusCode = HttpStatusCode.OK;
responseMessageSuccess.StatusMessage = "OK";
responseMessageSuccess.EnvId = displayCode;
responseMessageSuccess.Message = Convert.ToString(ConfigurationManager.AppSettings["EnvelopeSucess"].ToString());
responseToClient = Request.CreateResponse(HttpStatusCode.OK, responseMessageSuccess);
return responseToClient;
}
catch (Exception ex)
{
responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(Convert.ToString(ConfigurationManager.AppSettings["EnvelopeFail"].ToString()), Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
#pragma warning disable CS1998
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
var value = turnContext.Activity;
var attachments = turnContext.Activity.Attachments;
if (turnContext.Activity.Value == null) // someone typed in something, it isn't a card
{
var content = turnContext.Activity.Text;
var code = CheckForCode(content);
var conversationReference = turnContext.Activity.GetConversationReference();
var mention = new Mention
{
Mentioned = turnContext.Activity.From,
Text = $"<at>{turnContext.Activity.From.Name}</at>",
};
if (!string.IsNullOrEmpty(code))
{
if (DotNetInteractiveProcessRunner.Instance.CanExecuteCode)
{
var submissionToken = Guid.NewGuid().ToString("N");
var messageText = string.Empty;
var user = UserGame.GetOrCreateUser(mention, turnContext.Activity.From);
if (UserGame.CurrentChatUser?.Id != user.Id)
{
UserGame.CurrentChatUser = user;
messageText = $"Hey {mention.Text} It looks like you're typing some code. Let me run it for you! 😊";
}
else
{
messageText = UserGame.GetMessageForUser(mention);
}
await turnContext.Adapter.ContinueConversationAsync(_botId, conversationReference, async (context, token) =>
{
var message = MessageFactory.Text(messageText);
if (messageText.Contains(mention.Text))
{
message.Entities.Add(mention);
}
await context.SendActivityAsync(message, token);
}, cancellationToken);
// build the envelope
var submitCode = new SubmitCode(code);
submitCode.SetToken(submissionToken);
var envelope = KernelCommandEnvelope.Create(submitCode);
var channel = ContentSubjectHelper.GetOrCreateChannel(submissionToken);
EnvelopeHelper.StoreEnvelope(submissionToken, envelope);
var cardSent = false;
channel
.Timeout(DateTimeOffset.UtcNow.Add(TimeSpan.FromMinutes(1)))
.Buffer(TimeSpan.FromSeconds(1))
.Subscribe(
onNext: async formattedValues =>
{
turnContext.Adapter.ContinueConversationAsync(_botId, conversationReference,
(context, token) =>
{
if (formattedValues.Count > 0)
{
var hasHtml = formattedValues.Any(f => f.MimeType == HtmlFormatter.MimeType);
if (hasHtml)
{
if (!cardSent)
{
cardSent = true;
var card = new HeroCard
{
Title = "Your output is too awesome 😎",
Subtitle = "Use the viewer to see it.",
Buttons = new List <CardAction>
{
new TaskModuleAction("Open Viewer",
new { data = submissionToken })
},
}.ToAttachment();
var message = MessageFactory.Attachment(card);
context.SendActivityAsync(message, token).Wait();
}
}
else
{
var content = string.Join("\n", formattedValues.Select(f => f.Value));
var message = MessageFactory.Text($"```\n{content.HtmlEncode()}");
context.SendActivityAsync(message, token).Wait();
}
}
return(Task.CompletedTask);
}, cancellationToken).Wait();
}, onCompleted: async() =>
{
await turnContext.Adapter.ContinueConversationAsync(_botId, conversationReference, async(context, token) =>
{
await Task.Delay(1000);
var message = MessageFactory.Text($"{mention.Text} all done here 👍");
message.Entities.Add(mention);
await context.SendActivityAsync(message, token);
}, cancellationToken);
},
onError: async error =>
{
await turnContext.Adapter.ContinueConversationAsync(_botId, conversationReference, async(context, token) =>
{
await Task.Delay(1000);
var message = MessageFactory.Text($@"{mention.Text} there were some issues 👎 :\n {error.Message}");
message.Entities.Add(mention);
await context.SendActivityAsync(message, token);
}, cancellationToken);
});
user.IncrementCodeSubmissionCount();
await DotNetInteractiveProcessRunner.Instance.ExecuteEnvelope(submissionToken);
}
else
{
await turnContext.Adapter.ContinueConversationAsync(_botId, conversationReference, async (context, token) =>
{
var message = MessageFactory.Text($"Sorry {mention.Text} cannot execute your code now. 😓");
message.Entities.Add(mention);
await context.SendActivityAsync(message, token);
}, cancellationToken);
}
}
else if (string.IsNullOrWhiteSpace(DotNetInteractiveProcessRunner.Instance.SessionLanguage))
{
var card = CardUtilities.CreateAdaptiveCardAttachment(CardJsonFiles.SelectLanguage);
var attach = MessageFactory.Attachment(card);
await turnContext.SendActivityAsync(attach, cancellationToken);
}
else if (content.Contains("👊"))
{
var mentioned = turnContext.Activity.GetMentions()?.FirstOrDefault(m => m.Mentioned.Id.EndsWith(_botId));
if (mentioned != null)
{
await turnContext.Adapter.ContinueConversationAsync(_botId, conversationReference,
async (context, token) =>
{
var message = MessageFactory.Text($"{mention.Text} back at you my friend! 👊");
message.Entities.Add(mention);
await context.SendActivityAsync(message, token);
}, cancellationToken);
}
}
}
else
{
var userAction = turnContext.Activity.Value;
if (((JObject)userAction).Value <string>("userAction").Equals("SelectLanguage"))
{
if (string.IsNullOrWhiteSpace(DotNetInteractiveProcessRunner.Instance.SessionLanguage))
{
var language = ((JObject)userAction).Value <string>("language");
DotNetInteractiveProcessRunner.Instance.SessionLanguage = language;
var languageLabel = ((JObject)userAction).Value <string>("languageLabel");
var message = MessageFactory.Text($"All set. Let's write some {DotNetInteractiveProcessRunner.Instance.SessionLanguage} code together! 🤘🏻");
await turnContext.SendActivityAsync(message, cancellationToken);
}
}
}
}
public HttpResponseMessage RegisterUser(UserProfileToken objUser)
{
try
{
var rpostServiceAPI = new RpostServiceAPI();
if (!EnvelopeHelper.IsEmailValid(objUser.EmailId))
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Forbidden;
responseMessage.StatusMessage = "Forbidden";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["EmailWrong"].ToString());
HttpResponseMessage responseToClient = Request.CreateResponse(HttpStatusCode.Forbidden, responseMessage);
return(responseToClient);
}
eSign.Notification.RpostService.ServiceResponse response = rpostServiceAPI.RegisterUser(objUser.EmailId, objUser.Password, "1", "en-US", objUser.FirstName + " " + objUser.LastName);
if (response.Response == "Registration Successfully Processed")
{
var userProfile = new UserProfile
{
ID = Guid.NewGuid(),
UserID = Guid.NewGuid(),
EmailID = objUser.EmailId,
FirstName = objUser.FirstName,
LastName = objUser.LastName
};
using (var dbContext = new eSignEntities())
{
UserRepository userRepository = new UserRepository(dbContext);
userRepository.Save(userProfile);
dbContext.SaveChanges();
}
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Created;
responseMessage.StatusMessage = "Created";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["Success"].ToString());
HttpResponseMessage responseToClient = Request.CreateResponse(HttpStatusCode.Created, responseMessage);
return(responseToClient);
}
else if (response.Response == "The email address that entered is already registered in the system.")
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.Conflict;
responseMessage.StatusMessage = "Conflict";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["AlreadyRegistered"].ToString());
HttpResponseMessage responseToClient = Request.CreateResponse(HttpStatusCode.Conflict, responseMessage);
return(responseToClient);
}
else
{
ResponseMessage responseMessage = new ResponseMessage();
responseMessage.StatusCode = HttpStatusCode.BadRequest;
responseMessage.StatusMessage = "BadRequest";
responseMessage.Message = Convert.ToString(ConfigurationManager.AppSettings["Failed"].ToString());
HttpResponseMessage responseToClient = Request.CreateResponse(HttpStatusCode.BadRequest, responseMessage);
return(responseToClient);
}
}
catch (Exception ex)
{
HttpResponseMessage responseToClient = Request.CreateResponse((HttpStatusCode)422);
responseToClient.Content = new StringContent(ex.Message, Encoding.Unicode);
throw new HttpResponseException(responseToClient);
}
}
