/// <summary> /// Initializes a new instance of the ContentViewDecorator class with view model and data context. /// </summary> /// <param name="model">The content view model.</param> /// <param name="dataContext">The data context object.</param> public ContentViewDecorator(ContentView model, IDataContext dataContext) { Model = model; model.CopyTo(this, "Parent", "FieldRefs", "Roles"); Context = dataContext; this.Parent = new ContentListDecorator(dataContext, model.Parent); }
public DevelopmentDefaultData(IOptions<DevelopmentSettings> options, IDataContext dataContext, UserManager<User> userManager, RoleManager<Role> roleManager) { this.settings = options.Value; this.dataContext = dataContext; this.userManager = userManager; this.roleManager = roleManager; }
public static async Task<FeatureMappingViewModel> GetModel(IDataContext context, FeatureMappingFilter filter) { FeatureMappingViewModel model; if (filter.Action == FeatureMappingAction.Delete || filter.Action == FeatureMappingAction.Mapping || filter.Action == FeatureMappingAction.Copy) { model = await GetFullAndPartialViewModelForFeatureMapping(context, filter); } else if (filter.Action == FeatureMappingAction.Mappings || filter.Action == FeatureMappingAction.CopyAll) { model = await GetFullAndPartialViewModelForFeatureMappings(context, filter); } else if (filter.Action == FeatureMappingAction.FeatureCodes) { model = await GetFullAndPartialViewModelForFeatureCodes(context, filter); } else { model = GetFullAndPartialViewModel(context, filter); } if (filter.Action != FeatureMappingAction.NotSet) { model.IdentifierPrefix = Enum.GetName(filter.Action.GetType(), filter.Action); } return model; }
protected ApplicationApiController( IDataContext dataContext, Func<int> getUserId) { this.DataContext = dataContext; this.UserId = getUserId(); }
/// <summary> /// Sets errors for binding target. /// </summary> /// <param name="target">The binding target object.</param> /// <param name="errors">The collection of errors</param> /// <param name="context">The specified context, if any.</param> protected override sealed void SetErrors(object target, IList<object> errors, IDataContext context) { base.SetErrors(target, errors, context); var control = target as Control; if (control == null) return; Control rootControl = PlatformExtensions.GetRootControl(control); if (rootControl == null) return; ErrorProvider errorProvider = GetErrorProviderInternal(rootControl); if (errorProvider == null) return; var oldProvider = ServiceProvider .AttachedValueProvider .GetValue<ErrorProvider>(target, ErrorProviderName, false); if (!ReferenceEquals(oldProvider, errorProvider)) { if (oldProvider != null) { oldProvider.SetError(control, null); TryDispose(oldProvider); } ServiceProvider.AttachedValueProvider.SetValue(control, ErrorProviderName, errorProvider); if (errorProvider.Tag == null) errorProvider.Tag = 1; else if (errorProvider.Tag is int) errorProvider.Tag = (int)errorProvider.Tag + 1; } SetErrors(control, errorProvider, errors, context); }
void EnsureDataContext() { if (_dataContext != null) return; _dataContext = (IDataContext)IoC.GetInstance(null, Key); }
public void Execute(IDataContext context, DelegateExecute nextExecute) { var textControl = context.GetData(DataConstants.TEXT_CONTROL); GC.KeepAlive(textControl); DateTime lastInvocation, utcNow = DateTime.UtcNow; lock (syncLock) { lastInvocation = this.lastLocateInvocation; this.lastLocateInvocation = utcNow; } const int doubleKeyPressDelay = 500; if (utcNow.Subtract(lastInvocation).TotalMilliseconds < doubleKeyPressDelay) { var locateFileAction = actionManager.TryGetAction(LocateFileAction.Id) as IExecutableAction; if (locateFileAction != null) { locateFileAction.Execute(context); return; } } if (lastUnderlyingActionUpdate) { nextExecute(); } }
public void RecalculatePoints(IDataContext dataContext, IPointsCalculator pointsCalculator, List<PlayedGameToRecalculate> playedGamesToRecalculate) { int counter = 0; foreach (var playedGame in playedGamesToRecalculate) { var playerRanks = playedGame.PlayerGameResults.Select(x => new PlayerRank { PlayerId = x.PlayerId, GameRank = x.GameRank }).ToList(); var newPoints = pointsCalculator.CalculatePoints(playerRanks, playedGame.BoardGameGeekGameDefinition); var applicationUserForThisGamingGroup = new ApplicationUser() { CurrentGamingGroupId = playedGame.GamingGroupId }; foreach (var playerGameResult in playedGame.PlayerGameResults) { var scorecard = newPoints[playerGameResult.PlayerId]; playerGameResult.NemeStatsPointsAwarded = scorecard.BasePoints; playerGameResult.GameDurationBonusPoints = scorecard.GameDurationBonusPoints; playerGameResult.GameWeightBonusPoints = scorecard.GameWeightBonusPoints; dataContext.Save(playerGameResult, applicationUserForThisGamingGroup); } Debug.WriteLine("{0} games updated... last PlayedGame.Id is {1}", ++counter, playedGame.PlayedGameId); } }
private void Compose(IDataContext value) { foreach(var child in transform) { var go = ((Transform)child).gameObject; go.SetActive(false); } _composedDataContext = value; if(value != null) { var name = value.GetType().Name; foreach(var child in transform) { var go = ((Transform)child).gameObject; if (go.name != name) continue; go.SetActive(true); break; } } BroadcastDataContextChange(_composedDataContext); }
/// <summary> /// Executes action. Called after Update, that set <c>ActionPresentation.Enabled</c> to true. /// </summary> /// <param name="solution">The solution.</param> /// <param name="context">The context.</param> protected override void Execute(ISolution solution, IDataContext context) { if (!context.CheckAllNotNull(DataConstants.SOLUTION)) { return; } ITextControl textControl = context.GetData(DataConstants.TEXT_CONTROL); if (textControl == null) { return; } IElement element = GetElementAtCaret(context); if (element == null) { return; } var enumDeclaration = element.ToTreeNode().Parent as IEnumDeclaration; if (enumDeclaration == null) { return; } using (ModificationCookie cookie = textControl.Document.EnsureWritable()) { if (cookie.EnsureWritableResult != EnsureWritableResult.SUCCESS) { return; } using (CommandCookie.Create("Context Action Sort Enum By Name")) { PsiManager.GetInstance(solution).DoTransaction(delegate { Execute(solution, enumDeclaration); }); } } }
public void Handle(ref string bindingExpression, IDataContext context) { foreach (var replaceKeyword in ReplaceKeywords) bindingExpression = bindingExpression.Replace(replaceKeyword.Key, replaceKeyword.Value); if (!bindingExpression.Contains("$\"") && !bindingExpression.Contains("$'")) return; Dictionary<string, string> dict = null; InterpolatedStringTokenizer.SetSource(bindingExpression); while (InterpolatedStringTokenizer.Token != TokenType.Eof) { int start; int end; var exp = ParseInterpolatedString(InterpolatedStringTokenizer, out start, out end); if (exp != null) { if (dict == null) dict = new Dictionary<string, string>(); dict[bindingExpression.Substring(start, end - start)] = exp; } } if (dict != null) { foreach (var s in dict) { if (s.Value != null) bindingExpression = bindingExpression.Replace(s.Key, s.Value); } } }
/// <summary>Executes action. Called after Update, that set ActionPresentation.Enabled to true.</summary> /// <param name="context">The data context.</param> /// <param name="nextExecute">delegate to call</param> public void Execute(IDataContext context, [CanBeNull] DelegateExecute nextExecute) { if (context == null) { throw new ArgumentNullException("context"); } if (!AtLeadInWhitespace(context)) { if (nextExecute != null) { nextExecute(); } return; } var service = Shell.Instance.GetComponent<AutoTemplatesService>(); var settings = service.GetSettings(); if (!settings.GetUseCompleteStatement()) { return; } var actionManager = Shell.Instance.GetComponent<ActionManager>(); var action = actionManager.TryGetAction("Generate") as IExecutableAction; if (action != null) { action.Execute(context); } }
/// <summary> /// Updates the property value. /// </summary> /// <param name="dataContext"> /// The data context. /// </param> /// <param name="target"> /// The target. /// </param> public void Update(IDataContext dataContext, object target) { if (target == null) throw new ArgumentNullException("target"); Property.SetValue(target, ValueCalculator.GetValue(dataContext)); }
private static string GetSessionId(IDataContext context) { UnitTestSession session = GetUnitTestSession(context); if (session == null) return null; #if ! RESHARPER_50_OR_NEWER || RESHARPER_60_OR_NEWER return session.ID; #else // HACK: Get the last RunId for correlation instead of the SessionId because the SessionId is // not available to the task runner in R# 5.0 but the RunId is, so we use that for correlation. // Unfortunately runs are transient so they are deleted after tests finish. However before that // happens, the Update method will be called many times to update UI state so we should be able // to catch the run in flight and save it for later. // // I have asked JetBrains to provide SessionId info to TaskRunners in a future release // as it was done in R# 3.1. -- Jeff. foreach (IUnitTestRun run in session.Runs) { string runId = run.ID; LastRunIdCache[session.ID] = runId; return runId; } string lastRunId; LastRunIdCache.TryGetValue(session.ID, out lastRunId); return lastRunId; #endif }
public UnitOfWork(IDataContext dataContext, IUnitOfWorkManager manager) { State = UnitOfWorkState.Active; DataContext = dataContext; Manager = manager; Manager.Add(this); }
public ControllerBase(IDataContext context) { DataContext = context; PageIndex = 0; PageSize = ConfigurationSettings.GetInteger("DefaultPageSize"); }
public void insert() { try { DataAccessProviderFactory factory = new DataAccessProviderFactory(); dataContext = factory.GetDataContext(); dataContext.BeginTransaction(); insertKategorijeGimnasticara(); insertKluboviIMesta(); insertDrzave(); insertGimnasticari(); insertRegistrovaniGimnasticari(); insertSudije(); dataContext.Commit(); } catch (Exception ex) { if (dataContext != null && dataContext.IsInTransaction) dataContext.Rollback(); throw new InfrastructureException( Strings.getFullDatabaseAccessExceptionMessage(ex), ex); } finally { if (dataContext != null) dataContext.Dispose(); dataContext = null; } }
public static async Task<DerivativeViewModel> GetModel(IDataContext context, DerivativeFilter derivativeFilter) { DerivativeViewModel model = null; if (derivativeFilter.Action == DerivativeAction.Delete || derivativeFilter.Action == DerivativeAction.Derivative) { model = await GetFullAndPartialViewModelForDerivative(context, derivativeFilter); } else if (derivativeFilter.Action == DerivativeAction.Derivatives) { model = await GetFullAndPartialViewModelForDerivatives(context, derivativeFilter); } else if (derivativeFilter.Action == DerivativeAction.OxoDerivatives) { model = GetFullAndPartialViewModelForOxoDerivatives(context, derivativeFilter); } else { model = GetFullAndPartialViewModel(context, derivativeFilter); } if (derivativeFilter.Action != DerivativeAction.NotSet) { model.IdentifierPrefix = Enum.GetName(derivativeFilter.Action.GetType(), derivativeFilter.Action); } return model; }
private static async Task<DerivativeViewModel> GetFullAndPartialViewModelForDerivative(IDataContext context, DerivativeFilter filter) { var model = new DerivativeViewModel() { PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1, PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue, Configuration = context.ConfigurationSettings }; var derivative = await context.Vehicle.GetFdpDerivative(filter); var programmeFilter = new ProgrammeFilter() { ProgrammeId = derivative.ProgrammeId, Gateway = derivative.Gateway }; HydrateModelWithCommonProperties(model, context, programmeFilter); if (!(derivative is EmptyFdpDerivative)) { derivative.Programme = model.Programmes.FirstOrDefault(p => p.Id == derivative.ProgrammeId.GetValueOrDefault()); derivative.Body = model.Bodies.FirstOrDefault(b => b.Id == derivative.BodyId); derivative.Engine = model.Engines.FirstOrDefault(e => e.Id == derivative.EngineId); derivative.Transmission = model.Transmissions.FirstOrDefault(t => t.Id == derivative.TransmissionId); } model.Derivative = derivative; return model; }
public static IEnumerable<ValidationResult> Persist(IDataContext context, TakeRateFilter filter, FluentValidation.Results.ValidationResult results, bool global) { return context.TakeRate.PersistValidationErrors(filter, results, global); }
public void Execute(IDataContext context, DelegateExecute nextExecute) { var injector = PlatformObsoleteStatics.Instance.GetComponent<FileInjectedLayers>(); if (injector == null) { throw new ApplicationException("Could not get FileInjectedLayers instance!"); } var file = new FileSystemPath(SettingsFilePath); var settingsLayers = PlatformObsoleteStatics.Instance.GetComponent<UserInjectedSettingsLayers>(); if (settingsLayers == null) { throw new ApplicationException("Could not get UserInjectedSettingsLayers instance!"); } var layers = settingsLayers.GetUserInjectedLayersFromHost(_globalSettings.ProductGlobalLayerId); foreach (var layer in layers) { // TODO: find out if there's an easier way to check if this is layer we want, e.g. by id settingsLayers.TurnInjectedLayerOnOff(layer.Id, layer.Name == LayerName); } if (!injector.IsLayerInjected(_globalSettings.ProductGlobalLayerId, file)) { injector.InjectLayer(_globalSettings.ProductGlobalLayerId, file); } }
protected override string GenerateContent(IDataContext context, string outputFolder) { var bound = context.GetComponent<ISettingsStore>().BindToContextTransient(ContextRange.ApplicationWide); foreach (TemplateApplicability applicability in Enum.GetValues(typeof(TemplateApplicability))) CreateXml(applicability, bound, outputFolder, GeneralHelpers.GetCurrentVersion(), context); return "Code templates"; }
public override bool IsAvailable(IDataContext context) { IList<ITypeMember> typeMembers; ITypeElement ownerType; var moveStaticMembersIsAvailable = IsAvailable(context, out typeMembers, out ownerType); if (!moveStaticMembersIsAvailable) return false; Methods = new List<IMethod>(); foreach (var typeMember in typeMembers) { var method = typeMember != null ? typeMember as IMethod : null; if (method == null) return false; // Do a quick check to see if Extension Methods are allowed. var methodDeclaration = method.GetDeclarations().FirstOrDefault(); if (methodDeclaration != null) { var treeNode = methodDeclaration.CreateTreeElementPointer().GetTreeNode(); if (treeNode != null && !treeNode.IsVB9Supported()) return false; } if (!method.IsStatic || method.Parameters.None() || method.Parameters.First().Kind != ParameterKind.VALUE) return false; if (method.IsExtensionMethod ^ Direction == WorkflowDirection.ExtensionToShared) return false; Methods.Add(method); } return true; }
//[OperationBehavior(Impersonation=ImpersonationOption.Required)] public async Task<ImportQueue> ProcessQueuedItem(int importQueueId) { Console.WriteLine("ProcessQueuedItem: {0}", importQueueId); DataContext = DataContextFactory.CreateDataContext(WindowsIdentity.GetCurrent().Name); return await DataContext.Import.GetImportQueue(new ImportQueueFilter(importQueueId)); }
public static EngineCodeMappingViewModel GetModel(IDataContext context) { return new EngineCodeMappingViewModel() { Configuration = context.ConfigurationSettings }; }
private static async Task<MarketMappingViewModel> GetFullAndPartialViewModelForMarketMapping ( IDataContext context, MarketMappingFilter filter ) { var baseModel = SharedModelBase.GetBaseModel(context); var model = new MarketMappingViewModel() { PageIndex = filter.PageIndex.HasValue ? filter.PageIndex.Value : 1, PageSize = filter.PageSize.HasValue ? filter.PageSize.Value : Int32.MaxValue, Configuration = context.ConfigurationSettings, CurrentUser = baseModel.CurrentUser, CurrentVersion = baseModel.CurrentVersion }; var marketMapping = await context.Market.GetFdpMarketMapping(filter); var programmeFilter = new ProgrammeFilter() { ProgrammeId = marketMapping.ProgrammeId, Gateway = marketMapping.Gateway, Code = model.MarketMapping.Programme.VehicleName // In order to filter the gateways specific to the programme }; HydrateModelWithCommonProperties(model, context, programmeFilter); model.Gateways = context.Vehicle.ListGateways(programmeFilter); if (!(marketMapping is EmptyFdpMarketMapping)) { marketMapping.Programme = model.Programmes.FirstOrDefault(p => p.Id == marketMapping.ProgrammeId.GetValueOrDefault()); } model.MarketMapping = marketMapping; return model; }
// Hides the menu item if it's not a Unity project public override bool IsAvailable(IDataContext dataContext) { var project = dataContext.GetData(ProjectModelDataConstants.PROJECT); if (project == null || !project.IsUnityProject()) return false; return base.IsAvailable(dataContext); }
private static ITypeElement GetOriginTypeElement(IDataContext dataContext, DeclaredElementTypeUsageInfo initialTarget) { var data = dataContext.GetData(DataConstants.REFERENCES); if (data == null) { return null; } foreach (var current in data.OfType<IQualifiableReference>()) { if (!Equals(current.Resolve().DeclaredElement, initialTarget)) { continue; } var qualifierWithTypeElement = current.GetQualifier() as IQualifierWithTypeElement; if (qualifierWithTypeElement == null) { continue; } var qualifierTypeElement = qualifierWithTypeElement.GetQualifierTypeElement(); if (qualifierTypeElement != null) { return qualifierTypeElement; } } return null; }
public void initialize(Nullable<Gimnastika> gimnastika) { initializing = true; this.gimnastika = gimnastika; try { DataAccessProviderFactory factory = new DataAccessProviderFactory(); dataContext = factory.GetDataContext(); dataContext.BeginTransaction(); loadData(); initUI(); //dataContext.Commit(); initializing = false; } catch (Exception ex) { if (dataContext != null && dataContext.IsInTransaction) dataContext.Rollback(); throw new InfrastructureException( Strings.getFullDatabaseAccessExceptionMessage(ex), ex); } finally { if (dataContext != null) dataContext.Dispose(); dataContext = null; } }
public bool IsAvailable(IDataContext dataContext) { // todo make this resolvable also via the AllTypes... line var invokedNode = dataContext.GetSelectedTreeNode<IExpression>(); return cachedRegistrations.Any(r => r.Registration.RegistrationElement.Children().Contains(invokedNode)); }
/// <summary> /// Initializes a new instance of the RoleManager with data context. /// </summary> /// <param name="context">The data context object.</param> public RoleManager(IDataContext context) { this.DataContext = context; }
public AccountRepository(IDataContext dataContext) { _dataContext = dataContext; }
public static string GetFKName <T>(this IDataContext self, string listFieldName) where T : class { return(GetFKName(self, typeof(T), listFieldName)); }
public DealerService(IDataContext context, SecurityContext security) : base(context, security) { }
public GameDefinitionRetriever(IDataContext dataContext, IPlayerRepository playerRepository, IBoardGameGeekGameDefinitionInfoRetriever boardGameGeekGameDefinitionInfoRetriever) { _dataContext = dataContext; _playerRepository = playerRepository; _boardGameGeekGameDefinitionInfoRetriever = boardGameGeekGameDefinitionInfoRetriever; }
public VesselScheduleService(IDataContext dataContext) : base(dataContext) { }
public QuestionNotification( IByDisciplinesNotifiable notifiable, IDataContext context) : base(notifiable, context, context.QuestionNewsStorage) { }
protected override ISourceValue ResolveObjectInternal(object target, string name, IDataContext context, out bool keepValue) { var value = base.ResolveObjectInternal(target, name, context, out keepValue); if (value != null) { return(value); } keepValue = true; var item = TryFindResource(target, name); if (item != null) { return(new BindingResourceObject(item, true)); } var rootMember = BindingServiceProvider.VisualTreeManager.GetRootMember(target.GetType()); if (rootMember != null) { return(new XamlResourceWrapper(target, name, rootMember, GetOrAddDynamicResource(name, false))); } return(null); }
protected virtual IWindowViewMediator CreateWindowViewMediator([NotNull] IViewModel viewModel, Type viewType, [NotNull] IDataContext context) { return(TryCreateMediatorFromFactory(viewModel, viewType, context)); }
internal BlogSqlDataProvider(IDataContext context, IModelDataService <DataModel.VPost> modelDataService) : base(context) { _modelDataService = modelDataService ?? throw new ArgumentNullException(nameof(modelDataService)); }
public Task WaitCurrentNavigationAsync(IDataContext context = null) { return(_currentTask ?? Empty.Task); }
private void Show(IWindowViewMediator viewMediator, IAsyncOperation operation, IDataContext context, TaskCompletionSource <bool> tcs) { try { CallbackManager.Register(OperationType.WindowNavigation, viewMediator.ViewModel, operation.ToOperationCallback(), context); var task = viewMediator.ShowAsync(context); _currentTask = task; tcs.TrySetFromTask(task); } catch (Exception e) { tcs.TrySetException(e); throw; } }
public bool Update(IDataContext context, ActionPresentation presentation, DelegateUpdate nextUpdate) { // return true or false to enable/disable this action return(true); }
protected IWindowViewMediator TryCreateMediatorFromFactory([NotNull] IViewModel viewModel, Type viewType, [NotNull] IDataContext context) { lock (_mediatorRegistrations) { for (int i = 0; i < _mediatorRegistrations.Count; i++) { var mediator = _mediatorRegistrations[i].Invoke(viewModel, viewType, context); if (mediator != null) { return(mediator); } } } return(null); }
public GetAllDepartmentHandler(IDataContext dataContext, IMapper mapper, ICurrentUserProvider currentUserProvider) : base(dataContext, mapper, currentUserProvider) { }
public NodeRepository(IDataContext context) : base(context) { _context = context; }
public override GameDefinition Execute(CreateGameDefinitionRequest createGameDefinitionRequest, ApplicationUser currentUser, IDataContext dataContextWithTransaction) { ValidateNotNull(createGameDefinitionRequest); ValidateGameDefinitionNameIsNotNullOrWhitespace(createGameDefinitionRequest.Name); int gamingGroupId = createGameDefinitionRequest.GamingGroupId ?? currentUser.CurrentGamingGroupId; BoardGameGeekGameDefinition boardGameGeekGameDefinition = null; if (createGameDefinitionRequest.BoardGameGeekGameDefinitionId.HasValue) { boardGameGeekGameDefinition = _boardGameGeekGameDefinitionCreator.CreateBoardGameGeekGameDefinition( createGameDefinitionRequest.BoardGameGeekGameDefinitionId.Value, currentUser); } var existingGameDefinition = dataContextWithTransaction.GetQueryable <GameDefinition>() .FirstOrDefault(game => game.GamingGroupId == gamingGroupId && game.Name == createGameDefinitionRequest.Name); if (existingGameDefinition == null) { var newGameDefinition = new GameDefinition { Name = createGameDefinitionRequest.Name, BoardGameGeekGameDefinitionId = boardGameGeekGameDefinition?.Id, Description = createGameDefinitionRequest.Description, GamingGroupId = gamingGroupId }; new Task(() => _eventTracker.TrackGameDefinitionCreation(currentUser, createGameDefinitionRequest.Name)).Start(); return(dataContextWithTransaction.Save(newGameDefinition, currentUser)); } ValidateNotADuplicateGameDefinition(existingGameDefinition); existingGameDefinition.Active = true; existingGameDefinition.BoardGameGeekGameDefinitionId = boardGameGeekGameDefinition?.Id; if (!string.IsNullOrWhiteSpace(createGameDefinitionRequest.Description)) { existingGameDefinition.Description = createGameDefinitionRequest.Description; } return(dataContextWithTransaction.Save(existingGameDefinition, currentUser)); }
private static void OnViewCleared(IViewManager viewManager, IViewModel viewModel, object arg3, IDataContext arg4) { ClearBindingsRecursively(arg3 as DependencyObject); }
public PlayerAchievementRetriever(IDataContext dataContext) { _dataContext = dataContext; }
public GetUserRequestHandler( IDataContext context) { _context = context; }
/// <summary> /// Constructor. /// </summary> /// <param name="contextBase"></param> public Repository(IDataContext contextBase) { _contextBase = contextBase; }
/// <summary> /// Raised after the view model navigation. /// </summary> /// <param name="viewModel">The specified view model.</param> /// <param name="mode">The specified navigation mode.</param> /// <param name="context">The specified <see cref="IDataContext" />.</param> public virtual void OnNavigated(IViewModel viewModel, NavigationMode mode, IDataContext context) { OnNavigated(new NavigationContext(mode, CurrentViewModel, viewModel, this, context)); }
public static int Delete <T>([NotNull] this IDataContext dataContext, T obj) { return(Query <T> .Delete(DataContextInfo.Create(dataContext), obj)); }
/// <summary> /// Set context. /// </summary> /// <param name="context"></param> public override void SetContext(IDataContext context) { _contextBase = context; _context = (DbContext)_contextBase; }
public static object InsertWithIdentity <T>(this IDataContext dataContext, T obj) { return(Query <T> .InsertWithIdentity(DataContextInfo.Create(dataContext), obj)); }
public StickyController(IStickyService stickyService, IDataContext context) : base(context) { this.stickyService = stickyService; }
public static int InsertOrUpdate <T>(this IDataContext dataContext, T obj) { return(InsertOrReplace(dataContext, obj)); }
public static int Update <T>(this IDataContext dataContext, T obj) { return(Query <T> .Update(DataContextInfo.Create(dataContext), obj)); }
static public Table <T> GetTable <T>(this IDataContext dataContext) where T : class { return(new Table <T>(dataContext)); }
public static int InsertOrReplace <T>(this IDataContext dataContext, T obj) { return(Query <T> .InsertOrReplace(DataContextInfo.Create(dataContext), obj)); }