/// <summary> /// Construct ProblemResult instance from given visualTableKey, visualTitleValue, visualValues, visualValues and comments. /// </summary> /// <param name="visualTitleKey">VisualTitleKey.</param> /// <param name="visualTitleValue">VisualTitleValue.</param> /// <param name="tableValues">TableResult.</param> /// <param name="visualValues">VisualResult.</param> /// <param name="comments">Commenyts.</param> public ProblemResult( string visualTitleKey, string visualTitleValue, TableResult tableValues, VisualResult visualValues, string comments = "") { TableResult = tableValues; VisualResult = visualValues; VisualTitleKey = visualTitleKey; VisualTitleValue = visualTitleValue; Comments = comments; }
public JsonResult Importance() { var response = new TableResult(); try { response.Result = System.Enum.GetNames(typeof(ImportanceLevel)).AsEnumerable().Select(p => new { title = p }).ToArray(); response.TotalCount = System.Enum.GetNames(typeof(ImportanceLevel)).Count(); } catch (System.Exception ex) { Logger.Error("OnImportance", ex); } return JsonNet(response); }
public async Task <ImageEntity> GetEntityAsync(string partitionKey, string rowKey) { try { if (_table is null) { await CreateTableAsync(); } TableOperation insertOrMergeOperation = TableOperation.Retrieve <ImageEntity>(partitionKey, rowKey); // Execute the operation. TableResult result = await _table.ExecuteAsync(insertOrMergeOperation); var image = result.Result as ImageEntity; return(image); } catch (Exception e) { _log.LogInformation(e.Message); return(null); } }
private static void UpdateGuestEntity() { Console.Write("Enter First Name: "); string fname = Console.ReadLine(); Console.Write("Enter Last Name: "); string lname = Console.ReadLine(); TableOperation retrieveOperation = TableOperation.Retrieve <GuestEntity>(fname, lname); TableResult retrieveResult = table.Execute(retrieveOperation); if (retrieveResult.Result != null) { var guest = retrieveResult.Result as GuestEntity; Console.Write("Enter Contact Number"); guest.Contact = Console.ReadLine(); TableOperation updateOperation = TableOperation.Replace(guest); table.Execute(updateOperation); Console.WriteLine("Entity Updated!"); } else { Console.WriteLine("Could not be retrieved! :("); } }
private async Task <multiple_storage> get_files_name(string key) { /* string removeString = "HLIN"; * string sourceString = userid.Text.ToString(); * string blob = sourceString.Remove(sourceString.IndexOf(removeString), removeString.Length); */ string blob = userid.Text.ToString(); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(key); // Create the table client. CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Create the CloudTable object that represents the "people" table. CloudTable table = tableClient.GetTableReference("multiple"); // Create a retrieve operation that takes a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <multiple_storage>("Public", blob); // Execute the retrieve operation. TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation); return((multiple_storage)retrievedResult.Result); }
void updateHotTopics(string name) { Tweets tweets = getTweets(name); if (tweets != null) { string pattern = "(#|@)[a-zA-Z0-9_]{1,15}"; Regex regx = new Regex(pattern); CloudTable table = getCloudTable(); foreach (var tweet in tweets.Items) { string date = DateTime.Now.ToString("yyyy-MM-dd"); foreach (var match in regx.Matches(tweet.text)) { string matchString = match.ToString().Substring(1); TableOperation retrieveOperation = TableOperation.Retrieve <TopicEntity> (date, matchString); TableResult retrievedResult = table.Execute(retrieveOperation); TopicEntity updateEntity = (TopicEntity)retrievedResult.Result; if (updateEntity != null) { updateEntity.Mentions += 1; TableOperation updateOperation = TableOperation.Replace(updateEntity); table.Execute(updateOperation); } else { TopicEntity entity = new TopicEntity(date, matchString); TableOperation insertOperation = TableOperation.Insert(entity); table.Execute(insertOperation); } } } } }
//get_file_name private async Task <storage> get_file_name(string key, bool mul, string id) { /* string removeString = "HLIN"; * string sourceString = userid.Text.ToString(); * string blob = sourceString.Remove(sourceString.IndexOf(removeString), removeString.Length); */ int index = 0; string counter = ""; if (mul) { counter = (index < 0) ? id.ToString() : id.Remove(index, 5); } else { counter = (index < 0) ? userid.Text.ToString() : userid.Text.ToString().Remove(index, 5); } CloudStorageAccount storageAccount = CloudStorageAccount.Parse(key); // Create the table client. CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Create the CloudTable object that represents the "people" table. CloudTable table = tableClient.GetTableReference("user"); // Create a retrieve operation that takes a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <storage>("Public", counter); // Execute the retrieve operation. TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation); return((storage)retrievedResult.Result); }
private (CloudTable table, VideoEntity update) FetchForUpdate(string partitionKey, string rowKey, string StorageConnectionString) { string TableName = "Videos"; // Retrieve the storage account from the connection string. CloudStorageAccount storageAccount = CloudStorageAccount.Parse(StorageConnectionString); // Create the table client. CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); // Retrieve a reference to the table. // Persist this http connection in the class var table = tableClient.GetTableReference(TableName); // Create the table if it doesn't exist. table.CreateIfNotExists(); TableOperation retrieveOperation = TableOperation.Retrieve <VideoEntity>(partitionKey, rowKey); TableResult retrievedResult = table.Execute(retrieveOperation); VideoEntity updateEntity = (VideoEntity)retrievedResult.Result; var retVal = (table, updateEntity); return(retVal); }
//Write User to Table Storage public AttendeeRecord CreateAttendeeRecord(UserRegistrationRequest userRegistration) { var attendee = new AttendeeRecord() { PartitionKey = "attendees", Name = userRegistration.Name, Surname = userRegistration.Surname, Email = userRegistration.EmailAddress, Birthday = userRegistration.Birthday, City = userRegistration.City, ZipCode = userRegistration.ZipCode, UserId = userRegistration.UserId, Username = GenerateUsername(userRegistration.Name, userRegistration.Surname), Password = GenerateRandomPassword(), }; //Encrypt Settings attendee = encryptionService.EncryptÁttendeeRecord(attendee); //Write to Table Storage TableResult result = attendeeTable.Execute(TableOperation.InsertOrReplace(attendee)); return(result.Result as AttendeeRecord); }
public string GetMessage() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=[name];AccountKey=[key]"); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference("mytable"); // Create the table if it doesn't exist. table.CreateIfNotExists(); // read the latest messages from the table TableOperation retrieveOperation = TableOperation.Retrieve <MyMessages>("Partition0", "Row0"); // Execute the retrieve operation. TableResult retrievedResult = table.Execute(retrieveOperation); if (retrievedResult.Result != null) { return(((MyMessages)retrievedResult.Result).Messages); } else { return("Failed to retrieve the messages"); } }
public async Task <bool> AnswerQuestion(Guid questionId, string answer) { var table = _tableClient.GetTableReference(TableNames.Player); QuestionEntity oldQuestionEntity = await GetQuestionEntity(questionId); if (oldQuestionEntity == null) { _logger.LogError($"Could not answer question with '${answer}', no question with ID {questionId} found."); return(false); } oldQuestionEntity.ChosenAnswer = answer; TableOperation updateOperation = TableOperation.Merge(oldQuestionEntity); TableResult result = await table.ExecuteAsync(updateOperation); if (result.HttpStatusCode != 204) { return(false); } return(true); }
/// <summary> /// Insere uma nova entidade na tabela que está no Azure Table Storage. /// </summary> public async Task <T> InsertOrMergeEntityAsync(CloudTable table, T entity) { try { if (entity != null) { TableOperation tableOperation = TableOperation.InsertOrMerge(entity); TableResult result = await table.ExecuteAsync(tableOperation); T insertedEntity = result.Result as T; return(insertedEntity); } else { throw new ArgumentNullException("entity"); } } catch (Exception) { throw; } }
public async Task Retrieve(string ERP) { CloudTableClient tableClient = storagereAccount.CreateCloudTableClient(); CloudTable userTable = tableClient.GetTableReference("unitTestTable3"); TableOperation retrieveOperation = TableOperation.Retrieve <UnitEntity>("test", ERP); TableResult retrievedResult = await userTable.ExecuteAsync(retrieveOperation); if (retrievedResult.Result != null) { UnitERP = ((UnitEntity)retrievedResult.Result).RowKey; UnitBrand = ((UnitEntity)retrievedResult.Result).UnitBrand; BarcodeScan = ((UnitEntity)retrievedResult.Result).BardcodeScan; InspectionDate = ((UnitEntity)retrievedResult.Result).InspectionDate; InspectorName = ((UnitEntity)retrievedResult.Result).InspectorName; } else { System.Diagnostics.Debug.WriteLine("The password could not be retrieved."); } }
public void Resume() { CrawlerState = "Crawling"; DateTime begin = DateTime.Now; TimeSpan time = DateTime.Now.Subtract(begin); dashboard.CrawlingFor = time.ToString(); dashboard.BeganCrawlingAt = begin.ToString(); TableOperation retrieveOperation = TableOperation.Retrieve <Dashboard>("1", "1"); TableResult retrievedResult = Storage.DashboardTable.Execute(retrieveOperation); Dashboard dashboardRetrieved = (Dashboard)retrievedResult.Result; counterTable = dashboardRetrieved.SizeOfTable; numberOfUrlsCrawled = dashboardRetrieved.NumberOfUrlsCrawled; errorNumber = dashboardRetrieved.errorNumber; string[] disallowedUrlsArray = JsonConvert.DeserializeObject <string[]>(dashboardRetrieved.disallowedUrls); foreach (string url in disallowedUrlsArray) { if (!disallowedUrls.Contains(url)) { disallowedUrls.Add(url); } } }
/// <summary>Inserts a list of items into the table</summary> /// <param name="items">Items to insert in bulk</param> /// <returns>The HTTP Status Code response code.</returns> public int Insert(List <T> items) { if (items == null || items.Count < 1) { return((int)HttpStatusCode.BadRequest); } TableResult results = null; foreach (T item in items) { try { TableOperation op = TableOperation.InsertOrMerge(item); results = this.AzureTable.ExecuteAsync(op).GetAwaiter().GetResult(); } catch (System.Exception exp) { ; // log it somehow and keep going } } return(results.HttpStatusCode); }
public async Task DeleteLink(string id) { //get cloudtable var table = await GetCloudTable(_appSecretSettings.TableStorageConnectionString, _appSecretSettings.TableStorageContainerName); // Create a retrieve operation that expects a the right entity. TableOperation retrieveOperation = TableOperation.Retrieve <TableEntityAdapter <Link> >(_appSecretSettings.TableStoragePartitionKey, GetRowKey(id)); // Execute the operation. TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation); // Assign the result to an Entity. var deleteEntity = (TableEntityAdapter <Link>)retrievedResult.Result; // Create the Delete TableOperation. if (deleteEntity != null) { // Create the Delete TableOperation. TableOperation deleteOperation = TableOperation.Delete(deleteEntity); // Execute the operation. await table.ExecuteAsync(deleteOperation); } }
async public void GetNewPerson() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable varsTable = tableClient.GetTableReference("varsTable"); //varsTable.DeleteIfExists(); TableOperation retrieveOperation = TableOperation.Retrieve <varsGenderEntity>("gender", "gender"); TableResult retrievedResult = await varsTable.ExecuteAsync(retrieveOperation); varsGenderEntity updateEntity = (varsGenderEntity)retrievedResult.Result; TimeZoneInfo myTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Israel Standard Time"); DateTime currentDateTime = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, myTimeZone); updateEntity.last = currentDateTime; TableOperation updateOperation = TableOperation.Replace(updateEntity); // Execute the operation. await varsTable.ExecuteAsync(updateOperation); }
public GameData addClue(string game_id, string username, int to, int[] indexes, bool isnum) { // make bool return type TableOperation retrieveOperation = TableOperation.Retrieve <GameEntity>(game_id, ""); TableResult retrievedResult = table.Execute(retrieveOperation); GameEntity updateEntity = (GameEntity)retrievedResult.Result; if (updateEntity != null) { GameData gameData = updateEntity.gameData(); int index = gameData.getUsers().IndexOf(username); // not needed now for (int i = 0; i < indexes.Length; i++) { if (isnum) { gameData.getPlayers()[to].getHand()[indexes[i]].numinfo = true; } else { gameData.getPlayers()[to].getHand()[indexes[i]].suitinfo = true; } } gameData.last_move = username + " gave " + gameData.getUsers()[to] + " a clue"; gameData.clues--; gameData.turn++; if (gameData.getDeck().Count() == 0) { gameData.last_turn_count++; } updateEntity = new GameEntity(gameData); TableOperation insertOrReplaceOperation = TableOperation.InsertOrReplace(updateEntity); table.Execute(insertOrReplaceOperation); return(gameData); } return(null); }
public async Task <IActionResult> RemoveAssignmentLearnContent( [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "assignments/{assignmentId}/learn-content/{contentUid}")] HttpRequest req, [Table(AssignmentLearnContentTableName)] CloudTable assignmentLearnContentTable, [Table(AssignmentLearnContentTableName, "{assignmentId}", "{contentUid}")] AssignmentLearnContentEntity assignmentLearnContentEntityToDelete, string assignmentId, string contentUid) { if (assignmentLearnContentEntityToDelete == null) { return(new NoContentResult()); } _logger.LogInformation($"Removing assignment learn content with uid [{contentUid}] from assignment {assignmentId}"); TableOperation deleteOperation = TableOperation.Delete(assignmentLearnContentEntityToDelete); TableResult deleteResult = await assignmentLearnContentTable.ExecuteAsync(deleteOperation); if (deleteResult.HttpStatusCode < 200 || deleteResult.HttpStatusCode >= 300) { return(new InternalServerErrorResult()); } return(new OkResult()); }
public static async Task <T> InsertOrMergeEntityAsync <T>(CloudTable table, T entity) where T : TableEntity, new() { if (entity == null) { throw new ArgumentNullException("entity"); } try { // Create the InsertOrReplace table operation TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(entity); // Execute the operation. TableResult result = await table.ExecuteAsync(insertOrMergeOperation); return(result.Result as T); } catch (StorageException e) { Console.WriteLine(e.Message); Console.ReadLine(); throw; } }
public async Task DeleteEntityAsync(CustomerEntity deleteEntity) { try { if (deleteEntity == null) { throw new ArgumentNullException("deleteEntity"); } TableOperation deleteOperation = TableOperation.Delete(deleteEntity); TableResult result = await Table.ExecuteAsync(deleteOperation); if (result.RequestCharge.HasValue) { Console.WriteLine("Request Charge of Delete Operation: " + result.RequestCharge); } } catch (StorageException e) { Console.WriteLine(e.Message); Console.ReadLine(); throw; } }
public async Task <IdentityResult> UpdateAsync(TRole role, CancellationToken cancellationToken) { TableResult UpdateResult = await _db.UserData.ExecuteAsync(TableOperation.InsertOrReplace(role)); return(UpdateResult.HttpStatusCode == HttpStatusCode.NoContent.GetHashCode() ? IdentityResult.Success : IdentityResult.Failed(new IdentityError() { Code = UpdateResult.HttpStatusCode.ToString(), Description = "Update Role Fail." })); //// Retrieve //TRole Role = await FindByIdAsync(role.RowKey, cancellationToken); //if (Role == null) return IdentityResult.Failed(new IdentityError() //{ // Code = HttpStatusCode.NotFound.ToString(), // Description = "Role Not Found." //}); //// Update (Insert New) //IdentityResult Result = await CreateAsync(role, cancellationToken); //if (Result != IdentityResult.Success) return IdentityResult.Failed(Result.Errors.FirstOrDefault()); //// Delete //return await DeleteAsync(Role, cancellationToken); }
public async Task <T> RetrieveEntityUsingPointQueryAsync <T>(CloudTable table, string partitionKey, string rowKey) where T : TableEntity { try { TableOperation retrieveOperation = TableOperation.Retrieve <T>(partitionKey, rowKey); TableResult result = await table.ExecuteAsync(retrieveOperation); T row = result.Result as T; // Not cosmos, so no charge //if (result.RequestCharge.HasValue) //{ // Console.WriteLine("Request Charge of Retrieve Operation: " + result.RequestCharge); //} return(row); } catch (StorageException e) { Console.WriteLine(e.Message); Console.ReadLine(); throw; } }
public async Task EntityOperationReturnsExpectedEntityTest(TableOperationType operationType) { var entity = CreateEntity(); var result = new TableResult { Result = entity, }; this.mockTable .Setup(x => x.ExecuteAsync( It.IsAny <TableOperation>())) .ReturnsAsync(result); var response = await this.GetResponseByTableOperationAsync(operationType, entity); this.mockTable .Verify( x => x.ExecuteAsync( It.Is <TableOperation>(op => op.Entity == entity && op.OperationType == operationType)), Times.Once); Assert.Equal(entity.RowKey, response.RowKey); Assert.Equal(entity.PartitionKey, response.PartitionKey); }
public async Task <string> GetConfigurationAsync(string configurationKey) { await Initialize(); // check if exist. If not, create new configuration TableOperation retrieveOperation = TableOperation.Retrieve <ConfigEntity>(_configurationOptions.Environment, configurationKey); TableResult retrievedResult = await _table.ExecuteAsync(retrieveOperation); string configstr = ""; if (retrievedResult.Result == null) { return(null); } else { configstr = ((ConfigEntity)retrievedResult.Result).Data; } return(configstr); }
private static void removeData(newsItems items, string tableName) { //return if no headlines to process if (items.NewsItems.Count == 0) { return; } CloudTable table = getTableStorage(tableName); // Create the table if it doesn't exist. table.CreateIfNotExists(); // Create the TableOperation object that deletes the customer entity. foreach (newsItem item in items.NewsItems) { // Create a retrieve operation that expects a customer entity. TableOperation retrieveOperation = TableOperation.Retrieve <newsItem>(item.PartitionKey, item.RowKey); // Execute the operation. TableResult retrievedResult = table.Execute(retrieveOperation); // Assign the result to a CustomerEntity. newsItem deleteEntity = (newsItem)retrievedResult.Result; // Create the Delete TableOperation. if (deleteEntity != null) { TableOperation deleteOperation = TableOperation.Delete(deleteEntity); // Execute the operation. table.Execute(deleteOperation); } } }
public IHttpActionResult DeleteSample(string id) { // Create a retrieve operation that takes a Sample entity. TableOperation retrieveOperation = TableOperation.Retrieve <SampleEntity>(partitionName, id); // Execute the retrieve operation. TableResult retrievedResult = table.Execute(retrieveOperation); if (retrievedResult.Result == null) { return(NotFound()); } else { SampleEntity deleteEntity = (SampleEntity)retrievedResult.Result; deleteBlobs(deleteEntity); TableOperation deleteOperation = TableOperation.Delete(deleteEntity); // Execute the operation. table.Execute(deleteOperation); return(Ok(retrievedResult.Result)); } }
public async Task <ActionResult> Delete(string name) { try { CloudTable table = Common.GetTableConnect(connectionString, container); TableOperation retrieveOperation = TableOperation.Retrieve <SourceEntity>("PPDM", name); TableResult result = await table.ExecuteAsync(retrieveOperation); SourceEntity entity = result.Result as SourceEntity; if (entity == null) { return(BadRequest()); } TableOperation deleteOperation = TableOperation.Delete(entity); result = await table.ExecuteAsync(deleteOperation); } catch (Exception) { return(BadRequest()); } return(NoContent()); }
public string AzureGet(string input) { StreamReader keyFile = new StreamReader(Path.Combine(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath, @"azurestring.key")); string azureKey = keyFile.ReadLine(); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(string.Format("DefaultEndpointsProtocol=https;AccountName=gameofsounds;AccountKey={0}", azureKey)); CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference("test"); if (!table.Exists()) { return("Table test does not exist"); } TableOperation retrieveOperation = TableOperation.Retrieve <TestEntity>("partition0", input); TableResult result = table.Execute(retrieveOperation); if (result.Result != null) { return("Get Complete. Object returned: " + ((TestEntity)result.Result).ToString()); } return("Azure Get did not find an object for key: " + input); }
public async Task <UsuarioModel> LeerUsuario(string Id) { var table = TablaAzure(); TableOperation retrieveOperation = TableOperation.Retrieve <AzUsuarioEntity>( Id.Substring(0, 3), Id); // Execute the retrieve operation. TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation); // Print the phone number of the result. if (retrievedResult.Result != null) { var az = retrievedResult.Result as AzUsuarioEntity; return(new UsuarioModel() { Id = az.Id, CorreoElectronico = az.CorreoElectronico, }); } return(null); }
internal static Task <TableResult> TableOperationPostProcess(TableResult result, TableOperation operation, RESTCommand <TableResult> cmd, HttpResponseMessage resp, OperationContext ctx) { return(Task.Run(() => { if (operation.OperationType != TableOperationType.Retrieve && operation.OperationType != TableOperationType.Insert) { result.Etag = resp.Headers.ETag.ToString(); operation.Entity.ETag = result.Etag; } else { // Parse entity ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings(); readerSettings.MessageQuotas = new ODataMessageQuotas() { MaxPartsPerBatch = TableConstants.TableServiceMaxResults, MaxReceivedMessageSize = TableConstants.TableServiceMaxPayload }; ReadOdataEntity(result, operation, new HttpResponseAdapterMessage(resp, cmd.ResponseStream), ctx, readerSettings); } return result; })); }
public async Task <bool> ActualizarFraseGlobal(string partitionKey, int no_frase, string valor_frase) { bool response = false; int phrase_number = 0; TableQuery <FraseGlobalEntity> tableQuery = new TableQuery <FraseGlobalEntity>(); TableContinuationToken continuationToken = new TableContinuationToken(); foreach (FraseGlobalEntity fraseGlobalEntity in await cloudTableFG.ExecuteQuerySegmentedAsync(tableQuery, continuationToken)) { phrase_number = GetPhraseNumberByRowKey(fraseGlobalEntity.RowKey); if (fraseGlobalEntity.PartitionKey.Equals(partitionKey) && phrase_number == no_frase) { TableOperation RetrieveOperation = TableOperation.Retrieve <FraseGlobalEntity>(partitionKey, fraseGlobalEntity.RowKey); TableResult RetrievedResult = await cloudTableFG.ExecuteAsync(RetrieveOperation); FraseGlobalEntity EntityToUpdate = (FraseGlobalEntity)RetrievedResult.Result; EntityToUpdate.valor_frase = valor_frase; TableOperation UpdateOperation = TableOperation.Replace(EntityToUpdate); await cloudTableFG.ExecuteAsync(UpdateOperation); response = true; break; } } return(response); }
/// <summary> /// Sets table result. /// </summary> /// <param name="tableResult">Given TableResult.</param> /// <returns></returns> public TableResultBuilder SetTableResult(TableResult tableResult) { this.tableResult = tableResult; return this; }
/// <summary> /// Construct ProblemResult instance from given tableValues and visualValues. /// </summary> /// <param name="tableValues">TableResult.</param> /// <param name="visualValues">VisualResult.</param> public ProblemResult(TableResult tableValues, VisualResult visualValues) : this(string.Empty, string.Empty, tableValues, visualValues) { }
public JsonResult List(GridTaskRequestModel searchModel) { if (searchModel == null) searchModel = new GridTaskRequestModel(); var response = new TableResult(); try { var user = WebSecurity.GetUser(User.Identity.Name); var tasks = _unitOfWork.Repository<Task>().Query.Include(u => u.User).AsNoTracking().Where(w => w.UserId.Equals((System.Guid)user.ProviderUserKey)); //Поиск if (searchModel.Filter.IsNow.HasValue && searchModel.Filter.IsNow.Value) tasks = tasks.Where(p => !p.Done.HasValue || p.Done.HasValue && !p.Done.Value); if (searchModel.Filter.IsDone.HasValue && searchModel.Filter.IsDone.Value) tasks = tasks.Where(p => p.Done.HasValue && p.Done.Value); if (!string.IsNullOrEmpty(searchModel.Filter.Name)) tasks = tasks.Where(p => searchModel.Filter.Name.Equals(p.Name, System.StringComparison.InvariantCultureIgnoreCase)); if (!string.IsNullOrEmpty(searchModel.Filter.Description)) tasks = tasks.Where(p => !string.IsNullOrEmpty(p.Description) && p.Description.Contains(searchModel.Filter.Description)); // Сортировка if (searchModel.Sort.Created.HasValue) tasks = searchModel.Sort.Created.Value ? tasks.OrderBy(p => p.Created) : tasks.OrderByDescending(p => p.Created); else if (searchModel.Sort.Importance.HasValue) tasks = searchModel.Sort.Importance.Value ? tasks.OrderBy(p => p.Importance) : tasks.OrderByDescending(p => p.Importance); response.Result = tasks.AsEnumerable() .Skip(searchModel.Skip) .Take(searchModel.Take) .Select(p => new TaskModel(p)).ToArray(); // Считаем общее количество записей response.TotalCount = tasks.Count(); } catch (System.Exception ex) { Logger.Error("OnList", ex); } return JsonNet(response); }
private TableResultBuilder(string title) { tableResult = new TableResult(title); }
private TableResultBuilder() { tableResult = new TableResult(); }