public async Task <ActionResult> DeleteConfirmed(WebhookModel webhookModel)
{
var salesforceService = new SalesforceService((ClaimsPrincipal)User, SignInManager);
await salesforceService.DeleteWebhookAsync(webhookModel);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit(string id)
{
IEnumerable <Product2> selectedProduct2s = Enumerable.Empty <Product2>();
try
{
selectedProduct2s = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <Product2> Product2s =
await client.QueryAsync <Product2>("SELECT Id, Name, ProductCode, Description, CreatedDate, Family From Product2 Where Id= '" + id + "'");
return(Product2s.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "Edit Salesforce Product2s";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
return(View(selectedProduct2s.FirstOrDefault()));
}
// GET: Contacts
public async Task <ActionResult> Index()
{
IEnumerable <Contact> selectedContacts = Enumerable.Empty <Contact>();
try
{
selectedContacts = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <Contact> contacts =
await client.QueryAsync <Contact>("SELECT Id, Salutation, FirstName, LastName, MailingCity, MailingState, MailingCountry From Contact");
return(contacts.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "query Salesforce Contacts";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
return(View(selectedContacts));
}
public async Task <ActionResult> Edit(string id)
{
IEnumerable <LeadViewModel> selectedLeads = Enumerable.Empty <LeadViewModel>();
try
{
selectedLeads = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <LeadViewModel> leads =
await client.QueryAsync <LeadViewModel>("SELECT Id, Salutation, FirstName, LastName, Company, Street, City, State, PostalCode, Phone, MobilePhone, Fax, Email, Status, Description From Lead Where Id = '" + id + "'");
return(leads.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "Edit Salesforce Leads";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
return(View(selectedLeads.FirstOrDefault()));
}
public async Task <ActionResult> LeadEdit(Lead lead)
{
// TODO: Resolve Edit failures with ID
// Ensure the user is authenticated
if (!SalesforceService.IsUserLoggedIn())
{
// Should include a state argument to the URI so that when the dance is done, we can redirect to the page that we were requesting
string myUri = SalesforceOAuthRedirectHandler.AuthorizationUri.ToString() + "&state=" + this.Url.RequestContext.HttpContext.Request.RawUrl;
return(this.Redirect(myUri));
}
// Initialize the Force client
SalesforceService service = new SalesforceService();
ForceClient client = service.GetForceClient();
var success = await client.UpdateAsync("Lead", lead.Id, lead);
if (success.errors == null)
{
return(RedirectToAction("LeadList"));
}
else
{
return(View(lead));
}
}
// GET: Contacts
public async Task <ActionResult> Index()
{
var salesforceService = new SalesforceService((ClaimsPrincipal)User, SignInManager);
var contacts = await salesforceService.GetContactsAsync();
return(View(contacts));
}
public IActionResult Reset(ResetViewModel vm, string userid, string email, string token)
{
ViewData["status"] = "";
ValidateReset(vm, userid, email, token);
if (ModelState.IsValid)
{
try
{
Auth0.ManagementApi.Models.User userResult = null;
SalesforceService.Response hashResponse = SalesforceService.CheckHash(_sfdcTokenManager.instance_url, _sfdcTokenManager.access_token, System.Net.WebUtility.HtmlDecode(email), token).Result;
_logger.LogInformation("Hash Code Response: {0}", hashResponse.code);
_logger.LogInformation("User Id: {0}", userid);
//Hash matches
if (hashResponse.code == "10014")
{
string accessToken = GetClientToken().Result;
userResult = UpdateUserPassword(accessToken, System.Net.WebUtility.HtmlDecode(userid), vm.NewPassword1).Result;
ViewData["status"] = userResult.UpdatedAt;
}
else
{
ModelState.AddModelError("", "Token has expired");
}
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
}
return(View(vm));
}
public async Task <ActionResult> DeleteConfirmed(string id)
{
bool success = false;
try
{
success = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
success = await client.DeleteAsync("Contact", id);
return(success);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "Delete Salesforce Contacts";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
if (success)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public async Task <ActionResult> Index()
{
var salesforceService = new SalesforceService((ClaimsPrincipal)User, SignInManager);
var webhookModels = await salesforceService.GetWebhooksAsync();
return(View(webhookModels));
}
public async Task <ActionResult> Edit(string id)
{
IEnumerable <Contact> selectedContacts = Enumerable.Empty <Contact>();
try
{
selectedContacts = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <Contact> contacts =
await client.QueryAsync <Contact>("SELECT Id, FirstName, LastName, MailingStreet, MailingCity, MailingState, MailingPostalCode, MailingCountry, Phone, Email From Contact Where Id= '" + id + "'");
return(contacts.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "Edit Salesforce Contacts";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
return(View(selectedContacts.FirstOrDefault()));
}
public async Task <ActionResult> Create([Bind(Include = _ContactsPostBinding)] Contact contact)
{
String id = String.Empty;
try
{
id = (await SalesforceService.MakeAuthenticatedClientRequestAsync(
async(client) =>
{
return(await client.CreateAsync("Contact", contact));
}
)).ToString();
}
catch (Exception e)
{
this.ViewBag.OperationName = "Create Salesforce Contact";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
if (this.ViewBag.ErrorMessage == null)
{
return(RedirectToAction("Index"));
}
else
{
return(View(contact));
}
}
public async Task <ActionResult> Edit(string id)
{
IEnumerable <Event> selectedEvents = Enumerable.Empty <Event>();
try
{
selectedEvents = await SalesforceService
.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <Event> Events =
await client
.QueryAsync <Event>(
_SelectAll + $" Where Id= '{id}'");
return(Events.Records);
}
);
}
catch (Exception e)
{
ViewBag.OperationName = "Edit Salesforce Events";
ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler
.GetAuthorizationUrl(Request.Url.ToString());
ViewBag.ErrorMessage = e.Message;
}
if (ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(ViewBag.AuthorizationUrl));
}
return(View(selectedEvents.FirstOrDefault()));
}
public async Task <ActionResult> Create([Bind(Include = _EventsPostBinding)] Event Event)
{
SuccessResponse success = new SuccessResponse();
String id = String.Empty;
try
{
success = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
return(await client.CreateAsync("Event", Event));
}
);
id = success.Id;
}
catch (Exception e)
{
this.ViewBag.OperationName = "Create Salesforce Event";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
if (this.ViewBag.ErrorMessage == null)
{
return(RedirectToAction("Index"));
}
else
{
return(View(Event));
}
}
// GET: Events
public async Task <ActionResult> Index()
{
IEnumerable <Event> selectedEvents = Enumerable.Empty <Event>();
try
{
selectedEvents = await SalesforceService
.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <Event> events = await client
.QueryAsync <Event>(_SelectAll);
return(events.Records);
}
);
}
catch (Exception e)
{
ViewBag.OperationName = "query Salesforce Events";
ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler
.GetAuthorizationUrl(Request.Url.ToString());
ViewBag.ErrorMessage = e.Message;
}
if (ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(ViewBag.AuthorizationUrl));
}
IEnumerable <EventIndexViewModel> viewEvents = EventHelper.GetEventIndexViewModel(selectedEvents);
return(View(viewEvents));
}
public async Task <ActionResult> Edit([Bind(Include = _ContactsPostBinding)] Contact contact)
{
SuccessResponse success = new SuccessResponse();
try
{
success = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
success = await client.UpdateAsync("Contact", contact.Id, contact);
return(success);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "Edit Salesforce Contact";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
if (success.Success == true)
{
return(RedirectToAction("Index"));
}
else
{
return(View(contact));
}
}
// GET: Assistance
// GET: Contacts
// Note: the SOQL Field list, and Binding Property list have subtle differences as custom properties may be mapped with the JsonProperty attribute to remove __c
//const string _ContactsPostBinding = "Id,Salutation,FirstName,LastName,MailingStreet,MailingCity,MailingState,MailingPostalCode,MailingCountry,Phone,Email";
// GET: Contacts
public async Task <ActionResult> Index()
{
IEnumerable <Assistance__c> selectedContacts = Enumerable.Empty <Assistance__c>();
try
{
selectedContacts = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <Assistance__c> contacts =
await client.QueryAsync <Assistance__c>("SELECT Owner ID, Assistance Name, Contact, Date, Description, Provider, Status From Assistance__c");
return(contacts.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "query Salesforce Contacts";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
return(View(selectedContacts));
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
_context = new MobileServiceContext();
_salesforceService = new SalesforceService();
_domainEmployeeManager = new EntityDomainManager <Employee>(_context, Request, Services);
DomainManager = new EntityDomainManager <Ride>(_context, Request, Services);
}
// GET: Leads
public async Task <ActionResult> Index()
{
ApplicationUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
IEnumerable <LeadViewModel> selectedLeads = Enumerable.Empty <LeadViewModel>();
if (User.Identity.IsAuthenticated)
{
if (User.IsInRole("admin"))
{
try
{
selectedLeads = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <LeadViewModel> leads =
await
client.QueryAsync <LeadViewModel>(
"SELECT Id, LastName, Salutation, FirstName, Phone, MobilePhone, Email, UserEmail__c From Lead");
return(leads.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "query Salesforce Leads";
this.ViewBag.AuthorizationUrl =
SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
}
else
{
try
{
selectedLeads = await SalesforceService.MakeAuthenticatedClientRequestAsync(
async (client) =>
{
QueryResult <LeadViewModel> leads =
await client.QueryAsync <LeadViewModel>("SELECT Id, LastName, Salutation, FirstName, Phone, MobilePhone, Email, UserEmail__c From Lead Where UserEmail__c = '" + user.UserName + "'");
return(leads.Records);
}
);
}
catch (Exception e)
{
this.ViewBag.OperationName = "query Salesforce Leads";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
}
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
return(View(selectedLeads));
}
public async Task <List <Models.Contact> > Get()
{
var client = await SalesforceService.GetUserNamePasswordForceClientAsync();
var contacts = await client.QueryAsync <Models.Contact>("SELECT id, FirstName, LastName, Email FROM Contact");
var sfContact = contacts.Records;
return(sfContacts);
}
public async Task <ActionResult> Create(LeadViewModel lead)
{
ApplicationUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
var Lead = new LeadViewModel
{
Id = lead.Id,
Salutation = lead.Salutation,
FirstName = lead.FirstName,
LastName = lead.LastName,
Company = lead.Company,
Street = lead.Street,
City = lead.City,
State = lead.State,
PostalCode = lead.PostalCode,
Phone = lead.Phone,
MobilePhone = lead.MobilePhone,
Fax = lead.Fax,
Email = lead.Email,
Status = lead.Status,
CreatedDate = lead.CreatedDate,
Description = lead.Description,
UserEmail__c = user.Email
};
String id = String.Empty;
try
{
id = (await SalesforceService.MakeAuthenticatedClientRequestAsync(
async(client) =>
{
return(await client.CreateAsync("Lead", Lead));
}
)).ToString();
}
catch (Exception e)
{
this.ViewBag.OperationName = "Create Salesforce Lead";
this.ViewBag.AuthorizationUrl = SalesforceOAuthRedirectHandler.GetAuthorizationUrl(this.Request.Url.ToString());
this.ViewBag.ErrorMessage = e.Message;
}
if (this.ViewBag.ErrorMessage == "AuthorizationRequired")
{
return(Redirect(this.ViewBag.AuthorizationUrl));
}
if (this.ViewBag.ErrorMessage == null)
{
return(RedirectToAction("Index"));
}
else
{
return(View(lead));
}
}
public async Task <ActionResult> Edit(SalesforceContact contact)
{
if (ModelState.IsValid)
{
var salesforceService = new SalesforceService((ClaimsPrincipal)User, SignInManager);
await salesforceService.UpdateContactAsync(contact);
return(RedirectToAction("Index"));
}
return(View(contact));
}
public async Task <ActionResult> Create(WebhookModel webhookModel)
{
if (ModelState.IsValid)
{
var salesforceService = new SalesforceService((ClaimsPrincipal)User, SignInManager);
await salesforceService.CreateSalesforceObjectsAsync(webhookModel);
return(RedirectToAction("Index"));
}
return(View(webhookModel));
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
string connectstr = System.Configuration.ConfigurationManager.AppSettings["MS_TableConnectionString"];
_context = new MobileServiceContext();
test = connectstr;
string t = test;
_salesforceService = new SalesforceService();
_domainEmployeeManager = new EntityDomainManager <Employee>(_context, Request, Services);
DomainManager = new EntityDomainManager <Ride>(_context, Request, Services);
}
public Task <List <T> > SalesforceRequest <T>(string soqlQuery)
{
var requestTask = SalesforceService
.MakeAuthenticatedClientRequestAsync(
async(client) =>
{
QueryResult <T> entities = await client
.QueryAsync <T>(soqlQuery);
return(entities.Records);
}
);
return(requestTask);
}
private static string GetAbsoluteRedirectUri()
{
Uri redirectUri;
Uri.TryCreate(SalesforceService.GetAppSetting("Salesforce:RedirectUri"), UriKind.RelativeOrAbsolute, out redirectUri);
if (redirectUri.IsAbsoluteUri)
{
return(redirectUri.ToString());
}
else
{
string uriAuthority = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority);
return(new Uri(new Uri(uriAuthority), redirectUri).ToString());
}
}
public async Task TestDeleteObject()
{
IConnector connector = new Connector(consumerKey, consumerSecret, userName,
passwordAndToken, false, log, jsonHttpClient, xmlHttpClient);
ISalesforceService salesforceService = new SalesforceService(connector, log);
dynamic lead = new ExpandoObject();
using (salesforceService)
{
lead = await salesforceService.GetObjectByExternalIdentifier("Lead", "Email", "*****@*****.**");
bool isDeleted = await salesforceService.DeleteObject(lead.Id, "Lead");
Assert.IsTrue(isDeleted);
}
}
public async Task TestGetObjectByQuery()
{
IConnector connector = new Connector(consumerKey, consumerSecret, userName,
passwordAndToken, false, log, jsonHttpClient, xmlHttpClient);
ISalesforceService salesforceService = new SalesforceService(connector, log);
string query = "SELECT Id, Name FROM Lead WHERE Company = 'Fake News Corp.'";
using (salesforceService)
{
dynamic lead = salesforceService.GetObjectByQuery(query).GetAwaiter().GetResult();
Assert.AreEqual(lead.Name, "Jim Robot");
lead = await salesforceService.GetObjectByIdentifier("Lead", lead.Id);
Assert.AreEqual(lead.FirstName, "Jim");
}
}
public async Task <IHttpActionResult> Get()
{
var client = await SalesforceService.GetUserNamePasswordForceClientAsync();
var contacts = await client.QueryAsync <Models.Contact>("SELECT id, FirstName, LastName, Email FROM Contact");
var sfContact = contacts.Records
.Select(c => new {
c.id,
c.FirstName,
c.LastName,
c.Email
});
return(Ok(sfContacts));
}
public async Task <ActionResult> LeadEdit(string id)
{
// Ensure the user is authenticated
if (!SalesforceService.IsUserLoggedIn())
{
// Should include a state argument to the URI so that when the dance is done, we can redirect to the page that we were requesting
string myUri = SalesforceOAuthRedirectHandler.AuthorizationUri.ToString() + "&state=" + this.Url.RequestContext.HttpContext.Request.RawUrl;
return(this.Redirect(myUri));
}
// Initalize the Force client
SalesforceService service = new SalesforceService();
ForceClient client = service.GetForceClient();
Lead lead = await client.QueryByIdAsync <Lead>("Lead", id);
return(View(lead));
}
public async Task TestInsertObject()
{
IConnector connector = new Connector(consumerKey, consumerSecret, userName,
passwordAndToken, false, log, jsonHttpClient, xmlHttpClient);
ISalesforceService salesforceService = new SalesforceService(connector, log);
dynamic lead = new ExpandoObject();
lead.FirstName = "Jim";
lead.LastName = "Robot";
lead.Email = "*****@*****.**";
lead.Company = "Fake News Inc.";
using (salesforceService)
{
bool isCreated = await salesforceService.InsertUpdateObject(lead, "Lead", "");
Assert.IsTrue(isCreated);
}
}
