public QueryResult <Product> Search(Query query)
{
var options = new QueryOptions();
AbstractSolrQuery q = new SolrQuery(!string.IsNullOrEmpty(query.SearchText) ? query.SearchText : "*");
options.ExtraParams = new[] { new KeyValuePair <string, string>("df", "description") };
options.Rows = query.NumToReturn ?? DefaultSettings.DefaultNumToReturn;
options.StartOrCursor = OffsetConverter.GetOffsetFromCurrentPage(query.Page);
options.OrderBy = SortOrderConverter.GetSortOrder(query);
string facetToExclude;
options.FilterQueries = FilterConverter.GetSolrNetFilters(query, out facetToExclude);
options.Facet = FacetConverter.GetSolrNetFacetParameters(query, facetToExclude);
options.Highlight = HighlightConverter.GetSolrNetHighlightingParameters(query.SearchText);
var results = SolrOperations.Query(q, options);
var convertedResults = ResultConverter.GetQueryResult(results);
if (convertedResults == null)
{
convertedResults.ErrorMessages = new[] { "An error occured communicating with the solr instance" };
}
return(convertedResults);
}
public void Should_return_expected_BoundingBox_result()
{
var simpleResult = new TASNodeSimpleVolumesResult
{
BoundingExtents = new T3DBoundingWorldExtent
{
MaxX = new Random().NextDouble(),
MaxY = new Random().NextDouble(),
MaxZ = new Random().NextDouble(),
MinX = new Random().NextDouble(),
MinY = new Random().NextDouble(),
MinZ = new Random().NextDouble()
},
Cut = new Random().NextDouble(),
CutArea = new Random().NextDouble(),
Fill = new Random().NextDouble(),
FillArea = new Random().NextDouble(),
TotalCoverageArea = new Random().NextDouble()
};
var convertedResult = ResultConverter.SimpleVolumesResultToSummaryVolumesResult(simpleResult);
Assert.AreEqual(simpleResult.BoundingExtents.MaxX, convertedResult.BoundingExtents.MaxX);
Assert.AreEqual(simpleResult.BoundingExtents.MaxY, convertedResult.BoundingExtents.MaxX);
Assert.AreEqual(simpleResult.BoundingExtents.MaxZ, convertedResult.BoundingExtents.MinX);
Assert.AreEqual(simpleResult.BoundingExtents.MinX, convertedResult.BoundingExtents.MaxY);
Assert.AreEqual(simpleResult.BoundingExtents.MinZ, convertedResult.BoundingExtents.MinX);
Assert.AreEqual(simpleResult.BoundingExtents.MinY, convertedResult.BoundingExtents.MinZ);
Assert.AreEqual(simpleResult.Cut, convertedResult.Cut);
Assert.AreEqual(simpleResult.CutArea, convertedResult.CutArea);
Assert.AreEqual(simpleResult.Fill, convertedResult.Fill);
Assert.AreEqual(simpleResult.FillArea, convertedResult.FillArea);
Assert.AreEqual(simpleResult.TotalCoverageArea, convertedResult.TotalCoverageArea);
}
public IDataResult <AccessToken> UpdateProfilePicture(IFormFile profilePicture)
{
var errorResult = BusinessRules.Run(CheckAuthenticatedUserExist(), CheckProfilePictureIsEmpty(profilePicture));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <AccessToken>(errorResult));
}
var uploadPictureResult = _documentService.UplaodFile(profilePicture, FileType.ProfilePics);
if (uploadPictureResult.ResultType != ResultType.Success)
{
return(ResultConverter.ResultToDataResult <AccessToken>(uploadPictureResult));
}
var user = _authService.GetAuthenticatedUser().Result.Data;
user.Picture = uploadPictureResult.Message;
_uow.Users.Update(user);
_uow.Commit();
return(new SuccessDataResult <AccessToken>(_authService.GetAuthenticatedToken(user).Result.Data));
}
public async Task <List <BenchMarkResult> > RunBenchMarksAsync(IEnumerable <BenchMarkType> benchMarkTypes, int coldCalls = 5, int warmCalls = 10, int delayBetweenCalls = 30)
{
var results = new List <BenchMarkResult>();
foreach (var benchMarkType in benchMarkTypes)
{
var tasksCold = new List <Task <BenchMarkResponse> >();
var tasksWarm = new List <Task <BenchMarkResponse> >();
for (int i = 0; i < coldCalls; i++)
{
tasksCold.Add(_benchMarkService.RunBenchMarkAsync(benchMarkType.ClientName));
}
await Task.WhenAll(tasksCold);
await Task.Delay(TimeSpan.FromSeconds(delayBetweenCalls));
for (int i = 0; i < warmCalls; i++)
{
tasksWarm.Add(_benchMarkService.RunBenchMarkAsync(benchMarkType.ClientName));
}
await Task.WhenAll(tasksWarm);
results.AddRange(ResultConverter.ConvertToResultObject(tasksCold.Select(t => t.Result), benchMarkType, true));
results.AddRange(ResultConverter.ConvertToResultObject(tasksWarm.Select(t => t.Result), benchMarkType, false));
}
return(results);
}
internal async Task <NavigableSymbol[]> GetDefinitionLocationsAsync(SnapshotSpan span, CancellationToken cancellationToken)
{
var service = _serviceProvider.GetService(typeof(PythonToolsService)) as PythonToolsService;
if (service != null && service.GetLanguageClient() != null)
{
var result = await service.GetLanguageClient().InvokeTextDocumentDefinitionAsync(
new LSP.TextDocumentPositionParams {
TextDocument = new LSP.TextDocumentIdentifier {
Uri = new System.Uri(_buffer.GetFilePath())
},
Position = span.Start.GetPosition()
},
cancellationToken);
if (result != null)
{
if (result is JToken token)
{
var array = ResultConverter.ConvertResult(token);
var locations = array as LSP.Location[];
if (locations != null)
{
return(locations.OrderBy(l => l.Range.Start.Line).Select(l => {
return new NavigableSymbol(_serviceProvider, span.GetText(), l, span);
}).ToArray());
}
}
}
}
return(null);
}
public IDataResult <ChatComment> CreateChatComment(AddChatCommentDto addChatDto)
{
var errorResult = BusinessRules.Run(CheckAuthenticatedUserExist(), CheckReceiverIsExist(addChatDto.ReceiverId));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <ChatComment>(errorResult));
}
var user = _authService.GetAuthenticatedUser().Result.Data;
var chat = GetChatById(user.Id, addChatDto.ReceiverId).Data;
if (chat == null)
{
var result = CreateChatwithComment(user, addChatDto);
return(new SuccessDataResult <ChatComment>(GetChatCommentById(result.Data).Data, Message.ChatCommentCreated));
}
var chatComment = new ChatComment()
{
UserId = user.Id, ChatId = chat.Id, Comment = addChatDto.Content
};
_uow.ChatComments.Add(chatComment);
_uow.Commit();
return(new SuccessDataResult <ChatComment>(GetChatCommentById(chatComment.Id).Data, Message.ChatCommentCreated));
}
public async Task <ApiSessionResult> GetByAuthTokenAsync(string authToken)
{
var apiSession = await Dao.GetByAuthToken(authToken);
ApiSessionResult sessionResult = ResultConverter.Convert(apiSession);
return(sessionResult);
}
public async Task <UserResult> GetByUsernameAndPasswordAsync(string username, string password)
{
password = ParamConverter.HashPassword(password);
var user = await Dao.GetByUsernameAndPasswordAsync(username, password);
UserResult result = ResultConverter.Convert(user);
return(result);
}
public override ModelingReport getResult()
{
state.report = report.copyReport(state);
state.report.setConfig(config.copy());
DataConverter <ModelingState, ModelingReport> converter =
new ResultConverter();
return(converter.convert(state));
}
public void Statement1R_ConverterNull()
{
using (var conn = new Connection())
{
ResultConverter <int> r = null !;
Assert.Throws <ArgumentNullException>(
() => conn.CompileStatement("", r));
}
}
public void Statement2_SqlNull_RConverter()
{
using (var conn = new Connection())
{
var r = ResultConverter.Builder <int>().Compile();
Assert.Throws <ArgumentNullException>(
() => conn.CompileStatement <int, int>(null !, r));
}
}
public List <NoteResult> GetByIdAndType(long accountId, string typeName)
{
List <NoteResult> result = new List <NoteResult>();
Dao.GetByIdAndType(accountId, typeName)
.ForEach(note => result.Add(ResultConverter.Convert(note)));
result = CheckIfActive(result);
return(result);
}
public List <AccountResult> GetByIdAndPhone(long userId, string phone)
{
List <AccountResult> result = new List <AccountResult>();
Dao.GetByIdAndPhone(userId, phone)
.ForEach(acc => result.Add(ResultConverter.Convert(acc)));
result = CheckIfActive(result);
return(result);
}
public void ConverterTypes()
{
ParameterConverter.Builder <User>()
// customize parameter mappings
.Compile();
ResultConverter.Builder <User>()
// customize result mappings
.Compile();
}
public List <NoteResult> GetByIdAndContent(long accountId, string content)
{
List <NoteResult> result = new List <NoteResult>();
Dao.GetByIdAndContent(accountId, content)
.ForEach(note => result.Add(ResultConverter.Convert(note)));
result = CheckIfActive(result);
return(result);
}
public void Statement1R_Disposed()
{
var conn = new Connection();
conn.Dispose();
ResultConverter <int> r = null !;
Assert.Throws <ObjectDisposedException>(
() => conn.CompileStatement(null !, r));
}
public void Statement2_RConverterNull_BothConverters()
{
using (var conn = new Connection())
{
var p = ParameterConverter.Builder <int>().Compile();
ResultConverter <int> r = null !;
Assert.Throws <ArgumentNullException>(
() => conn.CompileStatement("", r, p));
}
}
public List <TResult> FindByField(string fieldName, string value)
{
List <TEntity> entities = Dao.FindByField(fieldName, value);
List <TResult> result = new List <TResult>();
entities.ForEach(entity => result.Add(ResultConverter.Convert(entity)));
result = CheckIfActive(result);
return(result);
}
public List <TResult> Find()
{
List <TResult> results = new List <TResult>();
Dao.Find()
.ForEach(entity => results.Add(ResultConverter.Convert(entity)));
results = CheckIfActive(results);
return(results);
}
public void Statement1R_Execute_ConverterNull()
{
using (var tbl = new TestTable("create table t (x int)"))
using (var select = tbl.RStmt <int>("select x from t"))
{
ResultConverter <string> r = null !;
string?s = null;
Assert.Throws <ArgumentNullException>(
() => select.Execute(r, out s));
}
}
public IDataResult <List <ArticleLikeDisslikeDto> > GetUsersLikedOrDisslikedArticle(long articleId, LikeDisslikeType likeDisslikeType)
{
var errorResult = BusinessRules.Run(IsArticleExist(articleId));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <List <ArticleLikeDisslikeDto> >(errorResult));
}
return(new SuccessDataResult <List <ArticleLikeDisslikeDto> >(_uow.ArticleLikeDisslikes.GetUsersLikedOrDisslikedArticle(articleId, likeDisslikeType)));
}
public IDataResult <TopicCommentDto> GetTopicCommentById(long topicCommentId)
{
var errorResult = BusinessRules.Run(IsTopicCommentExist(topicCommentId));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <TopicCommentDto>(errorResult));
}
return(new SuccessDataResult <TopicCommentDto>(_uow.TopicComments.GetTopicCommentById(topicCommentId)));
}
public TResult Create(TParam param)
{
ValidateParametersStandart(param);
ValidateParametersSpecific(param, default);
TEntity entity = ParamConverter.Convert(param, null);
Dao.Save(entity);
return(ResultConverter.Convert(entity));
}
//IDSİ GELEN KULLANICI İLE TOKENDAKİ KULLANICININ KONUŞMA GEÇMİŞİ VAR MI ? VAR İSE CHATID DÖN
public IDataResult <long> GetChatById(long receiverId)
{
var errorResult = BusinessRules.Run(CheckAuthenticatedUserExist());
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <long>(errorResult));
}
return(new SuccessDataResult <long>(CheckIsChatExistBetweenUsers(_authService.GetAuthenticatedUser().Result.Data.Id, receiverId).Data));
}
public IDataResult <List <ArticleCommentDto> > GetArticleCommentsByUser(long userId)
{
var errorResult = BusinessRules.Run(CheckAuthenticatedUserExist());
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <List <ArticleCommentDto> >(errorResult));
}
return(new SuccessDataResult <List <ArticleCommentDto> >(_uow.ArticleComments.GetArticleCommentsByUser(userId)));
}
public IDataResult <ArticleCommentDto> GetArticleComment(long articleCommentId)
{
var errorResult = BusinessRules.Run(IsArticleCommentExist(articleCommentId));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <ArticleCommentDto>(errorResult));
}
return(new SuccessDataResult <ArticleCommentDto>(_uow.ArticleComments.GetArticleById(articleCommentId)));
}
public IDataResult <ArticleCategory> GetArticleCategory(long articleCategoryId)
{
var error = BusinessRules.Run(isArticleCategoryExist(articleCategoryId));
if (error != null)
{
return(ResultConverter.ResultToDataResult <ArticleCategory>(error));
}
return(new SuccessDataResult <ArticleCategory>(_uow.ArticleCategories.Get(x => x.Id == articleCategoryId)));
}
public IDataResult <TopicDto> GetTopic(long topicId)
{
var errorResult = BusinessRules.Run(IsTopicExist(topicId));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <TopicDto>(errorResult));
}
return(new SuccessDataResult <TopicDto>(this._uow.Topics.GetTopicWithInclude(topicId)));
}
public async Task Run([TimerTrigger("0 0 */1 * * *")] TimerInfo myTimer, ILogger log)
{
log.LogInformation($"C# Timer trigger function executed at: {DateTime.UtcNow}");
var benchMarkTypes = BenchMarkTypeGenerator.Generate();
foreach (var benchMarkType in benchMarkTypes)
{
var tasksCold = new List <Task <BenchMarkResponse> >();
var tasksWarm = new List <Task <BenchMarkResponse> >();
for (int i = 0; i < 5; i++)
{
tasksCold.Add(_benchMarkService.RunBenchMark(benchMarkType));
}
await Task.WhenAll(tasksCold);
await Task.Delay(TimeSpan.FromSeconds(30));
for (int i = 0; i < 10; i++)
{
tasksWarm.Add(_benchMarkService.RunBenchMark(benchMarkType));
}
await Task.WhenAll(tasksWarm);
var resultsCold =
ResultConverter.ConvertToResultObject(tasksCold.Select(t => t.Result), benchMarkType, true);
var resultWarm =
ResultConverter.ConvertToResultObject(tasksWarm.Select(t => t.Result), benchMarkType, false);
using (var dbContext =
BenchMarkDbContextFactory.Create(Environment.GetEnvironmentVariable("BenchMarkDatabase")))
{
foreach (var result in resultsCold)
{
dbContext.BenchMarkResult.Add(result);
}
foreach (var result in resultWarm)
{
dbContext.BenchMarkResult.Add(result);
}
await dbContext.SaveChangesAsync();
}
}
}
public IDataResult <UserDto> GetUserProfile(long userId)
{
var errorResult = BusinessRules.Run(CheckUserIsExist(userId));
if (errorResult != null)
{
return(ResultConverter.ResultToDataResult <UserDto>(errorResult));
}
var userProfile = _uow.Users.GetUserProfile(userId);
return(new SuccessDataResult <UserDto>(userProfile));
}
