private void WriteCommandName(string name, ICommandOptions command)
{
var param = command.Argument;
if (param != null)
Writer.WriteLine("{0} <{1}> ({2})", name, param.Name, param.Member.Type.GetRealClassName());
else
Writer.WriteLine("{0}", name);
}
protected override Task InvalidateCacheAsync(IReadOnlyCollection<ModifiedDocument<User>> documents, ICommandOptions options = null) {
if (!IsCacheEnabled)
return Task.CompletedTask;
var users = documents.UnionOriginalAndModified();
var keysToRemove = users.Select(u => String.Concat("Email:", u.EmailAddress.ToLowerInvariant().Trim())).Distinct().ToList();
return Task.WhenAll(
Cache.RemoveAllAsync(keysToRemove),
InvalidateCachedQueriesAsync(users, options),
base.InvalidateCacheAsync(documents, options)
);
}
public static string GetCacheKey(this ICommandOptions options, string defaultCacheKey = null)
{
return(options.SafeGetOption <string>(SetCacheOptionsExtensions.CacheKeyKey, defaultCacheKey ?? options.GetDefaultCacheKey()));
}
public static bool ShouldReadCache(this ICommandOptions options)
{
return(options.SafeGetOption(SetCacheOptionsExtensions.ReadCacheEnabledKey, options.ShouldUseCache()));
}
public static TimeSpan GetExpiresIn(this ICommandOptions options)
{
return(options.SafeGetOption(SetCacheOptionsExtensions.CacheExpiresInKey, RepositoryConstants.DEFAULT_CACHE_EXPIRATION_TIMESPAN));
}
public CommandOptions(ICommandOptions options)
{
_options = options;
NoVersionCheck = options?.NoVersionCheck ?? false;
Verbose = options?.Verbose ?? false;
}
protected override Task InvalidateCachedQueriesAsync(IReadOnlyCollection <WebHook> documents, ICommandOptions options = null)
{
var keysToRemove = documents.Select(d => $"paged:Organization:{d.OrganizationId}:Project:{d.ProjectId}").Distinct();
var tasks = new List <Task>();
foreach (string key in keysToRemove)
{
tasks.Add(Cache.RemoveByPrefixAsync(key));
}
tasks.Add(base.InvalidateCachedQueriesAsync(documents, options));
return(Task.WhenAll(tasks));
}
public ExecuteResultEnum Build(ICommandOptions options)
{
if (!_configFile.Exists())
{
_reportService.Error($"Config file not found: {Configuration.ConfigurationFile}"); // why do we use Configuration here?
_reportService.Output($"\tPlease make sure you are in the right working directory");
return(ExecuteResultEnum.Error);
}
RunAutoUpdate(options);
if (RunConfigVersionCheck(options) == ExecuteResultEnum.Aborted)
{
return(ExecuteResultEnum.Aborted);
}
_reportService.PrintTitle("Build DataContext from spocr.json");
var config = _configFile.Config;
var project = config?.Project;
var schemas = config?.Schema;
var connectionString = project?.DataBase?.ConnectionString;
var hasSchemas = schemas?.Any() ?? false;
var hasConnectionString = string.IsNullOrWhiteSpace(connectionString);
if (!hasConnectionString)
{
_dbContext.SetConnectionString(connectionString);
}
if (!hasSchemas)
{
_reportService.Error($"Schema is empty: {Configuration.ConfigurationFile}"); // why do we use Configuration here?
_reportService.Output($"\tPlease run pull to get the DB-Schema.");
return(ExecuteResultEnum.Error);
}
var stopwatch = new Stopwatch();
var elapsed = new Dictionary <string, long>();
var codeBaseAlreadyExists = project.Role.Kind == ERoleKind.Extension;
if (!codeBaseAlreadyExists)
{
stopwatch.Start();
_reportService.PrintSubTitle("Generating CodeBase");
_output.GenerateCodeBase(project.Output, options.DryRun);
elapsed.Add("CodeBase", stopwatch.ElapsedMilliseconds);
}
stopwatch.Restart();
_reportService.PrintSubTitle("Generating TableTypes");
_engine.GenerateDataContextTableTypes(options.DryRun);
elapsed.Add("TableTypes", stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
_reportService.PrintSubTitle("Generating Inputs");
_engine.GenerateDataContextInputs(options.DryRun);
elapsed.Add("Inputs", stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
_reportService.PrintSubTitle("Generating Outputs");
_engine.GenerateDataContextOutputs(options.DryRun);
elapsed.Add("Outputs", stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
_reportService.PrintSubTitle("Generating Models");
_engine.GenerateDataContextModels(options.DryRun);
elapsed.Add("Models", stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
_reportService.PrintSubTitle("Generating StoredProcedures");
_engine.GenerateDataContextStoredProcedures(options.DryRun);
elapsed.Add("StoredProcedures", stopwatch.ElapsedMilliseconds);
var summary = elapsed.Select(_ => $"{_.Key} generated in {_.Value} ms.");
_reportService.PrintSummary(summary, $"SpocR v{_spocr.Version.ToVersionString()}");
_reportService.PrintTotal($"Total elapsed time: {elapsed.Sum(_ => _.Value)} ms.");
if (options.DryRun)
{
_reportService.PrintDryRunMessage();
}
return(ExecuteResultEnum.Succeeded);
}
public static async Task ConfigureSearchAsync <T>(this IElasticQueryBuilder builder, IRepositoryQuery query, ICommandOptions options, SearchDescriptor <T> search) where T : class, new()
{
if (search == null)
{
throw new ArgumentNullException(nameof(search));
}
var q = await builder.BuildQueryAsync(query, options, search).AnyContext();
search.Query(d => q);
}
public static async Task <QueryContainer> BuildQueryAsync <T>(this IElasticQueryBuilder builder, IRepositoryQuery query, ICommandOptions options, SearchDescriptor <T> search) where T : class, new()
{
var ctx = new QueryBuilderContext <T>(query, options, search);
await builder.BuildAsync(ctx).AnyContext();
return(new BoolQuery {
Must = new[] { ctx.Query },
Filter = new[] { ctx.Filter ?? new MatchAllQuery() }
});
}
/// <summary>
/// Initializes a new instance of the <see cref="Command"/> class.
/// </summary>
/// <param name="command"> The command must haves.</param>
/// <param name="commandOptions"> The command options.</param>
public Command(ICommand command, ICommandOptions commandOptions)
{
this.MainCommand = command.MainCommand;
this.Handler = command.Handler;
this.Set(commandOptions);
}
public DocumentsChangeEventArgs(ChangeType changeType, IReadOnlyCollection <ModifiedDocument <T> > documents, IRepository <T> repository, ICommandOptions options)
{
ChangeType = changeType;
Documents = documents ?? EmptyReadOnly <ModifiedDocument <T> > .Collection;
Repository = repository;
Options = options;
}
public ModifiedDocumentsEventArgs(IReadOnlyCollection <ModifiedDocument <T> > documents, IRepository <T> repository, ICommandOptions options)
{
Documents = documents ?? EmptyReadOnly <ModifiedDocument <T> > .Collection;
Repository = repository;
Options = options;
}
protected string[] GetIndexesByQuery(IRepositoryQuery query, ICommandOptions options = null)
{
return(HasMultipleIndexes ? TimeSeriesType.GetIndexesByQuery(query) : new[] { ElasticIndex.Name });
}
protected async Task <SearchDescriptor <T> > ConfigureSearchDescriptorAsync(SearchDescriptor <T> search, IRepositoryQuery query, ICommandOptions options)
{
if (search == null)
{
search = new SearchDescriptor <T>();
}
query = ConfigureQuery(query);
search.Type(ElasticType.Name);
var indices = GetIndexesByQuery(query);
if (indices?.Length > 0)
{
search.Index(String.Join(",", indices));
}
if (HasVersion)
{
search.Version(HasVersion);
}
search.IgnoreUnavailable();
await ElasticType.QueryBuilder.ConfigureSearchAsync(query, options, search).AnyContext();
return(search);
}
public async Task <FindResults <TResult> > FindAsAsync <TResult>(IRepositoryQuery query, ICommandOptions options = null) where TResult : class, new()
{
if (query == null)
{
query = new RepositoryQuery();
}
bool useSnapshotPaging = options.ShouldUseSnapshotPaging();
// don't use caching with snapshot paging.
bool allowCaching = IsCacheEnabled && useSnapshotPaging == false;
options = ConfigureOptions(options);
await OnBeforeQueryAsync(query, options, typeof(TResult)).AnyContext();
Func <FindResults <TResult>, Task <FindResults <TResult> > > getNextPageFunc = async r => {
var previousResults = r;
if (previousResults == null)
{
throw new ArgumentException(nameof(r));
}
if (!String.IsNullOrEmpty(previousResults.GetScrollId()))
{
var scrollResponse = await _client.ScrollAsync <TResult>(options.GetSnapshotLifetime(), previousResults.GetScrollId()).AnyContext();
_logger.Trace(() => scrollResponse.GetRequest());
var results = scrollResponse.ToFindResults();
results.Page = previousResults.Page + 1;
results.HasMore = scrollResponse.Hits.Count() >= options.GetLimit();
return(results);
}
if (options == null)
{
return(new FindResults <TResult>());
}
options?.PageNumber(!options.HasPageNumber() ? 2 : options.GetPage() + 1);
return(await FindAsAsync <TResult>(query, options).AnyContext());
};
string cacheSuffix = options?.HasPageLimit() == true?String.Concat(options.GetPage().ToString(), ":", options.GetLimit().ToString()) : null;
FindResults <TResult> result;
if (allowCaching)
{
result = await GetCachedQueryResultAsync <FindResults <TResult> >(options, cacheSuffix : cacheSuffix).AnyContext();
if (result != null)
{
((IGetNextPage <TResult>)result).GetNextPageFunc = async r => await getNextPageFunc(r).AnyContext();
return(result);
}
}
ISearchResponse <TResult> response = null;
if (useSnapshotPaging == false || !options.HasSnapshotScrollId())
{
var searchDescriptor = await CreateSearchDescriptorAsync(query, options).AnyContext();
if (useSnapshotPaging)
{
searchDescriptor.Scroll(options.GetSnapshotLifetime());
}
response = await _client.SearchAsync <TResult>(searchDescriptor).AnyContext();
}
else
{
response = await _client.ScrollAsync <TResult>(options.GetSnapshotLifetime(), options.GetSnapshotScrollId()).AnyContext();
}
_logger.Trace(() => response.GetRequest());
if (!response.IsValid)
{
if (response.ApiCall.HttpStatusCode.GetValueOrDefault() == 404)
{
return(new FindResults <TResult>());
}
string message = response.GetErrorMessage();
_logger.Error().Exception(response.OriginalException).Message(message).Property("request", response.GetRequest()).Write();
throw new ApplicationException(message, response.OriginalException);
}
if (useSnapshotPaging)
{
result = response.ToFindResults();
// TODO: Is there a better way to figure out if you are done scrolling?
result.HasMore = response.Hits.Count() >= options.GetLimit();
((IGetNextPage <TResult>)result).GetNextPageFunc = getNextPageFunc;
}
else if (options.HasPageLimit() == true)
{
result = response.ToFindResults(options.GetLimit());
result.HasMore = response.Hits.Count() > options.GetLimit();
((IGetNextPage <TResult>)result).GetNextPageFunc = getNextPageFunc;
}
else
{
result = response.ToFindResults();
}
result.Page = options.GetPage();
if (!allowCaching)
{
return(result);
}
var nextPageFunc = ((IGetNextPage <TResult>)result).GetNextPageFunc;
((IGetNextPage <TResult>)result).GetNextPageFunc = null;
await SetCachedQueryResultAsync(options, result, cacheSuffix : cacheSuffix).AnyContext();
((IGetNextPage <TResult>)result).GetNextPageFunc = nextPageFunc;
return(result);
}
public ExecuteResultEnum Pull(ICommandOptions options)
{
RunAutoUpdate(options);
if (!_configFile.Exists())
{
_reportService.Error($"File not found: {Configuration.ConfigurationFile}");
_reportService.Output($"\tPlease make sure you are in the right working directory");
return(ExecuteResultEnum.Error);
}
var userConfigFileName = Configuration.UserConfigurationFile.Replace("{userId}", _globalConfigFile.Config?.UserId);
var userConfigFile = new FileManager <ConfigurationModel>(_spocr, userConfigFileName);
if (userConfigFile.Exists())
{
// TODO
// userConfigFile.OnVersionMismatch = (spocrVersion, configVersion) => {
// _reportService.Warn($"Your installed SpocR Version {spocrVersion} does not match with spocr.json Version {configVersion}");
// };
var userConfig = userConfigFile.Read();
_configFile.OverwriteWithConfig = userConfig;
}
if (RunConfigVersionCheck(options) == ExecuteResultEnum.Aborted)
{
return(ExecuteResultEnum.Aborted);
}
if (!string.IsNullOrWhiteSpace(_configFile.Config?.Project?.DataBase?.ConnectionString))
{
_dbContext.SetConnectionString(_configFile.Config.Project.DataBase.ConnectionString);
}
if (string.IsNullOrWhiteSpace(_configFile.Config.Project.DataBase.ConnectionString))
{
_reportService.Error($"ConnectionString is empty: {Configuration.ConfigurationFile}");
_reportService.Output($"\tPlease run {Configuration.Name} set --cs <ConnectionString>");
return(ExecuteResultEnum.Error);
}
_reportService.PrintTitle("Pulling DB-Schema from Database");
var config = _configFile.Config;
var configSchemas = config?.Schema ?? new List <SchemaModel>();
var stopwatch = new Stopwatch();
stopwatch.Start();
_schemaManager.ListAsync(config).ContinueWith(t =>
{
var result = t.Result;
var overwriteWithCurrentConfig = configSchemas.Any();
if (overwriteWithCurrentConfig)
{
foreach (var schema in result ?? Enumerable.Empty <SchemaModel>())
{
var currentSchema = configSchemas.SingleOrDefault(i => i.Name == schema.Name);
schema.Status = currentSchema != null ? currentSchema.Status : _configFile.Config.Project.DefaultSchemaStatus;
}
}
configSchemas = result;
}).Wait();
if (configSchemas == null)
{
return(ExecuteResultEnum.Error);
}
var pullSchemas = configSchemas.Where(x => x.Status == SchemaStatusEnum.Build);
var ignoreSchemas = configSchemas.Where(x => x.Status == SchemaStatusEnum.Ignore);
var pulledStoredProcedures = pullSchemas.SelectMany(x => x.StoredProcedures ?? new List <StoredProcedureModel>()).ToList();
var pulledSchemasWithStoredProcedures = pullSchemas
.Select(x => new
{
Schema = x,
StoredProcedures = x.StoredProcedures?.ToList()
}).ToList();
pulledSchemasWithStoredProcedures.ForEach(schema =>
{
schema.StoredProcedures?.ForEach((sp => _reportService.Verbose($"PULL: [{schema.Schema.Name}].[{sp.Name}]")));
});
_reportService.Output("");
if (ignoreSchemas.Any())
{
_reportService.Error($"Ignored {ignoreSchemas.Count()} Schemas [{string.Join(", ", ignoreSchemas.Select(x => x.Name))}]");
_reportService.Output("");
}
_reportService.Note($"Pulled {pulledStoredProcedures.Count()} StoredProcedures from {pullSchemas.Count()} Schemas [{string.Join(", ", pullSchemas.Select(x => x.Name))}] in {stopwatch.ElapsedMilliseconds} ms.");
_reportService.Output("");
if (options.DryRun)
{
_reportService.PrintDryRunMessage();
}
else
{
config.Schema = configSchemas;
_configFile.Save(config);
}
return(ExecuteResultEnum.Succeeded);
}
public static bool ShouldNotify(this ICommandOptions options)
{
return(options.SafeGetOption(SetNotificationOptionsExtensions.NotificationsKey, true));
}
protected override Task InvalidateCacheAsync(IReadOnlyCollection <ModifiedDocument <WebHook> > documents, ICommandOptions options = null)
{
if (!IsCacheEnabled)
{
return(Task.CompletedTask);
}
var keys = documents.Select(d => d.Value).Union(documents.Select(d => d.Original).Where(d => d != null)).Select(h => String.Concat("Organization:", h.OrganizationId, ":Project:", h.ProjectId)).Distinct();
return(Task.WhenAll(Cache.RemoveAllAsync(keys), base.InvalidateCacheAsync(documents, options)));
}
protected override Task InvalidateCacheAsync(IReadOnlyCollection <ModifiedDocument <T> > documents, ICommandOptions options = null)
{
if (!IsCacheEnabled)
{
return(Task.CompletedTask);
}
return(Task.WhenAll(InvalidateCachedQueriesAsync(documents.Select(d => d.Value).ToList(), options), base.InvalidateCacheAsync(documents, options)));
}
protected override Task SendQueryNotificationsAsync(ChangeType changeType, IRepositoryQuery query, ICommandOptions options)
{
if (!NotificationsEnabled || !options.ShouldNotify())
{
return(Task.CompletedTask);
}
var delay = TimeSpan.FromSeconds(1.5);
var organizations = query.GetOrganizations();
var projects = query.GetProjects();
var stacks = query.GetStacks();
var ids = query.GetIds();
var tasks = new List <Task>();
string organizationId = organizations.Count == 1 ? organizations.Single() : null;
if (ids.Count > 0)
{
string projectId = projects.Count == 1 ? projects.Single() : null;
string stackId = stacks.Count == 1 ? stacks.Single() : null;
foreach (string id in ids)
{
tasks.Add(PublishMessageAsync(CreateEntityChanged(changeType, organizationId, projectId, stackId, id), delay));
}
return(Task.WhenAll(tasks));
}
if (stacks.Count > 0)
{
string projectId = projects.Count == 1 ? projects.Single() : null;
foreach (string stackId in stacks)
{
tasks.Add(PublishMessageAsync(CreateEntityChanged(changeType, organizationId, projectId, stackId), delay));
}
return(Task.WhenAll(tasks));
}
if (projects.Count > 0)
{
foreach (string projectId in projects)
{
tasks.Add(PublishMessageAsync(CreateEntityChanged(changeType, organizationId, projectId), delay));
}
return(Task.WhenAll(tasks));
}
if (organizations.Count > 0)
{
foreach (string organization in organizations)
{
tasks.Add(PublishMessageAsync(CreateEntityChanged(changeType, organization), delay));
}
return(Task.WhenAll(tasks));
}
return(PublishMessageAsync(new EntityChanged {
ChangeType = changeType,
Type = EntityTypeName
}, delay));
}
public static bool HasPageNumber(this ICommandOptions options)
{
return(options.SafeHasOption(SetPagingOptionsExtensions.PageNumberKey));
}
public static string GetDefaultCacheKey(this ICommandOptions options)
{
return(options.SafeGetOption <string>(SetCacheOptionsExtensions.CacheKeyKey, null));
}
public static int GetPage(this ICommandOptions options)
{
return(options.SafeGetOption(SetPagingOptionsExtensions.PageNumberKey, 1));
}
public static bool ShouldUseCache(this ICommandOptions options, bool defaultValue = false)
{
return(options.SafeGetOption(SetCacheOptionsExtensions.CacheEnabledKey, defaultValue));
}
public static bool ShouldUseSkip(this ICommandOptions options)
{
return(options.HasPageLimit() && options.GetPage() > 1);
}
public static bool HasCacheKey(this ICommandOptions options)
{
return(options.Values.Contains(SetCacheOptionsExtensions.CacheKeyKey) || options.Values.Contains(SetCacheOptionsExtensions.DefaultCacheKeyKey));
}
public WrappedCommandOptions(ICommandOptions innerOptions)
{
InnerOptions = innerOptions;
}
protected override async Task InvalidateCacheAsync(IReadOnlyCollection <ModifiedDocument <Stack> > documents, ICommandOptions options = null)
{
if (!IsCacheEnabled)
{
return;
}
var keys = documents.UnionOriginalAndModified().Select(GetStackSignatureCacheKey).Distinct();
await Cache.RemoveAllAsync(keys).AnyContext();
await base.InvalidateCacheAsync(documents, options).AnyContext();
}
protected virtual Task InvalidateCachedQueriesAsync(IReadOnlyCollection <User> documents, ICommandOptions options = null)
{
return(Task.CompletedTask);
}
protected override async Task AddDocumentsToCacheAsync(ICollection <FindHit <User> > findHits, ICommandOptions options)
{
await base.AddDocumentsToCacheAsync(findHits, options).AnyContext();
var cacheEntries = new Dictionary <string, FindHit <User> >();
foreach (var hit in findHits.Where(d => !String.IsNullOrEmpty(d.Document?.EmailAddress)))
{
cacheEntries.Add(EmailCacheKey(hit.Document.EmailAddress), hit);
}
if (cacheEntries.Count > 0)
{
await AddDocumentsToCacheWithKeyAsync(cacheEntries, options.GetExpiresIn()).AnyContext();
}
}
public CommandRegistry(string command, ICommandOptions parser)
{
this.command = command;
this.parser = parser;
}
