public static void MetaDataService_DefaultProfilesIds(IWrapper wrapper)
{
var service = new MetaDataService(
wrapper.Pipeline.FlowElements
.Where(e => typeof(IOnPremiseDeviceDetectionEngine).IsAssignableFrom(e.GetType()))
.Cast <IOnPremiseDeviceDetectionEngine>()
.ToArray());
var defaultProfiles = service.DefaultProfilesIds();
// Expect 5 components:
// hardware, platform, browser, crawler and metrics.
// metrics does not actually exist in the data file and
// does not have a default profile so it will be null.
Assert.AreEqual(5, defaultProfiles.Count);
Assert.IsTrue(defaultProfiles.ContainsKey(1));
Assert.IsTrue(defaultProfiles.ContainsKey(2));
Assert.IsTrue(defaultProfiles.ContainsKey(3));
Assert.IsTrue(defaultProfiles.ContainsKey(4));
Assert.IsTrue(defaultProfiles.ContainsKey(255));
Assert.AreEqual((uint)15364, defaultProfiles[1]);
Assert.AreEqual((uint)17017, defaultProfiles[2]);
Assert.AreEqual((uint)17470, defaultProfiles[3]);
Assert.AreEqual((uint)18092, defaultProfiles[4]);
Assert.IsNull(defaultProfiles[255]);
}
/// <summary>
/// Main entry point. Creates a bunch of services, and then kicks off
/// the webserver, which is a blocking call (since it's the dispatcher
/// thread) until the app exits.
/// </summary>
/// <param name="listeningPort"></param>
/// <param name="args"></param>
private static void StartWebServer(int listeningPort, string[] args)
{
try
{
Logging.Log("Starting Damselfly Services");
// Instantiate all of our services
var status = new StatusService();
var thumbs = new ThumbnailService();
var indexing = new IndexingService();
var downloads = new DownloadService();
var basket = new BasketService();
var folder = new FolderService();
var search = new SearchService();
var tasks = new TaskService();
var config = new ConfigService();
var meta = new MetaDataService();
var wp = new WordpressService();
var proc = new ImageProcessService();
var select = new SelectionService();
Logging.Log("Starting Damselfly Webserver");
BuildWebHost(listeningPort, args).Run();
Logging.Log("Damselfly Webserver stopped. Exiting");
}
catch (Exception ex)
{
Logging.Log("Damselfly Webserver terminated with exception: {0}", ex.Message);
}
}
public List <MarketDataEntity.Output> MetadataRequest(string curveName, string provider)
{
var _cfg = _config(provider);
var mds = new MetaDataService(_cfg);
var filter = new ArtesianSearchFilter();
filter.SearchText = curveName;
filter.Page = 1;
filter.PageSize = 1;
try
{
return(mds.SearchFacetAsync(filter)
.ConfigureAwait(true)
.GetAwaiter()
.GetResult()
.Results);
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException);
}
return(null);
}
protected override void InitializeFieldValidators(IStringMetaField metaField)
{
base.InitializeFieldValidators(metaField);
IFieldValidator fieldValidator = GetFieldValidator <int?>(nameof(IStringMetaField.MinLength));
MinLengthFieldItemViewModel =
TextBoxFieldItemViewModel.Create(fieldValidator, Entity, metaField.MinLength.ToString());
EditableItemsFields.Add(MinLengthFieldItemViewModel);
fieldValidator = GetFieldValidator <int?>(nameof(IStringMetaField.MaxLength));
MaxLengthFieldItemViewModel =
TextBoxFieldItemViewModel.Create(fieldValidator, Entity, metaField.MaxLength.ToString());
EditableItemsFields.Add(MaxLengthFieldItemViewModel);
fieldValidator = GetFieldValidator <int?>(nameof(IStringMetaField.DisplayedLinesCount));
DisplayedLinesCountFieldItemViewModel = TextBoxFieldItemViewModel.Create(fieldValidator, Entity,
metaField.DisplayedLinesCount.ToString());
EditableItemsFields.Add(DisplayedLinesCountFieldItemViewModel);
fieldValidator = GetFieldValidator <string>(nameof(IStringMetaField.DefaultValue));
DefaultValueFieldItemViewModel =
TextBoxFieldItemViewModel.Create(fieldValidator, Entity, metaField.DefaultValue);
EditableItemsFields.Add(DefaultValueFieldItemViewModel);
fieldValidator = GetFieldValidator <IEntity>(nameof(IStringMetaField.RegularExpression));
var regularExpressions = MetaDataService.GetRegularExpressions().OrderBy(me => me.Label).ToList();
var regularExpressionViewModels = regularExpressions.Select(RegularExpressionItemViewModel.Create);
EntityRegularExpressionFieldItemViewModel =
EntityFieldItemViewModel.Create(fieldValidator, Entity,
regularExpressionViewModels, metaField.RegularExpression);
EditableItemsFields.Add(EntityRegularExpressionFieldItemViewModel);
}
private void OpenRegularExpressionEdition(IEntity entity)
{
var regularExpression = entity as IRegularExpression;
var entityValidator = EntityService.GetEntityValidator(MetaRegularExpression);
if (regularExpression == null)
{
regularExpression = MetaDataService.InitializeRegularExpression(MetaRegularExpression);
}
var entityItemViewModels = new Dictionary <IEntityMetaField, List <IEntityItemViewModel> >();
var metaField = (IEntityMetaField)
EntityService.GetMetaField <IEntity>(MetaRegularExpression, nameof(IRegularExpression.CreationUser));
var mdUserItemViewModels =
new List <IEntityItemViewModel> {
MdUserItemViewModel.Create(regularExpression.CreationUser)
};
entityItemViewModels.Add(metaField, mdUserItemViewModels);
metaField = (IEntityMetaField)
EntityService.GetMetaField <IEntity>(MetaRegularExpression, nameof(IRegularExpression.LastUpdateUser));
mdUserItemViewModels =
new List <IEntityItemViewModel> {
MdUserItemViewModel.Create(regularExpression.LastUpdateUser)
};
entityItemViewModels.Add(metaField, mdUserItemViewModels);
Panels.Add(EntityEditionPanelViewModel.Create(ValidateRegularExpression, DeleteRegularExpressions,
entityValidator, regularExpression, entityItemViewModels));
SetFocusOnSelectedPanel();
}
public static void MetaDataService_ComponentIdForProfile(IWrapper wrapper)
{
var service = new MetaDataService(
wrapper.Pipeline.FlowElements
.Where(e => typeof(IOnPremiseDeviceDetectionEngine).IsAssignableFrom(e.GetType()))
.Cast <IOnPremiseDeviceDetectionEngine>()
.ToArray());
var comonentFor15364 = service.ComponentIdForProfile(15364);
var comonentFor17017 = service.ComponentIdForProfile(17017);
var comonentFor17470 = service.ComponentIdForProfile(17470);
var comonentFor18092 = service.ComponentIdForProfile(18092);
var comonentFor999999999 = service.ComponentIdForProfile(999999999);
var comonentFor0 = service.ComponentIdForProfile(0);
// Expect 5 components:
// hardware, platform, browser, crawler and metrics.
// metrics does not actually exist in the data file and
// does not have a default profile so it will be null.
Assert.AreEqual((byte)1, comonentFor15364);
Assert.AreEqual((byte)2, comonentFor17017);
Assert.AreEqual((byte)3, comonentFor17470);
Assert.AreEqual((byte)4, comonentFor18092);
Assert.IsNull(comonentFor999999999);
Assert.IsNull(comonentFor0);
}
public void TestSaveMetaFieldUpdate()
{
var metaDataService = new MetaDataService();
var metaEntity = Repository.MetaEntities.First();
var entityValidator = new EntityValidator(metaEntity);
var metaField = Repository.MetaFields.Single(mf => mf.Id == 1);
var intFieldValidator = new FieldValidator <int?>(metaField, entityValidator);
intFieldValidator.ValueCheckings.Add(CheckValue);
entityValidator.FieldValidators.Add(intFieldValidator);
metaField = Repository.MetaFields.Single(mf => mf.Id == 2);
var stringFieldValidator = new FieldValidator <string>(metaField, entityValidator);
stringFieldValidator.ValueCheckings.Add(CheckValue);
entityValidator.FieldValidators.Add(stringFieldValidator);
metaField.Label = "New label";
var results = metaDataService.SaveMetaField(entityValidator, metaField);
Assert.IsNotEmpty(results);
Assert.AreEqual(2, results.Count);
CollectionAssert.AllItemsAreNotNull(results);
Assert.True(results.All(r => r.IsValid));
Assert.AreEqual(2, Repository.MetaFields.Count);
CollectionAssert.Contains(Repository.MetaFields, metaField);
Assert.AreEqual(2, metaField.Id);
Assert.AreNotEqual(DateTime.MinValue, metaField.CreationDate);
Assert.NotNull(metaField.CreationUser);
Assert.AreNotEqual(DateTime.MinValue, metaField.LastUpdateDate);
Assert.NotNull(metaField.LastUpdateUser);
Assert.AreNotEqual(metaField.CreationDate, metaField.LastUpdateDate);
Assert.AreSame(metaField.CreationUser, metaField.LastUpdateUser);
}
public SearchView()
{
InitializeComponent();
var repo = new MetaDataRepository(ConfigurationManager.AppSettings["RepositoryDir"]);
var service = new MetaDataService(repo);
DataContext = new SearchViewModel(service);
}
public SearchService(UserStatusService statusService, ImageCache cache,
MetaDataService metadataService, UserConfigService configService)
{
_configService = configService;
_statusService = statusService;
_imageCache = cache;
_metadataService = metadataService;
}
public void TestGetMetaEntities()
{
var metaDataService = new MetaDataService();
var metaEntities = Repository.MetaEntities;
var foundMetaEntities = metaDataService.GetMetaEntities();
Assert.AreSame(metaEntities, foundMetaEntities);
}
public void TestGetRegularExpression()
{
var metaDataService = new MetaDataService();
var regularExpression = Repository.RegularExpressions.First();
var foundRegularExpression = metaDataService.GetRegularExpression(1);
Assert.AreSame(regularExpression, foundRegularExpression);
}
public void TestGetRegularExpressions()
{
var metaDataService = new MetaDataService();
var regularExpressions = Repository.RegularExpressions;
var foundRegularExpressions = metaDataService.GetRegularExpressions();
Assert.AreSame(regularExpressions, foundRegularExpressions);
}
public void TestInitializeMetaEntity()
{
var metaDataService = new MetaDataService();
var metaEntity = Repository.MetaEntities.First();
var entity = metaDataService.InitializeMetaEntity(metaEntity);
Assert.NotNull(entity);
Assert.AreEqual(INTEGER_DEFAULT_VALUE, entity.Id);
Assert.AreEqual(STRING_DEFAULT_VALUE, entity.Label);
}
public void TestInitializeRegularExpression()
{
var metaDataService = new MetaDataService();
var metaEntity = Repository.MetaEntities.First();
var regularExpression = metaDataService.InitializeRegularExpression(metaEntity);
Assert.NotNull(regularExpression);
Assert.AreEqual(INTEGER_DEFAULT_VALUE, regularExpression.Id);
Assert.AreEqual(STRING_DEFAULT_VALUE, regularExpression.Label);
}
public StatisticsController(StatisticsServices statisticsServices,
CustomerService customerServices,
MetaDataService metaDataServices,
UserManager <IdentityUser> userManager,
ILogger <StatisticsController> logger)
{
this.statisticsService = statisticsServices;
this.customerService = customerServices;
this.metaDataService = metaDataServices;
this.userManager = userManager;
this.logger = logger;
}
public void TestHashFex()
{
//arrange
var configModel = TestHelper.GetConfigModel();
var metaDataService1 = new MetaDataService(configModel, TestHelper.GetInputFilePath("simple.fex"));
var metaDataService2 = new MetaDataService(configModel, TestHelper.GetInputFilePath("advanced.fex"));
//act
var metaData1 = metaDataService1.Process();
var metaData2 = metaDataService2.Process();
//assert
Assert.AreNotEqual(metaData1.Hash, metaData2.Hash);
}
public override void Initialize(IDateTimeMetaField metaField, IMetaEntity metaEntity = null)
{
var metaDateTimeMetaField = EntityService.GetMetaEntity(nameof(IDateTimeMetaField));
EntityValidator = EntityService.GetEntityValidator(metaDateTimeMetaField);
if (metaField == null)
{
metaField = MetaDataService.InitializeDateTimeMetaField(metaDateTimeMetaField, metaEntity);
}
Caption = EntityValidator.MetaEntity.Label;
Entity = metaField;
InitializeFieldValidators(metaField);
}
public AccountsController(AccountsService customerServices,
MetaDataService metaDataService,
CustomerService customerService,
PaymentsService paymentsService,
UserManager <IdentityUser> userManager,
RazorPagesReportingEngine reportingEngine)
{
this.accountsService = customerServices;
this.userManager = userManager;
this.metaDataService = metaDataService;
this.reportingEngine = reportingEngine;
this.customerService = customerService;
this.paymentsService = paymentsService;
}
// GET: Administrateur/AssetTypeSupportedMetaDatas/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var assetTypeSupportedMetaData = AssetTypeSupportedMetaDatasService.Get(id);
if (assetTypeSupportedMetaData == null)
{
return(HttpNotFound());
}
ViewBag.AssetTypeID = new SelectList(AssetTypeService.GetAssetTypes(), "AssetTypeID", "TypeLabel", assetTypeSupportedMetaData.AssetTypeID);
ViewBag.MetaDataID = new SelectList(MetaDataService.GetMetaDatas(), "MetaDataID", "Title", assetTypeSupportedMetaData.MetaDataID);
return(View(assetTypeSupportedMetaData));
}
protected override void TestFex(string fileName)
{
//arrange
var configModel = TestHelper.GetConfigModel();
var metaDataService = new MetaDataService(configModel, TestHelper.GetInputFilePath(fileName));
//act
var metaData = metaDataService.Process();
//assert
Assert.AreEqual(metaData.Title, fileName.Substring(0, fileName.Length - 4));
Assert.AreEqual(metaData.Author, configModel.Author);
Assert.IsTrue(!string.IsNullOrEmpty(metaData.Hash));
Assert.IsTrue(metaData.ChangedAt > DateTime.MinValue);
Assert.IsTrue(metaData.GeneratedAt > DateTime.Today);
}
public void SearchItemsByKeywordAndTypNoInputShouldReturnEnEmptyList()
{
//arrange
var repoMock = A.Fake <IMetaDataRepository>();
var sut = new MetaDataService(repoMock);
//act
var result = sut.SearchItemsByKeywordAndTyp(null, null);
//assert
Assert.NotNull(result);
Assert.IsInstanceOf(typeof(ObservableCollection <MetadataItem>), result);
Assert.That(result.Count == 0);
}
public CardsController(CustomerService customerService,
AccountsService accountsService,
CardServices cardService,
PaymentsService transactionService,
MetaDataService metaDataService,
UserManager <IdentityUser> userManager,
ILogger <CardsController> logger)
{
this.transactionService = transactionService;
this.userManager = userManager;
this.cardService = cardService;
this.customerService = customerService;
this.accountsService = accountsService;
this.metaDataService = metaDataService;
this.logger = logger;
}
public ActionResult Edit([Bind(Include = "AssetSupportedMetaDataID,AssetTypeID,MetaDataID")] AssetTypeSupportedMetaData assetTypeSupportedMetaData)
{
try
{
if (ModelState.IsValid)
{
AssetTypeSupportedMetaDatasService.Update(assetTypeSupportedMetaData);
return(RedirectToAction("Index"));
}
ViewBag.AssetTypeID = new SelectList(AssetTypeService.GetAssetTypes(), "AssetTypeID", "TypeLabel", assetTypeSupportedMetaData.AssetTypeID);
ViewBag.MetaDataID = new SelectList(MetaDataService.GetMetaDatas(), "MetaDataID", "Title", assetTypeSupportedMetaData.MetaDataID);
return(View(assetTypeSupportedMetaData));
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "AssetTypeSupportedMetaDatas", "Edit")));
}
}
public void Initialize(IMetaEntity metaEntity)
{
MetaFieldTemplate = EntityService.GetMetaEntity(nameof(IMetaFieldTemplate));
EntityValidator = EntityService.GetEntityValidator(MetaFieldTemplate);
var metaMetaField = EntityService.GetMetaEntity(nameof(IMetaField));
if (metaEntity == null)
{
metaEntity = MetaDataService.InitializeMetaEntity(MetaFieldTemplate);
}
else
{
metaEntity = EntityService.GetMetaEntity(metaEntity.Id);
}
Caption = MdManagerLabels.MetaFieldTemplateLabel;
Entity = metaEntity;
}
public IEnumerable <CurveRange> MetadataRequestVersioned(string curveId, string provider, LocalDateTime start, LocalDateTime end)
{
Console.WriteLine("Requesting versioned metadata...");
var _cfg = _config(provider);
var mds = new MetaDataService(_cfg);
var numVersions = mds.ReadCurveRangeAsync(Convert.ToInt32(curveId), 1, 1, null, start, end).Result; // Get number of available curves.
var versions = mds.ReadCurveRangeAsync(Convert.ToInt32(curveId), 1, Convert.ToInt32(numVersions.Count), null, start, end).Result.Data;
//Console.WriteLine("Versions");
//foreach (var v in versions)
//{
// Console.WriteLine(v.Version);
//}
//Console.WriteLine("Total : " + versions.Count());
return(versions);
}
protected override void InitializeFieldValidators(IEntityMetaField metaField)
{
base.InitializeFieldValidators(metaField);
IFieldValidator fieldValidator = GetFieldValidator <int?>(nameof(IEntityMetaField.DefaultValueId));
DefaultValueIdFieldItemViewModel =
TextBoxFieldItemViewModel.Create(fieldValidator, Entity, metaField.DefaultValueId.ToString());
EditableItemsFields.Add(DefaultValueIdFieldItemViewModel);
fieldValidator = GetFieldValidator <IEntity>(nameof(IEntityMetaField.ValueType));
var metaEntities = MetaDataService.GetMetaEntities().OrderBy(me => me.Label).ToList();
var metaEntityViewModels = metaEntities.Select(MetaEntityItemViewModel.Create);
var metaEntity = metaEntities.SingleOrDefault(me => me.Id == metaField.ValueType?.Id);
ValueTypeFieldItemViewModel =
EntityFieldItemViewModel.Create(fieldValidator, Entity, metaEntityViewModels, metaEntity);
EditableItemsFields.Add(ValueTypeFieldItemViewModel);
}
public static void MetaDataService_DefaultProfileIdForComponent(IWrapper wrapper)
{
var service = new MetaDataService(
wrapper.Pipeline.FlowElements
.Where(e => typeof(IOnPremiseDeviceDetectionEngine).IsAssignableFrom(e.GetType()))
.Cast <IOnPremiseDeviceDetectionEngine>()
.ToArray());
var defaultProfile1 = service.DefaultProfileIdForComponent(1);
var defaultProfile99 = service.DefaultProfileIdForComponent(99);
var defaultProfile255 = service.DefaultProfileIdForComponent(255);
// Expect 5 components:
// hardware, platform, browser, crawler and metrics.
// metrics does not actually exist in the data file and
// does not have a default profile so it will be null.
Assert.AreEqual((uint)15364, defaultProfile1);
Assert.IsNull(defaultProfile99);
Assert.IsNull(defaultProfile255);
}
private static void LoadBinAssemblies(string path)
{
var loadedAssemblies = new HashSet <string>(
AppDomain.CurrentDomain.GetAssemblies().
Select(a => a.GetName().Name));
foreach (var asmFileName in Directory.GetFiles(path, "StoreManagement.*.dll"))
{
var nameOnly = Path.GetFileNameWithoutExtension(asmFileName);
if (!loadedAssemblies.Contains(nameOnly))
{
Assembly.LoadFrom(asmFileName);
}
}
foreach (var ei in ComponentManager.GetAllEntityInfos())
{
MetaDataService.AddEntityInfo(ei);
}
}
public void SearchItemsByKeywordOrTypWithKeywordShouldReturnTwoItems()
{
//arrange
var testList = new ObservableCollection <MetadataItem>
{
new MetadataItem()
{
Bezeichnung = "hallo",
Typ = "Vertrag"
},
new MetadataItem()
{
Bezeichnung = "Samy",
Typ = "Quittungen"
},
new MetadataItem()
{
Bezeichnung = "Hallo Welt",
Typ = "Vertrag"
}
};
var repoMock = A.Fake <IMetaDataRepository>();
A.CallTo(() => repoMock.SearchMetaDataItemsAndAddToList()).Returns(testList);
var sut = new MetaDataService(repoMock);
//act
var result = sut.SearchItemsByKeywordOrTyp("Hallo");
//assert
Assert.That(result.Count == 2);
Assert.AreEqual(testList[0], result[0]);
Assert.AreEqual(testList[2], result[1]);
}
public ImageRecognitionService(StatusService statusService, ObjectDetector objectDetector,
MetaDataService metadataService, AzureFaceService azureFace,
AccordFaceService accordFace, EmguFaceService emguService,
ThumbnailService thumbs, ConfigService configService,
ImageClassifier imageClassifier, ImageCache imageCache,
WorkService workService, ExifService exifService,
ImageProcessService imageProcessor)
{
_thumbService = thumbs;
_accordFaceService = accordFace;
_azureFaceService = azureFace;
_statusService = statusService;
_objectDetector = objectDetector;
_metdataService = metadataService;
_emguFaceService = emguService;
_configService = configService;
_imageClassifier = imageClassifier;
_imageProcessor = imageProcessor;
_imageCache = imageCache;
_workService = workService;
_exifService = exifService;
}
