public IPageManager Apply()
{
if (listView == null)
{
listView = resolverFactory.Resolve <UCIndexesListView>();
listView.Id = "QzqMws4HH0GfDcDn/K8JRQ==";
listView.ControlName = "attributes_list_management";
listView.ControlHeader = "Attributes";
listView.Description = "List of Attributes";
listView.SetIndexType(EntityType.Attribute);
}
if (content == null)
{
content = resolverFactory.Resolve <UCIndexDetail>();
content.Id = "EFp0ZhUYMkSo3SY5Y6y7AA==";
content.ControlName = "attribute_detail_management";
content.ControlHeader = "Manage Attribute";
content.Description = "Manage Attribute Detail";
content.ActivatedById = "QzqMws4HH0GfDcDn/K8JRQ==";
content.SetIndexType(EntityType.Attribute);
}
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = listView
});
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = content
});
return(this);
}
public IPageManager Apply()
{
if (listView == null)
{
listView = resolverFactory.Resolve <UCIndexesListView>();
listView.Id = "lS2j9IRSTE+c8TFL7LFgZA==";
listView.ControlName = "entities_list_management";
listView.ControlHeader = "Entities";
listView.Description = "List of Entities";
listView.SetIndexType(EntityType.Entity);
}
if (content == null)
{
content = resolverFactory.Resolve <UCIndexDetail>();
content.Id = "1JFIy8jqlU2LKbwoDkCc7g==";
content.ControlName = "entity_detail_management";
content.ControlHeader = "Manage Entity";
content.Description = "Manage Entity Detail";
content.ActivatedById = listView.Id;
content.SetIndexType(EntityType.Entity);
}
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = listView
});
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = content
});
return(this);
}
public IPageManager Apply()
{
if (uCSettingsListView == null)
{
uCSettingsListView = resolverFactory.Resolve <UCSettingsListView>();
}
if (uCSettingsContent == null)
{
uCSettingsContent = resolverFactory.Resolve <UCSettingsContent>();
uCSettingsContent.SetSettingProviders(settingProviders);
}
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = uCSettingsListView
});
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = uCSettingsContent
});
return(this);
}
private async Task <bool> InitAllEntities()
{
try
{
//IsLoading = true;
await Task.Run(async() =>
{
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
using (var indexerManager = ResolverFactory.Resolve <IndexerManager>())
{
indexerManager.OnReport(s => Logger.Information(s));
var allEntities = entityRepository.GetAll();
foreach (var entity in allEntities)
{
await indexerManager.Init();
await indexerManager.PullAll(true);
}
}
});
Message = "All entities has been initialized.";
Logger.Information(Message);
return(true);
}
catch (Exception ex)
{
ErrorLogger.Error(ex, ex.Message);
throw;
}
finally
{
//IsLoading = false;
}
}
public override async Task Invoke(IStepExecutionContext context = null)
{
var logger = ResolverFactory.Resolve <ILogger>("SyncService");
var errorLogger = ResolverFactory.Resolve <ILogger>("Error");
try
{
logger.Information($@"Queueing index changes of {IndexModel.Name}/{IndexModel.Id}...");
queueChangesManager.SetIndex(IndexModel);
queueChangesManager.OnReport(s => logger.Information(s));
await queueChangesManager.QueueChanges();
logger.Information($@"Queued index changes of {IndexModel.Name}/{IndexModel.Id}");
}
catch (Exception ex)
{
errorLogger.Error(ex, ex.Message);
throw;
}
finally
{
Counter += 1;
ResolverFactory.Release(logger);
ResolverFactory.Release(errorLogger);
logger = null;
errorLogger = null;
}
}
public T Create <T>(object owner) where T : BaseRepository
{
lock (lockObject)
{
T result = null;
List <BaseRepository> repos = null;
if (!_registeredInstances.ContainsKey(owner))
{
repos = new List <BaseRepository>();
_registeredInstances.Add(owner, repos);
}
else
{
repos = _registeredInstances[owner]?.Where(r => r != null && !r.IsDisposed).ToList();
}
if (repos == null)
{
repos = new List <BaseRepository>();
_registeredInstances[owner] = repos;
}
result = repos.Where(r => r is T).Select(r => r as T).FirstOrDefault();
if (result == null || result.IsDisposed)
{
result = _resolverFactory.Resolve <T>();
repos.Add(result);
}
// Update the list
_registeredInstances[owner] = repos;
return(result);
}
}
public override PullResult Preview()
{
using (var attributeRepository = ResolverFactory.Resolve <AttributeRepository>())
{
var options = attributeRepository.LoadOptions(AttributeModel.Id.ToString());
var limit = options.GetValue("puller_page_limit", 100);
var offset = 0;
var sqlScript = GetSqlScript(options, false); // should call raw SQL instead of calling view
var sets = adapter.Query(sqlScript, new
{
Limit = limit,
Offset = offset
});
var set = sets.FirstOrDefault();
var results = set?.Rows?.Select(r =>
{
var jObj = JObject.FromObject(r);
jObj.Remove("RowNum");
return(jObj.ToObject(typeof(object)));
});
return(new PullResult
{
Status = results?.Count() > 0 ? PullState.HasData : PullState.Invalid,
LastToken = new
{
Limit = limit,
Offset = offset
},
Data = results
});
}
}
public override PullResult Preview()
{
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
{
var options = entityRepository.LoadOptions(EntityModel.Id.ToString());
int limit = options.GetValue("puller_page_limit", 100);
var isSql2008 = options.GetValue("puller_is_sql_2008", true);
int offset = 0;
var sqlScript = GetSqlScript(options, false);
var sets = adapter.Query(sqlScript, new
{
Limit = limit,
Offset = offset
});
var set = sets.FirstOrDefault();
var results = set?.Rows?.Select(r =>
{
var jObj = JObject.FromObject(r);
jObj.Remove("RowNum");
return(jObj.ToObject(typeof(object)));
});
return(new PullResult
{
Status = results?.Count() > 0 ? PullState.HasData : PullState.Invalid,
LastToken = new
{
Limit = limit,
Offset = offset
},
Data = results
});
}
}
public override async Task Invoke(IStepExecutionContext context = null)
{
var indexerManager = ResolverFactory.Resolve <IndexerManager>();
var logger = ResolverFactory.Resolve <ILogger>("SyncService");
var errorLogger = ResolverFactory.Resolve <ILogger>("Error");
indexerManager.OnReport(s => logger.Information(s));
try
{
logger.Information($@"Updating index changes of {IndexModel.Name}/{IndexModel.Id}...");
indexerManager.SetIndex(IndexModel as IIndexModel);
await indexerManager.PullNext();
await Task.Run(() => { });
logger.Information($@"Updated index changes of {IndexModel.Name}/{IndexModel.Id}");
Counter += 1;
}
catch (Exception ex)
{
errorLogger.Error(ex, ex.Message);
throw;
}
finally
{
indexerManager?.Dispose();
ResolverFactory.Release(logger);
ResolverFactory.Release(errorLogger);
logger = null;
errorLogger = null;
}
}
public override async Task Invoke(IStepExecutionContext context = null)
{
var entityRepository = ResolverFactory.Resolve <EntityRepository>();
var logger = ResolverFactory.Resolve <ILogger>("SyncService");
var errorLogger = ResolverFactory.Resolve <ILogger>("Error");
try
{
logger.Information($@"Requeuing items of {IndexModel.Name}/{IndexModel.Id}...");
await Task.Run(() => entityRepository.ChangeStateOfIndexedItems(IndexModel, ItemState.None, ItemState.Invalid, null));
logger.Information($@"Requeued items of {IndexModel.Name}/{IndexModel.Id}");
}
catch (Exception ex)
{
errorLogger.Error(ex, ex.Message);
throw;
}
finally
{
Counter += 1;
entityRepository?.Dispose();
ResolverFactory.Release(logger);
ResolverFactory.Release(errorLogger);
logger = null;
errorLogger = null;
}
}
private async Task <bool> InitAllIndexes()
{
try
{
using (var attributeRepository = ResolverFactory.Resolve <AttributeRepository>())
using (var indexerManager = ResolverFactory.Resolve <IndexerManager>())
{
indexerManager.OnReport(s => Logger.Information(s));
var allAttributes = attributeRepository.GetAll();
foreach (var attr in allAttributes)
{
indexerManager.SetIndex(attr);
await indexerManager.Init();
await indexerManager.PullAll(true);
}
}
Message = "All attributes has been initialized.";
Logger.Information(Message);
return(true);
}
catch (Exception ex)
{
ErrorLogger.Error(ex, ex.Message);
throw;
}
finally
{
//IsLoading = false;
}
}
public override async Task Queue()
{
await Task.Run(() =>
{
using (var messageRepository = ResolverFactory.Resolve <MessageRepository>())
{
var limit = 500;
var offset = 0;
while (true)
{
var messages = messageRepository.GetUnqueuedMessages(ReporterModel, MessageType.Error, limit, offset);
if (messages == null || messages.Count() <= 0)
{
break;
}
foreach (var message in messages)
{
messageRepository.LinkToReporter(message.Id.ToString(), ReporterModel);
}
offset += limit;
}
}
});
}
public override async Task Queue()
{
await Task.Run(() =>
{
using (var messageRepository = ResolverFactory.Resolve <MessageRepository>())
using (var queueItemRepository = ResolverFactory.Resolve <QueueItemRepository>())
{
var showDebugInfo = Options.FirstOrDefault(o => o.Name == "show_debug_info").Value;
var showProgressInfo = Options.FirstOrDefault(o => o.Name == "show_progress_info").Value;
var limit = 500;
var offset = 0;
while (true)
{
// Create success message (MessageType = Information)
var successItems = queueItemRepository.GetQueuedItemsByStatus(
PushState.Success,
PushState.Failed | PushState.UnexpectedError | PushState.ValidationFailed | PushState.Ignore | PushState.Reported, // exclude items that are reported, failed...
limit,
offset);
foreach (var item in successItems)
{
var messageText = string.Empty;
messageText = item.TargetEntityType == EntityType.Entity
? GetEntityMessage(item, out IIndexModel indexModel, out IndexItemModel itemModel)
: GetAttributeMessage(item, out indexModel, out itemModel);
if (showDebugInfo == bool.TrueString)
{
//var message = messageRepository.GetById(item.MessageId.ToString());
messageText = $@"{messageText}
* Index Info:
```{JsonConvert.SerializeObject(indexModel, Formatting.Indented)}```
* Index Item Info:
```{JsonConvert.SerializeObject(itemModel, Formatting.Indented)}```";
}
if (showProgressInfo == bool.TrueString)
{
var message = messageRepository.GetById(item.MessageId.ToString());
messageText = $@"{messageText}
* Progress:
```{message.Message}```";
}
var messageId = messageRepository.Create(new
{
CreatedAt = DateTime.Now.ToUnixTimestamp(),
Message = messageText,
MessageType = MessageType.Information,
Status = MessageStatus.None
});
messageRepository.LinkToReporter(messageId, ReporterModel);
}
offset += limit;
}
}
});
}
public override PullResult Preview()
{
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
{
var options = entityRepository.LoadOptions(EntityModel.Id.ToString());
int limit = options.GetValue("puller_page_limit", 100);
int offset = 0;
var sqlScript = GetSqlScript(options, limit, offset + limit, false);
var sets = adapter.Query(sqlScript, new
{
Limit = limit,
Offset = offset + limit
});
var set = sets.FirstOrDefault();
var results = set?.Rows;
return(new PullResult
{
Status = results?.Count() > 0 ? PullState.HasData : PullState.Invalid,
LastToken = new
{
Limit = limit,
Offset = offset
},
Data = results
});
}
}
public SyncService(
ResolverFactory resolverFactory,
EntityRepository entityRepository,
AttributeRepository attributeRepository,
IWorkflowHost host,
IEnumerable <IBaseWorkflow> workflows)
{
_logger = resolverFactory.Resolve <ILogger>("SyncService");
_errorLogger = resolverFactory.Resolve <ILogger>("Error");
this.resolverFactory = resolverFactory;
this.entityRepository = entityRepository;
this.attributeRepository = attributeRepository;
_host = host;
this.workflows = workflows;
//RegisterWorkflows();
}
public override async Task Invoke(IStepExecutionContext context = null)
{
var reporterRepository = ResolverFactory.Resolve <ReporterRepository>();
var logger = ResolverFactory.Resolve <ILogger>("SyncService");
var errorLogger = ResolverFactory.Resolve <ILogger>("Error");
try
{
var reportModels = reporterRepository.GetAll();
var loopResult = Parallel.ForEach(reportModels, async(r, i) =>
{
var options = reporterRepository.LoadOptions(r.Id.ToString(), r.EntityType);
var reporter = reporters.FirstOrDefault(rt => rt.Id == r.ReporterId);
reporter.SetOptions(options.Select(o => new OptionItem {
Name = o.Key, Value = o.Value
}));
reporter.SetReportModel(r);
await reporter.Queue();
});
await Task.Run(() => 1);
}
catch (Exception ex)
{
errorLogger.Error(ex, ex.Message);
throw;
}
finally
{
reporterRepository?.Dispose();
ResolverFactory.Release(logger);
ResolverFactory.Release(errorLogger);
logger = null;
errorLogger = null;
}
}
private void OnManageIndex(OpenManageIndexPageEventArgument obj)
{
if (obj.IndexModel.EntityType != _indexType)
{
return;
}
var window = resolverFactory.Resolve <WManageIndex>();
window.Owner = Application.Current.MainWindow;
window.Closed += (s, e) => resolverFactory.Release(window);
window.SetPuller(obj.Puller);
window.SetIndexer(obj.Indexer);
window.SetPusher(obj.Pusher);
window.SetIndex(obj.IndexModel);
window.SetMapper(obj.Mapper);
window.ShowDialog();
}
public Task <int> Loaded()
{
using (var reporterRepository = ResolverFactory.Resolve <ReporterRepository>())
{
Reporters = new ObservableCollection <ReporterModel>(reporterRepository.GetAll());
return(Task.FromResult(0));
}
}
public Task <int> Loaded()
{
using (var connectionRepository = ResolverFactory.Resolve <ConnectionRepository>())
{
Connections = new ObservableCollection <ConnectionModel>(connectionRepository.GetAll());
return(Task.FromResult(0));
}
}
public Task <int> Loaded()
{
using (var messageDeliveryChannelRepository = ResolverFactory.Resolve <MessageDeliveryChannelRepository>())
{
Channels = new ObservableCollection <MessageDeliveryChannelModel>(messageDeliveryChannelRepository.GetAll());
return(Task.FromResult(0));
}
}
public override async Task <bool> Validate()
{
try
{
var ok = true;
//IsLoading = true;
await Task.Run(() =>
{
using (var connectionRepository = ResolverFactory.Resolve <ConnectionRepository>())
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
using (var attributeRepository = ResolverFactory.Resolve <AttributeRepository>())
{
var allAttributes = attributeRepository.GetAll();
foreach (var attr in allAttributes)
{
var initialized = true;
var entity = entityRepository.GetById(attr.EntityId.ToString());
var options = attributeRepository.LoadOptions(attr.Id.ToString());
var connection = connectionRepository.GetById(attr.SourceConnectionId.ToString());
var puller = pullers.FirstOrDefault(p => p.IsImplemented(attr.SourceProcessorId, entity.SourceProcessorId, connection.ProviderId));
var indexer = indexers.FirstOrDefault(p => p.IsImplemented(attr.SourceProcessorId, entity.SourceProcessorId, connection.ProviderId));
puller.SetIndex(attr);
puller.SetOptions(options.Select(o => new OptionItem {
Name = o.Key, Value = o.Value
}));
initialized = initialized && puller.Initialized();
indexer.SetIndex(attr);
indexer.SetOptions(options.Select(o => new OptionItem {
Name = o.Key, Value = o.Value
}));
initialized = initialized && entityRepository.Initialized(attr);
ok = ok && initialized;
if (!ok)
{
Logger.Information($@"Index ""{entity.Name}"" is not initialized.");
break;
}
}
}
});
Message = "All attributes has been initialized.";
Logger.Information(Message);
return(true);
}
catch (Exception ex)
{
ErrorLogger.Error(ex, ex.Message);
throw;
}
finally
{
//IsLoading = false;
}
}
private string GetAttributeMessage(QueueItemModel item, out IIndexModel indexModel, out IndexItemModel itemModel)
{
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
using (var attributeRepository = ResolverFactory.Resolve <AttributeRepository>())
{
var attributeModel = attributeRepository.GetById(item.TargetEntityId.ToString());
var entityModel = entityRepository.GetById(attributeModel.EntityId.ToString());
var entityOptions = entityRepository.LoadOptions(entityModel.Id.ToString(), new List <string> {
"Indexer"
});
var attributeOptions = attributeRepository.LoadOptions(attributeModel.Id.ToString(), new List <string> {
"Indexer"
});
var attributeItemModel = attributeRepository.GetIndexedItemById(attributeModel, item.TargetItemId);
var entityItemModel = entityRepository.GetIndexedItemBySourceId(entityModel, attributeItemModel.GetSourceId());
itemModel = attributeItemModel;
var entityReporterMappingOption = entityOptions.FirstOrDefault(o => o.Key == "indexer_reporter_columns");
var entityReporterMappingColumns = !string.IsNullOrWhiteSpace(entityReporterMappingOption?.Value)
? JsonConvert.DeserializeObject <List <ReporterColumnMapping> >(entityReporterMappingOption.Value)
: new List <ReporterColumnMapping> {
new ReporterColumnMapping {
SourceName = "Value",
MappingName = "Name",
Key = true,
Value = true
}
};
var attributeReporterMappingOption = attributeOptions.FirstOrDefault(o => o.Key == "indexer_reporter_columns");
var attributeReporterMappingColumns = !string.IsNullOrWhiteSpace(attributeReporterMappingOption?.Value)
? JsonConvert.DeserializeObject <List <ReporterColumnMapping> >(attributeReporterMappingOption.Value)
: new List <ReporterColumnMapping> {
new ReporterColumnMapping {
SourceName = "Value",
MappingName = "Name",
Key = true,
Value = true
}
};
var keys = entityReporterMappingColumns.Where(r => r.Key)
.Select(r => $@"_{r.MappingName}_: {entityItemModel.GetValue(r.SourceName)?.ToString() ?? "(empty)"}");
var vals = attributeReporterMappingColumns.Where(r => r.Value)
.Select(r => $@"_{r.MappingName}_: {attributeItemModel.GetValue(r.SourceName)?.ToString() ?? "(empty)"}");
if (attributeReporterMappingColumns.Count == 1)
{
vals = attributeReporterMappingColumns.Where(r => r.Value)
.Select(r => $@"{attributeItemModel.GetValue(r.SourceName)?.ToString() ?? "(empty)"}");
}
var executed = item.ExecutedAt.UnixTimeToTime().ToString("G");
var executedIn = item.ExecutedAt - item.ExecuteAt;
indexModel = attributeModel;
return($@"*{indexModel.Name}* ({string.Join(", ", keys)}): {vals} {executed} in {executedIn} second(s)");
}
}
public EntitiesSettingsProvider(
EntitiesSettingsOptionManager optionManager,
EntityRepository entityRepository,
ConnectionRepository connectionRepository,
IndexerManager indexerManager,
IEnumerable <IEntityPuller> pullers,
IEnumerable <IEntityIndexer> indexers,
ResolverFactory resolverFactory) : base(optionManager)
{
this.entityRepository = entityRepository;
this.connectionRepository = connectionRepository;
this.indexerManager = indexerManager;
this.pullers = pullers;
this.indexers = indexers;
this.indexerManager.OnReport(s => this.logger.Information(s));
this.logger = resolverFactory.Resolve <ILogger>("SyncService");
this.errorLogger = resolverFactory.Resolve <ILogger>("Error");
}
public BaseReporter(IOptionManager optionManager,
ResolverFactory resolverFactory,
MessageDeliveryChannelRepository messageDelieveryChannelRepository)
{
OptionManager = optionManager;
this.resolverFactory = resolverFactory;
this.messageDelieveryChannelRepository = messageDelieveryChannelRepository;
Logger = resolverFactory.Resolve <ILogger>("SyncService");
}
public override IPuller SetIndex(IIndexModel model)
{
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
{
AttributeModel = model as AttributeModel;
EntityModel = entityRepository.GetById(AttributeModel.EntityId.ToString());
SpreadOptions();
return(this);
}
}
public static LoggerConfiguration SlackError(
this LoggerSinkConfiguration loggerConfiguration,
ResolverFactory resolverFactory,
IFormatProvider fmtProvider = null)
{
var sink = resolverFactory.Resolve <SlackErrorSink>();
sink.SetFormatPrivider(fmtProvider);
return(loggerConfiguration.Sink(sink));
}
public override PullResult PullNext(object lastToken = null)
{
using (var entityRepository = ResolverFactory.Resolve <EntityRepository>())
{
var options = entityRepository.LoadOptions(EntityModel.Id.ToString());
var totalCount = GetCount(options, true);
int limit = options.GetValue("puller_page_limit", 100);
int offset = 0;
if (lastToken != null)
{
var jToken = JObject.FromObject(lastToken);
if (jToken.ContainsKey("Limit") && jToken.ContainsKey("Offset"))
{
limit = int.Parse(jToken.GetValue("Limit").ToString());
offset = int.Parse(jToken.GetValue("Offset").ToString());
offset = offset + limit;
}
}
if (offset > totalCount) // AccessDb never knows how to stop
{
return(new PullResult
{
Status = PullState.Invalid,
LastToken = new
{
Limit = limit,
Offset = offset
},
Data = null
});
}
var sqlScript = GetSqlScript(options, limit, offset + limit, true);
var sets = adapter.Query(sqlScript, new
{
Limit = limit,
Offset = offset + limit // for MsAccess only
});
var set = sets.FirstOrDefault();
var results = set?.Rows;
return(new PullResult
{
Status = results?.Count() > 0 ? PullState.HasData : PullState.Invalid,
LastToken = new
{
Limit = limit,
Offset = offset
},
Data = results
});
}
}
public IPageManager Apply()
{
if (_ucContent == null)
{
_ucContent = resolverFactory.Resolve <UCSchedulerContent>();
}
eventAggregator.GetEvent <AddPageEvent>().Publish(new AddPageEventArgument
{
PageDefinition = _ucContent
});
return(this);
}
public static LoggerConfiguration ApplicationOutput(
this LoggerSinkConfiguration loggerConfiguration,
ResolverFactory resolverFactory,
string channel,
IFormatProvider fmtProvider = null)
{
var sink = resolverFactory.Resolve <ApplicationOutputSink>();
sink.SetFormatPrivider(fmtProvider);
//sink.SetOwner(owner);
sink.SetChannel(channel);
return(loggerConfiguration.Sink(sink));
}
public PullIndexParallelWorkflow(
EntityRepository entityRepository,
AttributeRepository attributeRepository,
ScheduleOptionRepository scheduleOptionRepository,
IndexerManager indexerManager,
ResolverFactory resolverFactory)
{
this.entityRepository = entityRepository;
this.attributeRepository = attributeRepository;
this.scheduleOptionRepository = scheduleOptionRepository;
this.indexerManager = indexerManager;
this.logger = resolverFactory.Resolve <ILogger>("Workflow");
}
