Beispiel #1
0
        public override string[] GetCompletions(CommandCompletionContext completionContext)
        {
            var domain    = this.Content.Dispatcher.Invoke(() => this.Content.Domain);
            var tableInfo = this.Content.Dispatcher.Invoke(() => this.Content.Table.TableInfo);

            return(domain.Dispatcher.Invoke(() =>
            {
                var dataSet = domain.Source as CremaDataSet;
                var dataTable = dataSet.Tables[tableInfo.Name];

                if (completionContext.Arguments.Length >= dataTable.PrimaryKey.Length)
                {
                    return null;
                }

                var expItems = new List <string>();
                for (var i = 0; i < completionContext.Arguments.Length; i++)
                {
                    expItems.Add($"{dataTable.PrimaryKey[i].ColumnName}='{completionContext.Arguments[i]}'");
                }

                var expression = string.Join(" AND ", expItems);
                var query = from item in dataTable.Select(expression)
                            let value = CremaConvert.ChangeType(item[dataTable.PrimaryKey[completionContext.Arguments.Length]], typeof(string)) as string
                                        select value;
                return query.ToArray();
            }));
        }
Beispiel #2
0
        protected override void OnExecute()
        {
            var tableInfo = this.Content.Dispatcher.Invoke(() => this.Content.Table.TableInfo);
            var keys      = tableInfo.Columns.Where(item => item.IsKey).ToArray();
            var schema    = this.CreateSchema(tableInfo.Columns);

            var fieldList = new List <object>();

            for (var i = 0; i < this.Keys.Length; i++)
            {
                var key     = keys[i];
                var keyText = this.Keys[i];
                var type    = CremaDataTypeUtility.IsBaseType(key.DataType) ? CremaDataTypeUtility.GetType(key.DataType) : typeof(string);
                var value   = CremaConvert.ChangeType(keyText, type);
                fieldList.Add(value);
            }

            var authentication = this.CommandContext.GetAuthentication(this);
            var tableRow       = this.Content.Dispatcher.Invoke(() => this.Content.Find(authentication, fieldList.ToArray()));

            var terminal = new Terminal();

            if (terminal.ReadString("type 'remove':") != "remove")
            {
                return;
            }

            this.Content.Dispatcher.Invoke(() => { tableRow.Delete(authentication); });
        }
Beispiel #3
0
 public static string GetRandomString(this ITableColumn tableColumn)
 {
     if (tableColumn.DefaultValue != null && RandomUtility.Next(3) == 0)
     {
         return(null);
     }
     else if (tableColumn.AllowNull == true && RandomUtility.Next(4) == 0)
     {
         return(null);
     }
     else
     {
         var template = tableColumn.Template;
         var dataType = tableColumn.DataType;
         if (CremaDataTypeUtility.IsBaseType(dataType) == false)
         {
             var type = template.GetType(dataType);
             return(type.GetRandomString());
         }
         else
         {
             var value = RandomUtility.Next(CremaDataTypeUtility.GetType(dataType));
             return(CremaConvert.ChangeType(value, typeof(string)) as string);
         }
     }
 }
        protected override async Task <object[]> OnExecuteAsync(string domainID, string tableName, IDictionary <string, object> fields)
        {
            if (fields == null)
            {
                throw new ArgumentNullException(nameof(fields));
            }
            var domain = await this.CremaHost.GetDomainAsync(Guid.Parse(domainID));

            var contents = domain.Host as IEnumerable <ITableContent>;
            var content  = contents.FirstOrDefault(item => item.Dispatcher.Invoke(() => item.Table.Name) == tableName);

            if (content == null)
            {
                throw new TableNotFoundException(tableName);
            }
            var authentication = this.Context.GetAuthentication(this);
            var tableInfo      = content.Table.TableInfo;
            var row            = await content.AddNewAsync(authentication, null);

            foreach (var item in fields)
            {
                var typeName = tableInfo.Columns.First(i => i.DataType == item.Key).DataType;
                var type     = CremaDataTypeUtility.GetType(typeName);
                var value    = CremaConvert.ChangeType(item.Value, type);
                await row.SetFieldAsync(authentication, item.Key, value);
            }
            await content.EndNewAsync(authentication, row);

            return(tableInfo.Columns.Select(item => row[item.Name]).ToArray());
        }
 private object GetDefaultValue(ColumnInfo columnInfo)
 {
     if (columnInfo.DefaultValue != null && CremaDataTypeUtility.IsBaseType(columnInfo.DataType) == true)
     {
         var type = CremaDataTypeUtility.GetType(columnInfo.DataType);
         return(CremaConvert.ChangeType(columnInfo.DefaultValue, type));
     }
     return(columnInfo.DefaultValue);
 }
        public void Test4()
        {
            var dataTable     = new CremaDataTable();
            var c1            = dataTable.Columns.Add("Column1", typeof(string));
            var template      = new CremaTemplate(dataTable);
            var defaultString = "12.3";
            var defaultValue  = CremaConvert.ChangeType(defaultString, typeof(float));

            template.Columns[0].DefaultValue = defaultString;
            template.Columns[0].SetDataType(typeof(float));
            template.Columns[0].SetDataType(typeof(DateTime));
            Assert.AreEqual(c1.DefaultValue, template.Columns[0].DefaultValue);
            template.Columns[0].SetDataType(typeof(float));
            Assert.AreEqual(defaultValue, template.Columns[0].DefaultValue);
        }
Beispiel #7
0
        public void SetDefaultValueAsString()
        {
            var column       = this.RandomOrDefault(item => item.DefaultValue == DBNull.Value && item.AutoIncrement == false);
            var defaultValue = column.CremaType != null?column.CremaType.GetRandomValue() : RandomUtility.Next(column.DataType);

            column.DefaultValue = CremaConvert.ChangeType(defaultValue, typeof(string));
            if (column.DataType == typeof(DateTime))
            {
                Assert.AreEqual(defaultValue.ToString(), column.DefaultValue.ToString());
            }
            else
            {
                Assert.AreEqual(defaultValue, column.DefaultValue);
            }
        }
Beispiel #8
0
        public void SetDefaultStringValue()
        {
            this.attribute.DataType = CremaDataTypeUtility.GetBaseTypes().Random();
            var newDefaultValue = RandomUtility.Next(this.attribute.DataType);

            this.attribute.DefaultValue = CremaConvert.ChangeType(newDefaultValue, typeof(string));
            Assert.AreEqual(newDefaultValue.GetType(), this.attribute.DefaultValue.GetType());
            if (this.attribute.DataType == typeof(DateTime))
            {
                Assert.AreEqual(newDefaultValue.ToString(), this.attribute.DefaultValue.ToString());
            }
            else
            {
                Assert.AreEqual(newDefaultValue, this.attribute.DefaultValue);
            }
        }
        public static async Task <string> GetRandomStringAsync(this ITableColumn tableColumn)
        {
            if (tableColumn.DefaultValue != null && RandomUtility.Next(3) == 0)
            {
                return(null);
            }
            else if (tableColumn.AllowNull == true && RandomUtility.Next(4) == 0)
            {
                return(null);
            }
            else
            {
                var template = tableColumn.Template;
                var dataType = tableColumn.DataType;
                if (CremaDataTypeUtility.IsBaseType(dataType) == false)
                {
                    try
                    {
                        var domain         = template.Domain;
                        var dataBase       = domain.GetService(typeof(IDataBase)) as IDataBase;
                        var typeCollection = dataBase.GetService(typeof(ITypeCollection)) as ITypeCollection;
                        var typeName       = new ItemName(dataType);
                        var type           = await typeCollection.GetTypeAsync(typeName.Name, typeName.CategoryPath);

                        return(await type.GetRandomStringAsync());
                    }
                    catch (System.NullReferenceException e)
                    {
                        System.Diagnostics.Debugger.Launch();
                        throw e;
                    }
                }
                else
                {
                    var value = RandomUtility.Next(CremaDataTypeUtility.GetType(dataType));
                    return(CremaConvert.ChangeType(value, typeof(string)) as string);
                }
            }
        }
Beispiel #10
0
        protected override async Task OnExecuteAsync(CancellationToken cancellationToken)
        {
            var tableInfo = this.Content.Dispatcher.Invoke(() => this.Content.Table.TableInfo);
            var keys      = tableInfo.Columns.Where(item => item.IsKey).ToArray();
            var schema    = this.CreateSchema(tableInfo.Columns);

            var fieldList = new List <object>();

            for (var i = 0; i < this.Keys.Length; i++)
            {
                var key     = keys[i];
                var keyText = this.Keys[i];
                var type    = CremaDataTypeUtility.IsBaseType(key.DataType) ? CremaDataTypeUtility.GetType(key.DataType) : typeof(string);
                var value   = CremaConvert.ChangeType(keyText, type);
                fieldList.Add(value);
            }

            var fields         = new JsonPropertiesInfo();
            var authentication = this.CommandContext.GetAuthentication(this);
            var tableRow       = await this.Content.FindAsync(authentication, fieldList.ToArray());

            this.Content.Dispatcher.Invoke(() =>
            {
                foreach (var item in tableInfo.Columns)
                {
                    var field = tableRow[item.Name];
                    if (field != null || item.AllowNull == false)
                    {
                        fields.Add(item.Name, field);
                    }
                }
            });

            var result = fields.Execute(schema);

            if (result == null)
            {
                return;
            }

            foreach (var item in fields)
            {
                if (result.ContainsKey(item.Key) == false)
                {
                    await tableRow.SetFieldAsync(authentication, item.Key, DBNull.Value);
                }
            }

            foreach (var item in result)
            {
                if (tableInfo.Columns.Any(i => i.Name == item.Key) == false)
                {
                    continue;
                }
                var value1 = tableRow[item.Key];
                var value2 = item.Value;
                if (object.Equals(value1, value2) == true)
                {
                    continue;
                }

                await tableRow.SetFieldAsync(authentication, item.Key, item.Value);
            }
        }
        public object ToValue()
        {
            var type = CremaDataTypeUtility.GetType(this.Type);

            return(CremaConvert.ChangeType(this.Value, type));
        }