/// <summary>
/// Saves the provider.
/// </summary>
/// <param name="provider">The provider.</param>
/// <returns></returns>
public async Task <int> SaveProvider(EntityProvider provider)
{
provider.Id = UtilsService.GenerateId(provider.Id);
return(await Util.TryAsync(() => GetConnection().InsertOrReplaceAsync(provider),
failureMessage : "DataContext failed to SAVE EntityProvider"));
}
static void provider_OnCompleted(string key, EntityProvider provider)
{
lock (_obj)
{
EPDic[key].Enqueue(provider);
}
}
public Variable first, second; //One of these is an amount (nullable), other must be ItemFilter (non nullable)
public TransferItemCommand(EntityProvider from, EntityProvider to, Variable first, Variable second)
{
this.from = from;
this.to = to;
this.first = first;
this.second = second;
}
/// <summary>
/// Elimina aggregato (fascicolo) - Elimina anche tutti i riferimenti alle DocumentiUnit aggregate.
/// </summary>
/// <param name="idAggregate">Chiave aggregato</param>
/// <returns>N. di rercord complessivamente eliminati</returns>
public static int UdsDeleteDocumentUnitAggregate(Guid idAggregate)
{
EntityProvider provider = DbProvider;
using (DbTransaction tran = provider.BeginNoSave())
{
try
{
provider.UdsDeleteDocumentUnitAggregateChain(idAggregate);
provider.UdsDeleteDocumentUnitAggregate(idAggregate);
int count = provider.SaveChanges();
tran.Commit();
return(count);
}
catch
{
try
{
tran.Rollback();
}
catch
{
}
throw;
}
}
}
public AggregatePropertyVariable(PropertyAggregate aggregationType, EntityProvider entityProvider, PropertySupplier property, Direction?direction)
{
this.aggregationType = aggregationType;
this.entityProvider = entityProvider;
this.property = property;
this.direction = direction;
}
/// <summary>
/// Aggiunge una nuova DocumentUnit e collega i documenti collegati passati
/// </summary>
/// <param name="unit">DocumentUnit da inserire</param>
/// <param name="documents">Elenco dei riferimenti ai documenti da collegare</param>
/// <returns>DocumentUnit creata</returns>
public static DocumentUnit UdsAddDocumentUnitWithDocuments(DocumentUnit unit, DocumentUnitChain[] documents)
{
EntityProvider provider = DbProvider;
using (DbTransaction tran = provider.BeginNoSave())
{
try
{
var unitRes = provider.UdsAddDocumentUnit(unit);
if (unitRes != null)
{
provider.UdsDocumentUnitAddDocuments(unitRes.IdDocumentUnit, documents, false);
}
provider.SaveChanges();
tran.Commit();
return(unitRes);
}
catch
{
try
{
tran.Rollback();
}
catch
{
}
throw;
}
}
}
public override void Update(string compId)
{
if (this.UsePortal())
{
EntityProvider.UpdateEntityList <PartnerItemXref>(this);
return;
}
try
{
StartSession();
this.Items.EnlistTransaction(this.TransMan);
//persist detail records
foreach (PartnerItemXref PartnerItemXref in this.Items.ChangedItems)
{
if (PartnerItemXref.IsValid)
{
// PartnerItemXref.PriorityCodeDetailList.DeletedItems.Clear();
}
}
base.Update(compId);
}
catch
{
StopSession(true);
throw;
}
finally
{
StopSession();
}
}
private void btnTest_Click(object sender, EventArgs e)
{
WikibaseApi api = new WikibaseApi("https://test.wikidata.org", "TambonBot");
var entityProvider = new EntityProvider(api);
var item = entityProvider.getEntityFromId(new EntityId("Q42")) as Item;
}
public ConverterBase(EntityProvider <TEntityType> entityProvider,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
{
this.entityProvider = entityProvider;
this.propertyCopier = propertyCopier;
VirtualWorkDatabaseContext = virtualWorkDatabaseContext;
}
public LicenseConverter(EntityProvider <EntityType> entityProvider,
UserRepository userRepository,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
: base(entityProvider, propertyCopier, virtualWorkDatabaseContext)
{
this.userRepository = userRepository;
}
public GroupConverter(EntityProvider <EntityType> entityProvider,
PermissionConverter permissionConverter,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
: base(entityProvider, propertyCopier, virtualWorkDatabaseContext)
{
this.permissionConverter = permissionConverter;
}
public ServerConverter(EntityProvider <EntityType> entityProvider,
CameraConverter cameraConverter,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
: base(entityProvider, propertyCopier, virtualWorkDatabaseContext)
{
this.cameraConverter = cameraConverter;
}
protected static void InitBase(EntityProvider provider, bool executeQueries = false, string baseLineFileName = null)
{
lock (gate)
{
_provider = provider;
_executeQueries = executeQueries;
_baseLinePath = baseLineFileName;
_newBaseLinePath = string.IsNullOrEmpty(baseLineFileName) ? null : Path.ChangeExtension(baseLineFileName, "new");
}
}
public IssueHistoryConverter(EntityProvider <EntityType> entityProvider,
IssueRepository issueRepository,
UserRepository userRepository,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
: base(entityProvider, propertyCopier, virtualWorkDatabaseContext)
{
this.issueRepository = issueRepository;
this.userRepository = userRepository;
}
public EntityImageConverter(EntityProvider <EntityType> entityProvider,
UserRepository userRepository,
ResourceRepository resourceRepository,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
: base(entityProvider, propertyCopier, virtualWorkDatabaseContext)
{
this.userRepository = userRepository;
this.resourceRepository = resourceRepository;
}
public CheckSearchParametersTests()
{
var translatorMock = new Mock <ITranslator>();
translatorMock.Setup(f => f.GetTranslation("de", "search.termToShort", It.IsAny <string>()))
.Returns("search.termToShort");
translatorMock.Setup(f => f.GetTranslation("de", "search.termToShortForAll", It.IsAny <string>()))
.Returns("search.termToShortForAll");
entityProvider = new EntityProvider(translatorMock.Object, null, null, null);
}
public void PreParseCommands(List <CommandParameter> commandParameters)
{
extract <ActionCommandParameter>(commandParameters);//Extract and ignore
SelectorCommandParameter selector = extractFirst <SelectorCommandParameter>(commandParameters);
if (selector == null)
{
throw new Exception("SelectorCommandParameter is required for command: " + GetType());
}
blockHandler = BlockHandlerRegistry.GetBlockHandler(selector.Value.GetBlockType());
entityProvider = selector.Value;
}
public ItemProvider(ItemProviderSettings settings, TypeManager typeManager, ILogWriter log)
{
var entityProviderLog = log.NewRegion(nameof(EntityProvider));
var pool = new PostgreSqlConnectionPool(settings.PostgreSqlConnectionString, settings.MaxConnections, settings.Timeout);
var sqlProvider = new PostgreSqlProvider(pool, entityProviderLog.NewRegion("PostgreSQL"), settings.Schema);
sqlProvider.EnsureSchemaExists();
this.provider = new EntityProvider(sqlProvider, entityProviderLog);
this.log = log;
this.context = new ItemContext(typeManager);
}
protected override void UpdateData(int index)
{
try
{
if (index < 0)
{
//persist delete operation
if (_provider.Items.IsDeletedCount > 0)
{
_provider.Update(this.CompId);
}
}
else
{
//persist add/edit operations
if (_provider[index].IsDirty)
{
//validate the item
_provider[index].Validate();
//if valid, update the database
if (_provider[index].IsValid)
{
_provider.Update(this.CompId);
}
}
//clear error
_provider[index].SetErrorText(null);
}
}
catch (ProviderException pex)
{
if (index > -1)
{
_provider[index].SetErrorText(pex.Message);
}
ClientContext.HandleError(pex, this);
}
catch (Exception ex)
{
ClientContext.HandleError(ex, this);
}
finally
{
if (_provider.Items.IsDeletedCount > 0)
{
_provider.Items.AddRange(_provider.Items.DeletedItems);
_provider.Items.DeletedItems.Clear();
this.BindingSource.ResetBindings(false);
}
EntityProvider.InvalidateLookupObject("PartnerItemXref");
}
}
public BaseResponse UpdateProvider(EntityProvider provider)
{
var returnEntity = new BaseResponse();
var entityUser = new EntityLoginResponse();
var resu = new EntityProvider();
try
{
using (var db = GetSqlConnection())
{
const string sql = "update_provider";
var p = new DynamicParameters();
p.Add(name: "@Ruc", value: provider.ruc, dbType: DbType.String, direction: ParameterDirection.Input);
p.Add(name: "@NomEmp", value: provider.name, dbType: DbType.String, direction: ParameterDirection.Input);
p.Add(name: "@Distrito", value: provider.district, dbType: DbType.String, direction: ParameterDirection.Input);
p.Add(name: "@Direccion", value: provider.address, dbType: DbType.String, direction: ParameterDirection.Input);
p.Add(name: "@NomRepresent", value: provider.firtsname_representative, dbType: DbType.String, direction: ParameterDirection.Input);
p.Add(name: "@ApeRepresent", value: provider.lastname_representative, dbType: DbType.String, direction: ParameterDirection.Input);
p.Add(name: "@idprovider", dbType: DbType.Int32, direction: ParameterDirection.Output);
resu = db.Query <EntityProvider>(sql, param: p, commandType: CommandType.StoredProcedure).FirstOrDefault();
int idprovider = p.Get <int>("@idprovider");
if (idprovider > 0)
{
returnEntity.isSuccess = true;
returnEntity.errorCode = "0000";
returnEntity.errorMessage = string.Empty;
returnEntity.data = idprovider;
}
else
{
returnEntity.isSuccess = false;
returnEntity.errorCode = "0000";
returnEntity.errorMessage = string.Empty;
returnEntity.data = idprovider;
}
}
}
catch (Exception ex)
{
returnEntity.isSuccess = false;
returnEntity.errorCode = "0001";
returnEntity.errorMessage = ex.Message;
returnEntity.data = null;
}
return(returnEntity);
}
public override Dictionary <string, DataSet> Execute(string filter, Status status)
{
Dictionary <string, DataSet> results;
this._status = status;
try
{
base.StartPrivateSession();
//BuildJournalList(filter, this.CompId, base.TransMan);
Dictionary <string, object> parameters = new Dictionary <string, object>();
//Date gg = Convert.Date(Convert.ToString(frmArContribTrialBalControl._from).Substring(0,9).Trim());
// parameters.Add("@PmtDateFrom", "3/1/14");
//parameters.Add("@PmtDateThru", Convert.ToString(frmArContribTrialBalControl._thru).Substring(0,9).Trim());
parameters.Add("@PmtDateThru", frmArContribTrialBalControl._thru);
//parameters.Add("@PrintOption", this.PrintOption);
//parameters.Add("@SortOption", this.SortOption);
//parameters.Add("@SortOrder", this.SortOrder);
//parameters.Add("@ReportCurrency", this.ReportCurrency);
//if (Convert.ToInt32(frmArGroupStatisticRptControl.selection.EditValue) == 1)
if (frmArContribTrialBalControl._selection == 1)
{
set = EntityProvider.ExecuteCommand("trav_ARContribTrialBalanceArea_proc_CSI", this.CompId, true, parameters, base.TransMan);
}
else if (frmArContribTrialBalControl._selection == 2)
{
set = EntityProvider.ExecuteCommand("trav_ARContribTrialBalanceCitySt_proc_CSI", this.CompId, true, parameters, base.TransMan);
}
else
{
set = null;
}
for (int i = 0; i < set.Tables.Count; i++)
{
DataSet set2 = new DataSet("MainDataset");
DataTable table = set.Tables[i].Copy();
set2.Tables.Add(table);
this.Results.Add(i.ToString(), set2);
}
results = this.Results;
}
catch (Exception exception)
{
base.StopPrivateSession(true);
throw exception;
}
finally
{
base.StopPrivateSession(false);
}
return(results);
}
public UserConverter(GroupConverter groupConverter,
EmailRepository emailRepository,
TelephoneNumberRepository telephoneNumberRepository,
AddressRepository addressRepository,
EntityProvider <EntityType> entityProvider,
PropertyCopier propertyCopier,
VirtualWorkDatabaseContext virtualWorkDatabaseContext)
: base(entityProvider, propertyCopier, virtualWorkDatabaseContext)
{
this.emailRepository = emailRepository;
this.telephoneNumberRepository = telephoneNumberRepository;
this.addressRepository = addressRepository;
this.groupConverter = groupConverter;
}
/// <summary>
/// Sets the address.
/// </summary>
/// <param name="streets">The streets.</param>
/// <param name="name">The name.</param>
/// <param name="entity">The entity.</param>
private static void SetAddress(List <EntityStreet> streets, string name, ref EntityProvider entity)
{
var str = streets[UtilsService.RandomNumber(0, streets.Count - 1)];
var sub = _suburbList.FirstOrDefault(c => c.Id == str.SuburbId);
var town = _townList.FirstOrDefault(c => c.Id == sub.TownId);
var prov = _provinceList.FirstOrDefault(c => c.Id == town.ProvinceId);
entity.StreetId = str.Id;
entity.House = name;
entity.Street = str.Name;
entity.Suburb = sub.Name;
entity.Town = town.Name;
entity.Province = prov.Name;
entity.Country = prov.Country;
}
public BaseResponse SearchById(int id)
{
var returnEntity = new BaseResponse();
var provider = new EntityProvider();
try
{
using (var db = GetSqlConnection())
{
const string sql = "search_provider";
var p = new DynamicParameters();
//p.Add(name: "@userid", dbType: DbType.Int32, direction: ParameterDirection.Output);
p.Add(name: "@id", value: id, dbType: DbType.Int32, direction: ParameterDirection.Input);
//p.Add(name: "@email", value: user.email, dbType: DbType.String, direction: ParameterDirection.Input);
//p.Add(name: "@password", value: user.password, dbType: DbType.String, direction: ParameterDirection.Input);
//p.Add(name: "@perfil", value: user.role, dbType: DbType.String, direction: ParameterDirection.Input);
//p.Add(name: "@user_create", value: user.UsuarioCrea, dbType: DbType.Int32, direction: ParameterDirection.Input);
provider = db.Query <EntityProvider>(sql, param: p, commandType: CommandType.StoredProcedure).FirstOrDefault();
//int IdUsuario = p.Get<int>("@userid");
if (provider != null)
{
returnEntity.isSuccess = true;
returnEntity.errorCode = "0000";
returnEntity.errorMessage = string.Empty;
returnEntity.data = provider;
}
else
{
returnEntity.isSuccess = false;
returnEntity.errorCode = "0000";
returnEntity.errorMessage = string.Empty;
returnEntity.data = null;
}
}
}
catch (Exception ex)
{
returnEntity.isSuccess = false;
returnEntity.errorCode = "0001";
returnEntity.errorMessage = ex.Message;
returnEntity.data = null;
}
return(returnEntity);
}
/// <summary>
/// Counts the links to the various Wikimedia projects.
/// </summary>
/// <param name="entities">Entities to check.</param>
/// <returns>Number of sitelinks by name of the wiki.</returns>
public Dictionary <String, Int32> CountSiteLinks(IEnumerable <Entity> entities, StringBuilder collisionData)
{
var result = new Dictionary <String, Int32>();
result["Orphan"] = 0;
result["Deleted"] = 0;
// Create a new EntityProvider instance and pass the api created above.
EntityProvider entityProvider = new EntityProvider(_helper.Api);
foreach (var entity in entities)
{
// Get an entity by searching for the id
var item = _helper.GetWikiDataItemForEntity(entity);
if (item != null)
{
var links = item.getSitelinks();
if (!links.Any())
{
result["Orphan"]++;
if (collisionData != null)
{
collisionData.AppendFormat("Orphan: {0} - {1} ({2})", entity.wiki.wikidata, entity.english, entity.geocode);
collisionData.AppendLine();
}
}
foreach (var key in links.Keys)
{
if (!result.ContainsKey(key))
{
result[key] = 0;
}
result[key]++;
}
}
else
{
result["Deleted"]++;
if (collisionData != null)
{
collisionData.AppendFormat("Deleted: {0} - {1} ({2})", entity.wiki.wikidata, entity.english, entity.geocode);
collisionData.AppendLine();
}
}
}
return(result);
}
/// <summary>
/// Gets the providers.
/// </summary>
/// <returns></returns>
internal static async Task <List <EntityProvider> > GetProviders()
{
if (_providers == null)
{
_providers = new List <EntityProvider>();
}
if (_providers.Count == 0)
{
var streets = await GetStreets();
var dto1 = new EntityProvider();
dto1.Id = UtilsService.GenerateId(dto1.Id);
dto1.Name = "MultiChoice South Africa";
dto1.ContactPerson = "Sales Team";
dto1.EmailAddress = "*****@*****.**";
dto1.PhoneNumber = "+27 21 508 1234";
dto1.MobileNumber = null;
dto1.WebAddress = "http://www.multichoice.co.za";
dto1.IsFavourite = false;
SetAddress(streets, "15, DStv House", ref dto1);
_providers.Add(dto1);
var dto2 = new EntityProvider();
dto2.Id = UtilsService.GenerateId(dto2.Id);
dto2.Name = "MultiChoice Africa";
dto2.ContactPerson = "Sales Manager";
dto2.EmailAddress = "*****@*****.**";
dto2.PhoneNumber = "+27 11 218 2342";
dto2.MobileNumber = "+27 82 131 3893";
dto2.WebAddress = "http://www.multichoice.co.za";
dto2.IsFavourite = false;
SetAddress(streets, "64, Africa House", ref dto2);
_providers.Add(dto2);
}
using (var db = new MancobaLocalDataApi(ConnectionFactory, PlatformCapabilities))
{
var response = await db.SaveProvider(_providers);
}
return(_providers.OrderBy(c => c.Name).ToList());
}
private static void ConvertArchiveConservationEnabled(DocumentArchive archive)
{
EntityProvider currentProvider = DbProvider;
ICollection <Document> toUpdateDocuments = currentProvider.GetPreservationDocumentsNoDateMain(archive);
currentProvider.BeginNoSaveNoTransaction();
foreach (Document doc in toUpdateDocuments)
{
BindingList <DocumentAttributeValue> docAttributes = currentProvider.GetFullDocumentAttributeValues(doc.IdDocument);
AttributeService.ParseAttributeValues(archive, docAttributes, out DateTime? mainDate);
if (mainDate.HasValue)
{
Guid mainDateAttributeId = docAttributes.Where(x => x.Attribute.IsMainDate == true).Single().IdAttribute;
doc.DateMain = mainDate;
currentProvider.UpdateDateMain(doc.IdDocument, mainDate);
logger.Info($"ConvertArchiveConservationEnabled -> IdDocument: {doc.IdDocument} - IdArchive: {archive.IdArchive} - MainDate attribute Id: {mainDateAttributeId} - MainDate value: {mainDate:dd/MM/yyyy HH:mm:ss}");
}
}
currentProvider.SaveChanges();
}
public void BeforeEach()
{
var log = new CustomLogData(l => Debug.WriteLine(l));
logwriter = new RegionBasedLogWriter(log, "Spec");
sqlProvider = new PostgreSqlProvider(connectionPool, logwriter.NewRegion(nameof(PostgreSqlProvider)), SCHEMA);
sqlProvider.EnsureSchemaExists();
typeManager = new TypeManager();
typeManager.Register <DeviceType>();
typeManager.Register <SensorType>();
entityProvider = new EntityProvider(sqlProvider, logwriter.NewRegion(nameof(EntityProvider)));
provider = new ItemProvider(entityProvider, typeManager, logwriter.NewRegion(nameof(ItemProvider)));
var tables = sqlProvider.GetTableNamesBySchema(SCHEMA);
foreach (var table in tables)
{
sqlProvider.DropTable(table);
}
}
public void AddEntity_Fail(EntityTypes type, bool IsHead)
{
//arrange
var TargetTreeMember = CreateSampleTreeMember(type, IsHead);
Mock <IDataService> DSM = new Mock <IDataService>();
Mock <IRTree <IEntity> > RTM = new Mock <IRTree <IEntity> >();
RTM.Setup(x => x.AddItem(It.IsAny <IEntity>(), IsHead)).Returns(TargetTreeMember);
DSM.Setup(x => x.EntityTree).Returns(RTM.Object);
Mock <IEntityFactory> EFM = new Mock <IEntityFactory>();
EFM.Setup(x => x.CreateOrganization()).Returns(CreateSampleOrganization());
EFM.Setup(x => x.CreateCharacter()).Returns(CreateSampleCharacter());
IEntityProvider EP = new EntityProvider(new EventAggregator(), DSM.Object, EFM.Object);
//assert // act
Assert.ThrowsException <InvalidOperationException>(() => EP.AddEntity(type, IsHead));
}
/// <summary>
/// To the model.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
internal static ModelProvider ToModel(this EntityProvider entity)
{
var model = new ModelProvider();
model.Id = entity.Id;
model.Name = entity.Name;
model.ContactPerson = entity.ContactPerson;
model.EmailAddress = entity.EmailAddress;
model.PhoneNumber = entity.PhoneNumber;
model.MobileNumber = entity.MobileNumber;
model.WebAddress = entity.WebAddress;
model.IsFavourite = entity.IsFavourite;
model.StreetId = entity.StreetId;
model.House = entity.House;
model.Street = entity.Street;
model.Suburb = entity.Suburb;
model.Town = entity.Town;
model.Province = entity.Province;
model.Country = entity.Country;
return(model);
}
/// <summary>
/// Elimina una document unit. Rimuove anche i riferimenti dei documenti alla DocumentUnit dalla tabella DocumentUnitChain
/// </summary>
/// <param name="idDocumentUnit"></param>
/// <returns>Ritorna n. di record complessivamente eliminati</returns>
public static int UdsDeleteDocumentUnit(Guid idDocumentUnit, bool detachDocuments = true)
{
EntityProvider provider = DbProvider;
using (DbTransaction tran = provider.BeginNoSave())
{
try
{
//detach dei documenti
if (detachDocuments)
{
var docChain = DbProvider.UdsGetUnitChain(idDocumentUnit);
foreach (var item in docChain)
{
DetachDocument(item.Document);
}
}
provider.UdsDeleteDocumentUnitChain(idDocumentUnit);
provider.UdsDeleteDocumentUnit(idDocumentUnit);
int count = provider.SaveChanges();
tran.Commit();
return(count);
}
catch
{
try
{
tran.Rollback();
}
catch
{
}
throw;
}
}
}
public override Dictionary <string, DataSet> Execute(string filter, Status status)
{
Dictionary <string, DataSet> results;
this._status = status; //Missing Definition
try
{
base.StartPrivateSession();
BuildBlanketOrderList(filter, this.CompId, base.TransMan);
Dictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("@SortBy", this._sortBy); //Missing Definition
parameters.Add("@PrintAllInBaseCurrency", this.PrintAllInBase);
parameters.Add("@ReportCurrency", this.ReportCurrency);
parameters.Add("@ExchRate", TRAVERSE.Business.Sys.Currency.GetExchangeRate(this.ReportCurrency, ApplicationContext.SessionDate));//TRAVERSE.Business.Sys.
parameters.Add("@WksDate", ApplicationContext.SessionDate);
DataSet set = EntityProvider.ExecuteCommand("dbo.trav_SoBlanketOrderReport_proc_CSI", this.CompId, true, parameters, base.TransMan);
for (int i = 0; i < set.Tables.Count; i++)
{
DataSet set2 = new DataSet("MainDataset");
DataTable table = set.Tables[i].Copy();
set2.Tables.Add(table);
this.Results.Add(i.ToString(), set2);
}
results = this.Results;
}
catch (Exception exception)
{
base.StopPrivateSession(true);
throw exception;
}
finally
{
base.StopPrivateSession(false);
}
return(results);
}
protected static void TestQuery(EntityProvider pro, Expression query, string testName, bool expectedToFail)
{
if (query.NodeType == ExpressionType.Convert && query.Type == typeof(object))
{
query = ((UnaryExpression)query).Operand; // remove box
}
if (pro.Log != null)
{
DbExpressionWriter.Write(pro.Log, query);
pro.Log.WriteLine();
pro.Log.WriteLine("==>");
}
string queryText = pro.GetQueryText(query);
SetNewBaseLine(testName, queryText);
if (_executeQueries)
{
object result = pro.Execute(query);
IEnumerable seq = result as IEnumerable;
if (seq != null)
{
// iterate results
foreach (var item in seq)
{
}
}
else
{
IDisposable disposable = result as IDisposable;
if (disposable != null)
disposable.Dispose();
}
}
else if (pro.Log != null)
{
var text = pro.GetQueryText(query);
pro.Log.WriteLine(text);
pro.Log.WriteLine();
}
string expected = GetBaseLine(testName);
if (expected != null)
{
string trimActual = TrimExtraWhiteSpace(queryText).Trim();
string trimExpected = TrimExtraWhiteSpace(expected).Trim();
Assert.AreEqual(trimExpected, trimActual);
}
}
private long Save(EntityProvider provider)
{
bool isReuse = false;
var entityProvider = GetProvider(provider, out isReuse);
long id = 0;
try
{
Type thisType = this.GetType();
var attrs = thisType.GetCustomAttributes(typeof(EntityChildAttribute), false);
if (attrs != null && attrs.Length > 0)
{
#region 使用事务去保存该实体与其他相关实体
using (TransactionScope scope = new TransactionScope())
{
if (this.ID > 0)
{
id = this.ID;
entityProvider.ExcuteUpdate(this);
}
else
{
if (this.Collection.Count > 0)
{
id = entityProvider.ExcuteInsert(this);
}
}
if (attrs != null && attrs.Length > 0)
{
#region 保存外键关联表信息
foreach (EntityChildAttribute attr in attrs)
{
foreach (var pname in attr.PropertyNames)
{
var pi = thisType.GetProperty(pname, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase);
if (pi == null)
{
continue;
}
var v = pi.GetValue(this);
if (v == null)
{
continue;
}
var fkey = pi.GetCustomAttribute<FKeyAttribute>(false);
if (attr is EntityChildrenAttribute)
{
#region Save EntityChildren
var list = v as IList;
foreach (EntityBase data in list)
{
if (data.ID == 0 && fkey != null && fkey.FKey != null && fkey.FKey.Length > 0)
{
data.SetDbValue(fkey.FKey, id);
}
data.Save(entityProvider);
}
#endregion
}
else
{
#region Save EntityChild
var entity = v as EntityBase;
if (entity.ID == 0 && fkey != null && fkey.FKey != null && fkey.FKey.Length > 0)
{
entity.SetDbValue(fkey.FKey, this.ID);
}
entity.Save(entityProvider);
#endregion
}
}
}
#endregion
}
scope.Complete();
}
#endregion
}
else
{
#region 保存当前实体
if (this.ID > 0)
{
id = this.ID;
entityProvider.ExcuteUpdate(this);
}
else
{
if (this.Collection.Count > 0)
{
id = entityProvider.ExcuteInsert(this);
}
}
#endregion
}
}
catch
{
throw;
}
finally
{
if (!isReuse)
{
entityProvider.Close();
}
}
if (this._id == 0 && id > 0)
{
this.ID = id;
}
return id;
}
public NorthwindX(EntityProvider provider)
{
this.provider = provider;
}
public NorthwindSession(EntityProvider provider)
: this(new EntitySession(provider))
{
}
internal EntityProvider GetProvider(EntityProvider provider, out bool isReuse)
{
return DbContext.GetEntityProvider(provider, this.GetType(), out isReuse);
}
protected void TestQuery(EntityProvider pro, Expression query, bool expectedToFail)
{
if (query.NodeType == ExpressionType.Convert && query.Type == typeof(object))
{
query = ((UnaryExpression)query).Operand; // remove box
}
this.queryText = null;
this.queryText = pro.GetQueryText(query);
WriteBaseline(baselineKey, queryText);
if (this.executeQueries)
{
Exception caught = null;
try
{
object result = pro.Execute(query);
IEnumerable seq = result as IEnumerable;
if (seq != null)
{
// iterate results
foreach (var item in seq)
{
}
}
else
{
IDisposable disposable = result as IDisposable;
if (disposable != null)
disposable.Dispose();
}
}
catch (Exception e)
{
caught = e;
if (!expectedToFail)
{
throw new TestFailureException(e.Message + "\r\n\r\n" + queryText);
}
}
if (caught == null && expectedToFail)
{
throw new InvalidOperationException("Query succeeded when expected to fail");
}
}
string baseline = null;
if (this.baselines != null && this.baselines.TryGetValue(this.baselineKey, out baseline))
{
string trimAct = TrimExtraWhiteSpace(queryText).Trim();
string trimBase = TrimExtraWhiteSpace(baseline).Trim();
if (trimAct != trimBase)
{
throw new InvalidOperationException(string.Format("Query translation does not match baseline:\r\n Expected: {0}\r\n Actual : {1}", trimBase, trimAct));
}
}
if (baseline == null && this.baselines != null)
{
throw new InvalidOperationException("No baseline");
}
}
protected void TestQuery(EntityProvider pro, Expression query, string baselineKey, bool expectedToFail)
{
ConsoleColor originalColor = Console.ForegroundColor;
try
{
if (query.NodeType == ExpressionType.Convert && query.Type == typeof(object))
{
query = ((UnaryExpression)query).Operand; // remove box
}
if (pro.Log != null)
{
Console.ForegroundColor = ConsoleColor.Gray;
DbExpressionWriter.Write(pro.Log, pro.Language, query);
pro.Log.WriteLine();
pro.Log.WriteLine("==>");
}
string queryText = null;
try
{
queryText = pro.GetQueryText(query);
WriteBaseline(baselineKey, queryText);
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(string.Format("Query translation failed for {0}", baselineKey));
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(query.ToString());
throw new TestFailureException(e.Message);
}
if (this.executeQueries)
{
Exception caught = null;
try
{
object result = pro.Execute(query);
IEnumerable seq = result as IEnumerable;
if (seq != null)
{
// iterate results
foreach (var item in seq)
{
}
}
else
{
IDisposable disposable = result as IDisposable;
if (disposable != null)
disposable.Dispose();
}
}
catch (Exception e)
{
caught = e;
if (!expectedToFail)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Query failed to execute:");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(queryText);
throw new TestFailureException(e.Message);
}
}
if (caught == null && expectedToFail)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Query succeeded when expected to fail");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(queryText);
throw new TestFailureException(null);
}
}
else if (pro.Log != null)
{
var text = pro.GetQueryText(query);
pro.Log.WriteLine(text);
pro.Log.WriteLine();
}
string baseline = null;
if (this.baselines != null && this.baselines.TryGetValue(baselineKey, out baseline))
{
string trimAct = TrimExtraWhiteSpace(queryText).Trim();
string trimBase = TrimExtraWhiteSpace(baseline).Trim();
if (trimAct != trimBase)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Query translation does not match baseline:");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(queryText);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("---- current ----");
WriteDifferences(trimAct, trimBase);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("---- baseline ----");
WriteDifferences(trimBase, trimAct);
Console.ForegroundColor = ConsoleColor.Yellow;
throw new TestFailureException("Translation differed from baseline.");
}
}
if (baseline == null && this.baselines != null)
{
throw new TestFailureException("No baseline");
}
}
finally
{
Console.ForegroundColor = originalColor;
}
}
