public InstitutionAndJobRow (Institution i, Job j)
{
this.Build ();
this.institution = i;
this.job = j;
set_widgets();
}
public async Task<ActionResult> Institution_create([DataSourceRequest] DataSourceRequest request,head_by_institution inst)
{
if (inst != null && ModelState.IsValid)
{
Institution i = new Institution
{
id = 0,
name = inst.institution_name,
country = inst.country,
region = inst.region,
city = inst.city,
postal_code = inst.postal_code,
telephone = inst.telephone,
email = inst.email,
website_address = inst.website_address,
notes = inst.notes
};
User u = new User
{
id = 0,
name = inst.name,
lastname = inst.lastname,
username = inst.username,
password = EncryptionService.encrypt(inst.password)
};
int instId = await _mLearningService.CreateInstitution(i, new Head() {id = 0}, u);
//inst = await _mLearningService.GetObjectWithId<head_by_institution>(instId);
inst.id = instId;
inst.fullname = inst.lastname+", "+inst.name;
}
return Json(new[] { inst }.ToDataSourceResult(request, ModelState));
}
public static bool isDuplicateInstit(Institution instit, Dictionary<int, Institution> bzTable)
{
string name = instit.name;
string kurzName = instit.kurzname;
bool found = isDuplicateInstit(name, kurzName, bzTable);
return found;
}
public static void FromXonXcnMissingPersonAlternateFormat()
{
Institution i = new Institution("Abc", "123");
string xonxcn = String.Format("{0}", i.ToXON());
Recipient r = Recipient.FromXONXCNXTN(xonxcn);
Assert.Null(r.Person);
Assert.Equal(i, r.Institution);
}
protected void OnAddButtonClicked (object sender, System.EventArgs e)
{
Institution i = new Institution();
institutionlist.UnselectAll();
show.Institution = i;
show.IsEditing = true;
show.Show();
return;
}
public InstitutionNode (Institution institution)
{
Institution = institution;
if (institution.Photo != null && institution.Photo.Icon != null)
Photo = new Gdk.Pixbuf (institution.Photo.Icon);
else
Photo = Gdk.Pixbuf.LoadFromResource ("Views.images.MissingInstitutionIcon.jpg");
Name = institution.Name;
}
private void PrintPickList(Order ord, Institution rus)
{
var pickList = WorkflowReportFactory.CreatePicklistReport(ord, rus.Name, _dvPickListMakeup);
if (pickList != null)
{
pickList.PrintDialog();
// Log the pick list
}
}
public ActionResult Institutions(Institution obj)
{
if (ModelState.IsValid)
{
InstitutionRep.AddOrUpdate(obj);
return(RedirectToAction("Institutions"));
}
return(RedirectToAction("Institutions"));
}
public Institution GetInstitutionByName(string name)
{
Institution institution = _institutionRepository.FirstOrDefault(x => x.Name == name);
if (institution != null)
{
return(institution);
}
return(new Institution());
}
public async Task <int> CreateInstitutionAsync(Institution institution)
{
var tempInstitution = _institutionRepository.FirstOrDefault(x => x.Name == institution.Name);
if (tempInstitution != null)
{
throw new UserFriendlyException(ExceptionInfo.InstitutionExists);
}
return(await _institutionRepository.InsertAndGetIdAsync(institution));
}
public ActionResult Edit([Bind(Include = "InstitutionID,FullName,Type,Status,Email,Phone,UserId,FileName,FileContent,UserPhoto")] Institution institution)
{
if (ModelState.IsValid)
{
db.Entry(institution).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(institution));
}
public ActionResult Edit([Bind(Include = "InstitutionID,Name,abbreviation,Extension1,Extension2,Extension3,Extension4,Extension5")] Institution institution)
{
if (ModelState.IsValid)
{
db.Entry(institution).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(institution));
}
public ActionResult Edit(Institution institution)
{
if (ModelState.IsValid)
{
db.Entry(institution).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(institution));
}
//On obtaining a new job, updates the Occupation fields accordingly. Presently only supports a single job at a time.
public void getNewJob(Institution newWorkplace, float newWage)
{
working = true;
if (workplace != null)
{
former_workplaces.Add(workplace);
}
workplace = newWorkplace;
wage = newWage;
}
//Constructor to be used for children / new people who are not yet looking to enter the workforce
public Occupation(bool lookingForJob)
{
workplace = null;
former_workplaces = new List <Institution>();
money = 0;
looking_for_job = lookingForJob;
working = false;
retired = false;
former_workplaces = new List <Institution>();
}
//
// GET: /Institution/Delete/5
public ActionResult Delete(int id = 0)
{
Institution institution = db.Institutions.Find(id);
if (institution == null)
{
return(HttpNotFound());
}
return(View(institution));
}
public async Task <IActionResult> UnjustifiableExpense()
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
Institution institution = _context.Institutions.FirstOrDefault(x => x.UserId == applicationUser.Id);
ViewData["institutionId"] = institution.InstitutionId;
return(View());
}
public async Task <Institution> DeleteInstitution(Institution institution)
{
var deletedInstitution = await this.Institutions.FirstOrDefaultAsync(o => o.Id == institution.Id);
var institutionEntry = this.Institutions.Remove(deletedInstitution);
await this.SaveChangesAsync();
return(institutionEntry.Entity);
}
/// <summary>
///
/// </summary>
/// <param name="grouporusercode">usercode append query</param>
/// <param name="lbl">Label Control To Change</param>
/// <param name="fields">Field Type : 0- Name,1-Stream,2-Degree,3-Branch,4-Term</param>
public void setLabels(string grouporusercode, ref List <Label> lbl, List <byte> fields)
{
Institution insObj = new Institution(grouporusercode);
for (int lblCnt = 0; lblCnt < lbl.Count; lblCnt++)
{
Label lblSend = (Label)lbl[lblCnt];
insObj.SetControlText(ref lblSend, fields[lblCnt]);
}
}
public ActionResult Edit([Bind(Include = "Id,Name,Address,Tel,Mail,Type")] Institution institution)
{
if (ModelState.IsValid)
{
db.Entry(institution).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(institution));
}
public NonQueryResult UpdateInstitution(Institution institution)
{
StringBuilder query = new StringBuilder();
query.AppendLine("UPDATE institution ");
query.AppendLine("SET ");
query.AppendFormat("institution_name = '{0}' ", institution.Name);
query.AppendFormat("WHERE institution_id = '{0}'", institution.InstitutionId);
return(ExecuteNonQuery(query.ToString()));
}
public IActionResult AddInstitution([FromBody] Institution institution)
{
var result = _institutionService.AddInstitution(institution);
if (result.IsSucessful)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Approve(int?id)
{
Institution institution = db.Institutions.Where(p => p.InstitutionID == id).FirstOrDefault();
if (institution.Status == "Approved" || institution.Status == "Rejected")
{
TempData["AlertMessage"] = "Th application has already been Rejected/Approved";
return(RedirectToAction("AdminIndex"));
}
else
{
ApprovedInstitution approvedInstitution = new ApprovedInstitution();
approvedInstitution.InstitutionID = institution.InstitutionID;
approvedInstitution.FullName = institution.FullName;
approvedInstitution.Email = institution.Email;
approvedInstitution.Phone = institution.Phone;
approvedInstitution.Type = institution.Type;
approvedInstitution.FileName = institution.FileName;
approvedInstitution.UserPhoto = institution.UserPhoto;
approvedInstitution.Status = "Approved";
db.ApprovedInstitutions.Add(approvedInstitution);
db.SaveChanges();
//Send An Email After Approval with Activated User Roles and Moodle Credential
var mailTo = new List <MailAddress>();
mailTo.Add(new MailAddress(institution.Email, institution.FullName));
var body = $"Hello {institution.FullName}, Congratulations. We are glad to inform you that your application has been approved. You can now procced to adding your building details. You are required to pay the Subscription Fee in order for your building to be active to the Tenants <br/> Regards,<br/><br/> HomeLink <br/> .";
//Accommodation.Services.Implementation.EmailService emailService = new Accommodation.Services.Implementation.EmailService();
BackEnd.DataManager.EmailService emailService = new BackEnd.DataManager.EmailService();
emailService.SendEmail(new EmailContent()
{
mailTo = mailTo,
mailCc = new List <MailAddress>(),
mailSubject = "Application Statement | Ref No.:" + institution.InstitutionID,
mailBody = body,
mailFooter = "<br/> Many Thanks, <br/> <b>Alliance</b>",
mailPriority = MailPriority.High,
mailAttachments = new List <Attachment>()
});
db.Institutions.Remove(institution);
db.SaveChanges();
//userManager.AddToRole(institution.UserId, "Institution");
TempData["AlertMessage"] = $"{institution.FullName} has been successfully approved";
return(RedirectToAction("Index"));
}
}
/// <summary>
/// Manage Institution object.
/// If the object is of type CustomObjectBase,
/// then either insert values into, delete values from, or update values in Institution.
/// </summary>
/// <param name="sqlConnection">Sql connection or null.</param>
/// <param name="sqlTransaction">Sql transaction or null.</param>
/// <param name="connectionKeyName">Connection key name located in config file.</param>
/// <param name="value">Object of type Institution.</param>
/// <returns>Object of type CustomDataAccessStatus<Institution>.</returns>
public CustomDataAccessStatus <Institution> InstitutionManageAuto(
SqlConnection sqlConnection,
SqlTransaction sqlTransaction,
string connectionKeyName,
Institution value)
{
if (value.IsNew && !value.IsDeleted)
{
Institution returnValue = InstitutionInsertAuto(sqlConnection, sqlTransaction, connectionKeyName,
value.InstitutionCode,
value.InstitutionName,
value.Note,
value.InstitutionUrl,
value.BHLMemberLibrary);
return(new CustomDataAccessStatus <Institution>(
CustomDataAccessContext.Insert,
true, returnValue));
}
else if (!value.IsNew && value.IsDeleted)
{
if (InstitutionDeleteAuto(sqlConnection, sqlTransaction, connectionKeyName,
value.InstitutionCode))
{
return(new CustomDataAccessStatus <Institution>(
CustomDataAccessContext.Delete,
true, value));
}
else
{
return(new CustomDataAccessStatus <Institution>(
CustomDataAccessContext.Delete,
false, value));
}
}
else if (value.IsDirty && !value.IsDeleted)
{
Institution returnValue = InstitutionUpdateAuto(sqlConnection, sqlTransaction, connectionKeyName,
value.InstitutionCode,
value.InstitutionName,
value.Note,
value.InstitutionUrl,
value.BHLMemberLibrary);
return(new CustomDataAccessStatus <Institution>(
CustomDataAccessContext.Update,
true, returnValue));
}
else
{
return(new CustomDataAccessStatus <Institution>(
CustomDataAccessContext.NA,
false, value));
}
}
// generate a new institution
public static Institution GeneratorInstitution(Person owner, String type, Plot location)
{
// string type = GetRandomType();
Institution newInstitution;
switch (type)
{
case "ConstructionCompany":
newInstitution = new ConstructionCompany(owner, location, type);
break;
case "School":
newInstitution = new School(owner, location, type);
break;
case "Hospital":
newInstitution = new Hospital(owner, location, type);
break;
case "LawFirm":
newInstitution = new LawFirm(owner, location, type);
break;
case "ApartmentComplex":
newInstitution = new ApartmentComplex(owner, location, type);
break;
default:
newInstitution = new Institution(owner, location, type);
break;
}
if (newInstitution.getType().Equals("ConstructionCompany"))
{
constructionCompanyList.Add(newInstitution as ConstructionCompany);
}
institutionList.Add(newInstitution);
if (InstitutionDictionary.ContainsKey(type))
{
List <Institution> tempList = InstitutionDictionary[type];
tempList.Add(newInstitution);
}
else
{
InstitutionDictionary[type] = new List <Institution> {
newInstitution
};
}
Logger.Log("Institution", type, owner.name, "(" + location.x_pos + "," + location.y_pos + ")");
return(newInstitution);
}
public ActionResult Create([Bind(Include = "InstitutionID,Name,City,StateCode,NameAbbr,Description")] Institution institution)
{
if (ModelState.IsValid)
{
db.Institutions.Add(institution);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(institution));
}
public ActionResult Delete(int id)
{
Institution institution = db.Institutions.Find(id);
institution.Status = "Deleted";
institution.LastUpdatedBy = (int)Membership.GetUser().ProviderUserKey;
//institution.LastUpdatedOn = DateTimeOffset.Now;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult <Institution> > GetById(int id)
{
Institution Institution = await InstitutionService.GetById(id);
if (Institution == null)
{
return(NotFound());
}
return(Institution);
}
public async Task <JsonResult> RegisterInstitution([FromBody] Institution institution)
{
if (institution != null)
{
return(Json(await this.authenticationService.RegisterInstitution(institution)));
}
else
{
return(Json(null));
}
}
public async Task <IActionResult> Create([Bind("InstitutionId,InstitutionName")] Institution institution)
{
if (ModelState.IsValid)
{
_context.Add(institution);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(institution));
}
public ActionResult Create(Institution institution)
{
if (ModelState.IsValid)
{
db.Institutions.Add(institution);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(institution));
}
private void gridView3_FocusedRowChanged(object sender, DevExpress.XtraGrid.Views.Base.FocusedRowChangedEventArgs e)
{
DataRow dr = gridView3.GetFocusedDataRow();
if (dr != null)
{
int facilityID = Convert.ToInt32(dr["ID"]);
gridFacilityBreakdown.DataSource = Institution.GetResupplyPerUnit(facilityID);
txtSelectedFacility.Text = dr["Name"].ToString();
}
}
/// <summary>
/// Добавяне на институция
/// </summary>
/// <param name="institutionType"></param>
/// <returns></returns>
public IActionResult Add(int institutionType)
{
SetBreadcrums(0, institutionType);
var model = new Institution()
{
InstitutionTypeId = institutionType
};
ViewBag.institutionType = commonService.GetById <InstitutionType>(institutionType);
return(View(nameof(Edit), model));
}
public async Task <ActionResult> Edit([Bind(Include = "InstitutionID,InstitutionName,InstitutionPlace,InstitutionAddress")] Institution institution)
{
if (ModelState.IsValid)
{
db.Entry(institution).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(institution));
}
public InstitutionRelationshipDetailWindow (Institution i, EventHandler OnSave, Gtk.Window parent) : base(Gtk.WindowType.Toplevel)
{
this.Build ();
this.Modal = true;
this.OnSaved = OnSave;
this.TransientFor = parent;
InstitutionRelationship ir = new InstitutionRelationship ();
ir.Institution = i;
show.InstitutionRelationship = ir;
show.IsEditable = true;
}
public async Task <BasicResponse> AddInstitution(Institution institution)
{
var response = new BasicResponse();
institution.Id = _institutionRepository.GetNextKey();
await _institutionRepository.Insert(institution);
response.WasSuccessful = true;
return(response);
}
public ActionResult Create(Institution institution)
{
if (ModelState.IsValid)
{
db.Institutions.Add(institution);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(institution);
}
/// <summary>
/// This method seeds a test institution in the database.
/// </summary>
/// <returns>Returns the institution that will be seeded in the database.</returns>
public static Institution SeedInstitution()
{
Institution institution = new Institution
{
Name = "Fontys",
Description = "Description for Fontys",
IdentityId = "https://identity.fhict.nl"
};
return(institution);
}
public InstitutionPersonDetailWindow (Institution i, EventHandler OnSave, Gtk.Window parent) : base(Gtk.WindowType.Toplevel)
{
this.Build ();
this.Modal = true;
this.OnSaved = OnSave;
this.TransientFor = parent;
InstitutionPerson ip = new InstitutionPerson();
ip.Institution = i;
show.InstitutionPerson = ip;
show.InstitutionReadOnly ();
show.IsEditable = true;
}
/// <summary>
/// Constructs a serialization-capable DICOM softcopy presentation state object.
/// </summary>
/// <param name="presentationStateSopClass">The SOP class of this type of softcopy presentation state.</param>
protected DicomSoftcopyPresentationState(SopClass presentationStateSopClass)
{
_presentationSopClass = presentationStateSopClass;
_dicomFile = new DicomFile();
_serialized = false;
_sourceAETitle = string.Empty;
_stationName = string.Empty;
_institution = Institution.Empty;
Manufacturer = "ClearCanvas Inc.";
ManufacturersModelName = ProductInformation.GetName(false, false);
DeviceSerialNumber = string.Empty;
SoftwareVersions = ProductInformation.GetVersion(true, true, true, true);
_presentationInstanceNumber = 1;
_presentationSopInstanceUid = string.Empty;
_presentationSeriesDateTime = Platform.Time;
_presentationSeriesNumber = null;
_presentationSeriesInstanceUid = string.Empty;
_presentationLabel = "FOR_PRESENTATION";
}
public static bool isExistantInstit(Institution instit, Dictionary<int, Institution> bzTable)
{
//instit to update
string name = instit.name;
string kurzName = instit.kurzname;
List<Institution> originalLongNameFound =
bzTable.Values.Where(x => String.Equals(x.name, name, StringComparison.OrdinalIgnoreCase)).ToList();
//todo
List<Institution> originalShortNameFound =
bzTable.Values.Where(x => String.Equals(x.kurzname, kurzName, StringComparison.OrdinalIgnoreCase))
.ToList();
if (originalShortNameFound.Any() || originalLongNameFound.Any())
{
return true;
}
return false;
}
public ActionResult Create(Institution institution)
{
try
{
if (ModelState.IsValid)
{
unitOfWork.InstitutionRepository.Insert(institution);
unitOfWork.Save();
return RedirectToAction("Index");
}
}
catch (DataException)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
FillStatuses(institution.StatusID);
FillStates(institution.StateID);
FillChains(institution.ChainID);
FillUsers(institution.UserID);
return View(institution);
}
public ActionResult EditInstitutionProfile(Institution model)
{
var identity = ((ClaimsIdentity)User.Identity);
string userid = identity.GetClaimValue(ClaimTypes.NameIdentifier);
Institution institution = db.Institutions.FirstOrDefault(x => x.Institution_ID == model.Institution_ID);
if (ModelState.IsValid && institution != null)
{
TryUpdateModel(institution);
db.SaveChanges();
string role = identity.GetClaimValue(ClaimTypes.Role);
UserType Role = ((UserType)Enum.Parse(typeof(UserType), role));
return RedirectToAction(Role == UserType.Administrator ? "Institutions" : "Index");
}
else
{
return View(model);
}
}
void DoManagePublishersCommand(Institution inst)
{
ShowViewModel<ManagePublishersViewModel>(new { inst_id = inst.id });
}
// Update // REQUIRES ID FIELDS TO BE FILLED CORRECTLY, USE GET METHOD BEFORE UPDATE TO RECEIVE ID'S // YOU CANNOT UPDATE ANY FIELDS THAT ARE WITHIN ANY OF THE KEYS FOR THE TABLE // TO DO THAT DELETE AND CREATE NEW ONE public abstract bool UpdateInstitution(Institution institution);
public ActionResult Edit(Institution institution)
{
if (ModelState.IsValid)
{
db.Entry(institution).State = EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
}
return View(institution);
}
public async Task<IHttpActionResult> PostInstitution(Institution institution)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (!InstitutionExists(institution.Id))
{
db.Institutions.Add(institution);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (InstitutionExists(institution.Id) || InstitutionExists(institution.Name))
{
return Conflict();
}
else
{
throw;
}
}
return CreatedAtRoute("DefaultApi", new { id = institution.Id }, institution);
} else {
return Conflict();
}
}
protected void OnInstitutionDeleted (object sender, System.EventArgs e)
{
Institution = null;
}
private void onSelectInstitution()
{
institutionNameTextBox.Text = institutionsListBox.SelectedItem.ToString();
if (viewModel != null)
{
choosenInstitution = (Institution)viewModel.Institutions.CurrentItem;
}
publisherNameTextBox.Focus();
buttonAddPublisher.IsEnabled = true;
}
public InstitutionSelect (Institution institution, EventHandler changed)
{
this.Build ();
this.Institution = institution;
this.Changed = changed;
}
protected void OnInstitutionSelected (object sender, InstitutionEventArgs args)
{
Institution = args.Institution;
return;
}
private void institutionsListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (institutionsListBox.SelectedItem != null)
{
onSelectInstitution();
}
else
{
choosenInstitution = null;
buttonAddPublisher.IsEnabled = false;
}
}
public void AddAndSelectInstitution(Institution inst)
{
((List<Institution>)_institutions.CollectionView.SourceCollection).Add(inst);
((List<Institution>)_institutions.CollectionView.SourceCollection).Sort((x, y) => x.Name.CompareTo(y.Name));
_institutions.CollectionView.Refresh();
}
public async Task<IHttpActionResult> PutInstitution(Guid id, Institution institution)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != institution.Id)
{
return BadRequest();
}
if (institution.Id == Guid.Parse(Constants.GUID_UNDEFINED_INSTITUTION))
{
return Unauthorized();
}
db.Entry(institution).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstitutionExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
// Delete // REQUIRES ID FIELDS TO BE FILLED CORRECTLY, USE GET METHOD BEFORE UPDATE TO RECEIVE ID'S public abstract bool DeleteInstitution(Institution institution);
// Save public abstract string SaveInstitution(Institution institution);
public abstract IEnumerable<Publisher> GetPublishersForInstitution(Institution institution);
private bool saveInstitution()
{
bool result = false;
if (institutionNameTextBox.Text.Length != 0)
{
Institution inst = new Institution("", institutionNameTextBox.Text);
if (viewModel.IsInstitutionNameUnique(inst.Name))
{
if ((inst.Id = CentralRepository.Instance.SaveInstitution(inst)) != "")
{
viewModel.AddAndSelectInstitution(inst);
selectFirstInstitution();
result = true;
}
else
{
MessageBox.Show("Przy dodawaniu nowej instytucji do bazy wystąpił błąd!");
}
}
else
{
MessageBox.Show("W bazie istnieje już instytucja o podanej nazwie!");
}
}
else
{
MessageBox.Show("Aby dodać nową instytucję, należy podać jej nazwę!");
}
return result;
}
public async Task<List<Institution>> GetInstitutionsDetailsUrls(string institutionTypeId, string countyId,
string municipalityId, string ownershipType)
{
HttpClient client = GetClient();
var respObj = await client.PostAsync("",
new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()
{
new KeyValuePair<string, string>("vrsta", institutionTypeId),
new KeyValuePair<string, string>("okrug1", countyId),
new KeyValuePair<string, string>("okrug", countyId),
new KeyValuePair<string, string>("opstina", municipalityId),
new KeyValuePair<string, string>("vlasnistvo", ownershipType),
new KeyValuePair<string, string>("dugme", MpnKnownItems.PronadjiDugmeValue)
}));
var respHtml = await respObj.Content.ReadAsStringAsync();
HtmlDocument doc = new HtmlDocument();
List<Institution> toReturn = new List<Institution>();
doc.LoadHtml(respHtml);
var allRows = doc.DocumentNode.SelectNodes("//tr");
var dataRows = allRows.Skip(2).Where(r => r.ChildNodes.Count > 4);
foreach (var row in dataRows)
{
var cells = row.ChildNodes.Where(cn => cn.Name == "td").ToList();
string detailsRelativeUrl, name;
detailsRelativeUrl = cells[0].ChildNodes.Where(cn => cn.Name == "a").Single().GetAttributeValue("href", string.Empty);
var institution = new Institution()
{
DetailsRelativeUrl = detailsRelativeUrl
};
toReturn.Add(institution);
}
return toReturn;
}
public static void FromXonXcnWorksForSimpleCase()
{
Person p = new Person { First = "Bob", Last = "Smith", Degree = "MD" };
Institution i = new Institution("Abc", "123");
string xonxcn = String.Format("{0}|{1}", i.ToXON(), p.ToXCN());
Recipient r = Recipient.FromXONXCNXTN(xonxcn);
Assert.Equal(p, r.Person);
Assert.Equal(i, r.Institution);
}
