public bool Start(HostControl hostControl)
{
try
{
var iEngineService = EngineServiceFactory.Create(_tenantId);
//Todo: implement this
//var iOrderService = OrderServiceFactory.Create(_tenantId);
//_currentThreads = iOrderService.RetrieveProcessingOrderCount();
//Get settings for engine for order and service.
var engineSettings = iEngineService.RetrieveProvisioningEngineSetting(_companyId);
if (engineSettings == null)
{
throw new Exception("Unable to Retrieve Provisioning Engine Settings by Company Id: " + _companyId);
}
//Since this is in seconds we need to multiply by 1000 per second.
var timeInterval = engineSettings.ProvisioningInterval * 1000;
// CreateOrder the delegate that invokes methods for the timer.
//var provisioningStartTimerDelegate = new TimerCallback(OnProvisioningStartElapsedTime);
//_provisioningStartTimer = new Timer(provisioningStartTimerDelegate, engineSettings, timeInterval, timeInterval);
_provisioningStartTimer = new Timer(timeInterval);
_provisioningStartTimer.Elapsed += (sender, e) => OnProvisioningStartElapsedTime(sender, e, engineSettings);
//This makes sure the timer only executes once until you call start again.
_provisioningStartTimer.AutoReset = false;
_provisioningStartTimer.Start();
}
catch (Exception ex)
{
_iLogger.WriteLogEntry(_tenantId.ToString(), null, _name + " error while attempting to start timer.", LogLevelType.Error, ex);
}
_iLogger.WriteLogEntry(_tenantId.ToString(), null, _name + " has started.", LogLevelType.Info);
return(true);
}
private void Provision()
{
try
{
var iEngineService = EngineServiceFactory.Create(_tenantId);
var iOrderService = OrderServiceFactory.Create(_tenantId);
// Get Settings for current companyId
var engineSettings = iEngineService.RetrieveProvisioningEngineSetting(_companyId);
//Todo check if this can run right now based off schedule.
if (engineSettings.ProvisioningPaused)
{
_iLogger.WriteLogEntry(_tenantId.ToString(), null, _name + " Provisioning Paused.", LogLevelType.Info);
}
else
{
//Make this thread safe.
//Only allow one timer instance to get in at a time.
lock (_syncProvisioningStartRoot)
{
switch (engineSettings.ProvisionByMethod)
{
case ProvisionByMethodType.Order:
var domainOrder = iOrderService.RetrieveNextOrderToProvisionByCompanyIdAndActionType(_companyId, engineSettings.ProvisionableOrderOrServiceActionTypes);
int previousOrderId = 0;
//var services = new List<Service>();
//While there are orders pending and I am not using max threads get another order.
while (domainOrder != null && engineSettings.MaxThreadsPerDispatcher > _currentThreads)
{
if (previousOrderId != domainOrder.Id)
{
Task.Factory.StartNew(() => ProcessOrderThread(domainOrder));
}
//Set current to old.
previousOrderId = domainOrder.Id;
//Get next Service Order
domainOrder = iOrderService.RetrieveNextOrderToProvisionByCompanyIdAndActionType(_companyId, engineSettings.ProvisionableOrderOrServiceActionTypes);
}
break;
case ProvisionByMethodType.Service:
var domainService = iOrderService.RetrieveNextServiceToProvisionByCompanyIdAndActionType(_companyId, engineSettings.ProvisionableOrderOrServiceActionTypes);
int previousServiceId = 0;
//While there are orders pending and I am not using max threads get another order.
while (domainService != null && engineSettings.MaxThreadsPerDispatcher > _currentThreads)
{
if (previousServiceId != domainService.Id)
{
Task.Factory.StartNew(() => ProcessServiceThread(domainService));
}
//Set current to old.
previousServiceId = domainService.Id;
//Get next Service
domainService = iOrderService.RetrieveNextServiceToProvisionByCompanyIdAndActionType(_companyId, engineSettings.ProvisionableOrderOrServiceActionTypes);
}
break;
case ProvisionByMethodType.Item:
int orderId = 0;
int serviceId = 0;
int itemId = 0;
int previousItemId = 0;
object domainItem = iOrderService.RetrieveNextItemToProvisionByCompanyIdAndActionTypeAndItemType(_companyId, engineSettings.ProvisionableItemActionTypes);
if (domainItem is PhoneItem)
{
var phoneItem = domainItem as PhoneItem;
itemId = phoneItem.Id;
serviceId = phoneItem.ServiceId;
var service = iOrderService.RetrieveServiceById(serviceId);
orderId = service.OrderId;
}
if (domainItem is VideoItem)
{
var videoItem = domainItem as VideoItem;
itemId = videoItem.Id;
serviceId = videoItem.ServiceId;
var service = iOrderService.RetrieveServiceById(serviceId);
orderId = service.OrderId;
}
if (domainItem is InternetItem)
{
var internetItem = domainItem as InternetItem;
itemId = internetItem.Id;
serviceId = internetItem.ServiceId;
var service = iOrderService.RetrieveServiceById(serviceId);
orderId = service.OrderId;
}
previousItemId = 0;
//While there are orders pending and I am not using max threads get another order.
while (domainItem != null && engineSettings.MaxThreadsPerDispatcher > _currentThreads)
{
if (previousItemId != itemId)
{
Task.Factory.StartNew(() => ProcessItemThread(orderId, serviceId, itemId));
}
//Set current to old.
previousItemId = itemId;
//Get next Service
domainItem = iOrderService.RetrieveNextItemToProvisionByCompanyIdAndActionTypeAndItemType(_companyId, engineSettings.ProvisionableItemActionTypes);
}
break;
default:
throw new NotImplementedException(_name + " this type is not implemented yet.");
}
// Continue on this thread...
}
}
}
catch (AggregateException ae)
{
foreach (var ex in ae.Flatten().InnerExceptions)
{
_iLogger.WriteLogEntry(_tenantId.ToString(), null, _name + " error on retrieving next order.", LogLevelType.Error, ex);
}
}
catch (Exception ex)
{
_iLogger.WriteLogEntry(_tenantId.ToString(), null, _name + " error on retrieving next order.", LogLevelType.Error, ex);
}
}
