public bool UpdateMessage(ScheduleMessage model)
{
bool result = false;
try
{
_context.SaveChanges();
result = true;
}
catch (Exception ex)
{
result = false;
}
return(result);
}
public async Task ScheduleBack(ScrapySource source, PlatformModel platformModel, List <string> urls, ScheduleMessage scheduleMessage)
{
HttpSource httpSource = JsonConvert.DeserializeObject <HttpSource>(source.Source.Parameters.ToString());
if (httpSource.Layer > 0)
{
var transforms = scheduleMessage.Transforms
.Where(x => x.MapToSource.Contains(source.Name))
.Select(x => { x.MapToSource = new string[] { source.Name }; return(x); })
.ToArray();
var scheduleSource = scheduleMessage.Sources.Where(x => x.Name == source.Name).First();
var loadMaps = scheduleMessage.LandingTargets.LoadMaps
.Where(x => transforms.Any(y => y.Name == x.FromTransform))
.ToArray();
WebSeed webSeed = JsonConvert.DeserializeObject <WebSeed>(scheduleSource.Parameters.ToString());
foreach (var url in urls)
{
webSeed.SeedUrl = url;
webSeed.Depth = httpSource.Layer - 1;
scheduleSource.Parameters = webSeed;
ScheduleMessage subSchedule = new ScheduleMessage()
{
MessageId = scheduleMessage.MessageId,
Sources = new ScheduleSource[] { scheduleSource },
Transforms = transforms,
LandingTargets = new ScheduleLoad()
{
LoadProviders = scheduleMessage.LandingTargets.LoadProviders,
LoadMaps = loadMaps
},
MessageName = scheduleMessage.MessageName,
Scheduler = scheduleMessage.Scheduler
};
await Task.Delay(sendRate);
await ScheduleNew(subSchedule, platformModel);
}
}
}
public async Task ScheduleNew(ScheduleMessage scheduleMessage, PlatformModel platformModel)
{
Dictionary <string, ScrapySource> sourceDict =
SourceGenManager.Instance.GenerateSource(scheduleMessage.Sources, scheduleMessage.MessageId);
TransformEventData transformEventData =
TransformGenManager.Instance.GenerateTransform(sourceDict, scheduleMessage.Transforms);
LoadEventData loadEventData = LoadGenManager.Instance
.GenerateLoadEvent(transformEventData, scheduleMessage.LandingTargets);
MessageIndexer messageIndexer = new MessageIndexer()
{
MessageId = scheduleMessage.MessageId,
MessageName = scheduleMessage.MessageName,
StartTime = DateTime.Now,
SourceJobIds = sourceDict.Values
.Select(x => x.JobId).ToDictionary(x => x, x => 0),
TransformJobIds = transformEventData.TransformEvents
.SelectMany(x => x.Value)
.Select(x => x.JobId)
.ToDictionary(x => x, x => 0),
LoadJobIds = loadEventData.LoadEvents
.Select(x => x.JobId)
.ToDictionary(x => x, x => 0)
};
TaskingManager manager = new TaskingManager();
manager.AddTask(platformModel.CoreCache.StoreAsync(PrefixConst.MESSAGE_JOBs + messageIndexer.MessageId, messageIndexer));
foreach (var srcKey in transformEventData.SourceMapToTransform.Keys)
{
manager.AddTask(platformModel.CoreCache.StoreAsync(
PrefixConst.SOURCE_TRANSFOR_MAP + srcKey,
transformEventData.SourceMapToTransform[srcKey]));
}
foreach (var transkv in loadEventData.TransformToLoadMap)
{
manager.AddTask(platformModel.CoreCache.StoreStringAsync(
PrefixConst.TRANSFORM_LOAD_MAP + transkv.Key, transkv.Value));
}
foreach (var source in sourceDict.Values)
{
manager.AddTask(platformModel.CoreCache.StoreAsync(
PrefixConst.SOURCE_META + source.JobId,
source));
}
foreach (var transform in transformEventData.TransformEvents.SelectMany(x => x.Value))
{
manager.AddTask(platformModel.CoreCache.StoreAsync(
PrefixConst.TRANSFORM_META + transform.JobId, transform));
}
foreach (var load in loadEventData.LoadEvents)
{
manager.AddTask(platformModel.CoreCache.StoreAsync(
PrefixConst.LOAD_META + load.JobId, load));
}
await manager.WhenAll();
await PublishSourceJobs(
scheduleMessage.MessageName,
scheduleMessage.MessageId,
platformModel.PlatformExit,
messageIndexer.SourceJobIds.Keys.ToArray());
}
public Task ScheduleNew(ScheduleMessage scheduleMessage)
{
throw new NotImplementedException();
}
public ActionResult Index(HttpPostedFileBase postedFile)
{
string filePath = string.Empty;
if (postedFile != null)
{
string path = Server.MapPath("~/Uploads/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
filePath = path + Path.GetFileName(postedFile.FileName);
string extension = Path.GetExtension(postedFile.FileName);
postedFile.SaveAs(filePath);
//Create a DataTable.
DataTable dt = new DataTable();
dt = ConvertCSVtoDataTable(filePath, true);
DevinTwilioEntities db = new DevinTwilioEntities();
try
{
for (int i = 0; i < dt.Rows.Count; i++)
{
int?TriggerTypeID = null;
int?TriggerEventID = null;
int?TriggerID = null;
int?MMDomainID = null;
int?MMSubDomainID = null;
string TriggerType = Convert.ToString(dt.Rows[i]["Trigger Type"]);
if (!string.IsNullOrEmpty(TriggerType))
{
var TriggerTypeDetail = db.TriggerTypes.Where(m => m.TriggerType_Type == TriggerType).FirstOrDefault();
if (TriggerTypeDetail != null)
{
TriggerTypeID = TriggerTypeDetail.TriggerType_ID;
}
}
string TriggerEventDay = Convert.ToString(dt.Rows[i]["Trigger Event"]);
if (!string.IsNullOrEmpty(TriggerEventDay) && TriggerTypeID != null && TriggerTypeID > 0)
{
var TriggerEventDetails = db.TriggerEvents.Where(c => c.TriggerEvent_Day == TriggerEventDay && c.TriggerTypeId == TriggerTypeID).FirstOrDefault();
if (TriggerEventDetails != null)
{
TriggerEventID = TriggerEventDetails.TriggerEvent_ID;
}
}
//string Trigger = Convert.ToString(dt.Rows[i]["Trigger"]);
//if (!string.IsNullOrEmpty(Trigger))
//{
// var TriggersDetails = db.Triggers.Where(c => c.Trigger_Trigger == Trigger).FirstOrDefault();
// if (TriggersDetails != null)
// {
// TriggerID = TriggersDetails.Trigger_ID;
// }
//}
string MMDomain = Convert.ToString(dt.Rows[i]["MM Domain"]);
if (!string.IsNullOrEmpty(MMDomain))
{
MMDomainID = db.MMDomains.Where(c => c.MMDomain_Name == MMDomain).FirstOrDefault().MMDomain_ID;
}
string MMSubDomain = Convert.ToString(dt.Rows[i]["MM Sub-Domain"]);
if (!string.IsNullOrEmpty(MMSubDomain))
{
MMSubDomainID = db.MMSubDomains.Where(c => c.MMSubDomain_Name == MMSubDomain).FirstOrDefault().MMSubDomain_ID;
}
ScheduleMessage schMessage = new ScheduleMessage();
schMessage.ScheduleMessage_Message = Convert.ToString(dt.Rows[i]["Messages"]);
string appointmentScheduleDay = Convert.ToString(dt.Rows[i]["Appointment Schedule Day"]);
int appoinmentDay = 0;
if (appointmentScheduleDay != "")
{
double num;
if (double.TryParse(appointmentScheduleDay, out num))
{
appoinmentDay = Convert.ToInt32(appointmentScheduleDay);
schMessage.Appointment_Schedule = appoinmentDay;
}
}
if (dt.Rows[i]["ID"] != null)
{
schMessage.Display_MessageId = Convert.ToInt32(dt.Rows[i]["ID"]);
}
schMessage.ScheduleMessage_TriggerTypeID = TriggerTypeID;
schMessage.ScheduleMessage_TriggerEventID = TriggerEventID;
// schMessage.ScheduleMessage_TriggerID = TriggerID;
schMessage.ScheduleMessage_Time = Convert.ToString(dt.Rows[i]["Time"]);
// schMessage.ScheduleMessage_FrequencyOfDelivery = Convert.ToString(dt.Rows[i]["Frequency of delivery"]);
schMessage.ScheduleMessage_If1 = Convert.ToString(dt.Rows[i]["If 1"]);
schMessage.ScheduleMessage_If2 = Convert.ToString(dt.Rows[i]["If 2"]);
// schMessage.ScheduleMessage_OtherNotes = Convert.ToString(dt.Rows[i]["Other Notes"]);
schMessage.ScheduleMessage_TimesSent = Convert.ToString(dt.Rows[i]["Times Sent"]);
schMessage.ScheduleMessage_MMDomainID = MMDomainID;
schMessage.ScheduleMessage_MMSubDomainID = MMSubDomainID;
if (!string.IsNullOrEmpty(schMessage.ScheduleMessage_Message))
{
db.ScheduleMessages.Add(schMessage);
db.SaveChanges();
//var dbMessage = new ScheduleMessage();
//if (TriggerTypeID == (int)TriggerType_Enum.Enrollment)
// dbMessage = db.ScheduleMessages.FirstOrDefault(c => c.ScheduleMessage_TriggerEventID == TriggerEventID && c.ScheduleMessage_TriggerTypeID == TriggerTypeID);
//else if (TriggerTypeID == (int)TriggerType_Enum.Appointment)
//{
// dbMessage = db.ScheduleMessages.FirstOrDefault(c => c.ScheduleMessage_TriggerEventID == TriggerEventID && c.ScheduleMessage_TriggerTypeID == TriggerTypeID && c.Appointment_Schedule == appoinmentDay);
//}
//else
// dbMessage = db.ScheduleMessages.FirstOrDefault(c => c.ScheduleMessage_Message == schMessage.ScheduleMessage_Message);
//if (dbMessage == null || dbMessage.ScheduleMessage_ID == 0)
//{
// db.ScheduleMessages.Add(schMessage);
// db.SaveChanges();
//}
}
}
TempData["successMessage"] = "Message has been added sucessfully.";
}
catch (Exception ex)
{
TempData["errorMessage"] = ex.Message;
}
}
List <ScheduleViewModels> listScheduleMessages = GetAll();
return(View(listScheduleMessages));
}
public ActionResult Create(ScheduleViewModels model)
{
if (model.TriggerTypeId == 4)
{
if (model.Day == null)
{
TempData["errorMessage"] = "Day field is required for Appointment type";
BindDropDowns();
ViewBag.eventId = model.TriggerTypeId;
return(View());
}
}
if (ModelState.IsValid)
{
// Save the data in the Schedule Message
try
{
DevinTwilioEntities db = new DevinTwilioEntities();
var dbResult = new ScheduleMessage();
//** This code is commented out to add multiple messages for same event type, event and for same day **//
//if (model.TriggerTypeId == (int)TriggerType_Enum.Response)
// dbResult = db.ScheduleMessages.FirstOrDefault(c => c.ScheduleMessage_Message == model.Message);
//else if (model.TriggerTypeId == (int)TriggerType_Enum.Appointment)
//{
// dbResult = db.ScheduleMessages.FirstOrDefault(c => c.ScheduleMessage_TriggerEventID == model.TriggerEventId && c.ScheduleMessage_TriggerTypeID == model.TriggerTypeId && c.Appointment_Schedule == model.Day);
// }
//else
// dbResult = db.ScheduleMessages.FirstOrDefault(c => c.ScheduleMessage_TriggerEventID == model.TriggerEventId && c.ScheduleMessage_TriggerTypeID == model.TriggerTypeId);
//if (dbResult != null)
//{
// TempData["errorMessage"] = "Message already exist for selected trigger types and events.";
// BindDropDowns();
// ViewBag.eventId = model.TriggerTypeId;
// return View();
//}
// TODO 1 - we have to remove this code and assign mmdomainid and mmsubdomainid directly from model
var domainId = 0;
var subDomainId = 0;
if (model.MMDomainName != "")
{
var mmDomain = db.MMDomains.FirstOrDefault(c => c.MMDomain_Name == model.MMDomainName);
if (mmDomain != null)
{
domainId = mmDomain.MMDomain_ID;
}
}
if (model.MMSubDomainName != "")
{
var mmSubDomain = db.MMSubDomains.FirstOrDefault(c => c.MMSubDomain_Name == model.MMSubDomainName);
if (mmSubDomain != null)
{
subDomainId = mmSubDomain.MMSubDomain_ID;
}
}
ScheduleMessage objScheduleMessage = new ScheduleMessage();
objScheduleMessage.ScheduleMessage_Message = model.Message;
objScheduleMessage.ScheduleMessage_TriggerTypeID = model.TriggerTypeId;
objScheduleMessage.ScheduleMessage_TriggerEventID = model.TriggerEventId;
objScheduleMessage.ScheduleMessage_TriggerID = model.TriggerId;
objScheduleMessage.ScheduleMessage_Time = model.Time;
objScheduleMessage.ScheduleMessage_If1 = model.If1;
objScheduleMessage.ScheduleMessage_If2 = model.If2;
objScheduleMessage.ScheduleMessage_OtherNotes = model.OtherNotes;
objScheduleMessage.ScheduleMessage_MMDomainID = domainId;
objScheduleMessage.ScheduleMessage_MMSubDomainID = subDomainId;
objScheduleMessage.Appointment_Schedule = model.Day;
db.ScheduleMessages.Add(objScheduleMessage);
db.SaveChanges();
TempData["successMessage"] = "Message has been added sucessfully.";
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
TempData["errorMessage"] = ex.Message;
}
}
BindDropDowns();
return(View());
}
protected override Task ScheduleSend <T>(ScheduleMessage <T> message, IPipe <SendContext <ScheduleMessage <T> > > pipe,
CancellationToken cancellationToken)
{
return(_publishEndpoint.Publish(message, pipe, cancellationToken));
}
public Task StoreMeta(ScheduleMessage scheduleMessage)
{
return(coreCache.StoreAsync(PrefixConst.MESSAGE_META + scheduleMessage.MessageId, scheduleMessage));
}
protected override async Task ScheduleSend(ScheduleMessage message, IPipe <SendContext <ScheduleMessage> > pipe, CancellationToken cancellationToken)
{
var endpoint = await _schedulerEndpoint().ConfigureAwait(false);
await endpoint.Send(message, pipe, cancellationToken).ConfigureAwait(false);
}
public Task ScheduleNew(ScheduleMessage scheduleMessage, PlatformModel platformModel)
{
throw new NotImplementedException();
}
public Task ScheduleBack(ScrapySource source, PlatformModel platformModel, List <string> urls, ScheduleMessage scheduleMessage)
{
throw new NotImplementedException();
}
private void Schedule(ScheduleMessage message)
{
Schedule(() => QuartzJob.Create(message.Key, message.Event, message.EventMetadata),
message.RunAt,
message.Key);
}
protected abstract Task ScheduleSend <T>(ScheduleMessage <T> message, IPipe <SendContext <ScheduleMessage <T> > > pipe, CancellationToken cancellationToken)
where T : class;
protected abstract Task ScheduleSend(ScheduleMessage message, IPipe <SendContext <ScheduleMessage> > pipe, CancellationToken cancellationToken);
