public LoginViewModel(IUserDataService userDataService, IPageNavigationService pageNavigationService, IUserNotificationService userNotificationService, IAppRepository appRepository)
: base(pageNavigationService)
{
_userDataService = userDataService;
_pageNavigationService = pageNavigationService;
_userNotificationService = userNotificationService;
_appRepository = appRepository;
//TokenData = "bogdan/aa8d8752-7404-46ab-b55f-4b40fc8b60e7";
}
public DaysOnFireViewModel(IPageNavigationService pageNavigationService, IUserDataService userDataService, IAppRepository appRepository, IUserNotificationService userNotificationService)
: base(pageNavigationService)
{
_pageNavigationService = pageNavigationService;
_userDataService = userDataService;
_appRepository = appRepository;
_userNotificationService = userNotificationService;
DisplayName = "Days on fire";
}
public RepositoryEmitter(IAppRepository app,
IAppUpdateRepository appUpdate,
IAppTrackRepository appTrack,
IUserRepository user) {
App = app;
AppUpdate = appUpdate;
AppTrack = appTrack;
User = user;
}
public UserFactsViewModel(IPageNavigationService pageNavigationService, IUserDataService userDataService,
IAppRepository appRepository, IUserNotificationService userNotificationService)
: base(pageNavigationService)
{
_pageNavigationService = pageNavigationService;
_userDataService = userDataService;
_appRepository = appRepository;
_userNotificationService = userNotificationService;
DisplayName = "Behavior facts";
}
public HomeModule(IAppRepository repository)
{
_repository = repository;
Get["/"] = _ => GetIndex();
Get["/sobre"] = _ => View["About"];
Get["/eventos"] = _ => GetEvents();
Get["/evento/{slug}"] = _ => GetEvent((string)_.slug);
Get["/vagas"] = _ => View["Jobs"];
Get["/empresas"] = _ => GetCompanies();
}
public AppCommunicatorService()
{
List<IDbConfiguration> configurations = new List<IDbConfiguration>();
configurations.Add(new DocsDbConfiguration());
configurations.Add(new CommonDbConfiguration());
configurations.Add(new AopDbConfiguration());
this.unitOfWork = new UnitOfWork(configurations, Enumerable.Empty<IDbContextInitializer>());
this.docRepository = new DocRepository(unitOfWork);
this.appRepository = new AppRepository(unitOfWork);
}
public ScheduleViewModel(
IAppRepository repo,
AuthenticationService authService,
StatusMessageService messageService,
IReactorViewModelFactory reactorFactory,
BookedOrdersViewModel orders)
{
_repo = repo;
_factory = reactorFactory;
_authService = authService;
_messageService = messageService;
_bookedOrders = orders;
}
// Log the status of the import
async Task LogImport(int?importedId, string sourceParameter, Models.WooSections importedSection)
{
IAppRepository <WooSyncLog> _WooSyncLogRepository = _AppUnitOfWork.Repository <WooSyncLog>();
await _WooSyncLogRepository.AddAsync(new WooSyncLog
{
// add the parameters
WooSyncDateTime = _LogDate,
Result = (importedId != null) ? Models.WooResults.Success : (importedId == null) ? Models.WooResults.none : Models.WooResults.Error,
Parameters = sourceParameter,
Section = importedSection,
Notes = (importedId != null) && (importedId > 0) ? $"Imported id: {importedId}, DT: {DateTime.Now:d}" : $"DT: { DateTime.Now:d}"
});
}
private async Task <int> MapOurItemToWooItemSync(Product newWooProduct, Item addViewEntity)
{
// create a map to the woo Attribute maps using the id and the Attribute
//
IAppRepository <WooProductMap> _wooProductMapRepository = _AppUnitOfWork.Repository <WooProductMap>();
return(await _wooProductMapRepository.AddAsync(new WooProductMap
{
ItemId = addViewEntity.ItemId,
WooProductId = Convert.ToInt32(newWooProduct.id),
CanUpdate = true,
}));
}
public PhotosController(IAppRepository appRepository, IMapper mapper, IOptions <CloudinarySettings> cloudinaryConfig)
{
this.appRepository = appRepository;
this.mapper = mapper;
this.cloudinaryConfig = cloudinaryConfig;
Account account = new Account(
cloudinaryConfig.Value.ApiSecret,
cloudinaryConfig.Value.ApiKey,
cloudinaryConfig.Value.ApiSecret);
cloudinary = new Cloudinary(account);
}
public async Task <List <ItemUoM> > GetItemUoMsAsync(List <Guid?> linkedItemUoMIDs)
{
if ((linkedItemUoMIDs == null) || (linkedItemUoMIDs.Count == 0))
{
return(null);
}
IAppRepository <ItemUoM> appRepository = _AppUnitOfWork.Repository <ItemUoM>();
var _ItemUoMs = await appRepository.GetByAsync(iu => linkedItemUoMIDs.Contains(iu.ItemUoMId)); // ItemAttributeVarietyLookupId
return(_ItemUoMs.ToList());
}
public FundSelectListService(
IAppRepository <TbDomCompanyType> repositoryCompanyType,
IAppRepository <TbDomFStatus> repositoryFStatus,
IAppRepository <TbDomLegalForm> repositoryLegalForm,
IAppRepository <TbDomLegalType> repositoryLegalType,
IAppRepository <TbDomLegalVehicle> repositoryLegalVehicle)
{
this.repositoryCompanyType = repositoryCompanyType;
this.repositoryFStatus = repositoryFStatus;
this.repositoryLegalForm = repositoryLegalForm;
this.repositoryLegalType = repositoryLegalType;
this.repositoryLegalVehicle = repositoryLegalVehicle;
}
public Form1(IAppRepository appRepo, IAppService appSvc)
{
_appRepo = appRepo;
_appSvc = appSvc;
_appSvc.SetStateProvider(this);
InitializeComponent();
smtpView.Initialize(appRepo, appSvc);
recipientiView1.Initialize(appRepo, appSvc);
mailsView1.Initialize(appRepo, appSvc);
jobsView1.Initialize(appRepo, appSvc);
panel1.Visible = false;
}
public TaskViewModel(IAppRepository repo, ReactorViewModel reactor)
{
var wc = StaticRepository.Workcells.ToList();
if (repo == null || reactor == null)
{
throw new ArgumentNullException();
}
_reactor = reactor;
_repo = repo;
StartWorkcell = wc.FindIndex(w => w.Name == "BIN");
EndWorkcell = wc.FindIndex(w => w.Name == "WC09");
}
public PhotosController(IAppRepository appRepository, IMapper mapper, IOptions <CloudinarySettings> cloudinaryConfig)
{
_appRepository = appRepository;
_mapper = mapper;
_cloudinaryConfig = cloudinaryConfig;
Account account = new Account(
_cloudinaryConfig.Value.CloudName,
_cloudinaryConfig.Value.ApiKey,
_cloudinaryConfig.Value.ApiSecret);
_cloudinary = new Cloudinary(account);
}
public JwtController(IOptions <JwtIssuerOptions> jwtOptions, SignInManager <ApplicationUser> signInManager, UserManager <ApplicationUser> userManager, IAppRepository repository)
{
_signInManager = signInManager;
_userManager = userManager;
_jwtOptions = jwtOptions.Value;
_repository = repository;
ThrowIfInvalidOptions(_jwtOptions);
_serializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented
};
}
/// <summary>
/// Add or update variation of this item
/// </summary>
/// <param name="currItem">the item </param>
/// <param name="prodAttrib">the attribute</param>
/// <returns>Item modified with new data</returns>
async Task <Item> AddOrUpdateVarieties(Item currItem, ProductAttributeLine prodAttrib, WooProductAttributeMap currWooProductAttributeMap) //, bool IsAttributeVarietyUpddate)
{
IAppRepository <ItemAttributeVarietyLookup> _itemAttribVarietyLookupRepo = _AppUnitOfWork.Repository <ItemAttributeVarietyLookup>();
ItemAttributeVarietyLookup _itemAttributeVarietyLookup = null;
foreach (var attrbiTerm in prodAttrib.options)
{
_itemAttributeVarietyLookup = await _itemAttribVarietyLookupRepo.FindFirstAsync(ItemAttributeVariety => ItemAttributeVariety.VarietyName == attrbiTerm);
if (_itemAttributeVarietyLookup != null)
{
// found so update or add
ItemAttribute _itemAttribute = currItem.ItemAttributes.Find(ic => ic.ItemAttributeLookupId == currWooProductAttributeMap.ItemAttributeLookupId);
if (_itemAttribute == null)
{
return(currItem); // this should never occur
}
// does this attribute have this variety, if so update otherwise add
if ((_itemAttribute.ItemAttributeVarieties != null) && (_itemAttribute.ItemAttributeVarieties.Exists(iav => iav.ItemAttributeVarietyLookupId == _itemAttributeVarietyLookup.ItemAttributeVarietyLookupId)))
{
// this attribute variety / term exists so just update it. Do stuff here if we need - so far nada
//make sure this matches
ItemAttributeVariety _itemAttributeVariety = _itemAttribute.ItemAttributeVarieties.FirstOrDefault(iav => iav.ItemAttributeVarietyLookupId == _itemAttributeVarietyLookup.ItemAttributeVarietyLookupId);
///-> can this be null? It should never be
// copy the whole item across just in case there have been changes
_itemAttributeVariety.ItemAttributeVarietyLookupDetail = _itemAttributeVarietyLookup;
_itemAttributeVariety.ItemAttributeId = _itemAttribute.ItemAttributeId;
}
else
{
// we have a attribute variety, this means we should have an attribute that, that belongs too.
if (_itemAttribute.ItemAttributeVarieties == null)
{
_itemAttribute.ItemAttributeVarieties = new List <ItemAttributeVariety>();
}
// create a new variety assume 1.0 as in 1-1 QTY and update the ItemDetails. Do not change Item Id as then EF core knows it is a new record.
_itemAttribute.ItemAttributeVarieties.Add(new ItemAttributeVariety
{
ItemAttributeVarietyLookupId = _itemAttributeVarietyLookup.ItemAttributeVarietyLookupId,
ItemAttributeVarietyLookupDetail = _itemAttributeVarietyLookup, // copy the whole attribute across
ItemAttributeId = _itemAttribute.ItemAttributeId,
UoMId = _itemAttributeVarietyLookup.UoMId,
UoM = _itemAttributeVarietyLookup.UoM,
UoMQtyPerItem = 1.0
});
}
}
}
return(currItem);
}
protected override void Initialize(HttpControllerContext context)
{
base.Initialize(context);
if (this.AppRepository == null)
{
this.AppRepository = new Frapid.Core.DataAccess.App
{
_Catalog = this.MetaUser.Catalog,
_LoginId = this.MetaUser.LoginId,
_UserId = this.MetaUser.UserId
};
}
}
public AppController()
{
this._LoginId = AppUsers.GetCurrent().View.LoginId.To <long>();
this._UserId = AppUsers.GetCurrent().View.UserId.To <int>();
this._OfficeId = AppUsers.GetCurrent().View.OfficeId.To <int>();
this._Catalog = AppUsers.GetCatalog();
this.AppRepository = new Frapid.Config.DataAccess.App
{
_Catalog = this._Catalog,
_LoginId = this._LoginId,
_UserId = this._UserId
};
}
public PostImagesController(IAppRepository repo, IMapper mapper, IOptions <CloudinarySettings> cloudinaryConfig)
{
_cloudinaryConfig = cloudinaryConfig;
_mapper = mapper;
_repo = repo;
Account acc = new Account(
_cloudinaryConfig.Value.CloudName,
_cloudinaryConfig.Value.ApiKey,
_cloudinaryConfig.Value.ApiSecret
);
_cloudinary = new Cloudinary(acc);
}
public InternalLocalizationProvider(
IPageRepository pageRepository,
IStandardRepository standardRepository,
IChartRepository chartRepository,
IDynamicListRepository dynamicListRepository,
IAppRepository appRepository,
ILocalizationRepository localizationRepository)
{
_pageRepository = pageRepository;
_standardRepository = standardRepository;
_chartRepository = chartRepository;
_dynamicListRepository = dynamicListRepository;
_appRepository = appRepository;
_localizationRepository = localizationRepository;
}
public PriceUpdaterCron(
IAppRepository appRepository,
INotificationDispatcher notificationDispatcher,
IPriceUpdaterConfigProvider configProvider,
ILoopIdStore loopIdStore,
IGuidProvider guidProvider,
IAppPricesUpdater appPricesUpdater)
{
_appRepository = appRepository;
_notificationDispatcher = notificationDispatcher;
_configProvider = configProvider;
_loopIdStore = loopIdStore;
_guidProvider = guidProvider;
_appPricesUpdater = appPricesUpdater;
}
public ValuesControllerTest()
{
_mapper = MapperMock.MapperProfileTest();
_appReo = new AppRepositoryFake();
_controller = new ValuesController(_appReo, _mapper);
_newHome = new HomeDto()
{
Id = 4,
Name = "Test",
City = "Liverpool",
Address = "7 Street",
Email = "*****@*****.**",
Rating = 5
};
}
public override async Task DeleteRowAsync(ItemView deleteViewEntity)
{
IAppRepository <Item> _itemRepository = _AppUnitOfWork.Repository <Item>();
var _recsDelete = await _itemRepository.DeleteByIdAsync(deleteViewEntity.ItemId);
if (_recsDelete == AppUnitOfWork.CONST_WASERROR)
{
_GridSettings.PopUpRef.ShowNotification(PopUpAndLogNotification.NotificationType.Error, $"Item: {deleteViewEntity.ItemName} is no longer found, was it deleted?");
}
else
{
_GridSettings.PopUpRef.ShowNotification(PopUpAndLogNotification.NotificationType.Success, $"Item: {deleteViewEntity.ItemName} was it deleted?");
}
}
private async Task <int> MapOurItemToWooItemSync(ProductCategory newWooProductCategory, ItemCategoryLookup addViewEntity)
{
// create a map to the woo category maps using the id and the category
//
IAppRepository <WooCategoryMap> _wooCategoryMapRepository = _AppUnitOfWork.Repository <WooCategoryMap>();
return(await _wooCategoryMapRepository.AddAsync(new WooCategoryMap
{
ItemCategoryLookupId = addViewEntity.ItemCategoryLookupId,
WooCategoryId = (int)newWooProductCategory.id,
WooCategoryName = addViewEntity.CategoryName,
CanUpdate = true,
WooCategoryParentId = (int)newWooProductCategory.parent
}));
}
public override async Task DeleteRowAsync(ItemCategoryLookupView deleteViewEntity)
{
IAppRepository <ItemCategoryLookup> _itemCategoryLookupRepository = _AppUnitOfWork.Repository <ItemCategoryLookup>();
var _recsDelete = await _itemCategoryLookupRepository.DeleteByIdAsync(deleteViewEntity.ItemCategoryLookupId); //DeleteByAsync(icl => icl.ItemCategoryLookupId == SelectedItemCategoryLookup.ItemCategoryLookupId);
if (_recsDelete == AppUnitOfWork.CONST_WASERROR)
{
_GridSettings.PopUpRef.ShowNotification(PopUpAndLogNotification.NotificationType.Error, $"Category: {deleteViewEntity.CategoryName} is no longer found, was it deleted?");
}
else
{
_GridSettings.PopUpRef.ShowNotification(PopUpAndLogNotification.NotificationType.Success, $"Category: {deleteViewEntity.CategoryName} was it deleted?");
}
}
protected override async Task OnInitializedAsync()
{
IAppRepository <ItemAttributeLookup> _appRepository = _AppUnitOfWork.Repository <ItemAttributeLookup>();
var _itemAttributeVarieties = await _appRepository.GetAllAsync();
_ItemAttributes = new Dictionary <Guid, string>();
foreach (var item in _itemAttributeVarieties)
{
_ItemAttributes.Add(item.ItemAttributeLookupId, item.AttributeName);
}
//await LoadData();
await InvokeAsync(StateHasChanged);
}
private async Task LoadWooPrefs()
{
IAppRepository <WooSettings> _wooPrefs = _AppUnitOfWork.Repository <WooSettings>();
StateHasChanged();
modelWooSettings = await _wooPrefs.FindFirstAsync();
if (modelWooSettings == null)
{
modelWooSettings = new WooSettings(); // if nothing send back a empty record
}
IsSaved = false;
StateHasChanged();
}
public AppController(IUnitOfWork unitOfWork,
IAppRepository appRepository,
IDocRepository docRepository,
IUserRepository userRepository,
IClassificationRepository classificationRepository,
INomRepository nomRepository,
IDataGenerator dataGenerator)
{
this.unitOfWork = unitOfWork;
this.appRepository = appRepository;
this.docRepository = docRepository;
this.userRepository = userRepository;
this.classificationRepository = classificationRepository;
this.nomRepository = nomRepository;
this.dataGenerator = dataGenerator;
}
public AppProvider(
IGrainFactory grainFactory,
IAppRepository appRepository,
ISchemaRepository schemaRepository,
IRuleRepository ruleRepository)
{
Guard.NotNull(grainFactory, nameof(grainFactory));
Guard.NotNull(appRepository, nameof(appRepository));
Guard.NotNull(schemaRepository, nameof(schemaRepository));
Guard.NotNull(ruleRepository, nameof(ruleRepository));
this.grainFactory = grainFactory;
this.appRepository = appRepository;
this.schemaRepository = schemaRepository;
this.ruleRepository = ruleRepository;
}
public AppCommandHandler(
IAggregateHandler handler,
IAppRepository appRepository,
IUserRepository userRepository,
ClientKeyGenerator keyGenerator)
{
Guard.NotNull(handler, nameof(handler));
Guard.NotNull(keyGenerator, nameof(keyGenerator));
Guard.NotNull(appRepository, nameof(appRepository));
Guard.NotNull(userRepository, nameof(userRepository));
this.handler = handler;
this.keyGenerator = keyGenerator;
this.appRepository = appRepository;
this.userRepository = userRepository;
}
public AppsController(
IAppRepository appRepository,
IPageServiceProvider pageServiceProvider,
ILocalizationRepository localizationRepository,
IAppService appService,
IHttpContextAccessor httpContextAccessor,
IServiceLogger <AppsController> logger
)
{
_appRepository = appRepository;
_pageServiceProvider = pageServiceProvider;
_localizationRepository = localizationRepository;
_appService = appService;
_httpContextAccessor = httpContextAccessor;
_logger = logger;
}
public AppProvider(
IAppRepository appRepository,
ISchemaRepository schemaRepository,
IStateFactory stateFactory,
IRuleRepository ruleRepository)
{
Guard.NotNull(appRepository, nameof(appRepository));
Guard.NotNull(schemaRepository, nameof(schemaRepository));
Guard.NotNull(stateFactory, nameof(stateFactory));
Guard.NotNull(ruleRepository, nameof(ruleRepository));
this.appRepository = appRepository;
this.schemaRepository = schemaRepository;
this.stateFactory = stateFactory;
this.ruleRepository = ruleRepository;
}
public AppsController(IAppRepository appRepository,
IUserHelper userHelper,
DataContext context,
IConverterHelper converterHelper,
ICombosHelper combosHelper,
IMailHelper mailHelper,
ICustomerRepository customerRepository)
{
_appRepository = appRepository;
_userHelper = userHelper;
_context = context;
_converterHelper = converterHelper;
_combosHelper = combosHelper;
_mailHelper = mailHelper;
_customerRepository = customerRepository;
}
async Task <Guid> UpdateProductAttributeTerm(ProductAttributeTerm sourcePAT, Guid sourceParentAttributeId, WooProductAttributeTermMap sourceWooAttributeTermMap)
{
// we have found a mapping between the woo Product AttributeTerm and our AttributeTerm id so update the Attribute table just in case.
Guid _itemAttributeTermId = Guid.Empty;
IAppRepository <WooProductAttributeTermMap> _wooProductAttributeTermMapRepository = _AppUnitOfWork.Repository <WooProductAttributeTermMap>();
_itemAttributeTermId = await AddOrUpdateItemAttributeVariety(sourcePAT, sourceParentAttributeId, sourceWooAttributeTermMap.ItemAttributeVarietyLookupId);
/// Now update the woo AttributeTerm using the _ItemAttributeTermId returned.
if (await _wooProductAttributeTermMapRepository.UpdateAsync(sourceWooAttributeTermMap) == AppUnitOfWork.CONST_WASERROR)
{ // did not updated so set _ItemAttributeTermId to ItemAttributeTermID to Guid.Empty = error
_itemAttributeTermId = Guid.Empty;
}
return(_itemAttributeTermId);
}
public PatchCarCommand(
ILogger <PatchCarCommand> logger,
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
IAppRepository carRepository,
IMapper <Car, CarVm> carToCarVmMapper,
IMapper <Car, CarSm> carToCarSmMapper,
IMapper <CarSm, Car> carSmToCarMapper)
{
_log = logger ?? throw new ArgumentNullException(nameof(logger));
_carRepository = carRepository ?? throw new ArgumentNullException(nameof(carRepository));
_actionContextAccessor = actionContextAccessor ?? throw new ArgumentNullException(nameof(actionContextAccessor));
_objectModelValidator = objectModelValidator ?? throw new ArgumentNullException(nameof(objectModelValidator));
_carToCarVmMapper = carToCarVmMapper ?? throw new ArgumentNullException(nameof(carToCarVmMapper));
_carToCarSmMapper = carToCarSmMapper ?? throw new ArgumentNullException(nameof(carToCarSmMapper));
_carSmToCarMapper = carSmToCarMapper ?? throw new ArgumentNullException(nameof(carSmToCarMapper));
}
async Task <Guid> AddOrUpdateItemAttribute(ProductAttribute pPA, Guid pWooMappedItemAttributeId)
{
Guid _ItemAttributeId = Guid.Empty;
IAppRepository <ItemAttributeLookup> _ItemAttributeRepository = _AppUnitOfWork.Repository <ItemAttributeLookup>();
// check if the Attribute exists
ItemAttributeLookup _ItemAttribute = await _ItemAttributeRepository.FindFirstAsync(ic => ic.ItemAttributeLookupId == pWooMappedItemAttributeId);
if (_ItemAttribute != null)
{
_ItemAttributeId = await UpdateItemAttribute(pPA, _ItemAttribute);
}
else
{
_ItemAttributeId = await AddOrGetIDItemAttribute(pPA);
}
return(_ItemAttributeId);
}
async Task <Guid> AddOrUpdateItemAttributeVariety(ProductAttributeTerm sourcePAT, Guid sourceParentAttributeId, Guid sourceWooMappedItemAttributeTermId)
{
Guid _itemAttributeVarietyId = Guid.Empty;
IAppRepository <ItemAttributeVarietyLookup> _itemAttributeVarietyRepository = _AppUnitOfWork.Repository <ItemAttributeVarietyLookup>();
// check if the AttributeTerm exists
ItemAttributeVarietyLookup _ItemAttributeVariety = await _itemAttributeVarietyRepository.FindFirstAsync(ic => ic.ItemAttributeVarietyLookupId == sourceWooMappedItemAttributeTermId);
if (_ItemAttributeVariety != null)
{
_itemAttributeVarietyId = await UpdateItemAttributeVariety(sourcePAT, sourceParentAttributeId, _ItemAttributeVariety);
}
else
{
_itemAttributeVarietyId = await AddOrGetIDItemAttributeVariety(sourcePAT, sourceParentAttributeId);
}
return(_itemAttributeVarietyId);
}
public HomeController(IAppRepository repository)
{
_repository = repository;
}
public HomeController()
{
m_repository = new AppRepository();
}
public GameEngine(IAppRepository appRepository, IGameValidation gameValidation)
{
_appRepository = appRepository;
_gameValidation = gameValidation;
_random = new Random();
}
public AppController(IAppRepository repository)
{
this.AppRepository = repository;
}
public AppController(IAppRepository appRepo, IAppCategoryRepository appCategoryRepo, IAppIndustryRepository appIndustryRepo)
{
appRepository = appRepo;
appCategoryRepository = appCategoryRepo;
appIndustryRepository = appIndustryRepo;
}
public GameValidation(IAppRepository appRepository)
{
_appRepository = appRepository;
}
public ExtendedSplashViewModel(IPageNavigationService pageNavigationService, IAppRepository appRepository, IUserNotificationService userNotificationService) : base(pageNavigationService)
{
_pageNavigationService = pageNavigationService;
_appRepository = appRepository;
_userNotificationService = userNotificationService;
}
