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 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 ReportStep(ResolverFactory resolver,
IEnumerable <IReporter> reporters,
ReporterRepository reporterRepository) : base(resolver)
{
this.reporters = reporters;
this.reporterRepository = reporterRepository;
}
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 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 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 ReporterPageManager(
IEventAggregator eventAggregator,
ResolverFactory resolverFactory)
{
this.eventAggregator = eventAggregator;
this.resolverFactory = resolverFactory;
}
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 ConnectionPageManager(
IEventAggregator eventAggregator,
ResolverFactory resolverFactory)
{
this.eventAggregator = eventAggregator;
this.resolverFactory = resolverFactory;
}
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 UCIndexDetail(
IEventAggregator eventAggregator,
UCIndexDetailViewModel viewModel,
ResolverFactory resolverFactory)
{
InitializeComponent();
this.viewModel = viewModel;
this.resolverFactory = resolverFactory;
DataContext = this.viewModel;
Loaded += async(s, e) => await viewModel.Loaded();
cbbEntities.SelectionChanged += (s, e) => {
viewModel.FilterProcessors();
viewModel.LoadOptions();
};
cbbSourceConnections.SelectionChanged += (s, e) => {
viewModel.FilterProcessors();
viewModel.LoadOptions();
};
cbbDestinationConnections.SelectionChanged += (s, e) => {
viewModel.FilterProcessors();
viewModel.LoadOptions();
};
cbbSourceProcessors.SelectionChanged += (s, e) => {
viewModel.LoadOptions();
};
cbbDestinationProcessors.SelectionChanged += (s, e) => {
viewModel.LoadOptions();
};
eventAggregator.GetEvent <SelectIndexEvent>().Subscribe(OnSelectIndex);
eventAggregator.GetEvent <OpenManageIndexPageEvent>().Subscribe(OnManageIndex);
eventAggregator.GetEvent <OpenIndexPreviewPageEvent>().Subscribe(OnOpenPreviewPage);
}
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;
}
}
public MessageDeliveryChannelPageManager(
IEventAggregator eventAggregator,
ResolverFactory resolverFactory)
{
this.eventAggregator = eventAggregator;
this.resolverFactory = resolverFactory;
}
protected void Page_Load(object sender, EventArgs e)
{
txtText.Editor.Language = LanguageEnum.HTMLMixed;
// Set window title and image
CurrentMaster.Title.TitleText = GetString("EditingFormControl.TitleText");
CurrentMaster.Title.TitleImage = GetImageUrl("Design/Controls/EditingFormControl/title.png");
// Set macro options using the querystring argument
bool allowMacros = QueryHelper.GetBoolean("allowMacros", true);
if (allowMacros)
{
string resolverName = QueryHelper.GetString("resolverName", null);
if (!string.IsNullOrEmpty(resolverName))
{
macroSelectorElem.Resolver = ResolverFactory.GetResolver(resolverName);
}
else
{
macroSelectorElem.Resolver = EmailTemplateMacros.EmailTemplateResolver;
}
macroSelectorElem.ExtendedTextAreaElem = txtText.Editor.EditorID;
macroSelectorElem.TextAreaID = txtText.Editor.ClientID;
}
else
{
macroSelectorElem.Visible = false;
}
// Register macro scripts
RegisterModalPageScripts();
RegisterEscScript();
}
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 async Task CreateAsync(AuthenticationTokenCreateContext context)
{
var refreshTokenId = Guid.NewGuid().ToString("n");
if (context.Ticket == null)
{
context.Response.StatusCode = 400;
context.Response.ContentType = "application/json";
context.Response.ReasonPhrase = "invalid refresh token";
return;
}
IRefreshTokenService refreshTokenService = ResolverFactory.GetService <RefreshTokenService>();
var client = context.OwinContext.Get <Client>("oauth:client");
var token = new RefreshTokenDto()
{
RefreshTokenId = UnitHelper.GetHash(refreshTokenId),
Subject = context.Ticket.Identity.Name,
IssuedUtc = DateTime.UtcNow,
ExpiresUtc = DateTime.UtcNow.AddDays(client.RefreshTokenLifeTime)
};
context.Ticket.Properties.IssuedUtc = token.IssuedUtc;
context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc;
token.ProtectedTicket = context.SerializeTicket();
await refreshTokenService.CreateAsync(token);
context.SetToken(refreshTokenId);
}
public AttributePageManager(
IEventAggregator eventAggregator,
ResolverFactory resolverFactory)
{
this.eventAggregator = eventAggregator;
this.resolverFactory = resolverFactory;
}
static void Main(string[] args)
{
LogManager log = new LogManager("zip");
IZipFactory zipFactory = null;
log.StartBlock("Work");
Console.CancelKeyPress += (sender, a) =>
{
zipFactory.Dispose();
Console.WriteLine("Application was stoped. Press any key...");
log.WriteError("Process was canceled by user");
Console.ReadKey();
Environment.Exit(1);
};
try
{
log.WriteMessage("Parsing arguments...");
Options.IntitalizeArgs(args);
log.WriteMessage($"Mode: {Options.CompressionMode.ToString()}; Input file: {Options.InputFile}; Output file: {Options.OutputFile}; CPU Cores: {Options.NumberOfCores}");
zipFactory = ResolverFactory.CreateFactory();
if (zipFactory == null)
{
log.WriteError("Processor is null");
Environment.Exit(1);
}
Console.WriteLine($"{Options.CompressionMode.ToString()}. Wait...");
int begin = System.Environment.TickCount;
log.WriteMessage("Start process");
zipFactory.StartProcess();
log.WriteMessage($"Process finished. Elapsed time {System.Environment.TickCount - begin} milliseconds");
}
catch (Exception ex)
{
log.WriteError(ex);
Error = true;
GC.Collect();
}
finally
{
if (zipFactory != null)
{
zipFactory.Dispose();
}
log.StopBlock("Work");
}
if (Error)
{
Environment.Exit(1);
}
else
{
Environment.Exit(0);
}
}
public UserRepository(OppJarContext context) : base(context)
{
UserRoles = context.UserRoles;
Roles = context.Roles;
_passwordHasher = ResolverFactory.GetService <IPasswordHasher <User> >();
}
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 reporterRepository = ResolverFactory.Resolve <ReporterRepository>())
{
Reporters = new ObservableCollection <ReporterModel>(reporterRepository.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 LoggerFactory(
IApplicationManager applicationResourceManager,
ResolverFactory resolverFactory,
LoggerConfiguration loggerConfiguration)
{
this.applicationResourceManager = applicationResourceManager;
this.resolverFactory = resolverFactory;
this.loggerConfiguration = loggerConfiguration;
}
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;
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc()
.AddFluentValidation(validator =>
validator.RegisterValidatorsFromAssemblyContaining <Startup>())
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
//services.AddDtoValidation(services);
var oAuthConnection = Configuration["Storage:SqlServer:OAuthTimeTracker:ConnectionString"];
services.AddOAuth(oAuthConnection);
// Add domain policies
services.AddDomainPolicies();
// Add domainn repositories
services.AddDomainRepositories();
// Add domain services
services.AddDomainServies();
// Add Database Initializer
services.AddScoped <IDbInitializer, DbInitializer>();
// Register the Swagger generator, defining 1 or more Swagger documents
services.AddSwaggerGen(c =>
{
//c.SwaggerDoc("v1", new Info { Title = "Time tracker - API docs", Version = "v1" });
c.SwaggerDoc("v1", new Info
{
Version = "v1",
Title = "Time tracker - API docs",
Description = "Time tracker API documentations",
TermsOfService = "None",
Contact = new Contact
{
Name = "2Click Solutions",
Email = string.Empty,
Url = "https://github.com/quanntt0203"
}
});
// Set the comments path for the Swagger JSON and UI.
var xmlFile = $"TimeTrackerApi.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
c.IncludeXmlComments(xmlPath);
});
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
ResolverFactory.SetProvider(services);
}
protected override bool IsValid(PropertyValidatorContext context)
{
var kioskService = ResolverFactory.GetService <IKioskService>();
string kioskName = context.PropertyValue as string;
var kioskDto = AsyncHelper.RunSync(() => kioskService.FindAllAsync(k => k.Name.ToLower().Equals(kioskName.ToLower())));
return(kioskDto == null);
}
public BaseReporter(IOptionManager optionManager,
ResolverFactory resolverFactory,
MessageDeliveryChannelRepository messageDelieveryChannelRepository)
{
OptionManager = optionManager;
this.resolverFactory = resolverFactory;
this.messageDelieveryChannelRepository = messageDelieveryChannelRepository;
Logger = resolverFactory.Resolve <ILogger>("SyncService");
}
public ExceptionReporter(
ResolverFactory resolverFactory,
ExceptionReporterOptionManager optionManager,
MessageRepository messageRepository,
MessageDeliveryChannelRepository messageDeliveryChannelRepository
) : base(optionManager, resolverFactory, messageDeliveryChannelRepository)
{
this.messageRepository = messageRepository;
}
