public virtual Filter GetFilter(XmlElement e)
{
string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
DuplicateFilter df = new DuplicateFilter(fieldName);
string keepMode = DOMUtils.GetAttribute(e, "keepMode", "first");
if (keepMode.Equals("first", StringComparison.OrdinalIgnoreCase))
{
df.KeepMode = KeepMode.KM_USE_FIRST_OCCURRENCE;
}
else if (keepMode.Equals("last", StringComparison.OrdinalIgnoreCase))
{
df.KeepMode = KeepMode.KM_USE_LAST_OCCURRENCE;
}
else
{
throw new ParserException("Illegal keepMode attribute in DuplicateFilter:" + keepMode);
}
string processingMode = DOMUtils.GetAttribute(e, "processingMode", "full");
if (processingMode.Equals("full", StringComparison.OrdinalIgnoreCase))
{
df.ProcessingMode = ProcessingMode.PM_FULL_VALIDATION;
}
else if (processingMode.Equals("fast", StringComparison.OrdinalIgnoreCase))
{
df.ProcessingMode = ProcessingMode.PM_FAST_INVALIDATION;
}
else
{
throw new ParserException("Illegal processingMode attribute in DuplicateFilter:" + processingMode);
}
return df;
}
public Task <SearchResult> Search(string searchQuery, int skip, int limit, string searchField = "")
{
if (_isRebuilding ||
string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty)))
{
return(new SearchResult(new List <SearchItem>(), 0).AsTask());
}
using var dir = FSDirectory.Open(FileSystemLayout.SearchIndexFolder);
using var reader = DirectoryReader.Open(dir);
var searcher = new IndexSearcher(reader);
int hitsLimit = skip + limit;
using var analyzer = new StandardAnalyzer(AppLuceneVersion);
QueryParser parser = !string.IsNullOrWhiteSpace(searchField)
? new QueryParser(AppLuceneVersion, searchField, analyzer)
: new MultiFieldQueryParser(AppLuceneVersion, new[] { TitleField }, analyzer);
parser.AllowLeadingWildcard = true;
Query query = ParseQuery(searchQuery, parser);
var filter = new DuplicateFilter(TitleAndYearField);
var sort = new Sort(new SortField(SortTitleField, SortFieldType.STRING));
TopFieldDocs topDocs = searcher.Search(query, filter, hitsLimit, sort, true, true);
IEnumerable <ScoreDoc> selectedHits = topDocs.ScoreDocs.Skip(skip).Take(limit);
var searchResult = new SearchResult(
selectedHits.Map(d => ProjectToSearchItem(searcher.Doc(d.Doc))).ToList(),
topDocs.TotalHits);
searchResult.PageMap = GetSearchPageMap(searcher, query, filter, sort, limit);
return(searchResult.AsTask());
}
public void CanRemoveTwoDuplicatesWithStaticMethod()
{
ContentItem item = CreateOneItem <FirstItem>(1, "one", null);
ItemList list = new ItemList();
list.Add(item);
list.Add(item);
DuplicateFilter.FilterDuplicates(list);
Assert.AreEqual(1, list.Count);
}
public Rule NotDuplicate(string errorMsg = "重复")
{
var filter = new DuplicateFilter()
{
ErrorMsg = errorMsg
};
Filters.Add(filter);
return(this);
}
public void CanRemoveTwoDuplicatesWithWithFilterInstance()
{
ContentItem item = CreateOneItem <FirstItem>(1, "one", null);
ItemList list = new ItemList();
list.Add(item);
list.Add(item);
DuplicateFilter filter = new DuplicateFilter();
((ItemFilter)filter).Filter(list);
Assert.AreEqual(1, list.Count);
}
private static Option <SearchPageMap> GetSearchPageMap(
IndexSearcher searcher,
Query query,
DuplicateFilter filter,
Sort sort,
int limit)
{
ScoreDoc[] allDocs = searcher.Search(query, filter, int.MaxValue, sort, true, true).ScoreDocs;
var letters = new List <char>
{
'#', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
var map = letters.ToDictionary(letter => letter, _ => 0);
var current = 0;
var page = 0;
while (current < allDocs.Length)
{
// walk up by page size (limit)
page++;
current += limit;
if (current > allDocs.Length)
{
current = allDocs.Length;
}
char jumpLetter = searcher.Doc(allDocs[current - 1].Doc).Get(JumpLetterField).Head();
foreach (char letter in letters.Where(l => letters.IndexOf(l) <= letters.IndexOf(jumpLetter)))
{
if (map[letter] == 0)
{
map[letter] = page;
}
}
}
int max = map.Values.Max();
foreach (char letter in letters.Where(letter => map[letter] == 0))
{
map[letter] = max;
}
return(new SearchPageMap(map));
}
public void CanClearDuplicateFilter()
{
ContentItem item = CreateOneItem <FirstItem>(1, "one", null);
ItemList list = new ItemList();
list.Add(item);
list.Add(item);
list.Add(item);
DuplicateFilter filter = new DuplicateFilter();
filter.Filter(list);
Assert.AreEqual(1, list.Count);
filter.Clear();
filter.Filter(list);
Assert.AreEqual(1, list.Count);
}
public Task <SearchResult> Search(string searchQuery, int skip, int limit, string searchField = "")
{
if (string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty)))
{
return(new SearchResult(new List <SearchItem>(), 0).AsTask());
}
using DirectoryReader reader = _writer.GetReader(true);
var searcher = new IndexSearcher(reader);
int hitsLimit = limit == 0 ? searcher.IndexReader.MaxDoc : skip + limit;
using var analyzer = new StandardAnalyzer(AppLuceneVersion);
var customAnalyzers = new Dictionary <string, Analyzer>
{
{ ContentRatingField, new KeywordAnalyzer() },
{ StateField, new KeywordAnalyzer() }
};
using var analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer, customAnalyzers);
QueryParser parser = !string.IsNullOrWhiteSpace(searchField)
? new CustomQueryParser(AppLuceneVersion, searchField, analyzerWrapper)
: new CustomMultiFieldQueryParser(AppLuceneVersion, new[] { TitleField }, analyzerWrapper);
parser.AllowLeadingWildcard = true;
Query query = ParseQuery(searchQuery, parser);
var filter = new DuplicateFilter(TitleAndYearField);
var sort = new Sort(new SortField(SortTitleField, SortFieldType.STRING));
TopFieldDocs topDocs = searcher.Search(query, filter, hitsLimit, sort, true, true);
IEnumerable <ScoreDoc> selectedHits = topDocs.ScoreDocs.Skip(skip);
if (limit > 0)
{
selectedHits = selectedHits.Take(limit);
}
var searchResult = new SearchResult(
selectedHits.Map(d => ProjectToSearchItem(searcher.Doc(d.Doc))).ToList(),
topDocs.TotalHits);
if (limit > 0)
{
searchResult.PageMap = GetSearchPageMap(searcher, query, filter, sort, limit);
}
return(searchResult.AsTask());
}
public void CanRemoveSeveralDuplicatesWithWithFilterInstance()
{
ContentItem item = CreateOneItem <FirstItem>(1, "one", null);
ContentItem item2 = CreateOneItem <FirstItem>(2, "two", null);
ContentItem item3 = CreateOneItem <FirstItem>(3, "three", null);
ItemList list = new ItemList();
list.Add(item);
list.Add(item2);
list.Add(item2);
list.Add(item3);
list.Add(item3);
list.Add(item3);
DuplicateFilter filter = new DuplicateFilter();
((ItemFilter)filter).Filter(list);
Assert.AreEqual(3, list.Count);
}
public virtual Filter GetFilter(XmlElement e)
{
string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
DuplicateFilter df = new DuplicateFilter(fieldName);
string keepMode = DOMUtils.GetAttribute(e, "keepMode", "first");
if (keepMode.Equals("first", StringComparison.OrdinalIgnoreCase))
{
df.KeepMode = KeepMode.KM_USE_FIRST_OCCURRENCE;
}
else if (keepMode.Equals("last", StringComparison.OrdinalIgnoreCase))
{
df.KeepMode = KeepMode.KM_USE_LAST_OCCURRENCE;
}
else
{
throw new ParserException("Illegal keepMode attribute in DuplicateFilter:" + keepMode);
}
string processingMode = DOMUtils.GetAttribute(e, "processingMode", "full");
if (processingMode.Equals("full", StringComparison.OrdinalIgnoreCase))
{
df.ProcessingMode = ProcessingMode.PM_FULL_VALIDATION;
}
else if (processingMode.Equals("fast", StringComparison.OrdinalIgnoreCase))
{
df.ProcessingMode = ProcessingMode.PM_FAST_INVALIDATION;
}
else
{
throw new ParserException("Illegal processingMode attribute in DuplicateFilter:" + processingMode);
}
return(df);
}
public IEnumerable <Movie> FindDuplicates(List <Movie> movieList, DuplicateFilter filter)
{
var duplicateList = new List <Movie>();
int duplicateId = 1;
int currentMovieIndex = 0;
foreach (var movie in movieList)
{
IEnumerable <Movie> foundDuplicates = movieList.AsEnumerable();
if (!duplicateList.Any(m => m.Guid == movie.Guid))
{
if (filter.Name)
{
foundDuplicates = foundDuplicates.Where(m => m.Name == movie.Name && m.Guid != movie.Guid);
}
if (filter.Name && filter.Part)
{
foundDuplicates = foundDuplicates.Where(m => m.Name == movie.Name && m.Guid != movie.Guid && movie.Part == m.Part);
}
if (filter.Name && filter.Episode)
{
foundDuplicates = foundDuplicates.Where(m => m.Name == movie.Name && m.Guid != movie.Guid && movie.Episode == m.Episode);
}
if (filter.Language)
{
foundDuplicates = foundDuplicates.Where(m => m.LanguageDub == movie.LanguageDub && m.Guid != movie.Guid);
}
if (filter.Year)
{
foundDuplicates = foundDuplicates.Where(m => m.Year == movie.Year && m.Guid != movie.Guid);
}
if (filter.Filesize)
{
foundDuplicates = foundDuplicates.Where(m => m.Size == movie.Size && m.Guid != movie.Guid);
}
if (filter.Quality)
{
foundDuplicates = foundDuplicates.Where(m => m.Quality == movie.Quality && m.Guid != movie.Guid);
}
if (filter.DLDistance)
{
var distanceList = new List <Movie>();
foreach (var film in foundDuplicates)
{
if (film.Guid != movie.Guid)
{
int distance = film.Name.DamerauLevenshteinDistanceTo(movie.Name);
if (distance <= filter.NumericUpDownDistance)
{
distanceList.Add(film);
}
}
}
foundDuplicates = distanceList.AsEnumerable <Movie>();
}
if (foundDuplicates.Any())
{
movie.DuplicateId = duplicateId;
duplicateList.Add(movie);
foreach (var duplicate in foundDuplicates)
{
duplicate.DuplicateId = duplicateId;
duplicateList.Add(duplicate);
}
duplicateId++;
}
}
currentMovieIndex++;
OnProgressUpdate?.Invoke(currentMovieIndex);
}
return(duplicateList);
}
private static void CreateMemo(ARInvoiceEntry graph, ARRegister doc, RUTROT rutrot, string docType, bool OnRelease = false)
{
DuplicateFilter filter = PXCache <DuplicateFilter> .CreateCopy(graph.duplicatefilter.Current);
foreach (PXResult <ARInvoice, CurrencyInfo, Terms, Customer> res in ARInvoice_CurrencyInfo_Terms_Customer.Select(graph, (object)doc.DocType, doc.RefNbr, doc.CustomerID))
{
CurrencyInfo info = PXCache <CurrencyInfo> .CreateCopy((CurrencyInfo)res);
info.CuryInfoID = null;
info.IsReadOnly = false;
info = PXCache <CurrencyInfo> .CreateCopy(graph.currencyinfo.Insert(info));
ARInvoice invoice = (ARInvoice)graph.Document.Cache.CreateInstance();
if (docType == ARDocType.CreditMemo)
{
invoice.DueDate = null;
invoice.DiscDate = null;
invoice.CustomerID = doc.CustomerID;
invoice.ARAccountID = doc.ARAccountID;
invoice.ARSubID = doc.ARSubID;
}
if (docType == ARInvoiceType.DebitMemo)
{
invoice.DueDate = ((ARInvoice)res).DueDate;
invoice.DiscDate = ((ARInvoice)res).DiscDate;
BranchRUTROT branchRUTROT = GetBranchRUTROT(graph);
invoice.CustomerID = branchRUTROT.TaxAgencyAccountID;
invoice.ARAccountID = null;
invoice.ARSubID = null;
}
ARInvoiceRUTROT invoiceRUTROT = RUTROTHelper.GetExtensionNullable <ARInvoice, ARInvoiceRUTROT>(invoice);
invoiceRUTROT.IsRUTROTDeductible = false;
invoice.CuryInfoID = info.CuryInfoID;
invoice.DocType = docType;
invoice.OrigModule = GL.BatchModule.AR;
invoice.RefNbr = null;
invoice.OrigModule = GL.BatchModule.AR;
invoice.DocDesc = PXLocalizer.LocalizeFormat(RUTROTMessages.MemoDescription, doc.RefNbr);
invoice.OpenDoc = true;
invoice.Released = false;
invoice.Hold = false;
invoice.Printed = false;
invoice.Emailed = false;
invoice.BatchNbr = null;
invoice.ScheduleID = null;
invoice.Scheduled = false;
invoice.NoteID = null;
invoice.RefNoteID = null;
invoice.TermsID = null;
invoice.InstallmentCntr = null;
invoice.InstallmentNbr = null;
invoice.CuryOrigDiscAmt = 0m;
invoice.FinPeriodID = doc.FinPeriodID;
invoice.OrigDocDate = invoice.DocDate;
invoice.CuryLineTotal = 0m;
invoice.IsTaxPosted = false;
invoice.IsTaxValid = false;
invoice.CuryVatTaxableTotal = 0m;
invoice.CuryVatExemptTotal = 0m;
invoice.StatementDate = null;
invoice.PendingPPD = false;
invoice.CustomerLocationID = null;
if (!string.IsNullOrEmpty(invoice.PaymentMethodID))
{
CA.PaymentMethod pm = null;
if (invoice.CashAccountID.HasValue)
{
CA.PaymentMethodAccount pmAccount = null;
PXResult <CA.PaymentMethod, CA.PaymentMethodAccount> pmResult = (PXResult <CA.PaymentMethod, CA.PaymentMethodAccount>)
PXSelectJoin <CA.PaymentMethod,
LeftJoin <
CA.PaymentMethodAccount, On <CA.PaymentMethod.paymentMethodID, Equal <CA.PaymentMethodAccount.paymentMethodID> > >,
Where <
CA.PaymentMethod.paymentMethodID, Equal <Required <CA.PaymentMethod.paymentMethodID> >,
And <CA.PaymentMethodAccount.cashAccountID, Equal <Required <CA.PaymentMethodAccount.cashAccountID> > > > > .
Select(graph, invoice.PaymentMethodID, invoice.CashAccountID);
pm = pmResult;
pmAccount = pmResult;
if (pm == null || pm.UseForAR == false || pm.IsActive == false)
{
invoice.PaymentMethodID = null;
invoice.CashAccountID = null;
}
else if (pmAccount == null || pmAccount.CashAccountID == null || pmAccount.UseForAR != true)
{
invoice.CashAccountID = null;
}
}
else
{
pm = PXSelect <CA.PaymentMethod,
Where <CA.PaymentMethod.paymentMethodID, Equal <Required <CA.PaymentMethod.paymentMethodID> > > >
.Select(graph, invoice.PaymentMethodID);
if (pm == null || pm.UseForAR == false || pm.IsActive == false)
{
invoice.PaymentMethodID = null;
invoice.CashAccountID = null;
invoice.PMInstanceID = null;
}
}
if (invoice.PMInstanceID.HasValue)
{
CustomerPaymentMethod cpm = PXSelect <CustomerPaymentMethod,
Where <CustomerPaymentMethod.pMInstanceID, Equal <Required <CustomerPaymentMethod.pMInstanceID> > > > .
Select(graph, invoice.PMInstanceID);
if (string.IsNullOrEmpty(invoice.PaymentMethodID) || cpm == null || cpm.IsActive == false || cpm.PaymentMethodID != invoice.PaymentMethodID)
{
invoice.PMInstanceID = null;
}
}
}
else
{
invoice.CashAccountID = null;
invoice.PMInstanceID = null;
}
SalesPerson sp = (SalesPerson)PXSelectorAttribute.Select <ARInvoice.salesPersonID>(graph.Document.Cache, invoice);
if (sp == null || sp.IsActive == false)
{
invoice.SalesPersonID = null;
}
invoice = graph.Document.Insert(invoice);
}
TX.TaxAttribute.SetTaxCalc <ARTran.taxCategoryID>(graph.Transactions.Cache, null, TX.TaxCalc.ManualCalc);
graph.FieldDefaulting.AddHandler <ARTran.salesPersonID>((sender, e) =>
{
e.NewValue = null;
e.Cancel = true;
});
decimal roundedTotalDistributedLinesAmt = 0m;
foreach (ARTran srcTran in PXSelect <ARTran, Where <ARTran.tranType, Equal <Required <ARTran.tranType> >,
And <ARTran.refNbr, Equal <Required <ARTran.refNbr> > > > > .Select(graph, doc.DocType, doc.RefNbr))
{
ARTran tran = PXCache <ARTran> .CreateCopy(srcTran);
ARTranRUTROT tranRR = RUTROTHelper.GetExtensionNullable <ARTran, ARTranRUTROT>(tran);
if (tranRR.IsRUTROTDeductible != true)
{
continue;
}
tran.TranType = graph.Document.Current.DocType;
tran.RefNbr = graph.Document.Current.RefNbr;
string origDrCr = tran.DrCr;
tran.DrCr = null;
tran.Released = null;
tran.CuryInfoID = null;
tran.SOOrderNbr = null;
tran.SOShipmentNbr = null;
tran.OrigInvoiceDate = tran.TranDate;
tran.NoteID = null;
tran.ManualPrice = true;
tran.CuryTranAmt = Math.Floor(tranRR.CuryRUTROTAvailableAmt ?? 0m);
roundedTotalDistributedLinesAmt += tran.CuryTranAmt ?? 0m;
tranRR.IsRUTROTDeductible = false;
if (!string.IsNullOrEmpty(tran.DeferredCode))
{
DRSchedule schedule = PXSelect <DRSchedule,
Where <DRSchedule.module, Equal <BQLConstants.moduleAR>,
And <DRSchedule.docType, Equal <Required <DRSchedule.docType> >,
And <DRSchedule.refNbr, Equal <Required <DRSchedule.refNbr> >,
And <DRSchedule.lineNbr, Equal <Required <DRSchedule.lineNbr> > > > > > > .
Select(graph, doc.DocType, doc.RefNbr, tran.LineNbr);
if (schedule != null)
{
tran.DefScheduleID = schedule.ScheduleID;
}
}
SalesPerson sp = (SalesPerson)PXSelectorAttribute.Select <ARTran.salesPersonID>(graph.Transactions.Cache, tran);
if (sp == null || sp.IsActive == false)
{
tran.SalesPersonID = null;
}
ARTran insertedTran = graph.Transactions.Insert(tran);
PXNoteAttribute.CopyNoteAndFiles(graph.Transactions.Cache, srcTran, graph.Transactions.Cache, insertedTran);
insertedTran.ManualDisc = true;
insertedTran.TaxCategoryID = null;
graph.Transactions.Update(insertedTran);
}
decimal distributedFee = (rutrot.CuryDistributedAmt ?? 0m) - roundedTotalDistributedLinesAmt;
if (distributedFee != 0m)
{
foreach (ARTran artran in graph.Transactions.Cache.Inserted)
{
if (Math.Round(distributedFee) == 0m)
{
break;
}
if (artran.CuryTranAmt != 0m)
{
artran.CuryTranAmt += Math.Sign(distributedFee);
distributedFee -= Math.Sign(distributedFee);
}
graph.Transactions.Update(artran);
}
}
graph.Document.Current.CuryOrigDocAmt = graph.Document.Current.CuryDocBal;
graph.Document.Cache.Update(graph.Document.Current);
graph.RowInserting.AddHandler <ARSalesPerTran>((sender, e) => { e.Cancel = true; });
foreach (ARSalesPerTran salespertran in PXSelect <ARSalesPerTran, Where <ARSalesPerTran.docType, Equal <Required <ARSalesPerTran.docType> >,
And <ARSalesPerTran.refNbr, Equal <Required <ARSalesPerTran.refNbr> > > > > .Select(graph, doc.DocType, doc.RefNbr))
{
ARSalesPerTran newtran = PXCache <ARSalesPerTran> .CreateCopy(salespertran);
newtran.DocType = graph.Document.Current.DocType;
newtran.RefNbr = graph.Document.Current.RefNbr;
newtran.Released = false;
newtran.CuryInfoID = null;
newtran.CuryCommnblAmt *= -1m;
newtran.CuryCommnAmt *= -1m;
SalesPerson sp = (SalesPerson)PXSelectorAttribute.Select <ARSalesPerTran.salespersonID>(graph.salesPerTrans.Cache, newtran);
if (!(sp == null || sp.IsActive == false))
{
graph.salesPerTrans.Update(newtran);
}
}
var discountDetailsSet = PXSelect <ARInvoiceDiscountDetail,
Where <ARInvoiceDiscountDetail.docType, Equal <Required <ARInvoice.docType> >,
And <ARInvoiceDiscountDetail.refNbr, Equal <Required <ARInvoice.refNbr> > > >,
OrderBy <Asc <ARInvoiceDiscountDetail.docType,
Asc <ARInvoiceDiscountDetail.refNbr> > > >
.Select(graph, doc.DocType, doc.RefNbr);
foreach (ARInvoiceDiscountDetail discountDetail in discountDetailsSet)
{
ARInvoiceDiscountDetail newDiscountDetail = PXCache <ARInvoiceDiscountDetail> .CreateCopy(discountDetail);
newDiscountDetail.DocType = graph.Document.Current.DocType;
newDiscountDetail.RefNbr = graph.Document.Current.RefNbr;
newDiscountDetail.IsManual = true;
DiscountEngineProvider.GetEngineFor <ARTran, ARInvoiceDiscountDetail>().UpdateDiscountDetail(graph.ARDiscountDetails.Cache, graph.ARDiscountDetails, newDiscountDetail);
}
graph.Save.Press();
if (docType == ARDocType.CreditMemo && !OnRelease)
{
CreateAdjustment(graph, doc, graph.Document.Current);
}
}
public static DocCacheEntity GetCache(string path, string fieldName)
{
if (!System.IO.Directory.Exists(path) || !IndexReader.IndexExists(path))
{
return null;
}
var key = string.Join("@", path, fieldName);
lock (Cache)
{
if (!Cache.ContainsKey(key) || Cache[key].LastChange != IndexReader.LastModified(path))
{
var duplicateFilter = new DuplicateFilter(fieldName);
var reader = IndexReader.Open(path);
var docSet = duplicateFilter.GetDocIdSetCache(reader);
Cache[key] = new DocCacheEntity
{
Cache = docSet,
DocPath = path,
FieldName = fieldName,
LastChange = IndexReader.LastModified(path)
};
}
}
return Cache[key];
}