private ODMWorkspaceManager(string storageName, string storageKey, string dbEndpoint, string dbPrimaryKey, string dbName, string sourceSystem, string cvKey, string cvEndpoint, string cvTrainingKey, string cvTrainingEndpoint, string cvPredectionKey, string cvPredectionEndpoint)
{
cognitiveHelper = new CognitiveServicesHelper(cvKey, cvEndpoint, cvTrainingKey, cvTrainingEndpoint, cvPredectionKey, cvPredectionEndpoint);
workspaceRepo = new CosmosDBRepository <ODMWorkspace>(dbEndpoint, dbPrimaryKey, dbName, sourceSystem);
blobStorageName = storageName;
blobStorageKey = storageKey;
}
public async Task TestEditUserTemplate()
{
await TestAddTemplate();
ICosmosDBRepository <Template> _RepoTemplate = new CosmosDBRepository <Template>(endpoint, authkey, database, colTemplate);
ICosmosDBRepository <Category> _RepoCategory = new CosmosDBRepository <Category>(endpoint, authkey, database, colTemplate);
IUserProfileService _UserProfileProvider = new MockUserProfileService(graphUri, clientId2, appKey, AADInstance);
ILogger <TemplateApiController> _logger = new LoggerFactory().CreateLogger <TemplateApiController>();
TemplateApiController templateApiController = new TemplateApiController(_RepoTemplate, _RepoCategory, _UserProfileProvider, _logger);
var actionGetTemplatesResult = await templateApiController.GetUserTemplates();
actionGetTemplatesResult.AssertOkValueType <IEnumerable <Template> >();
var userTemplates = actionGetTemplatesResult.OkayContent <IEnumerable <Template> >();
IEnumerator enumerator = userTemplates.GetEnumerator();
enumerator.MoveNext();
Template toEdit = (Template)enumerator.Current;
toEdit.Name = "New Name";
var actionResult = await templateApiController.EditUserTemplate(toEdit);
actionResult.AssertOkValueType <bool>();
var result = actionResult.OkayContent <bool>();
Assert.True(result);
}
public async Task EditAsync([FromBody] Book book)
{
if (ModelState.IsValid)
{
await CosmosDBRepository <Book> .UpdateItemAsync(book.Id, book, CollectionId);
}
}
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
Configuration = configuration;
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
_doctorContext = new CosmosDBRepository <Doctor>(Configuration.GetValue <string>(
"DoctorCollection:AccountEndpoint"), Configuration.GetValue <string>(
"DoctorCollection:AccountKey"), Configuration.GetValue <string>(
"DoctorCollection:Database"), Configuration.GetValue <string>(
"DoctorCollection:Collection"), Configuration.GetValue <string>(
"DoctorCollection:PartitionKey"));
_patientContext = new CosmosDBRepository <Patient>(Configuration.GetValue <string>(
"PatientCollection:AccountEndpoint"), Configuration.GetValue <string>(
"PatientCollection:AccountKey"), Configuration.GetValue <string>(
"PatientCollection:Database"), Configuration.GetValue <string>(
"PatientCollection:Collection"), Configuration.GetValue <string>(
"PatientCollection:PartitionKey"));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
// Add framework services.
services.AddMvc();
var dbrepository = new CosmosDBRepository <Tweet>();
services.AddSingleton(dbrepository);
}
public static async Task <bool> IsEmployeeExists(string empNum, CosmosDBRepository <User> client)
{
var results = await client.GetItemsAsync((u) => u.AccountId == empNum && u.AccountType == "Employee" && u.IsActive);
if (results.Count() > 0)
{
return(true);
}
return(false);
}
public static async Task <User> GetEmployeeById(string empId, CosmosDBRepository <User> client)
{
var results = await client.GetItemsAsync((u) => u.Id == empId && u.AccountType == "Employee" && u.IsActive);
if (results.Count() > 0)
{
return(results.ElementAt(0));
}
return(null);
}
public static async Task UpdateDocument(NewRequest <SmartDoc> newDocReq, CosmosDBRepository <SmartDoc> client)
{
//foreach (var step in newDocReq.RequestItem.CognitivePipelineActions)
//{
// if (newDocReq.RequestItem.CognitivePipelineActions == null)
// newDocReq.RequestItem.CognitivePipelineActions = new List<ProcessingStep>();
// newDocReq.RequestItem.CognitivePipelineActions.Add(step);
//}
await client.UpdateItemAsync(newDocReq.ItemReferenceId, newDocReq.RequestItem);
}
public async Task TestGetCategories()
{
ICosmosDBRepository <Template> _RepoTemplate = new CosmosDBRepository <Template>(endpoint, authkey, database, colTemplate);
ICosmosDBRepository <Category> _RepoCategory = new CosmosDBRepository <Category>(endpoint, authkey, database, colTemplate);
IUserProfileService _UserProfileProvider = new MockUserProfileService(graphUri, clientId2, appKey, AADInstance);
ILogger <TemplateApiController> _logger = new LoggerFactory().CreateLogger <TemplateApiController>();
TemplateApiController templateApiController = new TemplateApiController(_RepoTemplate, _RepoCategory, _UserProfileProvider, _logger);
var actionResult = await templateApiController.GetCategories();
actionResult.AssertOkValueType <IEnumerable <Category> >();
}
public async Task <bool> Remove(string username)
{
var user = await CosmosDBRepository <User> .GetSingleItemAsync(x => x.Username == username);
if (user != null)
{
await CosmosDBRepository <User> .DeleteItemAsync(user.Id.ToString());
return(true);
}
return(false);
}
public async Task <bool> UserExists(string username)
{
//if (await _context.Users.AnyAsync(x => x.Username == username))
// return true;
var user = await CosmosDBRepository <User> .GetSingleItemAsync(x => x.Username == username);
if (user != null)
{
return(true);
}
return(false);
}
public async Task <User> Register(User user, string password)
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
//await _context.Users.AddAsync(user);
//await _context.SaveChangesAsync();
await CosmosDBRepository <User> .CreateItemAsync(user);
return(user);
}
public async Task <User> Login(string username, string password)
{
//var user = await _context.Users.FirstOrDefaultAsync(x => x.Username == username);
var user = await CosmosDBRepository <User> .GetSingleItemAsync(x => x.Username == username);
if (user == null)
{
return(null);
}
if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
{
return(null);
}
return(user);
}
/// <summary>
/// Creates a CosmosDB user if the user doesn't already exist.
/// </summary>
/// <param name="userId"></param>
/// <param name="documentClient"></param>
/// <returns></returns>
private static async Task <User> CreateUserIfNotExistAsync(string userId, CosmosDBRepository repo)
{
User cosmosDBUser = null;
try
{
cosmosDBUser = await repo.GetUserAsync(userId);
}
catch (DocumentClientException e)
{
if (e.StatusCode == System.Net.HttpStatusCode.NotFound)
{
cosmosDBUser = await repo.UpsertUserAsync(new User { Id = userId });
}
}
return(cosmosDBUser);
}
public async Task TestGetTemplateById()
{
ICosmosDBRepository <Template> _RepoTemplate = new CosmosDBRepository <Template>(endpoint, authkey, database, colTemplate);
ICosmosDBRepository <Category> _RepoCategory = new CosmosDBRepository <Category>(endpoint, authkey, database, colTemplate);
IUserProfileService _UserProfileProvider = new MockUserProfileService(graphUri, clientId2, appKey, AADInstance);
ILogger <TemplateApiController> _logger = new LoggerFactory().CreateLogger <TemplateApiController>();
TemplateApiController templateApiController = new TemplateApiController(_RepoTemplate, _RepoCategory, _UserProfileProvider, _logger);
var actionResult = await templateApiController.GetTemplateById("refrigerator_smart");
actionResult.AssertOkValueType <Template>();
var result = actionResult.OkayContent <Template>();;
Assert.Equal("refrigerator_smart", result.Id);
Assert.Equal(TemplateDocumentType.CommonTemplate, result.DocType);
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseResponseCompression();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMvc(routes =>
{
routes.MapRoute(name: "default", template: "{controller}/{action}/{id?}");
});
CosmosDBRepository <Book> .Initialize();
app.UseBlazor <Client.Program>();
}
public static async Task <string> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req,
ILogger log)
{
// Get CosmosDB Connection
var Repository = new CosmosDBRepository("VMManagement", "VM_Power_State", log);
log.LogInformation("RUN-MESSAGE 1 (GW 1103): Got CosmosDB Connection");
// Get CosmosDB Data
var CosmosItems = await Repository.GetItemsAsync();
log.LogInformation("RUN-MESSAGE 2: Got CosmosDB Items", CosmosItems);
var jsonCosmosItems = JsonConvert.SerializeObject(CosmosItems, Formatting.Indented);
return(jsonCosmosItems);
}
public async Task TestDeleteCommonTemplate()
{
ICosmosDBRepository <Template> _RepoTemplate = new CosmosDBRepository <Template>(endpoint, authkey, database, colTemplate);
ICosmosDBRepository <Category> _RepoCategory = new CosmosDBRepository <Category>(endpoint, authkey, database, colTemplate);
IUserProfileService _UserProfileProvider = new MockUserProfileService(graphUri, clientId2, appKey, AADInstance);
ILogger <TemplateApiController> _logger = new LoggerFactory().CreateLogger <TemplateApiController>();
TemplateApiController templateApiController = new TemplateApiController(_RepoTemplate, _RepoCategory, _UserProfileProvider, _logger);
var actionResult = await templateApiController.GetTemplateById("refrigerator_smart");
actionResult.AssertOkValueType <Template>();
var toDelete = actionResult.OkayContent <Template>();
var actionResult2 = await templateApiController.DeleteUserTemplate(toDelete.Id); //Should fail because you can't delete a common template
Assert.IsAssignableFrom <StatusCodeResult>(actionResult2);
}
public static async void Run([TimerTrigger("0/20 * * * * *")] TimerInfo myTimer, ILogger log)
{
try
{
// Get Connections
var Repository = new CosmosDBRepository("VMManagement", "VM_Power_State", log);
var Connection = new AzureConnection("11c4bafa-00bb-43f4-a42d-ed6f2663fbaf",
"92c95553-455f-4b53-8bcf-e2dfe4dbcb0b",
"A4LbQRKmqT:2x4Iu/h=yM=pDBuu9VVA1",
log);
log.LogInformation("RUN-MESSAGE 1 (AW 0903): Got Connections");
// Get Data
var CosmosItems = await Repository.GetItemsAsync();
log.LogInformation($"RUN-MESSAGE 2: Got {CosmosItems.Count} items from CosmosDB.");
var AzureMachines = Connection.VirtualMachines;
log.LogInformation($"RUN-MESSAGE 3: Got {AzureMachines.Count} items from Azure VMs.");
// Check if any data needs updating
var toBeUpdated = CompareItems(CosmosItems, AzureMachines, log);
if (toBeUpdated.Any())
{
log.LogInformation($"RUN-MESSAGE 5: Got {toBeUpdated.Count} items to be updated.");
foreach (var cosmosItem in toBeUpdated)
{
// Update any data requiring updates
await Repository.UpdateItemAsync(cosmosItem);
}
}
}
catch (Exception ex)
{
log.LogError(ex, $"ERROR-RUN in Function. Message: {ex.Message}; InnerException: {ex.InnerException}");
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler(builder => {
builder.Run(async context => {
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
var error = context.Features.Get <IExceptionHandlerFeature>();
if (error != null)
{
context.Response.AddApplicationError(error.Error.Message);
await context.Response.WriteAsync(error.Error.Message);
}
});
});
//app.UseHsts();
}
env.ConfigureNLog("nlog.config");
//add NLog to ASP.NET Core
loggerFactory.AddNLog();
loggerFactory.AddProvider(new NLogLoggerProvider());
app.UseCors(builder => builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
// app.UseCors(options => options.WithOrigins("http://localhost:4200").AllowAnyMethod());
//app.UseHttpsRedirection();
app.UseAuthentication();
app.UseMvc();
CosmosDBRepository <User> .Initialize();
}
public async Task TestAddTemplate()
{
ICosmosDBRepository <Template> _RepoTemplate = new CosmosDBRepository <Template>(endpoint, authkey, database, colTemplate);
ICosmosDBRepository <Category> _RepoCategory = new CosmosDBRepository <Category>(endpoint, authkey, database, colTemplate);
IUserProfileService _UserProfileProvider = new MockUserProfileService(graphUri, clientId2, appKey, AADInstance);
ILogger <TemplateApiController> _logger = new LoggerFactory().CreateLogger <TemplateApiController>();
ILogger <UserApiController> _logger1 = new LoggerFactory().CreateLogger <UserApiController>();
TemplateApiController templateApiController = new TemplateApiController(_RepoTemplate, _RepoCategory, _UserProfileProvider, _logger);
UserApiController userApiController = new UserApiController(_UserProfileProvider, _logger1);
var actionUserResult = await userApiController.GetCurrentUser();
var userResult = actionUserResult.OkayContent <User>();
var actionResult = await templateApiController.CreateUserTemplate(new Template()
{
Name = "TemplateTest"
});
actionResult.AssertOkValueType <string>();
string templateId = actionResult.OkayContent <string>();
Assert.NotNull(templateId);
var actionResult2 = await templateApiController.GetTemplateById(templateId);
actionResult2.AssertOkValueType <Template>();
var result2 = actionResult2.OkayContent <Template>();;
Assert.Equal(templateId, result2.Id);
Assert.Equal(TemplateDocumentType.User, result2.DocType);
Assert.Equal(userResult.Id.ToLower(), result2.UserId);
}
public async Task <IEnumerable <Book> > Get()
{
var result = await CosmosDBRepository <Book> .GetItemsAsync(CollectionId);
return(result);
}
public async Task DeleteConfirmedAsync(string id)
{
await CosmosDBRepository <Book> .DeleteItemAsync(id, CollectionId);
}
public TweetsController(CosmosDBRepository <Tweet> repository)
{
this.repository = repository;
this.context = new TweetQueryContext();
}
public static async Task <string> ProcessFinalResult(NewRequest <SmartDoc> processedReq, CosmosDBRepository <SmartDoc> smartDocsClient, CosmosDBRepository <User> usersClient)
{
string result = null;
if (processedReq.RequestItem.DocType == ClassificationType.ID)
{
var tempResult = CognitiveBusinessProcessor.ProcessEmployeeIdDocument(processedReq);
var isValid = await IsEmployeeExists(tempResult.EmployeeNum, usersClient);
tempResult.IsAuthenticationSuccessful = isValid;
tempResult.DetectionNotes += isValid ? ". Authentication Successful" : ". Authentication Failed";
tempResult.PrimaryClassification = InstructionFlag.AnalyzeText.ToString();
tempResult.PrimaryClassificationConfidence = 1;
result = JsonConvert.SerializeObject(tempResult);
//TODO: Future implementation to include face verification on the employee scanned id as well
}
else if (processedReq.RequestItem.DocType == ClassificationType.Face)
{
//This is when a user is using face authentication service
var tempResult = CognitiveBusinessProcessor.ProcessFaceAuthentication(processedReq);
if (tempResult.IsAuthenticationSuccessful)
{
var user = await GetEmployeeById(tempResult.DetectedFaceOwnerId, usersClient);
if (user != null)
{
tempResult.DetectedFaceName = user.DisplayName;
}
}
tempResult.PrimaryClassification = InstructionFlag.FaceAuthentication.ToString();
tempResult.PrimaryClassificationConfidence = tempResult.FaceDetails.Confidence;
result = JsonConvert.SerializeObject(tempResult);
}
else if (processedReq.RequestItem.DocType == ClassificationType.StoreShelf)
{
var threshold = double.Parse(GlobalSettings.GetKeyValue("CognitiveServices-ShelfCompliance-Threshold"));
var tempResult = CognitiveBusinessProcessor.ProcessShelfCompliance(processedReq, threshold);
processedReq.RequestItem.PrimaryClassification = InstructionFlag.ShelfCompliance.ToString();
processedReq.RequestItem.PrimaryClassificationConfidence = tempResult.Confidence;
result = JsonConvert.SerializeObject(tempResult);
}
else
{
if (processedReq.RequestItem.CognitivePipelineActions.Count > 0)
{
var step = processedReq.RequestItem.CognitivePipelineActions[0];
processedReq.RequestItem.PrimaryClassification = step.StepName;
processedReq.RequestItem.PrimaryClassificationConfidence = 1;
}
result = JsonConvert.SerializeObject(processedReq);
}
await UpdateDocument(processedReq, smartDocsClient);
return(result);
}
public GetClientSettings(ILogger <GetClientSettings> logger, IConfiguration config, CosmosDBRepository <ClientSettings> cosmosRepository)
{
_logger = logger;
_config = config;
_cosmosRepository = cosmosRepository;
}
public async Task <Book> Details(string id)
{
var result = await CosmosDBRepository <Book> .GetSingleItemAsync(id, CollectionId);
return(result);
}
private static async Task <PermissionToken> GetPermissionAsync(string userId, CosmosDBRepository repo, string permissionId, PermissionMode permissionMode = PermissionMode.Read)
{
Permission permission = null;
User user = await CreateUserIfNotExistAsync(userId, repo);
try
{
permission = await repo.GetPermissionAsync(user, permissionId, new RequestOptions { ResourceTokenExpirySeconds = (int)TOKEN_EXPIRY.TotalSeconds });
System.Diagnostics.Debug.WriteLine($"Retreived Existing Permission. {permission.Id}");
}
catch (DocumentClientException e)
{
if (e.StatusCode == System.Net.HttpStatusCode.NotFound)
{
DocumentCollection collection = await repo.GetDocumentCollectionAsync();
permission = new Permission
{
PermissionMode = permissionMode,
ResourceLink = collection.SelfLink,
// Permission restricts access to this partition key
ResourcePartitionKey = new PartitionKey(userId),
// Unique per user
Id = permissionId
};
try
{
permission = await repo.UpsertPermissionAsync(user, permission, new RequestOptions { ResourceTokenExpirySeconds = (int)TOKEN_EXPIRY.TotalSeconds });
}
catch (Exception ex)
{
throw ex;
}
}
else
{
throw e;
}
}
var expires = DateTimeOffset.Now.Add(TOKEN_EXPIRY).ToUnixTimeSeconds();
return(new PermissionToken()
{
Token = permission.Token,
Expires = expires,
UserId = userId
});
}
private static async Task <PermissionToken> GetPermissionToken(string userId, CosmosDBRepository repo, PermissionMode permissionMode)
{
string permissionDocumentId = $"{userId}_{COLLECTION}Collection_PermissionId";
PermissionToken permissionToken = null;
permissionToken = await GetPermissionAsync(userId, repo, permissionDocumentId, PermissionMode.All);
return(permissionToken);
}
