private void AddServices(TreeNode currentNode, AccountServiceElementCollection accountServiceElementCollection = null, WorkflowStepElementCollection workflowStepElementCollection = null)
{
TreeNode current;
if (accountServiceElementCollection != null)
{
foreach (AccountServiceElement accountServiceElement in accountServiceElementCollection)
{
ActiveServiceElement activeServiceElement = new ActiveServiceElement(accountServiceElement);
current = currentNode.Nodes.Add(activeServiceElement.Name);
current.Tag = activeServiceElement;
AddServices(current, workflowStepElementCollection: activeServiceElement.Workflow);
}
}
else if (workflowStepElementCollection != null)
{
foreach (WorkflowStepElement stepElement in workflowStepElementCollection)
{
current = currentNode.Nodes.Add(stepElement.ActualName);
current.Checked = stepElement.IsEnabled;
current.Tag = stepElement;
AddServices(current, workflowStepElementCollection: stepElement.BaseConfiguration.Element.Workflow);
}
}
return;
}
public void Start(int?accountID = null, Dictionary <string, string> options = null)
{
ActiveServiceElement configuration;
if (accountID == null)
{
configuration = new ActiveServiceElement(this.Configuration);
if (options != null)
{
configuration.Options.Merge(options);
}
Start(Service.CreateInstance(configuration));
}
else
{
configuration = new ActiveServiceElement(this.Accounts[accountID.Value]);
if (options != null)
{
configuration.Options.Merge(options);
}
Start(Service.CreateInstance(configuration, accountID.Value));
}
}
public bool AddToSchedule(string serviceName, int accountID, DateTime targetTime, Edge.Core.SettingsCollection options)
{
AccountElement account = EdgeServicesConfiguration.Current.Accounts.GetAccount(accountID);
if (account == null)
{
Log.Write(Program.LS, String.Format("Ignoring AddToSchedule request for account {0} which does not exist.", accountID), LogMessageType.Warning);
return(false);
}
AccountServiceElement service = account.Services[serviceName];
if (service == null)
{
Log.Write(Program.LS, String.Format("Ignoring AddToSchedule request for service {0} which does not exist in account {1}.", serviceName, accountID), LogMessageType.Warning);
return(false);
}
var activeServiceElement = new ActiveServiceElement(service);
ServicePriority priority = activeServiceElement.Options.ContainsKey("ServicePriority") ?
(ServicePriority)Enum.Parse(typeof(ServicePriority), activeServiceElement.Options["ServicePriority"]) :
ServicePriority.Normal;
AddToSchedule(activeServiceElement, account, targetTime, options, priority);
return(true);
}
/*=========================*/
#endregion
#region Generate
/*=========================*/
/// <summary>
///
/// </summary>
internal static ServiceInstance Generate(EnabledConfigurationElement config, ServiceInstance parentInstance, int accountID)
{
ActiveServiceElement activeConfig;
// Get the right constructor
if (config is ServiceElement)
{
activeConfig = new ActiveServiceElement((ServiceElement)config);
}
else if (config is ExecutionStepElement)
{
activeConfig = new ActiveServiceElement((ExecutionStepElement)config);
}
else if (config is AccountServiceElement)
{
activeConfig = new ActiveServiceElement((AccountServiceElement)config);
}
else if (config is AccountServiceSettingsElement)
{
activeConfig = new ActiveServiceElement((AccountServiceSettingsElement)config);
}
else
{
throw new ArgumentException("Configuration is an unrecognized class.", "config");
}
// Don't allow non-enabled services
if (!activeConfig.IsEnabled)
{
throw new InvalidOperationException(String.Format("Cannot create an instance of a disabled service. Set IsEnabled to true in the configuration file in order to run. Service name: {0}", activeConfig.Name));
}
return(new ServiceInstance(activeConfig, parentInstance, accountID));
}
/// <summary>
/// Check the service rule and add it if needed.
/// </summary>
/// <param name="serviceElement"></param>
/// <remarks>
/// We schedule the table for next day.
/// For example on sunday 23:00 we schedule the table for monday.
/// </remarks>
/// <param name="childService">if we add a service request this service is the requested child service to schedule.</param>
public void AddServicesByRules(AccountServiceElement accountServiceElement, int accountID, ServiceInstance childService)
{
ActiveServiceElement element = new ActiveServiceElement(accountServiceElement);
//TODO: check if there is parent to the service
foreach (SchedulingRuleElement rule in element.SchedulingRules)
{
// TODO: to check if there are same scheduling rules to account and service.
HandleRule(accountServiceElement, accountID, childService, rule);
}
}
public void AddToSchedule(ActiveServiceElement activeServiceElement, AccountElement account, DateTime targetTime, Edge.Core.SettingsCollection options, ServicePriority servicePriority)
{
if (options != null)
{
foreach (string option in options.Keys)
{
activeServiceElement.Options[option] = options[option];
}
}
//base configuration
var baseConfiguration = new ServiceConfiguration()
{
Name = activeServiceElement.Name,
MaxConcurrent = activeServiceElement.MaxInstances,
MaxConcurrentPerProfile = activeServiceElement.MaxInstancesPerAccount
};
//configuration per profile
var instanceConfiguration = new ServiceConfiguration()
{
BaseConfiguration = baseConfiguration,
Name = activeServiceElement.Name,
MaxConcurrent = (activeServiceElement.MaxInstances == 0) ? 9999 : activeServiceElement.MaxInstances,
MaxConcurrentPerProfile = (activeServiceElement.MaxInstancesPerAccount == 0) ? 9999 : activeServiceElement.MaxInstancesPerAccount,
LegacyConfiguration = activeServiceElement
};
//scheduling rules
instanceConfiguration.SchedulingRules.Add(new SchedulingRule()
{
Scope = SchedulingScope.UnPlanned,
SpecificDateTime = targetTime,
MaxDeviationAfter = TimeSpan.FromMinutes(30),
Hours = new List <TimeSpan>(),
GuidForUnplaned = Guid.NewGuid(),
});
instanceConfiguration.SchedulingRules[0].Hours.Add(new TimeSpan(0, 0, 0, 0));
Profile profile = new Profile()
{
ID = account.ID,
Name = account.ID.ToString(),
Settings = new Dictionary <string, object>()
};
profile.Settings.Add("AccountID", account.ID);
instanceConfiguration.SchedulingProfile = profile;
_scheduler.AddNewServiceToSchedule(instanceConfiguration);
}
/// <summary>
/// Initializing service from current configuration
/// </summary>
/// <param name="timePeriod">Service time period</param>
/// <param name="serviceName">Service Name , See Const</param>
/// <param name="channels">Channels List in string format seperated by comma</param>
/// <param name="accounts">Accounts List in string format seperated by comma</param>
internal void InitServices(DateTimeRange timePeriod, string serviceName, string channels, string accounts, Dictionary <string, Object> eventsHandlers)
{
try
{
ActiveServiceElement serviceElements = new ActiveServiceElement(EdgeServicesConfiguration.Current.Accounts.GetAccount(-1).Services[serviceName]);
//Removing overide options
serviceElements.Options.Remove("fromDate");
serviceElements.Options.Remove("toDate");
serviceElements.Options.Remove("ChannelList");
serviceElements.Options.Remove("AccountsList");
// TimePeriod
serviceElements.Options.Add("fromDate", timePeriod.Start.ToDateTime().ToString());
serviceElements.Options.Add("toDate", timePeriod.End.ToDateTime().ToString());
serviceElements.Options.Add("ChannelList", channels);
serviceElements.Options.Add("AccountsList", accounts);
serviceElements.Options.Add("PmsServiceName", serviceName);
//Update WorkFlow
foreach (WorkflowStepElement step in serviceElements.Workflow)
{
//CHECK IF CHILD SERVICE OPTION IS -> PMS = ENABLED
if (step.Options.ContainsKey("PMS") && !step.Options["PMS"].ToString().ToUpper().Equals("ENABLED"))
{
step.IsEnabled = false;
}
else
{
step.IsEnabled = true;
}
}
ServiceInstance = Edge.Core.Services.Service.CreateInstance(serviceElements);
ServiceInstance.OutcomeReported += (EventHandler)eventsHandlers[Const.EventsTypes.ParentOutcomeReportedEvent];
ServiceInstance.StateChanged += (EventHandler <ServiceStateChangedEventArgs>)eventsHandlers[Const.EventsTypes.ParentStateChangedEvent];
ServiceInstance.ChildServiceRequested += (EventHandler <ServiceRequestedEventArgs>)eventsHandlers[Const.EventsTypes.ChildServiceRequested];
//instance.ProgressReported += new EventHandler(instance_ProgressReported);
ServiceInstance.Initialize();
}
catch (Exception ex)
{
throw new Exception("Could not init validation service, Check configuration", ex);
}
}
void OnChildServiceRequested(int stepNumber, int attemptNumber, SettingsCollection options)
{
// Get the step configuration elements
WorkflowStepElement stepConfig = this.Configuration.Workflow[stepNumber];
AccountServiceSettingsElement stepSettings =
this.Configuration.StepSettings != null ?
this.Configuration.StepSettings[stepConfig] :
null;
// Take the step configuration
ActiveServiceElement configuration = stepSettings != null ?
new ActiveServiceElement(stepSettings) :
new ActiveServiceElement(stepConfig);
// Add child-specific options
if (options != null)
{
configuration.Options.Merge(options);
}
// Add parent options, without overriding child options with the same name
foreach (var parentOption in this.Configuration.Options)
{
if (!configuration.Options.ContainsKey(parentOption.Key))
{
configuration.Options.Add(parentOption.Key, parentOption.Value);
}
}
// Add parent extensions, without overriding child options with the same name
foreach (var parentExtension in this.Configuration.Extensions)
{
if (!configuration.Extensions.ContainsKey(parentExtension.Key))
{
configuration.Extensions.Add(parentExtension.Key, parentExtension.Value);
}
}
// Generate a child instance
ServiceInstance child = Service.CreateInstance(configuration, this, this.AccountID);
child.StateChanged += _childStateHandler;
child.OutcomeReported += _childOutcomeHandler;
child.ProgressReported += _childProgressHandler;
_childServices.Add(child, stepNumber);
if (ChildServiceRequested != null)
{
ChildServiceRequested(this, new ServiceRequestedEventArgs(child, attemptNumber));
}
}
/*=========================*/
#endregion
#region Constructor
/*=========================*/
/// <summary>
///
/// </summary>
internal ServiceInstance(ActiveServiceElement activeConfiguration, ServiceInstance parentInstance, int accountID)
{
ActiveConfigurationProperty.SetValue(this, activeConfiguration);
ParentInstanceProperty.SetValue(this, parentInstance);
if (accountID > -1)
{
AccountIDProperty.SetValue(this, accountID);
}
_childStateHandler = new EventHandler <ServiceStateChangedEventArgs>(ChildStateChanged);
_childOutcomeHandler = new EventHandler(ChildOutcomeReported);
Log = new Log(this);
}
public ServiceInstanceInfo(ServiceInstance instance)
{
_accountID = instance.AccountID;
_instanceID = instance.InstanceID;
_priority = instance.Priority;
_config = instance.Configuration;
_rule = instance.ActiveSchedulingRule;
_timeStarted = instance.TimeStarted;
_timeScheduled = instance.TimeScheduled;
_serviceUrl = instance.ServiceUrl;
if (instance.ParentInstance != null)
{
_parentInstanceData = new ServiceInstanceInfo(instance.ParentInstance);
}
}
/*=========================*/
#endregion
#region Constructor
/*=========================*/
/// <summary>
///
/// </summary>
internal ServiceInstance(ActiveServiceElement activeConfiguration, ServiceInstance parentInstance, int accountID)
{
this.Guid = Guid.NewGuid();
ActiveConfigurationProperty.SetValue(this, activeConfiguration);
ParentInstanceProperty.SetValue(this, parentInstance);
_logSource = activeConfiguration.Name;
if (accountID > -1)
{
AccountIDProperty.SetValue(this, accountID);
}
_childStateHandler = new EventHandler <ServiceStateChangedEventArgs>(ChildStateChanged);
_childOutcomeHandler = new EventHandler(ChildOutcomeReported);
_childProgressHandler = new EventHandler(ChildProgressReported);
}
protected override ServiceOutcome DoWork()
{
HttpWebRequest request;
WebResponse response;
#region Init
Dictionary <int, FacbookAccountParams> facbookAccountParams = new Dictionary <int, FacbookAccountParams>();
StringBuilder strAccounts = new StringBuilder();
foreach (AccountElement account in EdgeServicesConfiguration.Current.Accounts)
{
foreach (AccountServiceElement service in account.Services)
{
if (service.Uses.Element.Name == "Facebook.GraphApi")
{
ActiveServiceElement activeService = new ActiveServiceElement(service);
facbookAccountParams.Add(account.ID, new FacbookAccountParams()
{
FacebookAccountID = activeService.Options[FacebookConfigurationOptions.Account_ID],
AccessToken = activeService.Options[FacebookConfigurationOptions.Auth_AccessToken]
});
strAccounts.AppendFormat("{0},", account.ID);
}
}
}
if (strAccounts.Length == 0)
{
Log.Write("No account runing facebook found", LogMessageType.Information);
return(ServiceOutcome.Success);
}
else //remove last ','
{
strAccounts.Remove(strAccounts.Length - 1, 1);
this.ReportProgress(0.2);
#endregion
#region UpdateCampaignStatus
ServiceOutcome outcome = ServiceOutcome.Success;
int hourOfDay = DateTime.Now.Hour;
int today = Convert.ToInt32(DateTime.Now.DayOfWeek);
if (today == 0)
{
today = 7;
}
Dictionary <int, Dictionary <long, int> > statusByCampaignID = new Dictionary <int, Dictionary <long, int> >();
//prepere sqlstatment by time of day get all campaings by time and status != null and 1
using (SqlConnection connection = new SqlConnection(AppSettings.GetConnectionString(this, "DB")))
{
connection.Open();
SqlCommand sqlCommand = DataManager.CreateCommand(string.Format(@"SELECT distinct T0.Account_ID, T2.campaignid,T0.Hour{1}
FROM Campaigns_Scheduling T0
INNER JOIN User_GUI_Account T1 ON T0.Account_ID=T1.Account_ID
INNER JOIN UserProcess_GUI_PaidCampaign T2 ON T0.Campaign_GK=T2.Campaign_GK
WHERE T0.Day=@Day:Int AND T0.Account_ID IN ({0})
AND (T0.Hour{1} =1 OR T0.Hour{1}=2) AND
T2.Channel_ID=6 AND T1.Status!=0 AND T2.campStatus<>3 AND T2.ScheduleEnabled=1
ORDER BY T0.Account_ID" , strAccounts.ToString(), hourOfDay.ToString().PadLeft(2, '0')));
sqlCommand.Parameters["@Day"].Value = today;
sqlCommand.Connection = connection;
using (SqlDataReader sqlDataReader = sqlCommand.ExecuteReader())
{
while (sqlDataReader.Read())
{
int account_id = Convert.ToInt32(sqlDataReader["Account_ID"]);
long campaign_ID = Convert.ToInt64(sqlDataReader["campaignid"]);
int campaign_status = Convert.ToInt32(sqlDataReader[string.Format("Hour{0}", hourOfDay.ToString().PadLeft(2, '0'))]);
if (!statusByCampaignID.ContainsKey(account_id))
{
statusByCampaignID.Add(account_id, new Dictionary <long, int>());
}
statusByCampaignID[account_id][campaign_ID] = campaign_status;
}
}
}
foreach (KeyValuePair <int, Dictionary <long, int> > byAccount in statusByCampaignID)
{
FacbookAccountParams param = facbookAccountParams[byAccount.Key];
string accessToken = param.AccessToken;
foreach (var byCampaign in statusByCampaignID[byAccount.Key])
{
request = (HttpWebRequest)HttpWebRequest.Create(string.Format(@"https://graph.facebook.com/{0}?campaign_status={1}&access_token={2}", byCampaign.Key, byCampaign.Value, accessToken));
request.Method = "POST";
string strResponse;
try
{
response = request.GetResponse();
using (StreamReader stream = new StreamReader(response.GetResponseStream()))
{
strResponse = stream.ReadToEnd();
}
if (strResponse != "true")
{
outcome = ServiceOutcome.Failure;
Edge.Core.Utilities.Log.Write(string.Format("Account {0} failed:{1}", byAccount.Key, strResponse), null, LogMessageType.Error, byAccount.Key);
}
else
{
Edge.Core.Utilities.Log.Write(string.Format("Account- {0} with campaign-{1} updated successfuly with value {2} for day num{3}", byAccount.Key, byCampaign.Key, byCampaign.Value, today), null, LogMessageType.Error, byAccount.Key);
}
}
catch (WebException ex)
{
using (StreamReader reader = new StreamReader(ex.Response.GetResponseStream()))
{
outcome = ServiceOutcome.Failure;
strResponse = reader.ReadToEnd();
Edge.Core.Utilities.Log.Write(string.Format("Account {0} -{1}", byAccount.Key, strResponse), ex, LogMessageType.Error, byAccount.Key);
}
}
}
}
#endregion
return(outcome);
}
}
protected static T FromLegacyConfiguration <T>(NamedConfigurationElement legacyConfiguration, ServiceConfiguration baseConfiguration = null, Profile profile = null, Dictionary <string, string> options = null) where T : ServiceConfiguration, new()
{
if (legacyConfiguration is AccountServiceElement || legacyConfiguration is WorkflowStepElement || legacyConfiguration is ActiveServiceElement)
{
if (baseConfiguration == null)
{
throw new ArgumentNullException("baseConfiguration", "When creating a configuration from a Legacy.AccountServiceElement or Legacy.ActiveServiceElement, baseConfiguration must be supplied.");
}
if (profile == null)
{
throw new ArgumentNullException("profile", "When creating a configuration from a Legacy.AccountServiceElement or Legacy.ActiveServiceElement, profile must be supplied.");
}
}
if (legacyConfiguration is ServiceElement && !(legacyConfiguration is ActiveServiceElement))
{
if (baseConfiguration != null)
{
throw new ArgumentException("baseConfiguration", "When creating a configuration from a Legacy.ServiceInstance, baseConfiguration must be null.");
}
if (profile != null)
{
throw new ArgumentException("profile", "When creating a configuration from a Legacy.ServiceInstance, profile must be null.");
}
}
ServiceElement legacy;
if (legacyConfiguration is AccountServiceElement)
{
legacy = new ActiveServiceElement(legacyConfiguration as AccountServiceElement);
}
else if (legacyConfiguration is WorkflowStepElement)
{
legacy = new ActiveServiceElement(legacyConfiguration as WorkflowStepElement);
}
else
{
if (options != null)
{
legacy = new ActiveServiceElement((ServiceElement)legacyConfiguration);
}
else
{
legacy = (ServiceElement)legacyConfiguration;
}
}
if (options != null)
{
legacy.Options.Merge(options);
}
T serviceConfiguration = new T()
{
_name = legacy.Name,
MaxConcurrent = (legacy.MaxInstances == 0) ? 9999 : legacy.MaxInstances,
MaxConcurrentPerProfile = (legacy.MaxInstancesPerAccount == 0) ? 9999 : legacy.MaxInstancesPerAccount,
_legacyConfiguration = legacy,
_baseConfiguration = baseConfiguration,
_schedulingProfile = profile
};
if (legacy.Options.ContainsKey("ServicePriority"))
{
serviceConfiguration._priority = int.Parse(legacy.Options["ServicePriority"]);
}
//scheduling rules
foreach (SchedulingRuleElement schedulingRuleElement in legacy.SchedulingRules)
{
SchedulingRule rule = SchedulingRule.FromLegacyRule(schedulingRuleElement);
if (serviceConfiguration.SchedulingRules == null)
{
serviceConfiguration.SchedulingRules = new List <SchedulingRule>();
}
serviceConfiguration.SchedulingRules.Add(rule);
}
return(serviceConfiguration);
}
public bool AddToSchedule(string serviceName, int accountID, DateTime targetTime, Edge.Core.SettingsCollection options)
{
bool respond = true;
try
{
ServiceConfiguration myServiceConfiguration = new ServiceConfiguration();
ServiceConfiguration baseConfiguration = new ServiceConfiguration();
ActiveServiceElement activeServiceElement = new ActiveServiceElement(EdgeServicesConfiguration.Current.Accounts.GetAccount(accountID).Services[serviceName]);
if (options != null)
{
foreach (string option in options.Keys)
{
activeServiceElement.Options[option] = options[option];
}
}
ServiceElement serviceElement = EdgeServicesConfiguration.Current.Services[serviceName];
//base configuration;
baseConfiguration.Name = serviceElement.Name;
baseConfiguration.MaxConcurrent = serviceElement.MaxInstances;
baseConfiguration.MaxCuncurrentPerProfile = serviceElement.MaxInstancesPerAccount;
//configuration per profile
myServiceConfiguration = new ServiceConfiguration();
myServiceConfiguration.Name = activeServiceElement.Name;
if (activeServiceElement.Options.ContainsKey("ServicePriority"))
{
myServiceConfiguration.priority = int.Parse(activeServiceElement.Options["ServicePriority"]);
}
myServiceConfiguration.MaxConcurrent = (activeServiceElement.MaxInstances == 0) ? 9999 : activeServiceElement.MaxInstances;
myServiceConfiguration.MaxCuncurrentPerProfile = (activeServiceElement.MaxInstancesPerAccount == 0) ? 9999 : activeServiceElement.MaxInstancesPerAccount;
myServiceConfiguration.LegacyConfiguration = activeServiceElement;
// //scheduling rules
myServiceConfiguration.SchedulingRules.Add(new SchedulingRule()
{
Scope = SchedulingScope.UnPlanned,
SpecificDateTime = DateTime.Now,
MaxDeviationAfter = new TimeSpan(0, 0, 45, 0, 0),
Hours = new List <TimeSpan>(),
GuidForUnplaned = Guid.NewGuid()
});
myServiceConfiguration.SchedulingRules[0].Hours.Add(new TimeSpan(0, 0, 0, 0));
myServiceConfiguration.BaseConfiguration = baseConfiguration;
Edge.Core.Scheduling.Objects.Profile profile = new Edge.Core.Scheduling.Objects.Profile()
{
ID = accountID,
Name = accountID.ToString(),
Settings = new Dictionary <string, object>()
};
profile.Settings.Add("AccountID", accountID);
myServiceConfiguration.SchedulingProfile = profile;
_scheduler.AddNewServiceToSchedule(myServiceConfiguration);
}
catch (Exception ex)
{
respond = false;
Edge.Core.Utilities.Log.Write("AddManualServiceListner", ex.Message, ex, Edge.Core.Utilities.LogMessageType.Error);
}
return(respond);
}
private void addBtn_Click(object sender, EventArgs e)
{
ServicePriority servicePriority = ServicePriority.Low;
var options = new Edge.Core.SettingsCollection();
DateTime targetDateTime = new DateTime(dateToRunPicker.Value.Year, dateToRunPicker.Value.Month, dateToRunPicker.Value.Day, timeToRunPicker.Value.Hour, timeToRunPicker.Value.Minute, 0);
if (priorityCmb.SelectedItem != null)
{
switch (priorityCmb.SelectedItem.ToString())
{
case "Low":
{
servicePriority = ServicePriority.Low;
break;
}
case "Normal":
{
servicePriority = ServicePriority.Normal;
break;
}
case "High":
{
servicePriority = ServicePriority.High;
break;
}
case "Immediate":
{
servicePriority = ServicePriority.Immediate;
break;
}
}
}
int countedSelectedServices = 0;
foreach (TreeNode accountNode in servicesTreeView.Nodes)
{
foreach (TreeNode serviceNode in accountNode.Nodes)
{
if (!serviceNode.Checked)
{
continue;
}
countedSelectedServices++;
AccountElement account = (AccountElement)accountNode.Tag;
ActiveServiceElement service = (ActiveServiceElement)serviceNode.Tag;
if (useOptionsCheckBox.Checked)
{
foreach (ListViewItem item in optionsListView.Items)
{
options.Add(item.SubItems[0].Text.Trim(), item.SubItems[1].Text.Trim());
}
DateTime from = FromPicker.Value;
DateTime to = toPicker.Value;
if (to.Date < from.Date || to.Date > DateTime.Now.Date)
{
MessageBox.Show(String.Format("Account {0} service {1}: To date must be equal or greater than from date, and both should be less then today's date",
account.ID,
service.Name
));
continue;
}
DateTimeRange daterange = new DateTimeRange()
{
Start = new DateTimeSpecification()
{
BaseDateTime = from,
Hour = new DateTimeTransformation()
{
Type = DateTimeTransformationType.Exact, Value = 0
},
},
End = new DateTimeSpecification()
{
BaseDateTime = to,
Hour = new DateTimeTransformation()
{
Type = DateTimeTransformationType.Max
},
}
};
options.Add(PipelineService.ConfigurationOptionNames.TimePeriod, daterange.ToAbsolute().ToString());
}
_listener.AddToSchedule(service, account, targetDateTime, options, servicePriority);
options.Clear();
}
}
MessageBox.Show(String.Format("{0} unplanned services were added.", countedSelectedServices));
}
public bool AddToSchedule(string serviceName, int accountID, DateTime targetTime, SettingsCollection options)
{
// YANIV:
// if cannot perform at requested time, or can only perform after max deviation expires -
// throw exception with a message
ActiveServiceElement startupElement = null;
if (accountID < 0)
{
AccountServiceElement elem = ServicesConfiguration.SystemAccount.Services[serviceName];
if (elem != null)
{
startupElement = new ActiveServiceElement(elem);
}
else
{
startupElement = new ActiveServiceElement(ServicesConfiguration.Services[serviceName]);
}
}
else
{
AccountElement account = ServicesConfiguration.Accounts.GetAccount(accountID);
if (account == null)
{
// EXCEPTION:
return(false);
//throw new ArgumentException(
// String.Format("Account with ID {0} does not exist.", accountID),
// "accountID");
}
AccountServiceElement accountService = account.Services[serviceName];
if (accountService == null)
{
// EXCEPTION
// throw new ArgumentException(String.Format("Service {0} is not defined for account {1}", serviceName, account.Name), "serviceName");
return(false);
// Log.Write(String.Format("Service {0} is not defined for account {1}", serviceName, account.Name), LogMessageType.Warning);
}
else
{
startupElement = new ActiveServiceElement(accountService);
}
}
// Couldn't find exception
if (startupElement == null)
{
// EXCEPTION:
return(false);
//throw new ArgumentException(
// String.Format("The requested service \"{0}\" could not be found.", serviceName),
// "serviceName");
}
// Merge the options
if (options != null)
{
foreach (KeyValuePair <string, string> pair in options)
{
startupElement.Options[pair.Key] = pair.Value;
}
}
// Add the manual request.
if (targetTime < DateTime.Now)
{
_builder.AddManualRequest(startupElement, accountID);
}
else
{
_builder.AddManualRequest(startupElement, targetTime, accountID);
}
return(true);
}
private void addBtn_Click(object sender, EventArgs e)
{
bool allSucceed = true;
try
{
ServicePriority servicePriority = ServicePriority.Low;
Edge.Core.SettingsCollection options = new Edge.Core.SettingsCollection();
DateTime targetDateTime = new DateTime(dateToRunPicker.Value.Year, dateToRunPicker.Value.Month, dateToRunPicker.Value.Day, timeToRunPicker.Value.Hour, timeToRunPicker.Value.Minute, 0);
bool result = false;
if (priorityCmb.SelectedItem != null)
{
switch (priorityCmb.SelectedItem.ToString())
{
case "Low":
{
servicePriority = ServicePriority.Low;
break;
}
case "Normal":
{
servicePriority = ServicePriority.Normal;
break;
}
case "High":
{
servicePriority = ServicePriority.High;
break;
}
case "Immediate":
{
servicePriority = ServicePriority.Immediate;
break;
}
}
}
int countedSelectedServices = 0;
foreach (TreeNode accountNode in servicesTreeView.Nodes)
{
foreach (TreeNode serviceNode in accountNode.Nodes)
{
if (serviceNode.Checked)
{
countedSelectedServices++;
AccountElement account = (AccountElement)accountNode.Tag;
ActiveServiceElement service = (ActiveServiceElement)serviceNode.Tag;
if (useOptionsCheckBox.Checked)
{
foreach (ListViewItem item in optionsListView.Items)
{
options.Add(item.SubItems[0].Text.Trim(), item.SubItems[1].Text.Trim());
}
DateTime from = FromPicker.Value;
DateTime to = toPicker.Value;
if (to.Date < from.Date || to.Date > DateTime.Now.Date)
{
throw new Exception("to date must be equal or greater then from date, and both should be less then today's date");
}
if (chkBackward.Checked)
{
while (from.Date <= to.Date)
{
//For backward compatbility
options["Date"] = from.ToString("yyyyMMdd");
result = _listner.FormAddToSchedule(service, account, targetDateTime, options, servicePriority);
options.Clear();
if (!result)
{
allSucceed = result;
MessageBox.Show(string.Format("Service {0} for account {1} did not run", service.Name, accountNode.Text));
}
from = from.AddDays(1);
}
}
else
{
DateTimeRange daterange = new DateTimeRange()
{
Start = new DateTimeSpecification()
{
BaseDateTime = from,
Hour = new DateTimeTransformation()
{
Type = DateTimeTransformationType.Exact, Value = 0
},
},
End = new DateTimeSpecification()
{
BaseDateTime = to,
Hour = new DateTimeTransformation()
{
Type = DateTimeTransformationType.Max
},
}
};
options.Add(PipelineService.ConfigurationOptionNames.TimePeriod, daterange.ToAbsolute().ToString());
result = _listner.FormAddToSchedule(service, account, targetDateTime, options, servicePriority);
options.Clear();
if (!result)
{
allSucceed = result;
MessageBox.Show(string.Format("Service {0} for account {1} did not run", service.Name, accountNode.Text));
}
}
}
else
{
result = _listner.FormAddToSchedule(service, account, targetDateTime, options, servicePriority);
if (!result)
{
allSucceed = result;
}
}
}
}
}
if (!allSucceed)
{
throw new Exception("Some services did not run");
}
else
{
if (countedSelectedServices > 0)
{
MessageBox.Show(@"Unplaned service\services added successfully");
}
else
{
MessageBox.Show(@"No services selected");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public WizardSession Start(string WizardName)
{
//Debugger.Launch();
//load the service from configuration file
//CHANGED 1 (Service is taken from app.config- what to do if service not found?)
int wizardID;
ServiceElement requestedWizardConfiguration = ServicesConfiguration.Services[WizardName];
if (requestedWizardConfiguration == null)
{
throw new Exception("Wizard cannot be found");
}
//Get service data
wizardID = int.Parse(requestedWizardConfiguration.Options["WizardID"]); //to insert in database it's int future
//first step name
ExecutionStepElement FirstStepCollector = GetFirstCollectorStep(requestedWizardConfiguration.ExecutionSteps);
if (FirstStepCollector == null)
{
throw new Exception("No step collector found");
}
ActiveServiceElement configurationToRun = new ActiveServiceElement(requestedWizardConfiguration);
//Initalize the main wizard service (account service...etc)
ServiceInstance instance = Service.CreateInstance(configurationToRun);
instance.ChildServiceRequested += new EventHandler <ServiceRequestedEventArgs>(instance_ChildServiceRequested);
instance.ProgressReported += new EventHandler(instance_ProgressReported);
instance.StateChanged += new EventHandler <ServiceStateChangedEventArgs>(instance_StateChanged);
instance.OutcomeReported += new EventHandler(instance_OutcomeReported);
instance.Initialize();
object sessionID = null;
//Open new session by insert values in to the wizards_sessions_data table
using (DataManager.Current.OpenConnection())
{
using (SqlCommand sqlCommand = DataManager.CreateCommand(@"INSERT INTO Wizards_Sessions_Data
(WizardID,CurrentStepName,ServiceInstanceID,WizardStatus)
Values (@WizardID:Int,@CurrentStepName:NvarChar,@ServiceInstanceID:BigInt,@WizardStatus:Int);SELECT @@IDENTITY" ))
{
sqlCommand.Parameters["@WizardID"].Value = wizardID;
sqlCommand.Parameters["@CurrentStepName"].Value = FirstStepCollector.Name;
sqlCommand.Parameters["@ServiceInstanceID"].Value = instance.InstanceID;
sqlCommand.Parameters["@WizardStatus"].Value = WizardStatus.Collect;
sessionID = sqlCommand.ExecuteScalar();
if (sessionID == null)
{
throw new Exception("Error: Session not created");
}
}
}
instance.Configuration.Options["SessionID"] = sessionID.ToString();
//Create WizardSession object to return
WizardSession wizardSession = new WizardSession();
wizardSession.SessionID = System.Convert.ToInt32(sessionID); //@@IDENTITY IS DECIMAL
wizardSession.WizardID = wizardID;
wizardSession.CurrentStep = new StepConfiguration()
{
StepName = FirstStepCollector.Name
};
return(wizardSession);
}
