public async void CreateConnect(IHubCommunicator hubCommunicator, AuthorizationToken authToken)
{
string[] events = new string[4];
events[0] = "jira:issue_created";
events[1] = "jira:issue_updated";
events[2] = "jira:issue_deleted";
events[3] = "jira:worklog_updated";
var post = new JiraSubscriptionPost();
post.Events = events;
post.ExcludeIssueDetails = false;
post.JqlFilter = "";
post.Url = terminalEndpoint + "/terminals/terminalatlassian/process-issue";
post.Name = "Fr8 Jira Integration for (" + terminalEndpoint + ")";
var url = "/rest/webhooks/1.0/webhook";
Jira jira = CreateRestClient(authToken.Token);
var getSubscriptions = await jira.RestClient.ExecuteRequestAsync(Method.GET, url, post);
var oldSubscriptions = getSubscriptions.ToList <JToken>();
var subscriptionDoesExists = false;
for (var i = 0; i < oldSubscriptions.Count; i++)
{
if (oldSubscriptions[i].Value <string>("name") == post.Name)
{
subscriptionDoesExists = true;
}
}
if (!subscriptionDoesExists)
{
var subscription = await jira.RestClient.ExecuteRequestAsync(Method.POST, url, post);
}
}
/// <summary>
/// Creates Monitor All DocuSign Events plan with Record DocuSign Events and Store MT Data actions.
///
/// https://maginot.atlassian.net/wiki/display/DDW/Rework+of+DocuSign+connect+management
/// </summary>
public async Task CreatePlan_MonitorAllDocuSignEvents(IHubCommunicator hubCommunicator, AuthorizationToken authToken)
{
Logger.Info($"Create MADSE called {authToken.UserId}");
await RemoveInactiveExistingPlans(hubCommunicator, "MonitorAllDocuSignEvents", authToken);
await CreateAndActivateNewMADSEPlan(hubCommunicator, authToken);
}
public static async Task <ActivityPayload> AddAndConfigureChildActivity(this IHubCommunicator that, ActivityPayload parentActivity, ActivityTemplateDTO activityTemplate, string name = null, string label = null, int?order = null)
{
var child = await AddAndConfigureChildActivity(that, parentActivity.Id, activityTemplate, name, label, order);
parentActivity.ChildrenActivities.Add(child);
return(child);
}
public static async Task <ActivityPayload> AddAndConfigureChildActivity(this IHubCommunicator that, Guid parentActivityId, ActivityTemplateDTO activityTemplate, string name = null, string label = null, int?order = null)
{
//assign missing properties
label = string.IsNullOrEmpty(label) ? activityTemplate.Label : label;
name = string.IsNullOrEmpty(name) ? activityTemplate.Label : label;
return(await that.CreateAndConfigureActivity(activityTemplate.Id, name, order, parentActivityId));
}
public ActivityExecutor(IHubCommunicator hubCommunicator, ICrateManager crateManager, IActivityStore activityStore, IContainer container)
{
_hubCommunicator = hubCommunicator;
CrateManager = crateManager;
_activityStore = activityStore;
_container = container;
}
public PackageDownloadingService(IAgentSettingsManager agentSettingsManager,
IRetrievePackageQuery allPackagesQuery,
ILocalPackageCache agentCache,
IAgentConfigurationManager agentConfigurationManager,
ILogger logger,
IHubCommunicator hubCommunicator,
IInstalledPackageArchive installCache,
IPackageRepositoryFactory packageRepositoryFactory,
IPackagesList allPackagesList,
ICurrentlyDownloadingList currentlyDownloadingList,
CompletedInstallationTaskList installationResults,
IAgentWatchList watchList,
IInstallationManager installationManager,INotificationService notificationService)
{
_settingsManager = agentSettingsManager;
AllPackagesQuery = allPackagesQuery;
AgentCache = agentCache;
_agentConfigurationManager = agentConfigurationManager;
_logger = logger;
_hubCommunicator = hubCommunicator;
_installCache = installCache;
_packageRepository = packageRepositoryFactory.CreateRepository(agentSettingsManager.Settings.NuGetRepository);
_allPackagesList = allPackagesList;
_currentlyDownloadingList = currentlyDownloadingList;
_installationResults = installationResults;
_watchList = watchList;
_installationManager = installationManager;
_notificationService = notificationService;
TimedTask = new TimedSingleExecutionTask(agentSettingsManager.Settings.PackageSyncIntervalMs, FetchPackages,
_logger);
}
public PackageInstallationService(InstallationTaskQueue pendingInstalls,
RunningInstallationTaskList runningInstalls,
CompletedInstallationTaskList completedInstalls,
IDeploymentService deploymentService,
ILogger logger,
IHubCommunicator hubCommunicator,
ILocalPackageCache agentCache,
IInstalledPackageArchive installCache,
RunningInstallationTaskList runningTasks,
IAgentSettingsManager settingsManager,
IPackagesList allPackagesList,
CurrentlyDownloadingList currentlyDownloadingList,
INotificationService notificationService)
{
CompletedInstalls = completedInstalls;
_deploymentService = deploymentService;
_logger = logger;
_hubCommunicator = hubCommunicator;
_agentCache = agentCache;
_installCache = installCache;
_runningTasks = runningTasks;
_settingsManager = settingsManager;
_allPackagesList = allPackagesList;
_currentlyDownloadingList = currentlyDownloadingList;
_notificationService = notificationService;
PendingInstalls = pendingInstalls;
RunningInstalls = runningInstalls;
TimedTask = new TimedSingleExecutionTask(5000, CheckForNewInstallations, _logger);
}
protected OAuthApiIntegrationBase(IHubCommunicator hubCommunicator)
{
if (hubCommunicator == null)
{
throw new ArgumentNullException(nameof(hubCommunicator));
}
_hubCommunicator = hubCommunicator;
}
public static async Task <ActivityPayload> ConfigureChildActivity(this IHubCommunicator that, ActivityPayload parent, ActivityPayload child)
{
var result = await that.ConfigureActivity(child);
parent.ChildrenActivities.Remove(child);
parent.ChildrenActivities.Add(result);
return(result);
}
public async Task SchedulePolling(IHubCommunicator hubCommunicator, string externalAccountId, bool triggerImmediately, string groupId, string statId)
{
string pollingInterval = CloudConfigurationManager.GetSetting("terminalStatX.PollingInterval");
var additionalAttributes = JsonConvert.SerializeObject(
new
{
GroupId = groupId,
StatId = statId
});
await hubCommunicator.ScheduleEvent(externalAccountId, pollingInterval, triggerImmediately, additionalAttributes, statId.Substring(0, 18));
}
public static async Task <ActivityTemplateDTO> GetActivityTemplate(this IHubCommunicator that, Guid activityTemplateId)
{
var allActivityTemplates = await that.GetActivityTemplates();
var foundActivity = allActivityTemplates.FirstOrDefault(a => a.Id == activityTemplateId);
if (foundActivity == null)
{
throw new Exception($"ActivityTemplate was not found. Id: {activityTemplateId}");
}
return(foundActivity);
}
public ServiceContext CreateServiceContext(AuthorizationToken authToken, IHubCommunicator hubCommunicator)
{
var tokens = authToken.Token.Split(new[] { Authenticator.TokenSeparator }, StringSplitOptions.None);
var accessToken = tokens[0];
var accessTokenSecret = tokens[1];
var companyId = tokens[2];
var expiresAt = tokens[3];
DateTime expiresDate;
if (DateTime.TryParse(expiresAt, out expiresDate) == false)
{
//EventManager.TokenValidationFailed(authToken.Token, "Terminal Quickbooks token is invalid");
throw new ArgumentException("Terminal Quickbooks token is invalid", nameof(expiresAt));
}
// Token renew should fit into 151-180 days period,
// See https://developer.intuit.com/docs/0100_accounting/0060_authentication_and_authorization/connect_from_within_your_app#/manage
//
if (DateTime.Now > expiresDate.AddDays(-30) && DateTime.Now <= expiresDate)
{
authToken = _authenticator.RefreshAuthToken(authToken).Result;
var tokenDto = new AuthorizationTokenDTO
{
Id = authToken.Id.ToString(),
ExternalAccountId = authToken.ExternalAccountId,
Token = authToken.Token
};
hubCommunicator.RenewToken(tokenDto);
// After token refresh we need to get new accessToken and accessTokenSecret from it
tokens = authToken.Token.Split(new[] { Authenticator.TokenSeparator }, StringSplitOptions.None);
accessToken = tokens[0];
accessTokenSecret = tokens[1];
}
if (DateTime.Now > expiresDate)
{
var message = "Quickbooks token is expired. Please, get the new one";
//EventManager.TokenValidationFailed(authToken.Token, message);
throw new TerminalQuickbooksTokenExpiredException(message);
}
var oauthValidator = new OAuthRequestValidator(
accessToken,
accessTokenSecret,
Authenticator.ConsumerKey,
Authenticator.ConsumerSecret);
return(new ServiceContext(AppToken, companyId, IntuitServicesType.QBO, oauthValidator));
}
public async Task SchedulePolling(
IHubCommunicator hubCommunicator,
string externalAccountId,
GDrivePollingType pollingType,
bool triggerImmediatly)
{
var pollingInterval = "1";
await hubCommunicator.ScheduleEvent(
externalAccountId,
pollingInterval,
triggerImmediatly,
additionToJobId : pollingType.ToString()
);
}
public BasecampApiClient(IRestfulServiceClient restfulServiceClient, IHubCommunicator hubCommunicator) : base(hubCommunicator)
{
if (restfulServiceClient == null)
{
throw new ArgumentNullException(nameof(restfulServiceClient));
}
_restfulServiceClient = restfulServiceClient;
_initialUrl = CloudConfigurationManager.GetSetting("AppInitialUrl");
_redirectUrl = CloudConfigurationManager.GetSetting("AppRedirectUrl");
_authorizationUrl = CloudConfigurationManager.GetSetting("AppAuthorizationUrl");
_tokenUrl = CloudConfigurationManager.GetSetting("AppTokenUrl");
_clientId = CloudConfigurationManager.GetSetting("AppClientId");
_clientSecret = CloudConfigurationManager.GetSetting("AppClientSecret");
_contactEmail = CloudConfigurationManager.GetSetting("ContactEmail");
}
public static async Task <ActivityTemplateDTO> GetActivityTemplate(this IHubCommunicator that, string terminalName, string activityTemplateName, string activityTemplateVersion = "1", string terminalVersion = "1")
{
var allActivityTemplates = await that.GetActivityTemplates();
var foundActivity = allActivityTemplates.FirstOrDefault(a =>
a.Terminal.Name == terminalName && a.Terminal.Version == terminalVersion &&
a.Name == activityTemplateName && a.Version == activityTemplateVersion);
if (foundActivity == null)
{
throw new Exception($"ActivityTemplate was not found. TerminalName: {terminalName}\nTerminalVersion: {terminalVersion}\nActivitiyTemplateName: {activityTemplateName}\nActivityTemplateVersion: {activityTemplateVersion}");
}
return(foundActivity);
}
public DataService GetDataService(AuthorizationToken authToken, IHubCommunicator hubCommunicator)
{
var curServiceContext = CreateServiceContext(authToken, hubCommunicator);
//Modify required settings for the Service Context
curServiceContext.IppConfiguration.BaseUrl.Qbo = "https://sandbox-quickbooks.api.intuit.com/";
curServiceContext.IppConfiguration.MinorVersion.Qbo = "4";
curServiceContext.IppConfiguration.Logger.RequestLog.EnableRequestResponseLogging = true;
curServiceContext.IppConfiguration.Logger.CustomLogger = new TraceLogger();
curServiceContext.IppConfiguration.Message.Response.SerializationFormat = SerializationFormat.Json;
var curDataService = new DataService(curServiceContext);
curServiceContext.UseDataServices();
return(curDataService);
}
/// <summary>
/// Creates Journal Entry in the developers account in Sandbox in Intuit https://sandbox.qbo.intuit.com/app/journal
/// </summary>
public void Create(
StandardAccountingTransactionDTO curAccountingTransactionDto,
AuthorizationToken authToken,
IHubCommunicator hubCommunicator)
{
var curJournalEntry = CreateQbJournalEntry(curAccountingTransactionDto);
var curDataService = _serviceWorker.GetDataService(authToken, hubCommunicator);
try
{
curDataService.Add(curJournalEntry);
}
catch (Exception curException)
{
throw curException;
}
}
/// <summary>
/// Returns a list of QuickBooksAccounts, simplified version of Intuit Account class
/// </summary>
/// <param name="authTokenDO"></param>
/// <param name="userId"/>
/// <returns></returns>
public ChartOfAccountsCM GetChartOfAccounts(AuthorizationToken authToken, IHubCommunicator hubCommunicator, IServiceWorker serviceWorker)
{
var listOfAccounts = GetAccountList(authToken, hubCommunicator, serviceWorker);
if (listOfAccounts.Count == 0)
{
throw new Exception("No Accounts found in the QuickBooks account");
}
var listOfQBAccounts = new List <AccountDTO>();
foreach (var curAccount in listOfAccounts)
{
var curQuickBooksAccount = new AccountDTO();
curQuickBooksAccount.Id = curAccount.Id;
curQuickBooksAccount.Name = curAccount.Name;
listOfQBAccounts.Add(curQuickBooksAccount);
}
return(new ChartOfAccountsCM()
{
Accounts = listOfQBAccounts
});
}
public HubCommunicationService(IHubCommunicator hubCommunicator,
IPackagesList allPackagesList,
ILocalPackageCache localPackageCache,
IInstalledPackageArchive installCache,
RunningInstallationTaskList runningTasks,
IAgentSettingsManager settingsManager,
ILogger logger,
CurrentlyDownloadingList currentlyDownloadingList,
CompletedInstallationTaskList completedInstalls,
INotificationService notificationService)
{
_hubCommunicator = hubCommunicator;
_allPackagesList = allPackagesList;
_localPackageCache = localPackageCache;
_installCache = installCache;
_runningTasks = runningTasks;
_settingsManager = settingsManager;
_logger = logger;
_currentlyDownloadingList = currentlyDownloadingList;
CompletedInstalls = completedInstalls;
_notificationService = notificationService;
}
private async Task CreateAndActivateNewMADSEPlan(IHubCommunicator hubCommunicator, AuthorizationToken authToken)
{
try
{
var emptyMonitorPlan = new PlanNoChildrenDTO
{
Name = "MonitorAllDocuSignEvents",
Description = "MonitorAllDocuSignEvents",
PlanState = "Active",
Visibility = new PlanVisibilityDTO()
{
Hidden = true
}
};
var monitorDocusignPlan = await hubCommunicator.CreatePlan(emptyMonitorPlan);
Debug.WriteLine("Attemting to create a new MADSE plan");
var activityTemplates = await hubCommunicator.GetActivityTemplates();
var recordDocusignEventsTemplate = GetActivityTemplate(activityTemplates, "Prepare_DocuSign_Events_For_Storage");
var storeMTDataTemplate = GetActivityTemplate(activityTemplates, "Save_All_Payload_To_Fr8_Warehouse");
Debug.WriteLine($"Calling create and configure with params {recordDocusignEventsTemplate} {authToken.UserId} {monitorDocusignPlan}");
await hubCommunicator.CreateAndConfigureActivity(recordDocusignEventsTemplate.Id, "Record DocuSign Events", 1, monitorDocusignPlan.StartingSubPlanId, false, new Guid(authToken.Id));
var storeMTDataActivity = await hubCommunicator.CreateAndConfigureActivity(storeMTDataTemplate.Id, "Save To Fr8 Warehouse", 2, monitorDocusignPlan.StartingSubPlanId);
//save this
await hubCommunicator.ConfigureActivity(storeMTDataActivity);
await hubCommunicator.RunPlan(monitorDocusignPlan.Id, null);
Logger.Info($"#### New MADSE plan activated with planId: {monitorDocusignPlan.Id}");
}
catch (Exception exc)
{
Logger.Error($"#### Failed to create MADSE plan for {authToken.ExternalAccountId} Exception:{exc.Message} {exc.StackTrace.Substring(255)}");
}
}
public async Task <Dictionary <string, DbType> > ExtractColumnTypes(
IHubCommunicator hubCommunicator, ActivityContext activityContext)
{
var upstreamCrates = await hubCommunicator.GetCratesByDirection <KeyValueListCM>(activityContext.ActivityPayload.Id, CrateDirection.Upstream);
if (upstreamCrates == null)
{
return(null);
}
var columnTypesCrate = upstreamCrates
.FirstOrDefault(x => x.Label == "Sql Column Types");
if (columnTypesCrate == null)
{
return(null);
}
var columnTypes = columnTypesCrate.Content;
if (columnTypes == null)
{
return(null);
}
var columnTypeFields = columnTypes.Values;
if (columnTypeFields == null)
{
return(null);
}
var columnTypeMap = GetColumnTypeMap(columnTypeFields);
return(columnTypeMap);
}
private async Task RemoveInactiveExistingPlans(IHubCommunicator hubCommunicator, string plan_name, AuthorizationToken authToken)
{
try
{
var existingPlans = (await hubCommunicator.GetPlansByName(plan_name, PlanVisibility.Internal)).ToList();
if (existingPlans.Count > 0)
{
//active MADSE plans are likely related to another DS account
var plansForRemoval = existingPlans
.Where(val =>
(val.PlanState == PlanState.IntToString(PlanState.Inactive)) || //or all from above
!(val.SubPlans.Any() && val.SubPlans.ElementAt(0).Activities.Any() &&
val.SubPlans.ElementAt(0).Activities[1].ActivityTemplate.Name == "Save_All_Payload_To_Fr8_Warehouse")).ToList();
foreach (var plan in plansForRemoval)
{
await hubCommunicator.DeletePlan(plan.Id);
}
Logger.Info($"Removed {plansForRemoval.Count} obsolete MADSE plan");
}
}
catch (Exception exc) { Logger.Info("Failed to remove obsolete MADSE plan"); }
}
public SalesforceManager(Authentication authentication, IHubCommunicator hubCommunicator)
{
_authentication = authentication;
_hubCommunicator = hubCommunicator;
_logger = Logger.GetLogger(nameof(SalesforceManager));
}
public PlanHelper(IHubCommunicator hubCommunicator)
{
_hubCommunicator = hubCommunicator;
}
public async Task SchedulePolling(IHubCommunicator hubCommunicator, string externalAccountId, bool trigger_immediately)
{
string pollingInterval = "1";
await hubCommunicator.ScheduleEvent(externalAccountId, pollingInterval, trigger_immediately);
}
public void SchedulePolling(IHubCommunicator hubCommunicator, string externalAccountId)
{
string pollingInterval = CloudConfigurationManager.GetSetting("terminalDocuSign.PollingInterval");
hubCommunicator.ScheduleEvent(externalAccountId, pollingInterval);
}
public UpstreamQueryManager(ActivityContext activityContext, IHubCommunicator hubCommunicator)
{
_activityContext = activityContext;
_hubCommunicator = hubCommunicator;
}
public ControlHelper(ActivityContext activityContext)
{
_hubCommunicator = activityContext.HubCommunicator;
_activityContext = activityContext;
}
public async Task <object> HandleFr8Request(
string curActionPath,
IEnumerable <KeyValuePair <string, string> > parameters,
Fr8DataDTO curDataDTO)
{
if (curDataDTO == null)
{
throw new ArgumentNullException(nameof(curDataDTO));
}
if (curDataDTO.ActivityDTO == null)
{
throw new ArgumentException(nameof(curDataDTO.ActivityDTO) + " is null");
}
if (curDataDTO.ActivityDTO.ActivityTemplate == null)
{
throw new ArgumentException(nameof(curDataDTO.ActivityDTO.ActivityTemplate) + " is null");
}
ActivityContext activityContext = DeserializeRequest(curDataDTO);
//we should remove this mode
var activityTemplate = curDataDTO.ActivityDTO.ActivityTemplate;
IActivityFactory factory;
if (activityTemplate.Name.EndsWith("_TEST"))
{
var originalName = activityTemplate.Name;
_hubCommunicator = new TestMonitoringHubCommunicator(curDataDTO.ExplicitData, CrateManager);
activityTemplate.Name = activityTemplate.Name.Substring(0, activityTemplate.Name.Length - "_TEST".Length);
factory = _activityStore.GetFactory(activityTemplate.Name, activityTemplate.Version);
activityTemplate.Name = originalName;
}
else
{
factory = _activityStore.GetFactory(curDataDTO.ActivityDTO.ActivityTemplate.Name, curDataDTO.ActivityDTO.ActivityTemplate.Version);
}
if (factory == null)
{
throw new ArgumentException($"Activity template registration for [Name = '{curDataDTO.ActivityDTO.ActivityTemplate.Name}', Version = '{curDataDTO.ActivityDTO.ActivityTemplate.Version}'] not found");
}
_container.Configure(x =>
{
x.For <ActivityContext>().Use(activityContext);
x.For <UpstreamQueryManager>().Use <UpstreamQueryManager>().Singleton();
});
var activity = factory.Create(_container);
activityContext.HubCommunicator = _hubCommunicator;
var scope = parameters != null && parameters.Any(x => x.Key == "scope")
? parameters.First(x => x.Key == "scope").Value
: null;
switch (curActionPath.ToLower())
{
case "configure":
await activity.Configure(activityContext);
return(SerializeResponse(activityContext));
case "activate":
await activity.Activate(activityContext);
return(SerializeResponse(activityContext));
case "deactivate":
await activity.Deactivate(activityContext);
return(SerializeResponse(activityContext));
case "run":
{
var executionContext = await CreateContainerExecutionContext(curDataDTO);
if (scope == "childActivities")
{
await activity.RunChildActivities(activityContext, executionContext);
}
else
{
await activity.Run(activityContext, executionContext);
}
return(SerializeResponse(executionContext));
}
case "documentation":
var documentation = await activity.GetDocumentation(activityContext, curDataDTO.ActivityDTO.Documentation);
return(SerializeResponse(documentation));
}
throw new ArgumentException("Unsupported request: " + curActionPath);
}
public ActivityExecutor(IHubCommunicator hubCommunicator, ICrateManager crateManager)
{
_hubCommunicator = hubCommunicator;
CrateManager = crateManager;
}
public void CreateOrUpdatePolling(IHubCommunicator hubCommunicator, AuthorizationToken authToken)
{
DocuSignPolling polling = new DocuSignPolling(_docuSignManager, _eventReporter);
polling.SchedulePolling(hubCommunicator, authToken.ExternalAccountId);
}
public async Task <object> HandleFr8Request(string curTerminal, string curActionPath, Fr8DataDTO curDataDTO)
{
if (curDataDTO == null)
{
throw new ArgumentNullException(nameof(curDataDTO));
}
if (curDataDTO.ActivityDTO == null)
{
throw new ArgumentException(nameof(curDataDTO.ActivityDTO) + " is null");
}
if (curDataDTO.ActivityDTO.ActivityTemplate == null)
{
throw new ArgumentException(nameof(curDataDTO.ActivityDTO.ActivityTemplate) + " is null");
}
ActivityContext activityContext = DeserializeRequest(curDataDTO);
//we should remove this mode
var activityTemplate = curDataDTO.ActivityDTO.ActivityTemplate;
IActivityFactory factory;
if (activityTemplate.Name.EndsWith("_TEST"))
{
var originalName = activityTemplate.Name;
_hubCommunicator = new TestMonitoringHubCommunicator(curDataDTO.ExplicitData);
activityTemplate.Name = activityTemplate.Name.Substring(0, activityTemplate.Name.Length - "_TEST".Length);
factory = ActivityStore.GetValue(activityTemplate);
activityTemplate.Name = originalName;
}
else
{
factory = ActivityStore.GetValue(curDataDTO.ActivityDTO.ActivityTemplate);
}
if (factory == null)
{
throw new ArgumentException($"Activity template registration for [Name = '{curDataDTO.ActivityDTO.ActivityTemplate.Name}', Version = '{curDataDTO.ActivityDTO.ActivityTemplate.Version}'] not found");
}
var activity = factory.Create();
_hubCommunicator.Configure(curTerminal, activityContext.UserId);
activityContext.HubCommunicator = _hubCommunicator;
ContainerExecutionContext executionContext;
switch (curActionPath.ToLower())
{
case "configure":
await activity.Configure(activityContext);
return(SerializeResponse(activityContext));
case "activate":
await activity.Activate(activityContext);
return(SerializeResponse(activityContext));
case "deactivate":
await activity.Deactivate(activityContext);
return(SerializeResponse(activityContext));
case "run":
executionContext = await CreateContainerExecutionContext(curDataDTO);
await activity.Run(activityContext, executionContext);
return(SerializeResponse(executionContext));
case "executechildactivities":
executionContext = await CreateContainerExecutionContext(curDataDTO);
await activity.RunChildActivities(activityContext, executionContext);
return(SerializeResponse(executionContext));
case "documentation":
var documentation = await activity.GetDocumentation(activityContext, curDataDTO.ActivityDTO.Documentation);
return(SerializeResponse(documentation));
}
throw new ArgumentException("Unsupported request: " + curActionPath);
}
//only create a connect when running on dev/production
public void CreateConnect(IHubCommunicator hubCommunicator, AuthorizationToken authToken)
{
Logger.Info($"CreateConnect called {authToken.UserId}");
var authTokenDO = new AuthorizationTokenDO()
{
Token = authToken.Token, ExternalAccountId = authToken.ExternalAccountId
};
var config = _docuSignManager.SetUp(authToken);
string terminalUrl = CloudConfigurationManager.GetSetting("terminalDocuSign.TerminalEndpoint");
string prodUrl = CloudConfigurationManager.GetSetting("terminalDocuSign.DefaultProductionUrl");
string devUrl = CloudConfigurationManager.GetSetting("terminalDocuSign.DefaultDevUrl");
string demoUrl = CloudConfigurationManager.GetSetting("terminalDocuSign.DefaultDemoUrl");
bool isSelfHosting = CloudConfigurationManager.GetSetting("terminalDocusign.NotSelfHosting") == null;
string connectName = "";
string connectId = "";
Logger.Info($"CreateConnect terminalUrl {terminalUrl}");
if (!isSelfHosting)
{
if (terminalUrl.Contains(devUrl, StringComparison.InvariantCultureIgnoreCase))
{
connectName = DevConnectName;
// DS doesn't accept port in url, so instead of
//http://dev-terminals.fr8.co:53234/terminals/terminalDocuSign/events
// we should use
//http://dev-terminaldocusign.fr8.co/terminals/terminalDocuSign/events
terminalUrl = CloudConfigurationManager.GetSetting("terminalDocuSign.OverrideDevUrl");
}
else
if (terminalUrl.Contains(prodUrl, StringComparison.InvariantCultureIgnoreCase))
{
connectName = ProdConnectName;
}
else
if (terminalUrl.Contains(demoUrl, StringComparison.InvariantCultureIgnoreCase))
{
connectName = DemoConnectName;
}
else
{
Logger.Info($"Unable to set connectName from {terminalUrl}");
}
string publishUrl = terminalUrl + "/terminals/terminalDocuSign/events";
Logger.Info("Connect creation: publishUrl = {0}");
if (!string.IsNullOrEmpty(connectName))
{
connectId = _docuSignConnect.CreateOrActivateConnect(config, connectName, publishUrl);
Logger.Info($"Created connect named {connectName} pointing to {publishUrl} with id {connectId}");
}
else
{
// terminal has a temporary url
var connectsInfo = _docuSignConnect.ListConnects(config);
var connects = connectsInfo.Where(a => a.name == TemporaryConnectName).ToList();
foreach (var connect in connects)
{
_docuSignConnect.DeleteConnect(config, connect.connectId);
}
connectId = _docuSignConnect.CreateConnect(config, TemporaryConnectName, publishUrl);
Logger.Info($"Created connect named {TemporaryConnectName} pointing to {publishUrl} with id {connectId}");
}
}
else
{
Logger.Info($"terminalUrl is empty, no work has been done in DocuSignPlan.CreateConnect: prodUrl -> {prodUrl}, devUrl -> {devUrl}, demoUrl -> {demoUrl}");
}
}
