public void AddClassToSetAndSave_Saves()
{
var contxt = new RepositoryContext();
contxt.ObjectSet<TestClass>().AddObject(new TestClass() {FirstName = "Donald", LastName = "Duck"});
contxt.Save();
var duck = (from tc in contxt.ObjectSet<TestClass>() where tc.FirstName == "Donald" select tc).FirstOrDefault();
Assert.That(duck, Is.Not.Null);
}
public override bool IsUserInRole(string username, string roleName)
{
if (roleName == Roles.admin.ToString())
{
using (var dc = new RepositoryContext())
{
return dc.Users.Any(u => u.Login == username && u.Roles.Any(r => r.Name == roleName));
}
}
return false;
}
public override bool ChangePassword(string username, string oldPassword, string newPassword)
{
using (var dc = new RepositoryContext("LogoDB"))
{
var user = dc.Users.FirstOrDefault(u => u.Login == username);
if (user != null && user.Password == GetMD5Hash(oldPassword))
{
user.Password = GetMD5Hash(newPassword);
dc.SaveChanges();
return true;
}
return false;
}
}
protected override bool IsAuthorized(HttpActionContext actionContext)
{
var authHeader = actionContext.Request.Headers.Authorization;
if (authHeader == null || !authHeader.Scheme.Equals("token", StringComparison.OrdinalIgnoreCase))
return false;
var token = authHeader.Parameter;
if (!AccessTokenCredentials.TryParse(token))
return false;
var creds = AccessTokenCredentials.Parse(token);
using (var repo = new RepositoryContext())
{
var user = repo.UserRepository.GetById(creds.Id);
if (user == null || user.AccessToken == null)
return false;
// Validate expiry of the token
if (user.AccessTokenExpiry < DateTime.Now)
{
user.AccessToken = null;
user.AccessTokenExpiry = null;
repo.Save();
return false;
}
if (user.AccessToken == creds.TokenValue)
{
var identity = new GenericIdentity(user.Id.ToString());
IPrincipal principal = new GenericPrincipal(identity, user.Roles.Select(r => r.Name).ToArray());
Thread.CurrentPrincipal = principal;
if (HttpContext.Current != null)
HttpContext.Current.User = principal;
// move on to role check
return base.IsAuthorized(actionContext);
}
}
return false;
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
using (var ctx = new RepositoryContext("LogoDB"))
{
if (ctx.Users.Any(u => u.Login == username))
status = MembershipCreateStatus.DuplicateUserName;
else if (ctx.Users.Any(u => u.Email == email))
status = MembershipCreateStatus.DuplicateEmail;
else
{
var user = new User() { Id = Guid.NewGuid(), Login = username, Email = email, Password = GetMD5Hash(password), Repository = ctx.Repositorys.First() };
if (ctx.Users.Count() == 0)
{
user.Roles.Add(ctx.Roles.First(r => r.Name == "Administrator"));
}
ctx.Users.Add(user);
ctx.SaveChanges();
status = MembershipCreateStatus.Success;
return new MembershipUser(this.Name, username, user.Id, email, null, null, false, false, DateTime.Now, DateTime.MinValue, DateTime.Now, DateTime.Now, DateTime.MinValue);
}
return null;
}
}
protected AbstractApiController()
{
this.RepositoryContext = new RepositoryContext();
}
public UserService(RepositoryContext context)
{
_context = context;
}
public OwnerRepository(RepositoryContext repositoryContext) : base(repositoryContext)
{
}
public FileUploadRepository(RepositoryContext context, UserManager <ApplicationUser> userManager)
{
this.context = context;
this.userManager = userManager;
}
public UserRepository(RepositoryContext dbContext)
{
DbContext = dbContext;
}
/// <inheritdoc/>
public bool IsEnabled(RepositoryContext ctx)
{
return(_commonOptions.EnableNodeJSBuild);
}
public QuestionRepository(RepositoryContext repositoryContext)
: base(repositoryContext)
{
}
public MessageRepository(RepositoryContext repositoryContext)
: base(repositoryContext)
{
}
public RideRepository(RepositoryContext repositoryContext)
: base(repositoryContext)
{
}
public PlatformDetectorResult Detect(RepositoryContext context)
{
bool isNodeApp = false;
var sourceRepo = context.SourceRepo;
if (sourceRepo.FileExists(NodeConstants.PackageJsonFileName) ||
sourceRepo.FileExists(NodeConstants.PackageLockJsonFileName) ||
sourceRepo.FileExists(NodeConstants.YarnLockFileName))
{
isNodeApp = true;
}
else
{
_logger.LogDebug(
$"Could not find {NodeConstants.PackageJsonFileName}/{NodeConstants.PackageLockJsonFileName}" +
$"/{NodeConstants.YarnLockFileName} in repo");
}
if (!isNodeApp)
{
// Copying the logic currently running in Kudu:
var mightBeNode = false;
foreach (var typicalNodeFile in TypicalNodeDetectionFiles)
{
if (sourceRepo.FileExists(typicalNodeFile))
{
mightBeNode = true;
break;
}
}
if (mightBeNode)
{
// Check if any of the known iis start pages exist
// If so, then it is not a node.js web site otherwise it is
foreach (var iisStartupFile in IisStartupFiles)
{
if (sourceRepo.FileExists(iisStartupFile))
{
_logger.LogDebug(
"App in repo is not a Node.js app as it has the file {iisStartupFile}",
iisStartupFile.Hash());
return(null);
}
}
isNodeApp = true;
}
else
{
// No point in logging the actual file list, as it's constant
_logger.LogDebug("Could not find typical Node.js files in repo");
}
}
if (!isNodeApp)
{
_logger.LogDebug("App in repo is not a NodeJS app");
return(null);
}
var version = GetVersion(context);
version = GetMaxSatisfyingVersionAndVerify(version);
return(new PlatformDetectorResult
{
Platform = NodeConstants.PlatformName,
PlatformVersion = version,
});
}
private string GetVersionFromPackageJson(RepositoryContext context)
{
var packageJson = NodePlatform.GetPackageJsonObject(context.SourceRepo, _logger);
return(packageJson?.engines?.node?.Value as string);
}
public RepositoryBase(RepositoryContext repositoryContext)
{
_repositoryContext = repositoryContext;
}
public WeaponTypeRepository(RepositoryContext repositoryContext)
{
_context = repositoryContext;
}
public override string GetUserNameByEmail(string email)
{
using (var dc = new RepositoryContext("LogoDB"))
{
var user = dc.Users.FirstOrDefault(u => u.Email == email);
if (user != null)
return user.Login;
}
return null;
}
public override bool ValidateUser(string username, string password)
{
string md5Hash = GetMD5Hash(password);
using (var dc = new RepositoryContext("LogoDB"))
{
return dc.Users.Any(u => u.Login == username && u.Password == md5Hash);
}
}
public AuthenticationService(IOptions <JwtSettings> jwtSettings, RepositoryContext dataContext)
{
_jwtSettings = jwtSettings.Value;
_dataContext = dataContext;
}
public Produce_Unix_EndOfLine_EditorConfig_Declaration(RepositoryContext context)
: base(context, ".produce")
{
}
public ProductImageRepository(RepositoryContext context) : base(context)
{
}
/// <inheritdoc/>
public bool IsEnabledForMultiPlatformBuild(RepositoryContext ctx)
{
return(true);
}
public UserRepository(RepositoryContext ctx) : base(ctx)
{
}
public PizzeriaRepository(RepositoryContext repositoryContext) : base(repositoryContext)
{
}
public RecipeManager(RepositoryContext context)
{
_repositoryContext = context;
}
public CategoryRepository(RepositoryContext repositoryContext) : base(repositoryContext)
{
}
public UnitOfMeasureRepo(RepositoryContext context) : base(context)
{
}
public CountryManager(RepositoryContext context)
{
_repositoryContext = context;
}
public void Arrange()
{
RepositoryContext.SetupAsync().GetAwaiter().GetResult();
_singleOperationsTestData = TestData.GenerateSingleOperationsTestData(0);
_bulkOperationsTestData = TestData.GenerateBulkOperationsTestData(5);
}
//todo
public int SaveChanges()
{
return(RepositoryContext.SaveChanges());
}
public void Teardown()
{
RepositoryContext.DeleteAsync().GetAwaiter().GetResult();
_singleOperationsTestData = null;
_bulkOperationsTestData = null;
}
public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
{
using (var dc = new RepositoryContext("LogoDB"))
{
var user = dc.Users.FirstOrDefault(u => u.Id == (Guid)providerUserKey);
if (user != null)
return new MembershipUser(this.Name, user.Login, user.Id, user.Email, null, null, false, false, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue);
}
return null;
}
public CartsController(RepositoryContext context)
{
_context = context;
}
public override string ResetPassword(string username, string answer)
{
using (var dc = new RepositoryContext("LogoDB"))
{
var user = dc.Users.FirstOrDefault(u => u.Login == username);
if (user != null)
{
var newPw = GetRandomLetters(6);
user.Password = GetMD5Hash(newPw);
dc.SaveChanges();
return newPw;
}
}
return null;
}
public SponsorRepository(RepositoryContext context) : base(context)
{
}
public IList <User> GetViewUserList(UserInput userInput, out long count)
{
if (userInput.PageIndex < 0)
{
throw new ArgumentNullException("pageIndex", "pageindex has to be greater than 1");
}
if (userInput.PageSize > 100)
{
userInput.PageSize = 100;
}
var sqlWhere = string.Empty;
if (Convert.ToInt16(userInput.Status) > 0)
{
sqlWhere = $"{sqlWhere} AND Status={(int)userInput.Status}";
}
if (userInput.ParentId > 0)
{
sqlWhere = $"{sqlWhere} AND ParentId={userInput.ParentId}";
}
if (!userInput.Email.IsNullOrEmpty())
{
sqlWhere = $"{sqlWhere} AND Email= '{userInput.Email}' ";
}
if (!userInput.Mobile.IsNullOrEmpty())
{
sqlWhere = $"{sqlWhere} AND Mobile= '{userInput.Mobile}' ";
}
if (!userInput.UserName.IsNullOrEmpty())
{
sqlWhere = $"{sqlWhere} AND UserName='******' ";
}
if (!userInput.Name.IsNullOrEmpty())
{
sqlWhere = $"{sqlWhere} AND Name='{userInput.Name}'";
}
if (!userInput.GradeId.IsGuidNullOrEmpty())
{
sqlWhere = $"{sqlWhere} AND GradeId='{userInput.GradeId}'";
}
if (userInput.ServiceCenterId > 0)
{
sqlWhere = $"{sqlWhere} AND ServiceCenterUserId={userInput.ServiceCenterId}";
}
var sqlCount = $"SELECT COUNT(Id) [Count] FROM User_User where 1=1 {sqlWhere}";
count = RepositoryContext.ExecuteScalar(sqlCount)?.ConvertToLong() ?? 0;
var result = new List <User>();
var sql = $@"SELECT TOP {userInput.PageSize} * FROM (
SELECT ROW_NUMBER() OVER (ORDER BY id desc) AS RowNumber,* FROM User_User where 1=1 {sqlWhere}
) as A
WHERE RowNumber > {userInput.PageSize}*({userInput.PageIndex}-1) ";
using (var dr = RepositoryContext.ExecuteDataReader(sql)) {
while (dr.Read())
{
result.Add(ReadUser(dr));
}
}
return(result);
}
public DrinkRepository(RepositoryContext repositoryContext) : base(repositoryContext)
{
}
public Context(IIssueTrackerContext issueTrackerContext)
{
Repository = new RepositoryContext();
IssueTracker = issueTrackerContext;
}
public RepositoryWarpper(RepositoryContext repositoryContext)
{
_repoContext = repositoryContext;
}
