public static string Serialize(IKernelEventEnvelope eventEnvelope)
{
KernelCommandEnvelope.SerializationModel commandSerializationModel = null;
if (eventEnvelope.Event.Command is not null && eventEnvelope.Event.Command is not NoCommand)
{
var commandEnvelope = KernelCommandEnvelope.Create(eventEnvelope.Event.Command);
commandSerializationModel = new KernelCommandEnvelope.SerializationModel
{
command = commandEnvelope.Command,
commandType = commandEnvelope.CommandType,
token = eventEnvelope.Event.Command.GetToken()
};
}
var serializationModel = new SerializationModel
{
@event = eventEnvelope.Event,
eventType = eventEnvelope.EventType,
command = commandSerializationModel
};
return(JsonSerializer.Serialize(
serializationModel,
Serializer.JsonSerializerOptions));
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="modelTreeView">Diagram tree view.</param>
public SerializationViewModel(ViewModelStore viewModelStore, SerializationModel serializationModel)
: base(viewModelStore)
{
this.allVMs = new ObservableCollection <SerializedDomainModelViewModel>();
this.serializationModel = serializationModel;
this.selectedVMS = new Collection <object>();
this.rootVMs = new ObservableCollection <SerializedDomainModelViewModel>();
this.rootVMsRO = new ReadOnlyObservableCollection <SerializedDomainModelViewModel>(this.rootVMs);
this.selectRelationshipCommand = new DelegateCommand(SelectRelationshipCommand_Executed);
this.moveUpCommand = new DelegateCommand(MoveUpCommand_Executed, MoveUpCommand_CanExecute);
this.moveDownCommand = new DelegateCommand(MoveDownCommand_Executed, MoveDownCommand_CanExecute);
if (this.serializationModel.SerializedDomainModel != null)
{
this.rootVMs.Add(new SerializedDomainModelViewModel(this.ViewModelStore, this.serializationModel.SerializedDomainModel));
}
if (this.serializationModel != null)
{
foreach (SerializationClass c in this.serializationModel.Children)
{
if (c is SerializedDomainClass)
{
this.AddChild(c as SerializedDomainClass);
}
}
this.EventManager.GetEvent <ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
true, this.serializationModel.Id, new System.Action <ElementAddedEventArgs>(OnChildAdded));
this.EventManager.GetEvent <ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
true, this.serializationModel.Id, new System.Action <ElementDeletedEventArgs>(OnChildRemoved));
}
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
var authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
JavaScriptSerializer serializer = new JavaScriptSerializer();
SerializationModel serializeModel = serializer.Deserialize <SerializationModel>(authTicket.UserData);
MyPrincipal newUser = new MyPrincipal(authTicket.Name);
newUser.Id = serializeModel.Id;
newUser.FirstName = serializeModel.FirstName;
newUser.LastName = serializeModel.LastName;
newUser.Email = serializeModel.Email;
newUser.RoleId = serializeModel.RoleId;
newUser.BranchId = serializeModel.BranchId;
if (serializeModel.RoleId == 1)
{
newUser.IsAdmin = true;
}
else
{
newUser.IsAdmin = false;
}
HttpContext.Current.User = newUser;
}
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="modelTreeView">Diagram tree view.</param>
public SerializationViewModel(ViewModelStore viewModelStore, SerializationModel serializationModel)
: base(viewModelStore)
{
this.allVMs = new ObservableCollection<SerializedDomainModelViewModel>();
this.serializationModel = serializationModel;
this.selectedVMS = new Collection<object>();
this.rootVMs = new ObservableCollection<SerializedDomainModelViewModel>();
this.rootVMsRO = new ReadOnlyObservableCollection<SerializedDomainModelViewModel>(this.rootVMs);
this.selectRelationshipCommand = new DelegateCommand(SelectRelationshipCommand_Executed);
this.moveUpCommand = new DelegateCommand(MoveUpCommand_Executed, MoveUpCommand_CanExecute);
this.moveDownCommand = new DelegateCommand(MoveDownCommand_Executed, MoveDownCommand_CanExecute);
if (this.serializationModel.SerializedDomainModel != null)
{
this.rootVMs.Add(new SerializedDomainModelViewModel(this.ViewModelStore, this.serializationModel.SerializedDomainModel));
}
if (this.serializationModel != null)
{
foreach (SerializationClass c in this.serializationModel.Children)
if (c is SerializedDomainClass)
this.AddChild(c as SerializedDomainClass);
this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
true, this.serializationModel.Id, new System.Action<ElementAddedEventArgs>(OnChildAdded));
this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
true, this.serializationModel.Id, new System.Action<ElementDeletedEventArgs>(OnChildRemoved));
}
}
public static MyPrincipal getUser()
{
var authCookie = HttpContext.Current.Request[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie);
JavaScriptSerializer serializer = new JavaScriptSerializer();
SerializationModel serializeModel = serializer.Deserialize <SerializationModel>(authTicket.UserData);
MyPrincipal newUser = new MyPrincipal(authTicket.Name);
newUser.Id = serializeModel.Id;
newUser.FirstName = serializeModel.FirstName;
newUser.LastName = serializeModel.LastName;
newUser.Email = serializeModel.Email;
newUser.RoleId = serializeModel.RoleId;
newUser.BranchId = serializeModel.BranchId;
if (serializeModel.RoleId == 1)
{
newUser.IsAdmin = true;
}
else
{
newUser.IsAdmin = false;
}
return(newUser);
}
else
{
return(null);
}
}
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e)
{
if (e.ModelElement != null)
{
if (e.ModelElement.Store.TransactionManager.CurrentTransaction != null)
{
if (e.ModelElement.Store.TransactionManager.CurrentTransaction.IsSerializing)
{
return;
}
}
}
if (e.ModelElement == null)
{
return;
}
if (ImmutabilityExtensionMethods.GetLocks(e.ModelElement) != Locks.None)
{
return;
}
SerializationModel serializationModel = e.ModelElement as SerializationModel;
if (serializationModel != null)
{
string idElementName = serializationModel.SerializedIdAttributeName;
if (serializationModel.SerializedDomainModel != null)
{
serializationModel.SerializedDomainModel.SerializedIdAttributeName = idElementName;
}
foreach (SerializationClass s in serializationModel.Children)
{
if (s.IdProperty != null)
{
s.IdProperty.SerializationName = idElementName;
}
}
if (serializationModel.SerializedDomainModel != null)
{
if (serializationModel.SerializedDomainModel.IdProperty != null)
{
serializationModel.SerializedDomainModel.IdProperty.SerializationName = idElementName;
}
}
/*
*
* ReadOnlyCollection<ModelElement> elements = serializationModel.Store.ElementDirectory.FindElements(SerializedIdProperty.DomainClassId);
* foreach (ModelElement m in elements)
* (m as SerializedIdProperty).SerializationName = idElementName;
*
*
*/
}
}
/// <summary>
/// Initializes this object with the specified properties
/// </summary>
/// <param name="model">Serialization model</param>
/// <param name="roles">Available service roles</param>
public AppPrincipal(SerializationModel model, ServiceRoles roles)
{
Identity = new GenericIdentity(model.UserName);
UserId = model.UserId;
IsServiceUser = model.IsServiceUser;
SubscriptionId = model.SubscriptionId;
IsSubscriptionOwner = model.IsSubscriptionOwner;
ServiceRoles = roles ?? new ServiceRoles(new List <ServiceRoleDescription>());
}
public void Should_add_under_line_between_words()
{
SerializationModel model = new SerializationModel()
{
ChatId = "123"
};
string expected = "chat_id";
string serialized = Utils.Serialize(model);
serialized.Should().Contain(expected);
}
public void Should_remove_under_line_when_deserialize_objects()
{
string input = "{\"chat_id\":\"123\"}";
SerializationModel model = new SerializationModel()
{
ChatId = "123"
};
SerializationModel result = Utils.Deserialize <SerializationModel>(input);
result.Should().BeEquivalentTo(model);
}
public void DeepSerializationTest()
{
var sm = new SerializationModel {
IntProp = 5,
DoubleProp = 5.23,
StringProp = "string",
SPProp = new SerializationModel.SerializabeProp {
ListIntProp = new List <int> {
1, 2, 3, 4, 5
},
StringProp = "test",
ListSP2Prop = new List <SerializationModel.SerializabeProp.SerializableProp2> {
new SerializationModel.SerializabeProp.SerializableProp2 {
BoolProp = true,
ListStringProp = new List <string> {
"check", "list", "data"
}
},
new SerializationModel.SerializabeProp.SerializableProp2 {
BoolProp = false,
ListStringProp = new List <string> {
"mana", "healthpoints", "exp"
}
},
new SerializationModel.SerializabeProp.SerializableProp2 {
BoolProp = true,
ListStringProp = new List <string> {
"damage", "heal", "monk"
}
}
}
}
};
var bytes = sm.Serialize();
var dsm = new SerializationModel();
dsm.FillDeserialize(bytes);
Assert.AreEqual(sm.IntProp, dsm.IntProp);
Assert.AreEqual(sm.DoubleProp, dsm.DoubleProp);
Assert.AreEqual(sm.StringProp, dsm.StringProp);
Assert.AreEqual(sm.SPProp.StringProp, dsm.SPProp.StringProp);
Assert.AreEqual(sm.SPProp.ListIntProp.Count, dsm.SPProp.ListIntProp.Count);
for (var i = 0; i < sm.SPProp.ListIntProp.Count; i++)
{
Assert.AreEqual(sm.SPProp.ListIntProp[i], dsm.SPProp.ListIntProp[i]);
}
Assert.AreEqual(sm.SPProp.ListSP2Prop.Count, sm.SPProp.ListSP2Prop.Count);
for (var i = 0; i < sm.SPProp.ListSP2Prop.Count; i++)
{
Assert.AreEqual(sm.SPProp.ListSP2Prop[i], dsm.SPProp.ListSP2Prop[i]);
}
}
/// <summary>
/// Serializes this object into JSON
/// </summary>
/// <remarks>ServiceRoles are not serialized</remarks>
/// <returns>JSON representation of this object</returns>
public string Serialize()
{
var model = new SerializationModel
{
UserId = UserId,
UserName = Identity.Name,
SubscriptionId = SubscriptionId,
IsServiceUser = IsServiceUser,
IsSubscriptionOwner = IsSubscriptionOwner
};
return(JsonConvert.SerializeObject(model));
}
public static string Serialize(IKernelCommandEnvelope envelope)
{
var serializationModel = new SerializationModel
{
command = envelope.Command,
commandType = envelope.CommandType,
token = envelope.Token
};
return(JsonConvert.SerializeObject(
serializationModel,
Serializer.JsonSerializerSettings));
}
// GET: MyAccount
private void CreateAuthenticationTicket(UserModel model)
{
SerializationModel serializationModel = new SerializationModel();
serializationModel.FirstName = model.FirstName;
serializationModel.LastName = model.LastName;
serializationModel.Email = model.Email;
serializationModel.Id = model.Id;
serializationModel.RoleId = model.RoleID ?? 0;
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(serializationModel);
FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(1, model.Email, DateTime.Now, DateTime.Now.AddHours(8), false, userData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
Response.Cookies.Add(faCookie);
}
public void LoadSampleStream(string filename, SerializationModel model)
{
try
{
string[] str = filename.Split('/');
PHFetchResult assetResult = PHAsset.FetchAssetsUsingLocalIdentifiers(str, null);
PHAsset asset = assetResult.firstObject as PHAsset;
Stream stream = new MemoryStream();
PHImageManager.DefaultManager.RequestImageData(asset, null, (data, dataUti,
orientation, info) =>
{
byte[] byteArray = data.ToArray();
Stream streamm = new MemoryStream(byteArray);
dictionary.Add(filename, streamm);
model.Location = filename;
});
}
catch (Exception)
{
}
}
public static string ToDotNetSourceCode(this string json,
string rootTypeName,
SerializationModel serializetype = SerializationModel.DataContractJsonSerializer,
string language = @"CS")
{
var sb = new StringBuilder();
if (!string.IsNullOrEmpty(json))
{
var jtoken = JObject.Parse(json) as JToken;
if (null != jtoken)
{
var root = JsonRoot.ParseJsonIntoDataContract(jtoken, rootTypeName);
using (var stringWriter = new StringWriter(sb))
{
JsonRootCompiler compiler = new JsonRootCompiler(language, serializetype);
compiler.GenerateCode(root, stringWriter);
}
}
}
return(sb.ToString());
}
static void Main(string[] args)
{
string path = @"F:\Project\MyTest\MyTest\OutputTest\bin\Debug\Test.xml";
string bnpath = @"F:\Project\MyTest\MyTest\OutputTest\bin\Debug\bnTest.txt";
string jpath = @"F:\Project\MyTest\MyTest\OutputTest\bin\Debug\jTest.txt";
double[] data = new double[] { 10.2, 15.3, 4, 51.2, 5, 4, 0, -5.3, 5, 8 };
List <int> list = new List <int> {
6, 2, 48, 8, 6, 7, 4,
};
data.BubbleSort();
list.InsertSort();
foreach (var item in list)
{
Console.WriteLine(item);
}
People p = new People();
p.Name = "李静";
p.Sex = "女";
var t = ConvertHelpers.CreateInstanceByBase <Teacher, People>(p);
///启动队列
BusinessInfoHelper.Instance.start(StartThread);
BusinessInfoHelper.Instance.AddQueue("胡大帅3", "666666676666");
BusinessInfoHelper.Instance.AddQueue("胡大帅", "6666666666");
BusinessInfoHelper.Instance.AddQueue("胡大帅2", "66664666666");
List <SerializationModel> modellist = new List <SerializationModel>()
{
new SerializationModel()
{
name = "just fly", passWord = "******"
},
new SerializationModel()
{
name = "just fly1", passWord = "******"
},
new SerializationModel()
{
name = "just fly2", passWord = "******"
}
};
List <SerializationModel> nmodellist = new List <SerializationModel>();
foreach (var item in modellist)
{
nmodellist.Add(BinarySerializationHelper.DeepClone(item));
}
modellist[1].name = "hu";
SerializationModel model = BinarySerializationHelper.DeepClone(new SerializationModel()
{
name = "just fly", passWord = "******"
});
XmlSerializationHelper.SerializeToXml <List <SerializationModel> >(modellist, path);
var li = XmlSerializationHelper.DeSerializeFromXml <List <SerializationModel> >(path, true);
var ss = XmlSerializationHelper.SerializeToXml <List <SerializationModel> >(modellist);
var sss = XmlSerializationHelper.DeSerializeFromXml <List <SerializationModel> >(ss);
var bt = BinarySerializationHelper.FormatterObjectBytes(modellist);
BinarySerializationHelper.BinaryFileSave(bnpath, modellist);
var json = JsonSerializationHelper.SerializeToJson(modellist);
JsonSerializationHelper.SerializeToJson(modellist, jpath);
var dejson = JsonSerializationHelper.DeSerializeFromJson <List <SerializationModel> >(json);
var pdejson = JsonSerializationHelper.DeSerializeFromJson <List <SerializationModel> >(jpath, true);
Console.Read();
}
public static void Main(string[] arge)
{
#region data Query
var dicSelect = new Dictionary <EnumArryModel.Database, object>();
//+ where
dicSelect.Add(EnumArryModel.Database.Where, true);
//less Parameters
dicSelect.Add(EnumArryModel.Database.Wheretype, EnumArryModel.WhereType.RightLike);
//show 10 count
dicSelect.Add(EnumArryModel.Database.Top, 10);
string[] field = { "*" };
dicSelect.Add(EnumArryModel.Database.Field, field);
//database Name
dicSelect.Add(EnumArryModel.Database.DatabaseName, "CW100_develop");
//parameter Name
dicSelect.Add(EnumArryModel.Database.Key, "BrandID");
//Value
dicSelect.Add(EnumArryModel.Database.Value, "2");
//Table Name
dicSelect.Add(EnumArryModel.Database.TableName, "CW100_Product");
//Model
var sendSelect = new DatabseSend(EnumArryModel.SendType.Select, dicSelect, EnumArryModel.ReturnType.Json);
ISerializationModel ser = new SerializationModel();
//send
var parameter = ser.SuperBoyAnalytical(sendSelect);
var client = new SuperBoyICloudClient();
//get a return value
var returnValue = client.SuperBoyCloud(parameter);
if (returnValue != null)
{
}
#endregion
/*
*
#region 单数据修改
* Dictionary<EnumArry.Database, object> DicUPdate = new Dictionary<EnumArry.Database, object>();
* //带条件
* DicUPdate.Add(EnumArry.Database.WHERE, true);
* //小于参数
* DicUPdate.Add(EnumArry.Database.WHERETYPE, EnumArry.WhereType.Equal);
* //参数名
* DicUPdate.Add(EnumArry.Database.Key, "PID");
* //参数名值
* DicUPdate.Add(EnumArry.Database.Value, "1031");
* //值
* DicUPdate.Add(EnumArry.Database.UpdateKey, "ProductName");
* //修改值
* DicUPdate.Add(EnumArry.Database.UpdateValue, "555555");
* //表名
* DicUPdate.Add(EnumArry.Database.TableName, "CW100_Product");
*
*
* Model.Public.DatabseSend sendUpdate = new Model.Public.DatabseSend(EnumArry.SendType.SELECT, DicUPdate);
#endregion
#region 单数据删除
* Dictionary<EnumArry.Database, object> DicDelete = new Dictionary<EnumArry.Database, object>();
* //带条件
* DicDelete.Add(EnumArry.Database.WHERE, true);
* //小于参数
* DicDelete.Add(EnumArry.Database.WHERETYPE, EnumArry.WhereType.Less);
* //参数名
* DicDelete.Add(EnumArry.Database.Key, "PID");
* //值
* DicDelete.Add(EnumArry.Database.Value, 1000);
* //表名
* DicDelete.Add(EnumArry.Database.TableName, "CW100_Product");
*
* Model.Public.DatabseSend sendDelete = new Model.Public.DatabseSend(EnumArry.SendType.SELECT, DicDelete);
#endregion
#region 单数据增加
* /*
* Dictionary<EnumArry.Database, object> DicInster = new Dictionary<EnumArry.Database, object>();
* //带条件
* DicInster.Add(EnumArry.Database.WHERE, true);
* //小于参数
* DicInster.Add(EnumArry.Database.WHERETYPE, EnumArry.WhereType.Less);
* //显示10条
* DicInster.Add(EnumArry.Database.TOP, 10);
* //参数名
* DicInster.Add(EnumArry.Database.Key, "BrandID");
* //值
* DicInster.Add(EnumArry.Database.Value, 25);
*
* Model.Public.DatabseSend sendInster = new Model.Public.DatabseSend(EnumArry.SendType.SELECT, DicInster);
*
#endregion
*/
}
/// <summary>
/// Creates a new instance of the JsonRootCompiler class.
/// </summary>
/// <param name="language">The programming language in which the code will be generated.</param>
/// <param name="serializationModel">The serialization model used in the classes.</param>
public JsonRootCompiler(string language, SerializationModel serializationModel)
{
this.language = language;
this.serializationModel = serializationModel;
}
public JsonRootCompiler(string language, SerializationModel serializationModel)
{
this.language = language;
this.serializationModel = serializationModel;
}
