public void FindMembershipByEmailNotFound()
{
TestUtil.SetupResponseXml(_ctx.WebRequest, "<memberships type=\"array\"></memberships>");
IMembership membership = _organization.FindMembershipByEmail("*****@*****.**");
Assert.Null(membership);
}
internal void SetupMembershipReturns(string userHash, IMembership value)
{
lock (_lock)
{
_memberships[userHash] = value;
}
}
public void ReturnItem(IResource resource, IMembership membership)
{
var returnedItem = GetOutstandingBorrowedItem(resource, membership);
returnedItem.IsReturned = true;
returnedItem.ReturnedDate = DateTime.UtcNow;
}
public static IMembership Get(int xp, bool getNext = false)
{
var cache = new MembershipsCache();
List <Membership> list = (List <Membership>)cache.Get();
IMembership result = null;
for (int i = 0; i < list.Count; i++)
{
if (list[i].MinPointsToHaveThisLevel <= xp)
{
result = list[i];
}
else
{
if (getNext)
{
result = list[i];
}
break;
}
}
return(result);
}
public void CheckMemberIsUnderBorrowingLimit(IMembership membership)
{
if (IsMemberUnderBorrowingLimit(membership) == false)
{
throw new MembersBorrowingLimitExceededException(Constant.MembersBorrowingLimitExceeded);
}
}
public void ResolveReferralLimits(IMembership membership)
{
//Direct
if (GetDirectReferralsCount() > membership.DirectReferralsLimit + (long)DirectReferralLimitEnlargedBy)
{
var list = GetDirectReferralsList();
long howmany = list.Count - (long)membership.DirectReferralsLimit - DirectReferralLimitEnlargedBy;
for (int i = 0; i < howmany; ++i)
{
list[i].RemoveReferer();
list[i].Save();
}
}
//Rented
if (AppSettings.TitanFeatures.ReferralsRentedEnabled)
{
var rrm = new Prem.PTC.Referrals.RentReferralsSystem(Name, membership);
if (AppSettings.TitanFeatures.ReferralsRentedEnabled && (rrm.GetUserRentedReferralsCount() > membership.RentedReferralsLimit))
{
int howmany = rrm.GetUserRentedReferralsCount() - membership.RentedReferralsLimit;
rrm.DeleteRentedReferrals(howmany);
}
}
}
public void Setup()
{
_packingSlip = new PackingSlip();
_membership = new MembershipService();
_commisionService = new CommisionService();
_orderService = new OrderProcessingService(_packingSlip, _membership, _commisionService);
}
public MembershipController(
IAsyncRepository <Membership> membershipRepository,
IMembership membership)
{
_membershipRepository = membershipRepository;
_membership = membership;
}
private static Money CalculateExposureDirectEarnings(IMembership userMembership, PtcAdvert ad)
{
var exposureEarnings = Money.Zero;
switch (ad.ExposureType)
{
case AdExposure.Mini:
exposureEarnings = userMembership.ExposureMiniDirectClickEarnings;
break;
case AdExposure.Micro:
exposureEarnings = userMembership.ExposureMicroDirectClickEarnings;
break;
case AdExposure.Fixed:
exposureEarnings = userMembership.ExposureFixedDirectClickEarnings;
break;
case AdExposure.Standard:
exposureEarnings = userMembership.ExposureStandardDirectClickEarnings;
break;
case AdExposure.Extended:
exposureEarnings = userMembership.ExposureExtendedDirectClickEarnings;
break;
default:
break;
}
exposureEarnings = Money.MultiplyPercent(exposureEarnings, ad.DirectReferralClickValue);
return(exposureEarnings);
}
public IEnumerable<IHuntable> GetAvailableList(IMembership member)
{
var trucks = new List<Truck>();
trucks = _truckrepo.Where(m => m.IsContender).ToList();
return trucks;
}
/// <inheritdoc/>
public IMembership FindMembershipByEmail(string email)
{
string requestPath = string.Format("{0}/memberships?email={1}", Path, System.Uri.EscapeUriString(email));
ArrayList matches = (ArrayList)(ModelBase.Deserialize(Listen360, Listen360.GetRequestResponseElement(requestPath)));
IMembership match = (matches.Count == 0) ? null : (IMembership)matches[0];
return(match);
}
public void SetUp()
{
_membership = Substitute.For <IMembership>();
_securityRepository = Substitute.For <ISecurityRepository>();
_serviceContainer = Substitute.For <IServiceContainer>();
_authService = new AuthService(_membership, _securityRepository, _serviceContainer);
}
public AuthService(
IMembership membership,
ISecurityRepository securityRepository,
IServiceContainer serviceContainer)
{
_membership = membership;
_securityRepository = securityRepository;
_serviceContainer = serviceContainer;
}
public void LeastRecentUserIsEvictedFromCache()
{
SetStoreTimestamp(UnixMillisecondTime.Now);
const string userKey1 = "userkey1", userKey2 = "userkey2", userKey3 = "userkey3";
IMembership expectedMembership1 = NewMembershipFromSegmentRefs(new string[] { "seg1" }, null),
expectedMembership2 = NewMembershipFromSegmentRefs(new string[] { "seg2" }, null),
expectedMembership3 = NewMembershipFromSegmentRefs(new string[] { "seg3" }, null);
SetStoreMembership(userKey1, expectedMembership1);
SetStoreMembership(userKey2, expectedMembership2);
SetStoreMembership(userKey3, expectedMembership3);
var bsConfig = Components.BigSegments(_storeFactory)
.UserCacheSize(2)
.StaleAfter(TimeSpan.FromDays(1))
.CreateBigSegmentsConfiguration(BasicContext);
using (var sw = new BigSegmentStoreWrapper(bsConfig, BasicTaskExecutor, TestLogger))
{
var result1 = sw.GetUserMembership(userKey1);
Assert.Equal(expectedMembership1, result1.Membership);
Assert.Equal(BigSegmentsStatus.Healthy, result1.Status);
var result2 = sw.GetUserMembership(userKey2);
Assert.Equal(expectedMembership2, result2.Membership);
Assert.Equal(BigSegmentsStatus.Healthy, result2.Status);
var result3 = sw.GetUserMembership(userKey3);
Assert.Equal(expectedMembership3, result3.Membership);
Assert.Equal(BigSegmentsStatus.Healthy, result3.Status);
ShouldHaveQueriedMembershipTimes(userKey1, 1);
ShouldHaveQueriedMembershipTimes(userKey2, 1);
ShouldHaveQueriedMembershipTimes(userKey3, 1);
// Since the capacity is only 2 and userKey1 was the least recently used, that key should be
// evicted by the userKey3 query. Now only userKey2 and userKey3 are in the cache, and
// querying them again should not cause a new query to the store.
var result2a = sw.GetUserMembership(userKey2);
Assert.Equal(expectedMembership2, result2a.Membership);
var result3a = sw.GetUserMembership(userKey3);
Assert.Equal(expectedMembership3, result3a.Membership);
ShouldHaveQueriedMembershipTimes(userKey1, 1);
ShouldHaveQueriedMembershipTimes(userKey2, 1);
ShouldHaveQueriedMembershipTimes(userKey3, 1);
var result1a = sw.GetUserMembership(userKey1);
Assert.Equal(expectedMembership1, result1a.Membership);
ShouldHaveQueriedMembershipTimes(userKey1, 2);
ShouldHaveQueriedMembershipTimes(userKey2, 1);
ShouldHaveQueriedMembershipTimes(userKey3, 1);
}
}
public static Money CalculateEarningsFromDirectReferral(IMembership UserMembership, PtcAdvert Ad)
{
if (AppSettings.PtcAdverts.ExposureCategoriesEnabled)
{
return(CalculateExposureDirectEarnings(UserMembership, Ad));
}
return(calculateEarnings(UserMembership.DirectReferralAdvertClickEarnings, Ad.DirectReferralClickValue));
}
public void ClientControllerTestStart()
{
IUnityContainer container = TestBootstrapper.Initialise();
this.ClientProfileVMService = container.Resolve <IClientProfileVMServices>();
this.MembershipService = container.Resolve <IMembership>();
this.UserModelService = container.Resolve <IUserModelService>();
controller = new ClientController(this.ClientProfileVMService, this.MembershipService, this.UserModelService);
}
public RentReferralsSystem(string username, IMembership membership)
{
Username = username;
Membership = membership;
option = AppSettings.Referrals.Renting;
activeUsersIndex = 0;
random = new Random();
this.UserId = (new Member(username)).Id; //BAD
}
public void FindMembershipByEmail()
{
TestUtil.SetupResponseXml(_ctx.WebRequest, string.Format("<memberships type=\"array\">{0}</memberships>", Properties.Resources.FakeMembership1));
IMembership membership = _organization.FindMembershipByEmail("*****@*****.**");
Assert.IsTrue(_ctx.WebRequestFactory.CreateWebRequestCalled);
Assert.AreEqual(string.Format("{0}/{1}/[email protected]", _ctx.Url, _organization.Path), _ctx.WebRequestFactory.CreateWebRequestLastUrl);
Assert.NotNull(membership);
}
public MembershipManagerTests()
{
_member = new Membership()
{
Id = 1,
IsActive = true
};
_membershipManager = new MembershipManager();
}
internal EvalScope(Evaluator parent, FeatureFlag flag, User user, EventFactory eventFactory)
{
_parent = parent;
_flag = flag;
_user = user;
_eventFactory = eventFactory;
_prereqEvents = new LazilyCreatedList <EvaluationEvent>();
_bigSegmentsMembership = null;
_bigSegmentsStatus = null;
}
private IBorrowedItem CreateBorrowedItem(IResource resource, IMembership membership)
{
return(new BorrowedItem
{
Resource = resource,
Member = membership,
DueDate = membership.GetDateMemberCanBorrowTill(),
BorrowedDate = DateTime.UtcNow,
});
}
public static Money CalculateNormalMemberEarnings(IMembership UserMembership, PtcAdvert Ad)
{
if (AppSettings.PtcAdverts.ExposureCategoriesEnabled)
{
return(CalculateExposureNormalEarnings(UserMembership, Ad));
}
return(calculateEarnings(UserMembership.AdvertClickEarnings, Ad.ClickValue));
}
static void Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddSingleton <ICommission, AgentCommission>()
.AddSingleton <IMembership, CustomerMembership>()
.BuildServiceProvider();
ICommission commission = serviceProvider.GetService <ICommission>();
IMembership membership = serviceProvider.GetService <IMembership>();
PaymentService paymentService = new PaymentService(commission, membership);
PaymentResult result;
Console.WriteLine("Books");
Product product = new Product()
{
Agent = 1, Amount = 1000.00, Category = 1, ProductId = 1, ProductType = "Books", ProductName = "Book 1"
};
result = paymentService.MakePayment(product);
Console.WriteLine("---------------------------------------------------------------------");
Console.WriteLine("Toys");
Product product2 = new Product()
{
Agent = 1, Amount = 1000.00, Category = 1, ProductId = 1, ProductType = "", ProductName = "Toy 1"
};
paymentService.MakePayment(product2);
Console.WriteLine("---------------------------------------------------------------------");
Console.WriteLine("Video");
Product product3 = new Product()
{
Agent = 1, Amount = 2000.00, Category = 2, ProductId = 1, ProductType = "", ProductName = "Learning To Ski"
};
paymentService.MakePayment(product3);
Console.WriteLine("---------------------------------------------------------------------");
Console.WriteLine("New Membership");
Product product4 = new Product()
{
Agent = 1, Amount = 2000.00, Category = 3, ProductId = 1, ProductType = "New", ProductName = "Video"
};
paymentService.MakePayment(product4);
Console.WriteLine("---------------------------------------------------------------------");
Console.WriteLine("Upgrade Membership");
Product product5 = new Product()
{
Agent = 1, Amount = 2000.00, Category = 3, ProductId = 1, ProductType = "Upgrade", ProductName = "Video"
};
paymentService.MakePayment(product5);
Console.ReadLine();
//Console.WriteLine("Hello World!");
}
/// <summary>
/// Validates the account password.
/// </summary>
/// <param name="password">The password.</param>
/// <param name="membership">The membership.</param>
/// <returns></returns>
public static bool ValidateMembershipPassword(string password, IMembership membership)
{
if (membership == null)
{
return false;
}
var maskedPassword = password.FormatPasscode((InverGrovePasswordFormat)membership.PasswordFormatId, membership.PasswordSalt);
return (membership.Password == maskedPassword);
}
/// <exception cref="DbException" />
private void setMembership(IMembership membership, DateTime?when, DateTime?expires)
{
bool isUpToDate = IsUpToDate;
Membership = membership;
MembershipWhen = when;
MembershipExpires = expires;
HasEverUpgraded = true;
SaveMembership();
}
public IMembership GetIMem()
{
IMembership Imem = null;
Assembly assm = Assembly.Load(ConfigurationManager.AppSettings["UserRepositoryAssembly"]);
foreach (var typeItem in assm.GetTypes())
{
if (string.Compare(typeItem.Name, "MyMembership") == 0 && typeItem.IsClass)
{
Imem = assm.CreateInstance(typeItem.FullName) as IMembership;
}
}
return(Imem);
}
public static void Add(IContext context, IMembership member)
{
Context ctx = context as Context;
if (ctx == null)
throw new Exception(typeof(Context).FullName + " expected.");
SqlCommand command = new SqlCommand("insert into Membership (id_user, id_project, id_role, active) values (@UserID, @ProjectID, @RoleID, @Active)");
command.Parameters.Add(new SqlParameter("UserID", member.UserID));
command.Parameters.Add(new SqlParameter("ProjectID", member.ProjectID));
command.Parameters.Add(new SqlParameter("RoleID", member.RoleID));
command.Parameters.Add(new SqlParameter("Active", member.Active));
command.ExecuteNonQuery();
}
public static void Update(IContext context, IMembership member)
{
Context ctx = context as Context;
if (ctx == null)
throw new Exception(typeof(Context).FullName + " expected.");
SqlCommand command = new SqlCommand("update Membership set id_user=@UserID, id_project=@ProjectID, id_role=@RoleID, active=@Active where id_member = @MemberID");
command.Parameters.Add(new SqlParameter("MemberID", member.MemberID));
command.Parameters.Add(new SqlParameter("UserID", member.UserID));
command.Parameters.Add(new SqlParameter("ProjectID", member.ProjectID));
command.Parameters.Add(new SqlParameter("RoleID", member.RoleID));
command.Parameters.Add(new SqlParameter("Active", member.Active));
command.ExecuteNonQuery();
}
public AccountApiController(IAuthentication formsService, IViewElementRoleService viewElementRoleService, ICompanyChartService CompanyChartService,
IUserService userService, IServiceBase <CoreUserLog> userLogService, IUserProfileService userprofileService, IConstantService constantService, IDomainAuthenticationService domainAuthenticationService)
{
_membershipService = new AccountMembership();
_formsService = formsService;
_viewElementRoleService = viewElementRoleService;
_companyChartService = CompanyChartService;
_userService = userService;
_userLogService = userLogService;
_userProfileService = userprofileService;
_constantService = constantService;
_domainAuthenticationService = domainAuthenticationService;
}
public TravelersAroundService(IRepository repository,
IMembership membership,
IGeoCoder geoCoder,
ILocationDeterminator locationDeterminator,
ILog log,
ICache cache,
IAPIKeyGenerator apiKeyGen)
: base(log)
{
_repository = repository;
_membership = membership;
_locationDeterminator = locationDeterminator;
_geoCoder = geoCoder;
_cache = cache;
_apiKeyGen = apiKeyGen;
}
private IList GetGroupTaskList(String actorId)
{
IList groupTaskList = null;
IList groupIds = new ArrayList();
try {
IEnumerator membershipsEnumerator = organisationComponent.FindUserById(
actorId, new Relations("memberships.group")).Memberships.GetEnumerator();
while (membershipsEnumerator.MoveNext())
{
IMembership membership = (IMembership)membershipsEnumerator.Current;
groupIds.Add(membership.Group.Id);
}
groupTaskList = executionComponent.GetTaskList(groupIds);
}
finally {
}
return(groupTaskList);
}
/// <summary>
/// Constructor to Inject Service Dependecies
/// </summary>
/// <param name="agent"></param>
/// <param name="department"></param>
/// <param name="emailNotification"></param>
/// <param name="membership"></param>
/// <param name="membershipUpgrade"></param>
/// <param name="order"></param>
/// <param name="packingSlip"></param>
/// <param name="packingSlipRoyaltyDep"></param>
/// <param name="payment"></param>
/// <param name="product"></param>
/// <param name="shipping"></param>
/// <param name="user"></param>
/// <param name="videoSubscription"></param>
public PaymentController(IAgent agent, IDepartment department, IEmailNotification emailNotification,
IMembership membership, IMembershipUpgrade membershipUpgrade, IOrder order, IPackingSlip packingSlip,
IPackingSlipRoyaltyDep packingSlipRoyaltyDep, IPayment payment, IProduct product, IShipping shipping,
IUser user, IVideoSubscription videoSubscription)
{
_agent = agent;
_department = department;
_emailNotification = emailNotification;
_membership = membership;
_membershipUpgrade = membershipUpgrade;
_order = order;
_packingSlip = packingSlip;
_packingSlipRoyaltyDep = packingSlipRoyaltyDep;
_payment = payment;
_product = product;
_shipping = shipping;
_user = user;
_videoSubscription = videoSubscription;
}
public void Downgrade(IMembership membership, bool setMinPoints = true, bool resolveReferrals = true)
{
setMembership(membership, AppSettings.ServerTime, null);
if (resolveReferrals)
{
ResolveReferralLimits(membership);
}
if (AppSettings.Points.LevelMembershipPolicyEnabled && setMinPoints)
{
if (PointsBalance > membership.MinPointsToHaveThisLevel)
{
int substracted = PointsBalance - membership.MinPointsToHaveThisLevel;
PointsBalance = membership.MinPointsToHaveThisLevel;
SaveBalances();
BalanceLog.Add(this, BalanceType.PointsBalance, -substracted, "Level downgrade", BalanceLogType.Other);
}
}
}
private static void AssertEqualMembership(IMembership expected, IMembership actual)
{
if (actual.GetType().FullName.StartsWith("LaunchDarkly.Sdk.Server.Internal.BigSegments.MembershipBuilder"))
{
// The store implementation is using our standard membership types, so we can rely on the
// standard equality test for those
Assert.Equal(expected, actual);
}
else
{
// The store implementation has implemented IMembership in some other way, so we have to
// check for the inclusion or exclusion of specific keys
foreach (var segmentRef in allSegmentRefs)
{
if (actual.CheckMembership(segmentRef) != expected.CheckMembership(segmentRef))
{
Assert.True(false, string.Format("expected membership for {0} to be {1} but was {2}",
segmentRef, expected.CheckMembership(segmentRef), actual.CheckMembership(segmentRef)));
}
}
}
}
/// <summary> /// When overriden in a derived class, unlock the user. /// </summary> /// <param name="user">The user.</param> public abstract void UnlockUser(IMembership user);
/// <summary>
/// Resets the password.
/// </summary>
/// <param name="membership">The membership.</param>
/// <returns></returns>
/// <exception cref="System.NotSupportedException"></exception>
public string ResetPassword(IMembership membership)
{
if (!this.EnablePasswordReset)
{
throw new NotSupportedException(Messages.NotConfiguredToSupportPasswordResets);
}
return this.GetGeneratedPassword((Membership)membership);
}
/// <summary> /// When overriden in a derived class, deletes a user from the database. /// </summary> /// <param name="user">The user.</param> /// <param name="deleteAllRelatedData">if set to <c>true</c> [delete all related data].</param> public abstract void DeleteUser(IMembership user, bool deleteAllRelatedData);
public abstract bool IsAlreadyLogin(IMembership user, object loginIdentifier);
public abstract bool IsEligibleToLogin(IMembership user, object loginIdentifier);
/// <summary> /// When overriden in a derived class, creates a user in the database. /// </summary> /// <param name="userId">The user id.</param> /// <param name="fullName">The full name.</param> /// <param name="password">The password.</param> /// <param name="userGroupId">The user group id.</param> /// <param name="message">The message.</param> /// <returns></returns> public abstract CreateUserResult CreateUser(IMembership user);
public abstract bool IsPasswordHasBeenUsedBefore(IMembership user, string password);
public Condition(string name, IMembership membership)
{
this.Name = name.ToUpper();
this.Membership = membership;
}
/// <summary>
/// Class constructor. It initializes the IUserRepository object
/// </summary>
public AccountController(IUserRepository userRepo, IFormsAuth formsAuth, IMembership membership)
{
_userRepo = userRepo;
_formsAuth = formsAuth;
_membership = membership;
}
public abstract void SetUserLoginTime(IMembership user, DateTime loginTime);
public abstract DateTime GetUserLoginTime(IMembership user);
public void AddOutputVariableMembership(string variable, string conditionName, IMembership membership)
{
OutputVariables[variable.ToUpper()].Add(new Condition(conditionName, membership));
}
/// <summary>
/// Updates the membership.
/// </summary>
/// <param name="membership">The membership.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">membership</exception>
public bool UpdateMembership(IMembership membership)
{
if (membership == null)
{
throw new ParameterNullException("membership");
}
bool success = true;
try
{
this.membershipRepository.Update(membership);
}
catch (Exception)
{
success = false;
}
return success;
}
/// <summary> /// When overriden in a derived class, updates the user. /// </summary> /// <param name="user">The user.</param> public abstract void UpdateUser(IMembership user);
public abstract bool IsUserPasswordExpired(IMembership user);
public LevelupManager(Member user)
{
this.user = user;
membership = user.Membership;
}
/// <summary> /// When overriden in a derived class, changes the user's password. /// </summary> /// <param name="user">The user.</param> /// <param name="oldPassword">The old password.</param> /// <param name="NewPassword">The new password.</param> public abstract ChangePasswordResult ChangePassword(IMembership user, string oldPassword, string NewPassword);
