public static DateTime CreateDateFromWhenCommand(IAuthenticatedWho authenticatedWho, String when, String adminEmail)
{
DateTime whenDate = DateTime.Now;
String[] whenConfig = null;
Int32 days = 0;
// Supported when commands are "n days" or "n day" and "now"
if (when.IndexOf("day", StringComparison.InvariantCultureIgnoreCase) > 0)
{
// Split the when by the space
whenConfig = when.Split(' ');
// Check to make sure the split was OK
if (whenConfig.Length > 0)
{
// Check to make sure the first parameter in the split is the number of days
if (Int32.TryParse(whenConfig[0], out days) == false)
{
// send the author an error message
}
// Add the days to our task
whenDate = whenDate.AddDays(days);
}
}
else if (when.Trim().Equals("now", StringComparison.InvariantCultureIgnoreCase) == true)
{
// Use the date as of right now
whenDate = DateTime.Now;
}
else
{
// throw and error as this is not a supported command
String errorMessage = "The provided 'when' command is not valid: " + when;
ErrorUtils.SendAlert(authenticatedWho, ErrorUtils.ALERT_TYPE_FAULT, adminEmail, "SalesforcePlugin", errorMessage);
throw ErrorUtils.GetWebException(HttpStatusCode.InternalServerError, errorMessage);
}
return whenDate;
}
public static ObjectAPI CreateUserObject(IAuthenticatedWho authenticatedWho)
{
ObjectAPI userObject = null;
userObject = new ObjectAPI();
userObject.developerName = ManyWhoConstants.MANYWHO_USER_DEVELOPER_NAME;
userObject.properties = new List<PropertyAPI>();
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_DIRECTORY_ID, authenticatedWho.DirectoryId));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_DIRECTORY_NAME, authenticatedWho.DirectoryName));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_COUNTRY, null));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_EMAIL, authenticatedWho.Email));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_USERNAME, authenticatedWho.Email));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_FIRST_NAME, null));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_LANGUAGE, null));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_LAST_NAME, null));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_LOCATION, null));
userObject.properties.Add(CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_USER_ID, authenticatedWho.UserId));
return userObject;
}
public ServiceResponseAPI InvokeNotifyUsers(INotifier notifier, IAuthenticatedWho authenticatedWho, ServiceRequestAPI serviceRequest)
{
ChatterPostedMessage chatterPostedMessage = null;
ChatterNewMessageSegment chatterNewMessageSegment = null;
ServiceResponseAPI serviceResponse = null;
SforceService sforceService = null;
String groupAuthenticationToken = null;
String authenticationUrl = null;
String username = null;
String password = null;
String securityToken = null;
String chatterBaseUrl = null;
String adminEmail = null;
String endpointUrl = null;
String message = null;
// Grab the configuration values from the service request
authenticationUrl = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_AUTHENTICATION_URL, serviceRequest.configurationValues, true);
username = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_USERNAME, serviceRequest.configurationValues, true);
password = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_PASSWORD, serviceRequest.configurationValues, true);
securityToken = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_SECURITY_TOKEN, serviceRequest.configurationValues, false);
chatterBaseUrl = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_CHATTER_BASE_URL, serviceRequest.configurationValues, true);
adminEmail = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_ADMIN_EMAIL, serviceRequest.configurationValues, true);
if (serviceRequest.authorization != null)
{
Boolean postMade = false;
// Get the message from the inputs
message = ValueUtils.GetContentValue("Post", serviceRequest.inputs, true);
// Check to see if we have any group authorization - if so, we post to those groups
if (serviceRequest.authorization.groups != null &&
serviceRequest.authorization.groups.Count > 0)
{
foreach (GroupAuthorizationGroupAPI groupAuthorization in serviceRequest.authorization.groups)
{
// For group posts, we post as the admin, not as the user - as it's very likely the user does not have permissions to post
if (groupAuthenticationToken == null ||
groupAuthenticationToken.Trim().Length == 0)
{
// Login as the API user
sforceService = SalesforceDataSingleton.GetInstance().Login(authenticatedWho, serviceRequest.configurationValues, true, false);
if (sforceService == null)
{
throw new ArgumentNullException("SalesforceService", "Unable to log into Salesforce.");
}
// Get the session id out as we'll use that for the oauth login
groupAuthenticationToken = sforceService.SessionHeaderValue.sessionId;
}
// Create the endpoint url for the group
endpointUrl = chatterBaseUrl + SalesforceServiceSingleton.CHATTER_URI_PART_API_VERSION + String.Format(SalesforceServiceSingleton.CHATTER_URI_PART_POSTS, groupAuthorization.authenticationId);
// Create a new chatter post
chatterPostedMessage = new ChatterPostedMessage();
chatterPostedMessage.Body = new ChatterNewMessageBody();
chatterPostedMessage.Body.MessageSegments = new List <ChatterSegment>();
// Create a message segment for the actual post
chatterNewMessageSegment = new ChatterNewMessageSegment();
chatterNewMessageSegment.Type = ChatterMessageSegmentType.Text.ToString();
chatterNewMessageSegment.Text = message;
// Add the segment to the post
chatterPostedMessage.Body.MessageSegments.Add(chatterNewMessageSegment);
// Post the message synchronously
SalesforceSocialSingleton.GetInstance().PostNotification(notifier, authenticatedWho, groupAuthenticationToken, serviceRequest, endpointUrl, serviceRequest.joinPlayerUri, chatterPostedMessage);
// Set the flag that we did in fact make a post
postMade = true;
}
}
// Check to see if we have any user authorization - if so, we post to those users
if (serviceRequest.authorization.users != null &&
serviceRequest.authorization.users.Count > 0)
{
// Create the endpoint url
endpointUrl = chatterBaseUrl + SalesforceServiceSingleton.CHATTER_URI_PART_API_VERSION + String.Format(SalesforceServiceSingleton.CHATTER_URI_PART_MY_FEED, authenticatedWho.UserId);
// Create a new chatter post
chatterPostedMessage = new ChatterPostedMessage();
chatterPostedMessage.Body = new ChatterNewMessageBody();
chatterPostedMessage.Body.MessageSegments = new List <ChatterSegment>();
// Create a message segment for the actual post
chatterNewMessageSegment = new ChatterNewMessageSegment();
chatterNewMessageSegment.Type = ChatterMessageSegmentType.Text.ToString();
chatterNewMessageSegment.Text = message;
// Add the segment to the post
chatterPostedMessage.Body.MessageSegments.Add(chatterNewMessageSegment);
// Rather than posting to each user, we do a joint post to all of the users that need to be notified
foreach (GroupAuthorizationUserAPI userAuthorization in serviceRequest.authorization.users)
{
ChatterMentionsSegment chatterMentionsSegment = null;
chatterMentionsSegment = new ChatterMentionsSegment();
chatterMentionsSegment.Id = userAuthorization.authenticationId;
chatterMentionsSegment.Type = ChatterMessageSegmentType.Mention.ToString();
// Add the user to the @mention
chatterPostedMessage.Body.MessageSegments.Add(chatterMentionsSegment);
}
// Post the message synchronously
SalesforceSocialSingleton.GetInstance().PostNotification(notifier, authenticatedWho, serviceRequest, endpointUrl, serviceRequest.joinPlayerUri, chatterPostedMessage);
// Set the flag that we did in fact make a post
postMade = true;
}
if (postMade == false)
{
// Alert the admin that no message was sent
ErrorUtils.SendAlert(notifier, authenticatedWho, ErrorUtils.ALERT_TYPE_WARNING, "The service request does not have anything in the authorization context, so there's no one to notify.");
}
}
else
{
// Alert the admin that no one is in the authorization context
ErrorUtils.SendAlert(notifier, authenticatedWho, ErrorUtils.ALERT_TYPE_WARNING, "The service request does not have an authorization context, so there's no one to notify.");
}
// Construct the service response
serviceResponse = new ServiceResponseAPI();
serviceResponse.invokeType = ManyWhoConstants.INVOKE_TYPE_FORWARD;
serviceResponse.token = serviceRequest.token;
serviceResponse.outputs = null;
return(serviceResponse);
}
/// <summary>
/// This method is used to invoke particular messages on the service.
/// </summary>
public async Task<ServiceResponseAPI> Invoke(IAuthenticatedWho authenticatedWho, String action, ServiceRequestAPI serviceRequest)
{
System.Diagnostics.Trace.TraceInformation("@start - public async Task<ServiceResponseAPI> Invoke(IAuthenticatedWho authenticatedWho, String action, ServiceRequestAPI serviceRequest)");
Trace.TraceInformation(JsonConvert.SerializeObject(authenticatedWho));
Trace.TraceInformation(JsonConvert.SerializeObject(action));
Trace.TraceInformation(JsonConvert.SerializeObject(serviceRequest));
ServiceResponseAPI serviceResponse = null;
if (string.IsNullOrEmpty(action))
{
throw ErrorUtils.GetWebException(HttpStatusCode.BadRequest, "Action cannot be null or blank.");
}
if (serviceRequest == null)
{
throw ErrorUtils.GetWebException(HttpStatusCode.BadRequest, "ServiceRequest cannot be null.");
}
if (action.Equals(SERVICE_ACTION_LOGIN, StringComparison.InvariantCultureIgnoreCase) == true)
{
serviceResponse = await SalesforceInvokeSingleton.GetInstance().InvokeCreateMatter(authenticatedWho, serviceRequest);
}
else
{
// We don't have an action by that name
throw ErrorUtils.GetWebException(HttpStatusCode.BadRequest, "Action cannot be found for name: " + action);
}
return serviceResponse;
}
public MessageAPI PostNotification(INotifier notifier, IAuthenticatedWho authenticatedWho, ServiceRequestAPI serviceRequest, String endpointUrl, String flowLink, ChatterPostedMessage chatterPostedMessage)
{
return(PostNotification(notifier, authenticatedWho, SalesforceHttpUtils.GetAuthenticationDetails(authenticatedWho.Token).Token, serviceRequest, endpointUrl, flowLink, chatterPostedMessage));
}
public static void SendAlert(INotifier notifier, IAuthenticatedWho authenticatedWho, String alertType, String alertMessage)
{
SendAlert(notifier, authenticatedWho, alertType, alertMessage, null);
}
public static INotifier GetInstance(IAuthenticatedWho authenticatedWho, List <EngineValueAPI> configurationValues, String codeReference)
{
return(GetInstance(null, authenticatedWho, configurationValues, codeReference));
}
public static IAuthenticatedWho Deserialize(String token)
{
IAuthenticatedWho authenticatedWho = null;
String[] parameters = null;
String directoryIdParameter = null;
String directoryNameParameter = null;
String roleIdParameter = null;
String roleNameParameter = null;
String primaryGroupIdParameter = null;
String primaryGroupNameParameter = null;
String identityProviderParameter = null;
String manywhoTenantIdParameter = null;
String manywhoUserIdParameter = null;
String manywhoTokenParameter = null;
String tenantNameParameter = null;
String tokenParameter = null;
String userIdParameter = null;
String usernameParameter = null;
String emailParameter = null;
String firstNameParameter = null;
String lastNameParameter = null;
// Start by splitting the string so we have a complete key/value pairing
parameters = token.Split('&');
// Grab the parameters for each of the properties from the array
manywhoTenantIdParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_MANYWHO_TENANT_ID, StringComparison.OrdinalIgnoreCase));
manywhoUserIdParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_MANYWHO_USER_ID, StringComparison.OrdinalIgnoreCase));
manywhoTokenParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_MANYWHO_TOKEN, StringComparison.OrdinalIgnoreCase));
directoryIdParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_DIRECTORY_ID, StringComparison.OrdinalIgnoreCase));
directoryNameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_DIRECTORY_NAME, StringComparison.OrdinalIgnoreCase));
roleIdParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_ROLE_ID, StringComparison.OrdinalIgnoreCase));
roleNameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_ROLE_NAME, StringComparison.OrdinalIgnoreCase));
primaryGroupIdParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_PRIMARY_GROUP_ID, StringComparison.OrdinalIgnoreCase));
primaryGroupNameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_PRIMARY_GROUP_NAME, StringComparison.OrdinalIgnoreCase));
emailParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_EMAIL, StringComparison.OrdinalIgnoreCase));
identityProviderParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_IDENTITY_PROVIDER, StringComparison.OrdinalIgnoreCase));
tenantNameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_TENANT_NAME, StringComparison.OrdinalIgnoreCase));
tokenParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_TOKEN, StringComparison.OrdinalIgnoreCase));
userIdParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_USER_ID, StringComparison.OrdinalIgnoreCase));
usernameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_USERNAME, StringComparison.OrdinalIgnoreCase));
firstNameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_FIRST_NAME, StringComparison.OrdinalIgnoreCase));
lastNameParameter = parameters.Single(value => value.StartsWith(ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_LAST_NAME, StringComparison.OrdinalIgnoreCase));
// Check to make sure we have all of the parameters
Validation.Instance.IsNotNullOrWhiteSpace(manywhoTenantIdParameter, "ManyWhoTenantId", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_MANYWHO_TENANT_ID)
.IsNotNullOrWhiteSpace(manywhoUserIdParameter, "ManyWhoUserId", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_MANYWHO_USER_ID)
.IsNotNullOrWhiteSpace(manywhoTokenParameter, "ManyWhoToken", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_MANYWHO_TOKEN)
.IsNotNullOrWhiteSpace(directoryIdParameter, "DirectoryId", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_DIRECTORY_ID)
.IsNotNullOrWhiteSpace(directoryNameParameter, "DirectoryName", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_DIRECTORY_NAME)
.IsNotNullOrWhiteSpace(emailParameter, "Email", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_EMAIL)
.IsNotNullOrWhiteSpace(identityProviderParameter, "IdentityProvider", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_IDENTITY_PROVIDER)
.IsNotNullOrWhiteSpace(tenantNameParameter, "TenantName", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_TENANT_NAME)
.IsNotNullOrWhiteSpace(tokenParameter, "Token", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_TOKEN)
.IsNotNullOrWhiteSpace(userIdParameter, "UserId", "Missing parameter: " + ManyWhoConstants.AUTHENTICATED_WHO_TOKEN_USER_ID);
// Create our new authenticated who object
authenticatedWho = new AuthenticatedWho();
authenticatedWho.ManyWhoTenantId = Guid.Parse(manywhoTenantIdParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1]);
authenticatedWho.ManyWhoUserId = Guid.Parse(manywhoUserIdParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1]);
authenticatedWho.ManyWhoToken = manywhoTokenParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.DirectoryId = directoryIdParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.DirectoryName = directoryNameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.Email = emailParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.IdentityProvider = identityProviderParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.TenantName = tenantNameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.Token = tokenParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
authenticatedWho.UserId = userIdParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
if (firstNameParameter != null &&
firstNameParameter.Trim().Length > 0)
{
authenticatedWho.FirstName = firstNameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
if (lastNameParameter != null &&
lastNameParameter.Trim().Length > 0)
{
authenticatedWho.LastName = lastNameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
if (usernameParameter != null &&
usernameParameter.Trim().Length > 0)
{
authenticatedWho.Username = usernameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
if (!string.IsNullOrWhiteSpace(roleIdParameter))
{
authenticatedWho.RoleId = roleIdParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
if (!string.IsNullOrWhiteSpace(roleNameParameter))
{
authenticatedWho.RoleName = roleNameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
if (!string.IsNullOrWhiteSpace(primaryGroupIdParameter))
{
authenticatedWho.PrimaryGroupId = primaryGroupIdParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
if (!string.IsNullOrWhiteSpace(primaryGroupNameParameter))
{
authenticatedWho.PrimaryGroupName = primaryGroupNameParameter.Split(ManyWhoConstants.SERIALIZATION_DELIMITER_DELIMITER)[1];
}
// Finally, validate the object is OK
ValidateAuthenticatedWho(authenticatedWho);
return(authenticatedWho);
}
/// <summary>
/// This method is used to get the list of stream messages in salesforce.
/// </summary>
public async Task<MessageListAPI> GetStreamMessages(IAuthenticatedWho authenticatedWho, String streamId, SocialServiceRequestAPI socialServiceRequest)
{
MessageListAPI messageList = null;
return messageList;
}
public static WebException HandleUnsuccessfulHttpResponseMessage(INotifier notifier, IAuthenticatedWho authenticatedWho, Int32 iteration, HttpResponseMessage httpResponseMessage, String endpointUrl)
{
WebException webException = null;
if (iteration >= (MAXIMUM_RETRIES - 1))
{
// The the alert email the fault
ErrorUtils.SendAlert(notifier, authenticatedWho, "Fault", "The system has attempted multiple retries (" + MAXIMUM_RETRIES + ") with no luck on: " + endpointUrl + ". The status code is: " + httpResponseMessage.StatusCode + ". The reason is: " + httpResponseMessage.ReasonPhrase);
// Throw the fault up to the caller
webException = new WebException(httpResponseMessage.ReasonPhrase);
}
else
{
// Alert the admin that a retry has happened
ErrorUtils.SendAlert(notifier, authenticatedWho, "Warning", "The system is attempting a retry (" + iteration + ") on: " + endpointUrl + ". The status code is: " + httpResponseMessage.StatusCode + ". The reason is: " + httpResponseMessage.ReasonPhrase);
}
return(webException);
}
/// <summary>
/// This method is used to get the user info for the provided user id in docordo.
/// </summary>
public WhoAPI GetUserInfo(IAuthenticatedWho authenticatedWho, String streamId, String id, SocialServiceRequestAPI serviceRequest)
{
WhoAPI whoAPI = null;
return whoAPI;
}
/// <summary>
/// This method is used to get the list of stream followers in salesforce.
/// </summary>
public List<WhoAPI> GetStreamFollowers(IAuthenticatedWho authenticatedWho, String streamId, SocialServiceRequestAPI socialServiceRequest)
{
List<WhoAPI> whos = null;
return whos;
}
/// <summary>
/// This method is used to create a new activity stream in salesforce based on the provided configuration.
/// </summary>
public String CreateStream(IAuthenticatedWho authenticatedWho, SocialServiceRequestAPI socialServiceRequestAPI)
{
String streamId = null;
return streamId;
}
/// <summary>
/// This method is used to check to see if the user is in the provided authorization context.
/// </summary>
public ObjectDataResponseAPI GetUserInAuthorizationContext(IAuthenticatedWho authenticatedWho, ObjectDataRequestAPI objectDataRequestAPI)
{
System.Diagnostics.Trace.TraceInformation("@start - public ObjectDataResponseAPI GetUserInAuthorizationContext(IAuthenticatedWho authenticatedWho, ObjectDataRequestAPI objectDataRequestAPI)");
Trace.TraceInformation(JsonConvert.SerializeObject(authenticatedWho));
Trace.TraceInformation(JsonConvert.SerializeObject(objectDataRequestAPI));
System.Diagnostics.Trace.TraceInformation("A");
ObjectAPI userObject = DescribeUtils.CreateUserObject(authenticatedWho);
System.Diagnostics.Trace.TraceInformation("B");
userObject.properties.Add(DescribeUtils.CreateProperty(ManyWhoConstants.MANYWHO_USER_PROPERTY_STATUS,
authenticatedWho.UserId == ManyWhoConstants.AUTHENTICATED_USER_PUBLIC_USER_ID ?
ManyWhoConstants.AUTHORIZATION_STATUS_NOT_AUTHORIZED : ManyWhoConstants.AUTHORIZATION_STATUS_AUTHORIZED));
System.Diagnostics.Trace.TraceInformation("C");
ObjectDataResponseAPI objectDataResponseAPI = new ObjectDataResponseAPI();
objectDataResponseAPI.objectData = new List<ObjectAPI>();
objectDataResponseAPI.objectData.Add(userObject);
System.Diagnostics.Trace.TraceInformation("D");
return objectDataResponseAPI;
}
/// <summary>
/// This method is used to save data back to docordo.com.
/// </summary>
public ObjectDataResponseAPI Save(IAuthenticatedWho authenticatedWho, ObjectDataRequestAPI objectDataRequestAPI)
{
System.Diagnostics.Trace.TraceInformation("@start - public ObjectDataResponseAPI Save(IAuthenticatedWho authenticatedWho, ObjectDataRequestAPI objectDataRequestAPI)");
Trace.TraceInformation(JsonConvert.SerializeObject(authenticatedWho));
Trace.TraceInformation(JsonConvert.SerializeObject(objectDataRequestAPI));
throw new NotImplementedException();
}
public Boolean SendEmail(INotifier notifier, IAuthenticatedWho authenticatedWho, ServiceRequestAPI serviceRequest, Boolean includeTracking)
{
SforceService sforceService = null;
List <String> toEmails = null;
Boolean includeOutcomesAsButtons = true;
String includeOutcomesAsButtonsString = null;
String toEmail = null;
String fromEmail = null;
String subject = null;
String textBody = null;
String htmlBody = null;
String authenticationUrl = null;
String username = null;
String password = null;
String securityToken = null;
String redirectUri = null;
// Get the configuration information for salesforce
authenticationUrl = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_AUTHENTICATION_URL, serviceRequest.configurationValues, true);
username = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_USERNAME, serviceRequest.configurationValues, true);
password = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_PASSWORD, serviceRequest.configurationValues, true);
securityToken = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_SECURITY_TOKEN, serviceRequest.configurationValues, false);
// Get the values from the incoming request
toEmail = ValueUtils.GetContentValue(SERVICE_VALUE_TO_EMAIL, serviceRequest.inputs, false);
fromEmail = ValueUtils.GetContentValue(SERVICE_VALUE_FROM_EMAIL, serviceRequest.inputs, false);
subject = ValueUtils.GetContentValue(SERVICE_VALUE_SUBJECT, serviceRequest.inputs, true);
textBody = ValueUtils.GetContentValue(SERVICE_VALUE_TEXT_BODY, serviceRequest.inputs, false);
htmlBody = ValueUtils.GetContentValue(SERVICE_VALUE_HTML_BODY, serviceRequest.inputs, false);
redirectUri = ValueUtils.GetContentValue(SERVICE_VALUE_REDIRECT_URI, serviceRequest.inputs, false);
includeOutcomesAsButtonsString = ValueUtils.GetContentValue(SERVICE_VALUE_INCLUDE_OUTCOMES_AS_BUTTONS, serviceRequest.inputs, false);
// Create the to emails list
toEmails = new List <String>();
// Check to see if we have a value for including outcome buttons
if (String.IsNullOrWhiteSpace(includeOutcomesAsButtonsString) == true)
{
// Default is true
includeOutcomesAsButtons = true;
}
else
{
includeOutcomesAsButtons = Boolean.Parse(includeOutcomesAsButtonsString);
}
if (String.IsNullOrWhiteSpace(toEmail) == true)
{
if (serviceRequest.authorization == null)
{
throw new ArgumentNullException("ServiceRequest.Authorization", "The ServiceRequest.Authorization property cannot be null as we will not know who to send the email to.");
}
if (serviceRequest.authorization.groups == null ||
serviceRequest.authorization.groups.Count == 0)
{
throw new ArgumentNullException("ServiceRequest.Authorization.Groups", "The ServiceRequest.Authorization.Groups property cannot be null or empty as we will not know who to send the email to.");
}
if (serviceRequest.authorization.groups.Count > 1)
{
throw new ArgumentNullException("ServiceRequest.Authorization.Groups", "The ServiceRequest.Authorization.Groups property cannot contain more than one group currently.");
}
// We need to get the users from salesforce
sforceService = SalesforceDataSingleton.GetInstance().Login(authenticatedWho, serviceRequest.configurationValues, true, false);
if (sforceService == null)
{
throw new ArgumentNullException("SalesforceService", "Unable to log into Salesforce.");
}
// Get the to emails from Salesforce
toEmails = SalesforceAuthenticationSingleton.GetInstance().GetGroupMemberEmails(notifier, sforceService, serviceRequest, serviceRequest.authorization.groups[0].authenticationId);
if (toEmails == null ||
toEmails.Count == 0)
{
throw new ArgumentNullException("ServiceRequest.Authorization.Groups", "The ServiceRequest.Authorization.Groups configuration is not returning any users to send the email to.");
}
}
else
{
// The user is explicitly setting the to email
toEmails.Add(toEmail);
}
if (includeOutcomesAsButtons == false)
{
// Null out any outcomes so we don't send them through
serviceRequest.outcomes = null;
}
// Send the actual email
this.SendEmail(serviceRequest.configurationValues, fromEmail, toEmails.ToArray(), null, subject, textBody, htmlBody, serviceRequest.token, redirectUri, serviceRequest.outcomes);
return(includeOutcomesAsButtons);
}
/// <summary>
/// This method allows the user to post a new message to the stream in chatter.
/// </summary>
public async Task<MessageAPI> PostNewMessage(IAuthenticatedWho authenticatedWho, String streamId, HttpContent httpContent)
{
MessageAPI message = null;
return message;
}
public static HttpClient CreateHttpClient(IAuthenticatedWho authenticatedWho, String tenantId, String stateId)
{
return(CreateHttpClient(authenticatedWho, tenantId, stateId, TIMEOUT_SECONDS));
}
/// <summary>
/// This method allows the user to like messages in the stream in chatter.
/// </summary>
public async Task<String> LikeMessage(IAuthenticatedWho authenticatedWho, String streamId, String messageId, Boolean like, SocialServiceRequestAPI socialServiceRequest)
{
String response = null;
return response;
}
public void SendNotification(IAuthenticatedWho receivingAuthenticatedWho, String reason, String mediaType, String message)
{
this.Reason = reason;
this.AddNotificationMessage(mediaType, message);
this.SendNotification(receivingAuthenticatedWho);
}
/// <summary>
/// This method allows the user to follow the stream in chatter.
/// </summary>
public async Task<String> FollowStream(IAuthenticatedWho authenticatedWho, String streamId, Boolean follow, SocialServiceRequestAPI socialServiceRequest)
{
String response = null;
return response;
}
public EmailNotifier(IAuthenticatedWho receivingAuthenticatedWho)
{
this.ReceivingAuthenticatedWho = receivingAuthenticatedWho;
this.NotificationMessages = new List <INotificationMessage>();
this.LogEntries = new List <String>();
}
/// <summary>
/// This method allows the user to search for users by name in chatter.
/// </summary>
public async Task<List<MentionedWhoAPI>> SearchUsersByName(IAuthenticatedWho authenticatedWho, String streamId, String name, SocialServiceRequestAPI socialServiceRequest)
{
List<MentionedWhoAPI> mentionedUsers = null;
return mentionedUsers;
}
/// <summary>
/// This is a general purpose method for getting user information from chatter.
/// </summary>
public WhoAPI GetUserInfoById(INotifier notifier, IAuthenticatedWho authenticatedWho, String streamId, String id, SocialServiceRequestAPI socialServiceRequestAPI)
{
List <WhoAPI> stuffAuthenticatedUserIsFollowing = null;
ChatterUserInfo chatterUserInfo = null;
HttpResponseMessage httpResponseMessage = null;
HttpClient httpClient = null;
WhoAPI who = null;
String chatterBaseUrl = null;
String endpointUrl = null;
String adminEmail = null;
if (authenticatedWho == null)
{
throw new ArgumentNullException("BadRequest", "AuthenticatedWho is null.");
}
if (id == null ||
id.Trim().Length == 0)
{
throw new ArgumentNullException("BadRequest", "Id for user is null or blank.");
}
if (streamId == null ||
streamId.Trim().Length == 0)
{
throw new ArgumentNullException("BadRequest", "Stream identifier is null or blank.");
}
if (socialServiceRequestAPI == null)
{
throw new ArgumentNullException("BadRequest", "SocialServiceRequest is null.");
}
// We only need the chatter base url for this call
chatterBaseUrl = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_CHATTER_BASE_URL, socialServiceRequestAPI.configurationValues, true);
adminEmail = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_ADMIN_EMAIL, socialServiceRequestAPI.configurationValues, true);
// We enclose the request in a for loop to handle http errors
for (int i = 0; i < SalesforceHttpUtils.MAXIMUM_RETRIES; i++)
{
try
{
// Create a new client object
httpClient = SalesforceHttpUtils.CreateHttpClient(SalesforceHttpUtils.GetAuthenticationDetails(authenticatedWho.Token).Token);
// Create the endpoint url
endpointUrl = chatterBaseUrl + SalesforceServiceSingleton.CHATTER_URI_PART_API_VERSION + SalesforceServiceSingleton.CHATTER_URI_PART_USERS + "/" + id;
// Call the get method on the chatter API to grab the user information
httpResponseMessage = httpClient.GetAsync(endpointUrl).Result;
// Check the status of the response and respond appropriately
if (httpResponseMessage.IsSuccessStatusCode)
{
// Grab the chatter user info from the result
chatterUserInfo = httpResponseMessage.Content.ReadAsAsync <ChatterUserInfo>().Result;
// Convert the chatter user info over to a who
who = this.ChatterUserInfoToWhoAPI(chatterUserInfo);
// Get the stuff this user is following
stuffAuthenticatedUserIsFollowing = this.GetStuffAuthenticatedUserIsFollowing(httpClient, chatterBaseUrl);
// Check to see if the authenticated user is also the id
if (id.Equals(SalesforceServiceSingleton.CHATTER_ME, StringComparison.InvariantCultureIgnoreCase) == false)
{
// Check to see if the currently authenticated user is following the provided user id
if (stuffAuthenticatedUserIsFollowing != null &&
stuffAuthenticatedUserIsFollowing.Any(x => x.id == id) == true)
{
// The authenticated user is following the provided user id
who.isFollower = true;
}
}
else
{
// If the authenticated user is the same as the provided id, the "is following" refers to the stream
if (stuffAuthenticatedUserIsFollowing != null &&
stuffAuthenticatedUserIsFollowing.Any(x => x.id == streamId) == true)
{
// We are following this stream
who.isFollower = true;
}
}
// We successfully executed the request, we can break out of the retry loop
break;
}
else
{
// Make sure we handle the lack of success properly
BaseHttpUtils.HandleUnsuccessfulHttpResponseMessage(notifier, authenticatedWho, i, httpResponseMessage, endpointUrl);
}
}
catch (Exception exception)
{
// Make sure we handle the exception properly
BaseHttpUtils.HandleHttpException(notifier, authenticatedWho, i, exception, endpointUrl);
}
finally
{
// Clean up the objects from the request
BaseHttpUtils.CleanUpHttp(httpClient, null, httpResponseMessage);
}
}
return(who);
}
public Validation AuthenticatedWho(IAuthenticatedWho authenticatedWho)
{
return(IsNotNull(authenticatedWho, "authenticatedWho"));
}
/// <summary>
/// This method allows the user to share the flow app in salesforce with their friends.
/// </summary>
public MessageAPI PostNotification(INotifier notifier, IAuthenticatedWho authenticatedWho, String oauthToken, ServiceRequestAPI serviceRequest, String endpointUrl, String flowLink, ChatterPostedMessage chatterPostedMessage)
{
HttpResponseMessage httpResponseMessage = null;
HttpClient httpClient = null;
MediaTypeFormatter jsonFormatter = null;
MultipartFormDataContent multipartFormDataContent = null;
ChatterMessage chatterMessage = null;
ChatterAttachmentLink chatterAttachmentLink = null;
MessageAPI message = null;
String chatterBaseUrl = null;
String adminEmail = null;
if (oauthToken == null ||
oauthToken.Trim().Length == 0)
{
throw new ArgumentNullException("BadRequest", "OAuthToken cannot be null or blank.");
}
if (endpointUrl == null ||
endpointUrl.Trim().Length == 0)
{
throw new ArgumentNullException("BadRequest", "EndpointUrl cannot be null or blank.");
}
// Grab the values necessary to post the message over to chatter
chatterBaseUrl = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_CHATTER_BASE_URL, serviceRequest.configurationValues, true);
adminEmail = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_ADMIN_EMAIL, serviceRequest.configurationValues, true);
// Now we can create the multipart form we're going to post over to salesforce
multipartFormDataContent = new MultipartFormDataContent();
if (flowLink != null &&
flowLink.Trim().Length > 0)
{
// We also add the link to the app so the user has it
chatterAttachmentLink = new ChatterAttachmentLink();
chatterAttachmentLink.AttachmentType = "Link";
chatterAttachmentLink.Url = flowLink;
chatterAttachmentLink.UrlName = "Link to ManyWho Flow";
chatterPostedMessage.Attachment = chatterAttachmentLink;
}
// We enclose the request in a for loop to handle http errors
for (int i = 0; i < SalesforceHttpUtils.MAXIMUM_RETRIES; i++)
{
try
{
// Create a new client object
httpClient = SalesforceHttpUtils.CreateHttpClient(oauthToken);
// Create a new json formatter so the request will be in the right format
jsonFormatter = new JsonMediaTypeFormatter();
// Use the JSON formatter to create the content of the chatter post
multipartFormDataContent.Add(new ObjectContent <ChatterPostedMessage>(chatterPostedMessage, jsonFormatter), "json");
// Post the message over to chatter
httpResponseMessage = httpClient.PostAsync(endpointUrl, multipartFormDataContent).Result;
// Check the status of the response and respond appropriately
if (httpResponseMessage.IsSuccessStatusCode)
{
// Grab the chatter message from the post
chatterMessage = httpResponseMessage.Content.ReadAsAsync <ChatterMessage>().Result;
// Convert it over to a manywho message
message = SalesforceSocialSingleton.GetInstance().ChatterMessageToMessageAPI(chatterBaseUrl, null, chatterMessage);
// We successfully executed the request, we can break out of the retry loop
break;
}
else
{
// Make sure we handle the lack of success properly
BaseHttpUtils.HandleUnsuccessfulHttpResponseMessage(notifier, authenticatedWho, i, httpResponseMessage, endpointUrl);
}
}
catch (Exception exception)
{
// Make sure we handle the exception properly
BaseHttpUtils.HandleHttpException(notifier, authenticatedWho, i, exception, endpointUrl);
}
finally
{
// Clean up the objects from the request
BaseHttpUtils.CleanUpHttp(httpClient, null, httpResponseMessage);
}
}
return(message);
}
public async Task<ServiceResponseAPI> InvokeCreateMatter(IAuthenticatedWho authenticatedWho, ServiceRequestAPI serviceRequest)
{
ServiceResponseAPI serviceResponse = null;
DateTime whenDate = DateTime.Now;
List<ObjectAPI> taskObjects = null;
ObjectAPI taskObject = null;
string authenticationUrl = null;
string username = null;
string password = null;
string recordNumber = null;
string description = null;
string matterId = null;
// Grab the configuration values from the service request
authenticationUrl = SettingUtils.GetConfigurationValue(DocordoServiceSingleton.SERVICE_VALUE_DOCORDO_DOMAIN, serviceRequest.configurationValues, true);
username = SettingUtils.GetConfigurationValue(DocordoServiceSingleton.SERVICE_VALUE_DOCORDO_USERNAME, serviceRequest.configurationValues, true);
password = SettingUtils.GetConfigurationValue(DocordoServiceSingleton.SERVICE_VALUE_DOCORDO_PASSWORD, serviceRequest.configurationValues, true);
if (serviceRequest.authorization != null)
{
// Get the message from the inputs
recordNumber = ValueUtils.GetContentValue(DocordoServiceSingleton.SERVICE_INPUT_RECORD_NUMBER, serviceRequest.inputs, true);
description = ValueUtils.GetContentValue(DocordoServiceSingleton.SERVICE_INPUT_MATTER_DESCRIPTION, serviceRequest.inputs, true);
// Create a task object to save back to the system
taskObject = new ObjectAPI();
taskObject.developerName = "Matter";
taskObject.properties = new List<PropertyAPI>();
taskObject.properties.Add(new PropertyAPI() { developerName = "RecordNumber", contentValue = description });
taskObject.properties.Add(new PropertyAPI() { developerName = "Description", contentValue = description });
// Add the object to the list of objects to save
taskObjects = new List<ObjectAPI>();
taskObjects.Add(taskObject);
// Save the task object to docordo
DocordoLoginResponse docordoLoginResponse = DocordoAPI.DocordoService.GetInstance().Login(authenticationUrl, username, password);
taskObjects = DocordoDataSingleton.GetInstance().CreateMatter(authenticationUrl, docordoLoginResponse.EbikkoSessionId, docordoLoginResponse.CookieJSESSIONID, recordNumber, description);
// Check to see if anything came back as part of the save - it should unless there was a fault
if (taskObjects != null &&
taskObjects.Count > 0)
{
// Grab the first object from the returned task objects
taskObject = taskObjects[0];
// Grab the id from that object - this needs to be returned in our outputs
matterId = taskObject.externalId;
}
else
{
// If we didn't get any objects back, we need to throw an error
String errorMessage = "Task could not be created for an unknown reason.";
ErrorUtils.SendAlert(authenticatedWho, ErrorUtils.ALERT_TYPE_FAULT, "*****@*****.**", "DocordoPlugin", errorMessage);
throw ErrorUtils.GetWebException(HttpStatusCode.InternalServerError, errorMessage);
}
}
else
{
// Alert the admin that no one is in the authorization context
ErrorUtils.SendAlert(authenticatedWho, ErrorUtils.ALERT_TYPE_WARNING, "*****@*****.**", "DocordoPlugin", "The service request does not have an authorization context, so there's no one to notify.");
}
// Construct the service response
serviceResponse = new ServiceResponseAPI();
serviceResponse.invokeType = ManyWhoConstants.INVOKE_TYPE_FORWARD;
serviceResponse.token = serviceRequest.token;
serviceResponse.outputs = new List<EngineValueAPI>();
serviceResponse.outputs.Add(new EngineValueAPI() { contentType = ManyWhoConstants.CONTENT_TYPE_STRING, contentValue = matterId, developerName = DocordoServiceSingleton.SERVICE_OUTPUT_ID });
return serviceResponse;
}
public ServiceResponseAPI InvokeCreateEvent(INotifier notifier, IAuthenticatedWho authenticatedWho, ServiceRequestAPI serviceRequest)
{
List <ObjectDataTypePropertyAPI> objectDataTypeProperties = null;
ServiceResponseAPI serviceResponse = null;
DateTime whenDate = DateTime.Now;
List <ObjectAPI> eventObjects = null;
ObjectAPI eventObject = null;
String authenticationUrl = null;
String username = null;
String password = null;
String securityToken = null;
String adminEmail = null;
String when = null;
String duration = null;
String description = null;
String subject = null;
String eventId = null;
// Grab the configuration values from the service request
authenticationUrl = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_AUTHENTICATION_URL, serviceRequest.configurationValues, true);
username = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_USERNAME, serviceRequest.configurationValues, true);
password = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_PASSWORD, serviceRequest.configurationValues, true);
securityToken = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_SECURITY_TOKEN, serviceRequest.configurationValues, false);
adminEmail = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_ADMIN_EMAIL, serviceRequest.configurationValues, true);
if (serviceRequest.authorization != null)
{
// Get the message from the inputs
when = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_INPUT_WHEN, serviceRequest.inputs, true);
duration = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_INPUT_DURATION, serviceRequest.inputs, true);
description = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_INPUT_DESCRIPTION, serviceRequest.inputs, true);
subject = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_INPUT_SUBJECT, serviceRequest.inputs, true);
// Get the when date for the provided command
whenDate = DateUtils.CreateDateFromWhenCommand(notifier, authenticatedWho, when, adminEmail);
// Set the calendar event for a day in the week at 10am
whenDate = DateUtils.GetDayInWeek(whenDate, 10);
// Add the link to the flow in the description
description += " Link to Flow: " + serviceRequest.joinPlayerUri;
// Create a event object to save back to the system
eventObject = new ObjectAPI();
eventObject.developerName = "Event";
eventObject.properties = new List <PropertyAPI>();
eventObject.properties.Add(new PropertyAPI()
{
developerName = "ActivityDateTime", contentValue = whenDate.ToUniversalTime().ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffZ")
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "Description", contentValue = description
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "DurationInMinutes", contentValue = duration
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "Subject", contentValue = subject
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsAllDayEvent", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsArchived", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsChild", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsGroupEvent", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsPrivate", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsRecurrence", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsReminderSet", contentValue = "false"
});
eventObject.properties.Add(new PropertyAPI()
{
developerName = "IsVisibleInSelfService", contentValue = "false"
});
// Add the object to the list of objects to save
eventObjects = new List <ObjectAPI>();
eventObjects.Add(eventObject);
// Create the object data type properties for this object so the system knows what we're selecting
objectDataTypeProperties = new List <ObjectDataTypePropertyAPI>();
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "ActivityDateTime"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "Description"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "DurationInMinutes"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "Subject"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsAllDayEvent"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsArchived"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsChild"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsGroupEvent"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsPrivate"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsRecurrence"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsReminderSet"
});
objectDataTypeProperties.Add(new ObjectDataTypePropertyAPI()
{
developerName = "IsVisibleInSelfService"
});
// Save the event object to salesforce
eventObjects = SalesforceDataSingleton.GetInstance().Save(notifier, authenticatedWho, serviceRequest.configurationValues, objectDataTypeProperties, eventObjects);
// Check to see if anything came back as part of the save - it should unless there was a fault
if (eventObjects != null &&
eventObjects.Count > 0)
{
// Grab the first object from the returned event objects
eventObject = eventObjects[0];
// Grab the id from that object - this needs to be returned in our outputs
eventId = eventObject.externalId;
}
else
{
// If we didn't get any objects back, we need to throw an error
String errorMessage = "Event could not be created for an unknown reason.";
ErrorUtils.SendAlert(notifier, authenticatedWho, ErrorUtils.ALERT_TYPE_FAULT, errorMessage);
throw new ArgumentNullException("BadRequest", errorMessage);
}
}
else
{
// Alert the admin that no one is in the authorization context
ErrorUtils.SendAlert(notifier, authenticatedWho, ErrorUtils.ALERT_TYPE_WARNING, "The service request does not have an authorization context, so there's no one to notify.");
}
// Construct the service response
serviceResponse = new ServiceResponseAPI();
serviceResponse.invokeType = ManyWhoConstants.INVOKE_TYPE_FORWARD;
serviceResponse.token = serviceRequest.token;
serviceResponse.outputs = new List <EngineValueAPI>();
serviceResponse.outputs.Add(new EngineValueAPI()
{
contentType = ManyWhoConstants.CONTENT_TYPE_STRING, contentValue = eventId, developerName = SalesforceServiceSingleton.SERVICE_OUTPUT_ID
});
return(serviceResponse);
}
public static HttpClient CreateHttpClient(IAuthenticatedWho authenticatedWho, string tenantId, string stateId, int timeOut)
{
return(CreateHttpClient(Uri.EscapeDataString(AuthenticationUtils.Serialize(authenticatedWho)), tenantId, stateId, timeOut));
}
public HttpResponseMessage TaskEmailOutcomeResponse(String token, String selectedOutcomeId, String redirectUri = null)
{
IAuthenticatedWho authenticatedWho = null;
INotifier notifier = null;
HttpResponseMessage response = null;
ServiceResponseAPI serviceResponse = null;
ServiceRequestAPI serviceRequest = null;
String invokeType = null;
String responseContent = null;
try
{
if (String.IsNullOrWhiteSpace(token) == true)
{
throw new ArgumentNullException("Token", "The token for the request is null or blank.");
}
if (String.IsNullOrWhiteSpace(selectedOutcomeId) == true)
{
throw new ArgumentNullException("SelectedOutcomeId", "The selected outcome for the request is null or blank.");
}
// Get the email verification for this tracking code
serviceRequest = JsonConvert.DeserializeObject <ServiceRequestAPI>(StorageUtils.GetStoredJson(token.ToLower()));
if (serviceRequest == null)
{
throw new ArgumentNullException("ServiceRequest", "The request has already been processed.");
}
// Get the notifier email
authenticatedWho = new AuthenticatedWho();
authenticatedWho.Email = ValueUtils.GetContentValue(SalesforceServiceSingleton.SERVICE_VALUE_ADMIN_EMAIL, serviceRequest.configurationValues, true);
// Create the notifier
notifier = EmailNotifier.GetInstance(serviceRequest.tenantId, authenticatedWho, null, "TaskEmailOutcomeResponse");
// Create the service response to send back to ManyWho based on this outcome click
serviceResponse = new ServiceResponseAPI();
serviceResponse.invokeType = ManyWhoConstants.INVOKE_TYPE_FORWARD;
serviceResponse.tenantId = serviceRequest.tenantId;
serviceResponse.token = serviceRequest.token;
serviceResponse.selectedOutcomeId = selectedOutcomeId;
// Invoke the response on the manywho service
invokeType = RunSingleton.GetInstance().Response(notifier, null, serviceRequest.tenantId, serviceRequest.callbackUri, serviceResponse);
if (invokeType == null ||
invokeType.Trim().Length == 0)
{
throw new ArgumentNullException("ServiceRequest", "The invokeType coming back from ManyWho cannot be null or blank.");
}
if (invokeType.IndexOf(ManyWhoConstants.INVOKE_TYPE_SUCCESS, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
// The system has accepted our task email response so the token is now dead - we remove it from storage
StorageUtils.RemoveStoredJson(token.ToLower());
}
else
{
// The system has not accepted our task email response, so we should simply keep waiting and responding to emails with this task token
}
// Tell the user the outcome selection was successful
responseContent = "Your request has been successfully completed. Please close this window.";
if (String.IsNullOrWhiteSpace(redirectUri) == false)
{
// Redirect the user as specified
response = Request.CreateResponse(HttpStatusCode.RedirectMethod, redirectUri);
response.Headers.Add("Location", redirectUri);
}
else
{
// Send the user a response page
response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(responseContent);
}
}
catch (Exception exception)
{
throw BaseHttpUtils.GetWebException(HttpStatusCode.BadRequest, BaseHttpUtils.GetExceptionMessage(exception));
}
return(response);
}
protected override System.Threading.Tasks.Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
{
WorkflowRuleNotification receivedNotification = null;
IAuthenticatedWho authenticatedWho = null;
INotifier emailNotifier = null;
Guid tenantGuid = Guid.Empty;
String tenantId = null;
String mode = null;
String email = null;
try
{
// Get the mode from the request uri
mode = BaseHttpUtils.GetModeFromQuery(request.RequestUri);
// Get any provided notification email
email = BaseHttpUtils.GetEmailFromQuery(request.RequestUri);
// Check to make sure the incoming request has enough segments
// Deployed we have an extra segment for the deployment sub-directory, hence this is one more than you would have thought
if (request.RequestUri.Segments.Length < 9)
{
throw new ArgumentNullException("Request.Segments", "The incoming request is not a valid Url for outbound messages.");
}
// Get the segments from the call so we know which tenant we're executing against
tenantId = request.RequestUri.Segments[8].Replace("/", "");
// Check to make sure we've received valid guids
if (Guid.TryParse(tenantId, out tenantGuid) == false)
{
throw new ArgumentNullException("Request.Segments", "The incoming request does not contain a valid tenant identifier. You provided: " + tenantId);
}
// Create a basic authenticated who for the notifier
authenticatedWho = AuthenticationUtils.CreatePublicUser(tenantId);
authenticatedWho.Email = email;
// Create the notifier
emailNotifier = EmailNotifier.GetInstance(tenantId, authenticatedWho, null, "WorkflowRuleListenerMessageHandler");
// ExtractData would populate notification class' variables, which can be used to get desired data.
receivedNotification = new WorkflowRuleNotification();
receivedNotification.ExtractData(emailNotifier, request.Content.ReadAsStringAsync().Result, mode);
// Now send ManyWho the notification that something has changed on a set of records, but only if ManyWho actually cares about them
this.Execute(emailNotifier, tenantId, mode, receivedNotification);
// Send the debug log if the user is running in debug mode
if (SettingUtils.IsDebugging(mode))
{
ErrorUtils.SendAlert(emailNotifier, null, ErrorUtils.ALERT_TYPE_WARNING, "Debug Log Entries");
}
// Send a response back to SFDC
// Note: since we are not calling base class' SendAsync function, the request will return from here, and will not reach our POST function.
return(Task.FromResult(receivedNotification.PrepareResponse(request)));
}
catch (Exception exception)
{
// Send the debug log if the user is running in debug mode
if (SettingUtils.IsDebugging(mode))
{
ErrorUtils.SendAlert(emailNotifier, null, ErrorUtils.ALERT_TYPE_WARNING, BaseHttpUtils.GetExceptionMessage(exception));
}
throw BaseHttpUtils.GetWebException(HttpStatusCode.BadRequest, BaseHttpUtils.GetExceptionMessage(exception));
}
}
public void RegisterListener(IAuthenticatedWho authenticatedWho, ListenerServiceRequestAPI listenerServiceRequest)
{
Dictionary <String, ListenerServiceRequestAPI> salesforceListenerEntries = null;
String objectId = null;
Guid externalGuid = Guid.Empty;
if (authenticatedWho == null)
{
throw new ArgumentNullException("AuthenticatedWho", "The AuthenticatedWho object cannot be null.");
}
if (listenerServiceRequest == null)
{
throw new ArgumentNullException("ListenerServiceRequest", "The ListenerServiceRequest object cannot be null.");
}
if (String.IsNullOrWhiteSpace(listenerServiceRequest.listenType) == true)
{
throw new ArgumentNullException("ListenerServiceRequest.ListenType", "The ListenerServiceRequest.ListenType property cannot be null or blank.");
}
if (String.IsNullOrWhiteSpace(listenerServiceRequest.token) == true)
{
throw new ArgumentNullException("ListenerServiceRequest.Token", "The ListenerServiceRequest.Token property cannot be null or blank.");
}
if (listenerServiceRequest.valueForListening == null)
{
throw new ArgumentNullException("ListenerServiceRequest.ValueForListening", "The ListenerServiceRequest.ValueForListening property cannot be null.");
}
if (listenerServiceRequest.valueForListening.objectData == null ||
listenerServiceRequest.valueForListening.objectData.Count == 0)
{
throw new ArgumentNullException("ListenerServiceRequest.ValueForListening.ObjectData", "The Salesforce Service cannot listen without any object records to listen to.");
}
if (listenerServiceRequest.valueForListening.objectData.Count > 1)
{
throw new ArgumentNullException("ListenerServiceRequest.ValueForListening.ObjectData", "The Salesforce Service cannot listen to more than one object record in a single request.");
}
if (String.IsNullOrWhiteSpace(listenerServiceRequest.valueForListening.objectData[0].externalId) == true ||
Guid.TryParse(listenerServiceRequest.valueForListening.objectData[0].externalId, out externalGuid) == true)
{
throw new ArgumentNullException("ListenerServiceRequest.ValueForListening.ObjectData", "The Salesforce Service cannot listen to an object that has not been first saved or loaded from Salesforce.");
}
// Assign the object id from the external id
objectId = listenerServiceRequest.valueForListening.objectData[0].externalId;
// Try to get the listener requests out for this object
salesforceListenerEntries = this.GetListenerRequests(listenerServiceRequest.tenantId, objectId);
// Check to make sure we have something, or create a new list
if (salesforceListenerEntries == null)
{
// This is the first time we're registering a listener for this object, so we create a new map
salesforceListenerEntries = new Dictionary <String, ListenerServiceRequestAPI>();
}
// Now we have our list of listeners, we add this one based on the token
salesforceListenerEntries[listenerServiceRequest.token.ToLower()] = listenerServiceRequest;
// And we put the updated map, back into the data store
StorageUtils.SetStoredJson((listenerServiceRequest.tenantId + objectId).ToLower(), JsonConvert.SerializeObject(salesforceListenerEntries));
}
protected override System.Threading.Tasks.Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
{
WorkflowRuleNotification receivedNotification = null;
IAuthenticatedWho authenticatedWho = null;
INotifier emailNotifier = null;
Guid tenantGuid = Guid.Empty;
Guid flowGuid = Guid.Empty;
String tenantId = null;
String flowId = null;
String player = null;
String mode = null;
String email = null;
String reportingMode = null;
try
{
// Get the mode from the request uri
mode = BaseHttpUtils.GetModeFromQuery(request.RequestUri);
// Get the reporting mode from the request uri
reportingMode = BaseHttpUtils.GetReportingModeFromQuery(request.RequestUri);
// Get any provided notification email
email = BaseHttpUtils.GetEmailFromQuery(request.RequestUri);
// Check to make sure the incoming request has enough segments
if (request.RequestUri.Segments.Length < 9)
{
throw new ArgumentNullException("Request.Segments", "The incoming request is not a valid Url for outbound messages.");
}
// Get the segments from the call so we know which tenant we're executing against
tenantId = request.RequestUri.Segments[7].Replace("/", "");
flowId = request.RequestUri.Segments[8].Replace("/", "");
player = request.RequestUri.Segments[9];
// Check to make sure we've received valid guids
if (Guid.TryParse(tenantId, out tenantGuid) == false)
{
throw new ArgumentNullException("Request.Segments", "The incoming request does not contain a valid tenant identifier.");
}
if (Guid.TryParse(flowId, out flowGuid) == false)
{
throw new ArgumentNullException("Request.Segments", "The incoming request does not contain a valid flow identifier.");
}
// If a player has not been provided, we make it the default player
if (String.IsNullOrWhiteSpace(player) == true)
{
player = "default";
}
// Create a basic authenticated who for the notifier
authenticatedWho = AuthenticationUtils.CreatePublicUser(tenantId);
authenticatedWho.Email = email;
// Create the notifier
emailNotifier = EmailNotifier.GetInstance(tenantId, authenticatedWho, null, "WorkflowRuleMessageHandler");
//ExtractData would populate notification class' variables, which can be used to get desired data.
receivedNotification = new WorkflowRuleNotification();
receivedNotification.ExtractData(emailNotifier, request.Content.ReadAsStringAsync().Result, mode);
if (SettingUtils.IsDebugging(mode))
{
emailNotifier.AddLogEntry("Mode: " + mode);
}
if (SettingUtils.IsDebugging(mode))
{
emailNotifier.AddLogEntry("Email: " + email);
}
if (SettingUtils.IsDebugging(mode))
{
emailNotifier.AddLogEntry("Reporting Mode: " + reportingMode);
}
// Execute the notifications against ManyWho
this.Execute(emailNotifier, tenantId, flowId, player, mode, reportingMode, receivedNotification);
// Send the debug log if the user is running in debug mode
if (SettingUtils.IsDebugging(mode))
{
ErrorUtils.SendAlert(emailNotifier, null, ErrorUtils.ALERT_TYPE_WARNING, "Debug Log Entries");
}
//Send a response back to SFDC
//Note: since we are not calling base class' SendAsync function, the request will return from here, and will not reach our POST function.
return(Task.FromResult(receivedNotification.PrepareResponse(request)));
}
catch (Exception exception)
{
// Send the debug log if the user is running in debug mode
if (SettingUtils.IsDebugging(mode))
{
ErrorUtils.SendAlert(emailNotifier, null, ErrorUtils.ALERT_TYPE_WARNING, BaseHttpUtils.GetExceptionMessage(exception));
}
throw BaseHttpUtils.GetWebException(HttpStatusCode.BadRequest, BaseHttpUtils.GetExceptionMessage(exception));
}
}
