public async Task UploadMetadataWithEmptyDescription()
{
string url = ApiPaths.ALGO_STORE_METADATA;
MetaDataDTO metadata = new MetaDataDTO()
{
Name = Helpers.RandomString(8),
Description = ""
};
var response = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(metadata), Method.POST);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.OK));
MetaDataResponseDTO responceMetaData = JsonUtils.DeserializeJson <MetaDataResponseDTO>(response.ResponseJson);
DataManager.addSingleMetadata(responceMetaData);
Assert.AreEqual(metadata.Name, responceMetaData.Name);
Assert.AreEqual(metadata.Description, responceMetaData.Description);
Assert.NotNull(responceMetaData.Date);
Assert.NotNull(responceMetaData.Id);
Assert.Null(responceMetaData.Status);
MetaDataEntity metaDataEntity = await MetaDataRepository.TryGetAsync(t => t.Id == responceMetaData.Id) as MetaDataEntity;
Assert.NotNull(metaDataEntity);
Assert.AreEqual(metaDataEntity.Id, responceMetaData.Id);
Assert.AreEqual(metaDataEntity.Name, responceMetaData.Name);
Assert.AreEqual(metaDataEntity.Description, responceMetaData.Description);
}
public async Task DeleteMetadataWithUpoadAlgoBinary()
{
MetaDataResponseDTO temporaryResponseDTO = DataManager.getMetadataForDelete();
CascadeDeleteDTO editMetaData = new CascadeDeleteDTO()
{
Id = temporaryResponseDTO.Id,
Name = temporaryResponseDTO.Name
};
string url = ApiPaths.ALGO_STORE_UPLOAD_BINARY;
string AlgoId = editMetaData.Id;
Dictionary <string, string> quaryParam = new Dictionary <string, string>()
{
{ "AlgoId", AlgoId }
};
var responceAllClientMetadata = await this.Consumer.ExecuteRequestFileUpload(url, quaryParam, null, Method.POST, pathFile);
Assert.That(responceAllClientMetadata.Status, Is.EqualTo(HttpStatusCode.NoContent));
bool blobExists = await this.BlobRepository.CheckIfBlobExists(AlgoId, BinaryAlgoFileType.JAR);
Assert.That(blobExists, Is.EqualTo(true));
url = ApiPaths.ALGO_STORE_CASCADE_DELETE;
var responceCascadeDelete = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responceCascadeDelete.Status, Is.EqualTo(HttpStatusCode.NoContent));
MetaDataEntity metaDataEntityDeleted = await MetaDataRepository.TryGetAsync(t => t.Id == editMetaData.Id) as MetaDataEntity;
Assert.Null(metaDataEntityDeleted);
}
public void StoreMetaDataItemChangeFilePathChangePositiv()
{
this.CleanUpTestFolder();
//arrange
var metaDataMock = new MetadataItem();
var sut = new MetaDataRepository(FOLDER_PATH);
this.valuta = new DateTime(2018, 09, 20);
metaDataMock.FilePath = SOURCE_PATH;
metaDataMock.ValutaDatum = this.valuta;
metaDataMock.Guid = Guid.NewGuid();
//act
sut.StoreMetaDataItem(metaDataMock);
//assert
Assert.That(sut.FolderPath != null);
Assert.That(metaDataMock.FilePath != metaDataMock.NewFilePath);
this.CleanUpTestFolder();
}
public void SearchMetaDataItemsAndAddToListAddedListItemsReturnList()
{
this.CleanUpTestFolder();
//arrange
var metaDataMock = new MetadataItem();
var sut = new MetaDataRepository(FOLDER_PATH);
this.valuta = new DateTime(2018, 09, 20);
metaDataMock.FilePath = SOURCE_PATH;
metaDataMock.ValutaDatum = this.valuta;
metaDataMock.Guid = Guid.NewGuid();
metaDataMock.Benutzer = "Fer";
metaDataMock.Bezeichnung = "Hallo";
metaDataMock.Typ = "Verträge";
//act
sut.StoreMetaDataItem(metaDataMock);
ObservableCollection <MetadataItem> liste = sut.SearchMetaDataItemsAndAddToList();
//assert
Assert.That(liste.Count == 1);
this.CleanUpTestFolder();
}
public async Task EditMetadata()
{
string url = ApiPaths.ALGO_STORE_METADATA;
MetaDataResponseDTO temporaryResponseDTO = DataManager.getMetadataForEdit();
MetaDataEditDTO editMetaData = new MetaDataEditDTO()
{
Id = temporaryResponseDTO.Id,
Name = Helpers.RandomString(9),
Description = Helpers.RandomString(9)
};
temporaryResponseDTO.Name = editMetaData.Name;
temporaryResponseDTO.Description = editMetaData.Description;
var responseMetaDataAfterEdit = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responseMetaDataAfterEdit.Status, Is.EqualTo(HttpStatusCode.OK));
MetaDataResponseDTO responceMetaDataAfterEdit = JsonUtils.DeserializeJson <MetaDataResponseDTO>(responseMetaDataAfterEdit.ResponseJson);
Assert.AreEqual(responceMetaDataAfterEdit.Name, editMetaData.Name);
Assert.AreEqual(responceMetaDataAfterEdit.Description, editMetaData.Description);
Assert.NotNull(responceMetaDataAfterEdit.Date);
Assert.NotNull(responceMetaDataAfterEdit.Id);
Assert.Null(responceMetaDataAfterEdit.Status);
MetaDataEntity metaDataEntity = await MetaDataRepository.TryGetAsync(t => t.Id == responceMetaDataAfterEdit.Id) as MetaDataEntity;
Assert.NotNull(metaDataEntity);
Assert.AreEqual(metaDataEntity.Id, responceMetaDataAfterEdit.Id);
Assert.AreEqual(metaDataEntity.Name, responceMetaDataAfterEdit.Name);
Assert.AreEqual(metaDataEntity.Description, responceMetaDataAfterEdit.Description);
}
public static void Main()
{
var exe = Assembly.GetExecutingAssembly().Location;
var folder = Path.GetDirectoryName(exe);
if (folder != null)
{
var databaseName = ConfigurationManager.AppSettings["DatabaseName"];
var outputPath = ConfigurationManager.AppSettings["OutputPath"];
var connectionString = ConfigurationManager.ConnectionStrings["ConnectionStrings"].ConnectionString;
var repo = new MetaDataRepository(connectionString);
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
var sw = Stopwatch.StartNew();
var generator = new Generator(databaseName, outputPath, repo)
{
EntityBaseClassName = "IEntity", PkPropertyName = "Id"
};
generator.Run();
sw.Stop();
Console.WriteLine($"Code generated in {sw.ElapsedMilliseconds} ms in folder: {outputPath}");
Console.ReadKey();
}
}
public SearchView()
{
InitializeComponent();
var repo = new MetaDataRepository(ConfigurationManager.AppSettings["RepositoryDir"]);
var service = new MetaDataService(repo);
DataContext = new SearchViewModel(service);
}
public void MetaDataRepositoryConstructorTest()
{
MetaDataRepository target = new MetaDataRepository("name");
Assert.IsNotNull(target.ListOfFactDimensions);
Assert.IsNotNull(target.ListOfEventDimensions);
Assert.IsNotNull(target.ListOfCaseTableColumnNames);
Assert.IsNotNull(target.ListOfEventsTableColumnNames);
}
/// <summary>
/// Builds the metadata-repository from the Database.
/// </summary>
/// <returns>True if the repository is built, false if the operation failed.</returns>
public static bool BuildMetadataRepository()
{
if (!IsOpen())
{
return(false);
}
MetaData = GetMetaData(SqlCreator.FactTableName, SqlCreator.EventTableName);
return(MetaData != null);
}
public async Task AddProviderDataSingle <T>(int providerID, List <T> data)
{
Stopwatch sw = Stopwatch.StartNew();
var type = data[0].GetType();
var properties = type.GetProperties();
MetaObject mo = new MetaObject("ProviderData", providerID.ToString());
for (int i = 0; i < data.Count; i++)
{
foreach (var prop in properties)
{
try
{
if (prop.GetIndexParameters().Length == 0)
{
Trace.TraceInformation(" {0} ({1}): {2}", prop.Name,
prop.PropertyType.Name,
prop.GetValue(data[0]));
var propType = prop.PropertyType;
var value = prop.GetValue(data[i]);
System.Reflection.MethodInfo returnResult =
typeof(MetaObject)
.GetMethods().Single(m => m.Name == "AddProperty" && m.IsGenericMethod && m.ContainsGenericParameters
)
.MakeGenericMethod(propType);
returnResult.Invoke(mo, new object[] { prop.Name, value });
}
else
{
Trace.TraceInformation(" {0} ({1}): <Indexed>", prop.Name,
prop.PropertyType.Name);
}
}
catch (Exception e)
{
Trace.TraceInformation(e.Message);
}
}
}
using (MetaDataRepository db = new MetaDataRepository())
{
await db.SaveMetaDataAsync(mo);
}
sw.Stop();
Trace.TraceInformation("AddMetaIdeas took {0} ms.", sw.Elapsed.TotalMilliseconds);
}
public async Task DeleteMetadataOnlyWithIdParam()
{
MetaDataResponseDTO temporaryResponseDTO = DataManager.getMetadataForDelete();
CascadeDeleteDTO editMetaData = new CascadeDeleteDTO()
{
Id = temporaryResponseDTO.Id,
Name = "This Name Is Invalid"
};
string url = ApiPaths.ALGO_STORE_CASCADE_DELETE;
var responceCascadeDelete = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responceCascadeDelete.Status, Is.EqualTo(HttpStatusCode.NoContent));
MetaDataEntity metaDataEntityDeleted = await MetaDataRepository.TryGetAsync(t => t.Id == editMetaData.Id) as MetaDataEntity;
Assert.Null(metaDataEntityDeleted);
}
protected void Page_Init(object sender, EventArgs e)
{
MetaDataRepository metaDataRepository = new MetaDataRepository();
if (!Request.RawUrl.ToLower().Contains("online-payment") && Request.Url.ToString().ToLower().Contains("https"))
{
string oldUrl = "http://www.ameexusa.com" + Request.RawUrl;
Response.Redirect(oldUrl);
}
else if (Request.RawUrl.ToLower().Contains("online-payment") && !Request.Url.ToString().ToLower().Contains("www"))
{
string oldUrl = "https://www.ameexusa.com" + Request.RawUrl;
Response.Redirect(oldUrl);
}
else if(!Request.Url.ToString().ToLower().Contains("www"))
{
string oldUrl = "http://www.ameexusa.com" + Request.RawUrl;
Response.Redirect(oldUrl);
}
long queryStringId = GeneralExtensions.GetQueryStringId();
if (queryStringId > 0)
{
hidContentId.Value = queryStringId.ToString();
if (queryStringId > 0) // Check whether it is Home page or not
{
generelMetaData = metaDataRepository.GetMetaDataForContent(queryStringId);
Page.Title = generelMetaData.PageTitle;
ltlMetaDescription.Text = "<meta name=\"description\" content=\"" + generelMetaData.Description + "\"/>";
ltlMetaKeywords.Text = "<meta name=\"keywords\" content=\"" + generelMetaData.Keywords + "\"/>";
}
else
{
generelMetaData = metaDataRepository.GetMetaDataForContent("HomePageId".GetAppKeyLong());
Page.Title = generelMetaData.PageTitle;
ltlMetaDescription.Text = "<meta name=\"description\" content=\"" + generelMetaData.Description + "\"/>";
ltlMetaKeywords.Text = "<meta name=\"keywords\" content=\"" + generelMetaData.Keywords + "\"/>";
}
}
//ltlCopyRight.Text = "CopyRightText".GetAppKeyString();
ltlCopyRight.Text = "Copyright © " + System.DateTime.Now.Year + ". Ameex Technologies Corp. All rights reserved.";
string httpOff = Request.ServerVariables["HTTPS"] == "off" ? "http" : "https";
uxCanonicalUrl.Text = "<link href=\"" + httpOff + "://" + Request.ServerVariables["SERVER_NAME"] + Request.RawUrl.ToString() + "\" rel=\"canonical\" />";
}
public async Task AddProviderDataString(int providerID, string tag, List <string> data)
{
Stopwatch sw = Stopwatch.StartNew();
var type = data[0].GetType();
var properties = type.GetProperties();
MetaObject mo = new MetaObject("ProviderData", providerID.ToString());
mo.AddProperty <List <string> >(tag, (List <string>)data);
using (MetaDataRepository db = new MetaDataRepository())
{
await db.SaveMetaDataAsync(mo);
}
sw.Stop();
Trace.TraceInformation("AddMetaIdeas took {0} ms.", sw.Elapsed.TotalMilliseconds);
}
public async Task ClientDataGetAllAlgos()
{
UploadStringDTO metadataForUploadedBinary = await UploadStringAlgo();
string algoID = metadataForUploadedBinary.AlgoId;
string url = ApiPaths.ALGO_STORE_ADD_TO_PUBLIC;
MetaDataEntity metaDataEntity = await MetaDataRepository.TryGetAsync(t => t.Id == algoID) as MetaDataEntity;
Assert.NotNull(metaDataEntity);
AddToPublicDTO addAlgo = new AddToPublicDTO()
{
AlgoId = algoID,
ClientId = metaDataEntity.PartitionKey
};
var addAlgoToPublicEndpoint = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(addAlgo), Method.POST);
Assert.That(addAlgoToPublicEndpoint.Status, Is.EqualTo(HttpStatusCode.OK));
url = ApiPaths.ALGO_STORE_CLIENT_DATA_GET_ALL_ALGOS;
var clientDataAllAlgos = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, null, Method.GET);
Assert.That(clientDataAllAlgos.Status, Is.EqualTo(HttpStatusCode.OK));
Object responceclientDataAllAlgos = JsonUtils.DeserializeJson(clientDataAllAlgos.ResponseJson);
List <AlgoDTO> listAllAlgos = Newtonsoft.Json.JsonConvert.DeserializeObject <List <AlgoDTO> >(responceclientDataAllAlgos.ToString());
AlgoDTO expectedAlgoDTO = listAllAlgos.FindLast(t => t.Id.Equals(algoID));
string AlgoIdFromGettAllAlgos = expectedAlgoDTO.Id;
Assert.That(algoID, Is.EqualTo(AlgoIdFromGettAllAlgos));
foreach (AlgoDTO algo in listAllAlgos)
{
Assert.Zero(expectedAlgoDTO.Rating);
Assert.NotZero(expectedAlgoDTO.UsersCount);
Assert.NotNull(expectedAlgoDTO.Id);
Assert.NotNull(expectedAlgoDTO.Name);
Assert.NotNull(expectedAlgoDTO.Description);
Assert.NotNull(expectedAlgoDTO.Date);
Assert.NotNull(expectedAlgoDTO.Author);
}
}
public async Task DeleteMetadataWithUpoadAlgoString()
{
MetaDataResponseDTO temporaryResponseDTO = DataManager.getMetadataForDelete();
CascadeDeleteDTO editMetaData = new CascadeDeleteDTO()
{
Id = temporaryResponseDTO.Id,
Name = temporaryResponseDTO.Name
};
string url = ApiPaths.ALGO_STORE_UPLOAD_STRING;
string Algoid = editMetaData.Id;
PostUploadStringAlgoDTO uploadedStringDTO = new PostUploadStringAlgoDTO()
{
AlgoId = Algoid,
Data = Helpers.RandomString(300)
};
var responceUploadString = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(uploadedStringDTO), Method.POST);
Assert.That(responceUploadString.Status, Is.EqualTo(HttpStatusCode.NoContent));
Dictionary <string, string> quaryParamGetString = new Dictionary <string, string>()
{
{ "AlgoId", Algoid }
};
var responceGetUploadString = await this.Consumer.ExecuteRequest(url, quaryParamGetString, null, Method.GET);
Assert.That(responceGetUploadString.Status, Is.EqualTo(HttpStatusCode.OK));
UploadStringDTO uploadedStringContent = JsonUtils.DeserializeJson <UploadStringDTO>(responceGetUploadString.ResponseJson);
Assert.That(uploadedStringDTO.Data, Is.EqualTo(uploadedStringContent.Data));
url = ApiPaths.ALGO_STORE_CASCADE_DELETE;
var responceCascadeDelete = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responceCascadeDelete.Status, Is.EqualTo(HttpStatusCode.NoContent));
MetaDataEntity metaDataEntityDeleted = await MetaDataRepository.TryGetAsync(t => t.Id == editMetaData.Id) as MetaDataEntity;
Assert.Null(metaDataEntityDeleted);
}
/// <summary>
/// Method to get a table containing all dimensions.
/// </summary>
/// <param name="factTableName"></param>
/// <param name="eventTableName"></param>
/// <returns>FactTable containing the dimensions</returns>
/// <author>Jannik Arndt, Bernd Nottbeck</author>
public virtual MetaDataRepository GetMetaData(string factTableName, string eventTableName)
{
MetaDataRepository table = new MetaDataRepository(factTableName);
table.ListOfCaseTableColumnNames.AddRange(GetColumnNamesOfTable(DBWorker.SqlCreator.CaseTableName));
table.ListOfEventsTableColumnNames.AddRange(GetColumnNamesOfTable(DBWorker.SqlCreator.EventTableName));
//Add dimensions from table fact
table.ListOfFactDimensions.Add(new Dimension("--no selection--", isEmptyDimension: true));
table.ListOfFactDimensions.AddRange(GetDimensionsOf(factTableName));
//Add dimensions from table event
table.ListOfEventDimensions.AddRange(GetDimensionsOf(eventTableName));
//Add logical all level for each dimension
AddAllLevel(table.ListOfFactDimensions);
AddAllLevel(table.ListOfEventDimensions);
return(table);
}
public async Task GetProviderData(int providerID, string tag)
{
Stopwatch sw = Stopwatch.StartNew();
int count = 0;
using (MetaDataRepository db = new MetaDataRepository())
{
var data = await db.GetMetaObjectsAsync("ProviderData", providerID.ToString(), tag);
count = data.Count;
foreach (var i in data)
{
var objects = i.GetPropertyValue <List <string> >(tag);
string d = "";
}
}
sw.Stop();
Trace.TraceInformation("{0} with P-{1} took {2} ms. Found {3} objects.", "random", "P-X Idea", sw.Elapsed.TotalMilliseconds, count);
}
public async Task AddMetaIdeas()
{
Stopwatch sw = Stopwatch.StartNew();
using (MetaDataRepository db = new MetaDataRepository())
{
MetaObject mo;
mo = new MetaObject("P-X Idea", Guid.NewGuid().ToString());
mo.AddProperty <string>("Name", string.Format("name-{0}", 1));
mo.AddProperty <string>("Description", string.Format("description-{0}", 1));
mo.AddProperty <string>("Submitter", string.Format("submitter-{0}", 1));
await db.SaveMetaDataAsync(mo);
}
sw.Stop();
Trace.TraceInformation("AddMetaIdeas took {0} ms.", sw.Elapsed.TotalMilliseconds);
}
//public static bool DeleteMetaDataXML(ConnectionParameters conParams)
//{
// String DBDatabaseWithoutPathName = conParams.Database.Substring(conParams.Database.LastIndexOf(("\\")) + 1);
// Path = AppDomain.CurrentDomain.BaseDirectory + @"\Metadata_" + DBDatabaseWithoutPathName + "@" + conParams.Host + ".xml";
// if (File.Exists(Path))
// {
// try
// {
// File.Delete(Path);
// }
// catch {
// return false;
// }
// }
// return true;
//}
/// <summary>
/// <summary>
/// Writes the content from the xml-file to the FactTable if the xml exists
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
public static bool SynchronizeFactTableWithXML(ConnectionParameters conParams)
{
try
{
//Databasename without Path and without backslashes. The SQLite-Databasename is the directory Path to the database.
String dbDatabaseWithoutPathName = conParams.Database.Substring(conParams.Database.LastIndexOf(("\\")) + 1);
Path = AppDomain.CurrentDomain.BaseDirectory + @"\Metadata_" + dbDatabaseWithoutPathName + "@" + conParams.Host + ".xml";
if (File.Exists(Path))
{
XmlMetadata = DeserializeObjectFromXML <MetaDataRepository>(Path);
if (XmlMetadata != null)
{
if (CompareXMLWithMetadata(DBWorker.MetaData, XmlMetadata))
{
DBWorker.MetaData.EventClassifier = XmlMetadata.EventClassifier;
for (int i = 0; i < DBWorker.MetaData.ListOfFactDimensions.Count; i++)
{
GetMetadataFromXMLAndWriteInFacttable(DBWorker.MetaData.ListOfFactDimensions[i], XmlMetadata.ListOfFactDimensions[i], true);
}
return(true);
}
}
}
}
catch (NullReferenceException ex)
{
ErrorHandling.ReportErrorToUser("Error synchronize facttable: " + ex.Message);
}
catch (Exception ex)
{
ErrorHandling.ReportErrorToUser("Error synchronize facttable: " + ex.Message);
}
return(false);
}
/// <summary>
/// Compares the structure of the facttable from the DatabaseConnection and the facttable from the xml
/// If the structure is the same, the function returns true
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
private static bool CompareXMLWithMetadata(MetaDataRepository ftMetaworker, MetaDataRepository ftXml)
{
if (ftMetaworker.ListOfEventsTableColumnNames.Contains(ftXml.EventClassifier) || (ftMetaworker.EventClassifier == ""))
{
if (ftMetaworker.ListOfFactDimensions.Count == ftXml.ListOfFactDimensions.Count)
{
for (int i = 0; i < ftMetaworker.ListOfFactDimensions.Count; i++)
{
if (CompareDimensions(ftMetaworker.ListOfFactDimensions[i], ftXml.ListOfFactDimensions[i]) == false)
{
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
return(false);
}
public async Task GetIdeas()
{
Stopwatch sw = Stopwatch.StartNew();
int count = 0;
using (MetaDataRepository db = new MetaDataRepository())
{
var data = await db.GetMetaObjectsAsync("P-X Idea");
count = data.Count;
foreach (var i in data)
{
//Trace.TraceInformation(i.ToString());
//Trace.TraceInformation("Decrypted: {0}", i.GetPropertyValue<string>("Name", decryptionKey: decryptionKey));
//Trace.TraceInformation("Decrypted: {0}", i.GetPropertyValue<string>("Description", decryptionKey: decryptionKey));
var name = i.GetPropertyValue <string>("Name");
var description = i.GetPropertyValue <string>("Description");
var submitter = i.GetPropertyValue <string>("Submitter");
Trace.TraceInformation($"Object on {i.Object} Name on {name}, Desc on {description}, submitter on {submitter}");
}
}
sw.Stop();
Trace.TraceInformation("{0} with P-{1} took {2} ms. Found {3} objects.", "random", "P-X Idea", sw.Elapsed.TotalMilliseconds, count);
}
public static void MyClassInitialize(TestContext testContext)
{
string testDbPath = AppDomain.CurrentDomain.BaseDirectory + @"\Files\test.sqlite.db";
// To enable tests in a virtual machine (change the letter accordingly)
if (!Char.IsLetter(testDbPath.First()))
{
testDbPath = "Z:" + testDbPath.Substring(10);
}
ConParams = new ConnectionParameters("SQLite", "SQLite Connection", "", testDbPath);
String dbDatabaseWithoutPathName = ConParams.Database.Substring(ConParams.Database.LastIndexOf(("\\"), StringComparison.Ordinal) + 1);
Path = AppDomain.CurrentDomain.BaseDirectory + @"\Metadata_" + dbDatabaseWithoutPathName + "@" + ConParams.Host + ".xml";
DBWorker.ConfigureDBConnection(ConParams);
DBWorker.OpenConnection();
DBWorker.BuildMetadataRepository();
XMLHelper.SerializeObjectToXML(Path, DBWorker.MetaData);
XmlMetadata = XMLHelper.DeserializeObjectFromXML <MetaDataRepository>(Path);
}
public async Task GetAlgoMetaData(string clientIdTemp)
{
List <BuilInitialDataObjectDTO> metadataForUploadedBinaryList = await UploadSomeBaseMetaData(1);
BuilInitialDataObjectDTO metadataForUploadedBinary = metadataForUploadedBinaryList[metadataForUploadedBinaryList.Count - 1];
MetaDataEntity metaDataEntity = await MetaDataRepository.TryGetAsync(t => t.Id == metadataForUploadedBinary.AlgoId) as MetaDataEntity;
if (clientIdTemp.Equals("getFromData"))
{
clientIdTemp = metaDataEntity.PartitionKey;
}
string url = ApiPaths.ALGO_STORE_GET_ALGO_METADATA;
Dictionary <string, string> quaryParamAlgoData = new Dictionary <string, string>()
{
{ "AlgoId", metadataForUploadedBinary.AlgoId },
{ "clientId", clientIdTemp }
};
var responceAlgoMetadata = await this.Consumer.ExecuteRequest(url, quaryParamAlgoData, null, Method.GET);
Assert.That(responceAlgoMetadata.Status, Is.EqualTo(HttpStatusCode.OK));
GetAlgoMetaDataDTO postInstanceData = JsonUtils.DeserializeJson <GetAlgoMetaDataDTO>(responceAlgoMetadata.ResponseJson);
Assert.That(postInstanceData.AlgoId, Is.EqualTo(metadataForUploadedBinary.AlgoId));
Assert.That(postInstanceData.Name, Is.EqualTo(metadataForUploadedBinary.Name));
Assert.That(postInstanceData.Description, Is.EqualTo(metadataForUploadedBinary.Description));
Assert.That(postInstanceData.Date, Is.Not.Null);
Assert.That(postInstanceData.Author, Is.Not.Null);
Assert.That(postInstanceData.Rating, Is.Zero);
Assert.That(postInstanceData.UsersCount, Is.Not.Zero);
Assert.That(postInstanceData.AlgoMetaDataInformation, Is.Null);
}
public async Task DeleteMetadataWithStartedAlgo()
{
MetaDataResponseDTO temporaryResponseDTO = DataManager.getMetadataForDelete();
CascadeDeleteDTO editMetaData = new CascadeDeleteDTO()
{
Id = temporaryResponseDTO.Id,
Name = temporaryResponseDTO.Name
};
string url = ApiPaths.ALGO_STORE_UPLOAD_BINARY;
string AlgoId = editMetaData.Id;
Dictionary <string, string> quaryParam = new Dictionary <string, string>()
{
{ "AlgoId", AlgoId }
};
var responceAllClientMetadata = await this.Consumer.ExecuteRequestFileUpload(url, quaryParam, null, Method.POST, pathFile);
Assert.That(responceAllClientMetadata.Status, Is.EqualTo(HttpStatusCode.NoContent));
bool blobExists = await this.BlobRepository.CheckIfBlobExists(AlgoId, BinaryAlgoFileType.JAR);
Assert.That(blobExists, Is.EqualTo(true));
DeployBinaryDTO algo = new DeployBinaryDTO()
{
AlgoId = AlgoId
};
url = ApiPaths.ALGO_STORE_DEPLOY_BINARY;
var uploadBinaryresponce = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(algo), Method.POST);
Assert.That(uploadBinaryresponce.Status, Is.EqualTo(HttpStatusCode.OK));
RuntimeDataEntity runtimeDataEntity = await RuntimeDataRepository.TryGetAsync(t => t.Id == AlgoId) as RuntimeDataEntity;
Assert.NotNull(runtimeDataEntity);
StartBinaryDTO startAlgo = new StartBinaryDTO
{
AlgoId = algo.AlgoId
};
url = ApiPaths.ALGO_STORE_ALGO_START;
var startBinaryresponce = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(startAlgo), Method.POST);
Assert.That(startBinaryresponce.Status, Is.EqualTo(HttpStatusCode.OK));
StartBinaryResponseDTO startResponse = JsonUtils.DeserializeJson <StartBinaryResponseDTO>(startBinaryresponce.ResponseJson);
Assert.That(startResponse.Status, Is.EqualTo(("STARTED")));
url = ApiPaths.ALGO_STORE_CASCADE_DELETE;
var responceCascadeDelete = await this.Consumer.ExecuteRequest(url, Helpers.EmptyDictionary, JsonUtils.SerializeObject(editMetaData), Method.POST);
Assert.That(responceCascadeDelete.Status, Is.EqualTo(HttpStatusCode.NoContent));
MetaDataEntity metaDataEntityDeleted = await MetaDataRepository.TryGetAsync(t => t.Id == editMetaData.Id) as MetaDataEntity;
Assert.Null(metaDataEntityDeleted);
}
public async void CognativeFace(string postID)
{
const string subscriptionKey = "54c11b3999a149e9b1a721961478aa81";
string Message = "This Post is Already Saved by Cognative Modiator/Vision/Face Api";
JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
PostRepository repositoryPost = new PostRepository();
Post post = repositoryPost.getPostByID(postID);
if (post != null)
{
MetaDataRepository repositoryMetaData = new MetaDataRepository();
MetaData metaData = repositoryMetaData.getMetaDataByPostID(post.Post_ID);
if (metaData == null)
{
HttpClient client = new HttpClient();
// Request headers.
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
// Request parameters. A third optional parameter is "details".
string requestParameters = "returnFaceId=true&returnFaceLandmarks=false&returnFaceAttributes=age,gender,headPose,smile,facialHair,glasses,emotion,hair,makeup,occlusion,accessories,blur,exposure,noise";
// Assemble the URI for the REST API Call.
string uri = "https://eastasia.api.cognitive.microsoft.com/face/v1.0/detect" + "?" + requestParameters;
HttpResponseMessage response;
byte[] byteData = CognativeService.GetImageAsByteArray(Server.MapPath("~/InstagramFiles/" + post.Post_FileName));
using (ByteArrayContent content = new ByteArrayContent(byteData))
{
// This example uses content type "application/octet-stream".
// The other content types you can use are "application/json" and "multipart/form-data".
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
// Execute the REST API call.
response = await client.PostAsync(uri, content);
// Get the JSON response.
string contentString = await response.Content.ReadAsStringAsync();
// Display the JSON response.
//divShowApiData.InnerHtml = CognativeService.JsonPrettyPrint(contentString);
//JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
List <RootObject> faceApiValue = (List <RootObject>)javaScriptSerializer.Deserialize(CognativeService.JsonPrettyPrint(contentString), typeof(List <RootObject>));
if (faceApiValue != null)
{
metaData.Post_ID = post.Post_ID;
metaData.Face_Gender = faceApiValue[0].faceAttributes.gender;
metaData.Face_Age = faceApiValue[0].faceAttributes.age;
if (faceApiValue[0].faceRectangle.width > 0)
{
metaData.Face_Rectangle = faceApiValue[0].faceRectangle.width + "," + faceApiValue[0].faceRectangle.height + " " + faceApiValue[0].faceRectangle + " " + faceApiValue[0].faceRectangle.left.ToString();
}
Message = "This Post is Saved now by Cognative Modiator/Vision/Face Api";
}
}
}
Context.Response.Clear();
Context.Response.ContentType = "application/json";
Context.Response.AddHeader("content-length", javaScriptSerializer.Serialize(Message).Length.ToString());
Context.Response.Flush();
Context.Response.Write(javaScriptSerializer.Serialize(Message));
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
}
public PhotoSearchController()
{
string path = "~/Shoots";
objData = new MetaDataRepository(path);
}
public IEnumerable <MetaData> GetMetaDatasByStorage(
[Service] MetaDataRepository repository,
int id) => repository.GetMetaDataByStorageId(id);
public MetaData GetMetaData(
int id,
[Service] MetaDataRepository repository) =>
repository.GetMetaData(id);
public Generator(string databaseName, string outputPath, MetaDataRepository repository)
{
_databaseName = databaseName;
_path = outputPath;
_repository = repository;
}
/// <summary>
/// the constructor creates a new instance of the controller
/// </summary>
public MetaDataController()
{
_Repo = new MetaDataRepository();
}
