public override void SaveOperation(object sender, RoutedEventArgs e)
{
//validations on each row
foreach (var row in FPTemplateRows)
{
//sl no should be unique
var duplicateRow = FPTemplateRows.FirstOrDefault(p => p.SlNo == row.SlNo && p != row);
if (duplicateRow != null)
{
MessageBox.Show("Sl no " + row.SlNo + " has been repeated twice, Correct this before saving");
return;
}
//Location + segment uniqueness validation validation
var conflictingRow = FPTemplateRows.FirstOrDefault(p => p.SlNo != row.SlNo && p.Location == row.Location && p.Segment == row.Segment);
if (conflictingRow != null)
{
MessageBox.Show("Rows with Sl No " + row.SlNo + " and " + conflictingRow.SlNo + " have the same location and segments. Correct this before saving");
return;
}
}
base.SaveOperation(sender, e);
//update the energy grid
UpdateEnergyWiseArea();
}
private Entity FindBasePrice(EntityCollection basePrices, Entity productEntity)
{
int precision = GetPricePrecision(productEntity);
var price = GetPrice(productEntity, precision);
return(basePrices.FirstOrDefault(p => GetPrice(p, precision) == price));
}
// TODO: Move to own repository?
private long GetMedicalVendorUserEventTestLockId(long physicianId, long eventCustomerResultId, bool isActive)
{
var medicalVendorUserEventTestLockEntities = new EntityCollection <EventCustomerEvaluationLockEntity>();
IRelationPredicateBucket bucket = new RelationPredicateBucket(
EventCustomerEvaluationLockFields.PhysicianId == physicianId);
bucket.PredicateExpression.Add(EventCustomerEvaluationLockFields.EventCustomerId == eventCustomerResultId);
//bucket.PredicateExpression.Add(EventCustomerEvaluationLockFields.IsActive == isActive);
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
myAdapter.FetchEntityCollection(medicalVendorUserEventTestLockEntities, bucket);
}
try
{
return(medicalVendorUserEventTestLockEntities.FirstOrDefault().PhysicianId);
}
catch (NullReferenceException)
{
throw new ArgumentException(string.Format
("No UserEventTestLock exists for the given PhysicianId {0} and EventCustomerResultId {1}.",
physicianId, eventCustomerResultId));
}
}
public virtual async Task <TournamentEntity> GetTournamentEntityForMatchPlannerAsync(long tournamentId, CancellationToken cancellationToken)
{
var bucket = new RelationPredicateBucket(TournamentFields.Id == tournamentId);
bucket.Relations.Add(TournamentEntity.Relations.RoundEntityUsingTournamentId);
bucket.Relations.Add(RoundEntity.Relations.TeamInRoundEntityUsingRoundId);
bucket.Relations.Add(TeamInRoundEntity.Relations.TeamEntityUsingTeamId);
bucket.Relations.Add(TeamEntity.Relations.VenueEntityUsingVenueId);
var prefetchPathTournament = new PrefetchPath2(EntityType.TournamentEntity);
prefetchPathTournament.Add(TournamentEntity.PrefetchPathRounds);
prefetchPathTournament[0].SubPath.Add(RoundEntity.PrefetchPathRoundLegs);
prefetchPathTournament[0].SubPath.Add(RoundEntity.PrefetchPathTeamCollectionViaTeamInRound).SubPath
.Add(TeamEntity.PrefetchPathVenue);
var t = new EntityCollection <TournamentEntity>();
using var da = _dbContext.GetNewAdapter();
var qp = new QueryParameters(0, 0, 0, bucket)
{
CollectionToFetch = t,
PrefetchPathToUse = prefetchPathTournament
};
await da.FetchEntityCollectionAsync(qp, cancellationToken);
return(t.FirstOrDefault());
}
/// <summary>
/// Remove First Where
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="coll"></param>
/// <param name="funct"></param>
public static void RemoveWhere <T>(this EntityCollection <T> coll, Func <T, bool> funct)
where T : class
{
var t = coll.FirstOrDefault(funct);
if (t != null)
{
coll.Remove(t);
}
}
/// <summary>
/// Recalculates all scores of current partnership obligation parameters.
/// </summary>
/// <param name="partnershipId"><see cref="Guid"/> Id of partnership.</param>
public void RecalculateAllScore(Guid partnershipId)
{
var obligationsEsq = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "PartnershipParameter");
obligationsEsq.Filters.Add(
obligationsEsq.CreateFilterWithParameters(FilterComparisonType.Equal, "Partnership", partnershipId));
obligationsEsq.Filters.Add(
obligationsEsq.CreateFilterWithParameters(FilterComparisonType.Equal, "ParameterType",
PRMBaseConstants.ObligationParameterTypeId));
obligationsEsq.PrimaryQueryColumn.IsAlwaysSelect = true;
obligationsEsq.AddColumn("PartnershipParameterType");
obligationsEsq.AddColumn("IntValue");
obligationsEsq.AddColumn("FloatValue");
obligationsEsq.AddColumn("PartnerParamCategory");
obligationsEsq.AddColumn("Score");
obligationsEsq.UseAdminRights = false;
EntityCollection obligationsCollection = obligationsEsq.GetEntityCollection(_userConnection);
foreach (var target in obligationsCollection)
{
if (target.GetTypedColumnValue <Guid>("PartnershipParameterTypeId") == PRMBaseConstants.TargetPartnershipParamTypeId)
{
string targetScoreColumnName = target.GetTypedColumnValue <int>("IntValue") != 0
? "IntValue"
: "FloatValue";
var targetValue = target.GetTypedColumnValue <double>(targetScoreColumnName);
if (targetValue > 0)
{
Entity currentParameter =
obligationsCollection.FirstOrDefault(
x => x.GetTypedColumnValue <Guid>("PartnershipParameterTypeId") == PRMBaseConstants.CurrentPartnershipParamTypeId &&
x.GetTypedColumnValue <Guid>("PartnerParamCategoryId") == target.GetTypedColumnValue <Guid>("PartnerParamCategoryId"));
if (currentParameter == null)
{
return;
}
var targetScore = target.GetTypedColumnValue <double>("Score");
var currentValue = currentParameter.GetTypedColumnValue <double>(targetScoreColumnName);
var currentScore = Convert.ToInt32(currentValue >= targetValue ? targetScore : Math.Round((targetScore / targetValue) * currentValue));
var currentParameterId = currentParameter.GetTypedColumnValue <Guid>("Id");
var update = new Update(_userConnection, "PartnershipParameter")
.Set("Score", Column.Parameter(currentScore))
.Where("Id").IsEqual(Column.Parameter(currentParameterId))
.Execute();
}
}
}
}
public static void DeleteHelper(EntityCollection <TEntity> entityCollection)
{
if (entityCollection != null && entityCollection.Any())
{
using (var context = (entityCollection.FirstOrDefault() as ERP_Core.BaseEntityObject).GetContext() as TObjectContext)
{
DeleteHelper(context, entityCollection);
}
//Int32 count = entityCollection.Count();
//for (int i = 0; i < count; i++)
//{
// Object entity = entityCollection.Skip(0).Take(1).Single();
// context.DeleteObject(entity);
//}
}
}
public Entity FindEntity(string entitySchemaName, Dictionary <string, object> conditions,
Dictionary <string, OrderDirection> orderByColumns)
{
var esq = new EntitySchemaQuery(_userConnection.EntitySchemaManager, entitySchemaName);
esq.AddAllSchemaColumns();
foreach (KeyValuePair <string, object> condition in conditions)
{
IEntitySchemaQueryFilterItem columnFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal,
condition.Key, condition.Value);
esq.Filters.Add(columnFilter);
}
foreach (KeyValuePair <string, OrderDirection> orderByColumn in orderByColumns)
{
EntitySchemaQueryColumn column = esq.Columns.GetByName(orderByColumn.Key);
column.OrderDirection = orderByColumn.Value;
}
EntityCollection entities = esq.GetEntityCollection(_userConnection);
return(entities.FirstOrDefault());
}
private void LoadEntities()
{
var bucket = new RelationPredicateBucket(TournamentFields.Id == _tournament.Id);
bucket.Relations.Add(TournamentEntity.Relations.RoundEntityUsingTournamentId);
bucket.Relations.Add(RoundEntity.Relations.TeamInRoundEntityUsingRoundId);
bucket.Relations.Add(TeamInRoundEntity.Relations.TeamEntityUsingTeamId);
bucket.Relations.Add(TeamEntity.Relations.VenueEntityUsingVenueId);
var prefetchPathTournament = new PrefetchPath2(EntityType.TournamentEntity);
prefetchPathTournament.Add(TournamentEntity.PrefetchPathRounds);
prefetchPathTournament[1].SubPath.Add(RoundEntity.PrefetchPathRoundLegs);
prefetchPathTournament[1].SubPath.Add(RoundEntity.PrefetchPathTeamCollectionViaTeamInRound).SubPath.Add(TeamEntity.PrefetchPathVenue);
var t = new EntityCollection <TournamentEntity>();
_appDb.DbContext.GetNewAdapter().FetchEntityCollection(t, bucket, prefetchPathTournament);
_tournament = t.FirstOrDefault();
_entitiesLoaded = true;
}
/// <summary>
/// Searches for the city entity.
/// </summary>
/// <param name="cityNames">The variants of the city name.</param>
/// <returns>The found city entity or <c>null</c>.</returns>
/// <remarks>Tries to identify the city name language and searches for this language's culture.</remarks>
public Entity SearchForCity(IEnumerable <string> cityNames)
{
if (cityNames.IsNullOrEmpty())
{
return(null);
}
var esq = new EntitySchemaQuery(_citySchema)
{
RowCount = 1,
Cache = _userConnection.ApplicationCache,
IgnoreDisplayValues = true
};
string primaryDisplayColumnName = _citySchema.PrimaryDisplayColumn.Name;
esq.AddColumn(_citySchema.PrimaryDisplayColumn.Name);
esq.PrimaryQueryColumn.IsVisible = true;
SetCityQueryCulture(cityNames, esq);
esq.Filters.Add(
esq.CreateFilterWithParameters(FilterComparisonType.Equal, primaryDisplayColumnName, cityNames));
EntityCollection entities = esq.GetEntityCollection(_userConnection);
return(entities.FirstOrDefault());
}
/// <summary>
/// Searches for the country entity.
/// </summary>
/// <param name="code">The code of the country.</param>
/// <remarks>Uses alpha3 code of the country.</remarks>
/// <returns>The found country entity or <c>null</c>.</returns>
public Entity SearchForCountry(string code)
{
if (code.IsNullOrEmpty())
{
return(null);
}
string cacheItemName =
string.Format("EmailMining_LocationHelper_SearchForCountry_{0}_{1}", code, _userCultureId);
var esq = new EntitySchemaQuery(_countrySchema)
{
RowCount = 1,
Cache = _userConnection.ApplicationCache,
CacheItemName = cacheItemName,
IgnoreDisplayValues = true
};
esq.AddColumn(_countrySchema.PrimaryDisplayColumn.Name);
esq.PrimaryQueryColumn.IsVisible = true;
esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Code", code));
EntityCollection entities = esq.GetEntityCollection(_userConnection);
return(entities.FirstOrDefault());
}
/// <summary>
/// Merge collection of entities into golden entity.
/// </summary>
/// <param name="schemaName">Schema name.</param>
/// <param name="groupId">Identifier of the group of search results.</param>
/// <param name="goldenRecordId">Golden entity record identifier.</param>
/// <param name="duplicateRecordIds">Collection of entity unique identifiers.</param>
/// <param name="resolvedConflicts">Config for resolving conflicts.</param>
public virtual void MergeEntityDublicates(string schemaName, int groupId, List <Guid> duplicateRecordIds, Dictionary <string, string> resolvedConflicts)
{
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName(schemaName);
EntityCollection duplicates = GetEntityDublicates(schemaName, duplicateRecordIds);
Entity goldenEntity = duplicates.FirstOrDefault();
if (goldenEntity == null)
{
return;
}
duplicates.RemoveFirst();
duplicateRecordIds.Remove(goldenEntity.PrimaryColumnValue);
if (duplicates.Count == 0)
{
return;
}
Dictionary <string, string> detailMergeRules = GetDetailMergeRules(schemaName);
Dictionary <string, List <string> > referencedTables = GetReferencedTablesInfo(schemaName);
var entitySchemaOpposites = GetEntitySchemaOpposites(entitySchema.UId);
using (DBExecutor dbExecutor = UserConnection.EnsureDBConnection()) {
dbExecutor.CommandTimeout = 3600;
dbExecutor.StartTransaction();
foreach (var table in referencedTables)
{
string tableName = table.Key;
_log.Info($"schemaName: ${schemaName}, ref. tableName: ${tableName}, ref. columns: ${string.Join(", ", table.Value)}");
Guid goldRecordId = goldenEntity.PrimaryColumnValue;
try {
if (detailMergeRules.ContainsKey(tableName))
{
string mergeRule = detailMergeRules[tableName];
MergeDetailRecordsByRule(mergeRule, tableName, goldRecordId, duplicateRecordIds,
dbExecutor, entitySchemaOpposites);
}
else
{
UpdateReferencedRecords(tableName, table.Value, goldRecordId, duplicateRecordIds,
dbExecutor);
}
} catch {
dbExecutor.RollbackTransaction();
throw;
}
}
try {
MergeDuplicatesWithGoldRecord(goldenEntity, duplicates, resolvedConflicts);
DeleteMasterRecords(schemaName, duplicateRecordIds, dbExecutor);
SendDataToExternalServices(entitySchema, duplicateRecordIds);
goldenEntity.Save();
} catch {
dbExecutor.RollbackTransaction();
RevertSearchResultGroupToPositive(schemaName, groupId);
throw;
}
dbExecutor.CommitTransaction();
}
DeleteSearchResultGroup(schemaName, groupId);
DeleteMergedEntitiesFromSearchResult(schemaName, duplicateRecordIds);
PerformAfterDeduplicationActions(goldenEntity);
if (UserConnection.GetIsFeatureEnabled("UseDuplicatesHistory"))
{
LogMergeDuplicatesRecords(schemaName, duplicateRecordIds, goldenEntity.PrimaryColumnValue);
}
}
/// <summary>
/// Validates duplicate entities.
/// </summary>
/// <param name="schemaName">Schema name.</param>
/// <param name="duplicateRecordIds">Collection of identifiers of duplicate entities.</param>
/// <param name="resolvedConflicts">Config for resolving conflicts.</param>
/// <returns>Validation result.</returns>
public ValidateDuplicatesResponse ValidateDuplicates(string schemaName, List <Guid> duplicateRecordIds,
Dictionary <string, string> resolvedConflicts)
{
ValidateDuplicatesResponse response = new ValidateDuplicatesResponse();
EntitySchema entitySchema = UserConnection.EntitySchemaManager.GetInstanceByName(schemaName);
EntityCollection entityCollection = GetEntityDublicates(schemaName, duplicateRecordIds);
Entity goldenEntity = entityCollection.FirstOrDefault();
if (goldenEntity == null)
{
return(response);
}
entityCollection.RemoveFirst();
List <string> resolvedColumns = new List <string>();
if (resolvedConflicts != null)
{
resolvedColumns = resolvedConflicts.Keys.ToList();
}
List <string> conflictColumns = new List <string>();
foreach (EntitySchemaColumn column in goldenEntity.Schema.Columns)
{
if (IsColumnInIgnoreList(column.Name))
{
continue;
}
if (GetIsSystemColumn(entitySchema, column))
{
continue;
}
if (resolvedColumns.Contains(column.Name))
{
continue;
}
bool isConflictColumn = false;
EntityColumnValue goldenColumnValue = goldenEntity.FindEntityColumnValue(column.ColumnValueName);
foreach (Entity entity in entityCollection)
{
EntityColumnValue columnValue = entity.FindEntityColumnValue(column.ColumnValueName);
if (DataTypeUtilities.ValueIsNullOrEmpty(goldenColumnValue.Value))
{
goldenColumnValue = columnValue;
continue;
}
if (DataTypeUtilities.ValueIsNullOrEmpty(columnValue.Value))
{
continue;
}
if (IsEquals(goldenColumnValue.Value, columnValue.Value) == false)
{
isConflictColumn = true;
break;
}
}
if (isConflictColumn)
{
conflictColumns.Add(column.Name);
}
}
if (conflictColumns.Any())
{
conflictColumns.AddRange(resolvedColumns);
EntityCollection conflicts = GetEntityDublicates(schemaName, duplicateRecordIds, conflictColumns);
Dictionary <string, string> columnMap = GetQueryColumns(conflicts.Schema.Columns);
DataContract.EntityCollection convertedEntities =
QueryExtension.GetEntityCollection(conflicts, columnMap);
response.Conflicts = convertedEntities;
}
return(response);
}
private Entity FindBaseUnit(EntityCollection baseUnits, Entity productEntity)
{
var productUnitId = productEntity.GetTypedColumnValue <Guid>("UnitId");
return(baseUnits.FirstOrDefault(u => u.GetTypedColumnValue <Guid>("UnitId").Equals(productUnitId)));
}
public T this[byte slot]
{
get { return(_items.FirstOrDefault(item => item.Slot == slot)); }
}
public TEntity GetById(int id)
{
return(EntityCollection
.FirstOrDefault(x => x.Id == id));
}