public void AddClient(PhoneNumber phoneNumber, ITariff tariff)
{
_tariffsMap.Add(phoneNumber, tariff);
_canChangeTariffMap.Add(phoneNumber, true);
_callsMap.Add(phoneNumber, new List<CallInfo>());
_debtMap.Add(phoneNumber, 0);
}
/// <summary>
/// Posts the specified phone number.
/// </summary>
/// <param name="phoneNumber">The phone number.</param>
/// <returns></returns>
public override System.Net.Http.HttpResponseMessage Post( PhoneNumber phoneNumber )
{
var changes = new List<string>();
string newPhoneNumber = phoneNumber.NumberFormattedWithCountryCode;
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumber.NumberTypeValueId ) ),
string.Empty,
newPhoneNumber );
var rockContext = (RockContext)Service.Context;
System.Web.HttpContext.Current.Items.Add( "CurrentPerson", GetPerson() );
int? modifiedByPersonAliasId = phoneNumber.ModifiedAuditValuesAlreadyUpdated ? phoneNumber.ModifiedByPersonAliasId : (int?)null;
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
phoneNumber.PersonId,
changes,
true,
modifiedByPersonAliasId );
return base.Post( phoneNumber );
}
public Person()
{
Adresse = new Address();
Telefon = new PhoneNumber();
Rights = new Rights();
ID = Guid.NewGuid();
}
public void EqualsMethod()
{
var phoneNumber1 = new PhoneNumber("01234 567890");
var phoneNumber2 = new PhoneNumber("01234 567890");
Assert.True(phoneNumber1.Equals(phoneNumber2));
}
///<summary>Inserts one PhoneNumber into the database. Returns the new priKey.</summary>
internal static long Insert(PhoneNumber phoneNumber)
{
if(DataConnection.DBtype==DatabaseType.Oracle) {
phoneNumber.PhoneNumberNum=DbHelper.GetNextOracleKey("phonenumber","PhoneNumberNum");
int loopcount=0;
while(loopcount<100){
try {
return Insert(phoneNumber,true);
}
catch(Oracle.DataAccess.Client.OracleException ex){
if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
phoneNumber.PhoneNumberNum++;
loopcount++;
}
else{
throw ex;
}
}
}
throw new ApplicationException("Insert failed. Could not generate primary key.");
}
else {
return Insert(phoneNumber,false);
}
}
public void TestEquality()
{
var phone1 = new PhoneNumber("2055551212");
Assert.AreEqual(phone1, phone1);
var phone2 = new PhoneNumber("2055551212");
Assert.AreEqual(phone1, phone2);
}
public MessageRequest(PhoneNumber sender, string message)
{
if (message == null) throw new ArgumentNullException(nameof(message));
Sender = sender;
Message = message;
}
public virtual void Call(PhoneNumber target)
{
if (IsOnline)
{
OnOutgoingCall(this, new CallInfo(target, Number, TerminalState.OutGoingCall));
}
}
public TestTerminal(PhoneNumber number)
: base(number)
{
this.IncomingRequest += this.OnIncomingRequest;
this.Online += (sender, args) => { Console.WriteLine("Terminal {0} turned to online mode", Number); };
this.Offline += (sender, args) => { Console.WriteLine("Terminal {0} turned to offline mode", Number); };
}
private void SetTerminalsStateTo(PhoneNumber source, PhoneNumber target, TerminalState state)
{
var sourceTerminal = GetTerminalByPhoneNumber(source) as TestTerminal;
var targetTerminal = GetTerminalByPhoneNumber(target) as TestTerminal;
if (sourceTerminal != null) sourceTerminal.State = state;
if (targetTerminal != null) targetTerminal.State = state;
}
public void EqualsOperator()
{
var phoneNumber1 = new PhoneNumber("01234 567890");
var phoneNumber2 = new PhoneNumber("01234 567890");
Assert.True(phoneNumber1 == phoneNumber2);
}
public void Call(PhoneNumber target)
{
if (!IsOnline)
{
OnOutgoingCall(this, target);
OnOnline(this, null);
}
}
public void Constructor_OnlyDigits_SetsNumber()
{
string number = "5555555555";
var phoneNumber = new PhoneNumber(number);
Assert.Equal(number, phoneNumber.Number);
}
public void USPhoneNumber()
{
var phoneNumber = new PhoneNumber("8015461234");
Assert.Equal("801", phoneNumber.AreaCode);
Assert.Equal("546", phoneNumber.Prefix);
Assert.Equal("1234", phoneNumber.Postfix);
Assert.Equal("(801) 546-1234", phoneNumber.Formatted);
}
public Contract(string number, string phoneNumber, TariffPlan tariffPlan, string personalAccount, string dateOfConclusion)
{
Number = number;
PhoneNumber = new PhoneNumber { Value = phoneNumber };
TariffPlan = tariffPlan;
DateOfConclusion = DateTime.Parse(dateOfConclusion);
PersonalAccount = new PersonalAccount(personalAccount, DateOfConclusion + new TimeSpan(31, 0, 0));
}
private static EventAttendee CreateAttendee(string firstName, string lastName)
{
var name = new PersonName(firstName, lastName);
var email = new EmailAddress("*****@*****.**");
var phone = new PhoneNumber("2055551212");
var address = new Address("123 Main St.", "Suite 1", "Los Angeles", 10, "90036");
return new EventAttendee(name, address, email, phone, firstName, lastName);
}
public void NumericPhoneNumber()
{
const string phoneNumber = "0100100";
sut = PhoneNumber.Create(phoneNumber);
Assert.AreEqual(phoneNumber, sut.ToString());
}
public Terminal(PhoneNumber number,string name,TariffPlans rate)
{
this.Number = number;
this.UserName = name;
this.CurrentTariff = rate;
this.DateOfTariffChange = DateTime.Now;
this.AllowChangeTariff = false;
}
public void NumericPhoneNumberWithWhiteSpaces()
{
const string phoneNumber = "02 588 4430";
sut = PhoneNumber.Create(phoneNumber);
Assert.AreEqual(phoneNumber, sut.ToString());
}
public SpeakerDocument(Id id, Version version, SpeakerBio bio, PhoneNumber phoneNumber, EmailAddress emailAddress, Name name)
{
Bio = (string) bio;
Email = (string) emailAddress;
Id = (Guid) id;
PhoneNumber = (string) phoneNumber;
Name = (string) name;
Version = (int)version;
}
public void Player_FindByPhoneNumber()
{
using (var repository = new TelephoneGameRepository())
{
PhoneNumber phone = new PhoneNumber() { Number = "15022967010" };
Player p = GameService.FindPlayer(phone, repository);
Assert.That(null != p, "Player not found");
}
}
public void BrokenNumberToFix()
{
// a number I found in our data
// TOOD: this is currently broken
var number = new PhoneNumber("604 783 8072");
Assert.AreEqual("", number.Country);
Assert.AreEqual("604", number.Area);
Assert.AreEqual("783 8072", number.Local);
}
public SpeakerDocument(Id id, Version version, SpeakerBio bio, PhoneNumber phoneNumber, EmailAddress emailAddress, SpeakerName name)
{
Bio = bio;
Email = emailAddress;
Id = id;
PhoneNumber = phoneNumber;
Name = name;
Version = version;
}
public Contract(Client client, TariffType tariffType, DateTime conclusionDate)
{
LastTariffUpdateDate = DateTime.Now;
Client = client;
PhoneNumber = new PhoneNumber(rnd.Next(1000000, 9999999).ToString());
TariffPlan = new TariffPlan(tariffType);
ConclusionDate = conclusionDate;
}
/// <summary>
/// Creates the attendee.
/// </summary>
/// <param name="attendeeDto">The attendee dto.</param>
/// <returns></returns>
public static EventAttendee CreateAttendee(AttendeeDto attendeeDto)
{
var name = new PersonName(attendeeDto.FirstName, attendeeDto.LastName);
var address = new Address(attendeeDto.Address1, attendeeDto.Address2, attendeeDto.City, attendeeDto.StateId, attendeeDto.PostalCode);
var phone = new PhoneNumber(attendeeDto.PrimaryPhone);
var email = new EmailAddress(attendeeDto.EmailAddress);
var attendee = new EventAttendee(name, address, email, phone, attendeeDto.FirstName, attendeeDto.LastName, attendeeDto.DynamicColumnsData, attendeeDto.ProfileId, attendeeDto.UserId, attendeeDto.DidAttend);
return attendee;
}
public Microsoft.Communications.Contacts.Contact GetCanonicalContact(Microsoft.LiveFX.Client.Contact c)
{
Microsoft.Communications.Contacts.Contact contact = new Microsoft.Communications.Contacts.Contact();
//LiveItemCollection<Profile, ProfileResource> profiles = c.Profiles;
contact.Names.Add(new Name(c.Resource.GivenName, c.Resource.MiddleName, c.Resource.FamilyName, NameCatenationOrder.FamilyGivenMiddle));
foreach (ContactPhone cp in c.Resource.PhoneNumbers)
{
PhoneNumber pn = new PhoneNumber(cp.Value);
if (cp.Type == ContactPhone.ContactPhoneType.Business ||
cp.Type == ContactPhone.ContactPhoneType.Business2)
contact.PhoneNumbers.Add(pn, PhoneLabels.Voice, PropertyLabels.Business);
else if (cp.Type == ContactPhone.ContactPhoneType.BusinessMobile)
contact.PhoneNumbers.Add(pn, PhoneLabels.Cellular, PropertyLabels.Business);
else if (cp.Type == ContactPhone.ContactPhoneType.Mobile)
contact.PhoneNumbers.Add(pn, PhoneLabels.Cellular);
else if (cp.Type == ContactPhone.ContactPhoneType.Personal)
contact.PhoneNumbers.Add(pn, PhoneLabels.Voice, PropertyLabels.Personal);
else if (cp.Type == ContactPhone.ContactPhoneType.Personal2)
contact.PhoneNumbers.Add(pn, PhoneLabels.Voice, PropertyLabels.Personal);
else if (cp.Type == ContactPhone.ContactPhoneType.Other)
contact.PhoneNumbers.Add(pn, PhoneLabels.Voice);
else if (cp.Type == ContactPhone.ContactPhoneType.OtherFax)
contact.PhoneNumbers.Add(pn, PhoneLabels.Fax);
else if (cp.Type == ContactPhone.ContactPhoneType.Fax)
contact.PhoneNumbers.Add(pn, PhoneLabels.Fax);
else
contact.PhoneNumbers.Add(pn);
}
if (c.Resource.WindowsLiveId != null && c.Resource.WindowsLiveId.Trim() != null)
contact.EmailAddresses.Add(new EmailAddress(c.Resource.WindowsLiveId, "Windows Live ID"), PropertyLabels.Preferred);
foreach (ContactEmail ce in c.Resource.Emails)
{
EmailAddress ea = new EmailAddress(ce.Value);
if (ce.Type == ContactEmail.ContactEmailType.Personal)
contact.EmailAddresses.Add(ea, PropertyLabels.Personal);
else if (ce.Type == ContactEmail.ContactEmailType.Business)
contact.EmailAddresses.Add(ea, PropertyLabels.Business);
else if (ce.Type == ContactEmail.ContactEmailType.Other)
contact.EmailAddresses.Add(ea);
else
contact.EmailAddresses.Add(ea);
}
DateTime lastChanged = c.Resource.LastUpdatedTime.DateTime.ToUniversalTime();
contact.Dates.Add(lastChanged, "LastModificationTime");
string absoluteUri = c.Resource.Id;
Guid guid = new Guid(absoluteUri.PadLeft(32, '0'));
contact.ContactIds.Add(guid, "Live");
return contact;
}
public Contact(string name, PhoneNumber phoneNumber, EmailAddress emailAddress)
{
Guard.ArgumentNotNullOrEmpty(() => name, name);
Guard.ArgumentNotNull(() => phoneNumber, phoneNumber);
Guard.ArgumentNotNull(() => emailAddress, emailAddress);
Name = name;
Telephone = phoneNumber;
Email = emailAddress;
}
private void btAddPhoneNumber_Click(object sender, EventArgs e)
{
if (tbEditNumber.Text == "")
{
return;
}
PhoneNumber newNumber = new PhoneNumber(tbEditNumber.Text, lbLabels.SelectedItem.ToString());
lbNumbers.Items.Add(newNumber.ToString());
tbEditNumber.Text = "";
}
public CallInformation(GeoInformation geoInformation, DateTime callStartTime, PhoneNumber sourcePhoneNumber, PhoneNumber destinationPhoneNumber)
{
Check.AgainstNull(geoInformation, "Call information should include geographical information.");
Check.AgainstNull(sourcePhoneNumber, "Call information should include a source phone number.");
Check.AgainstNull(destinationPhoneNumber, "Call information should include a destination phone number.");
Check.That(()=>!sourcePhoneNumber.Equals(destinationPhoneNumber), "Calling yourself is not allowed.");
GeoInformation = geoInformation;
CallStartTime = callStartTime;
SourcePhoneNumber = sourcePhoneNumber;
DestinationPhoneNumber = destinationPhoneNumber;
}
///<summary>Converts a DataTable to a list of objects.</summary>
public static List<PhoneNumber> TableToList(DataTable table){
List<PhoneNumber> retVal=new List<PhoneNumber>();
PhoneNumber phoneNumber;
for(int i=0;i<table.Rows.Count;i++) {
phoneNumber=new PhoneNumber();
phoneNumber.PhoneNumberNum= PIn.Long (table.Rows[i]["PhoneNumberNum"].ToString());
phoneNumber.PatNum = PIn.Long (table.Rows[i]["PatNum"].ToString());
phoneNumber.PhoneNumberVal= PIn.String(table.Rows[i]["PhoneNumberVal"].ToString());
retVal.Add(phoneNumber);
}
return retVal;
}
/// <summary>
/// Handles the Click event of the lbSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void lbSave_Click(object sender, EventArgs e)
{
var rockContext = new RockContext();
rockContext.WrapTransaction(() =>
{
var personService = new PersonService(rockContext);
var changes = new List <string>();
Person business = null;
if (int.Parse(hfBusinessId.Value) != 0)
{
business = personService.Get(int.Parse(hfBusinessId.Value));
}
if (business == null)
{
business = new Person();
personService.Add(business);
tbBusinessName.Text = tbBusinessName.Text.FixCase();
}
// Business Name
History.EvaluateChange(changes, "Last Name", business.LastName, tbBusinessName.Text);
business.LastName = tbBusinessName.Text;
// Phone Number
var businessPhoneTypeId = new DefinedValueService(rockContext).GetByGuid(new Guid(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_WORK)).Id;
string oldPhoneNumber = string.Empty;
string newPhoneNumber = string.Empty;
var phoneNumber = business.PhoneNumbers.FirstOrDefault(n => n.NumberTypeValueId == businessPhoneTypeId);
if (phoneNumber != null)
{
oldPhoneNumber = phoneNumber.NumberFormattedWithCountryCode;
}
if (!string.IsNullOrWhiteSpace(PhoneNumber.CleanNumber(pnbPhone.Number)))
{
if (phoneNumber == null)
{
phoneNumber = new PhoneNumber {
NumberTypeValueId = businessPhoneTypeId
};
business.PhoneNumbers.Add(phoneNumber);
}
phoneNumber.CountryCode = PhoneNumber.CleanNumber(pnbPhone.CountryCode);
phoneNumber.Number = PhoneNumber.CleanNumber(pnbPhone.Number);
phoneNumber.IsMessagingEnabled = cbSms.Checked;
phoneNumber.IsUnlisted = cbUnlisted.Checked;
newPhoneNumber = phoneNumber.NumberFormattedWithCountryCode;
}
else
{
if (phoneNumber != null)
{
business.PhoneNumbers.Remove(phoneNumber);
new PhoneNumberService(rockContext).Delete(phoneNumber);
}
}
History.EvaluateChange(
changes,
string.Format("{0} Phone", DefinedValueCache.GetName(businessPhoneTypeId)),
oldPhoneNumber,
newPhoneNumber);
// Record Type - this is always "business". it will never change.
business.RecordTypeValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_BUSINESS.AsGuid()).Id;
// Record Status
int?newRecordStatusId = ddlRecordStatus.SelectedValueAsInt();
History.EvaluateChange(changes, "Record Status", DefinedValueCache.GetName(business.RecordStatusValueId), DefinedValueCache.GetName(newRecordStatusId));
business.RecordStatusValueId = newRecordStatusId;
// Record Status Reason
int?newRecordStatusReasonId = null;
if (business.RecordStatusValueId.HasValue && business.RecordStatusValueId.Value == DefinedValueCache.Read(new Guid(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE)).Id)
{
newRecordStatusReasonId = ddlReason.SelectedValueAsInt();
}
History.EvaluateChange(changes, "Record Status Reason", DefinedValueCache.GetName(business.RecordStatusReasonValueId), DefinedValueCache.GetName(newRecordStatusReasonId));
business.RecordStatusReasonValueId = newRecordStatusReasonId;
// Email
business.IsEmailActive = true;
History.EvaluateChange(changes, "Email", business.Email, tbEmail.Text);
business.Email = tbEmail.Text.Trim();
var newEmailPreference = rblEmailPreference.SelectedValue.ConvertToEnum <EmailPreference>();
History.EvaluateChange(changes, "EmailPreference", business.EmailPreference, newEmailPreference);
business.EmailPreference = newEmailPreference;
if (business.IsValid)
{
if (rockContext.SaveChanges() > 0)
{
if (changes.Any())
{
HistoryService.SaveChanges(
rockContext,
typeof(Person),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
business.Id,
changes);
}
}
}
// Add/Update Family Group
var familyGroupType = GroupTypeCache.GetFamilyGroupType();
int adultRoleId = familyGroupType.Roles
.Where(r => r.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid()))
.Select(r => r.Id)
.FirstOrDefault();
var adultFamilyMember = UpdateGroupMember(business.Id, familyGroupType, business.LastName + " Business", ddlCampus.SelectedValueAsInt(), adultRoleId, rockContext);
business.GivingGroup = adultFamilyMember.Group;
// Add/Update Known Relationship Group Type
var knownRelationshipGroupType = GroupTypeCache.Read(Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid());
int knownRelationshipOwnerRoleId = knownRelationshipGroupType.Roles
.Where(r => r.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid()))
.Select(r => r.Id)
.FirstOrDefault();
var knownRelationshipOwner = UpdateGroupMember(business.Id, knownRelationshipGroupType, "Known Relationship", null, knownRelationshipOwnerRoleId, rockContext);
// Add/Update Implied Relationship Group Type
var impliedRelationshipGroupType = GroupTypeCache.Read(Rock.SystemGuid.GroupType.GROUPTYPE_IMPLIED_RELATIONSHIPS.AsGuid());
int impliedRelationshipOwnerRoleId = impliedRelationshipGroupType.Roles
.Where(r => r.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_IMPLIED_RELATIONSHIPS_OWNER.AsGuid()))
.Select(r => r.Id)
.FirstOrDefault();
var impliedRelationshipOwner = UpdateGroupMember(business.Id, impliedRelationshipGroupType, "Implied Relationship", null, impliedRelationshipOwnerRoleId, rockContext);
rockContext.SaveChanges();
// Location
int workLocationTypeId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_WORK).Id;
var groupLocationService = new GroupLocationService(rockContext);
var workLocation = groupLocationService.Queryable("Location")
.Where(gl =>
gl.GroupId == adultFamilyMember.Group.Id &&
gl.GroupLocationTypeValueId == workLocationTypeId)
.FirstOrDefault();
if (string.IsNullOrWhiteSpace(acAddress.Street1))
{
if (workLocation != null)
{
groupLocationService.Delete(workLocation);
History.EvaluateChange(changes, "Address", workLocation.Location.ToString(), string.Empty);
}
}
else
{
var oldValue = string.Empty;
var newLocation = new LocationService(rockContext).Get(
acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country);
if (workLocation != null)
{
oldValue = workLocation.Location.ToString();
}
else
{
workLocation = new GroupLocation();
groupLocationService.Add(workLocation);
workLocation.GroupId = adultFamilyMember.Group.Id;
workLocation.GroupLocationTypeValueId = workLocationTypeId;
}
workLocation.Location = newLocation;
workLocation.IsMailingLocation = true;
History.EvaluateChange(changes, "Address", oldValue, newLocation.ToString());
}
rockContext.SaveChanges();
hfBusinessId.Value = business.Id.ToString();
});
var queryParams = new Dictionary <string, string>();
queryParams.Add("businessId", hfBusinessId.Value);
NavigateToCurrentPage(queryParams);
}
private void GetControlData()
{
GroupMembers = new List <GroupMember>();
int?childMaritalStatusId = null;
var childMaritalStatus = DefinedValueCache.Read(GetAttributeValue("ChildMaritalStatus").AsGuid());
if (childMaritalStatus != null)
{
childMaritalStatusId = childMaritalStatus.Id;
}
int?adultMaritalStatusId = ddlMaritalStatus.SelectedValueAsInt();
int recordTypePersonId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id;
int recordStatusActiveId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid()).Id;
foreach (NewGroupMembersRow row in nfmMembers.GroupMemberRows)
{
var groupMember = new GroupMember();
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
groupMember.Person = new Person();
groupMember.Person.Guid = row.PersonGuid.Value;
groupMember.Person.RecordTypeValueId = recordTypePersonId;
groupMember.Person.RecordStatusValueId = recordStatusActiveId;
if (row.RoleId.HasValue)
{
groupMember.GroupRoleId = row.RoleId.Value;
if (_isFamilyGroupType)
{
if (groupMember.GroupRoleId == _childRoleId)
{
groupMember.Person.MaritalStatusValueId = childMaritalStatusId;
}
else
{
groupMember.Person.MaritalStatusValueId = adultMaritalStatusId;
}
}
else
{
groupMember.Person.MaritalStatusValueId = null;
}
}
groupMember.Person.TitleValueId = row.TitleValueId;
groupMember.Person.FirstName = row.FirstName;
if (this.GetAttributeValue("ShowNickName").AsBoolean() && !string.IsNullOrEmpty(row.NickName))
{
groupMember.Person.NickName = row.NickName;
}
else
{
groupMember.Person.NickName = groupMember.Person.FirstName;
}
groupMember.Person.LastName = row.LastName;
groupMember.Person.SuffixValueId = row.SuffixValueId;
groupMember.Person.Gender = row.Gender;
var birthday = row.BirthDate;
if (birthday.HasValue)
{
// If setting a future birthdate, subtract a century until birthdate is not greater than today.
var today = RockDateTime.Today;
while (birthday.Value.CompareTo(today) > 0)
{
birthday = birthday.Value.AddYears(-100);
}
groupMember.Person.BirthMonth = birthday.Value.Month;
groupMember.Person.BirthDay = birthday.Value.Day;
if (birthday.Value.Year != DateTime.MinValue.Year)
{
groupMember.Person.BirthYear = birthday.Value.Year;
}
else
{
groupMember.Person.BirthYear = null;
}
}
else
{
groupMember.Person.SetBirthDate(null);
}
groupMember.Person.ConnectionStatusValueId = row.ConnectionStatusValueId;
if (_isFamilyGroupType)
{
groupMember.Person.GradeOffset = row.GradeOffset;
}
var contactInfoRow = nfciContactInfo.ContactInfoRows.FirstOrDefault(c => c.PersonGuid == row.PersonGuid);
if (contactInfoRow != null)
{
string homeNumber = PhoneNumber.CleanNumber(contactInfoRow.HomePhoneNumber);
if (_homePhone != null && !string.IsNullOrWhiteSpace(homeNumber))
{
var homePhoneNumber = new PhoneNumber();
homePhoneNumber.NumberTypeValueId = _homePhone.Id;
homePhoneNumber.Number = homeNumber;
homePhoneNumber.CountryCode = PhoneNumber.CleanNumber(contactInfoRow.HomePhoneCountryCode);
homePhoneNumber.NumberFormatted = PhoneNumber.FormattedNumber(homePhoneNumber.CountryCode, homeNumber);
groupMember.Person.PhoneNumbers.Add(homePhoneNumber);
}
string cellNumber = PhoneNumber.CleanNumber(contactInfoRow.CellPhoneNumber);
if (_cellPhone != null && !string.IsNullOrWhiteSpace(cellNumber))
{
var cellPhoneNumber = new PhoneNumber();
cellPhoneNumber.NumberTypeValueId = _cellPhone.Id;
cellPhoneNumber.Number = cellNumber;
cellPhoneNumber.CountryCode = PhoneNumber.CleanNumber(contactInfoRow.CellPhoneCountryCode);
cellPhoneNumber.NumberFormatted = PhoneNumber.FormattedNumber(cellPhoneNumber.CountryCode, cellNumber);
cellPhoneNumber.IsMessagingEnabled = contactInfoRow.IsMessagingEnabled;
groupMember.Person.PhoneNumbers.Add(cellPhoneNumber);
}
groupMember.Person.Email = contactInfoRow.Email;
}
groupMember.Person.IsEmailActive = true;
groupMember.Person.EmailPreference = EmailPreference.EmailAllowed;
groupMember.Person.LoadAttributes();
foreach (var attributeControl in attributeControls)
{
var attributeRow = attributeControl.AttributesRows.FirstOrDefault(r => r.PersonGuid == row.PersonGuid);
if (attributeRow != null)
{
attributeRow.GetEditValues(groupMember.Person);
}
}
GroupMembers.Add(groupMember);
}
}
public void Invalid_if_exchange_code_starts_with_0()
{
var phrase = "(223) 056-7890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public void Cleans_numbers_with_dots()
{
var phrase = "223.456.7890";
Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
}
public void Invalid_when_9_digits()
{
var phrase = "123456789";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public void Invalid_with_punctuations()
{
var phrase = "123-@:!-7890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public void InitPhone()
{
_phoneNumber = new PhoneNumber();
}
public async Task TestUpdate_OtherPhoneNumbersPrimary()
{
using (ShimsContext.Create())
{
System.Data.Entity.Fakes.ShimDbContext.AllInstances.SetOf1 <Person>((c) =>
{
return(context.People);
});
var yesterday = DateTimeOffset.Now.AddDays(-1.0);
var user = new User(5);
var phoneNumberId = 10;
Person person = new Person
{
PersonId = 10,
};
Person otherPerson = new Person
{
PersonId = 20
};
PhoneNumberType type = new PhoneNumberType
{
PhoneNumberTypeId = PhoneNumberType.Home.Id,
PhoneNumberTypeName = PhoneNumberType.Home.Value
};
PhoneNumber phoneNumber = null;
PhoneNumber primaryPhone1 = null;
PhoneNumber primaryPhone2 = null;
PhoneNumber otherPersonPrimaryPhoneNumber = null;
var number = "12345";
var ext = "123";
var isPrimary = true;
var updatedPhone = new UpdatedPhoneNumber(user, phoneNumberId, number, ext, type.PhoneNumberTypeId, isPrimary);
Action beforeTester = () =>
{
Assert.IsTrue(primaryPhone1.IsPrimary.Value);
Assert.IsTrue(primaryPhone2.IsPrimary.Value);
};
Action afterTester = () =>
{
Assert.IsTrue(phoneNumber.IsPrimary.Value);
Assert.IsFalse(primaryPhone1.IsPrimary.Value);
Assert.IsFalse(primaryPhone2.IsPrimary.Value);
Assert.IsTrue(otherPersonPrimaryPhoneNumber.IsPrimary.Value);
};
context.SetupActions.Add(() =>
{
otherPersonPrimaryPhoneNumber = new PhoneNumber
{
PhoneNumberId = 100,
IsPrimary = true,
Person = otherPerson,
PersonId = otherPerson.PersonId
};
primaryPhone1 = new PhoneNumber
{
PhoneNumberId = 20,
IsPrimary = true,
Person = person,
PersonId = person.PersonId
};
primaryPhone2 = new PhoneNumber
{
PhoneNumberId = 30,
IsPrimary = true,
Person = person,
PersonId = person.PersonId
};
phoneNumber = new PhoneNumber
{
PhoneNumberId = phoneNumberId,
Person = person,
PersonId = person.PersonId
};
context.PhoneNumbers.Add(phoneNumber);
context.PhoneNumbers.Add(primaryPhone1);
context.PhoneNumbers.Add(primaryPhone2);
context.PhoneNumbers.Add(otherPersonPrimaryPhoneNumber);
context.PhoneNumberTypes.Add(type);
});
context.Revert();
beforeTester();
service.Update(updatedPhone);
afterTester();
context.Revert();
beforeTester();
await service.UpdateAsync(updatedPhone);
afterTester();
}
}
public async Task TestUpdate_Contact_CheckProperties()
{
using (ShimsContext.Create())
{
System.Data.Entity.Fakes.ShimDbContext.AllInstances.SetOf1 <Person>((c) =>
{
return(context.People);
});
var creatorId = 1;
var yesterday = DateTimeOffset.Now.AddDays(-1.0);
var user = new User(5);
var phoneNumberId = 10;
Contact contact = new Contact
{
ContactId = 10,
};
PhoneNumberType type = new PhoneNumberType
{
PhoneNumberTypeId = PhoneNumberType.Home.Id,
PhoneNumberTypeName = PhoneNumberType.Home.Value
};
PhoneNumber phoneNumber = null;
var number = "12345";
var ext = "123";
var isPrimary = true;
var updatedPhone = new UpdatedPhoneNumber(user, phoneNumberId, number, ext, type.PhoneNumberTypeId, isPrimary);
Action afterTester = () =>
{
Assert.AreEqual(1, context.PhoneNumbers.Count());
var firstNumber = context.PhoneNumbers.First();
Assert.AreEqual(number, firstNumber.Number);
Assert.AreEqual(ext, firstNumber.Extension);
Assert.AreEqual(isPrimary, firstNumber.IsPrimary);
Assert.AreEqual(type.PhoneNumberTypeId, firstNumber.PhoneNumberTypeId);
Assert.AreEqual(phoneNumberId, firstNumber.PhoneNumberId);
Assert.AreEqual(creatorId, firstNumber.History.CreatedBy);
Assert.AreEqual(user.Id, firstNumber.History.RevisedBy);
Assert.AreEqual(yesterday, firstNumber.History.CreatedOn);
DateTimeOffset.Now.Should().BeCloseTo(firstNumber.History.RevisedOn, 20000);
};
context.SetupActions.Add(() =>
{
phoneNumber = new PhoneNumber
{
PhoneNumberId = phoneNumberId,
Contact = contact,
ContactId = contact.ContactId
};
phoneNumber.History.CreatedBy = creatorId;
phoneNumber.History.RevisedBy = creatorId;
phoneNumber.History.CreatedOn = yesterday;
phoneNumber.History.RevisedOn = yesterday;
context.PhoneNumbers.Add(phoneNumber);
context.PhoneNumberTypes.Add(type);
});
context.Revert();
service.Update(updatedPhone);
afterTester();
context.Revert();
await service.UpdateAsync(updatedPhone);
afterTester();
}
}
public async Task TestCreate_OtherPhoneNumbersPrimary()
{
using (ShimsContext.Create())
{
System.Data.Entity.Fakes.ShimDbContext.AllInstances.SetOf1 <Person>((c) =>
{
return(context.People);
});
var userId = 1;
var personId = 10;
Person person = null;
var phoneNumberType = new PhoneNumberType
{
PhoneNumberTypeId = PhoneNumberType.Home.Id,
PhoneNumberTypeName = PhoneNumberType.Home.Value
};
PhoneNumber primaryPhone1 = null;
PhoneNumber primaryPhone2 = null;
var user = new User(userId);
var newPhone = new NewPersonPhoneNumber(user, phoneNumberType.PhoneNumberTypeId, "1234", "123", personId, true);
Action beforeTester = () =>
{
Assert.AreEqual(2, context.PhoneNumbers.Count());
Assert.IsTrue(primaryPhone1.IsPrimary.Value);
Assert.IsTrue(primaryPhone2.IsPrimary.Value);
};
Action afterTester = () =>
{
Assert.AreEqual(1, context.People.Count());
Assert.AreEqual(2, context.PhoneNumbers.Count());
//the phone number is added to the person, not the context
Assert.IsTrue(person.PhoneNumbers.First().IsPrimary.Value);
Assert.IsFalse(primaryPhone1.IsPrimary.Value);
Assert.IsFalse(primaryPhone2.IsPrimary.Value);
};
context.SetupActions.Add(() =>
{
person = new Person
{
PersonId = personId
};
primaryPhone1 = new PhoneNumber
{
PhoneNumberId = 10,
IsPrimary = true,
Person = person,
PersonId = person.PersonId
};
primaryPhone2 = new PhoneNumber
{
PhoneNumberId = 20,
IsPrimary = true,
Person = person,
PersonId = person.PersonId
};
context.People.Add(person);
context.PhoneNumbers.Add(primaryPhone1);
context.PhoneNumbers.Add(primaryPhone2);
context.PhoneNumberTypes.Add(phoneNumberType);
});
context.Revert();
beforeTester();
service.Create(newPhone);
afterTester();
context.Revert();
beforeTester();
await service.CreateAsync(newPhone);
afterTester();
}
}
/// <summary>
/// Handles the Click event of the lbLinkConversation control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void lbLinkConversation_Click(object sender, EventArgs e)
{
mdLinkToPerson.Title = string.Format("Link Phone Number {0} to Person ", PhoneNumber.FormattedNumber(PhoneNumber.DefaultCountryCode(), hfSelectedMessageKey.Value, false));
ppPerson.SetValue(null);
newPersonEditor.SetFromPerson(null);
mdLinkToPerson.Show();
}
/// <summary>
/// Loads the phone numbers.
/// </summary>
/// <returns></returns>
private bool LoadPhoneNumbers()
{
// First load up all of the available numbers
var smsNumbers = DefinedTypeCache.Get(Rock.SystemGuid.DefinedType.COMMUNICATION_SMS_FROM.AsGuid()).DefinedValues.Where(a => a.IsAuthorized(Rock.Security.Authorization.VIEW, CurrentPerson));
var selectedNumberGuids = GetAttributeValue(AttributeKey.AllowedSMSNumbers).SplitDelimitedValues(true).AsGuidList();
if (selectedNumberGuids.Any())
{
smsNumbers = smsNumbers.Where(v => selectedNumberGuids.Contains(v.Guid)).ToList();
}
// filter personal numbers (any that have a response recipient) if the hide personal option is enabled
if (GetAttributeValue(AttributeKey.HidePersonalSmsNumbers).AsBoolean())
{
smsNumbers = smsNumbers.Where(v => v.GetAttributeValue("ResponseRecipient").IsNullOrWhiteSpace()).ToList();
}
// Show only numbers 'tied to the current' individual...unless they have 'Admin rights'.
if (GetAttributeValue(AttributeKey.ShowOnlyPersonalSmsNumber).AsBoolean() && !IsUserAuthorized(Authorization.ADMINISTRATE))
{
smsNumbers = smsNumbers.Where(v => CurrentPerson.Aliases.Any(a => a.Guid == v.GetAttributeValue("ResponseRecipient").AsGuid())).ToList();
}
if (smsNumbers.Any())
{
var smsDetails = smsNumbers.Select(v => new
{
v.Id,
Description = string.IsNullOrWhiteSpace(v.Description)
? PhoneNumber.FormattedNumber(string.Empty, v.Value.Replace("+", string.Empty))
: v.Description.LeftWithEllipsis(25),
});
ddlSmsNumbers.DataSource = smsDetails;
ddlSmsNumbers.Visible = smsNumbers.Count() > 1;
ddlSmsNumbers.DataValueField = "Id";
ddlSmsNumbers.DataTextField = "Description";
ddlSmsNumbers.DataBind();
string keyPrefix = string.Format("sms-conversations-{0}-", this.BlockId);
string smsNumberUserPref = this.GetUserPreference(keyPrefix + "smsNumber") ?? string.Empty;
if (smsNumberUserPref.IsNotNullOrWhiteSpace())
{
// Don't try to set the selected value unless you are sure it's in the list of items.
if (ddlSmsNumbers.Items.FindByValue(smsNumberUserPref) != null)
{
ddlSmsNumbers.SelectedValue = smsNumberUserPref;
}
}
hlSmsNumber.Visible = smsNumbers.Count() == 1;
hlSmsNumber.Text = smsDetails.Select(v => v.Description).FirstOrDefault();
hfSmsNumber.SetValue(smsNumbers.Count() > 1 ? ddlSmsNumbers.SelectedValue.AsInteger() : smsDetails.Select(v => v.Id).FirstOrDefault());
tglShowRead.Checked = this.GetUserPreference(keyPrefix + "showRead").AsBooleanOrNull() ?? true;
}
else
{
return(false);
}
return(true);
}
public void Valid_when_11_digits_and_starting_with_1_even_with_punctuation()
{
var phrase = "+1 (223) 456-7890";
Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
}
public void Invalid_when_11_digits_does_not_start_with_a_1()
{
var phrase = "22234567890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public void Invalid_if_area_code_starts_with_1()
{
var phrase = "(123) 456-7890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public bool CanVerifyPhoneNumber()
{
return(SmsVerificationEnabled && !PhoneNumber.IsNullOrEmpty() && !PhoneNumber.Trim().IsNullOrEmpty());
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad(System.EventArgs e)
{
base.OnLoad(e);
pnlMessage.Controls.Clear();
pnlMessage.Visible = false;
PagePanels[0] = phUserInfo;
PagePanels[1] = phDuplicates;
PagePanels[2] = phSendLoginInfo;
PagePanels[3] = phSentLoginInfo;
PagePanels[4] = phConfirmation;
PagePanels[5] = phSuccess;
if (!Page.IsPostBack)
{
DisplayUserInfo(Direction.Forward);
// show/hide address and phone panels
pnlAddress.Visible = GetAttributeValue("ShowAddress").AsBoolean();
pnlPhoneNumbers.Visible = GetAttributeValue("ShowPhoneNumbers").AsBoolean();
acAddress.Required = GetAttributeValue("AddressRequired").AsBoolean();
// set birthday picker required if minimum age > 0
if (GetAttributeValue("MinimumAge").AsInteger() > 0)
{
bdaypBirthDay.Required = true;
}
var phoneNumbers = new List <PhoneNumber>();
// add phone number types
if (pnlPhoneNumbers.Visible)
{
var phoneNumberTypeDefinedType = DefinedTypeCache.Read(new Guid(Rock.SystemGuid.DefinedType.PERSON_PHONE_TYPE));
if (!string.IsNullOrWhiteSpace(GetAttributeValue("PhoneTypes")))
{
var selectedPhoneTypeGuids = GetAttributeValue("PhoneTypes").Split(',').Select(Guid.Parse).ToList();
var selectedPhoneTypes = phoneNumberTypeDefinedType.DefinedValues
.Where(v => selectedPhoneTypeGuids.Contains(v.Guid))
.ToList();
foreach (var phoneNumberType in selectedPhoneTypes)
{
var numberType = new DefinedValue();
numberType.Id = phoneNumberType.Id;
numberType.Value = phoneNumberType.Value;
numberType.Guid = phoneNumberType.Guid;
var phoneNumber = new PhoneNumber {
NumberTypeValueId = numberType.Id, NumberTypeValue = numberType
};
phoneNumbers.Add(phoneNumber);
}
if (!string.IsNullOrWhiteSpace(GetAttributeValue("PhoneTypesRequired")))
{
_RequiredPhoneNumberGuids = GetAttributeValue("PhoneTypesRequired").Split(',').Select(Guid.Parse).ToList();
}
rPhoneNumbers.DataSource = phoneNumbers;
rPhoneNumbers.DataBind();
}
}
}
}
/// <summary>
/// Creates the person.
/// </summary>
/// <returns></returns>
private Person CreatePerson()
{
var rockContext = new RockContext();
DefinedValueCache dvcConnectionStatus = DefinedValueCache.Read(GetAttributeValue("ConnectionStatus").AsGuid());
DefinedValueCache dvcRecordStatus = DefinedValueCache.Read(GetAttributeValue("RecordStatus").AsGuid());
Person person = new Person();
person.FirstName = tbFirstName.Text;
person.LastName = tbLastName.Text;
person.Email = tbEmail.Text;
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id;
if (dvcConnectionStatus != null)
{
person.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if (dvcRecordStatus != null)
{
person.RecordStatusValueId = dvcRecordStatus.Id;
}
switch (ddlGender.SelectedValue)
{
case "M":
person.Gender = Gender.Male;
break;
case "F":
person.Gender = Gender.Female;
break;
default:
person.Gender = Gender.Unknown;
break;
}
var birthday = bdaypBirthDay.SelectedDate;
if (birthday.HasValue)
{
person.BirthMonth = birthday.Value.Month;
person.BirthDay = birthday.Value.Day;
if (birthday.Value.Year != DateTime.MinValue.Year)
{
person.BirthYear = birthday.Value.Year;
}
}
bool smsSelected = false;
foreach (RepeaterItem item in rPhoneNumbers.Items)
{
HiddenField hfPhoneType = item.FindControl("hfPhoneType") as HiddenField;
PhoneNumberBox pnbPhone = item.FindControl("pnbPhone") as PhoneNumberBox;
CheckBox cbUnlisted = item.FindControl("cbUnlisted") as CheckBox;
CheckBox cbSms = item.FindControl("cbSms") as CheckBox;
if (!string.IsNullOrWhiteSpace(PhoneNumber.CleanNumber(pnbPhone.Number)))
{
int phoneNumberTypeId;
if (int.TryParse(hfPhoneType.Value, out phoneNumberTypeId))
{
var phoneNumber = new PhoneNumber {
NumberTypeValueId = phoneNumberTypeId
};
person.PhoneNumbers.Add(phoneNumber);
phoneNumber.CountryCode = PhoneNumber.CleanNumber(pnbPhone.CountryCode);
phoneNumber.Number = PhoneNumber.CleanNumber(pnbPhone.Number);
// Only allow one number to have SMS selected
if (smsSelected)
{
phoneNumber.IsMessagingEnabled = false;
}
else
{
phoneNumber.IsMessagingEnabled = cbSms.Checked;
smsSelected = cbSms.Checked;
}
phoneNumber.IsUnlisted = cbUnlisted.Checked;
}
}
}
PersonService.SaveNewPerson(person, rockContext, null, false);
// save address
if (pnlAddress.Visible)
{
if (acAddress.IsValid && !string.IsNullOrWhiteSpace(acAddress.Street1) && !string.IsNullOrWhiteSpace(acAddress.City) && !string.IsNullOrWhiteSpace(acAddress.PostalCode))
{
Guid locationTypeGuid = GetAttributeValue("LocationType").AsGuid();
if (locationTypeGuid != Guid.Empty)
{
Guid familyGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
GroupService groupService = new GroupService(rockContext);
GroupLocationService groupLocationService = new GroupLocationService(rockContext);
var family = groupService.Queryable().Where(g => g.GroupType.Guid == familyGroupTypeGuid && g.Members.Any(m => m.PersonId == person.Id)).FirstOrDefault();
var groupLocation = new GroupLocation();
groupLocation.GroupId = family.Id;
groupLocationService.Add(groupLocation);
var location = new LocationService(rockContext).Get(acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country);
groupLocation.Location = location;
groupLocation.GroupLocationTypeValueId = DefinedValueCache.Read(locationTypeGuid).Id;
groupLocation.IsMailingLocation = true;
groupLocation.IsMappedLocation = true;
rockContext.SaveChanges();
}
}
}
return(person);
}
public void Cleans_numbers_with_multiple_spaces()
{
var phrase = "223 456 7890 ";
Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
}
private void LoadMessage(Dictionary <string, IConversation> conversationHashTable, TextMessage message, ILoadingProgressCallback progressCallback)
{
CheckForCancel(progressCallback);
string conversationKey;
PhoneNumber messagePhoneNumber = new PhoneNumber(message.Address, message.Country);
string phoneNumberStripped = PhoneNumber.Strip(messagePhoneNumber);
if (message.ChatId != null)
{
conversationKey = message.ChatId;
}
else
{
conversationKey = phoneNumberStripped;
}
if (string.IsNullOrEmpty(conversationKey))
{
return;
}
Contact unknownContact = new Contact(Contact.UnknownContactId, null, null, null, messagePhoneNumber);
message.Contact = GetContactByPhoneNumber(messagePhoneNumber);
if (message.Contact == null)
{
message.Contact = unknownContact;
}
else
{
//
// Update the contact's phone number to include country information.
//
foreach (PhoneNumber contactPhoneNumber in message.Contact.PhoneNumbers)
{
if (PhoneNumber.NumbersAreEquivalent(contactPhoneNumber, messagePhoneNumber))
{
contactPhoneNumber.Country = message.Country;
break;
}
}
}
IConversation conversation;
if (conversationHashTable.ContainsKey(conversationKey))
{
conversation = conversationHashTable[conversationKey];
// If The contact is not part of the conversation, add them here. This can happen with "orphaned" chat
// messages.
if (!message.Contact.Equals(unknownContact) && !conversation.AssociatedContacts.Contains(message.Contact))
{
conversation.AssociatedContacts.Add(message.Contact);
}
}
else if (message.ChatId != null)
{
// It's possible to have "orphaned" chat messages, where they appear in the message database with a chat ID
// but the chat ID was not in the chat room database. Handle those here.
List <IContact> chatContacts = new List <IContact>();
if (!message.Contact.Equals(unknownContact))
{
chatContacts.Add(message.Contact);
}
conversation = new ChatConversation(chatContacts);
conversationHashTable.Add(message.ChatId, conversation);
}
else
{
conversation = new SingleNumberConversation(unknownContact);
conversationHashTable.Add(conversationKey, conversation);
}
_messageLookupTable.Add(message.MessageId, message);
conversation.AddMessage(message);
IncrementWorkProgress(progressCallback);
}
public void Invalid_if_exchange_code_starts_with_1_on_valid_11_digit_number()
{
var phrase = "1 (223) 156-7890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public void Invalid_with_letters()
{
var phrase = "123-abc-7890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
public void Cleans_the_number()
{
var phrase = "(223) 456-7890";
Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
}
// Do NOT do this in practices, have a separate create for phone numbers.
// The only reason I did this is we scaffolded the phone number table and I didn't want to cause conflicts.
public int CreatePerson(string firstName, string lastName, string phone)
{
firstName = firstName != null?firstName.Trim() : null;
lastName = lastName != null?lastName.Trim() : null;
phone = phone != null?phone.Trim() : null;
int createdID;
PersonValidationException exception = new PersonValidationException();
// Be a little more specific than "== null" because that doesn't account for whitespace.
if (string.IsNullOrWhiteSpace(firstName))
{
exception.SubExceptions.Add(new ArgumentNullException(nameof(firstName), "First name was not provided."));
}
else
{
if (firstName.Any(x => char.IsDigit(x)))
{
exception.SubExceptions.Add(new ArgumentException(nameof(firstName), "First name cannot contain numbers."));
}
if (firstName.Length > 50)
{
exception.SubExceptions.Add(new ArgumentOutOfRangeException(nameof(firstName), "First name cannot be more than 50 characters long."));
}
}
if (string.IsNullOrWhiteSpace(lastName))
{
exception.SubExceptions.Add(new ArgumentNullException(nameof(lastName), "Last name was not provided."));
}
else
{
if (lastName.Any(x => char.IsDigit(x)))
{
exception.SubExceptions.Add(new ArgumentException(nameof(lastName), "Last name cannot contain numbers."));
}
if (lastName.Length > 50)
{
exception.SubExceptions.Add(new ArgumentOutOfRangeException(nameof(lastName), "Last name cannot be more than 50 characters long."));
}
}
if (string.IsNullOrWhiteSpace(phone))
{
exception.SubExceptions.Add(new ArgumentNullException(nameof(phone), "Phone number was not provided."));
}
else
{
// Check for phone number formatting (feel free to use RegEx or any other method).
// Has to be in the else branch to avoid null reference exceptions.
int temp;
string[] phoneParts = phone.Split('-');
if (!(
phoneParts[0].Length == 3 &&
int.TryParse(phoneParts[0], out temp) &&
phoneParts[1].Length == 3 &&
int.TryParse(phoneParts[1], out temp) &&
phoneParts[2].Length == 4 &&
int.TryParse(phoneParts[2], out temp)
))
{
exception.SubExceptions.Add(new ArgumentException(nameof(phone), "Phone number was not in a valid format."));
}
}
// If any exceptions have been generated by any validation, throw them as one bundled exception.
if (exception.SubExceptions.Count > 0)
{
throw exception;
}
// If we're at this point, we have no exceptions, as nothing got thrown.
// At this point, ID is 0.
Person newPerson = new Person()
{
FirstName = firstName,
LastName = lastName
};
PhoneNumber newPhoneNumber = new PhoneNumber()
{
Number = phone,
Person = newPerson
};
// Add the new model instances to the database.
using (PersonContext context = new PersonContext())
{
// By adding our object to the context, we're queueing it to receive an AUTO_INCREMENT ID once saved.
context.People.Add(newPerson);
context.PhoneNumbers.Add(newPhoneNumber);
// When we save it, the object and all references thereto are updated with the new ID.
context.SaveChanges();
// Which makes it very simple to then get the new ID to return.
createdID = newPerson.ID;
}
return(createdID);
}
private void CreateControls(bool setSelection)
{
// Load all the attribute controls
attributeControls.Clear();
pnlAttributes.Controls.Clear();
phDuplicates.Controls.Clear();
var rockContext = new RockContext();
var attributeService = new AttributeService(rockContext);
var locationService = new LocationService(rockContext);
foreach (string categoryGuid in GetAttributeValue("AttributeCategories").SplitDelimitedValues(false))
{
Guid guid = Guid.Empty;
if (Guid.TryParse(categoryGuid, out guid))
{
var category = CategoryCache.Read(guid);
if (category != null)
{
var attributeControl = new NewGroupAttributes();
attributeControl.ClearRows();
pnlAttributes.Controls.Add(attributeControl);
attributeControls.Add(attributeControl);
attributeControl.ID = "groupAttributes_" + category.Id.ToString();
attributeControl.CategoryId = category.Id;
foreach (var attribute in attributeService.GetByCategoryId(category.Id))
{
if (attribute.IsAuthorized(Authorization.EDIT, CurrentPerson))
{
attributeControl.AttributeList.Add(AttributeCache.Read(attribute));
}
}
}
}
}
nfmMembers.ClearRows();
nfciContactInfo.ClearRows();
var groupMemberService = new GroupMemberService(rockContext);
int defaultRoleId = _groupType.DefaultGroupRoleId ?? _groupType.Roles.Select(r => r.Id).FirstOrDefault();
var location = new Location();
acAddress.GetValues(location);
foreach (var groupMember in GroupMembers)
{
string groupMemberGuidString = groupMember.Person.Guid.ToString().Replace("-", "_");
var groupMemberRow = new NewGroupMembersRow();
groupMemberRow.GroupTypeId = _groupType.Id;
nfmMembers.Controls.Add(groupMemberRow);
groupMemberRow.ID = string.Format("row_{0}", groupMemberGuidString);
groupMemberRow.RoleUpdated += groupMemberRow_RoleUpdated;
groupMemberRow.DeleteClick += groupMemberRow_DeleteClick;
groupMemberRow.PersonGuid = groupMember.Person.Guid;
groupMemberRow.RequireGender = nfmMembers.RequireGender;
groupMemberRow.RequireGrade = nfmMembers.RequireGrade;
groupMemberRow.RoleId = groupMember.GroupRoleId;
groupMemberRow.ShowGradeColumn = _isFamilyGroupType;
groupMemberRow.ShowGradePicker = groupMember.GroupRoleId == _childRoleId;
groupMemberRow.ShowNickName = this.GetAttributeValue("ShowNickName").AsBoolean();
groupMemberRow.ValidationGroup = BlockValidationGroup;
var contactInfoRow = new NewGroupContactInfoRow();
nfciContactInfo.Controls.Add(contactInfoRow);
contactInfoRow.ID = string.Format("ci_row_{0}", groupMemberGuidString);
contactInfoRow.PersonGuid = groupMember.Person.Guid;
contactInfoRow.IsMessagingEnabled = _SMSEnabled;
contactInfoRow.PersonName = groupMember.Person.FullName;
if (_homePhone != null)
{
var homePhoneNumber = groupMember.Person.PhoneNumbers.Where(p => p.NumberTypeValueId == _homePhone.Id).FirstOrDefault();
if (homePhoneNumber != null)
{
contactInfoRow.HomePhoneNumber = PhoneNumber.FormattedNumber(homePhoneNumber.CountryCode, homePhoneNumber.Number);
contactInfoRow.HomePhoneCountryCode = homePhoneNumber.CountryCode;
}
else
{
contactInfoRow.HomePhoneNumber = string.Empty;
contactInfoRow.HomePhoneCountryCode = string.Empty;
}
}
if (_cellPhone != null)
{
var cellPhoneNumber = groupMember.Person.PhoneNumbers.Where(p => p.NumberTypeValueId == _cellPhone.Id).FirstOrDefault();
if (cellPhoneNumber != null)
{
contactInfoRow.CellPhoneNumber = PhoneNumber.FormattedNumber(cellPhoneNumber.CountryCode, cellPhoneNumber.Number);
contactInfoRow.CellPhoneCountryCode = cellPhoneNumber.CountryCode;
}
else
{
contactInfoRow.CellPhoneNumber = string.Empty;
contactInfoRow.CellPhoneCountryCode = string.Empty;
}
}
contactInfoRow.Email = groupMember.Person.Email;
if (setSelection)
{
if (groupMember.Person != null)
{
groupMemberRow.TitleValueId = groupMember.Person.TitleValueId;
groupMemberRow.FirstName = groupMember.Person.FirstName;
groupMemberRow.NickName = groupMember.Person.NickName;
groupMemberRow.LastName = groupMember.Person.LastName;
groupMemberRow.SuffixValueId = groupMember.Person.SuffixValueId;
groupMemberRow.Gender = groupMember.Person.Gender;
groupMemberRow.BirthDate = groupMember.Person.BirthDate;
groupMemberRow.ConnectionStatusValueId = groupMember.Person.ConnectionStatusValueId;
groupMemberRow.GradeOffset = groupMember.Person.GradeOffset;
}
}
foreach (var attributeControl in attributeControls)
{
var attributeRow = new NewGroupAttributesRow();
attributeControl.Controls.Add(attributeRow);
attributeRow.ID = string.Format("{0}_{1}", attributeControl.ID, groupMemberGuidString);
attributeRow.AttributeList = attributeControl.AttributeList;
attributeRow.PersonGuid = groupMember.Person.Guid;
attributeRow.PersonName = groupMember.Person.FullName;
if (setSelection)
{
attributeRow.SetEditValues(groupMember.Person);
}
}
if (Duplicates.ContainsKey(groupMember.Person.Guid))
{
var dupRow = new HtmlGenericControl("div");
dupRow.AddCssClass("row");
dupRow.ID = string.Format("dupRow_{0}", groupMemberGuidString);
phDuplicates.Controls.Add(dupRow);
var newPersonCol = new HtmlGenericControl("div");
newPersonCol.AddCssClass("col-md-6");
newPersonCol.ID = string.Format("newPersonCol_{0}", groupMemberGuidString);
dupRow.Controls.Add(newPersonCol);
newPersonCol.Controls.Add(PersonHtmlPanel(
groupMemberGuidString,
groupMember.Person,
groupMember.GroupRole,
location,
rockContext));
LinkButton lbRemoveMember = new LinkButton();
lbRemoveMember.ID = string.Format("lbRemoveMember_{0}", groupMemberGuidString);
lbRemoveMember.AddCssClass("btn btn-danger btn-xs");
lbRemoveMember.Text = "Remove";
lbRemoveMember.Click += lbRemoveMember_Click;
newPersonCol.Controls.Add(lbRemoveMember);
var dupPersonCol = new HtmlGenericControl("div");
dupPersonCol.AddCssClass("col-md-6");
dupPersonCol.ID = string.Format("dupPersonCol_{0}", groupMemberGuidString);
dupRow.Controls.Add(dupPersonCol);
var duplicateHeader = new HtmlGenericControl("h4");
duplicateHeader.InnerText = "Possible Duplicate Records";
dupPersonCol.Controls.Add(duplicateHeader);
foreach (var duplicate in Duplicates[groupMember.Person.Guid])
{
GroupTypeRole groupTypeRole = null;
Location duplocation = null;
var dupGroupMember = groupMemberService.Queryable()
.Where(a => a.PersonId == duplicate.Id)
.Where(a => a.Group.GroupTypeId == _groupType.Id)
.Select(s => new
{
s.GroupRole,
GroupLocation = s.Group.GroupLocations.Where(a => a.GroupLocationTypeValue.Guid.Equals(_locationType.Guid)).Select(a => a.Location).FirstOrDefault()
})
.FirstOrDefault();
if (dupGroupMember != null)
{
groupTypeRole = dupGroupMember.GroupRole;
duplocation = dupGroupMember.GroupLocation;
}
dupPersonCol.Controls.Add(PersonHtmlPanel(
groupMemberGuidString,
duplicate,
groupTypeRole,
duplocation,
rockContext));
}
}
}
ShowPage();
}
public void Valid_when_11_digits_and_starting_with_1()
{
var phrase = "12234567890";
Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
}
static void Main(string[] args)
{
int choose, chooseRegistration, chooseAutohrization;
bool isRegistrationMenu = true, isAutohorizationOk = true;
string nameUser, firstNameUser, emailUser, numberUser, passwordUser, checkName, checkPassword;
bool isNameOk = true, isFirstNameOk = true, isEmailOk = false, isNumberOk = true, isPasswordOk = true;
bool isCheckingPasswordOk = false, isCheckingNameOk = false;
User user = new User();
//цикл с меню
//3 кейса
//1 кейс выводит менюшку где надо выйти назад (все в цикле)
//2 кейс выведет менюшку с циклом так же где нужно выйти
while (true)
{
Console.SetCursorPosition(0, 0);
Console.WriteLine("1 - Регистрация");
Console.WriteLine("2 - Войти");
Console.WriteLine("3 - Выход");
int.TryParse(Console.ReadLine(), out choose);
switch (choose)
{
case 1:
isRegistrationMenu = true;
while (isRegistrationMenu)
{
Console.Clear();
Console.SetCursorPosition(0, 0);
Console.WriteLine("1 - Имя");
Console.WriteLine("2 - Фамилия");
Console.WriteLine("3 - Email");
Console.WriteLine("4 - Номер телефона");
Console.WriteLine("5 - Пароль");
Console.WriteLine("6 - Назад");
int.TryParse(Console.ReadLine(), out chooseRegistration);
switch (chooseRegistration)
{
case 1:
isNameOk = true;
Console.WriteLine("Введите ваше имя ");
nameUser = Console.ReadLine();
for (int i = 0; i < nameUser.Length; i++)
{
if (nameUser[i] >= '0' && nameUser[i] <= '9')
{
isNameOk = false;
break;
}
}
if (isNameOk)
{
user.SetName(nameUser);
Console.WriteLine("Ваше имя зарегистрированно");
}
else
{
Console.WriteLine("Вы ввели неверное имя,попробуйте еще раз");
}
Console.ReadLine();
Console.Clear();
break;
case 2:
isFirstNameOk = true;
Console.WriteLine("Введите вашу фамилию ");
firstNameUser = Console.ReadLine();
for (int i = 0; i < firstNameUser.Length; i++)
{
if (firstNameUser[i] >= '0' && firstNameUser[i] <= '9')
{
isFirstNameOk = false;
break;
}
}
if (isFirstNameOk)
{
user.SetFirstNAme(firstNameUser);
Console.WriteLine("Ваша фамилия зарегистрированно");
}
else
{
Console.WriteLine("Вы ввели неверную фамилию,попробуйте еще раз");
}
Console.ReadLine();
Console.Clear();
break;
case 3:
isEmailOk = false;
Console.WriteLine("Введите ваш Эмайл ");
emailUser = Console.ReadLine();
for (int i = 0; i < emailUser.Length; i++)
{
if (emailUser[i] == '@')
{
isEmailOk = true;
break;
}
}
if (isEmailOk)
{
user.SetEmail(emailUser);
Console.WriteLine("Ваш Email зарегистрирован");
}
else
{
Console.WriteLine("Вы ввели неверный Email,попробуйте еще раз");
}
Console.ReadLine();
Console.Clear();
break;
case 4:
Console.WriteLine("Введите ваш Телефон ");
numberUser = Console.ReadLine();
for (int i = 0; i < numberUser.Length; i++)
{
if (numberUser[i] >= '0' && numberUser[i] <= '9')
{
isNumberOk = true;
}
else
{
isNumberOk = false;
break;
}
}
if (isNumberOk)
{
user.SetNumber(numberUser);
Console.WriteLine("Ваш Телефон зарегистрирован");
}
else
{
Console.WriteLine("Вы ввели неверный Телефон,попробуйте еще раз");
}
Console.ReadLine();
Console.Clear();
break;
case 5:
isPasswordOk = true;
Console.WriteLine("Введите ваш пароль ");
passwordUser = Console.ReadLine();
if (passwordUser.Length == 0)
{
isPasswordOk = false;
}
for (int i = 0; i < passwordUser.Length; i++)
{
if (passwordUser[i] == ' ')
{
isPasswordOk = false;
break;
}
}
if (isPasswordOk)
{
user.SetPassword(passwordUser);
Console.WriteLine("Ваш пароль зарегистрирован");
}
else
{
Console.WriteLine("Вы ввели неправильный пароль");
}
Console.ReadLine();
Console.Clear();
break;
case 6:
isRegistrationMenu = false;
break;
}
}
Console.Clear();
break;
case 2:
if (isEmailOk && isFirstNameOk && isNameOk && isNumberOk && isPasswordOk)
{
isAutohorizationOk = true;
while (isAutohorizationOk)
{
Console.Clear();
Console.SetCursorPosition(0, 0);
Console.WriteLine("1 - Авторизация");
Console.WriteLine("2 - Вспомнить пароль");
Console.WriteLine("3 - Назад");
int.TryParse(Console.ReadLine(), out chooseAutohrization);
switch (chooseAutohrization)
{
case 1:
Console.WriteLine("Введите Email или номер телефона");
checkName = Console.ReadLine();
if ((checkName == user.GetName()) || (checkName == user.GetNumber()))
{
isCheckingNameOk = true;
}
Console.WriteLine("Введите пароль");
checkPassword = Console.ReadLine();
if (checkPassword == user.GetPassword())
{
isCheckingPasswordOk = true;
}
if (isCheckingNameOk && isCheckingPasswordOk)
{
Console.WriteLine("Вы вошли");
}
else
{
Console.WriteLine("Вы ввели неправильный логин или пароль");
}
Console.ReadLine();
Console.Clear();
break;
case 2:
Console.WriteLine("Введите ваш Email");
checkName = Console.ReadLine();
const string accountSid = "ACa3a0aa93822680c0df0f954abfaa5010";
const string authToken = "660eefc858c608383d38fac4633279d3";
TwilioClient.Init(accountSid, authToken);
var mediaUrl = new List <System.Uri>()
{
new Uri("https://climacons.herokuapp.com/clear.png")
};
var to = new PhoneNumber("+77779561787");
var message = MessageResource.Create(
to,
from: new PhoneNumber("+18317049551"),
body: user.GetPassword(),
mediaUrl: mediaUrl);
Console.WriteLine(message.Sid);
break;
case 3:
isAutohorizationOk = false;
break;
}
}
}
else
{
Console.WriteLine("Вы не прошли регистрацию до конца");
}
Console.ReadLine();
Console.Clear();
break;
case 3:
Environment.Exit(0);
break;
}
}
}
public void UpdateUser(Chat chat, User user, bool secret)
{
Subtitle.Text = LastSeenConverter.GetLabel(user, true);
SubtitleInfo.Text = Subtitle.Text;
Verified.Visibility = user.IsVerified ? Visibility.Visible : Visibility.Collapsed;
UserPhone.Badge = PhoneNumber.Format(user.PhoneNumber);
UserPhone.Visibility = string.IsNullOrEmpty(user.PhoneNumber) ? Visibility.Collapsed : Visibility.Visible;
Username.Badge = $"{user.Username}";
Username.Visibility = string.IsNullOrEmpty(user.Username) ? Visibility.Collapsed : Visibility.Visible;
DescriptionTitle.Text = user.Type is UserTypeBot ? Strings.Resources.DescriptionPlaceholder : Strings.Resources.UserBio;
if (user.Id == ViewModel.CacheService.Options.MyId)
{
NotificationsPanel.Visibility = Visibility.Collapsed;
}
else
{
NotificationsPanel.Visibility = Visibility.Visible;
}
if (secret)
{
UserStartSecret.Visibility = Visibility.Collapsed;
}
else
{
if (user.Type is UserTypeBot ||
user.Id == ViewModel.CacheService.Options.MyId ||
LastSeenConverter.IsServiceUser(user) ||
LastSeenConverter.IsSupportUser(user))
{
MiscPanel.Visibility = Visibility.Collapsed;
UserStartSecret.Visibility = Visibility.Collapsed;
}
else
{
MiscPanel.Visibility = Visibility.Visible;
UserStartSecret.Visibility = Visibility.Visible;
}
SecretLifetime.Visibility = Visibility.Collapsed;
SecretHashKey.Visibility = Visibility.Collapsed;
}
// Unused:
Location.Visibility = Visibility.Collapsed;
GroupLeave.Visibility = Visibility.Collapsed;
GroupInvite.Visibility = Visibility.Collapsed;
ChannelMembersPanel.Visibility = Visibility.Collapsed;
MembersPanel.Visibility = Visibility.Collapsed;
//Admins.Visibility = Visibility.Collapsed;
//Banned.Visibility = Visibility.Collapsed;
//Restricted.Visibility = Visibility.Collapsed;
//Members.Visibility = Visibility.Collapsed;
}
public ActionResult Outbound([FromBody] OutboundRequest outboundRequest)
{
var modelErrors = new List <string>();
OutboundResponse outboundResponse = new OutboundResponse();
CacheHandler cacheHandler = new CacheHandler();
var request = Request;
var headers = request.Headers;
headers.TryGetValue("Authorization", out authorizationToken);
string token = authorizationToken.FirstOrDefault().Substring("Basic ".Length).Trim();
string userName = token.Split(':')[0];
string authId = token.Split(':')[1];
try
{
if (!ModelState.IsValid)
{
foreach (var modelState in ModelState.Values)
{
foreach (var modelError in modelState.Errors)
{
modelErrors.Add(modelError.ErrorMessage);
}
}
outboundResponse.Message = "";
outboundResponse.Error = string.Join(",", modelErrors);
}
else
{
long accountId = _context.Account.Where(x => x.Username == userName && x.AuthId == authId).FirstOrDefault().Id;
PhoneNumber phoneNumber = _context.PhoneNumber.Where(x => x.Number == outboundRequest.From && x.AccountId == accountId).FirstOrDefault();
if (phoneNumber != null)
{
if (!cacheHandler.IsKeyPresentInInboundCache(outboundRequest.From, outboundRequest.To))
{
if (cacheHandler.GetOutboundSMSCountCache(outboundRequest.From) < 50)
{
cacheHandler.SetOutboundSMSCountCache(outboundRequest.From);
outboundResponse.Message = "outbound sms ok";
outboundResponse.Error = "";
}
else
{
outboundResponse.Message = "";
outboundResponse.Error = "limit reached for from <" + outboundRequest.From + "> ";
}
}
else
{
outboundResponse.Message = "";
outboundResponse.Error = "sms from <" + outboundRequest.From + "> to <" + outboundRequest.To + "> blocked by STOP request";
}
}
else
{
outboundResponse.Message = "";
outboundResponse.Error = "from parameter not found";
}
}
}
catch
{
outboundResponse.Message = "";
outboundResponse.Error = "unknown failure";
}
return(CreatedAtAction("Outbound", outboundResponse));
}
public void Invalid_when_more_than_11_digits()
{
var phrase = "321234567890";
Assert.Throws <ArgumentException>(() => PhoneNumber.Clean(phrase));
}
