/// <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();
}
