public async Task <bool> Actualizar(EmpleadosEntity actualizado)
{
var table = ObtenerTablaAzure();
// Create a retrieve operation that expects a customer entity.
TableOperation retrieveOperation = TableOperation.Retrieve <EmpleadosAzureEntity>(actualizado.RFC.Substring(0, 2), actualizado.RFC);
// Execute the operation.
TableResult retrievedResult = await table.ExecuteAsync(retrieveOperation);
// Assign the result to a CustomerEntity.
var updateEntity = retrievedResult.Result as EmpleadosAzureEntity;
// Create the Delete TableOperation.
if (updateEntity != null)
{
updateEntity.nombre = actualizado.nombre;
updateEntity.apellidoP = actualizado.apellidoP;
updateEntity.apellidoM = actualizado.apellidoM;
updateEntity.nacimiento = actualizado.nacimiento;
updateEntity.tipo = actualizado.tipo;
updateEntity.telefono = actualizado.telefono;
updateEntity.sueldo = actualizado.sueldo;
updateEntity.horario = actualizado.horario;
TableOperation updateOperation = TableOperation.Replace(updateEntity);
// Execute the operation.
await table.ExecuteAsync(updateOperation);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Updates a data entry in the Azure table: updates an already existing data in the table, by using eTag.
/// Fails if the data does not already exist or of eTag does not match.
/// </summary>
/// <param name="data">Data to be updated into the table.</param>
/// /// <param name="dataEtag">ETag to use.</param>
/// <returns>Value promise with new Etag for this data entry after completing this storage operation.</returns>
public async Task <string> UpdateTableEntryAsync(T data, string dataEtag)
{
const string operation = "UpdateTableEntryAsync";
var startTime = DateTime.UtcNow;
if (Logger.IsVerbose2)
{
Logger.Verbose2("{0} table {1} entry {2}", operation, TableName, data);
}
try
{
try
{
data.ETag = dataEtag;
var opResult = await Task <TableResult> .Factory.FromAsync(
tableReference.BeginExecute,
tableReference.EndExecute,
TableOperation.Replace(data),
null);
//The ETag of data is needed in further operations.
return(opResult.Etag);
}
catch (Exception exc)
{
CheckAlertWriteError(operation, data, null, exc);
throw;
}
}
finally
{
CheckAlertSlowAccess(startTime, operation);
}
}
private static async Task EditStudent()
{
System.Console.WriteLine("Adauga universitatea:");
string university = Console.ReadLine();
System.Console.WriteLine("Adauga CNP:");
string cnp = Console.ReadLine();
Studententity stud = await RetrieveRecordAsync(studentsTable, university, cnp);
if (stud != null)
{
System.Console.WriteLine("S-a gasit!");
var student = new Studententity(university, cnp);
System.Console.WriteLine("Adauga nume:");
string nume = Console.ReadLine();
System.Console.WriteLine("Adauga prenume:");
string prenume = Console.ReadLine();
System.Console.WriteLine("Adauga facultate:");
string facultate = Console.ReadLine();
System.Console.WriteLine("Adauga an studiu:");
string an = Console.ReadLine();
student.Nume = nume;
student.Prenume = prenume;
student.Facultate = facultate;
student.An = Convert.ToInt32(an);
student.ETag = "*";
var updateOperation = TableOperation.Replace(student);
await studentsTable.ExecuteAsync(updateOperation);
System.Console.WriteLine("S-a modificat!");
}
else
{
System.Console.WriteLine("Nu s-a gasit studentul!");
}
}
private static async Task EditStudent()
{
System.Console.WriteLine("Insert university:");
string university = Console.ReadLine();
System.Console.WriteLine("Insert cnp:");
string cnp = Console.ReadLine();
StudentEntity stud = await RetrieveRecordAsync(studentsTable, university, cnp);
if (stud != null)
{
System.Console.WriteLine("Record exists!");
var student = new StudentEntity(university, cnp);
System.Console.WriteLine("Insert firstName:");
string firstName = Console.ReadLine();
System.Console.WriteLine("Insert lastName:");
string lastName = Console.ReadLine();
System.Console.WriteLine("Insert faculty:");
string faculty = Console.ReadLine();
System.Console.WriteLine("Insert year of study:");
string year = Console.ReadLine();
student.FirstName = firstName;
student.LastName = lastName;
student.Faculty = faculty;
student.Year = Convert.ToInt32(year);
student.ETag = "*";
var updateOperation = TableOperation.Replace(student);
await studentsTable.ExecuteAsync(updateOperation);
System.Console.WriteLine("Record updated!");
}
else
{
System.Console.WriteLine("Record does not exists!");
}
}
public async Task <Device> Update(Device device)
{
TableOperation retrieveOperation = TableOperation.Retrieve <DeviceEntity>(device.UserEmail, device.Id);
TableResult retrievedResult = await cloudTable.ExecuteAsync(retrieveOperation);
var dev = new DeviceEntity();
if (retrievedResult.Result != null)
{
dev = retrievedResult.Result as DeviceEntity;
dev.Id = device.Id;
dev.Name = device.Name;
dev.IconName = device.IconName;
dev.Description = device.Description;
dev.Status = device.Status;
dev.IsOn = device.IsOn;
dev.UserEmail = device.UserEmail;
var updateOperation = TableOperation.Replace(dev);
await cloudTable.ExecuteAsync(updateOperation);
return(device);
}
return(null);
}
public async Task <Device> TurnOnOffDevice(Device device)
{
TableOperation retrieveOperation = TableOperation.Retrieve <DeviceEntity>(device.UserEmail, device.Id);
TableResult retrievedResult = await cloudTable.ExecuteAsync(retrieveOperation);
var dev = new DeviceEntity();
if (retrievedResult.Result != null)
{
dev = retrievedResult.Result as DeviceEntity;
dev.IsOn = device.IsOn;
var updateOperation = TableOperation.Replace(dev);
var tblResult = await cloudTable.ExecuteAsync(updateOperation);
// guardar datos aqui
var blob = cloudBlobContainer.GetAppendBlobReference("usage.txt");
// Interesante solución
// https://stackoverflow.com/questions/7653876/azure-updating-an-existing-xml-file-in-blob-storage
await blob.AppendTextAsync("Super smash bros ultimate\n");
return(device);
}
return(null);
}
private static CustomerEntity ReplaceAnEntity(CloudTable table)
{
TableOperation retrieveOperation = TableOperation.Retrieve <CustomerEntity>("Smith", "Ben");
// Execute the operation.
TableResult retrievedResult = table.Execute(retrieveOperation);
// Assign the result to a CustomerEntity object.
CustomerEntity updateEntity = (CustomerEntity)retrievedResult.Result;
if (updateEntity != null)
{
// Change the phone number.
updateEntity.PhoneNumber = "425-555-0105";
// Create the Replace TableOperation.
TableOperation updateOperation = TableOperation.Replace(updateEntity);
// Execute the operation.
return((CustomerEntity)table.Execute(updateOperation).Result);
}
return(null);
}
public User LogIn(User user)
{
//este user tem so email e password
try
{
TableQuery <ModeloTableUser> query = new TableQuery <ModeloTableUser>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, user.Email));
List <ModeloTableUser> resultado = table.ExecuteQuery(query).ToList <ModeloTableUser>();
if (resultado.Count == 1)
{
foreach (var userDB in resultado)
{
if (userDB.RowKey == user.Email && userDB.PartitionKey == user.Password)
{
user.Nome = userDB.Nome;
user.Apelido = userDB.Apelido;
user.QuantLogins = userDB.QuantLogins + 1;
user.Autenticado = true;
//Atualiza quantidade de logins e se esta autenticado.
TableOperation update = TableOperation.Replace(UserToModelTableUser(user));
table.Execute(update);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
if (user.Nome == null && user.Apelido == null)
{
user = null;
}
return(user);
}
/// <summary>
/// Updates the <see cref="T"/> in the Role store.
/// </summary>
/// <param name="role"><see cref="T"/></param>
/// <returns><see cref="Task"/></returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="role"/> is <c>null</c>.</exception>
/// <see cref="AzureTableRoleException">Thrown whenever a table operation results in a <see cref="StorageException"/> being thrown.</see>
/// <see cref="AzureTableRoleException">Thrown whenever a table operation results in a <see cref="StorageException"/> being thrown.</see>
public virtual async Task UpdateAsync(T role)
{
AssertNotDisposed();
if (role == null)
{
throw new ArgumentNullException("role");
}
if (string.IsNullOrWhiteSpace(role.RowKey))
{
throw new ArgumentException("Role Id not set", "role");
}
var op = TableOperation.Replace(role.EnsureETagSet());
try
{
var result = await Run(RoleTableName, op);
role.ETag = result.Etag;
}
catch (StorageException ex)
{
throw new AzureTableRoleException("An exception was thrown while attempting to update this role. See the inner exception for details.", ex);
}
}
private static string UpdateCostMasterLastProcessedDateWithTodaysDate(ILogger log)
{
TableOperation tableOperation;
string storageConnectionString = SourceConnection;
log.LogInformation("**** In Test Method ****");
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudTableClient tableClient = cloudStorageAccount.CreateCloudTableClient();
string tableName = "CostsMaster";
CloudTable cloudTable = tableClient.GetTableReference(tableName);
CostMasterEntity costMasterEntity = new CostMasterEntity("2020", "1");
costMasterEntity.LastProcessedDate = DateTime.Now.ToString("dd'/'MM'/'yyyy");
// retrieve record
var retrieverResult = RetrieveRecord(cloudTable, "2020", "1");
if (retrieverResult == null)
{
// if not found
tableOperation = TableOperation.Insert(costMasterEntity);
}
else
{
// update
costMasterEntity.ETag = "*";
tableOperation = TableOperation.Replace(costMasterEntity);
}
var result = cloudTable.ExecuteAsync(tableOperation);
//CreateNewTable(cloudTable, log);
return(result.Status.ToString());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "put", Route = null)] HttpRequest req,
// Invoce Microsoft.WindowsAzure.Storage.Table, which will connect to the employees table
[Table("employees", Connection = "TableStorageConnection")] CloudTable cloudTable,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
string employeeId = data.Id;
string updatedEmployeeName = data.Name;
string updatedEmployeeDepartment = data.Department;
// TableEntity is required for TableOperation.Replace
Employee updatedEmployeeData = new Employee(employeeId, updatedEmployeeName, updatedEmployeeDepartment);
// Replace (PUT) the data entry. Trying to update RowKey or PartitionKey would result in error.
// If that is needed the entity has to be deleted and recreated.
TableOperation operation = TableOperation.Replace(updatedEmployeeData);
await cloudTable.ExecuteAsync(operation);
return(new OkObjectResult($"The employee data of {updatedEmployeeName} has been updated!"));
}
public static async Task CancelOrphanPlans(
[TimerTrigger("0 05 12 * * *")] TimerInfo timer, // 12:05AM daily
[Table("plans")] CloudTable plansTable,
[Table("proposals")] CloudTable proposalsTable,
IBinder binder)
{
Utils.SetCulture();
var plans = await GetTodayPlansWithoutResponsible(plansTable);
foreach (var plan in plans)
{
if (!string.IsNullOrWhiteSpace(plan.Video))
{
var proposal = await proposalsTable.Retrieve <Proposal>(plan.PartitionKey, plan.Video);
if (proposal != null)
{
proposal.PlannedIn = "";
await proposalsTable.ExecuteAsync(TableOperation.Replace(proposal));
}
}
var result = await plansTable.ExecuteAsync(TableOperation.Delete(plan));
if (result.IsError())
{
continue;
}
await SlackHelper.PostMessage(binder, plan.Team, new PostMessageRequest {
Channel = plan.Channel,
Text = "Le Lunch & Watch de ce midi a été annulé car aucun responsable ne s'est manifesté."
});
}
}
private static async Task EditStudent()
{
System.Console.WriteLine("Introduceti universitatea:");
string university = Console.ReadLine();
System.Console.WriteLine("Introduceti cnp:");
string cnp = Console.ReadLine();
StudentEntity stud = await RetrieveRecordAsync(studentsTable, university, cnp);
if (stud != null)
{
System.Console.WriteLine("Intregistrarea exista deja!");
var student = new StudentEntity(university, cnp);
System.Console.WriteLine("Introduceti numele de familie:");
string firstName = Console.ReadLine();
System.Console.WriteLine("Introduceti prenumele:");
string lastName = Console.ReadLine();
System.Console.WriteLine("Introduceti facultatea: ");
string faculty = Console.ReadLine();
System.Console.WriteLine("Introduceti anul de studiu: ");
string year = Console.ReadLine();
student.FirstName = firstName;
student.LastName = lastName;
student.Faculty = faculty;
student.Year = Convert.ToInt32(year);
student.ETag = "*";
var updateOperation = TableOperation.Replace(student);
await studentsTable.ExecuteAsync(updateOperation);
System.Console.WriteLine("Modificarea s-a facut cu succes");
}
else
{
System.Console.WriteLine("Inregistrarea nu exista");
}
}
public void ReplaceBook(Book b)
{
operation = TableOperation.Replace(b);
_table.Execute(operation);
}
private static async Task UpdateInvestor(CloudTable cloudTable, Investor investor)
{
var operation = TableOperation.Replace(investor);
await cloudTable.ExecuteAsync(operation);
}
public static async Task Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer,
[Table("EventsTable")] CloudTable currentEvents,
[SignalR(HubName = "broadcastConflicts")] IAsyncCollector <SignalRMessage> signalRMessages, ILogger log)
{
try
{
log.LogInformation($"Appointments Conflicts Detector Timer trigger function executed at: {DateTime.Now}");
DateTimeOffset dateTimeOffset = DateTimeOffset.Now.AddMinutes(-5);
var partitionFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "BookingAppointmentEvent");
var IsConflictedFilter = TableQuery.GenerateFilterConditionForBool("IsConflicted", QueryComparisons.Equal, true);
var IsConflictShownFilter = TableQuery.GenerateFilterConditionForBool("IsConflictShown", QueryComparisons.Equal, false);
var dateFilter = TableQuery.GenerateFilterConditionForDate("EventCreationDate", QueryComparisons.LessThanOrEqual, dateTimeOffset);
var filter = TableQuery.CombineFilters(
dateFilter,
TableOperators.And,
TableQuery.CombineFilters(
TableQuery.CombineFilters(partitionFilter, TableOperators.And, IsConflictedFilter),
TableOperators.And, IsConflictShownFilter));
TableQuery <Event> rangeQuery = new TableQuery <Event>().Where(filter);
List <AppointmentEvent> appointmentEventsWithConflicts = new List <AppointmentEvent>();
var conflictedEvents = await currentEvents.ExecuteQuerySegmentedAsync(rangeQuery, null);
foreach (var conflictedEvent in conflictedEvents)
{
log.LogInformation($"{conflictedEvent.PartitionKey}\t{conflictedEvent.RowKey}\t{conflictedEvent.Timestamp}\t{conflictedEvent.EventId}");
var originalAppointmentEvent = appointmentEventsWithConflicts.Find(x => x.EventId == conflictedEvent.OriginalEventId);
if (originalAppointmentEvent != null)
{
originalAppointmentEvent.ConflictedEvents.Add(conflictedEvent);
}
else
{
appointmentEventsWithConflicts.Add(new AppointmentEvent()
{
EventId = conflictedEvent.OriginalEventId,
EventReferenceNo = conflictedEvent.OriginalEventId.ToString().Substring(0, conflictedEvent.OriginalEventId.ToString().IndexOf("-")),
ConflictedEvents = new List <Event>()
{
conflictedEvent
}
});
}
conflictedEvent.IsConflictShown = true;
await currentEvents.ExecuteAsync(TableOperation.Replace(conflictedEvent));
}
if (appointmentEventsWithConflicts.Any())
{
await signalRMessages.AddAsync(new SignalRMessage
{
Target = "appointmentConflictDetected",
Arguments = new[] { appointmentEventsWithConflicts }
});
}
}
catch (Exception ex)
{
log.LogInformation($"AppointmentsConflictsDetector Timer trigger function executed at: {DateTime.Now} exception:{ex.Message}");
}
}
public async Task <int> IncrementCountAsync(Repository repository)
{
string partitionKey = $"{repository.OrganizationId}_{repository.RepositoryId}";
string rowKey = string.Empty;
TableOperation retrieveOperation = TableOperation.Retrieve <EventStatsTableEntity>(partitionKey, rowKey);
try
{
TableResult retrieveResult = await this.table.ExecuteAsync(retrieveOperation).ConfigureAwait(false);
int retrieveStatusCode = retrieveResult.HttpStatusCode;
if (retrieveStatusCode == 404) // Not found
{
TableOperation insertOperation = TableOperation.Insert(new EventStatsTableEntity(repository, eventCount: 1));
try
{
await this.table.ExecuteAsync(insertOperation).ConfigureAwait(false);
return(1);
}
catch (Exception insertException) when(insertException is StorageException)
{
StorageException insertStorageException = (StorageException)insertException;
int insertStatusCode = insertStorageException.RequestInformation.HttpStatusCode;
if (insertStatusCode == 409) // Conflict
{
// We were too late to insert, so someone else did it. Retry.
await this.IncrementCountAsync(repository).ConfigureAwait(false);
}
else
{
Dictionary <string, string> properties = new Dictionary <string, string>()
{
{ "OrganizationLogin", repository.OrganizationLogin },
{ "RepositoryName", repository.RepositoryName },
{ "ErrorMessage", insertStorageException.Message },
{ "ErrorReturnCode", insertStatusCode.ToString() },
};
this.telemetryClient.TrackEvent("BookkeepingError", properties);
}
}
}
else if (retrieveStatusCode == 200)
{
EventStatsTableEntity retrieveStats = (EventStatsTableEntity)retrieveResult.Result;
string retrieveETag = retrieveResult.Etag;
int currentEventCount = retrieveStats.EventCount;
TableOperation replaceOperation = TableOperation.Replace(new EventStatsTableEntity(repository, currentEventCount + 1, retrieveETag));
try
{
await this.table.ExecuteAsync(replaceOperation).ConfigureAwait(false);
return(currentEventCount + 1);
}
catch (Exception replaceException) when(replaceException is StorageException)
{
StorageException replaceStorageException = (StorageException)replaceException;
int replaceStatusCode = replaceStorageException.RequestInformation.HttpStatusCode;
if (replaceStatusCode == 412) // Pre-condition failed
{
// We were too late to update, so someone else did it. Retry.
return(await this.IncrementCountAsync(repository).ConfigureAwait(false));
}
else
{
Dictionary <string, string> properties = new Dictionary <string, string>()
{
{ "OrganizationLogin", repository.OrganizationLogin },
{ "RepositoryName", repository.RepositoryName },
{ "ErrorMessage", replaceException.Message },
{ "ErrorReturnCode", replaceStatusCode.ToString() },
};
this.telemetryClient.TrackEvent("BookkeepingError", properties);
}
}
}
else
{
Dictionary <string, string> properties = new Dictionary <string, string>()
{
{ "OrganizationLogin", repository.OrganizationLogin },
{ "RepositoryName", repository.RepositoryName },
{ "ErrorReturnCode", retrieveStatusCode.ToString() },
};
this.telemetryClient.TrackEvent("BookkeepingError", properties);
}
}
catch (Exception exception)
{
Dictionary <string, string> properties = new Dictionary <string, string>()
{
{ "OrganizationLogin", repository.OrganizationLogin },
{ "RepositoryName", repository.RepositoryName },
{ "ErrorReturnCode", exception.ToString() },
{ "ErrorType", exception.GetType().ToString() },
};
this.telemetryClient.TrackEvent("BookkeepingError", properties);
}
return(0);
}
public Task ResetCountAsync(Repository repository)
{
TableOperation replaceOperation = TableOperation.Replace(new EventStatsTableEntity(repository, 0, eTag: "*"));
return(this.table.ExecuteAsync(replaceOperation));
}
protected override TableOperation AsTableOperation()
{
return(TableOperation.Replace(Entity));
}
private void UpdateCustomer(CloudTable cloudTable, CustomerUK customerToUpdate)
{
TableOperation update = TableOperation.Replace(customerToUpdate);
cloudTable.Execute(update);
}
public async Task UpdateBikeAsync(Bike bike)
{
var operation = TableOperation.Replace(bike);
await _table.ExecuteAsync(operation);
}
public void UpdateOCRJob(OCRJob job)
{
TableOperation insertOperation = TableOperation.Replace(job);
table.Execute(insertOperation);
}
public async Task UpdateOrder(Order order)
{
var entity = CreateOrderEntity(order);
var op = TableOperation.Replace(entity);
await ExecutionContext.TableStorage.ExecuteAsync(op);
}
public static async Task <IActionResult> PostOrchestration(
// Using /a/p/i route prefix, to let Functions Host distinguish api methods from statics
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "a/p/i/orchestrations('{instanceId}')/{action?}")] HttpRequest req,
string instanceId,
string action,
[DurableClient(TaskHub = "%DFM_HUB_NAME%")] IDurableClient durableClient)
{
// Checking that the call is authenticated properly
try
{
Globals.ValidateIdentity(req.HttpContext.User, req.Headers);
}
catch (UnauthorizedAccessException ex)
{
return(new OkObjectResult(ex.Message)
{
StatusCode = 401
});
}
string bodyString = await req.ReadAsStringAsync();
switch (action)
{
case "purge":
await durableClient.PurgeInstanceHistoryAsync(instanceId);
break;
case "rewind":
await durableClient.RewindAsync(instanceId, bodyString);
break;
case "terminate":
await durableClient.TerminateAsync(instanceId, bodyString);
break;
case "raise-event":
dynamic bodyObject = JObject.Parse(bodyString);
string eventName = bodyObject.name;
JObject eventData = bodyObject.data;
await durableClient.RaiseEventAsync(instanceId, eventName, eventData);
break;
case "set-custom-status":
string connectionString = Environment.GetEnvironmentVariable(EnvVariableNames.AzureWebJobsStorage);
string hubName = Environment.GetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME);
// Updating the table directly, as there is no other known way
var tableClient = CloudStorageAccount.Parse(connectionString).CreateCloudTableClient();
var table = tableClient.GetTableReference($"{hubName}Instances");
var orcEntity = (await table.ExecuteAsync(TableOperation.Retrieve(instanceId, string.Empty))).Result as DynamicTableEntity;
if (string.IsNullOrEmpty(bodyString))
{
orcEntity.Properties.Remove("CustomStatus");
}
else
{
// Ensuring that it is at least a valid JSON
string customStatus = JObject.Parse(bodyString).ToString();
orcEntity.Properties["CustomStatus"] = new EntityProperty(customStatus);
}
await table.ExecuteAsync(TableOperation.Replace(orcEntity));
break;
default:
return(new NotFoundResult());
}
return(new OkResult());
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, ILogger log)
{
log.LogTrace("C# HTTP trigger function processed a request.");
dynamic body = await req.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <LoginRepsonse>(body as string);
// parse query parameter
Guid? CompanyId = data?.CompanyId;
string oldUserName = null, oldPassword = null, UserName = null, Password = null;
string connectionstring2 = "DefaultEndpointsProtocol=https;AccountName=spassessservices20190227;AccountKey=KLx/VDJ279oOZ2Z2wELr90GauiVlEN4pr8r2ss2xAiokZJGAi4PF6eGz0nI0Vz0IieEwtKxqkgoM+ukeVoWxMw==;EndpointSuffix=core.windows.net";
if (data?.UserName == null && data?.Password == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a username and password"));
}
if (data?.newUserName != null || data?.newPassword != null)
{
oldUserName = data?.UserName;
oldPassword = data?.Password;
UserName = data?.newUserName;
Password = data?.newPassword;
}
else
{
UserName = data?.UserName;
Password = data?.Password;
oldUserName = UserName;
oldPassword = Password;
}
Login login;
try
{
//this code will do a insert and do a check for the id
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionstring2);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
//first call to get the login and verify
CloudTable cloudTable = tableClient.GetTableReference("Login");
TableOperation tableOperation = TableOperation.Retrieve <Login>(oldUserName, oldPassword);
TableResult tableResult = await cloudTable.ExecuteAsync(tableOperation);
login = tableResult.Result as Login;
if (login == null)
{
var newLogin = new Login()
{
PartitionKey = UserName,
RowKey = Password,
CompanyId = UpsertCompany.GenerateCompanyId(),
UserName = UserName,
Password = Password,
oldUserName = oldUserName,
oldPassword = oldPassword
};
TableOperation insertOperation = TableOperation.Insert(newLogin);
TableResult insertResult = await cloudTable.ExecuteAsync(insertOperation);
return(req.CreateResponse(HttpStatusCode.Created, "successful"));
}
else
{
var updateLogin = new Login()
{
PartitionKey = UserName,
RowKey = Password,
CompanyId = login.CompanyId,
UserName = UserName,
Password = Password,
oldUserName = oldUserName,
oldPassword = oldPassword,
ETag = "*"
};
var operation = TableOperation.Replace(updateLogin);
await cloudTable.ExecuteAsync(operation);
return(req.CreateResponse(HttpStatusCode.Created, "successful"));
}
}
catch (StorageException se)
{
log.LogTrace(se.Message);
}
catch (Exception ex)
{
log.LogTrace(ex.Message);
}
return(req.CreateResponse(HttpStatusCode.Created, "successful"));
}
/// <summary>
/// Updates the table entity into the Azure Table storage
/// </summary>
/// <param name="tableEntity">The entity to update to the Azure Table Storage</param>
/// <returns>The table result from the Execute statement</returns>
public TableResult Update(TableEntity tableEntity)
{
return(_cloudTable.Execute(TableOperation.Replace(tableEntity)));
}
public async Task ReplaceAsync(T item)
{
item.PrepareForSave();
var operation = TableOperation.Replace(item);
await _tableClient.ExecuteAsync(operation);
}
public bool UpdateScore(CycleIdentifier cycle, int checkpoint, long timestampTicks, CpScore cpScore)
{
var scoreEntity = _cycleScoresCache[cycle.Id];
if (scoreEntity.Timestamp.Ticks != timestampTicks)//final check before we overwrite something we didn't mean to
{
return(false);
}
scoreEntity.SaveScores(checkpoint, cpScore);
//this does update scoreEntity.TimeStamp
_cloudTable.Execute(scoreEntity.Timestamp == DateTimeOffset.MinValue ? TableOperation.Insert(scoreEntity) : TableOperation.Replace(scoreEntity));
//should we check the _cloudTable.Execute().HttpStatusCode ??
return(true);
//what is the new TimeStamp??
//else it's not the right timestamp
}
public async Task UpdateAsync(LocalAuthoritySet item) => await Table.ExecuteAsync(TableOperation.Replace(item));
public async Task UpdateTask(DocumentTaskEntity document)
{
TableOperation taskTableOp = TableOperation.Replace(document);
TableResult taskTableResult = await documentTaskTable.ExecuteAsync(taskTableOp);
}
