public void ReadXml(XmlReader xmlReader)
{
Name = xmlReader.GetAttribute("name");
Namespace = xmlReader.GetAttribute("namespace");
Kind = (TypeKind)Enum.Parse(typeof(TypeKind), xmlReader.GetAttribute("kind"));
Obsolete = string.Equals(xmlReader.GetAttribute("obsolete"), "true", StringComparison.OrdinalIgnoreCase);
ObsoleteMessage = xmlReader.GetAttribute("obsoleteMessage");
if (!xmlReader.IsEmptyElement)
{
var childReader = xmlReader.ReadSubtree();
while (childReader.Read())
{
if (childReader.NodeType == XmlNodeType.Element)
{
if (childReader.Name == "change")
{
var typeChangeInfo = new TypeChangeInfo();
typeChangeInfo.ReadXml(xmlReader);
Changes.Add(typeChangeInfo);
}
else if (childReader.Name == "member")
{
var member = new MemberInfo();
member.ReadXml(xmlReader);
Members.Add(member);
}
}
}
}
}
/// <summary>
/// Expands the distribution list into a set of user emails.
/// </summary>
private void TryExpandDistributionList(EmailAddress address)
{
if (Members == null)
{
Members = new ObservableCollection <string>();
}
if (address.MailboxType == MailboxType.PublicGroup)
{
var groupResults = Service.ExpandGroup(address);
foreach (var email in groupResults)
{
LoggingViewModel.Instance.Logger.Write(string.Concat("TryExpanDistributionList ", email));
TryExpandDistributionList(email);
}
}
else
{
if (!Members.Contains(address.Address))
{
Members.Add(address.Address);
}
}
}
public void AddMember(Guid userId, Guid createUserId)
{
if (Members.FirstOrDefault(m => m.UserId == userId) == null)
{
Members.Add(new RoleUser(Id, userId, createUserId));
}
}
public void saveNewMemberToStorage(MemberModel member)
{
updateMemberID();
member.ID = _memberID;
Members.Add(member);
saveToFile(Members);
}
public void AddMember(Mobile mob)
{
Members.Add(new PlayerState(mob, this, Members));
Item item = mob.FindItemOnLayer(Layer.OuterTorso) as Item;
if (item != null)
{
if (item.Movable == false)
{
mob.AddToBackpack(FactionItem.Imbue(new Robe(), this, false, Definition.HuePrimary));
mob.SendAsciiMessage("You have been granted a robe which signifies your faction.");
}
if (item.Movable == true)
{
mob.AddToBackpack(item);
mob.EquipItem(FactionItem.Imbue(new Robe(), this, false, Definition.HuePrimary));
mob.SendAsciiMessage("You have been granted a robe which signifies your faction.");
}
}
else
{
mob.EquipItem(FactionItem.Imbue(new Robe(), this, false, Definition.HuePrimary));
mob.SendAsciiMessage("You have been granted a robe which signifies your faction.");
}
mob.InvalidateProperties();
mob.Delta(MobileDelta.Noto);
}
public void Add(Mobile m)
{
var mi = this[m];
if (mi != null)
{
return;
}
var ns = m.NetState;
Members.Add(new PartyMemberInfo(m));
m.Party = this;
Span <byte> memberList =
stackalloc byte[PartyPackets.GetPartyMemberListPacketLength(this)].InitializePacket();
Span <byte> attrsPacket = stackalloc byte[OutgoingMobilePackets.MobileAttributesPacketLength].InitializePacket();
for (var i = 0; i < Members.Count; ++i)
{
var f = Members[i].Mobile;
PartyPackets.CreatePartyMemberList(memberList, this);
f.NetState?.Send(memberList);
if (f != m)
{
f.NetState.SendMobileStatusCompact(m, m.CanBeRenamedBy(f));
OutgoingMobilePackets.CreateMobileAttributes(attrsPacket, m, true);
f.NetState?.Send(attrsPacket);
ns.SendMobileStatusCompact(f, f.CanBeRenamedBy(m));
ns.SendMobileAttributes(f, true);
}
}
}
public void AddMembers(List <Member> members)
{
foreach (var item in members)
{
Members.Add(item);
}
}
/// <summary>
/// Method For reteriving Data from File
/// </summary>
/// <returns></returns>
public ObservableCollection <Member> GetMembership()
{
string row = "";
string[] columns;
try
{
if (File.Exists(@"file.txt"))
{
StreamReader input = new StreamReader(new FileStream(@"file.txt", FileMode.OpenOrCreate, FileAccess.Read), false);
while (input.Peek() != -1)
{
row = input.ReadLine();
columns = row.Split('-');
Member m = new Member(columns[0], columns[1], columns[2]);
Members.Add(m);
}
input.Close();
}
}
catch (FileNotFoundException)
{
Console.WriteLine("File not found");
}
catch (FormatException)
{
Console.WriteLine("Invalid e-mail address format");
}
return(MemberIndexer.members);
}
public EmployeeTalentMap(Concrete.DataRepository repo)
: base(repo, x => x.EmployeeTalents)
{
Members.Add(x => x.Employee)
.WithColumn(x => x.EmployeeId, col =>
{
col.OnWriteRecord(obj => { return(obj.Employee == null ? null : obj.Employee.Id); });
})
.OnComplete((rec, obj) =>
{
obj.Employee = Repository.FindNow <Employee>(x => x.Id == rec["EmployeeId"]);
})
.SetDependencyMode(MemberDependencyMode.Parent);
Members.Add(x => x.Talent)
.WithColumn(x => x.TalentId, col =>
{
col.OnWriteRecord(obj => { return(obj.Talent == null ? null : obj.Talent.Id); });
})
.OnComplete((rec, obj) =>
{
obj.Talent = Repository.FindNow <Talent>(x => x.Id == rec["TalentId"]);
})
.SetDependencyMode(MemberDependencyMode.Parent);
VersionColumn.SetName(x => x.RowVersion);
}
private async Task <TimeSpan> LoadFromExternalDatabase()
{
var table = await _externalDb.FetchAllMembers(Settings.UserName);
_logger.LogInfo("Found " + table.Count + " members in databse");
foreach (var member in table)
{
Members.Add(member.ProfileId, member);
switch (member.Status)
{
case IEMember.MEMBER_NEW:
NewItems.Add(member);
break;
case IEMember.MEMBER_REJECTED:
RejectedItems.Add(member);
break;
default:
ActiveItems.Add(member);
break;
}
}
NewItems.Sort();
RejectedItems.Sort();
ActiveItems.Sort();
TimeScheduler.GetTimeScheduler().AddTask(DS_TASK_NAME, TimeSpan.FromSeconds(INITIAL_DELAY), () => OnTimedEvent());
return(TimeScheduler.STOP_TIMER); // This stops us being re-scheduled
}
private void Load()
{
DataTable AcademyData = null;
DataTable MemberData = null;
using (var DBClient = Program.DatabaseManager.GetClient())
{
AcademyData = DBClient.ReadDataTable("SELECT * FROM GuildAcademy WHERE GuildID = " + Guild.ID + "");
MemberData =
DBClient.ReadDataTable("SELECT * FROM GuildAcademyMembers WHERE GuildID = " + Guild.ID + "");
}
foreach (DataRow row in AcademyData.Rows)
{
//load academy info
Message = row["Message"].ToString();
Points = GetDataTypes.GetUshort(row["Points"]);
}
//members
foreach (DataRow MemberRow in MemberData.Rows)
{
WorldCharacter character;
if (!CharacterManager.Instance.GetCharacterByID(Convert.ToInt32(MemberRow["CharID"]), out character))
{
continue; // maybe deleted
}
var member = new GuildAcademyMember(this, character, MemberRow);
Members.Add(member);
}
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Members.Clear();
var items = await DataStore.GetItemsAsync(true);
foreach (var item in items)
{
Members.Add(new RosterMemberViewModel(item));
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
void ForEnumPopulateMembers <TEnum>(string[] names, TEnum[] values)
where TEnum : struct, IComparable, IFormattable, IConvertible
{
int index = 0;
int length = names.Length;
#region Handle None values
int last_value = Reflection.EnumUtil <TEnum> .GetHashCodeSignExtended(values[length - 1]);
Contract.Assert(last_value.IsNoneOrPositive());
// Enum.GetNames() sorts values by ToUInt64'ing, meaning negative values will appear after positive ones
if (last_value.IsNone())
{
length--;
Members.Add(names[length]);
NameToIndex.Add(names[length], index);
}
#endregion
for (; index < length; index++)
{
Members.Add(names[index]);
NameToIndex.Add(names[index], index);
}
}
public void Add(Mobile m)
{
PartyMemberInfo mi = this[m];
if (mi == null)
{
Members.Add(new PartyMemberInfo(m));
m.Party = this;
Packet memberList = Packet.Acquire(new PartyMemberList(this));
Packet attrs = Packet.Acquire(new MobileAttributesN(m));
for (int i = 0; i < Members.Count; ++i)
{
Mobile f = Members[i].Mobile;
f.Send(memberList);
if (f != m)
{
f.Send(new MobileStatusCompact(m.CanBeRenamedBy(f), m));
f.Send(attrs);
m.Send(new MobileStatusCompact(f.CanBeRenamedBy(m), f));
m.Send(new MobileAttributesN(f));
}
}
Packet.Release(memberList);
Packet.Release(attrs);
}
}
public void AddMember(Mobile m)
{
if (!Members.Contains(m))
{
if (m.Guild != null && m.Guild != this)
{
((Guild)m.Guild).RemoveMember(m);
}
Members.Add(m);
m.Guild = this;
EventSink.InvokeJoinGuild(new JoinGuildEventArgs(m, this));
m.GuildFealty = null;
if (m is PlayerMobile)
{
((PlayerMobile)m).GuildRank = RankDefinition.Lowest;
}
Guild guild = m.Guild as Guild;
if (guild != null)
{
guild.InvalidateWarNotoriety();
}
}
}
/// <summary>
/// Tries to add the specified player to the party.
/// </summary>
/// <param name="player"></param>
/// <returns></returns>
public bool AddMember(IPlayerEntity player, bool isPartyLeader = false)
{
if (player.Party.IsInParty)
{
return(false);
}
if (Members.Contains(player))
{
return(false);
}
if (Members.Count == Members.Capacity)
{
return(false);
}
Members.Add(player);
if (isPartyLeader)
{
PartyLeaderId = player.PlayerData.Id;
}
player.Party.Party = this;
return(true);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="node">対象Node</param>
/// <param name="semanticModel">対象ソースのsemanticModel</param>
/// <param name="parent">親IAnalyzeItem</param>
/// <param name="container">イベントコンテナ</param>
public ItemForEach(ForEachStatementSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container)
{
ItemType = ItemTypes.MethodStatement;
var oparetion = semanticModel.GetOperation(node) as IForEachLoopOperation;
var localSymbol = oparetion.Locals.First();
// ローカルの型設定
IsVar = node.Type.IsVar;
LocalTypes.AddRange(GetTypes(localSymbol.Type, semanticModel, node));
// ローカル設定
Local.Add(new Expression(localSymbol.Name, Expression.GetSymbolTypeName(localSymbol)));
// コレクションの型設定
var conversionOperation = oparetion.Collection as IConversionOperation;
if (!(conversionOperation is null))
{
CollectionTypes.AddRange(GetTypes(conversionOperation.Operand.Type, semanticModel, node));
}
//コレクション
Collection.AddRange(OperationFactory.GetExpressionList(oparetion.Collection.Children.First(), container));
// 内部処理設定
var block = node.Statement as BlockSyntax;
foreach (var statement in block.Statements)
{
Members.Add(ItemFactory.Create(statement, semanticModel, container, this));
}
}
public MapleSquad(int ch, MapleCharacter leader)
{
Leader = leader;
Status = 1;
Members.Add(leader);
m_ch = ch;
}
private void LoadMembers()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Members.Clear();
Member[] members = SerializationHelper.LoadMembers().OrderBy(q => q.Department).ThenBy(q => q.Name).ToArray();
foreach (var member in members)
{
Members.Add(member);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
private void InitializeMembers()
{
Members.Add(new TeamMember()
{
Username = "******",
FirstName = "Subhan",
LastName = "Donald",
Verified = "true",
Version = 1
});
Members.Add(new TeamMember()
{
Username = "******",
FirstName = "Katya",
LastName = "Riddle",
Verified = "true",
Version = 1
});
Members.Add(new TeamMember()
{
Username = "******",
FirstName = "Roan",
LastName = "Chadwick",
Verified = "true",
Version = 1
});
}
public GuildMember Add(Player plr, GuildStatus rank)
{
var memb = Members.Where(x => x.Name == plr.Character.Name).FirstOrDefault();
if (memb == null)
{
memb = new GuildMember(this, plr, rank);
Members.Add(memb);
}
else
{
memb.Player = plr;
}
var status = ((Master?.Player ?? plr) == plr ? 0x80 : 0x00);
plr.Session.SendAsync(new SGuildViewPort
{
Guilds = new Network.Data.GuildViewPortDto[] {
new Network.Data.GuildViewPortDto {
ID = Index,
Type = Type,
Status = (byte)status,
RelationShip = 0,
Number = plr.Session.ID | status
}
}
});
return(memb);
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Members.Clear();
var members = await MemberStore.GetDatasAsync(true);
foreach (var item in members)
{
Members.Add(item);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
void _generateMemberMap()
{
this.Members = new Dictionary <String, Member>();
var memberList = Model.GenerateAllMembers(_t, RootMember, null);
foreach (var m in memberList)
{
Members.Add(m.FullyQualifiedName, m);
if (m is ColumnMember && !m.AnyParent(p => p is ChildCollectionMember))
{
_outputMembers.Add(m);
}
var col_m = m as ChildCollectionMember;
if (
col_m != null &&
col_m.AlwaysInclude &&
!col_m.AnyParent(p => p is ChildCollectionMember && !((ChildCollectionMember)p).AlwaysInclude) &&
!col_m.IsLazy
)
{
_includedChildCollections.Add(col_m);
}
}
}
public void AddMember(SDMemberBase sdMember)
{
if (!Members.ContainsKey(sdMember.Identifier))
{
Members.Add(sdMember.Identifier, sdMember);
}
}
void Define_Current(bool is_generic)
{
TypeExpr type;
FullNamedExpression explicit_iface;
if (is_generic)
{
explicit_iface = new TypeExpression(generic_enumerator_type, Location);
type = iterator_type_expr;
}
else
{
explicit_iface = new TypeExpression(Module.Compiler.BuiltinTypes.IEnumerator, Location);
type = new TypeExpression(Compiler.BuiltinTypes.Object, Location);
}
var name = new MemberName("Current", null, explicit_iface, Location);
ToplevelBlock get_block = new ToplevelBlock(Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location,
Block.Flags.CompilerGenerated | Block.Flags.NoFlowAnalysis);
get_block.AddStatement(new Return(new DynamicFieldExpr(CurrentField, Location), Location));
Property current = new Property(this, type, Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED, name, null);
current.Get = new Property.GetMethod(current, Modifiers.COMPILER_GENERATED, null, Location);
current.Get.Block = get_block;
Members.Add(current);
}
public string Add(Member member, string password)
{
if (IsBlacklisted(member))
{
return("You are banned from this group");
}
if (password != Password)
{
return("Wrong password\n");
}
foreach (Member memb in Members)
{
if (memb == member)
{
return("You are already subscribed to " + Name);
}
}
Members.Add(member);
return("You have subscribed to " + Name);
}
public void AddPeer(Peer name /*, string keyWord*/) // добавить шифрование
{
//if (keyWord == KeyWord)
Members.Add(name);
//else
// OnMessageHandler($"Ви неправильне ввели слово-ідентефікатор мережі.\n Будь ласка запитайте у відповідальної особи");
}
public RegionMap(Concrete.DataRepository repo)
: base(repo, x => x.Regions)
{
Members.Add(x => x.Parent)
.WithColumn(x => x.ParentId, col =>
{
col.OnWriteRecord(obj => { return(obj.Parent == null ? null : obj.Parent.Id); });
})
.OnComplete((rec, obj) =>
{
obj.Parent = Repository.FindNow <Region>(x => x.Id == rec["ParentId"]);
})
.SetDependencyMode(MemberDependencyMode.Parent);
Members.Add(x => x.Childs)
.OnComplete((rec, obj) =>
{
obj.Childs.Clear();
obj.Childs.AddRange(Repository.Where <Region>(x => x.ParentId == obj.Id).ToList());
})
.SetDependencyMode(MemberDependencyMode.Child);
Members.Add(x => x.Countries)
.OnComplete((rec, obj) =>
{
obj.Countries.Clear();
obj.Countries.AddRange(Repository.Where <Country>(x => x.RegionId == obj.Id).ToList());
})
.SetDependencyMode(MemberDependencyMode.Child);
VersionColumn.SetName(x => x.RowVersion);
}
public override void Update(GameTime gameTime)
{
if (_toBeAdded.Count > 0)
{
foreach (T basic in _toBeAdded)
{
Members.Add(basic);
}
_toBeAdded.Clear();
}
if (_toBeRemoved.Count > 0)
{
foreach (T basic in _toBeRemoved)
{
Members.Remove(basic);
}
_toBeRemoved.Clear();
}
foreach (T basic in Members)
{
if (basic != null && basic.Exists && basic.Active)
{
basic.Update(gameTime);
}
}
}
async Task ExecuteLoadCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
if (ProfileService.StoredDisciple == null || ProfileService.StoredDisciple.Id <= 0)
{
IsBusy = false;
return;
}
try {
IEnumerable <Disciple> members = await DataService.GetGroupMembers(CurrentGroup.Id);
Members.Clear();
members.ToList().ForEach(r => Members.Add(r));
} catch (Exception ex) {
Debug.WriteLine(ex);
} finally {
IsBusy = false;
}
}
