private void DeleteMember(Member objMember)
{
MemberList.Remove(objMember);
MembershipData.SaveMemberships(MemberList);
Messenger.Default.Send(new NotificationMessage(objMember.DisplayText + " is removed successfully."));
CloseWindow(objMemberUpdate);
}
public bool AddAgentToGroupInvite(string RequestingAgentID, UUID inviteID, UUID groupID, UUID roleID, string agentID)
{
// Check whether the invitee is already a member of the group
MembershipData m = m_Database.RetrieveMember(groupID, agentID);
if (m != null)
{
return(false);
}
// Check permission to invite
if (!HasPower(RequestingAgentID, groupID, GroupPowers.Invite))
{
m_log.DebugFormat("[Groups]: ({0}) Attempt at inviting to group {1} denied because of lack of permission", RequestingAgentID, groupID);
return(false);
}
// Check whether there are pending invitations and delete them
InvitationData invite = m_Database.RetrieveInvitation(groupID, agentID);
if (invite != null)
{
m_Database.DeleteInvite(invite.InviteID);
}
invite = new InvitationData();
invite.InviteID = inviteID;
invite.PrincipalID = agentID;
invite.GroupID = groupID;
invite.RoleID = roleID;
invite.Data = new Dictionary <string, string>();
return(m_Database.StoreInvitation(invite));
}
/// <summary>
/// Handles the Click event of the cmdChangePassword control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
protected void CmdChangePasswordClick(object sender, EventArgs e)
{
if (!cvPasswords.IsValid)
{
return;
}
GetMembershipData(UserId);
if (MembershipData == null)
{
return;
}
try
{
MembershipData.ChangePassword(MembershipData.ResetPassword(), NewPassword.Text);
ActionMessage.ShowSuccessMessage(GetLocalResourceObject("PasswordChangeSuccess").ToString());
GetMembershipData(UserId);
DataBind();
}
catch (Exception ex)
{
if (Log.IsErrorEnabled)
{
if (HttpContext.Current.User != null && HttpContext.Current.User.Identity.IsAuthenticated)
{
MDC.Set("user", HttpContext.Current.User.Identity.Name);
}
Log.Error(LoggingManager.GetErrorMessageResource("PasswordChangeError"), ex);
}
ActionMessage.ShowErrorMessage(LoggingManager.GetErrorMessageResource("PasswordChangeError"));
}
}
public bool StoreMember(MembershipData data)
{
CompositeKey dkey = new CompositeKey(data.GroupID, data.PrincipalID);
m_Membership[dkey] = data;
return(true);
}
private bool AddAgentToGroupInvite(UUID inviteID, UUID groupID, string agentID)
{
// Check whether the invitee is already a member of the group
MembershipData m = m_Database.RetrieveMember(groupID, agentID);
if (m != null)
{
return(false);
}
// Check whether there are pending invitations and delete them
InvitationData invite = m_Database.RetrieveInvitation(groupID, agentID);
if (invite != null)
{
m_Database.DeleteInvite(invite.InviteID);
}
invite = new InvitationData();
invite.InviteID = inviteID;
invite.PrincipalID = agentID;
invite.GroupID = groupID;
invite.RoleID = UUID.Zero;
invite.Data = new Dictionary <string, string>();
return(m_Database.StoreInvitation(invite));
}
protected void _AddAgentToGroupRole(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
{
RoleMembershipData data = m_Database.RetrieveRoleMember(GroupID, RoleID, AgentID);
if (data != null)
{
return;
}
data = new RoleMembershipData();
data.GroupID = GroupID;
data.PrincipalID = AgentID;
data.RoleID = RoleID;
m_Database.StoreRoleMember(data);
// Make it the SelectedRoleID
MembershipData membership = m_Database.RetrieveMember(GroupID, AgentID);
if (membership == null)
{
m_log.DebugFormat("[Groups]: ({0}) No such member {0} in group {1}", AgentID, GroupID);
return;
}
membership.Data["SelectedRoleID"] = RoleID.ToString();
m_Database.StoreMember(membership);
}
private void onMembershipDataUpdated(MembershipData membershipData)
{
if (membershipData.IsMember)
{
Service.Get <TrayNotificationManager>().DismissAllNotifications();
}
}
public void AddOnlyLatestMembershipData_OldRecordStays_Success_Test()
{
var testOldRecord = new MembershipData();
testOldRecord.FirstName.CsvNewValue = "testFirstName";
testOldRecord.LastName.CsvNewValue = "testLastName";
testOldRecord.Email.CsvNewValue = "testEmail";
testOldRecord.Address.CsvNewValue = "oldAddress";
testOldRecord.UpdateDate.CsvNewValue = DateTime.Parse("02/15/18 10:00").ToShortDateString();
var testNewRecordWithOlderDate = new MembershipData();
testNewRecordWithOlderDate.FirstName.CsvNewValue = "testFirstName";
testNewRecordWithOlderDate.LastName.CsvNewValue = "testLastName";
testNewRecordWithOlderDate.Email.CsvNewValue = "testEmail";
testNewRecordWithOlderDate.Address.CsvNewValue = "newAddress";
testNewRecordWithOlderDate.UpdateDate.CsvNewValue = DateTime.Parse("02/14/18 11:00").ToShortDateString();
var testList = new List <MembershipData> {
testOldRecord
};
MembershipHelper.AddOnlyLatestMembershipData(testList, testNewRecordWithOlderDate);
Assert.AreEqual(1, testList.Count);
Assert.AreEqual("oldAddress", testList.FirstOrDefault().Address.CsvNewValue);
}
private static int UpdateWorksheetRowFromMembershipData(SharedStringTable sharedStrings, Row row, List <MembershipData> inputDataList)
{
int updatedRows = 0;
var cellValue = string.Empty;
var collumnIndex = string.Empty;
var rowIndex = row.RowIndex.ToString();
try
{
var currentMembershipData = new MembershipData();
currentMembershipData.CloneExcelColumnIndexInAllProperties(inputDataList.FirstOrDefault());
// First collecting current old data for each cell for update
// into currentMembershipData to verify new and old values next
foreach (var cell in row.Descendants <Cell>())
{
cellValue = collumnIndex = string.Empty;
GetCellValueAndColumn(sharedStrings, row, cell, out cellValue, out collumnIndex);
// Update Excel Values for each inputData record
currentMembershipData.UpdateExcelCellOldValueInAllProperties(collumnIndex, cellValue);
}
;
// Next copy all CSV New values from inputData list that match the same email
inputDataList.ForEach(m =>
{
if (m.Email.CsvNewValue.Equals(currentMembershipData.Email.ExcelCellOldValue, StringComparison.InvariantCultureIgnoreCase))
{
currentMembershipData.CloneCsvNewValueInAllProperties(m);
}
});
// If no new value in email, nothing to update
if (string.IsNullOrEmpty(currentMembershipData.Email.CsvNewValue))
{
return(updatedRows);
}
// Update Exists property for the current record
inputDataList.Where(m => m.Email.CsvNewValue.Equals(currentMembershipData.Email.CsvNewValue, StringComparison.InvariantCultureIgnoreCase))
.SingleOrDefault().ExistsInExcelFile = true;
// Finally verify if we need to update that record
if (currentMembershipData.ContainsAnyNotMatchingOldAndNewValues())
{
if (TryUpdateRow(sharedStrings, row, currentMembershipData))
{
updatedRows++;
}
}
}
catch (Exception ex)
{
Console.WriteLine($"\nException detected during updating cell value '{cellValue}' " +
$"of column Index '{collumnIndex}' and row Index '{rowIndex}'. {ex}");
throw;
}
return(updatedRows);
}
private void onMembershipChanged(MembershipData membershipData)
{
if (dataEntityCollection.TryGetComponent(dataEntityCollection.LocalPlayerHandle, out RememberMeData component))
{
component.MembershipChanged(membershipData.IsMember, membershipData.MembershipType);
}
}
private void onMembershipDataChanged(MembershipData obj)
{
if (isMember != obj.IsMember)
{
isMember = obj.IsMember;
membershipSet(isMember);
}
}
private void onMembershipDataUpdated(MembershipData membershipData)
{
if (!base.gameObject.IsDestroyed() && membershipData.IsMember)
{
Service.Get <TrayNotificationManager>().DismissAllNotifications();
showMemberStatusIndicator();
}
}
private void onMembershipDataUpdated(MembershipData updatedMembershipData)
{
IsPlayerAMember = updatedMembershipData.IsMember;
IsLocked = !updatedMembershipData.IsMember;
if (!updatedMembershipData.IsMember && MemberLock == null)
{
Content.LoadAsync(onMemberLockLoaded, MemberLockContentKey);
}
}
private void onMembershipDataUpdated(MembershipData membershipData)
{
DataEntityHandle entityByComponent = dataEntityCollection.GetEntityByComponent(membershipData);
if (entityByComponent == ownerHandle)
{
ownerDisplay.SetMembershipType(getMembershipType(entityByComponent));
}
}
public async Task <MembershipData> FindMembershipByStickyIdAsync(long stickyId)
{
var membershipData = new MembershipData
{
StickyUserId = stickyId
};
var redisDb = _redisCache.GetDatabase(RedisDatabases.UserSegmentsZero);
//var redisData = await redisDb.StringGetAsync(stickyId.ToString());
var redisDruidData = await redisDb.StringGetAsync("Full_General:" + stickyId.ToString());
var redisRequestDb = _redisCache.GetDatabase(RedisDatabases.UserSegmentsRequest);
//Adding General Segment Membership
if (redisDruidData.HasValue)
{
membershipData.Segments.AddRange(Newtonsoft.Json.JsonConvert.DeserializeObject <List <UserSegment> >(redisDruidData));
}
else
{
await redisRequestDb.ListLeftPushAsync($"Empty_General", stickyId);
}
//Adding Special Segment Membership
var excludedSegments = await _redisCache.GetDatabase(RedisDatabases.CacheData).StringGetAsync("ExcludedSegments");
if (excludedSegments.HasValue)
{
var excludedIds = excludedSegments.ToString().Split(',');
foreach (var exid in excludedIds)
{
var specialSegmentData = await redisDb.StringGetAsync($"Full_{exid}:" + stickyId.ToString());
if (specialSegmentData.HasValue)
{
membershipData.Segments.AddRange(Newtonsoft.Json.JsonConvert.DeserializeObject <List <UserSegment> >(specialSegmentData));
}
else
{
await redisRequestDb.ListLeftPushAsync($"Empty_{exid}", stickyId);
}
}
}
//Adding Special Segment Membership
var redisCategoryData = await redisDb.StringGetAsync("Full_Category:" + stickyId.ToString());
if (redisCategoryData.HasValue)
{
membershipData.Segments.AddRange(Newtonsoft.Json.JsonConvert.DeserializeObject <List <UserSegment> >(redisCategoryData));
}
else
{
await redisRequestDb.ListLeftPushAsync($"Empty_Category", stickyId);
}
return(membershipData);
}
private bool onMembershipDataAdded(DataEntityEvents.ComponentAddedEvent <MembershipData> evt)
{
if (evt.Handle == Handle)
{
membershipData = evt.Component;
membershipData.MembershipDataUpdated += onMembershipDataUpdated;
setUpMembershipData(membershipData);
}
return(false);
}
private void onMembershipDataUpdated(MembershipData membershipData)
{
DataEntityHandle entityByComponent = dataEntityCollection.GetEntityByComponent(membershipData);
int incomingInvitationIndex = getIncomingInvitationIndex(entityByComponent);
if (incomingInvitationIndex >= 0 && incomingInvitationIndex < 4 && friendRequestItems != null && friendRequestItems[incomingInvitationIndex] != null)
{
friendRequestItems[incomingInvitationIndex].SetMembershipType(getMembershipType(entityByComponent));
}
}
public void ContainsNotMatchingOldAndNewValues_WithoutExcelOldValues_Success_Test()
{
var testRecord = new MembershipData();
testRecord.FirstName.CsvNewValue = "testFirstName";
testRecord.LastName.CsvNewValue = "testLastName";
testRecord.Email.CsvNewValue = "testEmail";
Assert.IsTrue(testRecord.ContainsAnyNotMatchingOldAndNewValues());
}
protected virtual void onMembershipDataUpdated(MembershipData membershipData)
{
DataEntityHandle entityByComponent = dataEntityCollection.GetEntityByComponent(membershipData);
int poolIndexFromHandle = getPoolIndexFromHandle(entityByComponent);
if (poolIndexFromHandle >= 0 && pooledScrollRect.IsIndexCellVisible(poolIndexFromHandle))
{
AbstractPlayerListItem component = pooledScrollRect.GetCellAtIndex(poolIndexFromHandle).GetComponent <AbstractPlayerListItem>();
component.SetMembershipType(getMembershipType(entityByComponent));
}
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
MemberList = MembershipData.GetMemberships();
ShowCommand = new RelayCommand(ShowMethod);
ShowUpdateWinCommand = new RelayCommand(ShowUpdateWindow);
ExitWindowCommand = new RelayCommand <IClosable>(ExitWindow);
Messenger.Default.Register <Member>(this, "add", SaveMember);
Messenger.Default.Register <Member>(this, "edit", UpdateMember);
Messenger.Default.Register <Member>(this, "delete", DeleteMember);
}
public MainViewModel()
{
database = new MembershipData();
Messenger.Default.Register <MessageMember>(this, ReceiveMember);
AddCommand = new RelayCommand(AddMethod);
UpdateCommand = new RelayCommand(UpdateMethod);
DeleteCommand = new RelayCommand(DeleteMethod);
ExitCommand = new RelayCommand(ExitMethod);
members = new MembershipList();
members.Write();
}
public void SetAgentActiveGroupRole(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
{
MembershipData data = m_Database.RetrieveMember(GroupID, AgentID);
if (data == null)
{
return;
}
data.Data["SelectedRoleID"] = RoleID.ToString();
m_Database.StoreMember(data);
}
protected override void OnDestroy()
{
base.OnDestroy();
CoroutineRunner.StopAllForOwner(this);
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
MembershipData component = default(MembershipData);
if (cPDataEntityCollection != null && cPDataEntityCollection.TryGetComponent(cPDataEntityCollection.LocalPlayerHandle, out component))
{
component.MembershipDataUpdated -= onMembershipDataUpdated;
}
}
public bool RemoveAgentFromGroupRole(string RequestingAgentID, string AgentID, UUID GroupID, UUID RoleID)
{
// Don't remove from Everyone role!
if (RoleID == UUID.Zero)
{
return(false);
}
// check permissions
bool unlimited = HasPower(RequestingAgentID, GroupID, GroupPowers.AssignMember) || IsOwner(RequestingAgentID, GroupID);
if (!unlimited)
{
m_log.DebugFormat("[Groups]: ({0}) Attempt at removing {1} from role {2} denied because of lack of permission", RequestingAgentID, AgentID, RoleID);
return(false);
}
RoleMembershipData rolemember = m_Database.RetrieveRoleMember(GroupID, RoleID, AgentID);
if (rolemember == null)
{
return(false);
}
m_Database.DeleteRoleMember(rolemember);
// Find another role for this person
UUID newRoleID = UUID.Zero; // Everyone
RoleMembershipData[] rdata = m_Database.RetrieveMemberRoles(GroupID, AgentID);
if (rdata != null)
{
foreach (RoleMembershipData r in rdata)
{
if (r.RoleID != UUID.Zero)
{
newRoleID = r.RoleID;
break;
}
}
}
MembershipData member = m_Database.RetrieveMember(GroupID, AgentID);
if (member != null)
{
member.Data["SelectedRoleID"] = newRoleID.ToString();
m_Database.StoreMember(member);
}
return(true);
}
private void Start()
{
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
participationData = cPDataEntityCollection.GetComponent <ParticipationData>(cPDataEntityCollection.LocalPlayerHandle);
membershipData = cPDataEntityCollection.GetComponent <MembershipData>(cPDataEntityCollection.LocalPlayerHandle);
gameObjectReferenceData = cPDataEntityCollection.GetComponent <GameObjectReferenceData>(cPDataEntityCollection.LocalPlayerHandle);
type = InteractInWorldIconType.UICanvas;
type = ((tweakableType != 0) ? tweakableType : type);
setState(type);
propService = Service.Get <PropService>();
indicatorRequest = Content.LoadAsync(onInteractIndicatorLoaded, InteractIndicatorContentKey);
}
private void onMembershipDataUpdated(MembershipData updatedMembershipData)
{
if (updatedMembershipData.IsMember)
{
if (gameStateController.IsAccountSystenActive)
{
gameStateController.OnAccountAccountSystemDeacitvated += onAccountAccountSystemDeacitvated;
}
else
{
showAllAccessCelebration();
}
}
}
private void onMembershipDataUpdated(MembershipData membershipData)
{
if (membershipData.IsMember && !isMember)
{
isMember = true;
int count = marketplaceItems.Count;
for (int i = 0; i < count; i++)
{
MarketplaceItem marketplaceItem = marketplaceItems[i].MarketplaceItem;
marketplaceItem.checkLockedState();
marketplaceItem.UpdateVisualStates();
}
}
}
private void Start()
{
membershipController = GetComponentInParent <MembershipController>();
membershipController.OnPurchaseRetried += onPurchaseRetried;
backgroundButtons = GetComponentInParent <BackgroundButtonsController>();
showCarrierBilling = membershipController.IsCarrierBillingAvailable();
string message = showCarrierBilling ? "with_carrier_billing_info" : "regular";
Service.Get <ICPSwrveService>().Funnel(Service.Get <MembershipService>().MembershipFunnelName, "03", "membership_terms", message);
PenguinName.text = Service.Get <SessionManager>().LocalUser.RegistrationProfile.DisplayName;
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
DataEntityHandle localPlayerHandle = cPDataEntityCollection.LocalPlayerHandle;
if (!(SceneManager.GetActiveScene().name == "Boot"))
{
avatarRenderer = GetComponentInChildren <AvatarRenderTextureComponent>();
AvatarAnimationFrame avatarFrame = new AvatarAnimationFrame("Base Layer.Interactions.PassPortPoses_CelebrateAnimation", 0f);
if (cPDataEntityCollection.TryGetComponent(localPlayerHandle, out AvatarDetailsData component))
{
avatarRenderer.RenderAvatar(component, avatarFrame);
}
else
{
avatarRenderer.RenderAvatar(new DCustomEquipment[0], avatarFrame);
}
}
bool hasTrialAvailable = true;
MembershipData component3 = default(MembershipData);
if (cPDataEntityCollection.TryGetComponent(localPlayerHandle, out ProfileData component2) && cPDataEntityCollection.TryGetComponent(localPlayerHandle, out component3))
{
if (component2.IsFirstTimePlayer || SceneManager.GetActiveScene().name != Service.Get <GameStateController>().SceneConfig.HomeSceneName)
{
ChangePenguinContainer.SetActive(value: false);
}
else
{
ChangePenguinContainer.SetActive(value: true);
}
hasTrialAvailable = component3.MembershipTrialAvailable;
}
membershipController.OnProductsReady += onProductsReady;
membershipController.GetProduct(hasTrialAvailable);
if (MonoSingleton <NativeAccessibilityManager> .Instance.AccessibilityLevel == NativeAccessibilityLevel.VOICE)
{
string tokenTranslation = Service.Get <Localizer>().GetTokenTranslation("Accessibility.Popup.Title.MembershipTerms");
MonoSingleton <NativeAccessibilityManager> .Instance.Native.Speak(tokenTranslation);
}
}
private void SaveMember(Member objMember)
{
//Do validation
if (!Validator.IsPresent("First Name", objMember.FirstName) ||
!Validator.IsPresent("Last Name", objMember.LastName) ||
!Validator.IsPresent("Email", objMember.Email) ||
!Validator.IsValidEmail("Email", objMember.Email))
{
return;
}
MemberList.Add(objMember);
MembershipData.SaveMemberships(MemberList);
Messenger.Default.Send(new NotificationMessage(objMember.DisplayText + " is added successfully."));
CloseWindow(objMembershipAdd);
}
private static void updateMembershipDataValues(bool isAllAccessActive)
{
CPDataEntityCollection cPDataEntityCollection = Service.Get <CPDataEntityCollection>();
DataEntityHandle[] entitiesByType = cPDataEntityCollection.GetEntitiesByType <MembershipData>();
for (int i = 0; i < entitiesByType.Length; i++)
{
MembershipData component = cPDataEntityCollection.GetComponent <MembershipData>(entitiesByType[i]);
if (component.MembershipType != MembershipType.Member)
{
component.IsMember = isAllAccessActive;
component.MembershipType = (isAllAccessActive ? MembershipType.AllAccessEventMember : MembershipType.None);
}
}
}
public MembershipData AddMembership(string accountName, MembershipData membershipInfo, string group, Privacy privacy) {
object[] results = this.Invoke("AddMembership", new object[] {
accountName,
membershipInfo,
group,
privacy});
return ((MembershipData)(results[0]));
}
/// <remarks/>
public void CreateMemberGroupAsync(MembershipData membershipInfo) {
this.CreateMemberGroupAsync(membershipInfo, null);
}
/// <remarks/>
public void AddMembershipAsync(string accountName, MembershipData membershipInfo, string group, Privacy privacy, object userState) {
if ((this.AddMembershipOperationCompleted == null)) {
this.AddMembershipOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddMembershipOperationCompleted);
}
this.InvokeAsync("AddMembership", new object[] {
accountName,
membershipInfo,
group,
privacy}, this.AddMembershipOperationCompleted, userState);
}
/// <remarks/>
public System.IAsyncResult BeginAddMembership(string accountName, MembershipData membershipInfo, string group, Privacy privacy, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("AddMembership", new object[] {
accountName,
membershipInfo,
group,
privacy}, callback, asyncState);
}
public void CreateMemberGroup(MembershipData membershipInfo) {
this.Invoke("CreateMemberGroup", new object[] {
membershipInfo});
}
/// <remarks/>
public System.IAsyncResult BeginCreateMemberGroup(MembershipData membershipInfo, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("CreateMemberGroup", new object[] {
membershipInfo}, callback, asyncState);
}
/// <remarks/>
public void AddMembershipAsync(string accountName, MembershipData membershipInfo, string group, Privacy privacy) {
this.AddMembershipAsync(accountName, membershipInfo, group, privacy, null);
}
/// <remarks/>
public void CreateMemberGroupAsync(MembershipData membershipInfo, object userState) {
if ((this.CreateMemberGroupOperationCompleted == null)) {
this.CreateMemberGroupOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCreateMemberGroupOperationCompleted);
}
this.InvokeAsync("CreateMemberGroup", new object[] {
membershipInfo}, this.CreateMemberGroupOperationCompleted, userState);
}
