public static SoftFluent.Samples.GED.Directory LoadById(System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
SoftFluent.Samples.GED.Directory directory = new SoftFluent.Samples.GED.Directory();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.GED.Constants.SoftFluent_Samples_GEDStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Directory", "LoadById");
persistence.AddRawParameter("@Id", id);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
directory.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
directory.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(directory);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Samples.AspNetIdentity2.Role Load(System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
SoftFluent.Samples.AspNetIdentity2.Role role = new SoftFluent.Samples.AspNetIdentity2.Role();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.AspNetIdentity2.Constants.SoftFluent_Samples_AspNetIdentity2StoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Role", "Load");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
role.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
role.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(role);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Json.NET.Publication LoadById(int id)
{
if ((id == -1))
{
return(null);
}
SoftFluent.Json.NET.Publication publication = new SoftFluent.Json.NET.Publication();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Json.NET.Constants.SoftFluent_Json_NETStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Publication", "LoadById");
persistence.AddParameter("@Id", id, ((int)(-1)));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
publication.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
publication.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(publication);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static ContactManager.ContactSource LoadById(int id)
{
if ((id == -1))
{
return(null);
}
ContactManager.ContactSource contactSource = new ContactManager.ContactSource();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ContactManager.Constants.ContactManagerStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "ContactSource", "LoadById");
persistence.AddParameter("@Id", id, ((int)(-1)));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
contactSource.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
contactSource.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(contactSource);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Samples.GED.Page LoadOneToProcess()
{
SoftFluent.Samples.GED.Page page = new SoftFluent.Samples.GED.Page();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.GED.Constants.SoftFluent_Samples_GEDStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Page", "LoadOneToProcess");
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
page.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
page.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(page);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static ModelCodeFluent.Vehicle LoadByVehicleId(System.Guid vehicleId)
{
if ((vehicleId.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
ModelCodeFluent.Vehicle vehicle = new ModelCodeFluent.Vehicle();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ModelCodeFluent.Constants.ModelCodeFluentStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Vehicle", "LoadByVehicleId");
persistence.AddParameter("@VehicleId", vehicleId, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
vehicle.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
vehicle.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(vehicle);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static DigitalPicnik.List LoadById(System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
DigitalPicnik.List list = new DigitalPicnik.List();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(DigitalPicnik.Constants.DigitalPicnikStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "List", "LoadById");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
list.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
list.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(list);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static void SaveLocalizedValues(SoftFluent.Samples.RedisCache.Category entity, int lcid, bool isDefault, string name)
{
if ((entity == null))
{
throw new System.ArgumentNullException("entity");
}
if ((entity.Id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
CodeFluent.Runtime.CodeFluentRuntimeException.Throw("invalidEntityKey", "Id", "entity", "SoftFluent.Samples.RedisCache.Category");
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.RedisCache.Constants.SoftFluent_Samples_RedisCacheStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Category", "SaveLocalizedValues");
persistence.AddParameter("@entityId", entity.Id, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@Lcid", lcid);
persistence.AddRawParameter("@IsDefault", isDefault);
persistence.AddParameter("@Name", name, default(string));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
SoftFluent.Samples.RedisCache.Category.SaveLocalizedValuesUpdateRowVersion(reader, entity, lcid, isDefault, name);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
}
public static SoftFluent.Json.NET.Support LoadByName(string name)
{
if ((name == default(string)))
{
return(null);
}
SoftFluent.Json.NET.Support support = new SoftFluent.Json.NET.Support();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Json.NET.Constants.SoftFluent_Json_NETStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Support", "LoadByName");
persistence.AddParameter("@Name", name, default(string));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
support.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
support.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(support);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Samples.ExtendedSearch.Customer LoadById(int id)
{
if ((id == -1))
{
return(null);
}
SoftFluent.Samples.ExtendedSearch.Customer customer = new SoftFluent.Samples.ExtendedSearch.Customer();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.ExtendedSearch.Constants.SoftFluent_Samples_ExtendedSearchStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Customer", "LoadById");
persistence.AddParameter("@Id", id, ((int)(-1)));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
customer.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
customer.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(customer);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static ContactManager.User LoadByEmail(string email)
{
if ((email == default(string)))
{
return(null);
}
ContactManager.User user = new ContactManager.User();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ContactManager.Constants.ContactManagerStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "User", "LoadByEmail");
persistence.AddParameter("@Email", email, default(string));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
user.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
user.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(user);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.SqlServerInMemory.Customer LoadById(System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
SoftFluent.SqlServerInMemory.Customer customer = new SoftFluent.SqlServerInMemory.Customer();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.SqlServerInMemory.Constants.SoftFluent_SqlServerInMemoryStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Customer", "LoadById");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
customer.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
customer.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(customer);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Samples.Thinktecture.IdentityServer.Role LoadByName(string name)
{
if ((name == default(string)))
{
return(null);
}
SoftFluent.Samples.Thinktecture.IdentityServer.Role role = new SoftFluent.Samples.Thinktecture.IdentityServer.Role();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.Thinktecture.IdentityServer.Constants.SoftFluent_Samples_Thinktecture_IdentityServerStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Role", "LoadByName");
persistence.AddParameter("@Name", name, default(string));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
role.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
role.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(role);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static ModelCodeFluent.Identity.RoleClaim LoadById(System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
ModelCodeFluent.Identity.RoleClaim roleClaim = new ModelCodeFluent.Identity.RoleClaim();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ModelCodeFluent.Constants.ModelCodeFluentStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "RoleClaim", "LoadById");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
roleClaim.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
roleClaim.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(roleClaim);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Samples.AspNetIdentity1.User LoadByProviderKey(string providerKey)
{
if ((providerKey == default(string)))
{
return(null);
}
SoftFluent.Samples.AspNetIdentity1.User user = new SoftFluent.Samples.AspNetIdentity1.User();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.AspNetIdentity1.Constants.SoftFluent_Samples_AspNetIdentity1StoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "User", "LoadByProviderKey");
persistence.AddParameter("@providerKey", providerKey);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
user.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
user.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(user);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static SoftFluent.Samples.Thinktecture.IdentityServer.Login LoadById(System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
SoftFluent.Samples.Thinktecture.IdentityServer.Login login = new SoftFluent.Samples.Thinktecture.IdentityServer.Login();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.Thinktecture.IdentityServer.Constants.SoftFluent_Samples_Thinktecture_IdentityServerStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Login", "LoadById");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
login.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
login.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(login);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public static ContactManager.Address LoadByContact(int contactId)
{
if ((contactId == -1))
{
return(null);
}
ContactManager.Address address = new ContactManager.Address();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ContactManager.Constants.ContactManagerStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Address", "LoadByContact");
persistence.AddParameter("@ContactId", contactId);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
address.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
address.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(address);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Json.NET.Constants.SoftFluent_Json_NETStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Customer", "Save");
persistence.AddParameter("@Customer_Id", this.Id, ((int)(-1)));
persistence.AddParameter("@Customer_Name", this.Name, default(string));
persistence.AddParameter("@Customer_Address", this.Address, default(string));
persistence.AddParameter("@Customer_City", this.City, default(string));
persistence.AddParameter("@Customer_ZipCode", this.ZipCode, default(string));
persistence.AddParameter("@Customer_Country", this.Country, default(string));
persistence.AddParameter("@Customer_Phone", this.Phone, default(string));
persistence.AddParameter("@Customer_Fax", this.Fax, default(string));
persistence.AddParameter("@Customer_WebSite", this.WebSite, default(string));
persistence.AddParameterEnumInt32("@Customer_Language", this.Language, SoftFluent.Json.NET.Language.French);
persistence.AddParameterEnumInt32("@Customer_CustomerType", this.CustomerType, SoftFluent.Json.NET.CustomerType.Client);
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Json.NET.Constants.SoftFluent_Json_NETStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Campaign", "Save");
persistence.AddParameter("@Campaign_Id", this.Id, ((int)(-1)));
persistence.AddParameter("@Campaign_Name", this.Name, default(string));
persistence.AddParameterEnumInt32("@Campaign_State", this.State, SoftFluent.Json.NET.CampaignStateType.Conceived);
persistence.AddParameter("@Campaign_Customer_Id", this.CustomerId, ((int)(-1)));
persistence.AddParameter("@Campaign_Price", this.Price, CodeFluentPersistence.DefaultDecimalValue);
persistence.AddParameter("@Campaign_PriceAllTaxIncluded", this.PriceAllTaxIncluded, CodeFluentPersistence.DefaultDecimalValue);
persistence.AddParameter("@Campaign_DiscountRate", this.DiscountRate, CodeFluentPersistence.DefaultDecimalValue);
persistence.AddParameter("@Campaign_ConceptionDate", this.ConceptionDate, CodeFluentPersistence.DefaultDateTimeValue);
persistence.AddParameter("@Campaign_AddressedDate", this.AddressedDate, CodeFluentPersistence.DefaultDateTimeValue);
persistence.AddParameter("@Campaign_PropositionDate", this.PropositionDate, CodeFluentPersistence.DefaultDateTimeValue);
persistence.AddParameter("@Campaign_ConfirmationDate", this.ConfirmationDate, CodeFluentPersistence.DefaultDateTimeValue);
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.GED.Constants.SoftFluent_Samples_GEDStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Document", "Save");
persistence.AddParameter("@Document_Id", this.Id, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@Document_Text", this.Text, default(string));
persistence.AddParameter("@Document_User_Id", this.UserId, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@Document_Title", this.Title, default(string));
persistence.AddParameter("@Document_Directory_Id", this.DirectoryId, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@Document_Reference", this.Reference, default(string));
persistence.AddParameter("@Document_Token", this.Token, default(string));
persistence.AddRawParameter("@Document_IsProcessed", this.IsProcessed);
persistence.AddRawParameter("@Document_IsReady", this.IsReady);
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ContactManager.Constants.ContactManagerStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Contact", "Save");
persistence.AddParameter("@Contact_Id", this.Id, ((int)(-1)));
persistence.AddParameter("@Contact_Email", this.Email, default(string));
persistence.AddParameter("@Contact_FirstName", this.FirstName, default(string));
persistence.AddParameter("@Contact_LastName", this.LastName, default(string));
persistence.AddParameter("@Contact_ContactSource_Id", this.ContactSourceId, ((int)(-1)));
persistence.AddParameterEnumInt32("@Contact_Status", this.Status, ContactManager.Status.Valid);
persistence.AddParameter("@Contact_Address_Id", this.AddressId, ((int)(-1)));
persistence.AddParameter("@Contact_User_Id", this.UserId, ((int)(-1)));
persistence.AddParameter("@Contact_Description", this.Description, default(string));
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Json.NET.Constants.SoftFluent_Json_NETStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Space", "Save");
persistence.AddParameter("@Space_Id", this.Id, ((int)(-1)));
persistence.AddParameter("@Space_Name", this.Name, default(string));
persistence.AddParameter("@Space_Description", this.Description, default(string));
persistence.AddParameter("@Space_Width", this.Width, CodeFluentPersistence.DefaultSingleValue);
persistence.AddParameter("@Space_Height", this.Height, CodeFluentPersistence.DefaultSingleValue);
persistence.AddParameter("@Space_TVA", this.TVA, CodeFluentPersistence.DefaultSingleValue);
persistence.AddParameter("@Space_Price", this.Price, CodeFluentPersistence.DefaultDecimalValue);
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.SaveSupportRelations();
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.ComponentOne.Constants.SoftFluent_Samples_ComponentOneStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "User", "Save");
persistence.AddParameter("@User_Id", this.Id, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@User_Email", this.Email, default(string));
persistence.AddParameter("@User_FirstName", this.FirstName, default(string));
persistence.AddParameter("@User_LastName", this.LastName, default(string));
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
if ((this._photo != null))
{
this._photo.SaveMetaData(persistence.Context);
}
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(ModelCodeFluent.Constants.ModelCodeFluentStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "UserClaim", "Save");
persistence.AddParameter("@UserClaim_Id", this.Id, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@UserClaim_Type", this.Type, default(string));
persistence.AddParameter("@UserClaim_Value", this.Value, default(string));
persistence.AddParameter("@UserClaim_ValueType", this.ValueType, default(string));
persistence.AddParameter("@UserClaim_Issuer", this.Issuer, default(string));
persistence.AddParameter("@UserClaim_OriginalIssuer", this.OriginalIssuer, default(string));
persistence.AddParameter("@UserClaim_User_Id", this.UserId, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Json.NET.Constants.SoftFluent_Json_NETStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "StockItem", "Save");
persistence.AddParameter("@StockItem_Id", this.Id, ((int)(-1)));
persistence.AddParameter("@StockItem_Publication_Id", this.PublicationId, ((int)(-1)));
persistence.AddParameter("@StockItem_Space_Id", this.SpaceId, ((int)(-1)));
persistence.AddParameter("@StockItem_Quantity", this.Quantity, CodeFluentPersistence.DefaultInt32Value);
persistence.AddParameter("@StockItem_AvailableQuantity", this.AvailableQuantity, CodeFluentPersistence.DefaultInt32Value);
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
persistence.AddParameter("@_rowVersion", this.RowVersion);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
private static SoftFluent.Samples.RedisCache.Category CacheLoadById(bool useCache, System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
SoftFluent.Samples.RedisCache.Category category = null;
string cacheKey = null;
if ((useCache == true))
{
cacheKey = CodeFluent.Runtime.Caching.SimpleCacheManager.BuildCacheKey("b6b0a13b51906622a43903b7f403984a", id);
category = SoftFluent.Samples.RedisCache.Caching.CacheManager0.Manager.Get("SoftFluent.Samples.RedisCache.Category", cacheKey) as SoftFluent.Samples.RedisCache.Category;
if ((category != null))
{
return(category);
}
}
category = new SoftFluent.Samples.RedisCache.Category();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.RedisCache.Constants.SoftFluent_Samples_RedisCacheStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Category", "LoadById");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@Lcid", System.Threading.Thread.CurrentThread.CurrentUICulture.LCID, ((int)(1033)));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
category.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
category.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
if ((useCache == true))
{
SoftFluent.Samples.RedisCache.Caching.CacheManager0.Manager.Add("SoftFluent.Samples.RedisCache.Category", cacheKey, category, null);
}
return(category);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
protected virtual bool BaseSave(bool force)
{
if ((this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.ToBeDeleted))
{
this.Delete();
return(false);
}
CodeFluent.Runtime.CodeFluentEntityActionEventArgs evt = new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saving, true);
this.OnEntityAction(evt);
if ((evt.Cancel == true))
{
return(false);
}
CodeFluentPersistence.ThrowIfDeleted(this);
this.Validate();
if (((force == false) &&
(this.EntityState == CodeFluent.Runtime.CodeFluentEntityState.Unchanged)))
{
return(false);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.SqlServerInMemory.Constants.SoftFluent_SqlServerInMemoryStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Customer", "Save");
persistence.AddParameter("@Customer_Id", this.Id, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@Customer_Name", this.Name, default(string));
persistence.AddParameter("@Customer_ContactSource_Id", this.ContactSourceId, ((int)(-1)));
persistence.AddParameter("@_trackLastWriteUser", persistence.Context.User.Name);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecordOnSave(reader);
}
CodeFluentPersistence.NextResults(reader);
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
this.OnEntityAction(new CodeFluent.Runtime.CodeFluentEntityActionEventArgs(this, CodeFluent.Runtime.CodeFluentEntityAction.Saved, false, false));
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
return(true);
}
private static SoftFluent.Samples.RedisCache.Product CacheLoadById(bool useCache, System.Guid id)
{
if ((id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(null);
}
SoftFluent.Samples.RedisCache.Product product = null;
string cacheKey = null;
if ((useCache == true))
{
cacheKey = CodeFluent.Runtime.Caching.SimpleCacheManager.BuildCacheKey("96f79df7ee65805288ec849db001ded7", id);
product = SoftFluent.Samples.RedisCache.Caching.CacheManager1.Manager.Get("SoftFluent.Samples.RedisCache.Product", cacheKey) as SoftFluent.Samples.RedisCache.Product;
if ((product != null))
{
return(product);
}
}
product = new SoftFluent.Samples.RedisCache.Product();
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.RedisCache.Constants.SoftFluent_Samples_RedisCacheStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Product", "LoadById");
persistence.AddParameter("@Id", id, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
product.ReadRecord(reader, CodeFluent.Runtime.CodeFluentReloadOptions.Default);
product.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
if ((useCache == true))
{
SoftFluent.Samples.RedisCache.Caching.CacheManager1.Manager.Add("SoftFluent.Samples.RedisCache.Product", cacheKey, product, null);
}
return(product);
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(null);
}
public virtual bool Reload(CodeFluent.Runtime.CodeFluentReloadOptions options)
{
bool ret = false;
if (((this.RoleId.Equals(CodeFluentPersistence.DefaultGuidValue) == true) ||
(this.UserId.Equals(CodeFluentPersistence.DefaultGuidValue) == true)))
{
return(ret);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.GED.Constants.SoftFluent_Samples_GEDStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "UserRole", "Load");
persistence.AddParameter("@RoleId", this.RoleId, CodeFluentPersistence.DefaultGuidValue);
persistence.AddParameter("@UserId", this.UserId, CodeFluentPersistence.DefaultGuidValue);
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecord(reader, options);
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
ret = true;
}
else
{
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Deleted;
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(ret);
}
public virtual bool Reload(CodeFluent.Runtime.CodeFluentReloadOptions options)
{
bool ret = false;
if ((this.Id.Equals(CodeFluentPersistence.DefaultGuidValue) == true))
{
return(ret);
}
CodeFluent.Runtime.CodeFluentPersistence persistence = CodeFluentContext.Get(SoftFluent.Samples.EncryptAspect.Constants.SoftFluent_Samples_EncryptAspectStoreName).Persistence;
persistence.CreateStoredProcedureCommand(null, "Customer", "Load");
persistence.AddParameter("@Id", this.Id);
persistence.AddParameter("@PassPhrase", SoftFluent.Samples.EncryptAspect.PassPhrase.GetPassPhrase(), default(string));
System.Data.IDataReader reader = null;
try
{
reader = persistence.ExecuteReader();
if ((reader.Read() == true))
{
this.ReadRecord(reader, options);
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Unchanged;
ret = true;
}
else
{
this.EntityState = CodeFluent.Runtime.CodeFluentEntityState.Deleted;
}
}
finally
{
if ((reader != null))
{
reader.Dispose();
}
persistence.CompleteCommand();
}
return(ret);
}