public void ShouldRecalculateFirmHavingTerritory()
{
SourceDb.Has(new Facts::Firm {
Id = 1
})
.Has(new Facts::FirmAddress {
FirmId = 1, TerritoryId = 2
});
TargetDb.Has(new CI::Firm {
Id = 1
})
.Has(new CI::FirmTerritory {
FirmId = 1, TerritoryId = 3
});
Transformation.Create(Query)
.Recalculate <CI::Firm>(1)
.Verify <CI::FirmTerritory>(m => m.Add(It.Is(Predicate.Match(new CI::FirmTerritory {
FirmId = 1, TerritoryId = 2
}))))
.Verify <CI::FirmTerritory>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmTerritory {
FirmId = 1, TerritoryId = 3
}))));
}
public void ShouldRecalculateFirmHavingClient()
{
SourceDb.Has(new Facts::Category {
Id = 1, Level = 3
})
.Has(new Facts::Project {
OrganizationUnitId = 1
})
.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::Firm {
Id = 1, ClientId = 1, OrganizationUnitId = 1
});
TargetDb.Has(new CI::Firm {
Id = 1
})
.Has(new CI::Client {
Id = 1
});
Transformation.Create(Query)
.Recalculate <CI::Firm>(1)
.Verify <CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm {
Id = 1, ClientId = 1
}))))
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 1
}))), Times.Never);
}
public void ShouldDestroyFirmHavingCategory()
{
TargetDb.Has(new CI::Firm {
Id = 1
})
.Has(new CI::FirmCategory1 {
FirmId = 1, CategoryId = 1
})
.Has(new CI::FirmCategory2 {
FirmId = 1, CategoryId = 2
})
;
Transformation.Create(Query)
.Destroy <CI::Firm>(1)
.Verify <CI::Firm>(m => m.Delete(It.Is(Predicate.Match(new CI::Firm {
Id = 1
}))))
.Verify <CI::FirmCategory1>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory1 {
FirmId = 1, CategoryId = 1
}))))
.Verify <CI::FirmCategory2>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory2 {
FirmId = 1, CategoryId = 2
}))))
;
}
public void ShouldRecalculateDependentAggregatesIfProjectUpdated()
{
SourceDb.Has(new Erm::Project {
Id = 1, OrganizationUnitId = 2
});
TargetDb.Has(new Facts::Project {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::Territory {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::Territory {
Id = 2, OrganizationUnitId = 2
})
.Has(new Facts::Firm {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::Firm {
Id = 2, OrganizationUnitId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Project>(1)
.VerifyDistinct(Statistics.Operation(1),
Aggregate.Recalculate <CI::Territory>(1),
Aggregate.Recalculate <CI::Firm>(1),
Aggregate.Recalculate <CI::Project>(1),
Aggregate.Recalculate <CI::Territory>(2),
Aggregate.Recalculate <CI::Firm>(2));
}
public void ShouldRecalculateFirmIfBranchOfficeOrganizationUnitUpdated()
{
SourceDb.Has(new Erm::BranchOfficeOrganizationUnit {
Id = 1, OrganizationUnitId = 2
});
TargetDb.Has(new Facts::Firm {
Id = 1, ClientId = 1, OrganizationUnitId = 1
})
.Has(new Facts::Firm {
Id = 2, ClientId = 1, OrganizationUnitId = 2
})
.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::BranchOfficeOrganizationUnit {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::LegalPerson {
Id = 1, ClientId = 1
})
.Has(new Facts::Account {
Id = 1, LegalPersonId = 1, BranchOfficeOrganizationUnitId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::BranchOfficeOrganizationUnit>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1), Aggregate.Recalculate <CI.Firm>(2));
}
public void ShouldRecalculateClientAndFirmIfCategoryFirmAddressUpdated()
{
SourceDb.Has(new Erm::CategoryFirmAddress {
Id = 1, FirmAddressId = 1, CategoryId = 1
})
.Has(new Erm::FirmAddress {
Id = 1, FirmId = 1
})
.Has(new Erm::Firm {
Id = 1, OrganizationUnitId = 1, ClientId = 1
})
.Has(new Erm::Client {
Id = 1
});
TargetDb.Has(new Facts::CategoryFirmAddress {
Id = 1, FirmAddressId = 1, CategoryId = 1
});
TargetDb.Has(new Facts::FirmAddress {
Id = 1, FirmId = 1
});
TargetDb.Has(new Facts::Firm {
Id = 1, OrganizationUnitId = 1, ClientId = 1
});
TargetDb.Has(new Facts::Client {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::CategoryFirmAddress>(1)
.VerifyDistinct(Aggregate.Recalculate <CI::Firm>(1),
Aggregate.Recalculate <CI::Client>(1));
}
public void ShouldRecalculateFirmHavingCategory()
{
SourceDb.Has(new Facts::Category { Id = 1, Level = 3 },
new Facts::Category { Id = 2, Level = 3 });
SourceDb.Has(new Facts::CategoryOrganizationUnit { Id = 1, CategoryId = 1, OrganizationUnitId = 1 },
new Facts::CategoryOrganizationUnit { Id = 2, CategoryId = 2, OrganizationUnitId = 1 });
SourceDb.Has(new Facts::Project { OrganizationUnitId = 1 });
SourceDb.Has(new Facts::FirmAddress { Id = 1, FirmId = 1 },
new Facts::FirmAddress { Id = 2, FirmId = 2 });
SourceDb.Has(new Facts::CategoryFirmAddress { Id = 1, FirmAddressId = 1, CategoryId = 1 },
new Facts::CategoryFirmAddress { Id = 2, FirmAddressId = 2, CategoryId = 2 });
SourceDb.Has(new Facts::Firm { Id = 1, OrganizationUnitId = 1 },
new Facts::Firm { Id = 2, OrganizationUnitId = 1 },
new Facts::Firm { Id = 3, OrganizationUnitId = 1 });
TargetDb.Has(new CI::Firm { Id = 1 },
new CI::Firm { Id = 2 },
new CI::Firm { Id = 3 })
.Has(new CI::FirmCategory { FirmId = 2, CategoryId = 1 },
new CI::FirmCategory { FirmId = 3, CategoryId = 1 });
Transformation.Create(Query)
.Recalculate<CI::Firm>(1)
.Recalculate<CI::Firm>(2)
.Recalculate<CI::Firm>(3)
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 1, AddressCount = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 2, AddressCount = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 3 }))))
.Verify<CI::FirmCategory>(m => m.Add(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 1, CategoryId = 1 }))))
.Verify<CI::FirmCategory>(m => m.Add(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 2, CategoryId = 2 }))))
.Verify<CI::FirmCategory>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 2, CategoryId = 1 }))))
.Verify<CI::FirmCategory>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 3, CategoryId = 1 }))));
}
public void ShouldRecalculateFirmIfContactUpdated()
{
SourceDb.Has(new Erm::Contact {
Id = 1, ClientId = 2
});
TargetDb.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::Client {
Id = 2
})
.Has(new Facts::Firm {
Id = 1, ClientId = 1
})
.Has(new Facts::Firm {
Id = 2, ClientId = 2
})
.Has(new Facts::Contact {
Id = 1, ClientId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Contact>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Client>(1), Aggregate.Recalculate <CI.Firm>(1), Aggregate.Recalculate <CI.Client>(2), Aggregate.Recalculate <CI.Firm>(2));
}
public void ShouldRecalculateFirmsIfActivityCreated()
{
SourceDb.Has(new Appointment {
Id = 1, ModifiedOn = DateTimeOffset.Now, IsActive = true, Status = ActivityStatusCompleted
})
.Has(new AppointmentReference {
ActivityId = 1, Reference = RegardingObjectReference, ReferencedObjectId = 2, ReferencedType = EntityTypeIds.Client
},
new AppointmentReference {
ActivityId = 1, Reference = RegardingObjectReference, ReferencedObjectId = 3, ReferencedType = EntityTypeIds.Firm
});
TargetDb.Has(new Facts::Client {
Id = 2
});
TargetDb.Has(new Facts::Firm {
Id = 3
});
TargetDb.Has(new Facts::Firm {
Id = 4, ClientId = 2
});
TargetDb.Has(new Facts::Firm {
Id = 5
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Activity>(1)
.VerifyDistinct(Aggregate.Recalculate <CI::Firm>(3),
Aggregate.Recalculate <CI::Firm>(4));
}
public void ShouldRecalculateFirmHavingBalance()
{
SourceDb.Has(new Facts::Project { Id = 1, OrganizationUnitId = 1 })
.Has(new Facts::Client { Id = 1 },
new Facts::Client { Id = 2 })
.Has(new Facts::BranchOfficeOrganizationUnit { Id = 1, OrganizationUnitId = 1 })
.Has(new Facts::LegalPerson { Id = 1, ClientId = 1 },
new Facts::LegalPerson { Id = 2, ClientId = 2 })
.Has(new Facts::Account { Id = 1, LegalPersonId = 1, BranchOfficeOrganizationUnitId = 1, Balance = 123 },
new Facts::Account { Id = 2, LegalPersonId = 2, BranchOfficeOrganizationUnitId = 1, Balance = 456 })
.Has(new Facts::Firm { Id = 1, ClientId = 1, OrganizationUnitId = 1 },
new Facts::Firm { Id = 2, ClientId = 2, OrganizationUnitId = 1 },
new Facts::Firm { Id = 3, OrganizationUnitId = 1 });
TargetDb.Has(new CI::Firm { Id = 1 },
new CI::Firm { Id = 2 },
new CI::Firm { Id = 3 })
.Has(new CI::FirmBalance { FirmId = 2, AccountId = 2, ProjectId = 1, Balance = 123 },
new CI::FirmBalance { FirmId = 3, ProjectId = 1, Balance = 123 });
Transformation.Create(Query)
.Recalculate<CI::Firm>(1, 2, 3)
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 1, ClientId = 1, ProjectId = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 2, ClientId = 2, ProjectId = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 3, ProjectId = 1 }))))
.Verify<CI::FirmBalance>(m => m.Add(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 1, AccountId = 1, ProjectId = 1, Balance = 123 }))))
.Verify<CI::FirmBalance>(m => m.Update(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 2, AccountId = 2, ProjectId = 1, Balance = 456 }))))
.Verify<CI::FirmBalance>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 3, ProjectId = 1, Balance = 123 }))));
}
public void ShouldRecalculateFirmIfCategoryOfLevel1Deleted()
{
TargetDb.Has(new Facts::Firm {
Id = 1
})
.Has(new Facts::FirmAddress {
Id = 1, FirmId = 1
})
.Has(new Facts::CategoryFirmAddress {
Id = 1, FirmAddressId = 1, CategoryId = 3
})
.Has(new Facts::Category {
Id = 1, Level = 1
})
.Has(new Facts::Category {
Id = 2, Level = 2, ParentId = 1
})
.Has(new Facts::Category {
Id = 3, Level = 3, ParentId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Category>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldDestroyClient()
{
TargetDb.Has(new CI::Client { Id = 1 });
Transformation.Create(Query)
.Destroy<CI::Client>(1)
.Verify<CI::Client>(m => m.Delete(It.Is(Predicate.Match(new CI::Client { Id = 1 }))));
}
public void ShouldDestroyCategoryGroup()
{
TargetDb.Has(new CI::CategoryGroup { Id = 1 });
Transformation.Create(Query)
.Destroy<CI::CategoryGroup>(1)
.Verify<CI::CategoryGroup>(x => x.Delete(It.Is(Predicate.Match(new CI::CategoryGroup { Id = 1 }))));
}
public void ShouldRecalculateClient()
{
SourceDb.Has(new Facts::Client { Id = 1, Name = "new name" });
TargetDb.Has(new CI::Client { Id = 1, Name = "old name" });
Transformation.Create(Query)
.Recalculate<CI::Client>(1)
.Verify<CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client { Id = 1, Name = "new name" }))));
}
public void ShouldDestroyTerritoryIfTerritoryDeleted()
{
TargetDb.Has(new Facts::Territory {
Id = 1, OrganizationUnitId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Territory>(1)
.VerifyDistinct(Aggregate.Destroy <CI::Territory>(1));
}
public void ShouldDestroyFirmHavingClient()
{
TargetDb.Has(new CI::Firm { Id = 1, ClientId = 1 })
.Has(new CI::Client { Id = 1 });
Transformation.Create(Query)
.Destroy<CI::Firm>(1)
.Verify<CI::Firm>(m => m.Delete(It.Is(Predicate.Match(new CI::Firm { Id = 1, ClientId = 1 }))))
.Verify<CI::Client>(m => m.Delete(It.Is(Predicate.Match(new CI::Client { Id = 1 }))), Times.Never);
}
public void ShouldDestroyFirmHavingBalance()
{
TargetDb.Has(new CI::Firm { Id = 1 })
.Has(new CI::FirmBalance { FirmId = 1, Balance = 123 });
Transformation.Create(Query)
.Destroy<CI::Firm>(1)
.Verify<CI::Firm>(m => m.Delete(It.Is(Predicate.Match(new CI::Firm { Id = 1 }))))
.Verify<CI::FirmBalance>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 1, Balance = 123 }))));
}
public void ShouldDestroyClientIfClientDeleted()
{
TargetDb.Has(new Facts::Client {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Client>(1)
.VerifyDistinct(Aggregate.Destroy <CI.Client>(1));
}
public void ShouldProcessFactAccordingToPriority()
{
//arrange
var factProcessor = new Mock <IFactProcessor>();
factProcessor.Setup(x => x.ApplyChanges(It.IsAny <IReadOnlyCollection <long> >()))
.Returns(new IOperation[0]);
var provider = new MetadataProvider(new[] { new FactsReplicationMetadataSource() }, new IMetadataProcessor[0]);
var factoryInvocationOrder = new List <Type>();
var factProcessorFactory = new Mock <IFactProcessorFactory>();
factProcessorFactory.Setup(x => x.Create(It.IsAny <IMetadataElement>()))
.Callback <IMetadataElement>(element =>
{
var type = element.GetType().GenericTypeArguments[0];
factoryInvocationOrder.Add(type);
})
.Returns(factProcessor.Object);
var transformation = new FactsReplicator(Mock.Of <ITracer>(),
Mock.Of <IReplicationSettings>(),
provider,
factProcessorFactory.Object,
new CustomerIntelligenceFactTypePriorityComparer());
SourceDb.Has(new Erm::Firm {
Id = 2
})
.Has(new Erm::FirmAddress {
Id = 1, FirmId = 1
}, new Erm::FirmAddress {
Id = 2, FirmId = 2
});
TargetDb.Has(new Facts::Firm {
Id = 1
});
var inputOperations = new[]
{
new FactOperation(typeof(Facts::FirmAddress), 1),
new FactOperation(typeof(Facts::Firm), 2),
new FactOperation(typeof(Facts::FirmAddress), 2),
};
//act
transformation.Replicate(inputOperations);
//assert
Assert.That(factoryInvocationOrder.Count, Is.EqualTo(2));
Assert.That(factoryInvocationOrder[0], Is.EqualTo(typeof(Facts::Firm)));
Assert.That(factoryInvocationOrder[1], Is.EqualTo(typeof(Facts::FirmAddress)));
}
public void ShouldRecalculateFirm()
{
SourceDb.Has(new Facts::Project { OrganizationUnitId = 1 })
.Has(new Facts::Firm { Id = 1, OrganizationUnitId = 1 });
TargetDb.Has(new CI::Firm { Id = 1 });
Transformation.Create(Query)
.Recalculate<CI::Firm>(1)
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 1 }))));
}
public void ShouldDestroyProjectIfProjectDeleted()
{
TargetDb.Has(new Facts::Project {
Id = 1, OrganizationUnitId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Project>(1)
.VerifyDistinct(Statistics.Operation(1),
Aggregate.Destroy <CI::Project>(1));
}
public void ShouldRecalculateTerritory()
{
SourceDb.Has(new Facts::Project { Id = 1, OrganizationUnitId = 1 })
.Has(new Facts::Territory { Id = 1, OrganizationUnitId = 1, Name = "new name" });
TargetDb.Has(new CI::Territory { Id = 1, Name = "old name" });
Transformation.Create(Query)
.Recalculate<CI::Territory>(1)
.Verify<CI::Territory>(m => m.Update(It.Is(Predicate.Match(new CI::Territory { Id = 1, ProjectId = 1, Name = "new name" }))));
}
public void ShouldDestroyCategoryGroupIfCategoryGroupDeleted()
{
TargetDb.Has(
new Facts::CategoryGroup {
Id = 1, Name = "Name", Rate = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::CategoryGroup>(1)
.VerifyDistinct(Aggregate.Destroy <CI::CategoryGroup>(1));
}
public void ShouldRecalculateClientHavingContact()
{
SourceDb.Has(new Facts::Client {
Id = 1
},
new Facts::Client {
Id = 2
},
new Facts::Client {
Id = 3
})
.Has(new Facts::Contact {
Id = 1, ClientId = 1
},
new Facts::Contact {
Id = 2, ClientId = 2
});
TargetDb.Has(new CI::Client {
Id = 1
},
new CI::Client {
Id = 2
},
new CI::Client {
Id = 3
})
.Has(new CI::ClientContact {
ClientId = 2, ContactId = 2
},
new CI::ClientContact {
ClientId = 3, ContactId = 3
});
Transformation.Create(Query)
.Recalculate <CI::Client>(1)
.Recalculate <CI::Client>(2)
.Recalculate <CI::Client>(3)
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 1
}))))
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 2
}))))
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 3
}))))
.Verify <CI::ClientContact>(m => m.Add(It.Is(Predicate.Match(new CI::ClientContact {
ClientId = 1, ContactId = 1
}))))
.Verify <CI::ClientContact>(m => m.Delete(It.Is(Predicate.Match(new CI::ClientContact {
ClientId = 3, ContactId = 3
}))));
}
public void ShouldRecalculateFirmIfOrderCreated()
{
SourceDb.Has(new Erm::Order {
Id = 2, FirmId = 1, WorkflowStepId = 4
});
TargetDb.Has(new Facts::Firm {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Order>(2)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateDetachedFirmIfBranchOfficeOrganizationUnitDeleted()
{
TargetDb.Has(new Facts::Firm {
Id = 1, ClientId = 2, OrganizationUnitId = 1
})
.Has(new Facts::BranchOfficeOrganizationUnit {
Id = 3, OrganizationUnitId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::BranchOfficeOrganizationUnit>(3)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateTerritoryIfTerritoryUpdated()
{
SourceDb.Has(new Erm::Territory {
Id = 1, OrganizationUnitId = 2
});
TargetDb.Has(new Facts::Territory {
Id = 1, OrganizationUnitId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Territory>(1)
.VerifyDistinct(Aggregate.Recalculate <CI::Territory>(1));
}
public void ShouldRecalculateFirmIfFirmAddressDeleted()
{
TargetDb.Has(new Facts::Firm {
Id = 1
})
.Has(new Facts::FirmAddress {
Id = 2, FirmId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::FirmAddress>(2)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateClientIfClientUpdated()
{
SourceDb.Has(new Erm::Client {
Id = 1
});
TargetDb.Has(new Facts::Client {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Client>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Client>(1));
}
public void ShouldRecalculateFirmIfClientDeleted()
{
TargetDb.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::Firm {
Id = 2, ClientId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Client>(1)
.VerifyDistinct(op => op is RecalculateAggregate, Aggregate.Recalculate <CI.Firm>(2));
}
/// <summary>
/// DataPack�� �Ķ���ͷ� �Ƽ� Insert ���� ����� ����.
/// </summary>
/// <param name="dataPack">�Ķ���� ������ �ִ� Pack</param>
/// <param name="dataTable">Insert�� DB ���̺� ��</param>
/// <param name="skipNullProperty">DataPack ������ Null �� ��� Skip</param>
/// <param name="targetDb">Sql, Oracle, OleDb �߿� ����</param>
/// <returns>SQL Insert��</returns>
public static string BuildInsertQuery(DataPack dataPack, string dataTable, bool skipNullProperty, TargetDb targetDb)
{
StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder();
sb1.Append("INSERT INTO ").Append(dataTable).Append(" (\r\n");
ITypedList itl = dataPack as ITypedList;
foreach( PropertyDescriptor pd in itl.GetItemProperties(null) )
{
object pdValue = pd.GetValue( dataPack );
if ( skipNullProperty == true )
{
switch ( pd.PropertyType.Name )
{
case "DateTime":
DateTime dt = Convert.ToDateTime( pdValue );
if ( dt == DateTime.MinValue )
{
continue;
}
break;
default:
if ( pdValue.ToString() == string.Empty )
{
continue;
}
break;
}
}
sb1.Append(pd.Name).Append(", \r\n");
switch (targetDb)
{
case TargetDb.SqlServer:
sb2.AppendFormat("@{0}", pd.Name);
break;
case TargetDb.OleDb:
sb2.Append("?");
break;
case TargetDb.Oracle:
sb2.AppendFormat(":{0}", pd.Name);
break;
}
sb2.Append(", \r\n");
}
sb1.Remove(sb1.Length - 4, 2);
sb1.Append(") VALUES (\r\n");
sb2.Remove(sb2.Length - 4, 2);
sb2.Append(")");
return sb1.ToString() + sb2.ToString();
}
/// <summary>
/// DataPack�� �Ķ���ͷ� �Ƽ� Insert ���� ����� ����.
/// DataPack ������ Null �� ��� Skip�ؼ� �����.
/// </summary>
/// <param name="dataPack">�Ķ���� ������ �ִ� Pack</param>
/// <param name="dataTable">Insert�� DB ���̺� ��</param>
/// <param name="targetDb">Sql, Oracle, OleDb �߿� ����</param>
/// <returns>SQL Insert��</returns>
public static string BuildInsertQuery(DataPack dataPack, string dataTable, TargetDb targetDb)
{
return BuildInsertQuery(dataPack, dataTable, true, targetDb);
}
/// <summary>
/// DataPack�� �Ķ���ͷ� �Ƽ� Update ���� ����� ����.
/// </summary>
/// <param name="dataPack">�Ķ���� ������ �ִ� Pack</param>
/// <param name="dataTable">Update�� DB ���̺� ��</param>
/// <param name="whereCondition">Update�� ����� Where ������</param>
/// <param name="skipNullProperty">DataPack ������ Null �� ��� Skip</param>
/// <param name="targetDb">Sql, Oracle, OleDb �߿� ����</param>
/// <returns>SQL Update��</returns>
public static string BuildUpdateQuery(DataPack dataPack, string dataTable, string whereCondition, bool skipNullProperty, TargetDb targetDb)
{
StringBuilder sb = new StringBuilder();
sb.Append("UPDATE ").Append(dataTable).Append(" SET\r\n");
ITypedList itl = dataPack as ITypedList;
foreach( PropertyDescriptor pd in itl.GetItemProperties(null) )
{
object pdValue = pd.GetValue( dataPack );
if ( skipNullProperty == true )
{
switch ( pd.PropertyType.Name )
{
case "DateTime":
DateTime dt = Convert.ToDateTime( pdValue );
if ( dt == DateTime.MinValue )
{
continue;
}
break;
default:
if ( pdValue.ToString() == string.Empty )
{
continue;
}
break;
}
}
switch (targetDb)
{
case TargetDb.SqlServer:
sb.AppendFormat("{0} = @{1}", pd.Name, pd.Name);
break;
case TargetDb.OleDb:
sb.AppendFormat("{0} = ?", pd.Name);
break;
case TargetDb.Oracle:
sb.AppendFormat("{0} = :{1}", pd.Name, pd.Name);
break;
}
sb.Append(", \r\n");
}
sb.Remove(sb.Length - 4, 2);
sb.Append("WHERE ").Append(whereCondition);
return sb.ToString();
}
/// <summary>
/// DataPack�� �Ķ���ͷ� �Ƽ� Update ���� ����� ����.
/// DataPack ������ Null �� ��� Skip�ؼ� �����.
/// </summary>
/// <param name="dataPack">�Ķ���� ������ �ִ� Pack</param>
/// <param name="dataTable">Update�� DB ���̺� ��</param>
/// <param name="whereCondition">Update�� ����� Where ������</param>
/// <param name="targetDb">Sql, Oracle, OleDb �߿� ����</param>
/// <returns>SQL Update��</returns>
public static string BuildUpdateQuery(DataPack dataPack, string dataTable, string whereCondition, TargetDb targetDb)
{
return BuildUpdateQuery(dataPack, dataTable, whereCondition, true, targetDb);
}
/// <summary>
/// DataPack�� �Ķ���ͷ� �Ƽ� Select ���� ����� ����.
/// DataPack(conditionPack)�� ���� '%' �� �ִ� ��� Select ������ Like �˻�, �ܴ� '=' �˻��� �����Ѵ�.
/// </summary>
/// <param name="selectQuery">Select ������</param>
/// <param name="conditionPack">������ ���� DataPack</param>
/// <param name="skipNullProperty">DataPack ������ Null �� ��� Skip</param>
/// <param name="targetDb">Sql, Oracle, OleDb �߿� ����</param>
/// <returns>SQL Select��</returns>
public static string BuildSelectQuery(string selectQuery, DataPack conditionPack, bool skipNullProperty, TargetDb targetDb)
{
StringBuilder sb = new StringBuilder();
sb.Append(selectQuery);
bool whereClauseAdded = false;
ITypedList itl = conditionPack as ITypedList;
foreach( PropertyDescriptor pd in itl.GetItemProperties(null) )
{
object pdValue = pd.GetValue(conditionPack);
if ( skipNullProperty == true )
{
switch ( pd.PropertyType.Name )
{
case "DateTime":
DateTime dt = Convert.ToDateTime( pdValue );
if ( dt == DateTime.MinValue )
{
continue;
}
break;
default:
if ( pdValue.ToString() == string.Empty )
{
continue;
}
break;
}
}
if (!whereClauseAdded)
{
sb.Append(" WHERE ");
whereClauseAdded = true;
}
string conditionOperator = (pdValue.ToString().IndexOf("%") < 0) ? " = " : " LIKE ";
switch (targetDb)
{
case TargetDb.SqlServer:
sb.AppendFormat("{0} {1} @{2} AND ", pd.Name, conditionOperator, pd.Name);
break;
case TargetDb.OleDb:
sb.AppendFormat("{0} {1} ? AND ", pd.Name, conditionOperator);
break;
case TargetDb.Oracle:
sb.AppendFormat("{0} {1} :{2} AND ", pd.Name, conditionOperator, pd.Name);
break;
}
}
if (whereClauseAdded)
{
sb.Remove(sb.Length - 5, 4);
}
return sb.ToString();
}
/// <summary>
/// DataPack(conditionPack)�� �Ķ���ͷ� �Ƽ� Select ���� ����� ����.
/// DataPack(conditionPack)�� ���� '%' �� �ִ� ��� Select ������ Like �˻�, �ܴ� '=' �˻��� �����Ѵ�.
/// DataPack(conditionPack) ������ Null �� ��� Skip
/// </summary>
/// <param name="selectQuery">Select ������</param>
/// <param name="conditionPack">������ ���� DataPack</param>
/// <param name="targetDb">Sql, Oracle, OleDb �߿� ����</param>
/// <returns>SQL Select��</returns>
public static string BuildSelectQuery(string selectQuery, DataPack conditionPack, TargetDb targetDb)
{
return BuildSelectQuery(selectQuery, conditionPack, true, targetDb);
}
