public void AddMember(SDMemberBase sdMember)
{
if (!Members.ContainsKey(sdMember.Identifier))
{
Members.Add(sdMember.Identifier, sdMember);
}
}
private static void ProcessChannelCreateFrame(ChannelCreateFrame channelCreateFrame)
{
var frameData = channelCreateFrame.data;
if (frameData.type == "lobby" &&
frameData.liveChannelId.IsNullOrEmpty() &&
frameData.workspaceId == DefaultWorkspaceId
)
{
Channels[frameData.id] = frameData;
ReadStates[frameData.id] = new ReadState
{
lastMessageId = frameData.lastMessageId,
mentionCount = 0,
};
if (frameData.lastMessage != null)
{
Users[frameData.lastMessage.author.id] = frameData.lastMessage.author;
}
if (!Members.ContainsKey(frameData.id))
{
Members[frameData.id] = new List <ChannelMember>();
}
if (!frameData.groupId.IsNullOrEmpty())
{
Groups[frameData.groupId] = frameData.groupMap[frameData.groupId];
}
}
}
internal override SObject ExecuteMethod(ScriptProcessor processor, string methodName, SObject caller, SObject This, SObject[] parameters)
{
if (Members.ContainsKey(methodName))
{
if (Members[methodName].Data.TypeOf() == LITERAL_TYPE_FUNCTION)
{
return(((SFunction)Members[methodName].Data).Call(processor, caller, this, parameters));
}
else
{
return(processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MESSAGE_TYPE_NOT_A_FUNCTION, methodName));
}
}
else if (Prototype != null && Prototype.HasMember(processor, methodName))
{
return(Prototype.ExecuteMethod(processor, methodName, caller, This, parameters));
}
else if (SuperClass != null)
{
return(SuperClass.ExecuteMethod(processor, methodName, caller, This, parameters));
}
else
{
return(processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MESSAGE_TYPE_NOT_A_FUNCTION, methodName));
}
}
//
// SuperMemo natives
public int AddMember(string textOrPath)
{
try
{
_waitForMemberEvent.Reset();
int ret = Core.Natives.Registry.AddMember.Invoke(
RegistryPtr,
new DelphiUTF16String(textOrPath));
if (ret > 0)
{
_waitForMemberId = ret;
if (Members.ContainsKey(ret) == false)
{
_waitForMemberEvent.Wait(AssemblyFactory.ExecutionTimeout);
}
}
return(ret);
}
catch (Exception ex)
{
LogTo.Error(ex,
"SM internal method call threw an exception.");
return(-1);
}
finally
{
_waitForMemberId = -1;
}
}
String BuildNewCalculatedMemberName(String defaultName)
{
String name = defaultName;
if (String.IsNullOrEmpty(name))
{
name = "[Calculated Member]";
}
int i = 1;
String start_name = name;
while (Members.ContainsKey(name))
{
// Начинаем формировать имя заново
name = start_name;
bool add_bracket = false;
if (name.EndsWith("]"))
{
name = name.Substring(0, name.Length - 1);
add_bracket = true;
}
name += " " + i.ToString();
i++;
if (add_bracket)
{
name += "]";
}
}
return(name);
}
internal override SObject GetMember(ScriptProcessor processor, SObject accessor, bool isIndexer)
{
if (isIndexer && accessor.TypeOf() == LiteralTypeNumber)
{
if (Prototype.GetIndexerGetFunction() != IndexerGetFunction)
{
IndexerGetFunction = Prototype.GetIndexerGetFunction();
}
return(IndexerGetFunction != null?IndexerGetFunction.Call(processor, this, this, new[] { accessor }) : processor.Undefined);
}
var accessorAsString = accessor as SString;
var memberName = accessorAsString != null ? accessorAsString.Value : accessor.ToString(processor).Value;
if (Members.ContainsKey(PropertyGetPrefix + memberName)) // getter property
{
return(((SFunction)Members[PropertyGetPrefix + memberName].Data).Call(processor, this, this, new SObject[] { }));
}
if (Members.ContainsKey(memberName))
{
return(Members[memberName]);
}
if (Prototype != null && Prototype.HasMember(processor, memberName))
{
return(Prototype.GetMember(processor, accessor, isIndexer));
}
if (SuperClass != null)
{
return(SuperClass.GetMember(processor, accessor, isIndexer));
}
return(processor.Undefined);
}
public void SetPlayerHomeRegion(int plyr, int region)
{
if (Members.ContainsKey(plyr))
{
Members[plyr].homeRegion = region;
}
}
public void AddMember(SDMember sdMember)
{
if (!Members.ContainsKey(sdMember.Identifier))
{
sdMember.ShortIdentifier = sdMember.Name;
Members.Add(sdMember.Identifier, sdMember);
}
}
public bool IsMember(uint memberid)
{
if (TeamUID == memberid)
{
return(true);
}
return(Members.ContainsKey(memberid));
}
/// <summary>
/// Remove a member from this <see cref="Team"/>.
/// </summary>
/// <param name="memberType">The type of the member.</param>
/// <param name="member">The member to add.</param>
public void RemoveMember(Type memberType, Member member)
{
if (!Members.ContainsKey(memberType))
{
return;
}
Members[memberType].Remove(member);
}
public void RemoveMember(MemberInfo member)
{
if (Members.ContainsKey(member))
{
Members.Remove(member);
OrdinalArguments.Remove(member);
}
}
internal bool RemoveMember(ID key)
{
if (Members.ContainsKey(key))
{
Members.Remove(key);
}
return(false);
}
internal void AddMembers(IEnumerable <KeyValuePair <string, IMember> > members, bool overwrite)
{
lock (_lock) {
foreach (var kv in members.Where(m => overwrite || !Members.ContainsKey(m.Key)))
{
WritableMembers[kv.Key] = kv.Value;
}
}
}
public override bool OwnExist(string name)
{
int index;
if (int.TryParse(name, out index) && index < Value.Count)
{
return(true);
}
return(Members.ContainsKey(name));
}
internal IMember AddMember(string name, IMember member, bool overwrite)
{
lock (_lock) {
if (overwrite || !Members.ContainsKey(name))
{
WritableMembers[name] = member;
}
return(member);
}
}
internal void AddMember(DiscordMember member)
{
if (member == null)
return;
if(Members.ContainsKey(member.ID)) //then replace
{
Members.Remove(member.ID);
}
Members.Add(member.ID, member);
}
private void Add(Type type, string key, object value, dynamic parent = null)
{
if (Members.ContainsKey(key))
{
throw new ArgumentException($"{key} is already exists.");
}
var metadata = new DynamicObjectMetadata(type, key, value, parent);
Members.Add(key, metadata);
}
public async Task XpLeaderboardAsync(int page = 1)
{
page--;
if (page < 0)
{
page = 0;
}
var membersXp = (await DbContext.GetOrderedListAsync <MembersEntity, int>(x => x.GuildId == Context.Guild !.Id, y => y.Xp, true))
.Where(x => Context.Guild !.Members.ContainsKey(x.MemberId))
.ToList();
var xpLeaderboard = membersXp.Skip(page * 15)
.Take(15)
.ToList();
if (xpLeaderboard.Count == 0)
{
await ReplyErrorAsync(Localization.XpGuildLeaderboardEmpty);
return;
}
var description = new StringBuilder();
var index = page * 15;
foreach (var userDb in xpLeaderboard)
{
try
{
var member = await Context.Guild !.GetMemberAsync(userDb.MemberId);
description.Append($"{++index}. **{member.FullName()}**: " +
$"`{GetText(Localization.XpLevelX, RiasUtilities.XpToLevel(userDb.Xp, XpService.XpThreshold))} " +
$"({userDb.Xp} {GetText(Localization.XpXp).ToLowerInvariant()})`\n");
}
catch
{
// ignored
}
}
var embed = new DiscordEmbedBuilder
{
Color = RiasUtilities.ConfirmColor,
Title = GetText(Localization.XpGuildLeaderboard),
Description = description.ToString(),
Footer = new DiscordEmbedBuilder.EmbedFooter
{
IconUrl = Context.User.GetAvatarUrl(ImageFormat.Auto),
Text = $"{Context.User.FullName()} • #{membersXp.FindIndex(x => x.MemberId == Context.User.Id) + 1}"
}
};
await ReplyAsync(embed);
}
/// <summary>
/// Gets a value indicating whether a symbol with
/// the specified name exists as a first-level child.
/// </summary>
/// <param name="identifier">
/// The name of the symbol to check for.
/// </param>
/// <returns>
/// <code>True</code> if the entry exists,
/// <code>False</code> otherwise.
/// </returns>
public bool Contains(string identifier)
{
if (IsCollection)
{
// All elements have the same set of symbols, albeit with different addresses,
// so checking element 0 is sufficient
return(CollectionElements[0].Contains(identifier));
}
return(Members.ContainsKey(identifier));
}
/// <summary>Shows the documentation of a given node (where possible).</summary>
void TreeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (Members.ContainsKey(e.Node))
{
var minfo = Members[e.Node];
ShownDocumentation FieldDoc = OpenDocumentation(minfo);
var tp = GetType(minfo);
ShownDocumentation TypDoc = OpenDocumentation(tp);
richTextBox1.Text = "Field: " + minfo.Name + "\n" + GetText(FieldDoc) + "\n--------\nType: " + tp.FullName + "\n" + GetText(TypDoc) + "\n";
}
}
private byte GetNextSlot()
{
for (byte i = 0; i < 6; i++)
{
if (!Members.ContainsKey(i))
{
return(i);
}
}
return(255);
}
/// <summary>
/// Adds a member to the lobby
/// </summary>
/// <param name="member"></param>
/// <returns></returns>
public bool AddMember(LobbyMember member)
{
if (Members.ContainsKey(member.Username))
{
return(false);
}
Members.Add(member.Username, member);
member.Team = this;
return(true);
}
IDeepCloneTypeOptions IDeepCloneTypeOptions.ForMember(string memberName, Action <IDeepCloneMemberOptions> action)
{
if (!Members.ContainsKey(memberName))
{
Members.Add(memberName, new DeepCloneMemberOptions
{
MemberName = memberName
});
}
action(Members[memberName]);
return(this);
}
protected virtual void OnMemberAddedOrUpdated(TMember member)
{
if (Members.ContainsKey(member.Id) == false)
{
Members[member.Id] = member;
}
if (member.Id == _waitForMemberId)
{
_waitForMemberEvent.Set();
}
}
// Public Methods (3)
public Variable getMember(string name)
{
if (Members.ContainsKey(name))
{
return(Members[name]);
}
if (Base != null)
{
return(Base.getMember(name));
}
return(null);
}
internal void AddMembers(IEnumerable <IVariable> variables, bool overwrite)
{
lock (_lock) {
if (!_readonly)
{
foreach (var v in variables.Where(m => overwrite || !Members.ContainsKey(m.Name)))
{
WritableMembers[v.Name] = v.Value;
}
}
}
}
public DiscordMember GetMemberByKey(ID key)
{
if (Unavailable)
{
throw new Exception("Server is currently unavailable!");
}
if (Members.ContainsKey(key))
{
return(Members[key]);
}
return(null);
}
/// <summary>
/// Adds a member to this <see cref="Team"/>.
/// </summary>
/// <param name="memberType">The type of the member.</param>
/// <param name="member">The member to add.</param>
public void AddMember(Type memberType, Member member)
{
if (memberType.BaseType != typeof(Member))
{
return;
}
if (!Members.ContainsKey(memberType))
{
Members[memberType] = new ObservableCollection <Member>();
}
Members[memberType].Add(member);
}
private bool IsInvitedMember(string userid)
{
if (Members.ContainsKey(userid))
{
MemberModel member;
Members.TryGetValue(userid, out member);
if (member != null && member.Status == MemberModel.Statuses.Invited)
{
return(true);
}
}
return(false);
}
internal void AddMembers(IEnumerable <IVariable> variables, bool overwrite)
{
lock (_lock) {
if (!_readonly)
{
foreach (var v in variables.Where(m => overwrite || !Members.ContainsKey(m.Name)))
{
// If variable holds function or a class, use value as member.
// If it holds an instance, use the variable itself (i.e. it is a data member).
WritableMembers[v.Name] = v.Value;
}
}
}
}
