public static void ModifyRandomMember(this CremaDataType dataType)
{
if (RandomUtility.Within(90) == true)
{
var typeMember = dataType.Members.RandomOrDefault();
if (typeMember != null)
{
typeMember.SetRandomValue();
if (RandomUtility.Within(5) == true)
{
typeMember.IsEnabled = RandomUtility.NextBoolean();
}
}
}
else if (RandomUtility.Within(75) == true)
{
AddRandomMember(dataType);
}
else
{
var dataMember = dataType.Members.RandomOrDefault();
if (dataMember != null)
{
if (RandomUtility.Within(50) == true)
{
dataMember.Delete();
}
else
{
dataType.Members.Remove(dataMember);
}
}
}
}
public void AddTypes_Fail()
{
var dataSet = new CremaDataSet();
var type1 = new CremaDataType("Type1");
var type2 = new CremaDataType("Type1");
var type3 = new CremaDataType("Type1", "/A/");
var type4 = new CremaDataType("Type1", "/A/");
dataSet.Types.Add(type1);
try
{
dataSet.Types.Add(type2);
Assert.Inconclusive();
}
catch
{
}
dataSet.Types.Add(type3);
try
{
dataSet.Types.Add(type4);
Assert.Inconclusive();
}
catch
{
}
}
public static string GetRandomValue(this CremaDataType dataType)
{
if (dataType.Members.Any() == false)
{
throw new Exception(dataType.TypeName);
}
if (dataType.IsFlag == true)
{
long value = 0;
var count = RandomUtility.Next(1, dataType.Members.Count);
for (var i = 0; i < count; i++)
{
var index = RandomUtility.Next(dataType.Members.Count);
value |= dataType.Members[index].Value;
}
var textvalue = dataType.ConvertToString(value);
if (textvalue == string.Empty)
{
throw new Exception();
}
return(textvalue);
}
else
{
return(dataType.Members.Random().Name);
}
}
private void WriteMembers(CremaDataType dataType, IXLWorksheet sheet)
{
var index = 1;
var rowIndex = 1;
if (this.settings.OmitAttribute == false)
{
sheet.Cell(rowIndex, index++).Value = CremaSchema.Tags;
sheet.Cell(rowIndex, index++).Value = CremaSchema.Enable;
}
sheet.Cell(rowIndex, index++).Value = CremaSchema.Name;
sheet.Cell(rowIndex, index++).Value = CremaSchema.Value;
sheet.Cell(rowIndex, index++).Value = CremaSchema.Comment;
if (this.settings.OmitSignatureDate == false)
{
sheet.Cell(rowIndex, index++).Value = CremaSchema.Creator;
sheet.Cell(rowIndex, index++).Value = CremaSchema.CreatedDateTime;
sheet.Cell(rowIndex, index++).Value = CremaSchema.Modifier;
sheet.Cell(rowIndex, index++).Value = CremaSchema.ModifiedDateTime;
}
this.WriteMembers(dataType.Members, sheet);
}
public void SetCremaType_Fail()
{
var type = new CremaDataType();
var column = new CremaDataColumn();
column.CremaType = type;
}
public static object GetRandomValue(this CremaDataType dataType)
{
var typeInfo = dataType.TypeInfo;
if (typeInfo.Members.Length == 0)
{
throw new Exception(dataType.Name);
}
if (typeInfo.IsFlag == true)
{
long value = 0;
int count = RandomUtility.Next(1, typeInfo.Members.Length);
for (int i = 0; i < count; i++)
{
var index = RandomUtility.Next(typeInfo.Members.Length);
value |= typeInfo.Members[index].Value;
}
var textvalue = typeInfo.ConvertToString(value);
if (textvalue == string.Empty)
{
throw new Exception();
}
return(textvalue);
}
else
{
return(typeInfo.Members.Random().Name);
}
}
public static CremaDataType Create(SerializationType serializedType)
{
var dataType = new CremaDataType();
Import(dataType, serializedType);
return(dataType);
}
public static void InitializeMembers(CremaDataType diffSource1, CremaDataType diffSource2, CremaDataType dataType1, CremaDataType dataType2)
{
//var hashValue1 = dataType1?.HashValue;
//var hashValue2 = dataType2?.HashValue;
diffSource1.BeginLoadData();
diffSource2.BeginLoadData();
//if (dataType1.HashValue != null && dataType1.HashValue == dataType2.HashValue)
{
var inlineBuilder = new SideBySideDiffBuilder(new Differ());
var memberText1 = dataType1 == null?DiffInternalUtility.GetString(dataType2.Items) : DiffInternalUtility.GetString(dataType1.Items);
var memberText2 = dataType2 == null?DiffInternalUtility.GetString(dataType1.Items) : DiffInternalUtility.GetString(dataType2.Items);
var memberDiff = inlineBuilder.BuildDiffModel(memberText1, memberText2);
DiffInternalUtility.FillMember(diffSource1, dataType1 ?? dataType2, memberDiff.OldText.Lines);
DiffInternalUtility.FillMember(diffSource2, dataType2 ?? dataType1, memberDiff.NewText.Lines);
}
//else
//{
//}
diffSource1.EndLoadData();
diffSource2.EndLoadData();
}
protected override async Task OnEndEditAsync(Authentication authentication)
{
var dataSet = this.TypeSource.DataSet;
var dataType = this.TypeSource;
var taskID = this.Domain.ID;
var dataTypes = new CremaDataType[] { dataType };
var itemPaths = new string[] { dataType.FullPath };
var dataBaseSet = await DataBaseSet.CreateAsync(this.DataBase, dataSet, DataBaseSetOptions.OmitUnlock | DataBaseSetOptions.AllowTypeCreation);
await this.Repository.LockAsync(authentication, this, nameof(OnEndEditAsync), itemPaths);
try
{
dataBaseSet.TypesToCreate = dataTypes;
this.types = await this.Types.AddNewAsync(authentication, dataBaseSet);
this.type = this.types.First();
this.Domain.Result = dataTypes.Select(item => item.TypeInfo).ToArray();
await base.OnEndEditAsync(authentication);
await this.Dispatcher.InvokeAsync(() => this.DataBase.InvokeTaskCompletedEvent(authentication, taskID));
}
finally
{
await this.Repository.UnlockAsync(authentication, this, nameof(OnEndEditAsync), itemPaths);
}
await this.Repository.UnlockAsync(authentication, this, nameof(OnCancelEditAsync), this.ItemPaths);
}
public static void CompareType(CremaDataType type1, CremaDataType type2)
{
if (type1 == null && type2 == null)
{
return;
}
if (type1 == null || type2 == null)
{
Assert.Fail("타입이 같지 않습니다.");
}
CompareSchema(type1, type2);
Assert.AreEqual(type1.TypeName, type2.TypeName, "TypeName");
Assert.AreEqual(type1.CategoryPath, type2.CategoryPath, "CategoryPath");
Assert.AreEqual(type1.Comment, type2.Comment, "Comment");
Assert.AreEqual(type1.CreationInfo, type2.CreationInfo, "CreationInfo");
Assert.AreEqual(type1.ModificationInfo, type2.ModificationInfo, "ModificationInfo");
Assert.AreEqual(type1.TypeInfo, type2.TypeInfo, "TypeInfo");
Assert.AreEqual(type1.Members.Count, type2.Members.Count, "Members.Count");
for (int i = 0; i < type1.Members.Count; i++)
{
CompareMember(type1.Members[i], type2.Members[i]);
}
}
public static void GenerateMembers(this CremaDataType dataType, int tryCount)
{
for (int i = 0; i < tryCount; i++)
{
CreateMember(dataType);
}
}
public void NewWithNullName()
{
var type = new CremaDataType(null);
Assert.AreEqual(string.Empty, type.TypeName);
Assert.AreEqual(PathUtility.Separator, type.CategoryPath);
Assert.AreEqual(CremaSchema.TypeNamespace + type.CategoryPath + type.TypeName, type.Namespace);
}
public static CremaDataType CreateRandomEmptyType(string prefix, string postfix)
{
var dataType = new CremaDataType(IdentifierUtility.Next(prefix, postfix));
dataType.IsFlag = RandomUtility.Within(25);
dataType.Comment = RandomUtility.Within(25) ? string.Empty : RandomUtility.NextString();
return(dataType);
}
protected TemplateViewModel(CremaDataType dataType, bool isNew)
{
this.isNew = isNew;
this.dataType = dataType;
this.typeName = dataType.TypeName;
this.count = 0;
this.DisplayName = Resources.Title_EditTypeTemplate;
}
public static CremaDataTypeMember AddRandomMember(this CremaDataType dataType)
{
var member = dataType.NewMember();
member.InitializeRandom();
dataType.Members.Add(member);
return(member);
}
public static CremaDataType CreateRandomType(string prefix, string postfix)
{
var dataType = new CremaDataType(IdentifierUtility.Next(prefix, postfix));
dataType.IsFlag = RandomUtility.Within(25);
dataType.Comment = RandomUtility.Within(25) ? string.Empty : RandomUtility.NextString();
dataType.AddRandomMembers(RandomUtility.Next(CremaDataTypeExtensions.MinMemberCount, CremaDataTypeExtensions.MaxMemberCount));
return(dataType);
}
public void NewWithNullNameAndType()
{
var categoryPath = RandomUtility.NextCategoryPath();
var type = new CremaDataType(null, categoryPath);
Assert.AreEqual(string.Empty, type.TypeName);
Assert.AreEqual(categoryPath, type.CategoryPath);
Assert.AreEqual(CremaSchema.TypeNamespace + type.CategoryPath + type.TypeName, type.Namespace);
}
public void NewWithName()
{
var typeName = RandomUtility.NextIdentifier();
var type = new CremaDataType(typeName);
Assert.AreEqual(typeName, type.TypeName);
Assert.AreEqual(PathUtility.Separator, type.CategoryPath);
Assert.AreEqual(CremaSchema.TypeNamespace + type.CategoryPath + type.TypeName, type.Namespace);
}
public void NewWithNameAndCategoryPath()
{
var typeName = RandomUtility.NextIdentifier();
var categoryPath = RandomUtility.NextCategoryPath();
var type = new CremaDataType(typeName, categoryPath);
Assert.AreEqual(typeName, type.TypeName);
Assert.AreEqual(categoryPath, type.CategoryPath);
Assert.AreEqual(CremaSchema.TypeNamespace + type.CategoryPath + type.TypeName, type.Namespace);
}
public static void DeleteItems(this CremaDataType dataType)
{
foreach (var item in dataType.Items.ToArray())
{
if ((bool)item.GetAttribute(DiffUtility.DiffEnabledKey) == false)
{
item.Delete();
}
}
}
private void ReadTypeMembers(XmlSchemaSimpleTypeRestriction restriction, CremaDataType dataType)
{
foreach (var item in restriction.Facets)
{
if (item is XmlSchemaEnumerationFacet)
{
this.ReadTypeMember(item as XmlSchemaEnumerationFacet, dataType);
}
}
}
protected override void DerializeSource(byte[] data)
{
var text = Encoding.UTF8.GetString(data).Decompress();
var index = text.IndexOf(";");
var path = text.Remove(index);
var itemName = new ItemName(path);
var xml = text.Substring(index + 1);
var dataSet = XmlSerializerUtility.ReadString <CremaDataSet>(xml);
this.dataType = dataSet.Types[itemName.Name];
}
private IDictionary <int, object> GetTypeMembers(CremaDataType dataType)
{
var props = new Dictionary <int, object>();
for (var i = 0; i < dataType.Members.Count; i++)
{
var typeMember = dataType.Members[i];
props.Add(i, this.GetTypeMember(typeMember));
}
return(props);
}
private string GetHashValue()
{
var argList = new List <object>(this.Members.Length * 2);
foreach (var item in this.Members)
{
argList.Add(item.Name);
argList.Add(item.Value);
}
return(CremaDataType.GenerateHashValue(argList.ToArray()));
}
public static CremaDataTypeMember AddEmptyMember(this CremaDataType dataType)
{
dataType.BeginLoadData();
var member = dataType.NewMember();
member.EmptyFields();
member.SetAttribute(DiffUtility.DiffEnabledKey, false);
member.SetAttribute(DiffUtility.DiffStateKey, DiffState.Imaginary);
dataType.Members.Add(member);
dataType.EndLoadData();
return(member);
}
public CremaDataTypeMember_Test()
{
this.userID = RandomUtility.NextWord();
this.dataType = new CremaDataType()
{
SignatureDateProvider = new SignatureDateProvider(userID)
};
this.dataType.IsFlag = RandomUtility.Within(25);
this.dataType.Comment = RandomUtility.Within(25) ? string.Empty : RandomUtility.NextString();
this.dataType.AddRandomMembers(10);
this.dataType.AcceptChanges();
}
public void AddTypes()
{
var dataSet = new CremaDataSet();
var type1 = new CremaDataType("Type1");
var type2 = new CremaDataType("Type1", "/A/");
var type3 = new CremaDataType("Type1", "/B/");
dataSet.Types.Add(type1);
dataSet.Types.Add(type2);
dataSet.Types.Add(type3);
}
public Type AddNew(Authentication authentication, CremaDataType dataType)
{
this.CremaHost.DebugMethod(authentication, this, nameof(AddNew), dataType.Name, dataType.CategoryPath);
this.ValidateAddNew(dataType.Name, dataType.CategoryPath, authentication);
this.Sign(authentication);
this.InvokeTypeCreate(authentication, dataType.Name, dataType.CategoryPath, dataType);
var type = this.BaseAddNew(dataType.Name, dataType.CategoryPath, authentication);
type.Initialize(dataType.TypeInfo);
this.InvokeTypesCreatedEvent(authentication, new Type[] { type, }, dataType.DataSet);
return(type);
}
public TypeDomain(DomainSerializationInfo serializationInfo, object source)
: base(serializationInfo, source)
{
this.IsNew = (bool)serializationInfo.GetProperty(nameof(IsNew));
this.dataType = source as CremaDataType;
this.view = this.dataType.View;
var dataSet = this.dataType.DataSet;
var itemPaths = (string)serializationInfo.GetProperty(nameof(ItemPaths));
dataSet.SetItemPaths(StringUtility.Split(itemPaths, ';'));
}
public SerializationType(CremaDataType dataType)
: this()
{
this.Tags = dataType.Tags;
this.DerivedTags = dataType.DerivedTags;
this.CategoryPath = dataType.CategoryPath;
this.Name = dataType.Name;
this.IsFlag = dataType.IsFlag;
this.Comment = dataType.Comment;
this.HashValue = dataType.TypeInfo.HashValue;
this.Members = dataType.Members.Select(item => new SerializationTypeMember(item)).ToArray();
}
