public IPersistentAssemblyInfo Build(string customer, string order, string orderLine, string masterDetailDynamicAssembly) {
var unitOfWork = new UnitOfWork(_session.DataLayer);
var objectSpace = new ObjectSpace(unitOfWork, XafTypesInfo.Instance);
var persistentAssemblyBuilder = PersistentAssemblyBuilder.BuildAssembly(objectSpace, masterDetailDynamicAssembly);
IClassInfoHandler classInfoHandler = persistentAssemblyBuilder.CreateClasses(GetClassNames(customer, order, orderLine));
classInfoHandler.CreateTemplateInfos(persistentClassInfo => GetTemplateInfos(persistentClassInfo, customer, order));
classInfoHandler.SetInheritance(info => GetInheritance(info));
classInfoHandler.CreateReferenceMembers(classInfo => GetReferenceMembers(classInfo, customer, order, orderLine), true);
objectSpace.CommitChanges();
return persistentAssemblyBuilder.PersistentAssemblyInfo;
}
public void CurrentObject_Model_Should_Be_Validated_Every_Time_CurrentObject_Is_Saving(){
var editor = new ModelEditorPropertyEditor(null, null);
bool validated = false;
Isolate.WhenCalled(() => editor.Control.Controller.Dictionary.GetDiffs()).ReturnRecursiveFake();
Isolate.WhenCalled(() => editor.Control.Controller.Dictionary.Validate()).DoInstead(context => validated=true);
var objectSpace = new ObjectSpace(new UnitOfWork(XpoDefault.DataLayer),XafTypesInfo.Instance);
var modelDifferenceObject = new ModelDifferenceObject(objectSpace.Session) { PersistentApplication = new PersistentApplication(objectSpace.Session) };
editor.CurrentObject = modelDifferenceObject;
editor.Setup(objectSpace, Isolate.Fake.Instance<XafApplication>());
objectSpace.CommitChanges();
Assert.IsTrue(validated);
}
private void ImportEmployeeCheckInAction_Execute(object sender, PopupWindowShowActionExecuteEventArgs e)
{
var fileData = importParam.FileImport;
var savePath = "wwwroot\\Upload\\ImportCheckIn"
+ DateTime.Now.ToString("ddMMyyyyHHmmsstt")
+ ".xlsx";
fileData.SaveToPath(savePath);
var configFilePath = "wwwroot\\Map\\CheckInImportMap.xml";
ProcessImportLib.process_read_employee_checkin_data(
this.ObjectSpace,
savePath,
configFilePath);
ObjectSpace.CommitChanges();
ObjectSpace.Refresh();
View.Refresh();
}
void runProgramAction_Execute(object sender, SingleChoiceActionExecuteEventArgs e)
{
var choice = e.SelectedChoiceActionItem;
var captionPath = choice.GetCaptionPath();
switch (e.SelectedChoiceActionItem.Caption)
{
case "Daily Update":
ShowDailyCashUpdateForm(e.ShowViewParameters);
break;
case fixForecastFormCaption:
ShowFixForecastForm(e.ShowViewParameters);
break;
case mapSelectedCaption:
MapSelected();
break;
case "Reload Forex Forecast":
var uploader = new CashDiscipline.Module.Logic.Forex.ForexToCashFlowUploader((XPObjectSpace)ObjectSpace);
uploader.Process();
ObjectSpace.CommitChanges();
break;
case "Save Forecast":
SaveForecast();
break;
case "Reindex":
Reindex();
break;
default:
if (e.SelectedChoiceActionItem.Caption == processCubeCaption)
{
ProcessCube(e.SelectedChoiceActionItem.Caption);
}
break;
}
}
public override void UpdateDatabaseAfterUpdateSchema() {
base.UpdateDatabaseAfterUpdateSchema();
//string name = "MyName";
//DomainObject1 theObject = ObjectSpace.FindObject<DomainObject1>(CriteriaOperator.Parse("Name=?", name));
//if(theObject == null) {
// theObject = ObjectSpace.CreateObject<DomainObject1>();
// theObject.Name = name;
//}
CompanyUser sampleUser = ObjectSpace.FindObject<CompanyUser>(new BinaryOperator("UserName", "User"));
if (sampleUser == null)
{
sampleUser = ObjectSpace.CreateObject<CompanyUser>();
sampleUser.UserName = "******";
sampleUser.SetPassword("123");
}
UserRole defaultRole = CreateDefaultRole();
sampleUser.Roles.Add(defaultRole);
CS.Model.Security.CompanyUser userAdmin = ObjectSpace.FindObject<CompanyUser>(new BinaryOperator("UserName", "Admin"));
if (userAdmin == null)
{
userAdmin = ObjectSpace.CreateObject<CompanyUser>();
userAdmin.UserName = "******";
// Set a password if the standard authentication type is used
userAdmin.SetPassword("123");
}
// If a role with the Administrators name doesn't exist in the database, create this role
UserRole adminRole = ObjectSpace.FindObject<UserRole>(new BinaryOperator("Name", "Administrators"));
if (adminRole == null)
{
adminRole = ObjectSpace.CreateObject<UserRole>();
adminRole.Name = "Administrators";
}
adminRole.IsAdministrative = true;
adminRole.PermissionPolicy = SecurityPermissionPolicy.AllowAllByDefault;
userAdmin.Roles.Add(adminRole);
ObjectSpace.CommitChanges();
//This line persists created object(s).
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
var defaultRole = (SecuritySystemRole)ObjectSpace.GetDefaultRole();
if (ObjectSpace.IsNewObject(defaultRole))
{
var emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "User activation";
emailTemplate.Body = string.Format("A new user @Model.User.UserName has been created. To activate the account please click the following link {0}@Model.User.Activation",
((IModelRegistration)
((IModelOptionsRegistration)CaptionHelper.ApplicationModel.Options).Registration).ActivationHost + "?ua=");
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "pass forgotten";
emailTemplate.Body = "We created a temporary password (@Model.Password) for the UserName (@Model.User.UserName). Please login to reset it";
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "New Customer";
emailTemplate.Body = "A new customer created with fullname @Model.FullName";
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "Project created";
emailTemplate.Body = "We created a new project (@Model.Name).";
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "TaskStatusChanged";
emailTemplate.Body = "The Status of (@Model.Subject) changed to (@Model.Status)";
}
var adminRole = ObjectSpace.GetAdminRole("Admin");
var adminUser = (User)adminRole.GetUser("Admin");
adminUser.Email = "*****@*****.**";
var userRole = ObjectSpace.GetRole("User");
var user = (SecuritySystemUser)userRole.GetUser("user");
user.Roles.Add(defaultRole);
ObjectSpace.CommitChanges();
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
var defaultRole = (PermissionPolicyRole)ObjectSpace.GetDefaultRole();
if (ObjectSpace.IsNewObject(defaultRole))
{
var emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Configure(EmailTemplateConfig.UserActivation, "http://*****:*****@Model.FullName";
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "Project created";
emailTemplate.Body = "We created a new project (@Model.Name).";
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "TaskStatusChanged";
emailTemplate.Body = "The Status of (@Model.Subject) changed to (@Model.Status)";
emailTemplate = ObjectSpace.CreateObject <EmailTemplate>();
emailTemplate.Subject = "email from action";
emailTemplate.Body = "Email send for the task with subject (@Model.Subject)";
}
var adminRole = ObjectSpace.GetAdminRole("Admin");
var adminUser = (XpandPermissionPolicyUser)adminRole.GetUser("Admin");
adminUser.Email = "*****@*****.**";
var userRole = ObjectSpace.GetRole("User");
var user = (PermissionPolicyUser)userRole.GetUser("User");
user.Roles.Add(defaultRole);
ObjectSpace.CommitChanges();
}
public void SaveSnapshot()
{
#region Arrange
var ccyAUD = ObjectSpace.FindObject <Currency>(CriteriaOperator.Parse("Name = ?", "AUD"));
var account = ObjectSpace.CreateObject <Account>();
account.Name = "VHA ANZ AUD";
account.Currency = ccyAUD;
var activity = ObjectSpace.CreateObject <Activity>();
activity.Name = "AR Rcpt";
#endregion
#region Actions
var tranDate = new DateTime(2014, 03, 31);
decimal amount = 1000;
int loops = 2;
for (int i = 0; i < loops; i++)
{
var cf1 = ObjectSpace.CreateObject <CashFlow>();
cf1.TranDate = tranDate;
cf1.Account = account;
cf1.Activity = activity;
cf1.AccountCcyAmt = amount;
}
ObjectSpace.CommitChanges();
var logic = new SaveForecastSnapshot(ObjectSpace);
logic.Process();
ObjectSpace.Refresh();
var snapshot = ObjectSpace.FindObject <CashFlowSnapshot>(null);
#endregion
#region Asserts
var sCfs = snapshot.CashFlows;
Assert.AreEqual(amount * loops, sCfs.Sum(x => x.AccountCcyAmt));
#endregion
}
protected virtual bool InitializeSecurity()
{
if (IsNewSecuritySystem)
{
throw new NotImplementedException();
// var anonymousRole = (ISecurityRole)EnsureRoleExists(SecurityStrategy.AnonymousUserName, GetPermissions);
// EnsureAnonymousUser(null);
}
var admins = EnsureRoleExists(SecurityStrategy.AdministratorRoleName, GetPermissions);
EnsureUserExists(Admin, "Administrator", admins);
if (!ObjectSpace.IsNewObject(admins))
{
return(false);
}
var userRole = EnsureRoleExists(UserRole, GetPermissions);
EnsureUserExists("user", "user", userRole);
ObjectSpace.CommitChanges();
return(true);
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
if (!ObjectSpace.GetObjectsQuery <PersistentAssemblyInfo>().Any(info => info.Name == "OneToMany"))
{
var persistentAssemblyInfo = ObjectSpace.CreateObject <PersistentAssemblyInfo>();
persistentAssemblyInfo.Name = "OneToMany";
var projectCassInfo = persistentAssemblyInfo.CreateClass("Project");
var contributorClassInfo = persistentAssemblyInfo.CreateClass("Contributor");
projectCassInfo.TypeAttributes.Add(ObjectSpace.CreateObject <PersistentDefaultClassOptionsAttribute>());
projectCassInfo.CreateSimpleMember(DBColumnType.String, "Name");
projectCassInfo.CreateCollection(contributorClassInfo).CreateAssociation("Project-Contributors");
contributorClassInfo.TypeAttributes.Add(ObjectSpace.CreateObject <PersistentDefaultClassOptionsAttribute>());
contributorClassInfo.CreateSimpleMember(DBColumnType.String, "Name");
contributorClassInfo.CreateReferenceMember(projectCassInfo).CreateAssociation("Project-Contributors");
ObjectSpace.CommitChanges();
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
if (!ObjectSpace.GetObjectsQuery <DocumentObject>().Any())
{
var assembly = GetType().Assembly;
var documentObject = ObjectSpace.CreateObject <DocumentObject>();
documentObject.Name = "Test document 1";
documentObject.Content = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().First(s => s.Contains("Lorem"))).Bytes();
documentObject = ObjectSpace.CreateObject <DocumentObject>();
documentObject.Name = "Test document 2";
documentObject.Content = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().First(s => s.Contains("Lorem2"))).Bytes();
documentObject = ObjectSpace.CreateObject <DocumentObject>();
documentObject.Name = "Test document 3";
documentObject.Content = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().First(s => s.Contains("Lorem3"))).Bytes();
documentObject = ObjectSpace.CreateObject <DocumentObject>();
documentObject.Name = "Template";
documentObject.Content = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().First(s => s.Contains("LoresumV2"))).Bytes();
ObjectSpace.CommitChanges();
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
if (!ObjectSpace.GetObjectsQuery <Order>().Any())
{
for (int i = 0; i < 2; i++)
{
var product = ObjectSpace.CreateObject <Product>();
product.ProductName = $"{nameof(Product.ProductName)}{i}";
var accessory = ObjectSpace.CreateObject <Accessory>();
accessory.Product = product;
accessory.AccessoryName = $"{nameof(Accessory.AccessoryName)}{i}";
var order = ObjectSpace.CreateObject <Order>();
order.Product = product;
order.Accessory = accessory;
order.AggregatedOrders.Add(order);
}
ObjectSpace.CommitChanges();
}
}
private void Duyet_Execute(object sender, SimpleActionExecuteEventArgs e)
{
LanTangCa lanTangCa = (LanTangCa)View.CurrentObject;
lanTangCa.ngayDuyet = DateTime.Today;
lanTangCa.nguoiDuyet = lanTangCa.Session.GetObjectByKey <NguoiDung>(SecuritySystem.CurrentUserId);
CriteriaOperator criteriaOperator = CriteriaOperator.And(CriteriaOperator.Parse("[nguoiChamCong] = ?", lanTangCa.nguoiTangCa), CriteriaOperator.Parse("[ngay.ngayChamCong] = ?", lanTangCa.ngayTangCa));
GioCong gio = ObjectSpace.FindObject <GioCong>(criteriaOperator);
if (!Equals(gio, null))
{
gio.soGioTangCa = lanTangCa.thoiGianTangCa;
gio.ngayDuyet = lanTangCa.ngayDuyet;
lanTangCa.gioCong = gio;
}
ObjectSpace.CommitChanges();
ObjectSpace.Refresh();
View.Refresh();
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
if (ObjectSpace.FindObject <Customer>(null) == null)
{
var customer = ObjectSpace.CreateObject <Customer>();
customer.Name = "Apostolis Bekiaris";
var order = ObjectSpace.CreateObject <Order>();
order.Quantity = 2;
customer.Orders.Add(order);
order = ObjectSpace.CreateObject <Order>();
order.Quantity = 3;
customer.Orders.Add(order);
order = ObjectSpace.CreateObject <Order>();
order.Quantity = 4;
customer.Orders.Add(order);
ObjectSpace.CommitChanges();
}
}
private void runProgramAction_Execute(object sender, SingleChoiceActionExecuteEventArgs e)
{
var algo = new SqlAlgorithm((XPObjectSpace)ObjectSpace);
algo.CommandText =
@"DECLARE @AustPostSettleActivity uniqueidentifier = (SELECT TOP 1 AustPostSettleActivity FROM SetOfBOoks WHERE GCRecord IS NULL)
INSERT INTO AustPostSettle
(
Oid,
BankStmt,
BankStmtDate,
BankStmtAmount,
GrossAmount,
DishonourChequeFee,
NegativeCorrections,
DishonourChequeReversal,
GrossCommission,
CommissionGST,
DateTimeCreated
)
SELECT
NEWID(),
bs.Oid,
bs.TranDate,
bs.TranAmount,
bs.TranAmount,
0.00,
0.00,
0.00,
0.00,
0.00,
GETDATE()
FROM BankStmt bs
WHERE bs.GCRecord IS NULL
AND bs.Activity = @AustPostSettleActivity
AND NOT EXISTS (SELECT * FROM AustPostSettle aps WHERE aps.BankStmt = bs.Oid AND aps.GCRecord IS NULL)" ;
algo.Process();
ObjectSpace.CommitChanges();
}
public void DeleteLookupObjects()
{
#region Arrange
for (int i = 0; i < 2; i++)
{
var lookup1 = ObjectSpace.CreateObject <MockLookupObject1>();
var lookup2 = ObjectSpace.CreateObject <MockLookupObject2>();
for (int j = 0; j < 2; j++)
{
var fact = ObjectSpace.CreateObject <MockFactObject>();
fact.LookupObject1 = lookup1;
fact.LookupObject2 = lookup2;
}
}
ObjectSpace.CommitChanges();
#endregion
#region Delete Lookup Objects
{
var deleter = new BatchDeleter(ObjectSpace);
var lookup1s = ObjectSpace.GetObjects <MockLookupObject1>();
deleter.Delete(lookup1s);
}
#endregion
#region Assert
{
var facts = ObjectSpace.GetObjects <MockFactObject>();
var lookup1s = ObjectSpace.GetObjects <MockLookupObject1>();
var lookup2s = ObjectSpace.GetObjects <MockLookupObject2>();
Assert.AreEqual(0, lookup1s.Count);
Assert.AreEqual(2, lookup2s.Count);
Assert.AreEqual(0, facts.Count);
}
#endregion
}
public void AddToObjectCacheTwice_Level1()
{
#region Arrange
var xpoFieldMapper = new XpoFieldMapper();
var typeInfo = XafTypesInfo.Instance.FindTypeInfo(typeof(MockFactObject));
var memberInfo = typeInfo.FindMember("MockLookupObject1");
#endregion
#region Act
var targetObj1 = ObjectSpace.CreateObject <MockFactObject>();
targetObj1.Description = "Target 1";
xpoFieldMapper.SetMemberValue(targetObj1, memberInfo, "Apple", true, true);
var targetObj2 = ObjectSpace.CreateObject <MockFactObject>();
targetObj2.Description = "Target 2";
xpoFieldMapper.SetMemberValue(targetObj2, memberInfo, "Apple", true, true);
ObjectSpace.CommitChanges();
#endregion
#region Assert
var targetObjs = ObjectSpace.GetObjects <MockFactObject>();
var retargetObj1 = targetObjs.Where(x => x.Description == "Target 1").FirstOrDefault();
var retargetObj2 = targetObjs.Where(x => x.Description == "Target 2").FirstOrDefault();
Assert.NotNull(retargetObj1);
Assert.NotNull(retargetObj1.MockLookupObject1);
Assert.NotNull(retargetObj2);
Assert.NotNull(retargetObj2.MockLookupObject1);
#endregion
}
public override void Load(ModelApplicationBase model)
{
var extraDiffStoresLayerBuilder = new ExtraDiffStoresLayerBuilder();
var language = model.Application.PreferredLanguage;
if (UseModelFromPath())
{
return;
}
var loadedModelDifferenceObjectInfos = GetLoadedModelDifferenceObjectInfos(model);
extraDiffStoresLayerBuilder.AddLayers(loadedModelDifferenceObjectInfos, _extraDiffStores);
if (_loadResources)
{
CreateResourceModels(model, loadedModelDifferenceObjectInfos);
}
if (model.Application.PreferredLanguage != language)
{
Application.SetLanguage(model.Application.PreferredLanguage);
}
ObjectSpace.CommitChanges();
}
void UpdateVersionInXaml(ITypeInfo objectsTypeInfo, Version newVersion)
{
if (objectsTypeInfo != null && objectsTypeInfo.IsPersistent)
{
IMemberInfo xamlMemberInfo = objectsTypeInfo.FindMember(XamlPropertyName);
if (xamlMemberInfo == null)
{
throw new MemberNotFoundException(objectsTypeInfo.Type, XamlPropertyName);
}
foreach (object objectToUpdate in ObjectSpace.GetObjects(objectsTypeInfo.Type))
{
var currentXaml = xamlMemberInfo.GetValue(objectToUpdate) as string;
string updatedXaml = WorkflowDefinitionsUpdater.UpdateDxAssembliesVersions(currentXaml, newVersion);
xamlMemberInfo.SetValue(objectToUpdate, updatedXaml);
ObjectSpace.SetModified(objectToUpdate);
}
if (ObjectSpace.IsModified)
{
ObjectSpace.CommitChanges();
}
}
}
void selectSemesterForClassTransactionTrackingAcception_Accepting(object sender, DialogControllerAcceptingEventArgs e)
{
ObjectSpace objectSpace = Application.CreateObjectSpace();
ListView lv = ((ListView)((WindowController)sender).Window.View);
Semester semester = lv.SelectedObjects.Count == 0 ? null : lv.SelectedObjects[0] as Semester;
//GroupOperator classroomsOp = new GroupOperator(CriteriaOperator.Parse("1=0"));
//ContainsOperator biOperator;
string strParse = "";
if (semester != null)
{
//NestedObjectSpace nobj= objectSpace.CreateNestedObjectSpace();
foreach (StudentClass studentClass in View.SelectedObjects)
{
ClassTransactionTracking ct = objectSpace.FindObject <ClassTransactionTracking>
(CriteriaOperator.Parse("StudentClass.ClassCode = ? and Semester.SemesterName = ?",
studentClass.ClassCode, semester.SemesterName));
if (ct == null)
{
ct = objectSpace.CreateObject <ClassTransactionTracking>();
ct.Semester = objectSpace.FindObject <Semester>(CriteriaOperator.Parse("SemesterName=?", semester.SemesterName));
ct.StudentClass = objectSpace.FindObject <StudentClass>(CriteriaOperator.Parse("ClassCode=?", studentClass.ClassCode));
ct.Save();
}
//biOperator = new ContainsOperator("StudentClasses", new BinaryOperator("ClassCode", studentClass.ClassCode));
//classroomsOp = new GroupOperator(GroupOperatorType.Or, classroomsOp, biOperator);
strParse += (strParse == "" ? string.Format("StudentClass.ClassCode='{0}'", studentClass.ClassCode) :
string.Format(" or StudentClass.ClassCode='{0}'", studentClass.ClassCode));
}
objectSpace.CommitChanges();
ReportData reportData = objectSpace.FindObject <ReportData>(
new BinaryOperator("Name", "Tỉ lệ nợ lớp biên chế NHHK"));
strParse = string.Format("({0}) and Semester.SemesterName= '{1}'", strParse, semester.SemesterName);
ReportServiceController rsc = ((WindowController)sender).Frame.GetController <ReportServiceController>();
rsc.ShowPreview((IReportData)reportData, CriteriaOperator.Parse(strParse)); //classroomsOp);
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
// Disable version
if (this.CurrentDBVersion != new Version("1.1.1.220"))
{
return;
}
//
FileInfo fi = new FileInfo(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName);
String dir = fi.Directory.FullName + "\\Import\\";
//
using (IObjectSpace os = ObjectSpace.CreateNestedObjectSpace()) {
var imp_ot = new SimpleAnalyticImporter <fmCFinIndex>();
imp_ot.Import(os, dir + "fmCFinIndex.csv");
var imp_fiv = new FinIndexItemImporter();
imp_fiv.Import(os, dir + "fmCFinIndexItem.csv");
os.CommitChanges();
}
ObjectSpace.CommitChanges();
}
private void CreateIOCP()
{
CreateIocp("MODUL1", 1, 0);
CreateIocp("MODUL2", 2, 0);
CreateIocp("MP1", 3, 4);
CreateIocp("MP2", 4, 4);
CreateIocp("MP3", 5, 4);
CreateIocp("MP4", 6, 4);
CreateIocp("MP5", 7, 4);
CreateIocp("MP6", 8, 4);
CreateIocp("MP7", 9, 4);
CreateIocp("MP8", 10, 4);
CreateIocp("MP9", 11, 4);
CreateIocp("MP10", 12, 4);
CreateIocp("MP11", 13, 4);
CreateIocp("MP12", 14, 4);
CreateIocp("MP13", 15, 4);
CreateIocp("MP14", 16, 4);
CreateIocp("MP15", 17, 4);
CreateIocp("MP16", 18, 4);
ObjectSpace.CommitChanges();
}
public override void UpdateDatabaseAfterUpdateSchema()
{
var session = ((XPObjectSpace)ObjectSpace).Session;
if (new QueryModelDifferenceObject(session).GetActiveModelDifference(ModelCombine, FeatureCenterModule.Application) == null)
{
new ModelDifferenceObject(session).InitializeMembers(ModelCombine, FeatureCenterModule.Application);
var role = Updater.EnsureRoleExists(ModelCombine, customizableRole => GetPermissions(customizableRole, Updater));
var user = Updater.EnsureUserExists(ModelCombine, ModelCombine, role);
var collection = ((XPBaseCollection)XafTypesInfo.Instance.FindTypeInfo(role.GetType()).FindMember("Users"));
collection.BaseAdd(user);
ObjectSpace.CommitChanges();
}
var modelDifferenceObjects = new XpandXPCollection <ModelDifferenceObject>(session, o => o.PersistentApplication.Name == "FeatureCenter");
foreach (var modelDifferenceObject in modelDifferenceObjects)
{
modelDifferenceObject.PersistentApplication.Name =
Path.GetFileNameWithoutExtension(modelDifferenceObject.PersistentApplication.ExecutableName);
}
ObjectSpace.CommitChanges();
}
private void ComprobanteDuplicarAction_Execute(object sender, SimpleActionExecuteEventArgs e)
{
var selectedComprobantes = View.SelectedObjects;
if (selectedComprobantes.Count == 0)
{
throw new UserFriendlyException("Seleccione al menos un comprobante");
}
var cloner = new BasicObjectCloner(true);
foreach (ComprobanteBase selected in selectedComprobantes)
{
selected.SetIgnoreOnChangedRecursive(true);
var copy = (ComprobanteBase)cloner.CloneTo(selected, selected.GetType());
DuplicarComprobante(copy);
}
ObjectSpace.CommitChanges();
View.Refresh();
}
private void simpleAction_AddDataSource_Execute(object sender, SimpleActionExecuteEventArgs e)
{
ObjectSpace.CommitChanges();
var dataSourceBase = InitializeWizard();
if (dataSourceBase == null)
{
return;
}
ViewCurrentObject.DataSourceXml = dataSourceBase.SaveToXml().ToString();
var cu = View.CurrentObject as DoSoScheduleBase;
if (cu != null)
{
cu.DataSource = dataSourceBase;
}
ObjectSpace.CommitChanges();
}
private void AutoBinding_Execute(object sender, SimpleActionExecuteEventArgs e)
{
//fmCSAStatementAccount current = e.CurrentObject as fmCSAStatementAccount;
//if (current == null) return;
//using (IObjectSpace os = ObjectSpace.CreateNestedObjectSpace()) {
// current = os.GetObject<fmCSAStatementAccount>(current);
// current.AutoBinding(null);
// os.CommitChanges();
//}
foreach (fmCSAStatementAccount sa in e.SelectedObjects)
{
using (IObjectSpace os = ObjectSpace.CreateNestedObjectSpace()) {
fmCSAStatementAccount nestedSA = os.GetObject <fmCSAStatementAccount>(sa);
nestedSA.AutoBinding(null);
os.CommitChanges();
}
}
ObjectSpace.CommitChanges();
DevExpress.XtraEditors.XtraMessageBox.Show("Автоматическая привязка Заявок и платёжных документов произведена успешно");
}
protected override void OnActivated()
{
base.OnActivated();
CriteriaOperator criteria = CriteriaOperator.And(CriteriaOperator.Parse("[thangChamCong] Is Null"));
CriteriaOperator criteriaOperator = new BinaryOperator("Id", new JoinOperand("ThangChamCong", null, Aggregate.Max, new OperandProperty("Id")));
var thangChamCong = (ThangChamCong)ObjectSpace.FindObject <ThangChamCong>(criteriaOperator);
if ((Equals(thangChamCong, null)) || thangChamCong.thangChamCong.Month < DateTime.Today.Month)
{
ThangChamCong thang = ObjectSpace.CreateObject <ThangChamCong>();
DateTime thangCham = DateTime.Today;
thang.ngayCapNhat = DateTime.Now;
thang.thangChamCong = thangCham;
}
else
{
IList <NgayTinhCong> ngayTinhCongs = ObjectSpace.GetObjects <NgayTinhCong>(criteria);
if (!Equals(ngayTinhCongs, null))
{
IList <ThangChamCong> thangChamCongs = ObjectSpace.GetObjects <ThangChamCong>();
foreach (NgayTinhCong ngayTinhCong in ngayTinhCongs)
{
foreach (ThangChamCong thang in thangChamCongs)
{
if ((ngayTinhCong.ngayChamCong.Month == thang.thangChamCong.Month) && (ngayTinhCong.ngayChamCong.Year == thang.thangChamCong.Year))
{
ngayTinhCong.thangChamCong = thang;
thang.ngayCapNhat = DateTime.Now;
}
}
}
}
}
ObjectSpace.CommitChanges();
ObjectSpace.Refresh();
View.Refresh();
// Perform various tasks depending on the target View.
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
OAuthUser sampleUser = ObjectSpace.FindObject <OAuthUser>(new BinaryOperator("UserName", "User"));
if (sampleUser == null)
{
sampleUser = ObjectSpace.CreateObject <OAuthUser>();
sampleUser.UserName = "******";
sampleUser.EnableStandardAuthentication = true;
sampleUser.SetPassword("");
}
PermissionPolicyRole defaultRole = CreateDefaultRole();
sampleUser.Roles.Add(defaultRole);
OAuthUser userAdmin = ObjectSpace.FindObject <OAuthUser>(new BinaryOperator("UserName", "Admin"));
if (userAdmin == null)
{
userAdmin = ObjectSpace.CreateObject <OAuthUser>();
userAdmin.UserName = "******";
userAdmin.EnableStandardAuthentication = true;
// Set a password if the standard Authentication type is used
userAdmin.SetPassword("");
}
// If a role with the Administrators name doesn't exist in the database, create this role
PermissionPolicyRole adminRole = ObjectSpace.FindObject <PermissionPolicyRole>(new BinaryOperator("Name", "Administrators"));
if (adminRole == null)
{
adminRole = ObjectSpace.CreateObject <PermissionPolicyRole>();
adminRole.Name = "Administrators";
}
adminRole.IsAdministrative = true;
userAdmin.Roles.Add(adminRole);
ObjectSpace.CommitChanges(); //This line persists created object(s).
}
private void saCancel_Execute(object sender, SimpleActionExecuteEventArgs e)
{
var timezone = ObjectSpace.GetObjects <Site>().First().Timezone;
var siteNow = DateTime.UtcNow.AddHours(timezone);
foreach (OrderDetail orderDetail in e.SelectedObjects)
{
if (orderDetail.Status == EOrderStatus.Canceled)
{
continue; // skip cancelled orders
}
// set order status
orderDetail.Status = EOrderStatus.Canceled;
// find related transaction. If exists create counter record.
var orderDetailTransactionDetail = orderDetail.TransactionDetail;
if (orderDetailTransactionDetail != null)
{
// create counter transaction
var transaction = ObjectSpace.CreateObject <Transaction>();
var transactionDetail = ObjectSpace.CreateObject <TransactionDetail>();
var orderTransaction = orderDetailTransactionDetail.Transaction;
transaction.Card = orderTransaction.Card;
transaction.ProductType = orderTransaction.ProductType;
transaction.DateEffective = orderTransaction.Date;
transactionDetail.Item = orderDetailTransactionDetail.Item;
transactionDetail.Quantity = orderDetailTransactionDetail.Quantity * -1; // inverse quantity
transactionDetail.Total = orderDetailTransactionDetail.Total * -1; // inverse total
transaction.TransactionDetails.Add(transactionDetail);
transaction.UpdateTotalsAndDate(siteNow);
transaction.Date = orderTransaction.Date; // todo burası parametrik yapılacak.
transaction.IsCancel = true;
transactionDetail.IsCancel = true;
orderDetail.CancelTransactionDetail = transactionDetail;
}
}
ObjectSpace.CommitChanges();
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
var sampleUser = ObjectSpace.FindObject <PermissionPolicyUser>(new BinaryOperator("UserName", "User"));
if (sampleUser == null)
{
sampleUser = ObjectSpace.CreateObject <PermissionPolicyUser>();
sampleUser.UserName = "******";
sampleUser.SetPassword("");
}
var defaultRole = CreateDefaultRole();
sampleUser.Roles.Add(defaultRole);
var userAdmin = ObjectSpace.FindObject <PermissionPolicyUser>(new BinaryOperator("UserName", "Admin"));
if (userAdmin == null)
{
userAdmin = ObjectSpace.CreateObject <PermissionPolicyUser>();
userAdmin.UserName = "******";
userAdmin.SetPassword("");
}
var adminRole = ObjectSpace.FindObject <PermissionPolicyRole>(new BinaryOperator("Name", "Administrators"));
if (adminRole == null)
{
adminRole = ObjectSpace.CreateObject <PermissionPolicyRole>();
adminRole.Name = "Administrators";
}
adminRole.IsAdministrative = true;
userAdmin.Roles.Add(adminRole);
ObjectSpace.CommitChanges();
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
if (ObjectSpace.FindObject <Country>(null) == null)
{
var country = ObjectSpace.CreateObject <Country>();
country.Name = "USA";
var customer = ObjectSpace.CreateObject <Customer>();
customer.Name = "DevExpress";
customer.Country = country;
customer = ObjectSpace.CreateObject <Customer>();
customer.Name = "Ray";
customer.Country = country;
country = ObjectSpace.CreateObject <Country>();
country.Name = "Netherlands";
country.EUMember = true;
customer = ObjectSpace.CreateObject <Customer>();
customer.Name = "Impactive";
customer.Country = country;
customer = ObjectSpace.CreateObject <Customer>();
customer.Name = "Tolis";
customer.Country = country;
var securitySystemRole = (SecuritySystemRole)ObjectSpace.GetRole("Admin");
securitySystemRole.IsAdministrative = true;
var user = (SecuritySystemUser)ObjectSpace.GetUser("Admin");
user.Roles.Add(securitySystemRole);
securitySystemRole = (SecuritySystemRole)ObjectSpace.GetRole("User");
securitySystemRole.SetTypePermissions(typeof(Customer), SecurityOperations.FullAccess, SecuritySystemModifier.Allow);
securitySystemRole.SetTypePermissions(typeof(Country), SecurityOperations.FullAccess, SecuritySystemModifier.Allow);
user = ObjectSpace.CreateObject <SecuritySystemUser>();
user.Roles.Add(securitySystemRole);
ObjectSpace.CommitChanges();
}
}
public override void UpdateDatabaseAfterUpdateSchema()
{
base.UpdateDatabaseAfterUpdateSchema();
CreateClassLevelObjects();
CreateMemberLevelObjects();
CreateObjectLevelObjects();
PermissionPolicyRole administratorRole = CreateAdministratorRole();
PermissionPolicyUser userAdmin = ObjectSpace.FindObject <PermissionPolicyUser>(new BinaryOperator("UserName", "Sam"));
if (userAdmin == null)
{
userAdmin = ObjectSpace.CreateObject <PermissionPolicyUser>();
userAdmin.UserName = "******";
userAdmin.IsActive = true;
userAdmin.SetPassword("");
userAdmin.Roles.Add(administratorRole);
}
PermissionPolicyRole securityDemoRole = CreateSecurityDemoRole();
PermissionPolicyUser userJohn = ObjectSpace.FindObject <PermissionPolicyUser>(new BinaryOperator("UserName", "John"));
if (userJohn == null)
{
userJohn = ObjectSpace.CreateObject <PermissionPolicyUser>();
userJohn.UserName = "******";
userJohn.IsActive = true;
//userJohn.Roles.Add(defaultRole);
userJohn.Roles.Add(securityDemoRole);
userJohn.Save();
}
ObjectSpace.CommitChanges();
}
public static XPCollection<WeekReportData> CreateClassroomTimetableData(ObjectSpace objectSpace, string classroomCode, string semesterName)
{
ConstrainstParameter cp = objectSpace.FindObject<ConstrainstParameter>(
new BinaryOperator("Code", "AFTERNOONPERIODCOUNT"));
int afternoonPeriodCount = Convert.ToInt32(cp.Value);
cp = objectSpace.FindObject<ConstrainstParameter>(
new BinaryOperator("Code", "MORNINGPERIODCOUNT"));
int morningPeriodCount = Convert.ToInt32(cp.Value);
try
{
using (XPCollection<WeekReportData> xpw = new XPCollection<WeekReportData>(objectSpace.Session,
new ContainsOperator("Classrooms", new BinaryOperator("ClassroomCode", classroomCode))))
{
objectSpace.Delete(xpw);
objectSpace.CommitChanges();
using (XPCollection<TkbSemester> xpctkbSemester = new XPCollection<TkbSemester>(objectSpace.Session,
new GroupOperator(GroupOperatorType.And, new BinaryOperator("Lesson.Semester.SemesterName",
semesterName), new BinaryOperator("Classroom.ClassroomCode", classroomCode))))
{
Dictionary<string, WeekReportData> dicTimePeriodforWeekData = new Dictionary<string, WeekReportData>();
WeekReportData currentWeekData;
foreach (TkbSemester tkbSem in xpctkbSemester)
{
string[] strperiod = tkbSem.Period.Split(',');
List<string> periodTimeList = new List<string>();
foreach (string s in strperiod)
{
if (Convert.ToInt32(s) >= 1 && Convert.ToInt32(s) <= morningPeriodCount)
if (!periodTimeList.Contains("Sáng"))
periodTimeList.Add("Sáng");
if (Convert.ToInt32(s) > morningPeriodCount && Convert.ToInt32(s) <= (morningPeriodCount + afternoonPeriodCount))
if (!periodTimeList.Contains("Chiều"))
periodTimeList.Add("Chiều");
if (Convert.ToInt32(s) > (morningPeriodCount + afternoonPeriodCount))
if (!periodTimeList.Contains("Tối"))
periodTimeList.Add("Tối");
}
foreach (String period in periodTimeList)
{
if (!dicTimePeriodforWeekData.ContainsKey(period))
{
currentWeekData = objectSpace.CreateObject<WeekReportData>();
currentWeekData.Semester = objectSpace.FindObject<Semester>(
CriteriaOperator.Parse("SemesterName = ?", semesterName));
currentWeekData.Classrooms.Add(objectSpace.FindObject<Classroom>(
CriteriaOperator.Parse("ClassroomCode=?", classroomCode)));
currentWeekData.PeriodTime = period;
dicTimePeriodforWeekData.Add(period, currentWeekData);
}
dicTimePeriodforWeekData[period][tkbSem.Day] += string.Format("Lớp:{0}\r\n Môn:{1}-{2}\r\nTiết:{3}\r\nTuần:{4}\r\n\r\n",
tkbSem.Lesson.ClassIDs, tkbSem.Lesson.Subject.SubjectCode, tkbSem.Lesson.Subject.SubjectName,
Utils.ShortStringPeriod(tkbSem.Period), Utils.ShortStringWeek(tkbSem.StringWeeks));
}
}
objectSpace.CommitChanges();
}
}
}
catch (Exception ex)
{
throw new UserFriendlyException("Lỗi thực hiện: " + ex.Message);
}
return new XPCollection<WeekReportData>(objectSpace.Session,
new GroupOperator(GroupOperatorType.And, new BinaryOperator("Semester.SemesterName",
semesterName), new ContainsOperator("Classrooms", new BinaryOperator("ClassroomCode", classroomCode))));
}
public void CurrentObject_Model_Should_Be_Set_To_Control_Controller_Dictionary_Every_Time_CurrentObject_Is_Saving(){
var editor = new ModelEditorPropertyEditor(null, null);
var dictionary = new Dictionary(new DictionaryNode("test"));
Isolate.WhenCalled(() => editor.Control.Controller.Dictionary).WillReturn(dictionary);
var objectSpace = new ObjectSpace(new UnitOfWork(XpoDefault.DataLayer),XafTypesInfo.Instance);
var modelDifferenceObject = new ModelDifferenceObject(objectSpace.Session) { PersistentApplication = new PersistentApplication(objectSpace.Session) };
editor.CurrentObject=modelDifferenceObject;
editor.Setup(objectSpace, Isolate.Fake.Instance<XafApplication>());
objectSpace.CommitChanges();
Assert.AreEqual(dictionary.RootNode.ToXml(), modelDifferenceObject.Model.RootNode.ToXml());
}
public void ProccesExcellRows(IEnumerable records, ObjectSpace objectSpace, DoWorkEventArgs e) {
var i = 0;
//for every row in excell sheet
foreach (Row record in records) {
++i;
if (i == 1) continue;
if (_BgWorker.CancellationPending) { e.Cancel = true; break; }
//var os = new ObjectSpace(objectSpace, XafTypesInfo.Instance);
object newObj = null;
//chech if row contains Oid
//get key property name of the object type being imported
var kp = objectSpace.GetKeyPropertyName(Type);
//check if it exists in excel and is mapped ?
var idMapping = ImportMap.Mappings.Where(p => p.MapedTo == kp).FirstOrDefault();
if (idMapping != null && GetQString(record[idMapping.Column].Value) != string.Empty) {
try {
//find existing object
var val = record[idMapping.Column];
var gwid = new Guid(GetQString(val.Value));
newObj = objectSpace.FindObject(Type, new BinaryOperator(kp, gwid), true);
} catch {
}
}
if (newObj == null) //create a new instance
newObj = objectSpace.CreateObject(Type) as IXPSimpleObject;
string message;
if (newObj != null) {
var props = ((IXPSimpleObject)newObj).ClassInfo.PersistentProperties
.OfType<XPMemberInfo>();
foreach (var mapping in ImportMap.Mappings) {
if (_BgWorker.CancellationPending) { e.Cancel = true; break; }
Application.DoEvents();
var mapping1 = mapping;
var prop = props.Where(p => p.Name == mapping1.MapedTo).FirstOrDefault();
try {
var val = record[mapping.Column];
// continue;
if (val != null) {
//if simple property
if (prop.ReferenceType == null) {
var isNullable = prop.MemberType.IsGenericType && prop.MemberType.GetGenericTypeDefinition() == typeof(Nullable<>);
object convertedValue = null;
if (prop.MemberType == null) return;
if (isNullable) {
if (prop.StorageType == typeof(int)) {
int number;
var rez = Int32.TryParse(val.Value, out number);
if (rez) convertedValue = number;
} else if (prop.StorageType == typeof(DateTime)) {
if (val.Value != string.Empty) {
//Include validate
var dt = DateTime.FromOADate(Convert.ToDouble(val.Value));
convertedValue = dt;
}
} else if (prop.StorageType == typeof(double)) {
double number;
var rez = Double.TryParse(val.Value, out number);
if (rez) convertedValue = number;
}
} else {
if (prop.MemberType == typeof(char))
convertedValue = Convert.ChangeType(GetQString(val.Value), prop.MemberType);
else if (prop.MemberType == typeof(Guid))
convertedValue = new Guid(GetQString(val.Value));
else if (prop.StorageType == typeof(DateTime)) {
if (val.Value != string.Empty) {
//Include validate
var dt = DateTime.FromOADate(Convert.ToDouble(val.Value));
convertedValue = dt;
}
} else if (prop.MemberType == typeof(double)) {
double number;
// Application.CurrentCulture.NumberFormat.NumberDecimalSeparator = ".";
var rez = Double.TryParse(val.Value, NumberStyles.Number, new NumberFormatInfo { NumberDecimalSeparator = "." }, out number);
if (rez) convertedValue = number;
} else if (prop.MemberType == typeof(bool)) {
if (val.Value != string.Empty && (val.Value.Length == 1 || val.Value.ToLower() == "true" || val.Value.ToLower() == "false")) {
bool truefalse;
if (val.Value.ToLower() == "true" || val.Value.ToLower() == "false")
truefalse = Convert.ToBoolean(val.Value);
else
truefalse = Convert.ToBoolean(Convert.ToInt32(val.Value));
convertedValue = truefalse;
}
} else
convertedValue = Convert.ChangeType(val.Value, prop.MemberType);
}
if (convertedValue != null) {
if (convertedValue.GetType() == typeof(double))
convertedValue = Math.Round((double)convertedValue, 2, MidpointRounding.ToEven);
prop.SetValue(newObj, convertedValue);
}
}
//if referenced property
if (prop.ReferenceType != null) {
//if other referenced type
if (prop.MemberType.IsSubclassOf(typeof(XPBaseObject))) {
var text = val.Value;
var typ = prop.MemberType;
var mval = ImportWizard.Helper.GetXpObjectByKeyValue(objectSpace, text, typ);
prop.SetValue(newObj, objectSpace.GetObject(mval));
}
}
}
} catch (Exception E) {
message = string.Format("Error processing record {0}. {1}", i, E);
_BgWorker.ReportProgress(0, message);
}
if (CurrentCollectionSource != null)
AddNewObjectToCollectionSource(CurrentCollectionSource, newObj, ObjectSpace);
ObjectSpace.Session.Save(newObj);
}
}
objectSpace.CommitChanges();
message = string.Format("Importing record {0} succesfull.", i);
_BgWorker.ReportProgress(1, message);
Application.DoEvents();
}
}
/// <summary>
/// Builds the snapshot.
/// </summary>
/// <param name="worker">The worker.</param>
/// <param name="targetNode">The target node.</param>
/// <returns></returns>
public bool BuildSnapshot(ActionWorker worker, ReplicationNode targetNode)
{
if (targetNode == null) throw new ArgumentNullException("targetNode");
if (targetNode.Session.IsNewObject(targetNode))
throw new UnsavedTargetNodeException();
if (targetNode.Disabled)
throw new DisabledTargetNodeException();
var result = false;
worker.ReportProgress(string.Format(Localizer.BuildingSnapshotForNode, targetNode.Name));
XafDeltaModule.Instance.LoadService.BeginLoad();
using (var applicationObjectSpace = XafDeltaModule.XafApp.CreateObjectSpace())
{
targetNode = applicationObjectSpace.GetObjectByKey<ReplicationNode>(targetNode.Oid);
Owner.DoBeforeBuildPackages(new BeforeBuildPackagesArgs(applicationObjectSpace));
var package = Owner.MessagingService.CreateOutputPackage(applicationObjectSpace, targetNode,
PackageType.Snapshot);
try
{
var doneObjects = new Dictionary<object, object>();
using (var snapshotObjectSpace = new ObjectSpace(package.UnitOfWork))
{
var mapStack = new Queue<object>();
var rootContext = new BuildContext(applicationObjectSpace, doneObjects,
snapshotObjectSpace, targetNode, worker, mapStack,
new HashSet<string>(), new List<IModelClass>());
foreach (var modelClass in XafDeltaModule.XafApp.Model.BOModel.Where(x => !x.NonSnapshot())
.TakeWhile(x => !worker.CancellationPending))
{
if (!modelClass.TypeInfo.IsAbstract && modelClass.TypeInfo.IsPersistent
&& (modelClass.TypeInfo.IsInterface || modelClass.TypeInfo.Implements<IXPObject>()))
buildClassSnapshot(new ClassBuildContext(rootContext, modelClass));
}
if (doneObjects.Keys.Count > 0)
{
snapshotObjectSpace.CommitChanges();
snapshotPostBuild(snapshotObjectSpace);
snapshotObjectSpace.CommitChanges();
createSnapshotMaps(rootContext);
snapshotObjectSpace.CommitChanges();
worker.ReportProgress(string.Format(Localizer.TotalObjectsSnapshoted,
doneObjects.Keys.Count));
result = true;
}
else
{
snapshotObjectSpace.Rollback();
worker.ReportProgress(Color.DarkMagenta, Localizer.NoObjectsFoundForSnapshot);
}
}
package.CloseUnitOfWork(doneObjects.Keys.Count > 0);
result &= !worker.CancellationPending;
if (result)
Owner.OnAfterBuildSnapshot(new AfterBuildSnapshotArgs(targetNode));
}
catch (Exception exception)
{
worker.ReportError( Localizer.SnapshotFailed, exception.Message);
result = false;
}
// on success, commit changes to app database and package storage
if (result)
{
package.CreateLogRecord(PackageEventType.Created);
applicationObjectSpace.CommitChanges();
}
}
XafDeltaModule.Instance.LoadService.EndLoad();
if (result)
{
worker.ReportProgress(Color.Blue, Localizer.SnapshotBuildingIs,
(worker.CancellationPending ? Localizer.Aborted : Localizer.Finished));
}
return result;
}
public static XPCollection<ClassTransactionTracking> CreateStudentClassTrackingData(ObjectSpace objectSpace, string semesterName)
{
string strParse = "";
try
{
using (XPCollection<StudentClass> xpw = new XPCollection<StudentClass>(objectSpace.Session))
{
foreach (StudentClass studentClass in xpw)
{
ClassTransactionTracking ct = objectSpace.FindObject<ClassTransactionTracking>
(CriteriaOperator.Parse("StudentClass.ClassCode = ? and Semester.SemesterName = ?",
studentClass.ClassCode, semesterName));
if (ct == null)
{
ct = objectSpace.CreateObject< ClassTransactionTracking>();
ct.Semester = objectSpace.FindObject<Semester>(CriteriaOperator.Parse("SemesterName=?", semesterName));
ct.StudentClass = objectSpace.FindObject<StudentClass>(CriteriaOperator.Parse("ClassCode=?", studentClass.ClassCode));
ct.Save();
}
strParse += (strParse == "" ? string.Format("StudentClass.ClassCode='{0}'", studentClass.ClassCode) :
string.Format(" or StudentClass.ClassCode='{0}'", studentClass.ClassCode));
}
objectSpace.CommitChanges();
strParse = string.Format("({0}) and Semester.SemesterName= '{1}'", strParse, semesterName);
}
}
catch (Exception ex)
{
throw new UserFriendlyException(string.Format("Lỗi thực hiện: {0}\r\n Strack trace:{1}", ex.Message, ex.StackTrace));
}
return new XPCollection<ClassTransactionTracking>(objectSpace.Session, CriteriaOperator.Parse(strParse));
}
public static XPCollection<AccountTransactionTracking> CreateStudentClassTransactionTrackingData(ObjectSpace objectSpace, string classCode, string semesterName)
{
try
{
using (XPCollection<AccountTransactionTracking> xpw = new XPCollection<AccountTransactionTracking>(objectSpace.Session,
new BinaryOperator("Student.StudentClass.ClassCode", classCode)))
{
objectSpace.Delete(xpw);
objectSpace.CommitChanges();
StudentClass studentClass = objectSpace.FindObject<StudentClass>(
new BinaryOperator("ClassCode", classCode));
Semester semester = objectSpace.FindObject<Semester>(
new BinaryOperator("SemesterName", semesterName));
DateTime semesterLastDate = semester.StartDate.AddDays(semester.NumberOfWeek * 7);
decimal beforedebtvalue=0;
decimal requestvalue= 0;
decimal paidvalue = 0;
if (studentClass != null && semester != null)
{
foreach (Student student in studentClass.Students)
{
beforedebtvalue = 0;
requestvalue = 0;
paidvalue = 0;
foreach (AccountTransaction accTrans in student.AccountTransactions)
{
if ((accTrans.Semester != null &&
Convert.ToInt32(accTrans.Semester.SemesterName)<Convert.ToInt32(semester.SemesterName)))
//||accTrans.TransactingDate< semester.StartDate)
beforedebtvalue += accTrans.MoneyAmount;
else if (//accTrans.TransactingDate <= semesterLastDate ||
(accTrans.Semester!=null && accTrans.Semester.SemesterName ==semester.SemesterName))
{
if (accTrans.MoneyAmount < 0) //money has to paid
{
requestvalue += (-accTrans.MoneyAmount);
}
else //money has paid
{
paidvalue += accTrans.MoneyAmount;
}
}
}
AccountTransactionTracking accTracking = objectSpace.CreateObject<AccountTransactionTracking>();
accTracking.Student = student;
accTracking.Semester = semester;
accTracking.BeforeDebtValue = -beforedebtvalue;
accTracking.PaidValue= paidvalue;
accTracking.RequestValue = requestvalue;
accTracking.Save();
}
objectSpace.CommitChanges();
}
}
}
catch (Exception ex)
{
throw new UserFriendlyException("Lỗi thực hiện: " + ex.Message);
}
return new XPCollection<AccountTransactionTracking>(objectSpace.Session,
new BinaryOperator("Student.StudentClass.ClassCode", classCode));
}
