public static async Task <dynamic> GetAllLists(HttpClient client, Queue <string> folderIDs)
{
Queue <List> allLists = new Queue <List>();
while (folderIDs.Count > 0)
{
string uri = $"{ConfigDictionary.Config()["ClickUpAPIURLRoot"]}/folder/{folderIDs.Dequeue()}/list?archived=false";
try
{
HttpResponseMessage response = await client.GetAsync(uri);
string responseData = await response.Content.ReadAsStringAsync();
ListsRoot listsRoot = JsonConvert.DeserializeObject <ListsRoot>(responseData);
for (int i = 0; i < listsRoot.Lists.Count; i++)
{
allLists.Enqueue(listsRoot.Lists[i]);
}
}
catch (HttpRequestException ex)
{
return(ex);
}
}
return(allLists);
}
public static async Task <dynamic> GetAllFolders(HttpClient client)
{
Queue <string> uris = new Queue <string>(2);
List <Folder> allFolders = new List <Folder>();
string clickUpAPIURLRoot = ConfigDictionary.Config()["ClickUpAPIURLRoot"];
uris.Enqueue($"{clickUpAPIURLRoot}/space/{ConfigDictionary.Config()["ClickUpProjectsSpaceID"]}/folder?archived=false");
uris.Enqueue($"{clickUpAPIURLRoot}/space/{ConfigDictionary.Config()["ClickUpRetainersSpaceID"]}/folder?archived=false");
try
{
while (uris.Count > 0)
{
HttpResponseMessage response = await client.GetAsync(uris.Dequeue());
string responseData = await response.Content.ReadAsStringAsync();
FoldersRoot folders = JsonConvert.DeserializeObject <FoldersRoot>(responseData);
for (int i = 0; i < folders.Folders.Count; i++)
{
allFolders.Add(folders.Folders[i]);
}
}
return(allFolders);
}
catch (HttpRequestException ex)
{
return(ex);
}
}
public async Task <dynamic> Get(string companyName)
{
if (CheckClientSecret())
{
using (HttpClient client = new HttpClient())
using (Entities db = new Entities())
{
client.DefaultRequestHeaders.Add("Authorization", ConfigDictionary.Config()["ClickUpAPIKey"]);
Queue <string> folderIDs = await Folders.ReturnFolderID(client, companyName, db);
if (folderIDs.Any())
{
Queue <string> listIDs = await Lists.ReturnListIDs(client, folderIDs);
if (listIDs.Any())
{
return(await Tasks.GetAllTasks(client, listIDs));
}
else
{
return(new ArgumentException("No lists found"));
}
}
else
{
return(new ArgumentException($"No folders found for the company: {companyName}"));
}
}
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden));
}
}
private bool CheckClientSecret()
{
IEnumerable <string> headerValuesClientSecret;
IEnumerable <string> headerValuesClientID;
if (Request
.Headers
.TryGetValues("client-secret", out headerValuesClientSecret) &&
Request
.Headers
.TryGetValues("client-id", out headerValuesClientID))
{
if (string.Equals(headerValuesClientSecret.FirstOrDefault(), ConfigDictionary.Config()["ClientSecret"]) &&
string.Equals(headerValuesClientID.FirstOrDefault(), ConfigDictionary.Config()["ClientID"]))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public static async Task <dynamic> GetContacts(HttpClient client, CompanyRoot.Result company)
{
List <Filter> filters = new List <Filter>();
Filter nameFilter = new Filter("associatedcompanyid", "EQ", company.Id);
filters.Add(nameFilter);
string[] searchProps = new string[] { "firstname", "lastname", "email", "phone" };
RequestBody search = new RequestBody(filters, searchProps.ToList());
string searchJson = JsonConvert.SerializeObject(search);
StringContent searchData = new StringContent(searchJson, Encoding.UTF8, "application/json");
string uri = $"{ConfigDictionary.Config()["HubSpotAPIURLRoot"]}/contacts/search?hapikey={ConfigDictionary.Config()["HubSpotAPIKey"]}";
try
{
HttpResponseMessage response = await client.PostAsync(uri, searchData);
string responseData = await response.Content.ReadAsStringAsync();
ContactRoot.Contact contactsData = JsonConvert.DeserializeObject <ContactRoot.Contact>(responseData);
return(contactsData);
}
catch (HttpRequestException ex)
{
return(ex);
}
}
public static async Task <dynamic> GetAllCampaigns(string companyName, Entities db, HttpClient client)
{
string alias;
try
{
alias = AliasMethods.GetAlias(companyName, db, "FacebookAdAccountID");
}
catch
{
return(new ArgumentException($"No HubSpot alias found for the company name {companyName}"));
}
string url = $"{ConfigDictionary.Config()["FacebookAPIURLRoot"]}/{ConfigDictionary.Config()["FacebookAPIVersion"]}/act_{alias}/campaigns?access_token={ConfigDictionary.Config()["FacebookAccessToken"]}";
try
{
HttpResponseMessage response = await client.GetAsync(url);
string responseData = await response.Content.ReadAsStringAsync();
AllCampaignsRoot allCampaignsRoot = JsonConvert.DeserializeObject <AllCampaignsRoot>(responseData);
return(allCampaignsRoot);
}
catch (HttpRequestException ex)
{
return(ex);
}
}
public async Task <dynamic> Get(string companyName)
{
if (CheckClientSecret())
{
using (HttpClient client = new HttpClient())
using (Entities db = new Entities())
{
if (db.StoreCustomDatas.Any(x => x.StoreName == companyName) &&
db.StoreCustomDatas.FirstOrDefault(x => x.StoreName == companyName).ShopifyID != null)
{
StoreCustomData store = db.StoreCustomDatas.FirstOrDefault(x => x.StoreName == companyName);
ShopifyCredential credentials = db
.ShopifyCredentials
.Where(x => x.ID == store.ShopifyID)
.FirstOrDefault();
client.DefaultRequestHeaders.Add("X-Shopify-Access-Token", credentials.Password);
string shopifyAPIVersion = ConfigDictionary.Config()["ShopifyAdminAPIVersion"];
DateTimeOffset thisMonth = new DateTimeOffset(DateTime.UtcNow.Year, DateTime.UtcNow.Month, 1, 0, 0, 0, TimeSpan.Zero);
DateTimeOffset lastMonth = thisMonth.AddMonths(-1);
DateTimeOffset monthBeforeLast = thisMonth.AddMonths(-2);
try
{
int?ordersThisMonth = await OrdersMethods.OrdersCount(client, credentials.HostName, shopifyAPIVersion, thisMonth.ToString("yyyy-MM-ddTHH:mm:ss zzz"));
int?ordersLastMonth = await OrdersMethods.OrdersCount(client, credentials.HostName, shopifyAPIVersion, lastMonth.ToString("yyyy-MM-ddTHH:mm:ss zzz"));
int?ordersMonthBeforeLast = await OrdersMethods.OrdersCount(client, credentials.HostName, shopifyAPIVersion, monthBeforeLast.ToString("yyyy-MM-ddTHH:mm:ss zzz"));
return(new OrdersCountDTO(ordersThisMonth, ordersLastMonth, ordersMonthBeforeLast));
}
catch (Exception ex)
{
return(ex);
}
}
else
{
return(new ArgumentException($"No store was found with the name {companyName}"));
}
}
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden));
}
}
public async Task <dynamic> Get(string companyName)
{
if (CheckClientSecret())
{
using (HttpClient client = new HttpClient())
using (Entities db = new Entities())
{
client.DefaultRequestHeaders.Add("X-Api-Key", ConfigDictionary.Config()["EverHourAPIKey"]);
return(await Projects.GetProject(companyName, client, db));
}
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden));
}
}
public async Task <dynamic> GetAllTasks(HttpClient client, string projectID)
{
string url = ConfigDictionary.Config()["BugHerdURLRoot"] + $"/projects/{projectID}/tasks.json";
try
{
HttpResponseMessage response = await client.GetAsync(url);
string responseData = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <TasksRoot>(responseData));
}
catch
{
return(null);
}
}
public static async Task <dynamic> GetCampaignInsights(string campaignID, HttpClient client)
{
string url = $"{ConfigDictionary.Config()["FacebookAPIURLRoot"]}/{ConfigDictionary.Config()["FacebookAPIVersion"]}/{campaignID}/insights?date_preset=this_month&access_token={ConfigDictionary.Config()["FacebookAccessToken"]}";
try
{
HttpResponseMessage response = await client.GetAsync(url);
string responseData = await response.Content.ReadAsStringAsync();
InsightsRoot insightsRoot = JsonConvert.DeserializeObject <InsightsRoot>(responseData);
return(insightsRoot);
}
catch (Exception ex)
{
return(ex);
}
}
public static async Task <dynamic> GetHubSpotInfo(HttpClient client, Entities db, string companyName, string[] searchProps)
{
string alias;
try
{
alias = AliasMethods.GetAlias(companyName, db, "HubSpot");
}
catch
{
return(new ArgumentException($"No HubSpot alias found for the company name {companyName}"));
}
List <Filter> filters = new List <Filter>();
Filter nameFilter = new Filter("name", "EQ", alias);
filters.Add(nameFilter);
RequestBody search = new RequestBody(filters, searchProps.ToList());
string searchJson = JsonConvert.SerializeObject(search);
StringContent searchData = new StringContent(searchJson, Encoding.UTF8, "application/json");
string uri = $"{ConfigDictionary.Config()["HubSpotAPIURLRoot"]}/companies/search?hapikey={ConfigDictionary.Config()["HubSpotAPIKey"]}";
try
{
HttpResponseMessage response = await client.PostAsync(uri, searchData);
string responseData = await response.Content.ReadAsStringAsync();
CompanyRoot.Company companyData = JsonConvert.DeserializeObject <CompanyRoot.Company>(responseData);
return(companyData);
}
catch (HttpRequestException ex)
{
return(ex);
}
}
public async Task <dynamic> GetProjectID(string companyName, HttpClient client, Entities db)
{
try
{
string alias = AliasMethods.GetAlias(companyName, db, "BugHerd");
string uri = $"{ConfigDictionary.Config()["BugHerdURLRoot"]}/projects/active.json";
HttpResponseMessage response = await client.GetAsync(uri);
string responseData = await response.Content.ReadAsStringAsync();
ProjectsRoot allProjects = JsonConvert.DeserializeObject <ProjectsRoot>(responseData);
return(allProjects.Projects.FirstOrDefault(x => x.Name == alias).ID);
}
catch
{
return(null);
}
}
public static async Task <dynamic> GetProject(string companyName, HttpClient client, Entities db)
{
try
{
string alias = AliasMethods.GetAlias(companyName, db, "Everhour");
string uri = ConfigDictionary.Config()["EverHourURLRoot"] + $"/projects?query={alias}";
HttpResponseMessage response = await client.GetAsync(uri);
string responseData = await response.Content.ReadAsStringAsync();
ProjectRoot projectRoot = JsonConvert.DeserializeObject <List <ProjectRoot> >(responseData).FirstOrDefault();
return(new ProjectDTO(projectRoot));
}
catch (Exception ex)
{
return(ex);
}
}
public async Task <dynamic> Get(string companyName)
{
if (CheckClientSecret())
{
using (HttpClient client = new HttpClient())
{
string username = ConfigDictionary.Config()["BugHerdAPIKey"];
string password = ConfigDictionary.Config()["BugHerdAPIPassword"];
byte[] authToken = Encoding.ASCII.GetBytes($"{username}:{password}");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authToken));
string projectID = await projectsMethods.GetProjectID(companyName, client, db);
if (!string.IsNullOrEmpty(projectID))
{
try
{
return(await tasksMethods.GetAllTasks(client, projectID));
}
catch (Exception ex)
{
return(ex);
}
}
else
{
return(new ArgumentException($"No projects found for the company: {companyName}"));
}
}
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden));
}
}
public static async Task <dynamic> GetAllTasks(HttpClient client, Queue <string> listIDs)
{
List <TaskDTO> allTasks = new List <TaskDTO>();
try
{
while (listIDs.Count > 0)
{
string uri = $"{ConfigDictionary.Config()["ClickUpAPIURLRoot"]}/list/{listIDs.Dequeue()}/task?archived=false";
try
{
HttpResponseMessage response = await client.GetAsync(uri);
string responseData = await response.Content.ReadAsStringAsync();
TasksRoot tasks = JsonConvert.DeserializeObject <TasksRoot>(responseData);
for (int i = 0; i < tasks.Tasks.Count; i++)
{
allTasks.Add(new TaskDTO(tasks.Tasks[i]));
}
}
catch
{
throw;
}
}
return(allTasks);
}
catch (Exception ex)
{
return(ex);
}
}
public async Task <dynamic> Get(string companyName)
{
DateTime operationStarted = DateTime.Now;
using (HttpClient client = new HttpClient())
using (Entities db = new Entities())
{
var result = await BulkAction.PerformBulkAction(client, companyName, db, ConfigDictionary.Config()["ShopifyAdminAPIVersion"]);
if (Equals(result.GetType(), typeof(string)))
{
return(BulkAction.WriteSalesData(result,
db
.StoreCustomDatas
.Where(x => x.StoreName == companyName)
.FirstOrDefault()
.StoreID,
db,
operationStarted));
}
else
{
return(result);
}
}
}
public async Task <dynamic> Get(string companyName)
{
if (CheckClientSecret())
{
DateTime operationStarted = DateTime.Now;
Entities db = new Entities();
using (HttpClient client = new HttpClient())
{
var result = await BulkAction.PerformBulkAction(client, companyName, db, ConfigDictionary.Config()["ShopifyAdminAPIVersion"]);
if (Equals(result.GetType(), typeof(string)))
{
StoreCustomData store = db.StoreCustomDatas.FirstOrDefault(x => x.StoreName == companyName);
var dbResult = BulkAction.WriteSalesData(result,
store.StoreID,
db,
operationStarted);
if (!Equals(dbResult.GetType(), typeof(Exception)))
{
return(db.SalesDatas.Where(x => x.StoreID == store.StoreID).OrderBy(x => x.Date));
}
else
{
return(new ArgumentException("An error occurred while writing to the database."));
}
}
else
{
return(result);
}
}
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden));
}
}
public static async Task <EngagementsRoot> ChainedEngagementsRequest(EngagementsRoot engagementsData, string companyID, HttpClient client)
{
string uri = $"https://api.hubapi.com/engagements/v1/engagements/associated/COMPANY/{companyID}/paged?limit=100&offset={engagementsData.Offset}&hapikey=" + ConfigDictionary.Config()["HubSpotAPIKey"];
HttpResponseMessage response = await client.GetAsync(uri);
string responseData = await response.Content.ReadAsStringAsync();
engagementsData = JsonConvert.DeserializeObject <EngagementsRoot>(responseData);
return(engagementsData);
}
public static async Task <dynamic> GetEngagements(HttpClient client, string companyName, Entities db, string companyID)
{
string alias;
try
{
alias = AliasMethods.GetAlias(companyName, db, "HubSpot");
}
catch
{
return(new ArgumentException($"No HubSpot alias found for the company name {companyName}"));
}
string uri = $"https://api.hubapi.com/engagements/v1/engagements/associated/COMPANY/{companyID}/paged?limit=100&hapikey=" + ConfigDictionary.Config()["HubSpotAPIKey"];
try
{
HttpResponseMessage response = await client.GetAsync(uri);
string responseData = await response.Content.ReadAsStringAsync();
EngagementsRoot engagementsData = JsonConvert.DeserializeObject <EngagementsRoot>(responseData);
while (engagementsData.HasMore)
{
engagementsData = await ChainedEngagementsRequest(engagementsData, companyID, client);
}
return(engagementsData);
}
catch (HttpRequestException ex)
{
return(ex);
}
}