public static async Task <IActionResult> CheckColor(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "CheckColor/{email}/{favorite_color}")] HttpRequestMessage request,
[Table("ClientsTable")] CloudTable ClientsTable,
string email, string favorite_color,
ILogger log)
{
log.LogInformation("ForgotPassword!\n");
string emailFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, email);
var emailQuery = new TableQuery <Client>().Where(emailFilter);
TableQuerySegment <Client> queryResult = await ClientsTable.ExecuteQuerySegmentedAsync(emailQuery, null);
Client client = queryResult.FirstOrDefault();
if (client == null)
{
return(new BadRequestObjectResult("Email does not exist.\n" +
"Please register before"));
}
if (string.Compare(favorite_color, client.favorite_color) != 0)
{
return(new BadRequestObjectResult("Oops, The color does not match."));
}
return((ActionResult) new OkObjectResult("OK"));
}
public async Task <T> GetTableEntity <T>(string partitionKey, string rowKey) where T : ITableEntity, new()
{
CloudTable table = this.GetStorageTable();
string partitionKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
string rowKeyFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey);
string filter = TableQuery.CombineFilters(
partitionKeyFilter,
TableOperators.And,
rowKeyFilter);
TableQuery <T> newsQuery = new TableQuery <T>().Where(filter);
TableQuerySegment <T> retrievedNews = await table.ExecuteQuerySegmentedAsync(newsQuery, null);
T element = retrievedNews.FirstOrDefault();
if (element == null)
{
throw new AzureXStoreException("The entity is not in the store.");
}
return(element);
}
public static async Task <IActionResult> SignIn(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "SignIn/{email}/{password}")] HttpRequestMessage request,
[Table("ClientsTable")] CloudTable ClientsTable,
[SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages,
string email, string password,
ILogger log)
{
log.LogInformation("Signing in!\n");
string emailFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, email);
var emailQuery = new TableQuery <Client>().Where(emailFilter);
TableQuerySegment <Client> queryResult = await ClientsTable.ExecuteQuerySegmentedAsync(emailQuery, null);
Client client = queryResult.FirstOrDefault();
if (client == null)
{
return(new BadRequestObjectResult("Email does not exist.\n" +
"Please register before signing in"));
}
else if (client.password != password)
{
return(new BadRequestObjectResult("Incorrect password."));
}
else
{
return((ActionResult) new OkObjectResult($"{client.name} signed in successfully"));
}
}
/// <summary>
/// Delete the track.
/// </summary>
/// <param name="trackId"></param>
internal static async Task <bool> DeleteTrack(string trackId)
{
try
{
// reference track table
CloudTable table = tableClient.GetTableReference(TracksTable);
await table.CreateIfNotExistsAsync();
// query tracks
TableQuery <TrackAuth> rangeQuery = new TableQuery <TrackAuth>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, trackId));
TableContinuationToken token = null;
TableQuerySegment <TrackAuth> tableQueryResult = await table.ExecuteQuerySegmentedAsync(rangeQuery, token);
TableOperation op = TableOperation.Delete(tableQueryResult.FirstOrDefault());
await table.ExecuteAsync(op);
return(true);
}
catch
{
return(false);
}
}
private static async Task <Counter> GetOrCreateCounter(CloudTable cloudTable, int counterId)
{
TableQuery <Counter> idQuery = new TableQuery <Counter>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, counterId.ToString()));
TableQuerySegment <Counter> queryResult = await cloudTable.ExecuteQuerySegmentedAsync(idQuery, null);
Counter cloudCounter = queryResult.FirstOrDefault();
if (cloudCounter == null)
{
cloudCounter = new Counter {
Id = counterId
};
TableOperation insertOperation = TableOperation.InsertOrReplace(cloudCounter);
cloudCounter.PartitionKey = "counter";
cloudCounter.RowKey = cloudCounter.Id.ToString();
TableResult tableResult = await cloudTable.ExecuteAsync(insertOperation);
return(await GetOrCreateCounter(cloudTable, counterId));
}
return(cloudCounter);
}
public async Task <TUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)
{
TableQuerySegment <TUser> Segment = await _db.UserData.ExecuteQuerySegmentedAsync(new TableQuery <TUser>().Where($"Email eq '{normalizedEmail}'"), null);
if (Segment.Count() > 0)
{
return(Segment.FirstOrDefault());
}
return(null);
}
public async Task <AzureTableUser> FindByEmailAsync(string email)
{
AzureTableUser User = null;
TableQuerySegment <UserDataEntity> Segment = await UserTable.ExecuteQuerySegmentedAsync(new TableQuery <UserDataEntity>().Where($"Email eq '{email}'").Take(1), null);
if (Segment.Count() > 0)
{
User = Segment.FirstOrDefault().ToUser();
}
return(User);
}
public static async Task <String> isLogin(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage request,
ILogger log)
{
log.LogInformation("is login.");
String result = "false";
CloudTable table = null;
try
{
StorageCredentials creds = new StorageCredentials(Environment.GetEnvironmentVariable("accountName"), Environment.GetEnvironmentVariable("accountKey"));
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
CloudTableClient client = account.CreateCloudTableClient();
table = client.GetTableReference("Users");
await table.CreateIfNotExistsAsync();
Console.WriteLine(table.Uri.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
User userLoginRequest = await ExtractContent <User>(request);
TableQuery <User> idQuery = new TableQuery <User>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, userLoginRequest.PartitionKey));
TableQuerySegment <User> queryResult = await table.ExecuteQuerySegmentedAsync(idQuery, null);
User user = queryResult.FirstOrDefault();
if (user == null)
{
result = "false";
}
else
{
if (user.Password.Equals(userLoginRequest.Password))
{
result = user.UserType;
}
else
{
result = "false";
}
}
return(result);
}
private static async Task <Boolean> isIdInTable(CloudTable table, String colName, string platId)
{
TableQuery <PlateNumber> idQuery = new TableQuery <PlateNumber>()
.Where(TableQuery.GenerateFilterCondition(colName, QueryComparisons.Equal, platId));
TableQuerySegment <PlateNumber> queryResult = await table.ExecuteQuerySegmentedAsync(idQuery, null);
PlateNumber plateNumber = queryResult.FirstOrDefault();
if (plateNumber == null)
{
return(false);
}
ownerName = plateNumber.PartitionKey;
return(true);
}
async Task <LametricEntity> IAzureTableManager.GetRow(string email)
{
var table = await _getTableObject();
TableQuery <LametricEntity> query = new TableQuery <LametricEntity>().Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, email),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, email)));
TableContinuationToken token = null;
TableQuerySegment <LametricEntity> seg = await table.ExecuteQuerySegmentedAsync <LametricEntity>(query, token);
return(seg.FirstOrDefault());
}
public CategoryMessage RetriveCategoryMessage(string notifyTo, Category category)
{
string query = TableQuery.GenerateFilterCondition
(
"PartitionKey",
QueryComparisons.Equal,
CategoryMessageEntity.ToPartitionKey(notifyTo, category.GroupID, category.Name)
);
TableQuery <CategoryMessageEntity> tableQuery = new TableQuery <CategoryMessageEntity>().Where(query).Take(1);
TableQuerySegment <CategoryMessageEntity> queryResult = _categoryMsgTable.ExecuteQuerySegmented(tableQuery, null);
CategoryMessageEntity entity = queryResult.FirstOrDefault();
return(entity);
}
/// <summary>
/// Method that will get the open shift request ID using the open shift ID.
/// </summary>
/// <param name="openShiftId">The Open Shift ID.</param>
/// <param name="openShiftReqId">The open shift request id.</param>
/// <returns>A unit of execution that contains the Open Shift Request entity.</returns>
public async Task <AllOpenShiftRequestMappingEntity> GetOpenShiftRequestMappingEntityByOpenShiftIdAsync(string openShiftId, string openShiftReqId)
{
var provider = CultureInfo.InvariantCulture;
await this.EnsureInitializedAsync().ConfigureAwait(false);
this.telemetryClient.TrackTrace($"GetOpenShiftRequestMappingEntityByOpenShiftIdAsync started at: {DateTime.Now.ToString(provider)} - OpenShiftId: {openShiftId}");
var getEntitiesProps = new Dictionary <string, string>()
{
{ "CurrentCallingAssembly", Assembly.GetCallingAssembly().GetName().Name },
{ "CurrentExecutingAssembly", Assembly.GetExecutingAssembly().GetName().Name },
{ "CallingTimestamp", DateTime.UtcNow.ToString("O", provider) },
};
this.telemetryClient.TrackEvent("GetOpenShiftRequestMappingEntityByOpenShiftIdAsync", getEntitiesProps);
// Table query
TableQuery <AllOpenShiftRequestMappingEntity> query = new TableQuery <AllOpenShiftRequestMappingEntity>();
query.Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(
"RowKey",
QueryComparisons.Equal,
openShiftReqId), TableOperators.And,
TableQuery.GenerateFilterCondition(
"TeamsOpenShiftId",
QueryComparisons.Equal,
openShiftId)));
// Results list
List <AllOpenShiftRequestMappingEntity> results = new List <AllOpenShiftRequestMappingEntity>();
TableContinuationToken continuationToken = null;
TableQuerySegment <AllOpenShiftRequestMappingEntity> queryResults = await this.openShiftRequestMappingCloudTable.ExecuteQuerySegmentedAsync(query, continuationToken).ConfigureAwait(false);
this.telemetryClient.TrackTrace($"GetOpenShiftRequestMappingEntityByOpenShiftIdAsync ended at: {DateTime.Now.ToString(provider)} - OpenShiftId: {openShiftId}");
return(queryResults.FirstOrDefault());
}
internal static async Task <ExtendedUser> GetExtendedUser(string userId)
{
try
{
// reference track table
CloudTable table = tableClient.GetTableReference(ExtendedUsersTable);
await table.CreateIfNotExistsAsync();
// query tracks
TableQuery <ExtendedUser> rangeQuery = new TableQuery <ExtendedUser>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, userId));
TableContinuationToken token = null;
TableQuerySegment <ExtendedUser> tableQueryResult =
await table.ExecuteQuerySegmentedAsync(rangeQuery, token);
return(tableQueryResult.FirstOrDefault());
}
catch
{
throw;
}
}
public static async Task <SmokingDetector> GetDevice(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "GetDevice/{email}/{id}")] HttpRequestMessage request,
[Table("DetectorsEntities")] CloudTable ClientsTable,
string email, string id,
ILogger log)
{
log.LogInformation("GetDevice!\n");
string emailFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, email);
string idFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, id);
var combinedFilter = TableQuery.CombineFilters(emailFilter, TableOperators.And, idFilter);
var Query = new TableQuery <SmokingDetector>().Where(combinedFilter);
TableQuerySegment <SmokingDetector> queryResult = await ClientsTable.ExecuteQuerySegmentedAsync(Query, null);
SmokingDetector detector = queryResult.FirstOrDefault();
if (detector == null)
{
return(null);
}
return(detector);
}
public async Task <RotaItemDto> GetRotaItemForPersonAndDateAndRole(string name, string role, string rotaType, DateTime dateTime)
{
try
{
var nameFilter = TableQuery.GenerateFilterCondition("Name", QueryComparisons.Equal, name);
var typeFilter = TableQuery.GenerateFilterCondition("Type", QueryComparisons.Equal, rotaType);
var roleFilter = TableQuery.GenerateFilterCondition("Role", QueryComparisons.Equal, role);
var filter = TableQuery.CombineFilters(
roleFilter,
TableOperators.And,
TableQuery.CombineFilters(nameFilter, TableOperators.And, typeFilter));
TableQuery <RotaItemDto> query = new TableQuery <RotaItemDto>().Where(filter);
TableQuerySegment <RotaItemDto> results = await _table.ExecuteQuerySegmentedAsync(query, null);
return(results.FirstOrDefault(ri => ri.DateTime == dateTime.ToUniversalTime()));
}
catch (Exception e)
{
throw new Exception("Could not get rota for person and role", e);
}
}
public static async Task <int> GetNumberOfPlaces(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "get-places-number/")] HttpRequestMessage request,
ILogger log)
{
log.LogInformation("GetNumberOfPlaces");
//addition
CloudTable table = null;
CloudTableClient client = null;
try
{
StorageCredentials creds = new StorageCredentials(Environment.GetEnvironmentVariable("accountName"), Environment.GetEnvironmentVariable("accountKey"));
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
client = account.CreateCloudTableClient();
table = client.GetTableReference("Garage");
await table.CreateIfNotExistsAsync();
Console.WriteLine(table.Uri.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
/*get the avaliable places*/
TableQuery <availablePlaces> idQuery = new TableQuery <availablePlaces>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, "places"));
TableQuerySegment <availablePlaces> queryResult = await table.ExecuteQuerySegmentedAsync(idQuery, null);
availablePlaces places = queryResult.FirstOrDefault();
Console.Out.WriteLine("RowKey" + places.RowKey);
return(int.Parse(places.numOfPlaces));
}
public static async Task <status> GetIfIsOpen(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "get-isOpen/{id}/{state}")] HttpRequestMessage request,
string id,
string state,
[SignalR(HubName = "CounterHub")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
log.LogInformation("Getting if to open or not.");
//addition
CloudTable table = null;
CloudTableClient client = null;
try
{
StorageCredentials creds = new StorageCredentials(Environment.GetEnvironmentVariable("accountName"), Environment.GetEnvironmentVariable("accountKey"));
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
client = account.CreateCloudTableClient();
table = client.GetTableReference("Users");
await table.CreateIfNotExistsAsync();
Console.WriteLine(table.Uri.ToString());
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
status st = new status();
CloudTable garageTable = client.GetTableReference("Garage");
Boolean isInTheGarage = await isIdInTable(garageTable, "PartitionKey", id);
/*get the avaliable places*/
TableQuery <availablePlaces> idQuery = new TableQuery <availablePlaces>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, "places"));
TableQuerySegment <availablePlaces> queryResult = await garageTable.ExecuteQuerySegmentedAsync(idQuery, null);
availablePlaces places = queryResult.FirstOrDefault();
if (isInTheGarage && state.Equals("in"))
{
st.isOpen = "arleady in the Garage!";
return(st);
}
else if (!isInTheGarage && state.Equals("out"))
{
st.isOpen = "arleady out of the Garage!";
return(st);
}
else if (isInTheGarage && state.Equals("out"))
{
//remove car from garage
TableOperation retrieve = TableOperation.Retrieve <Request>(id, "car");
TableResult result = await garageTable.ExecuteAsync(retrieve);
var deleteEntity = (TableEntity)result.Result;
TableOperation delete = TableOperation.Delete(deleteEntity);
await garageTable.ExecuteAsync(delete);
st.isOpen = "open";
//add one to the avaliavle places
places.numOfPlaces = (int.Parse(places.numOfPlaces) + 1).ToString();
//signalR
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "placesUpdate",
Arguments = new [] { places.numOfPlaces }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "garageUpdate",
Arguments = new[] { (Object)id }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = ((Request)result.Result).UserName + "Notify",
Arguments = new[] { ((Request)result.Result).ownerName + " left the garage" }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "adminNotify",
Arguments = new[] { ((Request)result.Result).ownerName + " left the garage" }
});
TableOperation add = TableOperation.InsertOrReplace(places);
await garageTable.ExecuteAsync(add);
return(st);
}
//in
if (int.Parse(places.numOfPlaces) == 0)
{
st.isOpen = "don't open the Garage is FULL!";
return(st);
}
List <String> users = await GetUsersFromTable(table);
foreach (string regesterdUser in users)
{
CloudTable usersTable = client.GetTableReference("Table00" + regesterdUser);
await usersTable.CreateIfNotExistsAsync();
Boolean isIdRegestered = await isIdInTable(usersTable, "RowKey", id);
if (isIdRegestered)
{
//add to garage
Request newCar = new Request();
newCar.PartitionKey = id;
newCar.RowKey = "car";
newCar.ownerName = ownerName;
newCar.UserName = regesterdUser;
TableOperation add = TableOperation.InsertOrReplace(newCar);
await garageTable.ExecuteAsync(add);
st.isOpen = "open";
//update the avaliable places
places.numOfPlaces = (int.Parse(places.numOfPlaces) - 1).ToString();
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "placesUpdate",
Arguments = new[] { places.numOfPlaces }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "garageUpdate",
Arguments = new[] { (Object)id }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = regesterdUser + "Notify",
Arguments = new[] { ownerName + " entered the garage" }
});
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "adminNotify",
Arguments = new[] { ownerName + " entered the garage" }
});
TableOperation addOrReplace = TableOperation.InsertOrReplace(places);
await garageTable.ExecuteAsync(addOrReplace);
return(st);
}
}
st.isOpen = "don't open";
return(st);
}
public static async void Run(
[QueueTrigger(QueueName.UsersReadyForNotifications, Connection = CommonName.Connection)] UserProfile userProfile,
[Queue(QueueName.AddProductHistory)] IAsyncCollector <ProductInfo> addProductHistoryMessageQueue,
[Queue(QueueName.ProductUpdateEmailNotifications)] IAsyncCollector <EmailMessage> emailMessageQueue,
[Queue(QueueName.EmailsToSend)] IAsyncCollector <SendGridMessage> sendGridMessageQueue,
IBinder binder,
ILogger log)
{
log.LogInformation($"C# Queue trigger function processed: {userProfile.FirstName}");
CloudTable productInfoTable = await binder.BindAsync <CloudTable>(new TableAttribute(TableName.ProductInfo, userProfile.UserId)
{
Connection = CommonName.Connection
});
CloudTable scrapeConfigTable = await binder.BindAsync <CloudTable>(new TableAttribute(TableName.ScrapeConfig)
{
Connection = CommonName.Connection
});
TableQuery <ProductInfo> productQuery = new TableQuery <ProductInfo>();
TableQuerySegment <ProductInfo> userProducts = await productInfoTable.ExecuteQuerySegmentedAsync(productQuery, null);
//Load all configs in the begginign/maybe this should be changed in the future
TableQuery <ScrapeConfig> configsQuery = new TableQuery <ScrapeConfig>();
TableQuerySegment <ScrapeConfig> allConfigs = await scrapeConfigTable.ExecuteQuerySegmentedAsync(configsQuery, null);
EmailMessage emailMessage;
StringBuilder emailBodyBuilder = new StringBuilder();
log.LogInformation($"userProducts: {userProducts.Results.Count}");
foreach (ProductInfo product in userProducts)
{
//Find config from allConfigs
ScrapeConfig config = allConfigs.FirstOrDefault(t => t.PartitionKey.Equals(product.URL.ToCoreUrl()));
if (config != null)
{
log.LogInformation($"ScrapeConfig : {config.Name}");
Utils utils = new Utils();
try
{
await utils.Scrape(config, product, log);
}
catch (Exception ex)
{
string errorMsg = ex.Message;
while (ex.InnerException != null)
{
errorMsg += Environment.NewLine + ex.InnerException.Message;
ex = ex.InnerException;
}
var error = $"Error while trying to scrape product = {product.Name}, URL={product.URL}. Error: {ex.Message}";
log.LogError(error);
SendGridMessage message = new SendGridMessage();
message.AddTo("*****@*****.**");
message.AddContent("text/html", error);
message.SetFrom(new EmailAddress("*****@*****.**"));
message.SetSubject("Product scrape exception");
await sendGridMessageQueue.AddAsync(message);
}
if (product.HasChangesSinceLastTime)
{
var productUpdateLine = utils.CreateProductEmailLine(product);
emailBodyBuilder.AppendLine(productUpdateLine);
emailBodyBuilder.AppendLine("<br>");
//Add to history queue
await addProductHistoryMessageQueue.AddAsync(product);
}
//Update product in db
TableOperation operation = TableOperation.InsertOrReplace(product);
await productInfoTable.ExecuteAsync(operation);
}
else
{
log.LogInformation($"Multiple scrape config matches the criteria URL={product.URL}");
}
}
if (emailBodyBuilder.Length > 0)
{
emailBodyBuilder.AppendLine();
emailBodyBuilder.AppendLine("<br>");
emailBodyBuilder.AppendLine("<br>");
emailBodyBuilder.AppendLine("<a href='https://product-scrape.azurewebsites.net/Products'>Here you can see the list of your products</a>");
emailMessage = new EmailMessage
{
UserId = userProfile.UserId,
Subject = "Products updates",
Content = emailBodyBuilder.ToString()
};
log.LogInformation($"EmailMessage Product updates");
await emailMessageQueue.AddAsync(emailMessage);
}
else if (userProfile.SendEmailWhenNoProductHasBeenChanged)
{
log.LogInformation($"EmailMessage No Product update");
emailMessage = new EmailMessage
{
UserId = userProfile.UserId,
Subject = "Products updates",
Content = "None of your products has been updated/changed since last check."
};
await emailMessageQueue.AddAsync(emailMessage);
}
}