public RootModel GetPstRootModel(IDataManager manager, String portfolioId, SecurityRepository securityRepository)
{
var targets = manager.GetPortfolioSecurityTargets(portfolioId).OrderByDescending(x => x.Target);
var latestChangeSetInfo = manager.GetLatestPortfolioSecurityTargetChangeSet();
var items = new List <ItemModel>();
foreach (var target in targets)
{
var security = securityRepository.GetSecurity(target.SecurityId);
var targetExpression = this.modelBuilder.CreateTargetExpression();
var item = this.modelBuilder.CreateItem(security, targetExpression);
item.Target.InitialValue = target.Target;
items.Add(item);
}
var targetTotalExpression = this.modelBuilder.CreateTargetTotalExpression(items);
var cashExpression = this.modelBuilder.CreateCashExpression(targetTotalExpression);
var result = new RootModel(
portfolioId,
latestChangeSetInfo,
items,
targetTotalExpression,
cashExpression
);
return(result);
}
public void Initialize(
RootModel root,
SecurityRepository securityRepository,
PortfolioRepository portfolioRepository,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository
)
{
var allFlatTargets = new List <BuPortfolioSecurityTargetInfo>();
foreach (var overlayItem in root.Factors.Items)
{
var factor = overlayItem.OverlayFactor.EditedValue;
if (!factor.HasValue)
{
continue;
}
var flatTargets = this.targetsFlattener.Flatten(
overlayItem.BottomUpPortfolio.Id,
factor.Value,
portfolioSecurityTargetRepository,
portfolioRepository
).ToArray();
allFlatTargets.AddRange(flatTargets);
var s = allFlatTargets.Sum(a => a.Target);
}
var resolver = new IsoCodeToOverlayTargetValueResolver(securityRepository, allFlatTargets);
this.Initialize(root, resolver);
}
public static CheckIdResult <T> Create(int[] ids, string actionTypeCode)
{
var result = new CheckIdResult <T>();
foreach (var id in ids)
{
var item = EntityObjectRepository.GetById <T>(id);
var lockableItem = item as LockableEntityObject;
if (item == null)
{
result._NotFoundIds.Add(id);
}
else if (item != null && !SecurityRepository.IsEntityAccessible(item.EntityTypeCode, id, actionTypeCode))
{
result._NotAccessedIds.Add(id);
}
else if (lockableItem != null && lockableItem.LockedByAnyoneElse && !QPContext.CanUnlockItems)
{
result._LockedItems.Add(item);
}
else
{
result._ValidItems.Add(item);
}
}
return(result);
}
public UserBusiness()
{
_userRepository = new UserRepository <UserResponseDTO, UserRequestDTO>();
_securityResponse = new SecurityRepository <AuthenticationResponseDTO, AuthenticationRequestDTO>();
_response = new UserResponseDTO();
_responseAuth = new AuthenticationResponseDTO();
}
public DocumentMetadataController(ILogger <DocumentMetadataController> logger, MetadataRepository metadata, DocumentRepository documentRepository, SecurityRepository securityRepository)
{
_metadataRepository = metadata;
_logger = logger;
_documentRepository = documentRepository;
_securityRepository = securityRepository;
}
public RootModel DeserializeFromJson(
String bpstModelAsJson,
SecurityRepository securityRepository,
TargetingTypeGroupRepository targetingTypeGroupRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
IOnDemand <IDataManager> ondemandManager
)
{
using (var reader = new JsonReader(new Newtonsoft.Json.JsonTextReader(new StringReader(bpstModelAsJson))))
{
var result = reader.Read(delegate
{
return(this.modelDeserializer.DeserializeRoot(
reader,
securityRepository,
targetingTypeGroupRepository,
basketRepository,
portfolioRepository,
this.repositoryManager,
ondemandManager
));
});
return(result);
}
}
public IEnumerable <IValidationIssue> ApplyIfValid(
RootModel model,
Taxonomy taxonomy,
RepositoryManager repositoryManager,
String username,
String userEmail,
SqlConnection connection,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
CalculationTicket ticket,
ref CalculationInfo info
)
{
var issues = this.ValidateModelAndPermissions(model, username, ticket);
var traverser = new IssueTraverser();
var traversedIssues = traverser.TraverseAll(issues);
if (traversedIssues.Any(x => x is ErrorIssue))
{
return(issues);
}
try
{
this.Apply(model, taxonomy, repositoryManager, username, userEmail, connection,
securityRepository, basketRepository, portfolioRepository, ref info);
return(issues);
}
catch (ValidationException exception)
{
return(issues.Union(new IValidationIssue[] { exception.Issue }));
}
}
public IEnumerable <AdvertisementViewMode> AllAds(int pub_id, int iss_id)
{
var token = HttpContext.Current.User.Identity.Name;
var repo = new SecurityRepository();
var luClient = repo.GetClient(token);
var mediaTrim = _adsizeMediaTrimRepository.GetAll().ToList();
var result = _mediaPageNumberRepository.GetAll().Where(x => x.pub_id == pub_id && x.iss_id == iss_id && x.tbl_io_detail.lu_ad_rate.pagination_req == 0).ToList().Select(ad => DesignDummyRepository.BuildAdViewModel(ad, luClient));
var test = result.Join(
mediaTrim,
mediaPage => new { mediaPage.adsize_id, mediaPage.pub_id },
trim => new { trim.adsize_id, trim.pub_id },
(t1, t2) => new { t1, t2 })
.Where(o => o.t2.lu_adsize_trim != null && o.t1.ad_shape_id == o.t2.lu_adsize_trim.ad_shape_id.GetValueOrDefault())
.Select(o => new { o.t1, o.t2.lu_adsize_trim.adsize_trim_desc, o.t2.lu_adsize_trim.lu_dummy_coordinate });
var adsList = new List <AdvertisementViewMode>();
foreach (var i in test)
{
i.t1.adsize_trim_desc = i.adsize_trim_desc;
if (i.lu_dummy_coordinate != null)
{
i.t1.coordinates = Mapper.Map <lu_dummy_coordinate, CoordinatesViewMode>(i.lu_dummy_coordinate);
}
adsList.Add(i.t1);
}
var uniquPlacedAds = _dummyPagePlacementRepository.GetAll().ToList().Select(x => x.media_page_number_id).Distinct();
return(adsList.Where(x => !uniquPlacedAds.Contains(x.ad_id) && x.adsize_trim_desc != null && x.status).OrderBy(x => x.company_name).Distinct());
}
public FocisProfileService(UserManager <ApplicationUser> userManager, SecurityRepository securityRepository)
: base(userManager, securityRepository)
{
this.userManager = userManager;
// this.securityRepository = securityRepository;
}
public IEnumerable <String> ExtractCodes(
SecurityRepository securityRepository,
String portfolioId,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository,
ISecurityIdToPortfolioIdResolver securityToPortfolioResolver
)
{
var traverser = new TargetsTraverser <Object>(
(whatever, target) => target, // we don't change targets
(whaterer, target) => whaterer // we don't change the state
);
var flatTargets = traverser.Traverse(
portfolioId,
portfolioSecurityTargetRepository,
new Object(),
new HashSet <String>(),
securityToPortfolioResolver
);
var results = flatTargets.GroupBy(x => securityRepository
.GetSecurity(x.SecurityId)
.AsCompanySecurity() // <---- at this level (very bottom) all securities have to be company securities (there must be no funds at this level)
.Country.IsoCode
).Select(x => x.Key).ToArray();
return(results);
}
public IEnumerable <IValidationIssue> ApplyIfValid(
RootModel root,
String username,
String userEmail,
SqlConnection connection,
TargetingTypeRepository targetingTypeRepository,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
CalculationTicket ticket,
ref CalculationInfo info
)
{
var targetingType = targetingTypeRepository.GetTargetingType(root.TargetingType.Id);
var issues = this.modelApplier.ApplyIfValid(
root,
targetingType.Taxonomy,
this.repositoryManager,
username,
userEmail,
connection,
securityRepository,
basketRepository,
portfolioRepository,
ticket,
ref info
);
return(issues);
}
public void Setup()
{
session = WindsorPersistenceFixture.Container.Resolve <ISession>();
repository = new SecurityRepository();
repository.Session = session;
tx = session.BeginTransaction();
}
public List <SecurityDomain> GetListInPage(int pageIndex, int pageSize, string exChange)
{
SecurityRepository securityRepo = SecurityRepositoryFactory.GetInstance().Create();
List <SecurityDomain> lst = securityRepo.GetListInPage(pageIndex, pageSize, exChange);
return(lst);
}
public ActionResult SellRead([DataSourceRequest] DataSourceRequest request)
{
SecurityRepository secsRepo = new SecurityRepository(UnitOfWork);
IEnumerable <OrderManagementSystem.Areas.OMS.Models.Security> secs = secsRepo.GetSell();
return(Json(secs.ToDataSourceResult(request)));
}
public void SuperAdmin_can_access_all_brands()
{
// *** Arrange ***
const int brandCount = 20;
var brands = new List <Core.Brand.Interface.Data.Brand>();
for (var i = 0; i < brandCount; i++)
{
brands.Add(CreateBrand());
}
var admin = SecurityRepository.GetAdminById(_actorInfoProvider.Actor.Id);
var allowedBrands = brands.Select(b => b.Id).ToList();
allowedBrands.AddRange(admin.AllowedBrands.Select(b => b.Id));
admin.SetAllowedBrands(allowedBrands);
SecurityTestHelper.SignInAdmin(admin);
// *** Act ***
var filtered = BrandQueries.GetFilteredBrands(brands, admin.Id);
// *** Assert ***
Assert.IsNotNull(filtered);
Assert.True(filtered.Count() == brandCount);
}
public static async Task <ProfileModel> Get(string userName, SecurityRepository accountRepository)
{
int companyId = NTContext.Context.CompanyId;
ProfileModel profile = await accountRepository.UserProfileGet(userName, companyId);
// setting all the roles for admin roles
if (profile.AdminRoles.Length > 0)
{
profile.AdminRoles = PageService.AdminRoles.Where(r => profile.AdminRoles.Contains(r.Key)).Select(r => r.Item).ToArray();
}
profile.SetMenu();
// setting the claims on to the context
NTContextModel model = new NTContextModel()
{
UserId = profile.UserId,
UserName = profile.UserName,
FirstName = profile.FirstName,
LastName = profile.LastName,
CompanyId = profile.CompanyId
};
NTContext.Context = model;
return(profile);
}
public Usuario Login(string uid, string pwd)
{
Usuario user;
user = GetUsuarioFromLogin(uid);
if (user != null)
{
if (user.Enabled)
{
SecurityRepository repo = new SecurityRepository();
if (repo.LoginUsuario(user, pwd))
{
// Sesion result = new Sesion(user);
user.FechaLastLogin = DateTime.Now;
repo.ModificarUsuario(user);
return(user);
}
}
else
{
throw new OMBSecurityException("El Usuario ha sido bloqueado por el administrador....");
}
}
return(null);
}
public static IServiceCollection CachePageClaimsRoles(this IServiceCollection services)
{
SecurityRepository repository = services.BuildServiceProvider().GetRequiredService <SecurityRepository>();
PageService.CachePageClaimsRoles(repository);
return(services);
}
public RootModel DeserializeRoot(JsonReader reader, SecurityRepository securityRepository)
{
return(reader.Read(delegate
{
var protfolioId = reader.ReadAsString(JsonNames.PortfolioId);
var latestChangeset = reader.Read(JsonNames.LatestChangeset, delegate
{
return this.ReadLastChangeset(reader);
});
var items = reader.ReadArray(JsonNames.Items, delegate
{
return this.ReadItem(reader, securityRepository);
});
var targetTotalExpression = this.modelBuilder.CreateTargetTotalExpression(items);
var cashExpression = this.modelBuilder.CreateCashExpression(targetTotalExpression);
var result = new RootModel(
protfolioId,
latestChangeset,
items,
targetTotalExpression,
cashExpression
);
return result;
}));
}
public static ContentInitListResult InitList(int siteId, bool isVirtual = false)
{
var isActionAccessable = !isVirtual && SecurityRepository.IsActionAccessible(ActionCode.AddNewContent);
if (siteId > 0)
{
var site = SiteRepository.GetById(siteId);
if (site == null)
{
throw new Exception(string.Format(SiteStrings.SiteNotFound, siteId));
}
var isSiteAccessable = !isVirtual && SecurityRepository.IsEntityAccessible(EntityTypeCode.Site, siteId, ActionTypeCode.Update);
return(new ContentInitListResult
{
ParentName = site.Name,
IsVirtual = isVirtual,
IsAddNewAccessable = isActionAccessable && isSiteAccessable
});
}
return(new ContentInitListResult
{
IsVirtual = isVirtual,
IsAddNewAccessable = isActionAccessable
});
}
private static ArticleInitListResult InitList(int contentId, bool isArchive, bool?boundToExternal)
{
var result = new ArticleInitListResult();
var content = ContentRepository.GetById(contentId);
if (content == null)
{
throw new Exception(string.Format(ContentStrings.ContentNotFound, contentId));
}
result.IsVirtual = content.IsVirtual;
result.PageSize = content.PageSize;
result.ContentName = content.Name;
result.IsUpdatable = content.IsUpdatable;
var titleField = FieldRepository.GetTitleField(contentId);
result.TitleFieldName = titleField == null ? FieldName.ContentItemId : titleField.FormName;
result.DisplayFields = FieldRepository.GetList(contentId, true);
result.IsAddNewAccessable = !isArchive && SecurityRepository.IsActionAccessible(ActionCode.AddNewArticle) && SecurityRepository.IsEntityAccessible(EntityTypeCode.Content, contentId, ActionTypeCode.Update);
result.IsArticleChangingActionsAllowed = content.IsArticleChangingActionsAllowed(boundToExternal);
result.ContentDisableChangingActions = content.DisableChangingActions;
return(result);
}
static void Main(string[] args)
{
using (var sr = new SecurityRepository())
{
//Console.WriteLine(sr.GetDoorActivity(new DateTime(2020, 04, 04), new DateTime(2020, 06, 06),1).Count());
//foreach (var a in sr.GetSuspiciousActivity(new DateTime(2020,04,04), new DateTime(2020, 06, 06)).Where(x=> x.DoorID==1 && x.UserID==2))
//{
// Console.WriteLine(a.Result+" " + a.User.FirstName+a.User.LastName + " " +a.Door.Name + " " +a.AttemptDate + " " +a.AuthorizationAttemptID);
//}
List <UserCredential> temp = new List <UserCredential>();
temp.Add(new UserCredential {
CredentialID = 2, Value = "1111"
});
temp.Add(new UserCredential {
CredentialID = 3, Value = "111"
});
Console.WriteLine(sr.IsAuthorized(1, temp));
sr.RevokeAccess(1, new Credential {
CredentialID = 3
});
Console.WriteLine(sr.IsAuthorized(1, temp));
List <DoorCredentialDetail> temp2 = new List <DoorCredentialDetail>();
temp2.Add(new DoorCredentialDetail {
CredentialID = 2,
});
temp2.Add(new DoorCredentialDetail {
CredentialID = 3, Value = "111"
});
sr.GrantAccess(1, temp2);
Console.WriteLine(sr.IsAuthorized(1, temp));
Console.ReadLine();
}
}
public override void OnActionExecuting(ActionExecutingContext context)
{
SecurityRepository securityRepository = (SecurityRepository)context.HttpContext.RequestServices.GetService(typeof(SecurityRepository));
ICryptoRSA cryptoRSA = (ICryptoRSA)context.HttpContext.RequestServices.GetService(typeof(ICryptoRSA));
KeyInfo keyInfo = securityRepository.Get();
cryptoRSA.ImportBinaryKeys(Convert.FromBase64String(keyInfo.PublicKey));
}
public static void CachePageClaimsRoles(SecurityRepository repository)
{
Pages = repository.IdentityPagesGet();
MenuPages = repository.IdentityMenuPagesGet();
AdminRoles = repository.IdentityAdminRolesGet();
CacheCompanyClaims(repository);
}
private static void CachePageClaimsRoles(SecurityRepository repository)
{
PageService.Pages = repository.PagesGet();
PageService.MenuPages = repository.MenuPagesGet();
PageService.AdminRoles = repository.AdminRolesGet();
//CacheCompanyClaims(repository);
}
public static void CachePageClaimsRoles(SecurityRepository repository)
{
Pages = repository.IdentityPagesGet();
MenuPages = repository.IdentityMenuPagesGet();
AdminRoles = repository.IdentityAdminRolesGet();
CacheCompanyClaims(repository);
}
protected override async Task ManageRepositoryAsync(ICreateClientSecretIdentityCommand command)
{
NullGuard.NotNull(command, nameof(command));
IClientSecretIdentity clientSecretIdentity = command.ToDomain();
await SecurityRepository.CreateClientSecretIdentityAsync(clientSecretIdentity);
}
protected override async Task ManageRepositoryAsync(IUpdateUserIdentityCommand command)
{
NullGuard.NotNull(command, nameof(command));
IUserIdentity userIdentity = command.ToDomain();
await SecurityRepository.UpdateUserIdentityAsync(userIdentity);
}
protected override async Task <IIdentity> GetIdentityAsync(IAuthenticateClientSecretCommand command)
{
NullGuard.NotNull(command, nameof(command));
IClientSecretIdentity clientSecretIdentity = await SecurityRepository.GetClientSecretIdentityAsync(command.ClientId);
return(clientSecretIdentity);
}
public LocationModel CreateLocation(LocationModel location)
{
var loc = Mapper.Map <LocationModel, Data.Graph.Location>(location);
loc = SecurityRepository.SaveOrUpdateLocation(loc);
HttpRuntime.Cache.Remove(cacheKey);
return(Mapper.Map <Data.Graph.Location, LocationModel>(loc));
}
public override PermissionInitListResult InitList(int parentId)
{
var result = base.InitList(parentId);
var artcile = ArticleRepository.GetById(parentId);
result.IsEnableArticlesPermissionsAccessable = SecurityRepository.IsActionAccessible(ActionCode.EnableArticlesPermissions) && SecurityRepository.IsEntityAccessible(EntityTypeCode.Content, artcile.ContentId, ActionTypeCode.Update);
return(result);
}
public override void CreateRole(string roleName)
{
var repository = new SecurityRepository();
var role = repository.GetRole(roleName);
if (role != null)
throw new ProviderException("Specified role already exists");
role = new Role { Name = roleName };
repository.SaveRole(role);
}
private static void CacheCompanyClaims(SecurityRepository repository)
{
var companies = repository.IdentityCompanyClaimsGet();
CompanyClaims = new Dictionary<int, CompanyEntity>();
foreach (var company in companies)
{
CompanyClaims.Add(company.CompanyId, company);
}
}
public IEnumerable<ISecurity> GetAll()
{
SecurityRepository repository = new SecurityRepository(DataFiles.GetSecuritiesFile());
return repository.GetAll();
//using (var context = GetContext())
//{
// var repository = new Repository<Security>(context);
// return repository.GetAll();
//}
}
public void Update(ISecurity security)
{
SecurityRepository repository = new SecurityRepository(DataFiles.GetSecuritiesFile());
repository.UpdateRange(new ISecurity[] { security });
//using (var context = GetContext())
//{
// var repository = new Repository<Security>(context);
// repository.Update(security.ToDataObject());
// repository.UnitOfWork.Commit();
//}
}
public bool Exists(ISecurity security)
{
SecurityRepository repository = new SecurityRepository(DataFiles.GetSecuritiesFile());
return repository.Exists(security);
//// 设置查询条件
//var spec = Specification<Security>.Eval(p => p.Code.Equals(security.Code));
//using (var context = GetContext())
//{
// var repository = new Repository<Security>(context);
// return repository.Exists(spec);
//}
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
var repository = new SecurityRepository();
var role = repository.GetRole(roleName);
if (role == null)
throw new ProviderException("Specified role not found");
if (!throwOnPopulatedRole)
{
if (role.User2Roles.Count() > 0)
throw new ProviderException("Role is populated");
}
repository.DeleteRole(role);
return true;
}
public ActionResult Index()
{
var sr = new SecurityRepository();
var opStatus = sr.InsertSecurityData();
if (opStatus.Status)
{
var mr = new MarketsAndNewsRepository();
opStatus = mr.InsertMarketData();
if (opStatus.Status)
{
var ar = new AccountRepository();
opStatus = ar.RefreshAccountsData();
}
}
ViewBag.OperationStatus = opStatus;
return View();
}
internal static void Initialize(AccountAtAGlanceContext context)
{
//var customer = new Customer()
//{
// FirstName = "Marcus",
// LastName = "Hightower",
// Address = "1234 Anywhere St.",
// City = "Phoenix",
// State = "AZ",
// Zip = 85229,
// CustomerCode = "C15643"
//};
//var ba = new BrokerageAccount()
//{
// AccountNumber = "Z485739881",
// AccountTitle = "Joint Brokerage",
// Total = 1369265.00M,
// MarginBalance = 414888.67M,
// IsRetirement = false,
// CashTotal = 10000.00M,
// PositionsTotal = 1359265.00M,
// WatchList = new WatchList { Title = "My Watch Securities" }
//};
//customer.BrokerageAccounts.Add(ba);
//context.Customers.Add(customer);
//var exchange = new Exchange
//{
// Title = "NYSE"
//};
//var stock = new Stock
//{
// Change = 2.5M,
// PercentChange = 5.00M,
// Last = 32.10M,
// Shares = 100000,
// Symbol = "MSFT",
// RetrievalDateTime = DateTime.Now,
// Company = "Microsoft Corporation",
// Exchange = exchange,
// DayHigh = 33.00M,
// DayLow = 32.00M,
// Dividend = 0M,
// Open = 32.00M,
// Volume = 1000000M,
// YearHigh = 34.00M,
// YearLow = 28.00M,
// AverageVolume = 100000M,
// MarketCap = 10000000M
//};
//context.Stocks.Add(stock);
context.Database.ExecuteSqlCommand(@"
CREATE PROCEDURE dbo.DeleteSecuritiesAndExchanges
AS
BEGIN
BEGIN TRANSACTION
BEGIN TRY
DELETE FROM WatchListSecurity;
DELETE FROM Positions;
DELETE FROM Securities_Stock;
DELETE FROM Securities_MutualFund;
DELETE FROM Securities;
DELETE FROM Exchanges;
DELETE FROM MarketIndexes
COMMIT TRANSACTION
SELECT 0
END TRY
BEGIN CATCH
ROLLBACK TRANSACTION
SELECT -1
END CATCH
END
");
context.Database.ExecuteSqlCommand(@"
CREATE PROCEDURE dbo.DeleteAccounts
AS
BEGIN
BEGIN TRANSACTION
BEGIN TRY
DELETE FROM Orders;
DELETE FROM BrokerageAccounts;
DELETE FROM WatchLists;
DELETE FROM Customers
COMMIT TRANSACTION
SELECT 0
END TRY
BEGIN CATCH
ROLLBACK TRANSACTION
SELECT -1
END CATCH
END
");
IStockEngine engine = new StockEngine();
var sr = new SecurityRepository(engine);
var opStatus = sr.InsertSecurityData();
if (opStatus.Status)
{
var mr = new MarketsAndNewsRepository(engine);
opStatus = mr.InsertMarketData();
if (opStatus.Status)
{
var ar = new AccountRepository(engine);
opStatus = ar.RefreshAccountsData();
}
}
}
public override bool ChangePasswordQuestionAndAnswer(string password, string newPasswordQuestion,
string newPasswordAnswer)
{
if (!ValidatePassword(password))
return false;
var repository = new SecurityRepository();
var user = repository.GetUser(Id);
if (user != null)
{
user.PasswordQuestion = newPasswordQuestion;
user.PasswordAnswer = newPasswordAnswer;
repository.SaveUser(user);
}
return true;
}
new byte[] GetPassword()
{
var password = new SecurityRepository().GetUser(Id, u => u.Password);
if (password == null || password.Length != 64) return new byte[0];
return password.ToArray();
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
if (!RoleExists(roleName))
throw new ProviderException("Specified role not found");
var logins = new SecurityRepository().GetLoginsAssignedToRole(roleName);
if (!string.IsNullOrEmpty(usernameToMatch))
logins = logins.Where(v => v.Contains(usernameToMatch));
return logins.OrderBy(v => v).ToArray();
}
public AccountDomain(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, SecurityRepository accountRepository)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.accountRepository = accountRepository;
}
public void TestMethod_Security()
{
string filePath = Path.Combine(Environment.CurrentDirectory, "TestSecurity.sdf");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
List<ISecurity> securities = ExampleSecurities();
System.Diagnostics.Debug.Print(string.Format("Security data count is {0}", securities.Count));
SecurityRepository repository = new SecurityRepository(filePath);
repository.AddRange(securities);
ISecurity get = repository.Get(securities[0].Code);
Assert.IsTrue(repository.Exists(securities[0]));
Assert.IsFalse(repository.Exists(ExampleSecurity()));
var updateData = new Security { Code = "600518", Market = Market.XSHG, ShortName = "康*美*药*业", Type = SecurityType.Unknown };
repository.UpdateRange(new ISecurity[] { updateData });
IList<ISecurity> result0 = repository.GetAll().ToList();
Assert.IsTrue(repository.Exists(updateData));
List<ISecurity> updateSecurities = GetUpdateSecurityDatas(securities).ToList();
repository.UpdateRange(updateSecurities);
IList<ISecurity> result = repository.GetAll().ToList();
if (result != null && result.Count > 0)
{
System.Diagnostics.Debug.Print(string.Format("Security Data count is {0}", result.Count));
}
Assert.AreEqual(securities.Count, result.Count);
}
public bool ChangeNameAndEMail(string password, string email, string firstName, string secondName, string lastName)
{
if (!ValidatePassword(password))
return false;
var repository = new SecurityRepository();
var user = repository.GetUser(Id);
if (user != null)
{
user.EMail = email;
user.FirstName = firstName;
user.SecondName = secondName;
user.LastName = lastName;
repository.SaveUser(user);
}
return true;
}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion,
string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
if (string.IsNullOrEmpty(username))
{
status = MembershipCreateStatus.InvalidUserName;
return null;
}
if (string.IsNullOrEmpty(email))
{
status = MembershipCreateStatus.InvalidEmail;
return null;
}
if (!string.IsNullOrEmpty(password) && password.Length < MinRequiredPasswordLength)
{
status = MembershipCreateStatus.InvalidPassword;
return null;
}
var repository = new SecurityRepository();
if (repository.TestUserByLogin(username))
{
status = MembershipCreateStatus.DuplicateUserName;
return null;
}
if (repository.TestUserByEmail(email))
{
status = MembershipCreateStatus.DuplicateEmail;
return null;
}
var salt = SaltGenerator.GenerateSalt();
var account = new User
{
Login = username,
EMail = email,
Salt = salt,
FirstName = username,
LastName = username,
PasswordQuestion = passwordQuestion,
PasswordAnswer = passwordAnswer
};
repository.SaveUser(account);
var user = (AccountMembershipUser)GetUser(username, false);
if (user != null)
{
user.SavePassword(password);
status = MembershipCreateStatus.Success;
}
else
status = MembershipCreateStatus.ProviderError;
return user;
}
public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords)
{
var result = new SecurityRepository().GetUsers(pageIndex, pageSize);
var users = result.Select(u => new AccountMembershipUser
(u.Id, u.Login, u.Salt, u.FirstName, u.SecondName, u.LastName, u.EMail, u.RegDate, u.IsActive));
totalRecords = result.TotalEntries;
var collection = new MembershipUserCollection();
foreach (var user in users)
collection.Add(user);
return collection;
}
public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
{
var user = new SecurityRepository().GetAccount((int)providerUserKey);
if (userIsOnline)
user.UpdateLastActivity();
return user;
}
public override MembershipUser GetUser(string username, bool userIsOnline)
{
var user = new SecurityRepository().GetAccount(username);
if (userIsOnline)
user.UpdateLastActivity();
return user;
}
