protected override void BeginProcessing()
{
base.BeginProcessing();
var commitCommandFactory =
new CommitApiCommandFactory(
new ApiUriFactory(Connection.Host),
new CommitApiPostKeyValuePairFactory(this.Connection.AccessToken));
commitCommand = commitCommandFactory.CreateCommit(true);
activeDirectoryRepository = new ActiveDirectoryRepository(ForestName, Credential);
addressGroupSearchableRepository = new SearchableRepository <AddressGroupObject>(
new ConfigCommandFactory(
new ApiUriFactory(Connection.Host),
new ConfigPostKeyValuePairFactory(Connection.AccessToken, Connection.Vsys)),
Schema.AddressGroupSchemaName);
addressSearchableRepository = new SearchableRepository <AddressObject>(
new ConfigCommandFactory(
new ApiUriFactory(Connection.Host),
new ConfigPostKeyValuePairFactory(Connection.AccessToken, Connection.Vsys)),
Schema.AddressSchemaName);
addableRepository = new AddableRepository(
new ConfigCommandFactory(
new ApiUriFactory(Connection.Host),
new ConfigPostKeyValuePairFactory(Connection.AccessToken, Connection.Vsys)));
membershipRepository = new MembershipRepository(
new ConfigMembershipCommandFactory(
new ApiUriFactory(Connection.Host),
new ConfigMembershipPostKeyValuePairFactory(Connection.AccessToken, Connection.Vsys)));
}
internal GenericSpecification(
ISearchableRepository <T> repository,
ProtobufSerialization protobuf)
{
this.Repository = repository;
this.Protobuf = protobuf;
}
public SimpleSearchIconListAdapter(IImageRepository repo_in, string[] keywords_in)
{
repo = repo_in;
keywords = keywords_in;
image_id_to_index = new Hashtable();
// ask the repo to do the actual search for us
keyrepo = repo_in as ISearchableRepository;
if (keyrepo == null)
{
valid = false;
return;
}
image_ids = keyrepo.FindImagesByKeyword(keywords);
for (int i = 0; i < image_ids.Length; i++)
{
repo.GetImage(image_ids[i]).OnThumbnailChange += new ImageItem.ThumbnailChangeHandler(ImageThumbnailChanged);
image_id_to_index.Add(image_ids[i], i);
}
valid = true;
}
public PsAddSetTests(string verb, string noun, string schemaName)
{
this.verb = verb;
this.noun = noun;
psTestRunner = new PsTestRunner <T>();
searchableRepository = new SearchableRepository <T>(ConfigCommandFactory, schemaName);
}
public static Task <T[]> Search <T>(this ISearchableRepository <T> repository, ISpecification <T> specification)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(repository.Search(specification, null, null, null));
}
public QueueCommandHandler(IRepository <Guid, QueueInfo> queueRepository,
ISearchableRepository <Tuple <Guid, Guid>, QueueInfo> queryRepository)
{
Condition.Requires(queueRepository).IsNotNull();
Condition.Requires(queryRepository).IsNotNull();
m_QueueRepository = queueRepository;
m_QueryRepository = queryRepository;
}
public static GenericSpecification <T> Specification <T>(this ISearchableRepository <T> repository)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(new GenericSpecification <T>(repository, Static.Locator.Resolve <ProtobufSerialization>()));
}
public static SearchBuilder <T> Builder <T>(this ISearchableRepository <T> repository)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(new SearchBuilder <T>(repository));
}
public static Task <long> CountAll <T>(this ISearchableRepository <T> repository)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(repository.Count(null));
}
public static Task <long> Count <T>(
this ISearchableRepository <T> repository,
Expression <Func <T, bool> > filter)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(repository.Count(new ExpressionSpecification <T>(filter)));
}
public static SearchBuilder <T> Builder <T>(
this ISearchableRepository <T> repository,
Expression <Func <T, bool> > filter)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(new SearchBuilder <T>(repository).With(new ExpressionSpecification <T>(filter)));
}
public OrganizationCommandHandler(IRepository <Guid, Organization> organizationRepository,
ISearchableRepository <UserInfo, UserInfo> userRepository,
ICommandHandler <CreateUserCommand> createHandler)
{
Condition.Requires(organizationRepository).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
Condition.Requires(createHandler).IsNotNull();
m_OrganizationRepository = organizationRepository;
m_UserRepository = userRepository;
m_CreateHandler = createHandler;
}
public PersonService(
ISearchableRepository <Benday.EasyAuthDemo.Api.DataAccess.Entities.PersonEntity> repository,
IValidatorStrategy <Benday.EasyAuthDemo.Api.DomainModels.Person> validator,
IUsernameProvider usernameProvider, ISearchStringParserStrategy searchStringParser) :
base(usernameProvider)
{
_Repository = repository;
_ValidatorInstance = validator;
_SearchStringParser = searchStringParser;
_Adapter = new PersonAdapter();
}
public static Task <T[]> Search <T>(
this ISearchableRepository <T> repository,
Expression <Func <T, bool> > filter,
int?limit,
int?offset)
where T : class, ISearchable
{
if (repository == null)
{
throw new ArgumentNullException("repository can't be null");
}
return(repository.Search(new ExpressionSpecification <T>(filter), limit, offset, null));
}
public void InflateMembers <T, TDeserializer>(
ISearchableRepository <T> searchableRepository,
GroupFirewallObject groupFirewallObject,
ConfigTypes configType) where T : FirewallObject where TDeserializer : ApiResponseForGetAll
{
var allTObjects = searchableRepository.GetAll <TDeserializer>(configType);
groupFirewallObject.MemberObjects.AddRange(
(from tObject in allTObjects
where groupFirewallObject.Members.Contains(tObject.Key)
select tObject.Value)
.ToList());
}
private void UpdateFromID(ArrayList ids)
{
Console.WriteLine("here, ids: {0}", ids);
this.Clear();
image_ids.Clear();
kw_to_image_ids.Clear();
ISearchableRepository srepo = repo as ISearchableRepository;
if (srepo == null)
{
return;
}
if (ids == null)
{
return;
}
foreach (string imageid in ids)
{
image_ids.Add(imageid);
string[] kwds = srepo.GetImageKeywords(imageid);
foreach (string kw in kwds)
{
if (!kw_to_image_ids.Contains(kw))
{
kw_to_image_ids.Add(kw, new ArrayList());
}
((ArrayList)kw_to_image_ids[kw]).Add(imageid);
}
}
Gtk.TreeIter iter = new Gtk.TreeIter();
foreach (string kw in kw_to_image_ids.Keys)
{
this.Append(out iter);
if (((ArrayList)kw_to_image_ids[kw]).Count == image_ids.Count)
{
// this keyword is present on all the images
this.SetValue(iter, 0, new GLib.Value(kw));
}
else
{
// this keyword is present only on some images
this.SetValue(iter, 0, new GLib.Value("<i>" + kw + "</i>"));
}
this.SetValue(iter, 1, new GLib.Value(kw));
}
}
public AuthorizationController(IAuthorizationTokenProvider tokenProvider,
ICommandHandler <CreateUserCommand> userCommandHandler,
ISearchableRepository <UserInfo, UserInfo> searchRepository,
IHashProvider hashProvider,
IRepository <UserInfo, UserInfo> userRepository)
{
Condition.Requires(tokenProvider).IsNotNull();
Condition.Requires(userCommandHandler).IsNotNull();
Condition.Requires(searchRepository).IsNotNull();
Condition.Requires(hashProvider).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
m_TokenProvider = tokenProvider;
m_UserCommandHandler = userCommandHandler;
m_SearchRepository = searchRepository;
m_HashProvider = hashProvider;
}
public UserCommandHandler(IHashProvider hashProvider,
IRepository <UserInfo, UserInfo> userRepository,
IMessager messager,
IAuthorizationTokenProvider tokenProvider,
ISearchableRepository <UserInfo, UserInfo> searchRepository)
{
Condition.Requires(tokenProvider).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
Condition.Requires(hashProvider).IsNotNull();
Condition.Requires(messager).IsNotNull();
Condition.Requires(searchRepository).IsNotNull();
m_UserRepository = userRepository;
m_HashProvider = hashProvider;
m_Messager = messager;
m_TokenProvider = tokenProvider;
m_SearchRepository = searchRepository;
}
public UserController(IAuthorizationTokenProvider tokenProvider,
IRepository <UserInfo, UserInfo> userRepository,
ISearchableRepository <UserInfo, UserInfo> searchRepository,
ICommandHandler <ResetPasswordCommand> commandHandler,
ICommandHandler <SetPasswordCommand> setPasswordHandler)
{
Condition.Requires(tokenProvider).IsNotNull();
Condition.Requires(userRepository).IsNotNull();
Condition.Requires(commandHandler).IsNotNull();
Condition.Requires(searchRepository).IsNotNull();
Condition.Requires(setPasswordHandler).IsNotNull();
m_TokenProvider = tokenProvider;
m_UserRepository = userRepository;
m_CommandHandler = commandHandler;
m_SearchRepository = searchRepository;
m_SetPasswordHandler = setPasswordHandler;
}
public void KeywordEntryActivated(object o, EventArgs ea)
{
string[] imageids = store.CurrentIDs;
if (imageids == null || imageids.Length == 0)
{
return;
}
ISearchableRepository srepo = repo as ISearchableRepository;
if (srepo == null)
{
return;
}
string kwstring = keyword_entry.Text;
kwstring = kwstring.Trim();
if (kwstring == "")
{
return;
}
string[] kws = kwstring.Split(',', '\n', '\r');
if (kws.Length == 0)
{
return;
}
for (int i = 0; i < kws.Length; i++)
{
kws[i] = kws[i].Trim();
if (kws[i] != "")
{
foreach (string iid in imageids)
{
srepo.AddImageKeyword(iid, kws[i]);
}
}
}
keyword_entry.Text = "";
}
public SimpleSearchIconListAdapter (IImageRepository repo_in, string[] keywords_in)
{
repo = repo_in;
keywords = keywords_in;
image_id_to_index = new Hashtable ();
// ask the repo to do the actual search for us
keyrepo = repo_in as ISearchableRepository;
if (keyrepo == null) {
valid = false;
return;
}
image_ids = keyrepo.FindImagesByKeyword (keywords);
for (int i = 0; i < image_ids.Length; i++) {
repo.GetImage(image_ids[i]).OnThumbnailChange += new ImageItem.ThumbnailChangeHandler (ImageThumbnailChanged);
image_id_to_index.Add (image_ids[i], i);
}
valid = true;
}
public GetTests(string schemaName, ConfigTypes configType)
{
this.schemaName = schemaName;
this.configType = configType;
searchableRepository = new SearchableRepository <T>(ConfigCommandFactory, schemaName);
}
public PsDeleteTests(string noun, string schemaName)
{
this.noun = noun;
psTestRunner = new PsTestRunner <T>();
searchableRepository = new SearchableRepository <T>(ConfigCommandFactory, schemaName);
}
public RenameTests(string schemaName)
{
searchableRepository = new SearchableRepository <T>(ConfigCommandFactory, schemaName);
renamableRepository = new RenamableRepository(ConfigCommandFactory);
}
public DeleteTests(string schemaName)
{
searchableRepository = new SearchableRepository <T>(ConfigCommandFactory, schemaName);
}
public PsAddMemberTests(string noun, string groupSchemaName)
{
this.noun = noun;
psTestRunner = new PsTestRunner <TGroup>();
searchableRepository = new SearchableRepository <TGroup>(ConfigCommandFactory, groupSchemaName);
}
internal SearchBuilder(ISearchableRepository <T> repository)
{
this.Repository = repository;
}
public MapEntitiesController(SqlConnectionFactory f)
{
_repository = new MapEntityRepository(f, new MapEntityValidator(new MetaObjectValidator(new MetaFieldRepository(f))));
_mapRepository = new MapRepository(f);
}
