public void CanCreateTaskForApprpriateClients()
{
var clientRepository = new LocalRepository <Client>();
var taskQueueStorage = new Mock <ITaskQueueStorage>();
var taskRepository = new LocalRepository <InsideModel.Models.Task>();
var serverTime = new Mock <IServerTime>();
var taskManager = new Mock <ITaskManager>();
var task = new CreateUpdatePhonecallsTasksForClients(
clientRepository,
taskQueueStorage.Object,
taskRepository,
serverTime.Object,
taskManager.Object);
clientRepository.Add(ModelHelper.TestClient1AllDataNoReferences);
clientRepository.Add(ModelHelper.TestClient2AllDataNoReferences);
var taskExecutionDate = new DateTime(2014, 01, 01);
serverTime.Setup(st => st.RequestStarted).Returns(taskExecutionDate);
var taskMessage = "{\"StartDate\":\"2014-01-01\",\"EndDate\":\"2014-02-01\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
taskQueueStorage.Verify(ts => ts.Add(It.Is <InsideModel.Models.Task>(t => t.Message == "{\"ClientId\":1,\"StartDate\":\"2014-01-01T00:00:00\",\"EndDate\":\"2014-02-01T00:00:00\"}")), Times.Exactly(1));
taskQueueStorage.Verify(ts => ts.Add(It.Is <InsideModel.Models.Task>(t => t.Message == "{\"ClientId\":3,\"StartDate\":\"2014-01-01T00:00:00\",\"EndDate\":\"2014-02-01T00:00:00\"}")), Times.Exactly(1));
}
public void NoPhoneCallsForDatePeriodDoesNotTranslateToAnyContact()
{
var clientRepository = new LocalRepository <Client>();
var externalDataProvider = new Mock <IExternalDataProvider>();
var contactRepository = new Mock <IRepository <Contact> >();
var contactAutoRating = new Mock <IContactAutoRating>();
clientRepository.Add(ModelHelper.TestClient1AllDataNoReferences);
var startDate = new DateTime(2014, 01, 01);
var endDate = new DateTime(2014, 02, 01);
externalDataProvider.Setup(x => x.GetPhoneData(1, startDate, endDate)).Returns("");
var task = new UpdatePhonecalls(
clientRepository,
contactRepository.Object,
externalDataProvider.Object,
contactAutoRating.Object);
var taskMessage = "{\"ClientId\":1,\"StartDate\":\"2014-01-01T00:00:00\",\"EndDate\":\"2014-02-01T00:00:00\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
externalDataProvider.Verify(x => x.MapPhoneDataToContact(It.IsAny <CallTrackingMetricsWebhookData>()), Times.Never);
contactRepository.Verify(cr => cr.Add(It.IsAny <Contact>()), Times.Never);
}
public void NoCtmIdThrowsException()
{
var clientRepository = new LocalRepository <Client>();
var externalDataProvider = new Mock <IExternalDataProvider>();
var contactRepository = new Mock <IRepository <Contact> >();
var contactAutoRating = new Mock <IContactAutoRating>();
clientRepository.Add(new Client()
{
Id = 1
});
var startDate = new DateTime(2014, 01, 01);
var endDate = new DateTime(2014, 02, 01);
externalDataProvider.Setup(x => x.GetPhoneData(1, startDate, endDate)).Returns("{\"calls\":[{\"id\": 1}, {\"id\": 2}],\"next_page\":null,\"previous_page\":null,\"total_pages\":1,\"page\":1}");
var task = new UpdatePhonecalls(
clientRepository,
contactRepository.Object,
externalDataProvider.Object,
contactAutoRating.Object);
var taskMessage = "{\"ClientId\":1,\"StartDate\":\"2014-01-01T00:00:00\",\"EndDate\":\"2014-02-01T00:00:00\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
externalDataProvider.Verify(x => x.MapPhoneDataToContact(It.IsAny <CallTrackingMetricsWebhookData>()), Times.Never);
contactRepository.Verify(cr => cr.Add(It.IsAny <Contact>()), Times.Never);
}
public void CanPerfomTaskForClientsTranslateAllCallsInData()
{
var clientRepository = new LocalRepository <Client>();
var externalDataProvider = new Mock <IExternalDataProvider>();
var contactRepository = new Mock <IRepository <Contact> >();
var contactAutoRating = new Mock <IContactAutoRating>();
clientRepository.Add(ModelHelper.TestClient1AllDataNoReferences);
var startDate = new DateTime(2014, 01, 01);
var endDate = new DateTime(2014, 02, 01);
externalDataProvider.Setup(x => x.GetPhoneData(1, startDate, endDate)).Returns("{\"calls\":[{\"id\": 1,\"account_id\":1}, {\"id\": 2,\"account_id\":1}],\"next_page\":null,\"previous_page\":null,\"total_pages\":1,\"page\":1}");
var task = new UpdatePhonecalls(
clientRepository,
contactRepository.Object,
externalDataProvider.Object,
contactAutoRating.Object);
var taskMessage = "{\"ClientId\":1,\"StartDate\":\"2014-01-01T00:00:00\",\"EndDate\":\"2014-02-01T00:00:00\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
externalDataProvider.Verify(x => x.MapPhoneDataToContact(It.Is <CallTrackingMetricsWebhookData>(ctm => ctm.id == 1)), Times.Once);
externalDataProvider.Verify(x => x.MapPhoneDataToContact(It.Is <CallTrackingMetricsWebhookData>(ctm => ctm.id == 2)), Times.Once);
contactRepository.Verify(cr => cr.Add(It.IsAny <Contact>()), Times.Exactly(2));
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var importDate = DateTime.UtcNow;
var beginingOfImportDate = importDate.Date;
var cutOffDate = beginingOfImportDate.AddDays(1);
Console.WriteLine("Begin import seo data");
var seoJson =
downloadManager.FetchUrl(
"http://serpbook.com/serp/api/?viewkey=63xc118&auth=aba2dfa3bdea8475e07d35a24a2b4bc6");
seoJson = seoJson.Replace("\"n\\/a\"", "\"null\"");
var seoPositions = JsonConvert.DeserializeObject(seoJson, typeof(IEnumerable <SearchEngineRank>)) as IEnumerable <SearchEngineRank>;
if (!serpRankingRepository.Any(s => s.Date >= beginingOfImportDate && s.Date < cutOffDate))
{
foreach (var searchPosition in seoPositions)
{
var serpRanking = serpRankingRepository.Create();
serpRanking.Date = importDate;
seoDataMapper.Map(searchPosition, serpRanking);
serpRankingRepository.Add(serpRanking);
}
serpRankingRepository.SaveChanges();
Console.WriteLine("Completed import seo data - Added " + seoPositions.Count() + " keywords",
"Information");
}
else
{
throw new Exception("Seo Data for " + importDate.ToString("yyyy-MM-dd") + " already exists");
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var createProductAnalyticTask = JsonConvert.DeserializeObject <TaskMessageWithStartDateAndEndDate>(taskMessage.Message);
var clients = clientRepository.Where(c => c.IsActive);
var dayOfExecution = serverTime.RequestStarted.Date;
var dayAfterExecution = serverTime.RequestStarted.AddDays(1).Date;
var addedTask = new List <InsideModel.Models.Task>();
var taskNum = 0;
foreach (var client in clients)
{
if (client.AnalyticsTableId.IsNullOrWhiteSpace())
{
continue;
}
var messageToAdd =
JsonConvert.SerializeObject(new ImportContactProductAnalyticDataTaskMessage()
{
ClientId = client.Id,
StartDate = createProductAnalyticTask.StartDate,
EndDate = createProductAnalyticTask.EndDate
});
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.AddProductAnalyticData, dayOfExecution,
dayAfterExecution))
{
taskNum++;
var earliestExecution = serverTime.RequestStarted + GetNextExecutionDelay(taskNum);;
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.AddProductAnalyticData, earliestExecution);
taskQueueStorage.Add(taskToAdd);
}
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var createUpdatePhoneCallTask = JsonConvert.DeserializeObject <UpdatePhonecallsTaskMesage>(taskMessage.Message);
var clients = clientRepository.Where(c => c.IsActive && c.CallTrackingMetricId != null);
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = serverTime.RequestStarted.AddDays(1).Date;
var addedTask = new List <InsideModel.Models.Task>();
foreach (var client in clients)
{
var messageToAdd =
JsonConvert.SerializeObject(new UpdatePhonecallsForClientsTaskMessage
{
ClientId = client.Id,
StartDate = createUpdatePhoneCallTask.StartDate,
EndDate = createUpdatePhoneCallTask.EndDate
});
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.UpdatePhonecalls, dayOfExecutionLowerBound,
dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.UpdatePhonecalls, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
}
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var contactProductTask =
JsonConvert.DeserializeObject <ImportEventsTaskMessage>(taskMessage.Message);
customEventsExtractor.ImportEvents(contactProductTask.ClientId, contactProductTask.StartDate, contactProductTask.EndDate);
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var sendEmailTask = JsonConvert.DeserializeObject <NotificationTaskMessage>(taskMessage.Message);
var contactId = sendEmailTask.ContactId;
var contactNotificationToSend = contactRepository.Where(c => c.Id == contactId)
.Include(l => l.Client);
if (!contactNotificationToSend.Any())
{
return;
}
var client = contactNotificationToSend.First().Client;
if (!client.IsActive)
{
return;
}
if (!client.Labels.Where(l => l.Name == "Helloypaket").Any())
{
return;
}
var notificationText = notificationPhoneTextBuilder.GetDefinition(contactId);
phoneNotificationSender.SendNotification(client.Id, notificationText);
}
private void PerformTask(InsideModel.Models.Task taskToPerform)
{
if (taskToPerform.Type == TaskType.CreateTaskForUsersToSendNewContactEmailNotification)
{
_notificationEmailSender.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.SendNewContactPhoneNotification)
{
phoneNotificationTaskPerformer.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.AddProductAnalyticData)
{
addAnalyticProductDataForClient.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.CreateAnalyticDataTasksForClients)
{
createAnalyticDataTasksForClients.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.ImportCustomEvents)
{
customEventsImporter.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.ImportSeoData)
{
seoDataImporter.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.SendNewContactEmailNotificationToUser)
{
userEmailSender.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.ImportCustomEventsTaskCreator)
{
importCustomEventsTaskCreator.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.RemoveExpiredTokens)
{
removeExpiredTokens.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.CreateUpdatePhonecallsTasksForClients)
{
updatePhonecallsTaskCreator.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.UpdatePhonecalls)
{
updatePhonecalls.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.CreateTaskForUsersToSendNewContactSmsNotification)
{
smsNotificationTaskCreator.PerformTask(taskToPerform);
}
else if (taskToPerform.Type == TaskType.SendNewContactSmsNotificationToUser)
{
userSmsNotificationTaskPerformer.PerformTask(taskToPerform);
}
else
{
throw new Exception("Unknown task type: " + taskToPerform.Type);
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var contactProductTask =
JsonConvert.DeserializeObject <ImportContactProductAnalyticDataTaskMessage>(taskMessage.Message);
analyticsDataExtractor.UpdateContact(contactProductTask.ClientId, contactProductTask.StartDate,
contactProductTask.EndDate);
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var sendSmsToUserTask = JsonConvert.DeserializeObject <UserSpecificSmsNotificationTaskMessage>(taskMessage.Message);
var user = userRepository.Single(u => u.Id == sendSmsToUserTask.UserId);
var defintion = smsDefinitionBuilder.GetDefinition(sendSmsToUserTask.ContactId, sendSmsToUserTask.UserId);
if (defintion != null)
{
smsSender.SendSms(user.Phone, defintion);
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var sendEmailToUserTask = JsonConvert.DeserializeObject <UserSpecificNotificationTaskMessage>(taskMessage.Message);
var defintion = notificationEmailDefinitionBuilder.GetDefinition(sendEmailToUserTask.ContactId, sendEmailToUserTask.UserId);
if (defintion != null)
{
SendEmail(defintion);
}
}
public void CanCreateTaskForActiveClientsWithAnalyticId()
{
var clientRepository = new LocalRepository <Client>();
var taskQueueStorage = new Mock <ITaskQueueStorage>();
var taskRepository = new LocalRepository <InsideModel.Models.Task>();
var serverTime = new Mock <IServerTime>();
var taskManagere = new Mock <ITaskManager>();
var task = new CreateAnalyticDataTasksForClients(
clientRepository,
taskQueueStorage.Object,
taskRepository,
serverTime.Object, taskManagere.Object);
var client1 = new Client()
{
Id = 1,
IsActive = true,
AnalyticsTableId = "SomeId"
};
var client2 = new Client()
{
Id = 2,
IsActive = true,
AnalyticsTableId = "SomeId"
};
clientRepository.Add(client1);
clientRepository.Add(client2);
var taskExecutionDate = new DateTime(2014, 01, 01);
serverTime.Setup(st => st.RequestStarted).Returns(taskExecutionDate);
var taskMessage = "{\"StartDate\":\"2013-12-30\",\"EndDate\":\"2014-01-02\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
//Assert.AreEqual(2, taskRepository.All().Count());
taskQueueStorage.Verify(ts => ts.Add(It.Is <InsideModel.Models.Task>(t => t.Message == "{\"ClientId\":1,\"StartDate\":\"2013-12-30T00:00:00\",\"EndDate\":\"2014-01-02T00:00:00\"}" && t.Type == "AddProductAnalyticData")), Times.Exactly(1));
taskQueueStorage.Verify(ts => ts.Add(It.Is <InsideModel.Models.Task>(t => t.Message == "{\"ClientId\":2,\"StartDate\":\"2013-12-30T00:00:00\",\"EndDate\":\"2014-01-02T00:00:00\"}" && t.Type == "AddProductAnalyticData")), Times.Exactly(1));
}
public void ContactInDbDoesNotAddContactModifiesState()
{
var clientRepository = new LocalRepository <Client>();
var externalDataProvider = new Mock <IExternalDataProvider>();
var contactRepository = new LocalRepository <Contact>();
var contactAutoRating = new Mock <IContactAutoRating>();
clientRepository.Add(ModelHelper.TestClient1AllDataNoReferences);
var contactProperty = new ContactProperty("CTMId", "1");
var contact = new Contact()
{
Id = 1,
ClientId = 1
};
contact.Property.Add(contactProperty);
contactRepository.Add(contact);
var startDate = new DateTime(2014, 01, 01);
var endDate = new DateTime(2014, 02, 01);
externalDataProvider.Setup(x => x.GetPhoneData(1, startDate, endDate)).Returns("{\"calls\":[{\"id\": 1,\"account_id\":1}, {\"id\": 2,\"account_id\":1}],\"next_page\":null,\"previous_page\":null,\"total_pages\":1,\"page\":1}");
var task = new UpdatePhonecalls(
clientRepository,
contactRepository,
externalDataProvider.Object,
contactAutoRating.Object);
var taskMessage = "{\"ClientId\":1,\"StartDate\":\"2014-01-01T00:00:00\",\"EndDate\":\"2014-02-01T00:00:00\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
externalDataProvider.Verify(x => x.MapPhoneDataToContact(It.IsAny <CallTrackingMetricsWebhookData>()), Times.Once);
externalDataProvider.Verify(x => x.MapPhoneDataToContact(It.IsAny <CallTrackingMetricsWebhookData>(), It.IsAny <Contact>()), Times.Once);
Assert.AreEqual(2, contactRepository.All().Count());
}
public void NotifyClientsForNewContactWithPhoneNotification(int contactId)
{
var addedTask = new List <InsideModel.Models.Task>();
var messageToAdd =
JsonConvert.SerializeObject(new NewContactTaskMessage()
{
ContactId = contactId
});
var dayOfExecution = serverTime.RequestStarted;
var hasTaskInRepository = taskRepository.Where(tr => tr.Message == messageToAdd &&
dayOfExecution == tr.EarliestExecution &&
tr.Type == TaskType.SendNewContactPhoneNotification).Any();
if (!hasTaskInRepository)
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.SendNewContactPhoneNotification,
serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
}
}
public void NoTaskCreatedForInactiveClientsOrClientsWithNoTrackingId()
{
var clientRepository = new LocalRepository <Client>();
var taskQueueStorage = new Mock <ITaskQueueStorage>();
var taskRepository = new LocalRepository <InsideModel.Models.Task>();
var serverTime = new Mock <IServerTime>();
var taskManager = new Mock <ITaskManager>();
var task = new CreateUpdatePhonecallsTasksForClients(
clientRepository,
taskQueueStorage.Object,
taskRepository,
serverTime.Object,
taskManager.Object);
clientRepository.Add(new Client()
{
IsActive = false,
CallTrackingMetricId = 1
});
clientRepository.Add(new Client()
{
IsActive = true,
});
var taskExecutionDate = new DateTime(2014, 01, 01);
serverTime.Setup(st => st.RequestStarted).Returns(taskExecutionDate);
var taskMessage = "{\"StartDate\":\"2014-01-01\",\"EndDate\":\"2014-02-01\"}";
var message = new InsideModel.Models.Task()
{
Message = taskMessage
};
task.PerformTask(message);
Assert.AreEqual(0, taskRepository.All().Count());
taskQueueStorage.Verify(ts => ts.Add(It.IsAny <InsideModel.Models.Task>()), Times.Never);
}
private bool IsTaskToTry(InsideModel.Models.Task taskToCheck)
{
if (taskToCheck.NumTries <= 0)
{
return(true);
}
if (taskToCheck.Type == TaskType.AddProductAnalyticData)
{
if (taskToCheck.NumTries >= 3)
{
return(false);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = dayOfExecutionLowerBound.AddDays(1);
var clientsForImporting =
clientRepository.Where(cr => cr.IsActive && cr.Labels.Any(l => l.Name == "Custom Event")).ToList();
var addedTask = new List <InsideModel.Models.Task>();
foreach (var client in clientsForImporting)
{
if (client.AnalyticsTableId.IsNullOrWhiteSpace())
{
continue;
}
var endDate = serverTime.RequestStarted;
var startDate = endDate.AddDays(-3);
var clientId = client.Id;
var createTaskForImportingWebEvents = new ImportEventsTaskMessage()
{
ClientId = clientId,
StartDate = startDate.Date,
EndDate = endDate.Date
};
var messageToAdd = JsonConvert.SerializeObject(createTaskForImportingWebEvents);
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.ImportCustomEvents,
dayOfExecutionLowerBound, dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.ImportCustomEvents, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
}
else
{
throw new Exception("Task Already in Database: " + messageToAdd);
}
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var sendSmsTask = JsonConvert.DeserializeObject <SmsNotificationTaskMessage>(taskMessage.Message);
if (!IsContactValidToSend(sendSmsTask.ContactId))
{
return;
}
var users =
contactRepository.First(c => c.Id == sendSmsTask.ContactId)
.Client.InsideUserSets.Where(u => u.ReceiveSms != null && (bool)u.ReceiveSms && !string.IsNullOrEmpty(u.Phone)).ToList();
if (!users.Any())
{
return;
}
var dayOfExecution = serverTime.RequestStarted.Date;
var dayAfterExecution = serverTime.RequestStarted.AddDays(1).Date;
var addedTask = new List <InsideModel.Models.Task>();
foreach (var insideUser in users)
{
var createTaskForUserSpecificNotification = new UserSpecificSmsNotificationTaskMessage()
{
ContactId = sendSmsTask.ContactId,
UserId = insideUser.Id
};
var messageToAdd = JsonConvert.SerializeObject(createTaskForUserSpecificNotification);
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.SendNewContactSmsNotificationToUser, dayOfExecution,
dayAfterExecution))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.SendNewContactSmsNotificationToUser, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
}
}
}
public ActionResult Create(string type)
{
if (type == "CreateAnalyticDataTasksForClients")
{
var endDate = serverTime.RequestStarted;
var startDate = endDate.AddDays(-2);
var createTaskForProductAnalyticTaskMessage = new TaskMessageWithStartDateAndEndDate()
{
StartDate = startDate.Date,
EndDate = endDate.Date
};
var messageToAdd = JsonConvert.SerializeObject(createTaskForProductAnalyticTaskMessage);
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = dayOfExecutionLowerBound.AddDays(1);
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.CreateAnalyticDataTasksForClients,
dayOfExecutionLowerBound, dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.CreateAnalyticDataTasksForClients, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
return
(Content("Successfully Created task: CreateAnalyticDataTasksForClients"));
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Task Already in Database: " + messageToAdd));
}
}
else if (type == "ImportCustomEvents")
{
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = dayOfExecutionLowerBound.AddDays(1);
var messageToAdd = "";
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.ImportCustomEventsTaskCreator,
dayOfExecutionLowerBound, dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.ImportCustomEventsTaskCreator, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Task Already in Database"));
}
return
(Content("Successfully Created task: ImportCustomEventsTaskCreator"));
}
else if (type == "ImportSeoData")
{
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = dayOfExecutionLowerBound.AddDays(1);
var messageToAdd = "";
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.ImportSeoData,
dayOfExecutionLowerBound, dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.ImportSeoData, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
return
(Content("Successfully Created task: ImportSeoData"));
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Task Already in Database"));
}
}
else if (type == "RemoveExpiredTokens")
{
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = dayOfExecutionLowerBound.AddDays(1);
var messageToAdd = "";
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.RemoveExpiredTokens,
dayOfExecutionLowerBound, dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.RemoveExpiredTokens, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
return
(Content("Successfully Created task: RemoveExpiredTokens"));
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Task Already in Database"));
}
}
else if (type == "UpdatePhoneCalls")
{
var endDate = serverTime.RequestStarted;
var startDate = endDate.AddDays(-10);
var createTaskForUpdatePhoneCallsTaskMessage = new UpdatePhonecallsTaskMesage()
{
StartDate = startDate.Date,
EndDate = endDate.Date
};
var messageToAdd = JsonConvert.SerializeObject(createTaskForUpdatePhoneCallsTaskMessage);
var dayOfExecutionLowerBound = serverTime.RequestStarted.Date;
var dayOfExecutionUpperBound = dayOfExecutionLowerBound.AddDays(1);
if (!taskManager.HasTaskInRepository(messageToAdd, TaskType.CreateUpdatePhonecallsTasksForClients,
dayOfExecutionLowerBound, dayOfExecutionUpperBound))
{
var taskToAdd = new InsideModel.Models.Task(messageToAdd, TaskType.CreateUpdatePhonecallsTasksForClients, serverTime.RequestStarted);
taskQueueStorage.Add(taskToAdd);
return
(Content("Successfully Created task: CreateUpdatePhonecallsTasksForClients"));
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Task Already in Database: " + messageToAdd));
}
}
else
{
HttpContext.Response.StatusDescription = "BadRequest";
HttpContext.Response.StatusCode = 400;
return(Content("No Task Created"));
}
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
var updatePhoneCallsMessage =
JsonConvert.DeserializeObject <UpdatePhonecallsForClientsTaskMessage>(taskMessage.Message);
var callTrackingMetricsId =
clientRepository.Single(c => c.Id == updatePhoneCallsMessage.ClientId).CallTrackingMetricId;
if (callTrackingMetricsId == null)
{
throw new Exception("No Call tracking metrics Id found for client:" + updatePhoneCallsMessage.ClientId);
}
string pageUrl = null;
CtmData phoneData;
do
{
string phoneDataString;
if (pageUrl == null)
{
phoneDataString = externalDataProvider.GetPhoneData((int)callTrackingMetricsId,
updatePhoneCallsMessage.StartDate, updatePhoneCallsMessage.EndDate);
}
else
{
phoneDataString = externalDataProvider.GetPhoneData(pageUrl);
}
if (phoneDataString.IsNullOrWhiteSpace())
{
return;
}
phoneData = JsonConvert.DeserializeObject <CtmData>(phoneDataString);
foreach (var call in phoneData.calls)
{
var hasCallInDb = contactRepository.Where(l => l.Property.Any(lp => lp.Type == "CTMId" && lp.Value == call.id.ToString())).Any();
if (hasCallInDb)
{
var contactToUpdate =
contactRepository.Single(
l => l.Property.Any(lp => lp.Type == "CTMId" && lp.Value == call.id.ToString()));
externalDataProvider.MapPhoneDataToContact(call, contactToUpdate);
contactAutoRating.SetAutoRating(contactToUpdate);
}
else
{
var hasMatchingClient = clientRepository.Where(c => c.CallTrackingMetricId == call.account_id).Any();
if (!hasMatchingClient)
{
throw new Exception("Recived ctm webhook data. Found no matching client for given account id: " + call.account_id);
}
var contact = externalDataProvider.MapPhoneDataToContact(call);
contactAutoRating.SetAutoRating(contact);
contactRepository.Add(contact);
}
}
contactRepository.SaveChanges();
pageUrl = phoneData.next_page;
} while (!phoneData.next_page.IsNullOrWhiteSpace());
}
public void PerformTask(InsideModel.Models.Task taskMessage)
{
accessTokenProvider.RemoveExpired();
Console.WriteLine("Finished Cleaning");
}
