public RegionsByGeoServicesEntitySeeder(IProcessQueries queryProcessor
, IQueryEntities entities
)
{
_queryProcessor = queryProcessor;
_entities = entities;
}
public ValidateUpdateEstablishmentNameCommand(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
// id must be within valid range and exist in the database
RuleFor(x => x.Id)
.GreaterThanOrEqualTo(1)
.WithMessage(MustBePositivePrimaryKey.FailMessageFormat, x => "Establishment name id", x => x.Id)
.MustFindEstablishmentNameById(entities)
.WithMessage(MustFindEstablishmentNameById.FailMessageFormat, x => x.Id)
;
// text of the establishment name is required, has max length, and must be unique
RuleFor(x => x.Text)
.NotEmpty()
.WithMessage(MustNotBeEmpty.FailMessageFormat, x => "Establishment name")
.Length(1, EstablishmentNameConstraints.TextMaxLength)
.WithMessage(MustNotExceedStringLength.FailMessageFormat,
x => "Establishment name", x => EstablishmentNameConstraints.TextMaxLength, x => x.Text.Length)
.MustBeUniqueEstablishmentNameText(entities, x => x.Id)
.Unless(x => x.IsContextName, ApplyConditionTo.CurrentValidator)
.WithMessage(MustBeUniqueEstablishmentNameText <object> .FailMessageFormat, x => x.Text)
;
// when the establishment name is official, it cannot be a former / defunct name
When(x => x.IsOfficialName, () =>
RuleFor(x => x.IsFormerName).Equal(false)
.WithMessage(MustNotBeFormerEstablishmentNameWhenIsOfficial.FailMessage)
);
}
public ValidateUpdateEstablishmentUrlCommand(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(x => x.Id)
// id must be within valid range
.GreaterThanOrEqualTo(1)
.WithMessage(MustBePositivePrimaryKey.FailMessageFormat, x => "Establishment URL id", x => x.Id)
// id must exist in the database
.MustFindEstablishmentUrlById(entities)
.WithMessage(MustFindEstablishmentUrlById.FailMessageFormat, x => x.Id)
;
// value of the establishment URL is required, has max length, follows format, and must be unique
RuleFor(x => x.Value)
.NotEmpty()
.WithMessage(MustNotBeEmpty.FailMessageFormat, x => "Establishment URL")
.Length(1, EstablishmentUrlConstraints.ValueMaxLength)
.WithMessage(MustNotExceedStringLength.FailMessageFormat,
x => "Establishment URL", x => EstablishmentUrlConstraints.ValueMaxLength, x => x.Value.Length)
.MustNotContainUrlProtocol()
.WithMessage(MustNotContainUrlProtocol.FailMessage)
.MustBeWellFormedUrl()
.WithMessage(MustBeWellFormedUrl.FailMessageFormat, x => x.Value)
.MustBeUniqueEstablishmentUrlValue(entities, x => x.Id)
.WithMessage(MustBeUniqueEstablishmentUrlValue <object> .FailMessageFormat, x => x.Value)
;
// when the establishment URL is official, it cannot be former / defunct
When(x => x.IsOfficialUrl, () =>
RuleFor(x => x.IsFormerUrl).Equal(false)
.WithMessage(MustNotBeFormerEstablishmentUrlWhenIsOfficial.FailMessage)
);
}
public HandleParticipantByAgreementIdAndEstablishmentIdQuery(IQueryEntities entities
, IProcessQueries queryProcessor
)
{
_entities = entities;
_queryProcessor = queryProcessor;
}
public ValidateUpdateMyPhotoCommand(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(x => x.Principal)
.NotNull()
.WithMessage(MustNotHaveNullPrincipal.FailMessage)
.MustNotHaveEmptyIdentityName()
.WithMessage(MustNotHaveEmptyIdentityName.FailMessage)
.MustFindUserByPrincipal(entities)
;
RuleFor(x => x.Content)
.NotNull().WithMessage(MustHaveFileContent.FailMessage)
.Must(x => x.Length > 0).WithMessage(MustHaveFileContent.FailMessage)
.MustNotExceedFileSize(1, FileSizeUnitName.Megabyte, x => x.Name)
;
RuleFor(x => x.Name)
.NotEmpty().WithMessage(MustHaveFileName.FailMessage)
.MustHaveAllowedFileExtension(PersonConstraints.AllowedPhotoFileExtensions)
;
RuleFor(x => x.MimeType)
.NotEmpty().WithMessage(MustHaveFileMimeType.FailMessage)
;
}
public ExternalFileEntitySeeder(IStoreBinaryData binaryData
, IQueryEntities entities
)
{
_binaryData = binaryData;
_entities = entities;
}
public static bool TokenMatchesEntity(Guid token, IQueryEntities entities,
IEnumerable <Expression <Func <EmailConfirmation, object> > > eagerLoad = null)
{
EmailConfirmation entity;
return(TokenMatchesEntity(token, entities, eagerLoad, out entity));
}
public ValidateCreateEstablishmentNameCommand(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
When(x => x.Owner == null, () =>
RuleFor(x => x.OwnerId.HasValue).Equal(true).WithMessage("Establishment Name owner id must be provided.")
);
// owner id must exist in the database when in valid range
When(x => x.OwnerId.HasValue, () =>
RuleFor(x => x.OwnerId.Value)
.MustFindEstablishmentById(entities)
.WithMessage(MustFindEstablishmentById.FailMessageFormat, x => x.OwnerId)
);
// text of the establishment name is required, has max length, and must be unique
RuleFor(x => x.Text)
.NotEmpty()
.WithMessage(MustNotBeEmpty.FailMessageFormat, x => "Establishment name")
.Length(1, EstablishmentNameConstraints.TextMaxLength)
.WithMessage(MustNotExceedStringLength.FailMessageFormat,
x => "Establishment name", x => EstablishmentNameConstraints.TextMaxLength, x => x.Text.Length)
.MustBeUniqueEstablishmentNameText(entities)
.Unless(x => x.IsContextName, ApplyConditionTo.CurrentValidator)
.WithMessage(MustBeUniqueEstablishmentNameText <object> .FailMessageFormat, x => x.Text)
;
// when the establishment name is official, it cannot be a former / defunct name
When(x => x.IsOfficialName, () =>
RuleFor(x => x.IsFormerName).Equal(false)
.WithMessage(MustNotBeFormerEstablishmentNameWhenIsOfficial.FailMessage)
);
}
public HandlePartnerParticipantsByOwnerDomainQuery(IQueryEntities entities
, IProcessQueries queryProcessor
)
{
_entities = entities;
_queryProcessor = queryProcessor;
}
public ValidatePurgeContactPhoneCommand(IQueryEntities entities, IProcessQueries queryProcessor)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
// principal must be authorized to perform this action
RuleFor(x => x.Principal)
.NotNull()
.WithMessage(MustNotHaveNullPrincipal.FailMessage)
.MustNotHaveEmptyIdentityName()
.WithMessage(MustNotHaveEmptyIdentityName.FailMessage)
.MustBeInAnyRole(RoleName.AgreementManagers)
;
RuleFor(x => x.AgreementId)
// agreement id must exist
.MustFindAgreementById(entities)
.WithMessage(MustFindAgreementById <object> .FailMessageFormat, x => x.AgreementId)
// principal must own agreement
.MustBeOwnedByPrincipal(queryProcessor, x => x.Principal)
.WithMessage(MustBeOwnedByPrincipal <object> .FailMessageFormat, x => x.AgreementId, x => x.Principal.Identity.Name)
// contact id must exist under this agreement
.MustOwnContactWithId(entities, x => x.ContactId)
.WithMessage(MustOwnContactWithId <object> .FailMessageFormat, x => x.AgreementId, x => x.ContactId)
// phone id must exist under this agreement & contact
.MustOwnContactPhoneWithId(entities, x => x.ContactId, x => x.PhoneId)
.WithMessage(MustOwnContactPhoneWithId <object> .FailMessageFormat, x => x.PhoneId, x => x.ContactId, x => x.AgreementId)
;
}
public ValidateUpdateEstablishmentLocationCommand(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
When(x => x.Entity == null, () =>
RuleFor(x => x.Id.HasValue).Equal(true).WithMessage("Establishment Location owner id must be provided.")
);
// id must be within valid range and exist in the database
When(x => x.Id.HasValue, () =>
RuleFor(x => x.Id.Value)
.GreaterThanOrEqualTo(1)
.WithMessage(MustBePositivePrimaryKey.FailMessageFormat, x => "Establishment id", x => x.Id)
.MustFindEstablishmentById(entities)
.WithMessage(MustFindEstablishmentById.FailMessageFormat, x => x.Id)
);
// text of the establishment name is required, has max length, and must be unique
//RuleFor(x => x.Principal)
// .Must(x => x.IsInRole(RoleName.EstablishmentAdministrator))
// .WithMessage("User '{0}' is not authorized to execute this command.", x => x.Principal.Identity.Name)
//;
// place must exist if specified
When(x => x.PlaceId.HasValue, () =>
RuleFor(x => x.PlaceId.Value)
.MustFindPlaceById(entities)
);
}
public HandleMyUsersQuery(IQueryEntities entities
, IProcessQueries queryProcessor
)
{
_entities = entities;
_queryProcessor = queryProcessor;
}
public ValidateRevokeRoleFromUserCommand(IQueryEntities entities, IProcessQueries queryProcessor)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(x => x.Principal)
.NotNull()
.WithMessage(MustNotHaveNullPrincipal.FailMessage)
// principal.identity.name cannot be null or empty
.MustNotHaveEmptyIdentityName()
.WithMessage(MustNotHaveEmptyIdentityName.FailMessage)
// principal.identity.name must match User.Name entity property
.MustFindUserByPrincipal(entities)
// principal must be authorized to revoke roles
.MustBeInAnyRole(RoleName.RoleGrantors)
;
RuleFor(x => x.UserId)
.MustFindUserById(entities)
.WithMessage(MustFindUserById.FailMessageFormat, x => x.UserId)
;
RuleFor(x => x.RoleId)
.MustFindRoleById(entities)
.WithMessage(MustFindRoleById.FailMessageFormat, x => x.RoleId)
// each tenant must have at least one security admin
.MustNotRevokeOnlyGrant(queryProcessor, RoleName.SecurityAdministrator, x => x.Principal, x => x.UserId)
.WithMessage(MustNotRevokeOnlyGrant <object> .FailMessageFormat, x => RoleName.SecurityAdministrator)
// system must always have at least one authorization agent
.MustNotRevokeOnlyGrant(queryProcessor, RoleName.AuthorizationAgent, x => x.Principal)
.WithMessage(MustNotRevokeOnlyGrant <object> .FailMessageFormat, x => RoleName.AuthorizationAgent)
// cannot remove self from authorization agent role
.MustNotRevokeOwnGrant(queryProcessor, RoleName.AuthorizationAgent, x => x.Principal, x => x.UserId)
.WithMessage(MustNotRevokeOwnGrant <object> .FailMessageFormat, x => RoleName.AuthorizationAgent)
;
When(x => !x.Principal.IsInRole(RoleName.AuthorizationAgent), () =>
{
RuleFor(x => x.RoleId)
// do not let security admins revoke non-tenant roles
.MustBeTenantRole(entities)
.WithMessage(MustBeTenantRole.FailMessageFormat, x => x.Principal.Identity.Name, x => x.GetType().Name, x => x.RoleId)
// cannot remove self from security admin role
.MustNotRevokeOwnGrant(queryProcessor, RoleName.SecurityAdministrator, x => x.Principal, x => x.UserId)
.WithMessage(MustNotRevokeOwnGrant <object> .FailMessageFormat, x => RoleName.SecurityAdministrator)
;
RuleFor(x => x.UserId)
// do not let security admins revoke from users outside of their tenancy
.MustBeTenantUserId(queryProcessor, x => x.Principal)
.WithMessage(MustBeTenantUserId <object> .FailMessageFormat, x => x.Principal.Identity.Name, x => x.GetType().Name, x => x.UserId)
;
});
}
public static bool ValueMatchesPerson(string value, IQueryEntities entities,
IEnumerable <Expression <Func <Person, object> > > eagerLoad = null)
{
Person person;
return(ValueMatchesPerson(value, entities, eagerLoad, out person));
}
public ConfirmEmailValidator(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
EmailConfirmation confirmation = null;
RuleFor(p => p.SecretCode)
// secret cannot be empty
.NotEmpty()
.WithMessage(FailedBecauseSecretCodeWasEmpty)
// token must match a confirmation
.Must((o, p) => ValidateEmailConfirmation.TokenMatchesEntity(o.Token, entities, out confirmation))
.WithMessage(FailedBecauseOfInconsistentData)
// intent must match entity
.Must((o, p) => ValidateEmailConfirmation.IntentIsCorrect(confirmation, o.Intent))
.WithMessage(FailedBecauseOfInconsistentData)
;
RuleFor(p => p.SecretCode)
// secret must match entity
.Must(p => ValidateEmailConfirmation.SecretCodeIsCorrect(confirmation, p))
.When(p =>
!string.IsNullOrWhiteSpace(p.SecretCode) &&
confirmation != null &&
ValidateEmailConfirmation.IntentIsCorrect(confirmation, p.Intent))
.WithMessage(FailedBecauseSecretCodeWasIncorrect)
;
}
public ValidatePurgeParticipantCommand(IQueryEntities entities, IProcessQueries queryProcessor)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
// principal must be authorized to perform this action
RuleFor(x => x.Principal)
.NotNull()
.WithMessage(MustNotHaveNullPrincipal.FailMessage)
.MustNotHaveEmptyIdentityName()
.WithMessage(MustNotHaveEmptyIdentityName.FailMessage)
.MustBeInAnyRole(RoleName.AgreementManagers)
;
RuleFor(x => x.AgreementId)
// agreement id must exist
.MustFindAgreementById(entities)
.WithMessage(MustFindAgreementById <object> .FailMessageFormat, x => x.AgreementId)
// principal must own agreement
.MustBeOwnedByPrincipal(queryProcessor, x => x.Principal)
.WithMessage(MustBeOwnedByPrincipal <object> .FailMessageFormat, x => x.AgreementId, x => x.Principal.Identity.Name)
// establishment id must exist under this agreement
.MustOwnParticipantWithId(entities, x => x.EstablishmentId)
.WithMessage(MustOwnParticipantWithId <object> .FailMessageFormat, x => x.EstablishmentId, x => x.AgreementId)
;
// cannot be only remaining owner participant
RuleFor(x => x.EstablishmentId)
.MustNotBeOnlyOwningParticipant(queryProcessor, x => x.AgreementId, x => x.Principal)
.WithMessage(MustNotBeOnlyOwningParticipant <object> .FailMessageFormat, x => x.EstablishmentId, x => x.AgreementId);
}
public ExternalFileEntitySeeder(IStoreBinaryData binaryData
, IQueryEntities entities
)
{
_binaryData = binaryData;
_entities = entities;
}
private static IQueryable <TEntity> EagerLoad <TEntity>(this IQueryable <TEntity> queryable,
Expression <Func <TEntity, object> > expression,
IQueryEntities entities)
where TEntity : Entity
{
return(entities.EagerLoad(queryable, expression));
}
public static bool IdMatchesEntity(int id, IQueryEntities entities,
IEnumerable <Expression <Func <Person, object> > > eagerLoad = null)
{
Person entity;
return(IdMatchesEntity(id, entities, eagerLoad, out entity));
}
public UpdateMyAffiliationValidator(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
var eagerLoad = new Expression <Func <Establishment, object> >[]
{
e => e.Type.Category,
};
RuleFor(p => p.Principal)
// principal cannot be null
.NotEmpty()
.WithMessage(ValidatePrincipal.FailedBecausePrincipalWasNull)
// principal.identity.name cannot be null, empty, or whitespace
.Must(ValidatePrincipal.IdentityNameIsNotEmpty)
.WithMessage(ValidatePrincipal.FailedBecauseIdentityNameWasEmpty)
// principal.identity.name must match User.Name entity property
.Must(p => ValidatePrincipal.IdentityNameMatchesUser(p, entities))
.WithMessage(ValidatePrincipal.FailedBecauseIdentityNameMatchedNoUser,
p => p.Principal.Identity.Name)
;
RuleFor(p => p.EstablishmentId)
// establishment id must exist in database
.Must(p => ValidateEstablishment.IdMatchesEntity(p, entities, eagerLoad))
.WithMessage(ValidateEstablishment.FailedBecauseIdMatchedNoEntity,
p => p.EstablishmentId)
;
}
public static bool EmailMatchesEntity(string email, IQueryEntities entities,
IEnumerable <Expression <Func <Establishment, object> > > eagerLoad = null)
{
Establishment entity;
return(EmailMatchesEntity(email, entities, eagerLoad, out entity));
}
public static bool EmailMatchesEntity(string email, IQueryEntities entities,
IEnumerable<Expression<Func<Establishment, object>>> eagerLoad, out Establishment entity)
{
entity = entities.Query<Establishment>().EagerLoad(entities, eagerLoad).ByEmail(email);
// return true (valid) if there is an entity
return entity != null;
}
internal MustNotExceedFileSize(decimal fileSizeInBytes, FileSizeUnitName unit, Func <T, string> fileName, IQueryEntities entities)
: base(FailMessageFormat.Replace("{0}", "{FileName}").Replace("{1}", "{ActualSize}").Replace("{2}", "{MaxSize}"))
{
_fileSizeInBytes = fileSizeInBytes;
_fileName = fileName;
_unit = unit;
_entities = entities;
}
public static bool EmailMatchesEntity(string email, IQueryEntities entities,
IEnumerable <Expression <Func <Establishment, object> > > eagerLoad, out Establishment entity)
{
entity = entities.Query <Establishment>().EagerLoad(entities, eagerLoad).ByEmail(email);
// return true (valid) if there is an entity
return(entity != null);
}
public HandleCreateActivityDocumentCommand(ICommandEntities entities
, IQueryEntities detachedEntities
, IStoreBinaryData binaryData
)
{
_entities = entities;
_detachedEntities = detachedEntities;
_binaryData = binaryData;
}
public ValidateCreateEmployeeModuleSettingsCommand(IQueryEntities entities)
{
CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(x => x.EstablishmentId)
.MustFindEstablishmentById(entities)
.WithMessage(MustFindEstablishmentById.FailMessageFormat, x => x.EstablishmentId)
;
}
internal MustNotBeOnlyEstablishmentName(IQueryEntities entities)
: base(FailMessageFormat.Replace("{0}", "{PropertyValue}"))
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
_entities = entities;
}
internal MustFindUserByPrincipal(IQueryEntities entities)
: base(FailMessageFormat)
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
_entities = entities;
}
internal MustFindRoleById(IQueryEntities entities)
: base(FailMessageFormat.Replace("{0}", "{PropertyValue}"))
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
_entities = entities;
}
internal MustNotBeDefaultAffiliation(IQueryEntities entities)
: base(FailMessageFormat.Replace("{0}", "{AffiliationId}"))
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
_entities = entities;
}
internal MustFindPlaceById(IQueryEntities entities)
: base("Place with id '{PropertyValue}' does not exist.")
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
_entities = entities;
}
internal MustFindAgreementById(IQueryEntities entities)
: base(FailMessageFormatter)
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
_entities = entities;
}
public HandleMyAgreementSettingsQuery(IProcessQueries queryProcessor
, ICommandEntities entities
, IQueryEntities detachedEntities
)
{
_queryProcessor = queryProcessor;
_entities = entities;
_detachedEntities = detachedEntities;
}
//private readonly IManageViews _viewManager;
//private readonly ActivityViewProjector _activityProjector;
public FacultyStaffController(IProcessQueries queryProcessor
, IQueryEntities entities
//,IManageViews viewManager
//, ActivityViewProjector activityProjector
)
{
_queryProcessor = queryProcessor;
_entities = entities;
//_viewManager = viewManager;
//_activityProjector = activityProjector;
}
public WaterBodiesByGeoServicesEntitySeeder(IProcessQueries queryProcessor
, IQueryEntities entities
, IContainGeoPlanet geoPlanet
, IContainGeoNames geoNames
)
{
_queryProcessor = queryProcessor;
_entities = entities;
_geoPlanet = geoPlanet;
_geoNames = geoNames;
}
public UserEntitySeeder(IProcessQueries queryProcessor
, IQueryEntities entities
, IHandleCommands<CreatePerson> createPerson
, IHandleCommands<CreateEmailAddress> createEmail
, IHandleCommands<CreateUser> createUser
, IHandleCommands<GrantRoleToUser> grantRole
, IUnitOfWork unitOfWork
)
: base(queryProcessor, entities, createPerson, createEmail, createUser)
{
_queryProcessor = queryProcessor;
_grantRole = grantRole;
_unitOfWork = unitOfWork;
}
public static bool TokenMatchesEntity(Guid token, IQueryEntities entities,
IEnumerable<Expression<Func<EmailConfirmation, object>>> eagerLoad, out EmailConfirmation entity)
{
if (token == Guid.Empty)
{
entity = null;
return false;
}
entity = entities.Query<EmailConfirmation>().EagerLoad(entities, eagerLoad).ByToken(token);
// return true (valid) if there is an entity
return entity != null;
}
public static bool ValueMatchesPerson(string value, IQueryEntities entities,
IEnumerable<Expression<Func<Person, object>>> eagerLoad, out Person person)
{
if (entities == null)
{
person = null;
return false;
}
person = entities.Query<Person>().EagerLoad(entities, eagerLoad).ByEmail(value);
// return true (valid) if there is an entity
return person != null;
}
public static bool NumberAndPrincipalMatchesEntity(int number, IPrincipal principal, IQueryEntities entities,
out EmailAddress entity)
{
if (entities == null)
{
entity = null;
return false;
}
entity = entities.Query<EmailAddress>().ByUserNameAndNumber(principal.Identity.Name, number);
// return true (valid) if there is an entity
return entity != null;
}
public static bool IdentityNameMatchesUser(IPrincipal principal, IQueryEntities entities, IEnumerable<Expression<Func<User, object>>> eagerLoad, out User entity)
{
if (entities == null)
{
entity = null;
return false;
}
entity = entities.Query<User>()
.EagerLoad(entities, eagerLoad)
.ByName(principal.Identity.Name);
// return true (valid) if there is an entity
return entity != null;
}
public CompositeSqlSeeder(IUnitOfWork unitOfWork
, IQueryEntities entities
, DevelopmentSqlSeeder sqlSeeder
, MemberEntitySeeder memberEntitySeeder
, ExternalFileEntitySeeder externalFileEntitySeeder
, PrivateSqlSeeder privateSeeder
)
{
_unitOfWork = unitOfWork;
_entities = entities;
_sqlSeeder = sqlSeeder;
_memberEntitySeeder = memberEntitySeeder;
_externalFileEntitySeeder = externalFileEntitySeeder;
_privateSeeder = privateSeeder;
}
public static bool IdMatchesEntity(int id, IQueryEntities entities,
IEnumerable<Expression<Func<Person, object>>> eagerLoad, out Person entity)
{
if (id < 0)
{
entity = null;
return false;
}
entity = entities.Query<Person>()
.EagerLoad(entities, eagerLoad).By(id);
// return true (valid) if there is an entity
return entity != null;
}
public CompositeSqlSeeder(IUnitOfWork unitOfWork
, IQueryEntities entities
, DevelopmentSqlSeeder sqlSeeder
, MemberEntitySeeder memberEntitySeeder
, LoadableFileEntitySeeder loadableFileEntitySeeder
, ImageEntitySeeder imageEntitySeeder
, ExternalFileEntitySeeder externalFileEntitySeeder
)
{
_unitOfWork = unitOfWork;
_entities = entities;
_sqlSeeder = sqlSeeder;
_memberEntitySeeder = memberEntitySeeder;
_loadableFileEntitySeeder = loadableFileEntitySeeder;
_imageEntitySeeder = imageEntitySeeder;
_externalFileEntitySeeder = externalFileEntitySeeder;
}
public static bool IdMatchesEntity(int id, IQueryEntities entities,
IEnumerable<Expression<Func<Person, object>>> eagerLoad = null)
{
Person entity;
return IdMatchesEntity(id, entities, eagerLoad, out entity);
}
public static bool EmailMatchesEntity(string email, IQueryEntities entities, out Establishment entity)
{
return EmailMatchesEntity(email, entities, null, out entity);
}
public FacultyStaffController(IProcessQueries queryProcessor, IQueryEntities entities)
{
_queryProcessor = queryProcessor;
_entities = entities;
}
public static bool IdentityNameMatchesUser(IPrincipal principal, IQueryEntities entities, IEnumerable<Expression<Func<User, object>>> eagerLoad = null)
{
User entity;
return IdentityNameMatchesUser(principal, entities, eagerLoad, out entity);
}
public static bool ValueMatchesPerson(string value, IQueryEntities entities, out Person person)
{
return ValueMatchesPerson(value, entities, null, out person);
}
public static bool IdMatchesEntity(int id, IQueryEntities entities, out Person entity)
{
return IdMatchesEntity(id, entities, null, out entity);
}
public MemberEntitySeeder(IQueryEntities entities)
{
_entities = entities;
}
public static bool ValueMatchesPerson(string value, IQueryEntities entities,
IEnumerable<Expression<Func<Person, object>>> eagerLoad = null)
{
Person person;
return ValueMatchesPerson(value, entities, eagerLoad, out person);
}
public static bool IdentityNameMatchesUser(IPrincipal principal, IQueryEntities entities, out User entity)
{
return IdentityNameMatchesUser(principal, entities, null, out entity);
}
public static bool TokenMatchesEntity(Guid token, IQueryEntities entities, out EmailConfirmation entity)
{
return TokenMatchesEntity(token, entities, null, out entity);
}
private static ResetPasswordValidator CreateValidator(IQueryEntities entities = null, IStorePasswords passwords = null)
{
return new ResetPasswordValidator(entities, passwords);
}
public CoreSqlSeeder(IQueryEntities entities)
: base(entities as DbContext)
{
_entities = entities;
}
public static bool EmailMatchesEntity(string email, IQueryEntities entities,
IEnumerable<Expression<Func<Establishment, object>>> eagerLoad = null)
{
Establishment entity;
return EmailMatchesEntity(email, entities, eagerLoad, out entity);
}
public static bool TokenMatchesEntity(Guid token, IQueryEntities entities,
IEnumerable<Expression<Func<EmailConfirmation, object>>> eagerLoad = null)
{
EmailConfirmation entity;
return TokenMatchesEntity(token, entities, eagerLoad, out entity);
}
public DevelopmentSqlSeeder(IQueryEntities entities)
: base(entities)
{
}
