private void gOAuthScopes_Bind(object sender, EventArgs e)
{
ScopeService scopeService = new ScopeService(OAuthContext);
gOAuthScopes.DataSource = scopeService.Queryable().ToList();
gOAuthScopes.DataBind();
}
public async Task AddScopeTestAsync()
{
const long newId = 1L;
const string newScope = "scope.new";
await using (var context = NewContext())
{
var service = new ScopeService(context);
await service.AddScopeAsync(new Scope
{
UserId = newId,
ScopeId = newScope
});
await context.CommitAsync();
}
await using (var context = NewContext())
{
var service = new ScopeService(context);
var result = await service.HasScopeAsync(newId, new [] { newScope });
Assert.True(result);
}
}
protected void gOAuthClients_RowSelected(object sender, Rock.Web.UI.Controls.RowEventArgs e)
{
ClientService clientService = new ClientService(OAuthContext);
Client client = clientService.Get(e.RowKeyId);
hfClientId.Value = client.Id.ToString();
tbClientName.Text = client.ClientName;
tbApiKey.Text = client.ApiKey.ToString();
tbApiSecret.Text = client.ApiSecret.ToString();
tbCallbackUrl.Text = client.CallbackUrl;
cbActive.Checked = client.Active;
ClientScopeService clientScopeService = new ClientScopeService(OAuthContext);
ScopeService scopeService = new ScopeService(OAuthContext);
cblClientScopes.DataSource = scopeService.Queryable().Select(s => new { Id = s.Id, Value = s.Identifier + " - " + s.Description }).ToList();
cblClientScopes.DataBind();
clientScopeService.Queryable().Where(cs => cs.ClientId == client.Id).ToList().ForEach(cs =>
cblClientScopes.Items.FindByValue(cs.ScopeId.ToString()).Selected = cs.Active
);
gOAuthClientEdit.Show();
}
private string GetArea(HttpContext context)
{
try
{
string type = ConvertUtility.Trim(context.Request.QueryString["type"]);
string code = ConvertUtility.Trim(context.Request.QueryString["code"]);
string json = string.Empty;
if (string.IsNullOrEmpty(type) || string.IsNullOrEmpty(code))
{
return(json);
}
ScopeService service = ScopeService.Init();
//{p:[{id:'',name:''}],c:[{id:'',name:''}],d:[{id:'',name:''}]}
if (type == Architectures.CITY)
{
IList <RegionType> region = service.RegionCollection.FindAll(m => m.CityId.Equals(code));
IList <ScopeType> scope = service.ScopeCollection.FindAll(m => m.RegionId.Equals(region[0].RegionId));;
json = ToJson(null, region, scope);
}
else if (type == Architectures.REGION)
{
json = ToJson(null, null, service.ScopeCollection.FindAll(m => m.RegionId.Equals(code)));
}
return(json);
}
catch (Exception ex)
{
throw ex;
}
}
protected void gOAuthScopesDelete_Click(object sender, Rock.Web.UI.Controls.RowEventArgs e)
{
ScopeService scopeService = new ScopeService(OAuthContext);
scopeService.Delete(scopeService.Get(e.RowKeyId));
OAuthContext.SaveChanges();
OAuthContext = new OAuthContext();
gOAuthScopes_Bind(sender, e);
}
public async Task HasScopeTestAsync(long id, string scope, bool expected)
{
await using var context = NewContext();
var service = new ScopeService(context);
bool hasScope = await service.HasScopeAsync(id, new [] { scope });
Assert.Equal(expected, hasScope);
}
protected void Application_Start(object sender, EventArgs e)
{
try
{
ScopeService.Init();
}
catch (Exception ex)
{
throw ex;
}
}
protected void gOAuthScopes_RowSelected(object sender, Rock.Web.UI.Controls.RowEventArgs e)
{
ScopeService scopeService = new ScopeService(OAuthContext);
Scope scope = scopeService.Get(e.RowKeyId);
hfScopeId.Value = scope.Id.ToString();
tbIdentifier.Text = scope.Identifier;
tbDescription.Text = scope.Description;
cbScopeActive.Checked = scope.Active;
gOAuthScopeEdit.Show();
}
private string GetJSON(string type, string code)
{
try
{
if (string.IsNullOrEmpty(type) || string.IsNullOrEmpty(code))
{
List <CityType> cityCollection = ScopeService.Init().CityCollection;
StringBuilder builder = new StringBuilder();
int mIndex = 0;
int mCount = cityCollection.Count;
builder.Append("[");
foreach (var cityType in cityCollection)
{
mIndex++;
City city = new City(cityType.CityId);
builder.AppendFormat("{{\"text\":\"{0}\",\"attributes\":{{\"type\":\"{2}\",\"code\":\"{1}\"}},\"state\":\"closed\"}}", city.CityName, city.CityId, Architectures.CITY);
if (mIndex != mCount)
{
builder.Append(",");
}
}
builder.Append("]");
return(builder.ToString());
}
if (type == Architectures.CITY)
{
City city = new City(code);
return(city.ToTree());
}
else if (type == Architectures.REGION)
{
Region region = new Region(code);
return(region.ToTree());
}
else
{
return(string.Empty);
}
}
catch (Exception ex)
{
throw ex;
}
}
public string SelectClientFromAutoCompleteDropDown(string clientId)
{
try
{
string[] strDummy = clientId.Split('_');
clientId = (strDummy[0].Contains("("))?parseClientID(strDummy[0]):strDummy[0];
string viewID = strDummy[1];
if (!string.IsNullOrEmpty(clientId))
{
if ((((CffPrincipal)Context.User).IsInClientRole == true || ((CffPrincipal)Context.User).IsInCustomerRole == true) && (clientId == "-1"))
{ //force to zero to return an error so we do not allow allclients scope for client or customer role
clientId = "0";
}
SessionWrapper.Instance.GetSession(viewID).ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(Convert.ToInt32(clientId));
SessionWrapper.Instance.GetSession(viewID).IsDeselectingCustomer = false;
if (SessionWrapper.Instance.GetSession(viewID).CurrentUserID != (System.Web.HttpContext.Current.User as CffPrincipal).CffUser.UserId.ToString())
{
SessionWrapper.Instance.GetSession(viewID).CurrentUserID = (System.Web.HttpContext.Current.User as CffPrincipal).CffUser.UserId.ToString();
}
if (SessionWrapper.Instance.Get != null)
{
SessionWrapper.Instance.Get.ClientFromQueryString = SessionWrapper.Instance.GetSession(viewID).ClientFromQueryString;
}
}
IScopeService scopeService = new ScopeService(this,
SecurityManagerFactory.Create(Context.User as CffPrincipal, SessionWrapper.Instance.GetSession(viewID).Scope),
RepositoryFactory.CreateClientRepository(),
RepositoryFactory.CreateCustomerRepository()
);
scopeService.SelectClient(int.Parse(clientId));
}
catch (FormatException)
{
}
return(string.Empty);
}
protected void gOAuthScopeEdit_SaveClick(object sender, EventArgs e)
{
ScopeService scopeService = new ScopeService(OAuthContext);
Scope scope = null;
if (hfScopeId.Value.AsIntegerOrNull().HasValue)
{
scope = scopeService.Get(hfScopeId.Value.AsInteger());
}
else
{
scope = new Scope();
scopeService.Add(scope);
}
scope.Identifier = tbIdentifier.Text;
scope.Description = tbDescription.Text;
scope.Active = cbScopeActive.Checked;
OAuthContext.SaveChanges();
OAuthContext = new OAuthContext();
gOAuthScopes_Bind(sender, e);
gOAuthScopeEdit.Hide();
}
public ScopeRepo1(SingletonService singleton, ScopeService scope, TransientService transient)
{
this.singleton = singleton;
this.scope = scope;
this.transient = transient;
}
protected void Page_Load(object sender, EventArgs e)
{
CffPrincipal cPrincipal = (CffPrincipal)Context.User;
// verify if this user agreed on the CFF Agreement
if (SessionWrapper.Instance.Get == null)
{
if ((cPrincipal.CffUser.UserType == UserType.EmployeeStaffUser) ||
(cPrincipal.CffUser.UserType == UserType.EmployeeManagementUser) ||
(cPrincipal.CffUser.UserType == UserType.EmployeeAdministratorUser))
{
string viewID = SaferTrader.Core.Common.StringEnum.GenerateUniqueKey(12);
SessionWrapper.Instance.GetSession(viewID).ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(Convert.ToInt32(QueryString.ClientId));
SessionWrapper.Instance.GetSession(viewID).UserIdentity = 1;
string rUrl = ResolveClientUrl(Context.Request.Url.AbsolutePath + "?Client=" + QueryString.ClientId.ToString() + "&User="******"&ViewID=" + viewID);
string tUrl = this.Context.Request.RawUrl;
this.Response.Redirect(rUrl);
}
else
{ //redirect to logon page - allow only one window tab instance to open, unless it came from the reports tab etc
string rUrl = ResolveClientUrl("~/Logon.aspx");
string tUrl = this.Context.Request.RawUrl;
this.Response.Redirect(rUrl);
}
}
if ((QueryString.ClientId != cPrincipal.CffUser.ClientId) && (cPrincipal.IsInClientRole || cPrincipal.IsInCustomerRole))
{
SessionWrapper.Instance.Get.ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId((int)cPrincipal.CffUser.ClientId);
}
if (Page.IsPostBack)
{
int ClientId = (this.Client != null) ? this.Client.Id : 0;
if (ClientId == 0)
{
if (QueryString.ClientId == null)
{
ClientId = Convert.ToInt32(cPrincipal.CffUser.ClientId.ToString());
}
else
{
ClientId = (int)QueryString.ClientId;
}
}
if (SessionWrapper.Instance.Get != null)
{
if ((SessionWrapper.Instance.Get.ClientFromQueryString.Id != ClientId) &&
(!string.IsNullOrEmpty(SessionWrapper.Instance.Get.AccountsIDList)))
{
SessionWrapper.Instance.Get.ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(ClientId);
}
else if (SessionWrapper.Instance.Get.ClientFromQueryString.Id != ClientId)
{
if (cPrincipal.CffUser.UserType == UserType.EmployeeAdministratorUser ||
cPrincipal.CffUser.UserType == UserType.EmployeeManagementUser || cPrincipal.CffUser.UserType == UserType.EmployeeStaffUser)
{
SessionWrapper.Instance.Get.ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(ClientId);
}
else if (cPrincipal.IsInClientRole || cPrincipal.IsInCustomerRole)
{
SessionWrapper.Instance.Get.ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(Convert.ToInt32(cPrincipal.CffUser.ClientId.ToString()));
}
}
}
else if (!string.IsNullOrEmpty(QueryString.ViewIDValue))
{
if ((SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).ClientFromQueryString.Id != ClientId) &&
(!string.IsNullOrEmpty(SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).AccountsIDList)))
{
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(ClientId);
}
else if (SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).ClientFromQueryString.Id != ClientId)
{
if (cPrincipal.CffUser.UserType == UserType.EmployeeAdministratorUser ||
cPrincipal.CffUser.UserType == UserType.EmployeeManagementUser || cPrincipal.CffUser.UserType == UserType.EmployeeStaffUser)
{
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(ClientId);
}
else if (cPrincipal.IsInClientRole || cPrincipal.IsInCustomerRole)
{
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).ClientFromQueryString = RepositoryFactory.CreateClientRepository().GetCffClientByClientId(Convert.ToInt32(cPrincipal.CffUser.ClientId.ToString()));
}
}
}
}
IScopeService scopeService = new ScopeService(this,
SecurityManagerFactory.Create(Context.User as CffPrincipal, SessionWrapper.Instance.Get.Scope),
RepositoryFactory.CreateClientRepository(),
RepositoryFactory.CreateCustomerRepository());
presenter = new DashboardPresenter(this, scopeService);
MembershipUser membershipUser = Membership.GetUser(User.Identity.Name);
if (presenter.IsReadAgreement((Guid)membershipUser.ProviderUserKey) == false)
{
RedirectTo("AgreementPage.aspx");
}
else
{
if (!IsPostBack)
{
presenter.InitialiseView();
}
content.InnerHtml = presenter.DashboardMainContent();
}
}
public async Task SeedUsers(int seedAmount)
{
await TestCleaner.CleanDatabase();
IDataGateway dataGateway = new SQLServerGateway();
IConnectionStringData connectionString = new ConnectionStringData();
IListingRepository listingRepository = new ListingRepository(dataGateway, connectionString);
ICollaborationRepository listingCollaborationRepository = new CollaborationRepository(dataGateway, connectionString);
IRelationshipRepository listingRelationshipRepository = new RelationshipRepository(dataGateway, connectionString);
ITeamModelRepository listingTeamModelRepository = new TeamModelRepository(dataGateway, connectionString);
IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
IUserProfileRepository userProfileRepository = new UserProfileRepository(dataGateway, connectionString);
IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString);
IAssignmentPolicyRepository assignmentPolicyRepository = new AssignmentPolicyRepository(dataGateway, connectionString);
IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository = new AssignmentPolicyPairingRepository(dataGateway, connectionString);
IScopeRepository scopeRepsitory = new ScopeRepository(dataGateway, connectionString);
IClaimRepository claimRepository = new ClaimRepository(dataGateway, connectionString);
IScopeClaimRepository scopeClaimRepository = new ScopeClaimRepository(dataGateway, connectionString);
IUserScopeClaimRepository userScopeClaimRepository = new UserScopeClaimRepository(dataGateway, connectionString);
IScopeService scopeService = new ScopeService(claimRepository, scopeRepsitory, scopeClaimRepository, userScopeClaimRepository);
ICryptographyService cryptographyService = new CryptographyService(userAccountRepository);
IAssignmentPolicyService assignmentPolicyService = new AssignmentPolicyService(assignmentPolicyRepository, assignmentPolicyPairingRepository, scopeRepsitory, scopeService);
IClaimsService claimService = new ClaimsService(claimRepository, scopeRepsitory, scopeClaimRepository, userScopeClaimRepository);
IListingCreationService listingCreationService = new ListingCreationService(listingRepository, listingCollaborationRepository, listingRelationshipRepository,
listingTeamModelRepository);
var accounts = await userAccountRepository.GetAllAccounts();
var accountSettings = await userAccountSettingsRepository.GetAllSettings();
IUserChannelsRepo userChannelsRepo = new UserChannelsRepo(dataGateway, connectionString);
var userChannels = await userChannelsRepo.GetAllUserChannelsAsync();
foreach (var userChannel in userChannels)
{
await userChannelsRepo.DeleteUserChannelsByIdAsync(userChannel.Id);
}
await DataAccessTestHelper.ReseedAsync("UserChannels", 0, connectionString, dataGateway);
IMessagesRepo messagesRepo = new MessagesRepo(dataGateway, connectionString);
var messages = await messagesRepo.GetAllMessagesAsync();
foreach (var message in messages)
{
await messagesRepo.DeleteMessageByIdAsync(message.Id);
}
await DataAccessTestHelper.ReseedAsync("Messages", 0, connectionString, dataGateway);
IChannelsRepo channelsRepo = new ChannelsRepo(dataGateway, connectionString);
var channels = await channelsRepo.GetAllChannelsAsync();
foreach (var channel in channels)
{
await channelsRepo.DeleteChannelbyIdAsync(channel.Id);
}
IAccountVerificationRepo accountVerification = new AccountVerificationRepo(dataGateway, connectionString);
var verfications = await accountVerification.GetAllAccountVerifications();
foreach (var verfication in verfications)
{
await accountVerification.DeleteAccountVerificationById(verfication.Id);
}
await DataAccessTestHelper.ReseedAsync("AccountVerification", 0, connectionString, dataGateway);
IPublicUserProfileRepo publicUserProfileRepo = new PublicUserProfileRepo(dataGateway, connectionString);
var publicProfiles = await publicUserProfileRepo.GetAllPublicProfiles();
foreach (var profile in publicProfiles)
{
await publicUserProfileRepo.DeletePublicProfileById(profile.Id);
}
await DataAccessTestHelper.ReseedAsync("PublicUserProfile", 0, connectionString, dataGateway);
if (accounts != null)
{
var numRows = accounts.ToList().Count;
for (int i = 1; i <= numRows; ++i)
{
await userAccountSettingsRepository.DeleteUserAccountSettingsByUserId(i);
}
}
await TestCleaner.CleanDatabase();
await DataAccessTestHelper.ReseedAsync("UserAccountSettings", 0, connectionString, dataGateway);
IUserAccountService userAccountService = new UserAccountService(userAccountRepository);
IUserProfileService userProfileService = new UserProfileService(userProfileRepository);
var assignedScopes = new List <ScopeModel>();
var namedScopes = new List <string>()
{
"friends_list:read,", "friends_list:write,", "friends_list:delete,", "friends_list:block,",
"friends_list:approve,", "user_profile:read,", "user_profile:report,", "user_profile:write,", "user_profile.friends_list.status:read,",
"application:read,", "user_profile.visibility:read,", "user_profile.photo:upload,", "messaging:send,", "messaging:get,", "messaging.users:get,", "messaging.channels:addUser,", "messaging.channels:removeUser,", "channels.user:getall,", "channels:create,", "channels:getowner,", "channels:delete,", "message:delete,", "channel:setonline,", "channel:setoffline,",
"account:delete,", "account:passwordchange,", "account.fontszie:change,", "account.email:change,", "account.fontSize:get,", "account.fontstyle:change,", "account.fontstyle:get,", "account.theme:change,", "account.theme:get,",
"listings:read,", "listings:write,"
};
var claims = new List <ClaimModel>();
claims.Add(new ClaimModel()
{
Type = "channel_owner",
Value = "false",
IsDefault = true
});
claims.Add(new ClaimModel()
{
Type = "Moderator",
Value = "false",
IsDefault = true
});
var currentClaims = await claimService.GetAllClaims();
foreach (var claim in claims)
{
foreach (var currentClaim in currentClaims)
{
if (claim.Type == currentClaim.Type)
{
continue;
}
}
await claimService.CreateClaim(claim);
}
var databaseClaims = await claimService.GetAllClaims();
foreach (var scope in namedScopes)
{
assignedScopes.Add(new ScopeModel()
{
Type = scope,
Claims = databaseClaims,
Description = null,
IsDefault = true
});
}
assignedScopes.ForEach(async x => await scopeService.CreateScope(x));
var scopes = (await scopeService.GetAllScopes()).ToList();
var assignmentPolicies = await assignmentPolicyService.CreateAssignmentPolicy(new BusinessModels.UserAccessControl.AssignmentPolicyModel()
{
Default = true,
Name = "DefaultAccessPolicy",
AssignedScopes = scopes,
Priority = 1,
RequiredAccountType = "user"
});
var adminPolicies = await assignmentPolicyService.CreateAssignmentPolicy(new BusinessModels.UserAccessControl.AssignmentPolicyModel()
{
Default = true,
Name = "DefaultAdminPolicy",
AssignedScopes = scopes,
Priority = 1,
RequiredAccountType = "admin"
});
PublicUserProfileManager publicUserProfileManager = new PublicUserProfileManager(new PublicUserProfileService(publicUserProfileRepo, new ValidationService(userAccountService, userProfileService)));
IAccountVerificationRepo accountVerificationRepo = new AccountVerificationRepo(new SQLServerGateway(), new ConnectionStringData());
IDictionary <string, string> _testConfigKeys = new Dictionary <string, string>();
_testConfigKeys.Add("Sender", "*****@*****.**");
_testConfigKeys.Add("TrackOpens", "true");
_testConfigKeys.Add("Subject", "Welcome!");
_testConfigKeys.Add("TextBody", "Welcome to InfiniMuse!");
_testConfigKeys.Add("MessageStream", "outbound");
_testConfigKeys.Add("Tag", "Welcome");
_testConfigKeys.Add("HtmlBody", "Thank you for registering! Please confirm your account with the link: <a href='{0}'>Confirm Your Account!</a><strong>Once confirmed you will have access to the features.</strong>");
IConfiguration configuration = new ConfigurationBuilder()
.AddInMemoryCollection(_testConfigKeys)
.Build();
EmailService emailService = new EmailService(new UserAccountRepository
(new SQLServerGateway(), new ConnectionStringData()), new AccountVerificationRepo
(new SQLServerGateway(), new ConnectionStringData()), new UserAccountService(new UserAccountRepository
(new SQLServerGateway(), new ConnectionStringData())), configuration);
for (int i = 1; i < seedAmount; ++i)
{
UserAccountModel userAccountModel = new UserAccountModel();
UserProfileModel userProfileModel = new UserProfileModel();
UserAccountSettingsModel userAccountSettingsModel = new UserAccountSettingsModel();
userAccountModel.Id = i;
userAccountModel.Username = "******" + i;
userAccountModel.Password = "" + i;
userAccountModel.Salt = "" + i;
userAccountModel.EmailAddress = "TestEmailAddress" + i;
userAccountModel.AccountType = "user";
userAccountModel.AccountStatus = "TestAccountStatus" + i;
userAccountModel.CreationDate = DateTimeOffset.UtcNow;
userAccountModel.UpdationDate = DateTimeOffset.UtcNow;
userProfileModel.Id = i;
userProfileModel.FirstName = "TestFirstName" + i;
userProfileModel.Surname = "TestSurname" + i;
userProfileModel.DateOfBirth = DateTimeOffset.UtcNow;
userProfileModel.UserAccountId = userAccountModel.Id;
userAccountSettingsModel.Id = i;
userAccountSettingsModel.UserId = userAccountModel.Id;
userAccountSettingsModel.FontSize = 12;
userAccountSettingsModel.FontStyle = "Default";
userAccountSettingsModel.ThemeColor = "Light";
await userAccountRepository.CreateAccount(userAccountModel);
await cryptographyService.newPasswordEncryptAsync("T" + i, i);
await userProfileRepository.CreateUserProfile(userProfileModel);
await userAccountSettingsRepository.CreateUserAccountSettings(userAccountSettingsModel);
PublicUserProfileModel publicUserProfileModel = new PublicUserProfileModel();
publicUserProfileModel.UserId = userAccountModel.Id;
publicUserProfileModel.Description = "My name is " + userAccountModel.Username;
publicUserProfileModel.Visibility = "Public";
publicUserProfileModel.Age = userAccountModel.Id + 20;
publicUserProfileModel.Hobbies = "These are my hobbies";
publicUserProfileModel.Intrests = "These are my intrests";
publicUserProfileModel.Height = "This is how tall I am";
await publicUserProfileManager.CeatePublicUserProfileAsync(publicUserProfileModel);
await emailService.CreateVerificationToken(publicUserProfileModel.UserId);
}
IMessagingService messagingService = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);
ChannelModel model = new ChannelModel();
model.OwnerId = 1;
model.Name = "Jakes Group";
await messagingService.CreateChannelAsync(model);
for (int i = 2; i < 19; i++)
{
await messagingService.AddUserToChannelAsync(i, 1);
}
IFriendListRepo friendListRepo = new FriendListRepo(dataGateway, connectionString);
IFriendRequestListRepo friendRequestListRepo = new FriendRequestListRepo(dataGateway, connectionString);
IFriendBlockListRepo friendBlockListRepo = new FriendBlockListRepo(dataGateway, connectionString);
IEnumerable <FriendsListJunctionModel> friends = await friendListRepo.GetAllFriends();
foreach (var friend in friends)
{
await friendListRepo.DeleteFriendListbyId(friend.Id);
}
await DataAccessTestHelper.ReseedAsync("FriendsList", 0, connectionString, dataGateway);
IEnumerable <FriendsListJunctionModel> requets = await friendRequestListRepo.GetAllFriendRequests();
foreach (var request in requets)
{
await friendRequestListRepo.DeleteFriendRequestListbyId(request.Id);
}
await DataAccessTestHelper.ReseedAsync("FriendRequestList", 0, connectionString, dataGateway);
IEnumerable <FriendsListJunctionModel> blocks = await friendBlockListRepo.GetAllFriendBlocks();
foreach (var block in blocks)
{
await friendBlockListRepo.DeleteFriendBlockbyId(block.Id);
}
await DataAccessTestHelper.ReseedAsync("FriendBlockList", 0, connectionString, dataGateway);
for (int i = 0; i < 20; i++)
{
BusinessCollaborationModel newBusinessCollaborationModel = new BusinessCollaborationModel();
BusinessListingModel newBusinessListingModel = new BusinessListingModel();
newBusinessCollaborationModel.Title = "TestTitle" + i;
newBusinessCollaborationModel.Details = "TestDetails" + i;
newBusinessCollaborationModel.City = "TestCity" + i;
newBusinessCollaborationModel.State = "TestState" + i;
newBusinessCollaborationModel.NumberOfParticipants = i;
newBusinessCollaborationModel.InPersonOrRemote = "InpersonOrRemoteTest" + i;
newBusinessCollaborationModel.UserAccountId = i;
newBusinessCollaborationModel.CollaborationType = "TestcollaborationType" + i;
newBusinessCollaborationModel.InvolvementType = "InvolvementType" + i;
newBusinessCollaborationModel.Experience = "Testexperience" + i;
newBusinessCollaborationModel.CollaborationType = "TestCollaborationType" + i;
newBusinessCollaborationModel.InvolvementType = "TestInvolvementType" + i;
newBusinessCollaborationModel.Experience = "TestExperience" + i;
await listingCreationService.CreateListing(newBusinessCollaborationModel);
}
for (int i = 21; i < 40; i++)
{
BusinessRelationshipModel newBusinessRelationshipModel = new BusinessRelationshipModel();
BusinessListingModel newBusinessListingModel1 = new BusinessListingModel();
newBusinessRelationshipModel.Title = "TestTitle" + i;
newBusinessRelationshipModel.Details = "TestDetails" + i;
newBusinessRelationshipModel.City = "TestCity" + i;
newBusinessRelationshipModel.State = "TestState" + i;
newBusinessRelationshipModel.NumberOfParticipants = i;
newBusinessRelationshipModel.InPersonOrRemote = "InpersonOrRemoteTest" + i;
newBusinessRelationshipModel.UserAccountId = i;
newBusinessRelationshipModel.RelationshipType = "TestcollaborationType" + i;
newBusinessRelationshipModel.Age = 21;
newBusinessRelationshipModel.Interests = "TestInterests" + i;
newBusinessRelationshipModel.GenderPreference = "TestGenderPreference" + i;
await listingCreationService.CreateListing(newBusinessRelationshipModel);
}
for (int i = 41; i < 60; i++)
{
BusinessTeamModel newBusinessTeamModel = new BusinessTeamModel();
BusinessListingModel newBusinessListingModel1 = new BusinessListingModel();
newBusinessTeamModel.Title = "TestTitle" + i;
newBusinessTeamModel.Details = "TestDetails" + i;
newBusinessTeamModel.City = "TestCity" + i;
newBusinessTeamModel.State = "TestState" + i;
newBusinessTeamModel.NumberOfParticipants = i;
newBusinessTeamModel.InPersonOrRemote = "InpersonOrRemoteTest" + i;
newBusinessTeamModel.UserAccountId = i + 1;
newBusinessTeamModel.TeamType = "TestTeamType" + i;
newBusinessTeamModel.GameType = "TestGameType" + i;
newBusinessTeamModel.Platform = "TestPlatform" + i;
newBusinessTeamModel.Experience = "TestExperience" + i;
await listingCreationService.CreateListing(newBusinessTeamModel);
}
IUserReportsRepo userReportsRepo = new UserReportsRepo(dataGateway, connectionString);
IValidationService validationService = new ValidationService(userAccountService, userProfileService);
IPublicUserProfileService publicUserProfileService = new PublicUserProfileService(publicUserProfileRepo, validationService);
IUserInteractionService userInteractionService = new UserInteractionService(friendBlockListRepo, friendListRepo, friendRequestListRepo, userReportsRepo, validationService);
IFriendListManager friendListManager = new FriendListManager(userAccountRepository, publicUserProfileService, userInteractionService);
for (int i = 10; i < 15; i++)
{
await friendListManager.RequestFriendAsync(1, i);
}
await friendListManager.RequestFriendAsync(18, 1);
for (int i = 2; i < 10; i++)
{
await friendListManager.RequestFriendAsync(1, i);
await friendListManager.ConfirmFriendAsync(1, i);
}
for (int i = 3; i < 10; i++)
{
await friendListManager.RequestFriendAsync(2, i);
await friendListManager.ConfirmFriendAsync(2, i);
}
await friendListManager.BlockFriendAsync(19, 1);
MessageModel messageModel = new MessageModel();
messageModel.ChannelId = 1;
messageModel.UserId = 1;
messageModel.Message = "Hi Tim";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 1;
messageModel.UserId = 2;
messageModel.Message = "Whats up Jake";
await messagingService.SendMessageAsync(messageModel);
model = new ChannelModel();
model.OwnerId = 3;
model.Name = "Richards Group";
await messagingService.CreateChannelAsync(model);
await messagingService.AddUserToChannelAsync(1, 2);
await messagingService.AddUserToChannelAsync(2, 2);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 3;
messageModel.Message = "Hi Jake and Tim";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 1;
messageModel.Message = "Whats up Richard how are you doing";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 3;
messageModel.Message = "Im Chilling";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 3;
messageModel.Message = "Just doing some homework";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 1;
messageModel.Message = "Oh nice, I started spring break this week and I finished all of my homework a few days ago so im just relaxing playing some warzone";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 3;
messageModel.Message = "Oh sweet";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 2;
messageModel.Message = "Whats up guys its me Tim";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 3;
messageModel.Message = "Hey Tim";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 1;
messageModel.Message = "Whats up tim";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 2;
messageModel.Message = "Nothing much guys";
await messagingService.SendMessageAsync(messageModel);
messageModel = new MessageModel();
messageModel.ChannelId = 2;
messageModel.UserId = 1;
messageModel.Message = "You guys wanna hop on warzone with me";
await messagingService.SendMessageAsync(messageModel);
}
public string SelectCustomerFromAutoCompleteDropDown(string customerId)
{
//assign new customer instance here based from retrieved customer number and existing clientid
Scope xScope = Scope.AllClientsScope;
CffCustomerExt xCustomer = null;
CffCustomer cCustomer = null;
if (SessionWrapper.Instance.Get != null)
{
if (SessionWrapper.Instance.Get.EmptyWindowHit == 0)
{
SessionWrapper.Instance.Get.EmptyWindowHit = 1;
}
if (xCustomer == null)
{
if (customerId.Contains("("))
{ //this is customer number! we should be able to retrieve correct customer id + client id
customerId = customerId.Substring(customerId.IndexOf("(") + 1);
customerId = customerId.Replace(")", "");
}
if (!string.IsNullOrEmpty(customerId))
{
cCustomer = (RepositoryFactory.CreateCustomerRepository().GetMatchedCustomerInfo(Convert.ToInt32(customerId),
SessionWrapper.Instance.Get.ClientFromQueryString.Id).CffCustomerInformation.Customer);
xCustomer = new CffCustomerExt(cCustomer.Name, cCustomer.Id, cCustomer.Number);
}
}
if (xCustomer != null)
{
SessionWrapper.Instance.Get.CustomerFromQueryString = (ICffCustomer)xCustomer;
if (SessionWrapper.Instance.Get.CurrentUserID != (System.Web.HttpContext.Current.User as CffPrincipal).CffUser.UserId.ToString())
{
SessionWrapper.Instance.Get.CurrentUserID = (System.Web.HttpContext.Current.User as CffPrincipal).CffUser.UserId.ToString();
}
}
}
else if (!string.IsNullOrEmpty(QueryString.ViewIDValue))
{
if (SessionWrapper.Instance.GetSession(QueryString.ViewIDValue) != null)
{
xScope = SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).Scope;
if (SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).EmptyWindowHit == 0)
{
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).EmptyWindowHit = 1;
}
cCustomer = (RepositoryFactory.CreateCustomerRepository().GetMatchedCustomerInfo(Convert.ToInt32(customerId),
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).ClientFromQueryString.Id).CffCustomerInformation.Customer);
xCustomer = new CffCustomerExt(cCustomer.Name, cCustomer.Id, cCustomer.Number);
if (xCustomer != null)
{
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).CustomerFromQueryString = (ICffCustomer)xCustomer;
}
if (SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).CurrentUserID != (System.Web.HttpContext.Current.User as CffPrincipal).CffUser.UserId.ToString())
{
SessionWrapper.Instance.GetSession(QueryString.ViewIDValue).CurrentUserID = (System.Web.HttpContext.Current.User as CffPrincipal).CffUser.UserId.ToString();
}
}
}
IScopeService scopeService = new ScopeService(this,
SecurityManagerFactory.Create(Context.User as CffPrincipal, xScope),
RepositoryFactory.CreateClientRepository(),
RepositoryFactory.CreateCustomerRepository());
string jSon = string.Empty;
if (!string.IsNullOrEmpty(customerId))
{
try
{
scopeService.SelectCustomer(int.Parse(customerId));
using (MemoryStream stream = new MemoryStream())
{
serializer.WriteObject(stream, Client);
jSon = Encoding.Default.GetString(stream.ToArray());
}
}
catch (FormatException)
{
}
}
return(jSon);
}
public CollectionServices(ScopeService scopeService, SingletonService singletonService, TransientService transientService)
{
_scopeService = scopeService;
_singletonService = singletonService;
_transientService = transientService;
}
public ScopeController(ScopeService scopeService)
{
_scopeService = scopeService;
}
