Пример #1
0
        protected async override Task <int> ExecuteCommandAsync(UpsertOptions options)
        {
            await base.ExecuteCommandAsync(options);

            IEnumerable <object> docs = null;

            if (options.File == null)
            {
                var parameters = new string[]
                {
                    options.Value1, options.Value2, options.Value3,
                    options.Value4, options.Value5, options.Value6,
                    options.Value7, options.Value8, options.Value9
                };

                var paramId = 0;

                var documents = options.Documents;

                parameters
                .TakeWhile(x => x != null)
                .ToList()
                .ForEach(x => {
                    paramId++;
                    documents = documents.ReplaceFirst("%%", x);
                });

                documents = new AliasProcessor().Process(documents, DateTime.UtcNow, iterator);

                docs = new object[] { JsonConvert.DeserializeObject <object>(documents) };
            }
            else
            {
                docs = (await File.ReadAllLinesAsync(options.File))
                       .Select(x => JsonConvert.DeserializeObject(x));
            }

            var loaded = 0;

            var count = docs.Count();

            Console.WriteLine($"Upserting {count} documents.");

            foreach (var doc in docs)
            {
                Console.WriteLine(JsonConvert.SerializeObject(doc));
                var result = await Container.UpsertItemAsync(doc);

                LogRequestCharge(result.RequestCharge);
                if ((int)result.StatusCode >= 200 && (int)result.StatusCode <= 299)
                {
                    loaded++;
                }
            }

            Console.WriteLine($"Upserted {loaded}/{count} documents.");

            return(0);
        }
Пример #2
0
        protected override Task <int> ExecuteCommandAsync(AliasesOptions options)
        {
            var aliasProcessor = new AliasProcessor();

            var now = DateTime.UtcNow;

            foreach (var group in aliasProcessor.Groups)
            {
                Console.WriteLine($"{group.Name} aliases:");
                Console.WriteLine($"  {"Alias".PadRight(16)} {"Example".PadRight(32)} Description");
                foreach (var alias in group.Aliases)
                {
                    Console.WriteLine($"  {alias.Key.PadRight(16)} {alias.Generate(now, 0).PadRight(32)} {alias.Description}");
                }
            }

            return(Task.FromResult(0));
        }
Пример #3
0
        protected async override Task <int> ExecuteCommandAsync(TOptions options)
        {
            await base.ExecuteCommandAsync(options);

            string    query     = null;
            QueryData queryData = null;

            if (options.Query.Contains(' '))
            {
                query = options.Query;
            }
            else
            {
                DirectoryInfo queriesDir = null;

                if (options.Global)
                {
                    var appDir    = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
                    var cosmicDir = appDir.CreateSubdirectory("cosmic");
                    queriesDir = cosmicDir.CreateSubdirectory("queries");
                }
                else
                {
                    queriesDir = new DirectoryInfo(".");
                }

                var queryLocation = $"{queriesDir}/{options.Query}";
                if (queryLocation.EndsWith(".json"))
                {
                    queryLocation = queryLocation.Substring(0, queryLocation.Length - 5);
                }

                var queryFile = await File.ReadAllTextAsync($"{queryLocation}.json");

                queryData = JsonConvert.DeserializeObject <QueryData>(queryFile);
                query     = queryData.Query;
            }

            var parameters = new string[]
            {
                options.Value1, options.Value2, options.Value3,
                options.Value4, options.Value5, options.Value6,
                options.Value7, options.Value8, options.Value9
            };

            var paramId = 0;

            parameters
            .TakeWhile(x => x != null)
            .ToList()
            .ForEach(x => {
                paramId++;
                query = query.ReplaceFirst("%%", x);
            });

            while (query.Contains("%%"))
            {
                query = query.ReplaceFirst("%%", queryData.Parameters[paramId].DefaultValue);
                paramId++;
            }

            query = new AliasProcessor().Process(query, DateTime.UtcNow, iterator);

            if (options.OutputQuery)
            {
                Console.WriteLine(query);
            }

            var queryDefinition        = new QueryDefinition(query);
            var queryResultSetIterator = Container.GetItemQueryIterator <dynamic>(queryDefinition);

            Docs = new List <dynamic>();

            while (queryResultSetIterator.HasMoreResults)
            {
                var currentResultSet = await queryResultSetIterator.ReadNextAsync();

                LogRequestCharge(currentResultSet.RequestCharge);
                foreach (dynamic doc in currentResultSet)
                {
                    Docs.Add(doc);
                }
            }

            return(0);
        }