/// <summary>
/// Delete a campaign feedback message
/// <param name="campaignId">Unique id for the campaign</param>
/// <param name="feedback_id">Unique id for the feedback message.</param>
/// </summary>
internal async Task <HttpResponseMessage> DeleteFeedbackAsync(string campaignId, string feedback_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.campaigns, SubTargetType.feedback,
SubTargetType.not_applicable, campaignId, feedback_id);
return(await BaseOperation.DeleteAsync(endpoint));
}
/// <summary>
/// Get information about a specific workflow email
/// <param name="workflow_id">Unique id for the Automation workflow</param>
/// <param name="workflow_email_id">Unique id for the Automation workflow email</param>
/// </summary>
internal async Task <AutomationsEmail> GetAutomationEmailInfoAsync(string workflow_id, string workflow_email_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.automations, SubTargetType.emails,
SubTargetType.not_applicable, workflow_id, workflow_email_id);
return(await BaseOperation.GetAsync <AutomationsEmail>(endpoint));
}
/// <summary>
/// Get feedback about a campaign
/// <param name="campaignId">Unique id for the campaign</param>
/// <param name="feedback_id">Unique id for the feedback message.</param>
/// </summary>
internal async Task <Feedback> GetFeedbackAsync(string campaignId, string feedback_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.campaigns, SubTargetType.feedback,
SubTargetType.not_applicable, campaignId, feedback_id);
return(await BaseOperation.GetAsync <Feedback>(endpoint));
}
/// <summary>
/// Return statistics for the top-performing domains from a campaign.
/// <param name="campaignId">Unique id for campaign</param>
/// </summary>
internal async Task <RootUnsubscribe> GetUnsubscriberListAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.unsubscribed,
SubTargetType.not_applicable, campaignId);
return(await BaseOperation.GetAsync <RootUnsubscribe>(endpoint));
}
/// <summary>
/// Get information about a specific Automation workflow
/// <param name="workflow_id">Unique id for the Automation workflow</param>
/// </summary>
internal async Task <MCAutomation> GetAutomationAsync(string workflow_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.automations, SubTargetType.not_applicable,
SubTargetType.not_applicable, workflow_id);
return(await BaseOperation.GetAsync <MCAutomation>(endpoint));
}
/// <summary>
/// Delete a campaign folder
/// <param name="folder_id">Unique id for the campaign folder</param>
/// </summary>
internal async Task <HttpResponseMessage> DeleteCampaignFolderAsync(string folder_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.campaign_folders, SubTargetType.not_applicable,
SubTargetType.not_applicable, folder_id);
return(await BaseOperation.DeleteAsync(endpoint));
}
/// <summary>
/// Send a campaign
/// <param name="campaignId">Unique id for the campaign</param>
/// </summary>
internal async Task <dynamic> SendCampaignAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.campaigns, SubTargetType.actionSend, SubTargetType.not_applicable,
campaignId);
return(await BaseOperation.PostAsync(endpoint));
}
/// <summary>
/// Return a summary of social activity for the campaign, tracked by EepURL.
/// <param name="campaignId">Unique id for campaign</param>
/// </summary>
internal async Task <Eepurl> GetEepUrlActivityAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.eepurl, SubTargetType.not_applicable,
campaignId);
return(await BaseOperation.GetAsync <Eepurl>(endpoint));
}
/// <summary>
/// Get a specific campaign folder
/// <param name="folder_id">Unique id for the campaign folder</param>
/// </summary>
internal async Task <CampaignFolder> GetCampaignFolderAsync(string folder_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.campaign_folders, SubTargetType.not_applicable,
SubTargetType.not_applicable, folder_id);
return(await BaseOperation.GetAsync <CampaignFolder>(endpoint));
}
/// <summary>
/// Get the status of a batch operation request
/// <param name="batchId">The unique id for the batch operation</param>
/// </summary>
internal async Task <RootBatch> GetBatchReportAsync(string batchId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.batches, SubTargetType.not_applicable,
SubTargetType.not_applicable, batchId);
return(await BaseOperation.GetAsync <RootBatch>(endpoint));
}
/// <summary>
/// Return A list of reports for child campaigns of a specific parent campaign.
/// <param name="campaignId">Campaign Id</param>
/// </summary>
internal async Task <Sub_Reports> GetChildCampaignReportsAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.sub_reports,
SubTargetType.not_applicable, campaignId);
return(await BaseOperation.GetAsync <Sub_Reports>(endpoint));
}
/// <summary>
/// Start a batch operation
/// <param name="bundle"></param>
/// </summary>
internal async Task <dynamic> PostBatchOperationAsync(RootBatch bundle)
{
string endpoint = Authenticate.EndPoint(TargetTypes.batches, SubTargetType.not_applicable,
SubTargetType.not_applicable);
return(await BaseOperation.PostAsync <RootBatch>(endpoint, bundle));
}
public void AddStep_NewOperation_CorrectAddingOfSteps(
Dictionary <string, List <BaseStep> > addingStates,
Dictionary <string, List <BaseStep> > expectedStates,
BaseOperation customizableOper)
{
foreach (var state in addingStates.Keys)
{
foreach (var step in addingStates[state])
{
customizableOper.AddStep(state, step.LuaName, step.Name,
step.DefaultPosition);
}
}
Assert.Multiple(() =>
{
foreach (var state in customizableOper.States.Keys)
{
Assert.True(expectedStates.ContainsKey(state));
foreach (var step in customizableOper.States[state])
{
Assert.True(expectedStates[state]
.Where(x => x.Name == step.Name &&
x.LuaName == step.LuaName &&
x.DefaultPosition == step.DefaultPosition &&
x.Owner == step.Owner)
.Count() == 1);
}
}
});
}
public void GetStateBaseSteps_StateFromSource_ReturnsStepsOrEmptyList(
Dictionary <string, List <BaseStep> > addingStates,
State.StateType selectedState, List <BaseStep> expectedSteps,
BaseOperation customizableOper)
{
FillBaseOperationStatesWithReset(customizableOper, addingStates);
List <BaseStep> actualSteps = customizableOper
.GetStateBaseSteps(selectedState);
Assert.Multiple(() =>
{
for (int stepId = 0; stepId < actualSteps.Count; stepId++)
{
BaseStep expectedStep = expectedSteps[stepId];
BaseStep actualStep = actualSteps[stepId];
bool areEqual =
expectedStep.DefaultPosition ==
actualStep.DefaultPosition &&
expectedStep.LuaName == actualStep.LuaName &&
expectedStep.Name == actualStep.Name &&
expectedStep.Owner == actualStep.Owner;
Assert.IsTrue(areEqual);
}
});
}
/// <summary>
/// Return statistics for the top-performing domains from a campaign.
/// <param name="campaignId">Unique id for campaign</param>
/// </summary>
internal async Task <DomainPerformance> GetDomainPerformanceAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.domain_performance,
SubTargetType.not_applicable, campaignId);
return(await BaseOperation.GetAsync <DomainPerformance>(endpoint));
}
/// <summary>
/// Get the send checklist for a campaign
/// <param name="campaign_id">Unique id for the campaign</param>
/// </summary>
internal async Task <RootCheckList> GetCheckListAsync(string campaign_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.campaigns, SubTargetType.send_checklist,
SubTargetType.not_applicable, campaign_id);
return(await BaseOperation.GetAsync <RootCheckList>(endpoint));
}
/// <summary>
/// Delete a specific template
/// <param name="template_id">The unique id for the template</param>
/// </summary>
internal async Task <HttpResponseMessage> DeleteTemplateAsync(string template_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.templates, SubTargetType.not_applicable,
SubTargetType.not_applicable, template_id);
return(await BaseOperation.DeleteAsync(endpoint));
}
/// <summary>
/// Return recent feedback based on a campaign’s statistics
/// <param name="campaignId">Campaign Id</param>
/// </summary>
internal async Task <CampaignAdvice> GetAdviceAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.advice, SubTargetType.not_applicable,
campaignId);
return(await BaseOperation.GetAsync <CampaignAdvice>(endpoint));
}
public async Task <double> Handle(Query request, CancellationToken cancellationToken)
{
BaseOperation oper = request.factory.CreateOperation();
double result = await _calculator.GetResult(request.Num1, request.Num2, oper);
return(result);
}
public async Task <IActionResult> TestDouble()
{
var e = new BaseOperation()
{
Id = null,
B = new B()
{
Id = "B-1"
}
};
var e2 = new BaseOperation()
{
Id = null,
B = new B()
{
Id = "B-2"
}
};
//** Store ***********************//
await _session.StoreAsync(e);
await _session.StoreAsync(e2);
await _session.SaveChangesAsync();
//** Delete ***********************//
_session.Delete(e);
await _session.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> TestUpdate([FromRoute] string id)
{
var e = new BaseOperation()
{
Id = null,
B = new B()
{
Id = "B-single"
}
};
//** Store ***********************//
await _session.StoreAsync(e);
await _session.SaveChangesAsync();
//** Update ***********************//
e.B.Id = "BUpdate";
await _session.StoreAsync(e);
await _session.SaveChangesAsync();
//** Delete ***********************//
_session.Delete(e);
await _session.SaveChangesAsync();
return(Ok());
}
/// <summary>
/// Return list member activity for a specific campaign
/// <param name="campaignId">Unique id for the campaign</param>
/// <param name="subscriber_hash">The MD5 hash of the lowercase version of the list member’s email address</param>
/// </summary>
internal async Task <EmailActivity> GetSubscriberEmailActivityAsync(string campaignId, string subscriber_hash)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.email_activity,
SubTargetType.not_applicable, campaignId, subscriber_hash);
return(await BaseOperation.GetAsync <EmailActivity>(endpoint));
}
/// <summary>
/// View all subscribers removed from a workflow
/// <param name="workflow_id">Unique id for the Automation workflow</param>
/// </summary>
internal async Task <RemovedSubscriber> GetRemovedSubscriberListAsync(string workflow_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.automations, SubTargetType.removed_subscribers,
SubTargetType.not_applicable, workflow_id);
return(await BaseOperation.GetAsync <RemovedSubscriber>(endpoint));
}
/// <summary>
/// View queued subscribers for an automated email
/// <param name="workflow_id">Unique id for the Automation workflow</param>
/// <param name="workflow_email_id">Unique id for the Automation workflow email</param>
/// </summary>
internal async Task <RootAutomationsEmailQueue> GetQueuedSubscriberListAsync(string workflow_id, string workflow_email_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.automations, SubTargetType.emails, SubTargetType.queue,
workflow_id, workflow_email_id);
return(await BaseOperation.GetAsync <RootAutomationsEmailQueue>(endpoint));
}
/// <summary>
/// Get conversation messages
/// <param name="conversation_id">Unique id for the campaign</param>
/// <param name="message_id">The unique id for the conversation message</param>
/// </summary>
internal async Task <ConversationMessage> GetMessageAsync(string conversation_id, string message_id)
{
string endpoint = Authenticate.EndPoint(TargetTypes.conversations, SubTargetType.messages,
SubTargetType.not_applicable, conversation_id, message_id);
return(await BaseOperation.GetAsync <ConversationMessage>(endpoint));
}
/// <summary>
/// Get screenshot
/// <param name="jobId">Get generate screenshot by job id</param>
/// </summary>
public RootScreenshot GetGeneratedScreenshot(string jobId)
{
var request = new RestRequest();
request.Resource = string.Format("/{0}.json", jobId);
return(BaseOperation.ExecuteGet <RootScreenshot>(request, baseUrl, UserName, AccessKey));
}
/// <summary>
/// Return top open locations for a specific campaign.
/// <param name="campaignId">Unique id for the campaign</param>
/// </summary>
internal async Task <RootLocation> GetTopLocationAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.locations, SubTargetType.not_applicable,
campaignId);
return(await BaseOperation.GetAsync <RootLocation>(endpoint));
}
/// <summary>
/// Return top open locations for a specific campaign.
/// <param name="campaignId">Unique id for the campaign</param>
/// <param name="subscriber_hash">The MD5 hash of the lowercase version of the list member’s email address</param>
/// </summary>
internal async Task <SentTo> GetCampaignRecipientAsync(string campaignId, string subscriber_hash)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.sent_to, SubTargetType.not_applicable,
campaignId, subscriber_hash);
return(await BaseOperation.GetAsync <SentTo>(endpoint));
}
/// <summary>
/// Return top open locations for a specific campaign.
/// <param name="campaignId">Unique id for the campaign</param>
/// </summary>
internal async Task <RootSentTo> GetRecipientsInfoAsync(string campaignId)
{
string endpoint = Authenticate.EndPoint(TargetTypes.reports, SubTargetType.sent_to, SubTargetType.not_applicable,
campaignId);
return(await BaseOperation.GetAsync <RootSentTo>(endpoint));
}
/// <summary>
/// Get a list of conversations
/// </summary>
internal async Task <RootConversation> GetConversationsAsync()
{
string endpoint = Authenticate.EndPoint(TargetTypes.conversations, SubTargetType.not_applicable,
SubTargetType.not_applicable);
return(await BaseOperation.GetAsync <RootConversation>(endpoint));
}
public BlockingOperationScreen(String message, BaseOperation op)
: base(message)
{
m_operation = op;
}
public void OnOperationStarted(BaseOperation op)
{
}
public void OnOperationFinished(BaseOperation op)
{
Finish();
}