public OrganizationService(
IContextManager contextManager,
// IUserIdentification userIdentification,
ITranslationEntity translationManagerToVm,
ITranslationViewModel translationManagerToEntity,
// ILogger<Services.ChannelService> logger,
ICommonServiceInternal commonService,
// VmListItemLogic listItemLogic,
// DataUtils dataUtils,
// VmOwnerReferenceLogic ownerReferenceLogic,
ICacheManager cacheManager,
IPublishingStatusCache publishingStatusCache,
IUserOrganizationChecker userOrganizationChecker,
IVersioningManager versionManager,
ServiceUtilities utilities,
IValidationManager validationManager
) :
base(translationManagerToVm, translationManagerToEntity, publishingStatusCache, userOrganizationChecker, contextManager, utilities, commonService, validationManager)
{
this.contextManager = contextManager;
// this.logger = logger;
// this.userIdentification = userIdentification;
// this.listItemLogic = listItemLogic;
// this.dataUtils = dataUtils;
// this.ownerReferenceLogic = ownerReferenceLogic;
this.typesCache = cacheManager.TypesCache;
// this.languageCache = cacheManager.LanguageCache;
this.versionManager = versionManager;
}
public ApplicantController(IApplicantManager applicantManager, IValidationManager validationManager, IErrorMapper errorMapper, ILogger <ApplicantController> logger)
{
_applicantManager = applicantManager;
_validationManager = validationManager;
_errorMapper = errorMapper;
_logger = logger;
}
internal EntityServiceBase(ITranslationEntity translationManagerToVm, ITranslationViewModel translationManagerToEntity, IPublishingStatusCache publishingStatusCache, IUserOrganizationChecker userOrganizationChecker, IContextManager contextManager, ServiceUtilities utilities, ICommonServiceInternal commonService, IValidationManager validationManager) : base(translationManagerToVm, translationManagerToEntity, publishingStatusCache, userOrganizationChecker)
{
ContextManager = contextManager;
Utilities = utilities;
CommonService = commonService;
ValidationManager = validationManager;
}
public RecordManager(IFamilyBooksRepository familyBooksRepository, IValidationManager validationManager)
{
Guard.ArgumentNotNull(familyBooksRepository, "familyBooksRepository");
Guard.ArgumentNotNull(validationManager, "validationManager");
_familyBooksRepository = familyBooksRepository;
_validationManager = validationManager;
}
public OrganisationManager(IProvider <Guid, Organisation> provider,
IValidationManager <Organisation> validationManager,
IWorkflowManager <Organisation> workflowManager
)
: base(provider, validationManager, workflowManager)
{
}
public void InitProviders(IBinder binder, IValidationManager validationManager, IReporter reporter, ITemplatable templatable, ITranslator translator)
{
this.Binder = binder;
this.ValidationManager = validationManager;
this.Reporter = reporter;
this.Templatable = templatable;
this.Translator = translator;
}
public IdController(IUserManager userManager, IValidationManager manager, DataContext ctx, IConfiguration config, ILogger <IdController> logger)
{
_userManager = userManager;
_validManager = manager;
_context = ctx;
_config = config;
_logger = logger;
}
public TestDerivedManager(
IMapperRegistry mapper,
IProvider <int, TestEntity> provider,
IValidationManager <TestEntity> validationManager,
IWorkflowManager <TestEntity> workflowManager = null)
: base(provider, validationManager, workflowManager)
{
}
public TokenManager(ILoginConfig config, ILoginCredentials credentials, IResponseManager responseManager, IValidationManager validationManager, IOauthTokenFactory tokenFactory, IHttpHandler client)
{
this.config = config;
this.credentials = credentials;
this.responseManager = responseManager;
this.validationManager = validationManager;
this.tokenFactory = tokenFactory;
this.client = client;
}
/// <summary>
/// Initializes a new instance of the <see cref="ManagerBase{TId,TEntity,TSummary,TCriteria}" /> class.
/// </summary>
/// <param name="mapper">The mapper.</param>
/// <param name="provider">The provider.</param>
/// <param name="validationManager">The validation manager.</param>
/// <param name="workflowManager">The workflow manager.</param>
protected ManagerBase(
IProvider <TId, TEntity, TLookup, TSummary, TCriteria> provider,
IValidationManager <TEntity> validationManager = null,
IWorkflowManager <TEntity> workflowManager = null) : base(provider)
{
provider.GuardIsNotNull(nameof(provider));
Provider = provider;
ValidationManager = validationManager;
WorkflowManager = workflowManager;
}
public BaseValidationChecker(ICacheManager cacheManager, IResolveManager resolveManager)
{
this.validationMessagesDictionary = new Dictionary <Guid, List <ValidationMessage> >();
this.entityOrPublishedLanguagesAvailabilityIds = new List <Guid>();
this.validationPaths = new List <ValidationPath>();
this.typesCache = cacheManager.TypesCache;
this.resolveManager = resolveManager;
this.textManager = resolveManager.Resolve <ITextManager>();
this.validationManager = resolveManager.Resolve <IValidationManager>();
}
public MeasurementController(IMeasurementRepository repository,
ILogger logger, IMapper mapper,
IAquariumRepository aquariumRepository, IValidationManager validationManager,
IUnitManager unitManager,
IMeasurementManager measurementManager) : base(logger, mapper)
{
_repository = repository;
_aquariumRepository = aquariumRepository;
_validationManager = validationManager;
_unitManager = unitManager;
_measurementManager = measurementManager;
}
/// <summary>
/// Construtor padrão da classe
/// </summary>
/// <param name="entity">Entidade associada.</param>
/// <param name="entityTypeManager">Gerenciador dos tipos de entidades.</param>
/// <param name="validationManager">Instancia do gerenciador de validações.</param>
/// <param name="propertyChangeNotify">Método que receberá notificação de evento</param>
/// <param name="culture"></param>
public InstanceState(IEntity entity, IEntityTypeManager entityTypeManager, IValidationManager validationManager, System.ComponentModel.PropertyChangedEventHandler propertyChangeNotify, System.Globalization.CultureInfo culture)
{
entity.Require("entity").NotNull();
validationManager.Require("validationManager").NotNull();
propertyChangeNotify.Require("propertyChangeNotify").NotNull();
_specializedList = new Dictionary <string, Colosoft.Reflection.TypeName>();
_entityTypeManager = entityTypeManager;
_validationManager = validationManager;
_entity = entity;
_propertyChangeNotify = propertyChangeNotify;
_propertyAttributes = new Dictionary <string, IStatebleItem>();
LoadTypeSettings(culture);
_entity.PropertyChanged += EntityPropertyChanged;
}
public BusinessService(
IRepository repository,
ISubstitutionService substitutionService,
IValidationManager validationManager,
ITsvParser <TsvModel> tsvParser,
IRandomGenerator randomGenerator,
AppSettings appSettings
)
{
_repository = repository;
_substitutionService = substitutionService;
_validationManager = validationManager;
_tsvParser = tsvParser;
_randomGenerator = randomGenerator;
_appSettings = appSettings;
}
public ServiceTestBase()
{
VersioningManagerMock = new Mock <IVersioningManager>();
UserIdentificationMock = new Mock <IUserIdentification>();
CommonServiceMock = new Mock <ICommonServiceInternal>();
ExternalSourceRepoMock = new Mock <IExternalSourceRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IExternalSourceRepository>()).Returns(ExternalSourceRepoMock.Object);
ConnectionRepoMock = new Mock <IServiceServiceChannelRepository>();
unitOfWorkMockSetup.Setup(uw => uw.CreateRepository <IServiceServiceChannelRepository>()).Returns(ConnectionRepoMock.Object);
translationManagerMockSetup = new Mock <ITranslationEntity>();
translationManagerVModelMockSetup = new Mock <ITranslationViewModel>();
LockingManager = (new Mock <ILockingManager>()).Object;
VersioningManager = VersioningManagerMock.Object;
UserOrganizationChecker = (new Mock <IUserOrganizationChecker>()).Object;
UserIdentification = UserIdentificationMock.Object;
TranslationManagerVModel = translationManagerVModelMockSetup.Object;
AddressService = (new Mock <IAddressService>()).Object;
CommonService = CommonServiceMock.Object;
UserInfoService = (new Mock <IUserInfoService>()).Object;
UserOrganizationService = (new Mock <IUserOrganizationService>()).Object;
DataUtils = new DataUtils();
ValidationManagerMock = (new Mock <IValidationManager>()).Object;
PublishedId = PublishingStatusCache.Get(PublishingStatus.Published);
DeletedId = PublishingStatusCache.Get(PublishingStatus.Deleted);
OldPublishedId = PublishingStatusCache.Get(PublishingStatus.OldPublished);
var mapServiceProviderMock = new MapServiceProvider(
(new Mock <IHostingEnvironment>()).Object,
new ApplicationConfiguration((new Mock <IConfigurationRoot>()).Object),
(new Mock <IOptions <ProxyServerSettings> >()).Object,
new Mock <ILogger <MapServiceProvider> >().Object);
AddressLogic = new AddressLogic(mapServiceProviderMock);
}
public UserManager(IUserStore <IApplicationUser> store, IUnitOfWork unitOfWork, IValidationManager validationManager) : base(store)
{
_unitOfWork = unitOfWork;
_validationManager = validationManager;
UserValidator = new UserValidator <IApplicationUser>(this)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = true
};
// Configure validation logic for passwords
PasswordValidator = new PasswordValidator
{
RequiredLength = 6,
RequireNonLetterOrDigit = false,
RequireDigit = true
};
var provider = new DpapiDataProtectionProvider("Crimea-Mechanic");
UserTokenProvider = new DataProtectorTokenProvider <IApplicationUser, string>(provider.Create("UserToken"));
}
static void Main(string[] args)
{
GamerManager gamerManager = new GamerManager(new IValidationManager());
Gamer gamer = new Gamer()
{
FirstName = "Mutluhan", LastName = "Avcı", DateOfBirth = 1999, TCno = 123456789
};
Game game = new Game()
{
GameId = 1, GameName = "Call of Duty MW2", GamePrice = 120
};
gamerManager.Add(gamer);
IValidationManager validationManager = new IValidationManager();
validationManager.Validate(gamer);
CampaignManager campaign = new CampaignManager();
Campaign campaign1 = new Campaign()
{
CampaignName = "Cpt.Price", DiscountRate = 30, RaiseRate = 15
};
campaign.Add(campaign1, game);
campaign.Delete(campaign1, game);
campaign.Update(campaign1, game);
SaleManager sale = new SaleManager();
Sale sale1 = new Sale()
{
GameName = "Call of Duty MW2", Gamer = "Mutluhan Avcı", Price = 249
};
sale.Sales(game, gamer, sale1);
sale.CampaignSales(game, gamer, campaign1, sale1);
}
public StatusAPIController()
{
_repo = new StatusRepository();
_validationMngr = new StatusValidationManager(_repo);
}
public ApplicationMetadataValidationManager(IValidationManager validationManager, IApplicationMetadataProvider applicationMetadataProvider, IApplicationMetadataProviderValidator[] applicationMetadataProviderValidators)
{
_validationManager = validationManager;
_applicationMetadataProvider = applicationMetadataProvider;
_applicationMetadataProviderValidators = applicationMetadataProviderValidators;
}
public ApplicationManager(IUnitOfWork unitOfWork, IUserInternalManager userManager, IValidationManager validationManager) : base(unitOfWork, userManager)
{
_validationManager = validationManager;
}
public RequestController(IValidationManager manager)
{
_manager = manager;
}
public UserController(DataContext context, IUserManager userManager, IValidationManager val)
{
_context = context;
_userManager = userManager;
_validationManager = val;
}
public ValidationsTagHelper(IValidationManager validationManager)
{
_validationManager = validationManager;
}
public GamerManager(IValidationManager validation)
{
_validation = validation;
}
//private readonly IResourceManager _resourceManager;
public ValidationService()
{
this._iValidationManager = new ValidationManager();
//this._resourceManager = new ResourceManager();
}
public ViewModelDependencies(IViewModelFactory f, IFrozenContext frozenCtx, IPrincipalResolver principalResolver, IIconConverter iconConverter, IAssetsManager assetMgr, IValidationManager validationManager, IPerfCounter perfCounter)
{
Factory = f;
FrozenContext = frozenCtx;
PrincipalResolver = principalResolver;
IconConverter = iconConverter;
Assets = assetMgr;
ValidationManager = validationManager;
PerfCounter = perfCounter;
}
public MessageController(IApiService service, IAttachmentCreator attachmentCreator, IValidationManager validationManager)
{
_service = service;
_attachmentCreator = attachmentCreator;
_validationManager = validationManager;
}
/// <summary>
/// This method should be called before any of the other methods. It effectivly initializes the Validation Engine.
/// Use this overloaded method to provide your own custom validator and manager.
/// </summary>
/// <param name="validator">A <see cref="IValidator"/> representing a custom validator.</param>
/// <param name="manager">A <see cref="IValidationManager"/> representing a custom manager.</param>
/// <exception cref="System.InvalidOperationException">If the Engine has already been initialized, this will be thrown.</exception>
/// <exception cref="System.ArgumentNullException">If validator or manager are null.</exception>
public static void Initialize(IValidator validator, IValidationManager manager)
{
if (_isInitialized)
throw new InvalidOperationException("Initialization of the Validation Engine can only happen once.");
if (validator == null)
throw new ArgumentNullException("validator");
if (manager == null)
throw new ArgumentNullException("manager");
CurrentValidator = validator;
CurrentManager = manager;
CurrentValidator.RegisterService(typeof(IValidationManager), CurrentManager);
CurrentValidator.RegisterService(typeof(IValidator), CurrentValidator);
_isInitialized = true;
}
public CarServiceReviewManager(IUnitOfWork unitOfWork, IUserInternalManager userManager, IValidationManager validationManager) : base(unitOfWork, userManager)
{
_validationManager = validationManager;
}
public override IResult Parse(object source)
{
if (null == source)
{
throw new ArgumentNullException("source");
}
ContainerWebPart webPart = source as ContainerWebPart;
if (null == webPart)
{
throw new ArgumentException("source is not an ContainerWebPart");
}
IConfiguration config = webPart.Configuration;
if (null == config)
{
throw new ArgumentException("missing configuration");
}
IValidationManager validationManager = webPart.ValidationManager;
if (null == validationManager)
{
throw new ArgumentException("missing validation manager");
}
base.Parse(source);
if (config.Sections.ContainsKey("Template"))
{
IConfigurationSection templateConfig = config.GetConfigurationSectionReference("Template");
webPart.TemplateConfig = templateConfig;
}
else
{
webPart.TemplateConfig = config.NewConfigurationSectionInstance("Template");
}
if (config.Sections.ContainsKey("Validation"))
{
foreach (IConfigurationElement element in config.Sections["Validation"].Elements.Values)
{
IValidationTask task = validationManager.NewValidationTaskInstance();
if (element.Attributes.ContainsKey("target"))
{
task.Target = element.GetAttributeReference("target").Value;
}
if (element.Attributes.ContainsKey("member"))
{
task.Member = element.GetAttributeReference("member").Value.ToString();
}
foreach (IConfigurationElement handlerElement in element.Elements.Values)
{
if (handlerElement.Attributes.ContainsKey("handlerKey"))
{
string handlerKey = handlerElement.GetAttributeReference("handlerKey").Value.ToString();
IValidationHandler handler = validationManager.Handler(handlerKey);
if ("expression" == handlerKey)
{
IExpressionHandler expressionHandler = handler as IExpressionHandler;
IEnumerator <IConfigurationElement> enumerator = handlerElement.Elements.Values.GetEnumerator();
if (enumerator.MoveNext())
{
IConfigurationElement expressionElement = enumerator.Current;
expressionHandler.Expression = (validationManager.ExpressionsManager.Token(expressionElement.GetAttributeReference("type").Value.ToString()) as IExpression);
if (null == expressionHandler.Expression)
{
throw new InvalidOperationException("Token is not an IExpression");
}
expressionHandler.Expression.Make(expressionElement, validationManager.ExpressionsManager);
}
}
task.Handlers.Add(handler);
}
}
validationManager.RegisterTask(task);
}
}
if (config.Sections.ContainsKey("Checks"))
{
foreach (IConfigurationElement element in config.Sections["Checks"].Elements.Values)
{
if (element.Attributes.ContainsKey("command"))
{
string command = element.GetAttributeReference("command").Value.ToString();
webPart.Checks.Add(command, new List <Container.CheckDefinition>());
foreach (IConfigurationElement checkElement in element.Elements.Values)
{
Container.CheckDefinition check = new Container.CheckDefinition();
if (checkElement.Attributes.ContainsKey("error"))
{
check.Error = checkElement.GetAttributeReference("error").Value.ToString();
}
if (checkElement.Attributes.ContainsKey("milestone"))
{
check.Milestone = checkElement.GetAttributeReference("milestone").Value.ToString();
}
IEnumerator <IConfigurationElement> enumerator = checkElement.Elements.Values.GetEnumerator();
if (enumerator.MoveNext())
{
IConfigurationElement expressionElement = enumerator.Current;
IExpression expression = webPart.ExpressionsManager.Token(expressionElement.GetAttributeReference("type").Value.ToString()) as IExpression;
if (null == expression)
{
throw new InvalidOperationException("Token is not an IExpression");
}
expression.Make(expressionElement, webPart.ExpressionsManager);
check.Expression = expression;
}
webPart.Checks[command].Add(check);
}
}
}
}
return(null);
}
public void InitProviders(IBinder binder, IValidationManager validationManager, IReporter reporter, ITemplatable templatable, ITranslator translator)
{
this.Binder = binder;
this.ValidationManager = validationManager;
this.Reporter = reporter;
this.Templatable = templatable;
this.Translator = translator;
}
