public void Two_instances_of_different_addresses_are_not_equal()
{
Assert.NotEqual(GroupAddress.FromGroups(9, 5, 4), GroupAddress.FromGroups(10, 5, 4));
}
public void ToString_prints_ets_like_group_address()
{
Assert.Equal("5/4/9", GroupAddress.FromGroups(5, 4, 9).ToString());
}
public void Address_with_middle_group_10_cannot_be_constructed()
{
Assert.Throws <ArgumentOutOfRangeException>(() => GroupAddress.FromGroups(0, 10, 0));
}
public void Two_instances_of_same_address_are_equal()
{
Assert.Equal(GroupAddress.FromGroups(10, 5, 4), GroupAddress.FromGroups(10, 5, 4));
}
static void EncodeGroup(StringBuilder builder, GroupAddress group)
{
builder.AppendFormat("(NIL NIL {0} NIL)", MimeUtils.Quote(group.Name));
EncodeInternetAddressListAddresses(builder, group.Members);
builder.Append("(NIL NIL NIL NIL)");
}
public override int GetHashCode()
{
return(GroupAddress != null ? GroupAddress.GetHashCode() : 0);
}
public static void Main(string[] args)
{
// Establish tunneling connection with gateway at 10.0.0.135
_trace = new ConsoleTrace();
var connection = new KnxConnection(new IPEndPoint(IPAddress.Parse("10.0.0.102"), 50000), new IPEndPoint(IPAddress.Parse("10.0.0.135"), 3671), _trace);
var messageBus = new MessageBus();
var dressingLight = new Entity(messageBus,
new IntegerMessageBusAddress(123),
new[] { new Switch() });
var button = new Button(new IntegerMessageBusAddress(123));
var dressingLightButton = new Entity(messageBus, new IntegerMessageBusAddress(456), new[] { button });
var temperatureGauge = new TemperatureGauge();
var temperatureLivingRoom = new Entity(messageBus, new IntegerMessageBusAddress(1001), new[] { temperatureGauge });
var temperatureGauge2 = new TemperatureGauge();
var temperatureDressingRoom = new Entity(messageBus, new IntegerMessageBusAddress(1002), new[] { temperatureGauge2 });
var radio = new Entity(messageBus, new IntegerMessageBusAddress(999), new[] { new Radio() });
var binding = new KnxBinding(connection, messageBus, new IntegerMessageBusAddress(10000));
binding.AddSwitch(GroupAddress.FromGroups(0, 0, 6), new IntegerMessageBusAddress(123), KnxAddressBindingTypes.Switch);
binding.AddSwitch(GroupAddress.FromGroups(0, 4, 0), new IntegerMessageBusAddress(999), KnxAddressBindingTypes.Switch);
binding.AddSwitch(GroupAddress.FromGroups(0, 3, 21), new IntegerMessageBusAddress(1001), KnxAddressBindingTypes.Temperature);
binding.AddSwitch(GroupAddress.FromGroups(0, 3, 20), new IntegerMessageBusAddress(1002), KnxAddressBindingTypes.Temperature);
var test = new Test(temperatureGauge.Temperatures, temperatureGauge2.Temperatures);
using (RunAsp(test))
{
for (;;)
{
var ck = Console.ReadKey();
CemiFrame cemiFrame = null;
if (ck.Key == ConsoleKey.R)
{
cemiFrame = new CemiFrame(CemiFrame.MessageCodes.DataRequest,
CemiFrame.Control1Flags.DoNotRepeat | CemiFrame.Control1Flags.PriorityLow |
CemiFrame.Control1Flags.StandardFrame, CemiFrame.Control2Flags.GroupAddress, IndividualAddress.FromAddressLineDevice(1, 1, 60),
GroupAddress.FromGroups(0, 0, 6), 1, (ushort)(CemiFrame.Commands.ValueRead) << 6);
}
else if (ck.Key == ConsoleKey.Escape)
{
break;
}
if (cemiFrame != null)
{
var task = connection.SendTunnelingRequest(cemiFrame);
task.Wait();
Console.WriteLine("Seq sent: " + task.Result);
}
}
Console.ReadKey();
connection.Dispose();
}
}
/// <summary>
/// Writes to package.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="model">The model.</param>
public static void WriteToPackage <T>(T model)
{
var typeName = model.GetType().Name;
if (model is IImportModel)
{
var importModel = (IImportModel)model;
// check if a textwriter is needed for this model type
if (!textWriters.ContainsKey(typeName))
{
if (!Directory.Exists(_packageDirectory))
{
InitalizePackageFolder();
}
textWriters.Add(typeName, (TextWriter)File.CreateText($@"{_packageDirectory}\{importModel.GetFileName()}"));
// if model is for person create related writers
if (importModel is Person)
{
// person attributes
var personAttributeValue = new PersonAttributeValue();
textWriters.Add(personAttributeValue.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{personAttributeValue.GetFileName()}"));
// person phones
var personPhone = new PersonPhone();
textWriters.Add(personPhone.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{personPhone.GetFileName()}"));
// person addresses
var personAddress = new PersonAddress();
textWriters.Add(personAddress.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{personAddress.GetFileName()}"));
}
// if model is for financial batch create related writers
if (importModel is FinancialBatch)
{
// financial transactions
var financialTransaction = new FinancialTransaction();
textWriters.Add(financialTransaction.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{financialTransaction.GetFileName()}"));
// financial transation details
var financialTransactionDetail = new FinancialTransactionDetail();
textWriters.Add(financialTransactionDetail.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{financialTransactionDetail.GetFileName()}"));
}
// if model is for financial transaction create related writers
if (importModel is FinancialTransaction)
{
// financial transation details
var financialTransactionDetail = new FinancialTransactionDetail();
textWriters.Add(financialTransactionDetail.GetType().Name, ( TextWriter )File.CreateText($@"{_packageDirectory}\{financialTransactionDetail.GetFileName()}"));
}
// if model is for group create related writers
if (importModel is Group)
{
// group member
var groupMember = new GroupMember();
textWriters.Add(groupMember.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{groupMember.GetFileName()}"));
// group attributes
var groupAttributeValue = new GroupAttributeValue();
textWriters.Add(groupAttributeValue.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{groupAttributeValue.GetFileName()}"));
// group addresses
var groupAddress = new GroupAddress();
textWriters.Add(groupAddress.GetType().Name, (TextWriter)File.CreateText($@"{_packageDirectory}\{groupAddress.GetFileName()}"));
}
// if model is for business create related writers
if (importModel is Business)
{
// business attributes
var businessAttributeValue = new BusinessAttributeValue();
textWriters.Add(businessAttributeValue.GetType().Name, ( TextWriter )File.CreateText($@"{_packageDirectory}\{businessAttributeValue.GetFileName()}"));
// business phones
var businessPhone = new BusinessPhone();
textWriters.Add(businessPhone.GetType().Name, ( TextWriter )File.CreateText($@"{_packageDirectory}\{businessPhone.GetFileName()}"));
// business addresses
var businessAddress = new BusinessAddress();
textWriters.Add(businessAddress.GetType().Name, ( TextWriter )File.CreateText($@"{_packageDirectory}\{businessAddress.GetFileName()}"));
// business contacts
var businessContact = new BusinessContact();
textWriters.Add(businessContact.GetType().Name, ( TextWriter )File.CreateText($@"{_packageDirectory}\{businessContact.GetFileName()}"));
}
}
var txtWriter = textWriters[typeName];
// check if a csvwriter is needed for this model type
if (!csvWriters.ContainsKey(typeName))
{
var newCsvWriter = new CsvWriter(txtWriter);
csvWriters.Add(typeName, newCsvWriter);
newCsvWriter.WriteHeader <T>();
//newCsvWriter.Configuration.QuoteAllFields = true;
// if model is for person create related writers
if (importModel is Person)
{
// person attributes
var personAttributeValue = new PersonAttributeValue();
var newPersonAttributeValueCsvWriter = new CsvWriter(textWriters[personAttributeValue.GetType().Name]);
csvWriters.Add(personAttributeValue.GetType().Name, newPersonAttributeValueCsvWriter);
newPersonAttributeValueCsvWriter.WriteHeader <PersonAttributeValue>();
// person phones
var personPhone = new PersonPhone();
var newPersonPhoneCsvWriter = new CsvWriter(textWriters[personPhone.GetType().Name]);
csvWriters.Add(personPhone.GetType().Name, newPersonPhoneCsvWriter);
newPersonPhoneCsvWriter.WriteHeader <PersonPhone>();
// person addresses
var personAddress = new PersonAddress();
var newPersonAddressCsvWriter = new CsvWriter(textWriters[personAddress.GetType().Name]);
csvWriters.Add(personAddress.GetType().Name, newPersonAddressCsvWriter);
newPersonAddressCsvWriter.WriteHeader <PersonAddress>();
}
// if model is for financial batch create related writers
if (importModel is FinancialBatch)
{
// financial transaction
var financialTransaction = new FinancialTransaction();
var newFinancialTransactionCsvWriter = new CsvWriter(textWriters[financialTransaction.GetType().Name]);
csvWriters.Add(financialTransaction.GetType().Name, newFinancialTransactionCsvWriter);
newFinancialTransactionCsvWriter.WriteHeader <FinancialTransaction>();
// financial transaction detail
var financialTransactionDetail = new FinancialTransactionDetail();
var newFinancialTransactionDetailCsvWriter = new CsvWriter(textWriters[financialTransactionDetail.GetType().Name]);
csvWriters.Add(financialTransactionDetail.GetType().Name, newFinancialTransactionDetailCsvWriter);
newFinancialTransactionDetailCsvWriter.WriteHeader <FinancialTransactionDetail>();
}
//if model is for financial transaction, create related writers
if (importModel is FinancialTransaction)
{
// financial transaction detail
var financialTransactionDetail = new FinancialTransactionDetail();
var newFinancialTransactionDetailCsvWriter = new CsvWriter(textWriters[financialTransactionDetail.GetType().Name]);
csvWriters.Add(financialTransactionDetail.GetType().Name, newFinancialTransactionDetailCsvWriter);
newFinancialTransactionDetailCsvWriter.WriteHeader <FinancialTransactionDetail>();
}
// if model is for group create related writers
if (importModel is Group)
{
// group member
var groupMember = new GroupMember();
var newGroupMemberCsvWriter = new CsvWriter(textWriters[groupMember.GetType().Name]);
csvWriters.Add(groupMember.GetType().Name, newGroupMemberCsvWriter);
newGroupMemberCsvWriter.WriteHeader <GroupMember>();
// group attributes
var groupAttributeValue = new GroupAttributeValue();
var newGroupAttributeValueCsvWriter = new CsvWriter(textWriters[groupAttributeValue.GetType().Name]);
csvWriters.Add(groupAttributeValue.GetType().Name, newGroupAttributeValueCsvWriter);
newGroupAttributeValueCsvWriter.WriteHeader <GroupAttributeValue>();
// group addresses
var groupAddress = new GroupAddress();
var newGroupAddressCsvWriter = new CsvWriter(textWriters[groupAddress.GetType().Name]);
csvWriters.Add(groupAddress.GetType().Name, newGroupAddressCsvWriter);
newGroupAddressCsvWriter.WriteHeader <GroupAddress>();
}
// if model is for business create related writers
if (importModel is Business)
{
// business attributes
var businessAttributeValue = new BusinessAttributeValue();
var newBusinessAttributeValueCsvWriter = new CsvWriter(textWriters[businessAttributeValue.GetType().Name]);
csvWriters.Add(businessAttributeValue.GetType().Name, newBusinessAttributeValueCsvWriter);
newBusinessAttributeValueCsvWriter.WriteHeader <BusinessAttributeValue>();
// business phones
var businessPhone = new BusinessPhone();
var newBusinessPhoneCsvWriter = new CsvWriter(textWriters[businessPhone.GetType().Name]);
csvWriters.Add(businessPhone.GetType().Name, newBusinessPhoneCsvWriter);
newBusinessPhoneCsvWriter.WriteHeader <PersonPhone>();
// business addresses
var businessAddress = new BusinessAddress();
var newBusinessAddressCsvWriter = new CsvWriter(textWriters[businessAddress.GetType().Name]);
csvWriters.Add(businessAddress.GetType().Name, newBusinessAddressCsvWriter);
newBusinessAddressCsvWriter.WriteHeader <PersonAddress>();
// business Contacts
var businessContacts = new BusinessContact();
var newBusinessContactsCsvWriter = new CsvWriter(textWriters[businessContacts.GetType().Name]);
csvWriters.Add(businessContacts.GetType().Name, newBusinessContactsCsvWriter);
newBusinessContactsCsvWriter.WriteHeader <PersonAddress>();
}
}
var csvWriter = csvWriters[typeName];
csvWriter.WriteRecord <T>(model);
// if person model write out any related models
if (importModel is Person)
{
// person attributes
var personAttributeValue = new PersonAttributeValue();
var csvPersonAttributeValueWriter = csvWriters[personAttributeValue.GetType().Name];
if (csvPersonAttributeValueWriter != null)
{
foreach (var attribute in ((Person)importModel).Attributes)
{
csvPersonAttributeValueWriter.WriteRecord(attribute);
}
}
// person phones
var personPhone = new PersonPhone();
var csvPersonPhoneWriter = csvWriters[personPhone.GetType().Name];
if (csvPersonPhoneWriter != null)
{
foreach (var phone in ((Person)importModel).PhoneNumbers)
{
csvPersonPhoneWriter.WriteRecord(phone);
}
}
// person addresses
var personAddress = new PersonAddress();
var csvPersonAddressWriter = csvWriters[personAddress.GetType().Name];
if (csvPersonAddressWriter != null)
{
foreach (var address in ((Person)importModel).Addresses)
{
csvPersonAddressWriter.WriteRecord(address);
}
}
}
// if financial model write out any related models
if (importModel is FinancialBatch)
{
// write out financial transactions and transaction details
var financialTransaction = new FinancialTransaction();
var csvFinancialTransactionWriter = csvWriters[financialTransaction.GetType().Name];
var financialTransactionDetail = new FinancialTransactionDetail();
var csvFinancialTransactionDetailWriter = csvWriters[financialTransactionDetail.GetType().Name];
if (csvFinancialTransactionWriter != null && csvFinancialTransactionDetailWriter != null)
{
foreach (var transaction in ((FinancialBatch)importModel).FinancialTransactions)
{
csvFinancialTransactionWriter.WriteRecord(transaction);
foreach (var transactionDetail in transaction.FinancialTransactionDetails)
{
csvFinancialTransactionDetailWriter.WriteRecord(transactionDetail);
}
}
}
}
// if financial Transaction model write out any related models
if (importModel is FinancialTransaction)
{
var financialTransactionDetail = new FinancialTransactionDetail();
var csvFinancialTransactionDetailWriter = csvWriters[financialTransactionDetail.GetType().Name];
if (csvFinancialTransactionDetailWriter != null)
{
foreach (var transactionDetail in ((FinancialTransaction)importModel).FinancialTransactionDetails)
{
csvFinancialTransactionDetailWriter.WriteRecord(transactionDetail);
}
}
}
// if group model write out any related models
if (importModel is Group)
{
// group members
var groupMember = new GroupMember();
var csvGroupMemberWriter = csvWriters[groupMember.GetType().Name];
if (csvGroupMemberWriter != null)
{
foreach (var groupMemberItem in ((Group)importModel).GroupMembers)
{
csvGroupMemberWriter.WriteRecord(groupMemberItem);
}
}
// group attributes
var groupAttributeValue = new GroupAttributeValue();
var csvPersonAttributeValueWriter = csvWriters[groupAttributeValue.GetType().Name];
if (csvPersonAttributeValueWriter != null)
{
foreach (var attribute in ((Group)importModel).Attributes)
{
csvPersonAttributeValueWriter.WriteRecord(attribute);
}
}
// group addresses
var groupAddress = new GroupAddress();
var csvGroupAddressWriter = csvWriters[groupAddress.GetType().Name];
if (csvGroupAddressWriter != null)
{
foreach (var address in ((Group)importModel).Addresses)
{
csvGroupAddressWriter.WriteRecord(address);
}
}
}
// if business model write out any related models
if (importModel is Business)
{
// business attributes
var personBusinessValue = new BusinessAttributeValue();
var csvBusinessAttributeValueWriter = csvWriters[personBusinessValue.GetType().Name];
if (csvBusinessAttributeValueWriter != null)
{
foreach (var attribute in (( Business )importModel).Attributes)
{
csvBusinessAttributeValueWriter.WriteRecord(attribute);
}
}
// business phones
var businessPhone = new BusinessPhone();
var csvBusinessPhoneWriter = csvWriters[businessPhone.GetType().Name];
if (csvBusinessPhoneWriter != null)
{
foreach (var phone in (( Business )importModel).PhoneNumbers)
{
csvBusinessPhoneWriter.WriteRecord(phone);
}
}
// business addresses
var businessAddress = new BusinessAddress();
var csvBusinessAddressWriter = csvWriters[businessAddress.GetType().Name];
if (csvBusinessAddressWriter != null)
{
foreach (var address in (( Business )importModel).Addresses)
{
csvBusinessAddressWriter.WriteRecord(address);
}
}
// business contacts
var businessContact = new BusinessContact();
var csvBusinessContactWriter = csvWriters[businessContact.GetType().Name];
if (csvBusinessContactWriter != null)
{
foreach (var contact in (( Business )importModel).Contacts)
{
csvBusinessAddressWriter.WriteRecord(contact);
}
}
}
}
}
public static Group Translate(DataRow row, DataTable members)
{
var group = new Group();
if (row.Field <int?>("Group_Id").HasValue)
{
group.Id = row.Field <int?>("Group_Id").Value;
}
else
{
if (!string.IsNullOrWhiteSpace(row.Field <string>("Group_Name")) && row.Field <int?>("ParentGroupId").HasValue)
{
MD5 md5Hasher = MD5.Create();
var hashed = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(row.Field <string>("Group_Name") + row.Field <int?>("ParentGroupId").Value));
var groupId = Math.Abs(BitConverter.ToInt32(hashed, 0)); // used abs to ensure positive number
if (groupId > 0)
{
group.Id = groupId;
}
}
else
{
return(null);
}
}
group.Name = row.Field <string>("Group_Name");
group.GroupTypeId = row.Field <int>("Group_Type_ID");
group.IsActive = row.Field <int>("is_active") != 0;
group.IsPublic = row.Field <int>("is_public") != 0;
group.MeetingDay = row.Field <string>("ScheduleDay");
group.ParentGroupId = row.Field <int?>("ParentGroupId") ?? 90000000 + group.GroupTypeId;
group.Description = row.Field <string>("Description");
if (!string.IsNullOrWhiteSpace(row.Field <string>("StartHour")))
{
group.MeetingTime = row.Field <string>("StartHour") + ":00";
}
var importAddress = new GroupAddress();
importAddress.GroupId = group.Id;
importAddress.Street1 = row.Field <string>("Address1");
importAddress.Street2 = row.Field <string>("Address2");
importAddress.City = row.Field <string>("City");
importAddress.State = row.Field <string>("StProvince");
importAddress.PostalCode = row.Field <string>("PostalCode");
importAddress.Country = row.Field <string>("country");
importAddress.AddressType = AddressType.Other;
// only add the address if we have a valid address
if (importAddress.Street1.IsNotNullOrWhitespace() &&
importAddress.City.IsNotNullOrWhitespace() &&
importAddress.PostalCode.IsNotNullOrWhitespace())
{
group.Addresses.Add(importAddress);
}
foreach (var member in members.Select("Group_Id =" + group.Id))
{
var groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.PersonId = member.Field <int>("Individual_ID");
groupMember.Role = member.Field <string>("Group_Member_Type");
group.GroupMembers.Add(groupMember);
}
return(group);
}
public static List <Group> Translate(XElement inputGroup)
{
List <Group> groups = new List <Group>();
int?departmentId = null;
int?directorId = null;
var group = new Group();
group.Id = inputGroup.Attribute("id").Value.AsInteger();
group.Name = inputGroup.Element("name")?.Value;
group.Description = inputGroup.Element("description")?.Value.RemoveCrLf();
group.GroupTypeId = inputGroup.Element("group_type").Attribute("id").Value.AsInteger();
group.CampusId = inputGroup.Element("campus").Attribute("id").Value.AsIntegerOrNull();
group.Capacity = inputGroup.Element("group_capacity").Value.AsIntegerOrNull();
group.IsActive = !inputGroup.Element("inactive").Value.AsBoolean();
group.IsPublic = inputGroup.Element("public_search_listed").Value.AsBoolean();
group.MeetingDay = inputGroup.Element("meeting_day").Value;
group.MeetingTime = inputGroup.Element("meeting_time").Value;
ProcessBooleanAttribute(group, inputGroup.Element("childcare_provided"), "HasChildcare");
if (group.GroupTypeId == 0)
{
group.GroupTypeId = CcbApi.GROUPTYPE_UNKNOWN_ID;
}
groups.Add(group);
// add the department as a group with an id of 9999 + its id to create a unique group id for it
if (inputGroup.Element("department") != null && inputGroup.Element("department").Attribute("id") != null && inputGroup.Element("department").Attribute("id").Value.IsNotNullOrWhitespace())
{
departmentId = ("9999" + inputGroup.Element("department").Attribute("id").Value).AsInteger();
var departmentName = inputGroup.Element("department").Value;
if (departmentName.IsNullOrWhiteSpace())
{
departmentName = "No Department Name";
}
groups.Add(new Group {
Id = departmentId.Value, Name = inputGroup.Element("department").Value, IsActive = true, GroupTypeId = 9999
});
}
// add the director as a group with an id of 9998 + its id to create a unique group id for it
if (inputGroup.Element("director") != null && inputGroup.Element("director").Attribute("id") != null && inputGroup.Element("director").Attribute("id").Value.IsNotNullOrWhitespace())
{
directorId = ("9998" + inputGroup.Element("director").Attribute("id").Value).AsInteger();
var directorGroup = new Group();
directorGroup.Id = directorId.Value;
directorGroup.IsActive = true;
directorGroup.Name = inputGroup.Element("director").Element("full_name").Value;
directorGroup.GroupTypeId = 9998;
// add parent group of the department if it exists
if (departmentId.HasValue)
{
directorGroup.ParentGroupId = departmentId.Value;
}
directorGroup.GroupMembers.Add(new GroupMember {
PersonId = inputGroup.Element("director").Attribute("id").Value.AsInteger(), Role = "Leader", GroupId = directorGroup.Id
});
groups.Add(directorGroup);
}
// add leader
if (inputGroup.Element("main_leader").Attribute("id") != null && inputGroup.Element("main_leader").Attribute("id").Value.AsInteger() != 0)
{
group.GroupMembers.Add(new GroupMember {
PersonId = inputGroup.Element("main_leader").Attribute("id").Value.AsInteger(), Role = "Leader", GroupId = group.Id
});
}
// add assistant leaders
if (inputGroup.Element("leaders") != null)
{
foreach (var leaderNode in inputGroup.Element("leaders").Elements("leader"))
{
group.GroupMembers.Add(new GroupMember {
PersonId = leaderNode.Attribute("id").Value.AsInteger(), Role = "Assistant Leader", GroupId = group.Id
});
}
}
// add participants
if (inputGroup.Element("participants") != null)
{
foreach (var participantNode in inputGroup.Element("participants").Elements("participant"))
{
group.GroupMembers.Add(new GroupMember {
PersonId = participantNode.Attribute("id").Value.AsInteger(), Role = "Member", GroupId = group.Id
});
}
}
var addressList = inputGroup.Element("addresses").Elements("address");
foreach (var address in addressList)
{
if (address.Element("street_address") != null && address.Element("street_address").Value.IsNotNullOrWhitespace())
{
var importAddress = new GroupAddress();
importAddress.GroupId = group.Id;
importAddress.Street1 = address.Element("street_address").Value.RemoveCrLf();
importAddress.City = address.Element("city").Value;
importAddress.State = address.Element("state").Value;
importAddress.PostalCode = address.Element("zip").Value;
importAddress.Latitude = address.Element("latitude")?.Value;
importAddress.Longitude = address.Element("longitude")?.Value;
importAddress.Country = address.Element("country")?.Value;
var addressType = address.Attribute("type").Value;
switch (addressType)
{
case "mailing":
case "home":
{
importAddress.AddressType = AddressType.Home;
importAddress.IsMailing = addressType.Equals("mailing");
break;
}
case "work":
{
importAddress.AddressType = AddressType.Work;
break;
}
case "other":
{
importAddress.AddressType = AddressType.Other;
break;
}
}
// only add the address if we have a valid address
if (importAddress.Street1.IsNotNullOrWhitespace() && importAddress.City.IsNotNullOrWhitespace() && importAddress.PostalCode.IsNotNullOrWhitespace())
{
group.Addresses.Add(importAddress);
}
}
}
// determine the parent group
if (directorId.HasValue)
{
group.ParentGroupId = directorId.Value;
}
else if (departmentId.HasValue)
{
group.ParentGroupId = departmentId.Value;
}
return(groups);
}
/// <summary>
/// Xor of the hash codes of the layer length, datalink, message type, query version and group address.
/// </summary>
public sealed override int GetHashCode()
{
return(base.GetHashCode() ^
GroupAddress.GetHashCode());
}
public async Task <Result <bool> > UpdateAddressAsync(Abonent abonent, int id, GroupAddress addressGroup, string information)
{
if (!abonent.Addresses.Any(p => p.Information == information && p.Id != id))
{
var answer = abonent.UpdateAddress(id, addressGroup, information);
if (answer.Succeeded)
{
await db.SaveChangesAsync();
return(Result <bool> .Success(true));
}
return(Result <bool> .Fail(answer.Errors));
}
return(Result <bool> .Fail(new string[] { "Such Address exists" }));
}
public void AddSwitch(GroupAddress groupAddress, IMessageBusAddress address, KnxAddressBindingTypes knxAddressBindingType)
{
_mapping.Add(address, groupAddress);
_bindingTypes = _bindingTypes.Add(groupAddress, knxAddressBindingType);
_messageBus.AddMessageSink(address, this, this);
}
public static Group Translate(DataRow row, DataTable members, DataTable staffing)
{
var group = new Group();
if (row.Field <int?>("Group_Id").HasValue)
{
group.Id = row.Field <int?>("Group_Id").Value;
}
else
{
if (!string.IsNullOrWhiteSpace(row.Field <string>("Group_Name")) && row.Field <int?>("ParentGroupId").HasValue)
{
MD5 md5Hasher = MD5.Create();
string valueToHash = $"{ row.Field<string>( "Group_Name" ) }{ row.Field<int>( "ParentGroupId" ) }";
var hashed = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(valueToHash));
var groupId = Math.Abs(BitConverter.ToInt32(hashed, 0)); // used abs to ensure positive number
if (groupId > 0)
{
group.Id = groupId;
}
}
else
{
return(null);
}
}
// Limit the group name to 50 since the schedules that will be created in Rock use the group's name as the schedule name and
// that field is limited in the database to 50 characters
group.Name = row.Field <string>("Group_Name").Left(50);
group.GroupTypeId = row.Field <int>("Group_Type_ID");
group.IsActive = row.Field <int>("is_active") != 0;
if (row.Field <int?>("is_public").HasValue)
{
group.IsPublic = row.Field <int?>("is_public").Value != 0;
}
group.MeetingDay = row.Field <string>("ScheduleDay");
group.ParentGroupId = row.Field <int?>("ParentGroupId") ?? 90000000 + group.GroupTypeId;
group.Description = row.Field <string>("Description");
if (!string.IsNullOrWhiteSpace(row.Field <string>("StartHour")))
{
group.MeetingTime = row.Field <string>("StartHour") + ":00";
}
var importAddress = new GroupAddress();
importAddress.GroupId = group.Id;
importAddress.Street1 = row.Field <string>("Address1");
importAddress.Street2 = row.Field <string>("Address2");
importAddress.City = row.Field <string>("City");
importAddress.State = row.Field <string>("StProvince");
importAddress.PostalCode = row.Field <string>("PostalCode");
importAddress.Country = row.Field <string>("country");
importAddress.AddressType = AddressType.Other;
// only add the address if we have a valid address
if (importAddress.Street1.IsNotNullOrWhitespace() &&
importAddress.City.IsNotNullOrWhitespace() &&
importAddress.PostalCode.IsNotNullOrWhitespace())
{
group.Addresses.Add(importAddress);
}
foreach (var member in members.Select($"Group_Id ={ group.Id }"))
{
var groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.PersonId = member.Field <int>("Individual_ID");
groupMember.Role = member.Field <string>("Group_Member_Type");
group.GroupMembers.Add(groupMember);
}
if (staffing != null)
{
foreach (var staff in staffing.Select($"Group_Id = { group.Id }"))
{
var groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.PersonId = staff.Field <int>("INDIVIDUAL_ID");
groupMember.Role = "Staff";
group.GroupMembers.Add(groupMember);
}
}
return(group);
}
public void Address_0_3_7_is_ushort_address_775()
{
var sut = GroupAddress.FromGroups(0, 3, 7);
Assert.Equal(sut.AsUShort, 775);
}
private static bool IsToUndisclosedRecipients(GroupAddress address)
{
return((address.Name ?? "").ToLower().Replace(" ", "").Replace("-", "") == "undisclosedrecipients");
}
public void Address_12_6_129_is_ushort_address_40577()
{
var sut = GroupAddress.FromGroups(19, 6, 129);
Assert.Equal(sut.AsUShort, 40577);
}
public static Group Translate(GroupDTO group, List <GroupMemberDTO> members, DataTable staffing)
{
var slingshotGroup = new Group();
if (group.GroupId.HasValue)
{
slingshotGroup.Id = group.GroupId.Value;
}
else
{
if (!string.IsNullOrWhiteSpace(group.GroupName) && group.ParentGroupId.HasValue)
{
MD5 md5Hasher = MD5.Create();
string valueToHash = $"{ group.GroupName }{ group.ParentGroupId.Value }";
var hashed = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(valueToHash));
var groupId = Math.Abs(BitConverter.ToInt32(hashed, 0)); // used abs to ensure positive number
if (groupId > 0)
{
slingshotGroup.Id = groupId;
}
}
else
{
return(null);
}
}
// Limit the group name to 50 since the schedules that will be created in Rock use the group's name as the schedule name and
// that field is limited in the database to 50 characters
slingshotGroup.Name = group.GroupName.Left(50);
slingshotGroup.GroupTypeId = group.GroupTypeId;
slingshotGroup.IsActive = group.IsActive;
if (group.IsPublic.HasValue)
{
slingshotGroup.IsPublic = group.IsPublic.Value;
}
slingshotGroup.MeetingDay = group.ScheduleDay;
slingshotGroup.ParentGroupId = group.ParentGroupId ?? 90000000 + slingshotGroup.GroupTypeId;
slingshotGroup.Description = group.Description;
if (!string.IsNullOrWhiteSpace(group.StartHour))
{
slingshotGroup.MeetingTime = group.StartHour + ":00";
}
var importAddress = new GroupAddress();
importAddress.GroupId = slingshotGroup.Id;
importAddress.Street1 = group.Address1;
importAddress.Street2 = group.Address2;
importAddress.City = group.City;
importAddress.State = group.StateProvince;
importAddress.PostalCode = group.PostalCode;
importAddress.Country = group.Country;
importAddress.AddressType = AddressType.Other;
// only add the address if we have a valid address
if (importAddress.Street1.IsNotNullOrWhitespace() &&
importAddress.City.IsNotNullOrWhitespace() &&
importAddress.PostalCode.IsNotNullOrWhitespace())
{
slingshotGroup.Addresses.Add(importAddress);
}
var groupMembers = members.AsEnumerable().Where(m => m.GroupId == slingshotGroup.Id);
foreach (var member in groupMembers)
{
var groupMember = new GroupMember();
groupMember.GroupId = slingshotGroup.Id;
groupMember.PersonId = member.IndividualId;
groupMember.Role = member.GroupMemberType;
slingshotGroup.GroupMembers.Add(groupMember);
}
if (staffing != null)
{
foreach (var staff in staffing.Select($"RLC_ID = { slingshotGroup.Id } OR Activity_ID = { slingshotGroup.Id }"))
{
var groupMember = new GroupMember();
groupMember.GroupId = slingshotGroup.Id;
groupMember.PersonId = staff.Field <int>("INDIVIDUAL_ID");
groupMember.Role = "Staff";
slingshotGroup.GroupMembers.Add(groupMember);
}
}
return(slingshotGroup);
}
public void Address_with_main_group_33_cannot_be_constructed()
{
Assert.Throws <ArgumentOutOfRangeException>(() => GroupAddress.FromGroups(33, 0, 0));
}
static bool TryParse(string text, ref int index, out InternetAddress addr)
{
string name, route, user, domain;
DomainList domains;
addr = null;
if (text[index] != '(')
{
return(false);
}
index++;
if (!TryParse(text, ref index, out name))
{
return(false);
}
if (!TryParse(text, ref index, out route))
{
return(false);
}
if (!TryParse(text, ref index, out user))
{
return(false);
}
if (!TryParse(text, ref index, out domain))
{
return(false);
}
while (index < text.Length && text[index] == ' ')
{
index++;
}
if (index >= text.Length || text[index] != ')')
{
return(false);
}
index++;
if (domain != null)
{
var address = user + "@" + domain;
if (route != null && DomainList.TryParse(route, out domains))
{
addr = new MailboxAddress(name, domains, address);
}
else
{
addr = new MailboxAddress(name, address);
}
}
else if (user != null)
{
addr = new GroupAddress(user);
}
return(true);
}
public KnxAddressBinding(GroupAddress groupAddress, KnxAddressBindingTypes knxAddressBindingType)
{
GroupAddress = groupAddress;
KnxAddressBindingType = knxAddressBindingType;
}
