CRUD Operations on Model with Object-Based Foreign Key
This scenario demonstrates performing Create, Read, Update, and Delete operations on an object that has a foreign key reference to a lookup table. The FK reference is represented as an object.
Scenario Prototype
public interface IEmployeeComplex
{
string? CellPhone { get; set; }
IReadOnlyEmployeeClassification? EmployeeClassification { get; set; }
int EmployeeKey { get; set; }
string? FirstName { get; set; }
string? LastName { get; set; }
string? MiddleName { get; set; }
string? OfficePhone { get; set; }
string? Title { get; set; }
}
public interface IModelWithLookupComplexScenario<TEmployee>
where TEmployee : class, IEmployeeComplex, new()
{
/// <summary>
/// Create a new Employee row, returning the new primary key.
/// </summary>
/// <remarks>This may NOT modify the EmployeeClassification record.</remarks>
int Create(TEmployee employee);
/// <summary>
/// Delete a Employee row using an object.
/// </summary>
/// <remarks>Behavior when row doesn't exist is not defined. This may NOT modify or delete the EmployeeClassification record.</remarks>
void Delete(TEmployee employee);
/// <summary>
/// Delete a Employee row using its primary key.
/// </summary>
/// <remarks>Behavior when row doesn't exist is not defined.</remarks>
void DeleteByKey(int employeeKey);
/// <summary>
/// Gets an Employee row by its name.
/// </summary>
IList<TEmployee> FindByLastName(string lastName);
/// <summary>
/// Gets all Employee rows.
/// </summary>
IList<TEmployee> GetAll();
/// <summary>
/// Gets an Employee row by its primary key.
/// </summary>
TEmployee? GetByKey(int employeeKey);
/// <summary>
/// Get an employee classification by key.
/// </summary>
/// <param name="employeeClassificationKey">The employee classification key.</param>
IEmployeeClassification? GetClassification(int employeeClassificationKey);
/// <summary>
/// Update a Employee row.
/// </summary>
/// <remarks>Behavior when row doesn't exist is not defined. This may NOT modify the EmployeeClassification record.</remarks>
void Update(TEmployee employee);
}
Database Views
CREATE VIEW HR.EmployeeDetail WITH SCHEMABINDING AS SELECT e.EmployeeKey, e.FirstName, e.MiddleName, e.LastName, e.Title, e.OfficePhone, e.CellPhone, e.EmployeeClassificationKey, ec.EmployeeClassificationName, ec.IsExempt, ec.IsEmployee FROM HR.Employee e INNER JOIN HR.EmployeeClassification ec ON e.EmployeeClassificationKey = ec.EmployeeClassificationKey;
ADO.NET
In order to promote code reuse, object population has been moved into the model's constructor.
public class EmployeeComplex : IEmployeeComplex
{
public EmployeeComplex()
{
}
public EmployeeComplex(IDataReader reader)
{
if (reader == null)
throw new ArgumentNullException(nameof(reader), $"{nameof(reader)} is null.");
EmployeeKey = reader.GetInt32(reader.GetOrdinal("EmployeeKey"));
FirstName = reader.GetString(reader.GetOrdinal("FirstName"));
if (!reader.IsDBNull(reader.GetOrdinal("MiddleName")))
MiddleName = reader.GetString(reader.GetOrdinal("MiddleName"));
LastName = reader.GetString(reader.GetOrdinal("LastName"));
if (!reader.IsDBNull(reader.GetOrdinal("Title")))
Title = reader.GetString(reader.GetOrdinal("Title"));
if (!reader.IsDBNull(reader.GetOrdinal("OfficePhone")))
OfficePhone = reader.GetString(reader.GetOrdinal("OfficePhone"));
if (!reader.IsDBNull(reader.GetOrdinal("CellPhone")))
CellPhone = reader.GetString(reader.GetOrdinal("CellPhone"));
EmployeeClassification = new EmployeeClassification(reader);
}
public string? CellPhone { get; set; }
public IReadOnlyEmployeeClassification? EmployeeClassification { get; set; }
public int EmployeeKey { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public string? MiddleName { get; set; }
public string? OfficePhone { get; set; }
public string? Title { get; set; }
}
Likewise, a database view was used to join the Employee table with its lookup table(s).
public class ModelWithLookupComplexScenario : SqlServerScenarioBase, IModelWithLookupComplexScenario<EmployeeComplex>
{
public ModelWithLookupComplexScenario(string connectionString) : base(connectionString)
{ }
public int Create(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
const string sql = @"INSERT INTO HR.Employee
(FirstName, MiddleName, LastName, Title, OfficePhone, CellPhone, EmployeeClassificationKey)
OUTPUT Inserted.EmployeeKey
VALUES
(@FirstName, @MiddleName, @LastName, @Title, @OfficePhone, @CellPhone, @EmployeeClassificationKey);";
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@FirstName", employee.FirstName);
cmd.Parameters.AddWithValue("@MiddleName", (object?)employee.MiddleName ?? DBNull.Value);
cmd.Parameters.AddWithValue("@LastName", employee.LastName);
cmd.Parameters.AddWithValue("@Title", (object?)employee.Title ?? DBNull.Value);
cmd.Parameters.AddWithValue("@OfficePhone", (object?)employee.OfficePhone ?? DBNull.Value);
cmd.Parameters.AddWithValue("@CellPhone", (object?)employee.CellPhone ?? DBNull.Value);
cmd.Parameters.AddWithValue("@EmployeeClassificationKey", employee.EmployeeClassification.EmployeeClassificationKey);
return (int)cmd.ExecuteScalar();
}
}
public void Delete(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
const string sql = @"DELETE HR.Employee WHERE EmployeeKey = @EmployeeKey;";
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeKey", employee.EmployeeKey);
cmd.ExecuteNonQuery();
}
}
public void DeleteByKey(int employeeKey)
{
const string sql = @"DELETE HR.Employee WHERE EmployeeKey = @EmployeeKey;";
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeKey", employeeKey);
cmd.ExecuteNonQuery();
}
}
public IList<EmployeeComplex> FindByLastName(string lastName)
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed WHERE ed.LastName = @LastName";
var result = new List<EmployeeComplex>();
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@LastName", lastName);
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
result.Add(new EmployeeComplex(reader));
}
return result;
}
}
}
public IList<EmployeeComplex> GetAll()
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed";
var result = new List<EmployeeComplex>();
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
result.Add(new EmployeeComplex(reader));
}
return result;
}
}
public EmployeeComplex? GetByKey(int employeeKey)
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed WHERE ed.EmployeeKey = @EmployeeKey";
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeKey", employeeKey);
using (var reader = cmd.ExecuteReader())
{
if (!reader.Read())
return null;
return new EmployeeComplex(reader);
}
}
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
const string sql = @"SELECT ec.EmployeeClassificationKey, ec.EmployeeClassificationName, ec.IsExempt, ec.IsEmployee
FROM HR.EmployeeClassification ec
WHERE ec.EmployeeClassificationKey = @EmployeeClassificationKey;";
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeClassificationKey", employeeClassificationKey);
using (var reader = cmd.ExecuteReader())
{
if (!reader.Read())
return null;
return new EmployeeClassification()
{
EmployeeClassificationKey = reader.GetInt32(reader.GetOrdinal("EmployeeClassificationKey")),
EmployeeClassificationName = reader.GetString(reader.GetOrdinal("EmployeeClassificationName")),
IsExempt = reader.GetBoolean(reader.GetOrdinal("IsExempt")),
IsEmployee = reader.GetBoolean(reader.GetOrdinal("IsEmployee"))
};
}
}
}
public void Update(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
const string sql = @"UPDATE HR.Employee
SET FirstName = @FirstName,
MiddleName = @MiddleName,
LastName = @LastName,
Title = @Title,
OfficePhone = @OfficePhone,
CellPhone = @CellPhone,
EmployeeClassificationKey = @EmployeeClassificationKey
WHERE EmployeeKey = @EmployeeKey;";
using (var con = OpenConnection())
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeKey", employee.EmployeeKey);
cmd.Parameters.AddWithValue("@FirstName", employee.FirstName);
cmd.Parameters.AddWithValue("@MiddleName", (object?)employee.MiddleName ?? DBNull.Value);
cmd.Parameters.AddWithValue("@LastName", employee.LastName);
cmd.Parameters.AddWithValue("@Title", (object?)employee.Title ?? DBNull.Value);
cmd.Parameters.AddWithValue("@OfficePhone", (object?)employee.OfficePhone ?? DBNull.Value);
cmd.Parameters.AddWithValue("@CellPhone", (object?)employee.CellPhone ?? DBNull.Value);
cmd.Parameters.AddWithValue("@EmployeeClassificationKey", employee.EmployeeClassification.EmployeeClassificationKey);
cmd.ExecuteNonQuery();
}
}
}
Chain
Chain does not support representing FK's as child objects for create/update operations. The FK must be exposed via the parent object.
Read operations must occur against a database view in order to get the properties from the child object. The Decompose
attribute indicates that the child should be populated from the same view.
[TableAndView("HR.Employee", ViewName = "HR.EmployeeDetail")]
public partial class EmployeeComplex
{
public string? CellPhone { get; set; }
[Decompose] //Used for Read operations
public EmployeeClassification? EmployeeClassification { get; set; }
//Used for Insert/Update operations
public int EmployeeClassificationKey => EmployeeClassification?.EmployeeClassificationKey ?? 0;
public int EmployeeKey { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public string? MiddleName { get; set; }
public string? OfficePhone { get; set; }
public string? Title { get; set; }
}
//Used for linking the entity to the test framework. Not part of the recipe.
partial class EmployeeComplex : IEmployeeComplex
{
IReadOnlyEmployeeClassification? IEmployeeComplex.EmployeeClassification
{
get => EmployeeClassification;
set => EmployeeClassification = (EmployeeClassification?)value;
}
}
}
public class ModelWithLookupComplexScenario : IModelWithLookupComplexScenario<EmployeeComplex>
{
readonly SqlServerDataSource m_DataSource;
public ModelWithLookupComplexScenario(SqlServerDataSource dataSource)
{
m_DataSource = dataSource;
}
public int Create(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
//The object is mapped to the view, so we need to override the table we write to.
return m_DataSource.Insert(employee).ToInt32().Execute();
}
public void Delete(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
//The object is mapped to the view, so we need to override the table we write to.
m_DataSource.Delete(employee).Execute();
}
public void DeleteByKey(int employeeKey)
{
m_DataSource.DeleteByKey<EmployeeComplex>(employeeKey).Execute();
}
public IList<EmployeeComplex> FindByLastName(string lastName)
{
return m_DataSource.From<EmployeeComplex>(new { LastName = lastName }).ToCollection().Execute();
}
public IList<EmployeeComplex> GetAll()
{
return m_DataSource.From<EmployeeComplex>().ToCollection().Execute();
}
public EmployeeComplex? GetByKey(int employeeKey)
{
return m_DataSource.From<EmployeeComplex>(new { employeeKey }).ToObjectOrNull().Execute();
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
return m_DataSource.GetByKey<EmployeeClassification>(employeeClassificationKey).ToObject().Execute();
}
public void Update(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
//The object is mapped to the view, so we need to override the table we write to.
m_DataSource.Update(employee).Execute();
}
}
Dapper
Dapper does not support representing FK's as child objects for create/update operations. The FK must be exposed via the parent object.
Read operations must occur against a database view in order to get the properties from the child object. The Multi Mapping overload indicates that the child should be populated from the same view. Use the splitOn
parameter to indicate the primary key of the second object.
public partial class EmployeeComplex : IEmployeeComplex
{
public string? CellPhone { get; set; }
public EmployeeClassification? EmployeeClassification { get; set; }
//Used for Insert/Update operations
public int EmployeeClassificationKey => EmployeeClassification?.EmployeeClassificationKey ?? 0;
public int EmployeeKey { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public string? MiddleName { get; set; }
public string? OfficePhone { get; set; }
public string? Title { get; set; }
}
//Used for linking the entity to the test framework. Not part of the recipe.
partial class EmployeeComplex : IEmployeeComplex
{
IReadOnlyEmployeeClassification? IEmployeeComplex.EmployeeClassification
{
get => EmployeeClassification;
set => EmployeeClassification = (EmployeeClassification?)value;
}
}
}
public class ModelWithLookupComplexScenario : ScenarioBase, IModelWithLookupComplexScenario<EmployeeComplex>
{
public ModelWithLookupComplexScenario(string connectionString) : base(connectionString)
{
}
public int Create(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
const string sql = @"INSERT INTO HR.Employee
(FirstName, MiddleName, LastName, Title, OfficePhone, CellPhone, EmployeeClassificationKey)
OUTPUT Inserted.EmployeeKey
VALUES
(@FirstName, @MiddleName, @LastName, @Title, @OfficePhone, @CellPhone, @EmployeeClassificationKey);";
using (var con = OpenConnection())
return (int)con.ExecuteScalar(sql, employee);
}
public void Delete(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
const string sql = @"DELETE HR.Employee WHERE EmployeeKey = @EmployeeKey;";
using (var con = OpenConnection())
con.Execute(sql, employee);
}
public void DeleteByKey(int employeeKey)
{
const string sql = @"DELETE HR.Employee WHERE EmployeeKey = @EmployeeKey;";
using (var con = OpenConnection())
con.Execute(sql, new { employeeKey });
}
public IList<EmployeeComplex> FindByLastName(string lastName)
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed WHERE ed.LastName = @LastName";
var result = new List<EmployeeComplex>();
using (var con = OpenConnection())
return con.Query<EmployeeComplex, EmployeeClassification, EmployeeComplex>(sql,
(e, ec) => { e.EmployeeClassification = ec; return e; },
new { LastName = lastName },
splitOn: "EmployeeClassificationKey")
.ToList();
}
public IList<EmployeeComplex> GetAll()
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed";
var result = new List<EmployeeComplex>();
using (var con = OpenConnection())
return con.Query<EmployeeComplex, EmployeeClassification, EmployeeComplex>(sql,
(e, ec) => { e.EmployeeClassification = ec; return e; },
splitOn: "EmployeeClassificationKey")
.ToList();
}
public EmployeeComplex? GetByKey(int employeeKey)
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed WHERE ed.EmployeeKey = @EmployeeKey";
using (var con = OpenConnection())
return con.Query<EmployeeComplex, EmployeeClassification, EmployeeComplex>(sql,
(e, ec) => { e.EmployeeClassification = ec; return e; },
new { EmployeeKey = employeeKey },
splitOn: "EmployeeClassificationKey")
.SingleOrDefault();
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
const string sql = @"SELECT ec.EmployeeClassificationKey, ec.EmployeeClassificationName, ec.IsExempt, ec.IsEmployee
FROM HR.EmployeeClassification ec
WHERE ec.EmployeeClassificationKey = @EmployeeClassificationKey;";
using (var con = OpenConnection())
return con.QuerySingle<EmployeeClassification>(sql, new { employeeClassificationKey });
}
public void Update(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
const string sql = @"UPDATE HR.Employee
SET FirstName = @FirstName,
MiddleName = @MiddleName,
LastName = @LastName,
Title = @Title,
OfficePhone = @OfficePhone,
CellPhone = @CellPhone,
EmployeeClassificationKey = @EmployeeClassificationKey
WHERE EmployeeKey = @EmployeeKey;";
using (var con = OpenConnection())
con.Execute(sql, employee);
}
}
DbConnector
public class ModelWithLookupComplexScenario : ScenarioBase, IModelWithLookupComplexScenario<EmployeeComplex>
{
public ModelWithLookupComplexScenario(string connectionString) : base(connectionString)
{
}
public int Create(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
const string sql = @"INSERT INTO HR.Employee
(FirstName, MiddleName, LastName, Title, OfficePhone, CellPhone, EmployeeClassificationKey)
OUTPUT Inserted.EmployeeKey
VALUES
(@FirstName, @MiddleName, @LastName, @Title, @OfficePhone, @CellPhone, @EmployeeClassificationKey);";
return DbConnector.Scalar<int>(sql,
new
{
employee.FirstName,
employee.MiddleName,
employee.LastName,
employee.Title,
employee.OfficePhone,
employee.CellPhone,
employee.EmployeeClassificationKey
}).Execute();
}
public void Delete(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
const string sql = @"DELETE HR.Employee WHERE EmployeeKey = @EmployeeKey;";
DbConnector.NonQuery(sql, new { employee.EmployeeKey }).Execute();
}
public void DeleteByKey(int employeeKey)
{
const string sql = @"DELETE HR.Employee WHERE EmployeeKey = @employeeKey;";
DbConnector.NonQuery(sql, new { employeeKey }).Execute();
}
public IList<EmployeeComplex> FindByLastName(string lastName)
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed WHERE ed.LastName = @LastName";
var settings = new ColumnMapSetting().WithSplitOnFor<EmployeeClassification>(e => e.EmployeeClassificationKey);
return DbConnector.ReadToList<EmployeeComplex>(settings, sql, new { LastName = lastName }).Execute();
}
public IList<EmployeeComplex> GetAll()
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed";
//Configure Split map settings
var settings = new ColumnMapSetting().WithSplitOnFor<EmployeeClassification>(e => e.EmployeeClassificationKey);
return DbConnector.ReadToList<EmployeeComplex>(settings, sql).Execute();
}
public EmployeeComplex? GetByKey(int employeeKey)
{
const string sql = @"SELECT ed.EmployeeKey, ed.FirstName, ed.MiddleName, ed.LastName, ed.Title, ed.OfficePhone, ed.CellPhone, ed.EmployeeClassificationKey, ed.EmployeeClassificationName, ed.IsExempt, ed.IsEmployee FROM HR.EmployeeDetail ed WHERE ed.EmployeeKey = @EmployeeKey";
//Configure Split map settings
var settings = new ColumnMapSetting().WithSplitOnFor<EmployeeClassification>(e => e.EmployeeClassificationKey);
return DbConnector.ReadSingleOrDefault<EmployeeComplex>(settings, sql, new { EmployeeKey = employeeKey }).Execute();
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
const string sql = @"SELECT ec.EmployeeClassificationKey, ec.EmployeeClassificationName, ec.IsExempt, ec.IsEmployee
FROM HR.EmployeeClassification ec
WHERE ec.EmployeeClassificationKey = @employeeClassificationKey;";
return DbConnector.ReadSingle<EmployeeClassification>(sql, new { employeeClassificationKey }).Execute();
}
public void Update(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
const string sql = @"UPDATE HR.Employee
SET FirstName = @FirstName,
MiddleName = @MiddleName,
LastName = @LastName,
Title = @Title,
OfficePhone = @OfficePhone,
CellPhone = @CellPhone,
EmployeeClassificationKey = @EmployeeClassificationKey
WHERE EmployeeKey = @EmployeeKey;";
DbConnector.NonQuery(sql,
new
{
employee.EmployeeKey,
employee.FirstName,
employee.MiddleName,
employee.LastName,
employee.Title,
employee.OfficePhone,
employee.CellPhone,
employee.EmployeeClassificationKey
}).Execute();
}
}
Entity Framework 6
TODO
Entity Framework Core
Child objects outside of the DBContext (e.g. from a REST call) need to be mapped to an object created by the DBContext.
This provides a layer of safety, as otherwise clients could override data in the lookup table.
public class ModelWithLookupComplexScenario : IModelWithLookupComplexScenario<Employee>
{
private Func<OrmCookbookContext> CreateDbContext;
public ModelWithLookupComplexScenario(Func<OrmCookbookContext> dBContextFactory)
{
CreateDbContext = dBContextFactory;
}
public int Create(Employee employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassificationKeyNavigation == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassificationKeyNavigation)} is null.");
using (var context = CreateDbContext())
{
//Prevent updates to the lookup table
context.Entry(employee.EmployeeClassificationKeyNavigation).State = EntityState.Unchanged;
context.Employee.Add(employee);
context.SaveChanges();
return employee.EmployeeKey;
}
}
public void Delete(Employee employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
using (var context = CreateDbContext())
{
context.Entry(employee).State = EntityState.Deleted;
context.SaveChanges();
}
}
public void DeleteByKey(int employeeKey)
{
using (var context = CreateDbContext())
{
//Find the row you wish to delete
var temp = context.Employee.Find(employeeKey);
if (temp != null)
{
context.Employee.Remove(temp);
context.SaveChanges();
}
}
}
public IList<Employee> FindByLastName(string lastName)
{
using (var context = CreateDbContext())
return context.Employee
.Where(ec => ec.LastName == lastName)
.Include(e => e.EmployeeClassificationKeyNavigation)
.ToList();
}
public IList<Employee> GetAll()
{
using (var context = CreateDbContext())
return context.Employee
.Include(e => e.EmployeeClassificationKeyNavigation)
.ToList();
}
public Employee? GetByKey(int employeeKey)
{
using (var context = CreateDbContext())
return context.Employee
.Include(e => e.EmployeeClassificationKeyNavigation)
.SingleOrDefault(e => e.EmployeeKey == employeeKey);
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
using (var context = CreateDbContext())
return context.EmployeeClassification.Find(employeeClassificationKey);
}
/// <summary>
/// Updates the specified employee.
/// </summary>
/// <param name="employee">The employee.</param>
/// <exception cref="ArgumentNullException">employee</exception>
public void Update(Employee employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassificationKeyNavigation == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassificationKeyNavigation)} is null.");
using (var context = CreateDbContext())
{
//Prevent updates to the lookup table
context.Entry(employee.EmployeeClassificationKeyNavigation).State = EntityState.Unchanged;
context.Entry(employee).State = EntityState.Modified;
context.SaveChanges();
}
}
}
LINQ to DB
TODO
LLBLGen Pro
As LLBLGen Pro supports change tracking in the entities it doesn't have to refetch an entity that's been updated. The repository code illustrates this. As it also by default persists all reachable entities in a graph, recursive saves are disabled here to make sure only the entity that's passed in is persisted.
Entity classes are always derived from a known base class so types created by the user aren't taken into account when traversing the graph, only entity classes.
public class ModelWithLookupComplexScenario : IModelWithLookupComplexScenario<EmployeeEntity>
{
public int Create(EmployeeEntity employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
using (var adapter = new DataAccessAdapter())
{
// the test FoulLookup will alter the associated lookup entity and if we persist things recursively we'll save this record too, so we don't use any
// recursive persistence here.
adapter.SaveEntity(employee, true, recurse: false);
return employee.EmployeeKey;
}
}
public void Delete(EmployeeEntity employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
using (var adapter = new DataAccessAdapter())
{
employee.IsNew = false;
adapter.DeleteEntity(employee);
}
}
public void DeleteByKey(int employeeKey)
{
using (var adapter = new DataAccessAdapter())
{
adapter.DeleteEntitiesDirectly(typeof(EmployeeEntity), new RelationPredicateBucket(EmployeeFields.EmployeeKey.Equal(employeeKey)));
}
}
public IList<EmployeeEntity> FindByLastName(string lastName)
{
using (var adapter = new DataAccessAdapter())
{
return new LinqMetaData(adapter).Employee
.Where(ec => ec.LastName == lastName)
.WithPath(p => p.Prefetch(e => e.EmployeeClassification))
.ToList();
}
}
public IList<EmployeeEntity> GetAll()
{
using (var adapter = new DataAccessAdapter())
{
return new LinqMetaData(adapter).Employee
.WithPath(p => p.Prefetch(e => e.EmployeeClassification))
.ToList();
}
}
public EmployeeEntity? GetByKey(int employeeKey)
{
using (var adapter = new DataAccessAdapter())
{
return new LinqMetaData(adapter).Employee
.WithPath(p => p.Prefetch(e => e.EmployeeClassification))
.SingleOrDefault(e => e.EmployeeKey == employeeKey);
}
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
using (var adapter = new DataAccessAdapter())
{
return new LinqMetaData(adapter).EmployeeClassification.FirstOrDefault(ec => ec.EmployeeClassificationKey == employeeClassificationKey);
}
}
/// <summary>
/// Updates the specified employee.
/// </summary>
/// <param name="employee">The employee.</param>
/// <exception cref="ArgumentNullException">employee</exception>
public void Update(EmployeeEntity employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
using (var adapter = new DataAccessAdapter())
{
EmployeeEntity toPersist = employee;
if (toPersist.IsNew)
{
toPersist = new EmployeeEntity(employee.EmployeeKey);
adapter.FetchEntity(toPersist);
//Copy the changed fields
toPersist.FirstName = employee.FirstName;
toPersist.MiddleName = employee.MiddleName;
toPersist.LastName = employee.LastName;
toPersist.CellPhone = employee.CellPhone;
toPersist.OfficePhone = employee.OfficePhone;
toPersist.Title = employee.Title;
toPersist.EmployeeClassificationKey = employee.EmployeeClassificationKey;
}
if (!toPersist.IsNew)
{
// By default the whole graph is persisted in-order, FKs are synced etc. but there's a test in this system
// which makes it fail if we do so, so we have to disable the recursive saves.
adapter.SaveEntity(toPersist, refetchAfterSave: false, recurse: false);
}
}
}
}
NHibernate
TODO
RepoDb
RepoDb does not support representing FK's as child objects for create/update operations. The FK must be exposed via the parent object.
RepoDb supports ExecuteQueryMultiple which can cater a much more optimal solution for fetching parent-children related data entities.
Read operations must occur against a database view in order to get the properties from the child object. The Decompose
attribute indicates that the child should be populated from the same view.
[Map("[HR].[Employee]")]
public partial class EmployeeComplex : IEmployeeComplex
{
public string? CellPhone { get; set; }
public EmployeeClassification? EmployeeClassification { get; set; }
public int EmployeeClassificationKey { get; set; }
public int EmployeeKey { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public string? MiddleName { get; set; }
public string? OfficePhone { get; set; }
public string? Title { get; set; }
}
//Used for linking the entity to the test framework. Not part of the recipe.
partial class EmployeeComplex : IEmployeeComplex
{
IReadOnlyEmployeeClassification? IEmployeeComplex.EmployeeClassification
{
get => EmployeeClassification;
set
{
EmployeeClassification = (EmployeeClassification?)value;
EmployeeClassificationKey = (value?.EmployeeClassificationKey).GetValueOrDefault();
}
}
}
}
public class ModelWithLookupComplexScenario : DbRepository<SqlConnection>,
IModelWithLookupComplexScenario<EmployeeComplex>
{
public ModelWithLookupComplexScenario(string connectionString)
: base(connectionString, RDB.Enumerations.ConnectionPersistency.Instance)
{ }
public int Create(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
return Insert<EmployeeComplex, int>(employee);
}
public void Delete(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
base.Delete(employee);
}
public void DeleteByKey(int employeeKey)
{
Delete<EmployeeComplex>(employeeKey);
}
public IList<EmployeeComplex> FindByLastName(string lastName)
{
return Query<EmployeeComplex>(e => e.LastName == lastName).AsList();
}
public IList<EmployeeComplex> GetAll()
{
return QueryAll<EmployeeComplex>().AsList();
}
public EmployeeComplex? GetByKey(int employeeKey)
{
var employee = Query<EmployeeComplex>(employeeKey).FirstOrDefault();
if (employee != null)
{
employee.EmployeeClassification = Query<EmployeeClassification>(employee.EmployeeClassificationKey).FirstOrDefault();
}
return employee;
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
return Query<EmployeeClassification>(employeeClassificationKey).FirstOrDefault();
}
public void Update(EmployeeComplex employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
base.Update(employee);
}
}
ServiceStack
public class ModelWithLookupComplexScenario : IModelWithLookupComplexScenario<Employee>
{
private readonly IDbConnectionFactory _dbConnectionFactory;
public ModelWithLookupComplexScenario(IDbConnectionFactory dbConnectionFactory)
{
_dbConnectionFactory = dbConnectionFactory;
}
public int Create(Employee employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee.EmployeeClassification)} is null.");
employee.EmployeeClassificationId = employee.EmployeeClassification.Id;
using (var db = _dbConnectionFactory.OpenDbConnection())
{
db.Save(employee);
}
return employee.Id;
}
public void Delete(Employee employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
using (var db = _dbConnectionFactory.OpenDbConnection())
db.Delete(employee);
}
public void DeleteByKey(int employeeKey)
{
using (var db = _dbConnectionFactory.OpenDbConnection())
db.DeleteById<Employee>(employeeKey);
}
public IList<Employee> FindByLastName(string lastName)
{
using (var db = _dbConnectionFactory.OpenDbConnection())
return db.LoadSelect<Employee>(e => e.LastName == lastName);
}
public IList<Employee> GetAll()
{
using (var db = _dbConnectionFactory.OpenDbConnection())
return db.LoadSelect<Employee>();
}
public Employee? GetByKey(int employeeKey)
{
using (var db = _dbConnectionFactory.OpenDbConnection())
return db.LoadSingleById<Employee>(employeeKey);
}
public IEmployeeClassification? GetClassification(int employeeClassificationKey)
{
using (var db = _dbConnectionFactory.OpenDbConnection())
return db.SingleById<EmployeeClassification>(employeeClassificationKey);
}
public void Update(Employee employee)
{
if (employee == null)
throw new ArgumentNullException(nameof(employee), $"{nameof(employee)} is null.");
if (employee.EmployeeClassification != null)
employee.EmployeeClassificationId = employee.EmployeeClassification.Id;
using (var db = _dbConnectionFactory.OpenDbConnection())
db.Update(employee);
}
}


|
Modular Choice and Consent |
The farmer has a choice to opt-out of sharing data with an entity or with third parties if that sharing is not the primary purpose of the service or product. |
|
Third Party Audit and Certification |
An independent third party has certified that the internal privacy and use practices of an entity coincide with an entity’s stated policy, and has verified each assertion of true/false for these OADA principles. |
|
Deletion of Data Upon Request |
A farmer’s data is deleted upon the farmer’s request, with reasonable considerations for backup and recovery services. A particular farmer’s contribution to aggregated data is impossible to delete in general once it has become non-identifiable, so this principle refers only to data which is possible to identify and delete. |
|
Publicly accessible policies |
The privacy and use policies of a given entity and the assertions of true/false for each of these OADA principles are publicly available, and their locations are properly provided as described in the OADA API. |
|
Sharing of Identifiable Data with Third Parties |
A farmer explicitly controls who can see his or her data, and identifiable data shared with this entity is not provided to outside parties unless requested by the farmer. This includes personally identifiable data as well as geospatially identifiable data. |
|
Sharing of Anonymized or Aggregate Data with Third Parties |
Anonymous or aggregate data are not shared with third parties unless requested by the farmer. |
|
Internal Guidelines for Data Access |
A company has internal policies which limit access to farmer data to only those individuals and uses necessary to properly provide a farmer with a given service. |
|
Access and Transferability |
A farmer and his authorized agents are not intentionally denied access to the farmer’s data, and the farmer can transfer his or her data from a service at any time. |
|
Open Formats |
All data generated for a farmer is available to that farmer in a publicly published format. |


Our Mission
BLD PWR ENGAGES CULTURE, EDUCATION AND ACTIVISM TO BUILD AND TRAIN AN INCLUSIVE COMMUNITY OF ENTERTAINERS AND ATHLETES TO ADVANCE RADICAL SOCIAL CHANGE.  BLD PWR AIMS TO BUILD AN EQUITABLE SOCIETY.


| Table 1 |
Influences of explanatory variables on nestedness in pollina ... |
| Table 2 |
Influences of explanatory variables on modularity in pollina ... |
| Table 3 |
Influences of explanatory variables on nestedness in food we ... |
| Table 4 |
Influences of explanatory variables on modularity in food we ... |
| Table 5 |
Influences of explanatory variables on modularity in seed-di ... |


Plugin Information |
|---|
View Attention on the plugin site for more information. |
Description
A plugin to handle red builds in Jenkins. The plugin allows users to volunteer to investigate/fix red builds. It also creates a report with all volunteers and a summary report of all the current red builds in a view. For develops it's possible to extend the attention plugin to create your own build failure detection to populete the issue list.
Configuration
After installing the plugin you need to setup the plugin for sending mail and also adding the teams. Go to Manage Jenkins -> Configure System.
This plugin will also require that you enable user security and the users need to login before they can volunteer.
Volunteer to fix/investigate build
When a build goes red there will be a volunteer section on the build page where the users can volunteer them self or another user/team. The one volunteered will be notified via mail (if different from the logged in user).
Build Failure Report
The Build Failure report will list all the failed builds in the current view. Information such as number of failures and who broke the build initially will be displayed.
Volunteer Report
The volunteer report lists the builds that contains volunteers. At the beginning of the page the builds that the current user has volunteered for will be shown.
Extension point
If you are a developer and want to add your own issue detection you can write a class to your own plugin that extends the AttentionExtension class
Maven dependency
<dependency> <groupId>org.jenkins-ci.plugins</groupId> <artifactId>attention</artifactId> <version>X.X</version> <optional>true</optional> </dependency>
Example
@Extension public class JunitAttentionExtension extends AttentionExtension { @Override public List<DetectedIssue> getIssues(Run<?, ?> run) { List<TestResultAction> actions = run.getActions(TestResultAction.class); List<DetectedIssue> issues = new LinkedList<DetectedIssue>(); for (TestResultAction action : actions) { List<CaseResult> failedTests = action.getFailedTests(); for (CaseResult result : failedTests) { DetectedIssue issue = new DetectedIssue(TestResultAction.class.getName()); issue.setupTestFailure(result.getTitle(), result.getErrorDetails(), result.getFailedSince(), result.getFailCount()); issues.add(issue); } } return issues; } }
Versions
Version 1.1 (relased October 10, 2015)
- Made the dependency to junit optional
- Fixed a bug that would print the smtp password when configuring Jenkins
Version 1.0 (released October 09, 2015)
- The attention plugin was released to the public.
Attachments:
volunteer.png (image/png)
redbuild.png (image/png)
volunteerreport.png (image/png)


Image:
change image
ID:
state:
state
withdraw
on sale
ordered
wait for transaction
wait for confirm
completed
Name:
owner Id:
count:
price:
parent type:
select
type:
select
detail:
Return
Submit
Reset


rtc-tools
The rtc-tools
module does most of the heavy lifting within the
rtc.io suite. Primarily it handles the logic of coupling
a local RTCPeerConnection
with it's remote counterpart via an
rtc-signaller signalling
channel.
Getting Started
If you decide that the rtc-tools
module is a better fit for you than either
rtc-quickconnect or
rtc then the code snippet below
will provide you a guide on how to get started using it in conjunction with
the rtc-signaller (version 5.0 and above)
and rtc-media modules:
var messenger = require('rtc-switchboard-messenger');
var signaller = require('rtc-signaller')(messenger('https://switchboard.rtc.io/'));
var rtc = require('rtc-tools');
var getUserMedia = require('getusermedia');
var attachMedia = require('attachmediastream');
// capture local media first as firefox
// will want a local stream and doesn't support onnegotiationneeded event
getUserMedia({ video: true, audio: true }, function(err, localStream) {
if (err) {
return console.error('could not capture media: ', err);
}
document.body.appendChild(attachMedia(localStream));
// look for friends
signaller.on('peer:announce', function(data) {
var pc = rtc.createConnection();
var monitor = rtc.couple(pc, data.id, signaller);
// add the stream to the connection
pc.addStream(localStream);
// once the connection is active, log a console message
monitor.once('connected', function() {
console.log('connection active to: ' + data.id);
pc.getRemoteStreams().forEach(function(stream) {
document.body.appendChild(attachMedia(stream));
});
});
monitor.createOffer();
});
// announce ourself in the rtc-getting-started room
signaller.announce({ room: 'rtc-getting-started' });
});
This code definitely doesn't cover all the cases that you need to consider (i.e. peers leaving, etc) but it should demonstrate how to:
- Capture video and add it to a peer connection
- Couple a local peer connection with a remote peer connection
- Deal with the remote steam being discovered and how to render that to the local interface.
Reference
createConnection
createConnection(opts?, constraints?) => RTCPeerConnection
Create a new RTCPeerConnection
auto generating default opts as required.
var conn;
// this is ok
conn = rtc.createConnection();
// and so is this
conn = rtc.createConnection({
iceServers: []
});
rtc-tools/cleanup
cleanup(pc)
The cleanup
function is used to ensure that a peer connection is properly
closed and ready to be cleaned up by the browser.
rtc-tools/couple
couple(pc, targetId, signaller, opts?)
Couple a WebRTC connection with another webrtc connection identified by
targetId
via the signaller.
The following options can be provided in the opts
argument:
sdpfilter
(default: null)A simple function for filtering SDP as part of the peer connection handshake (see the Using Filters details below).
Example Usage
var couple = require('rtc/couple');
couple(pc, '54879965-ce43-426e-a8ef-09ac1e39a16d', signaller);
Using Filters
In certain instances you may wish to modify the raw SDP that is provided
by the createOffer
and createAnswer
calls. This can be done by passing
a sdpfilter
function (or array) in the options. For example:
// run the sdp from through a local tweakSdp function.
couple(pc, '54879965-ce43-426e-a8ef-09ac1e39a16d', signaller, {
sdpfilter: tweakSdp
});
rtc-tools/detect
Provide the rtc-core/detect functionality.
rtc-tools/generators
The generators package provides some utility methods for generating constraint objects and similar constructs.
var generators = require('rtc/generators');
generators.config(config)
Generate a configuration object suitable for passing into an W3C RTCPeerConnection constructor first argument, based on our custom config.
In the event that you use short term authentication for TURN, and you want
to generate new iceServers
regularly, you can specify an iceServerGenerator
that will be used prior to coupling. This generator should return a fully
compliant W3C (RTCIceServer dictionary)[http://www.w3.org/TR/webrtc/#idl-def-RTCIceServer].
If you pass in both a generator and iceServers, the iceServers _will be ignored and the generator used instead.
generators.connectionConstraints(flags, constraints)
This is a helper function that will generate appropriate connection
constraints for a new RTCPeerConnection
object which is constructed
in the following way:
var conn = new RTCPeerConnection(flags, constraints);
In most cases the constraints object can be left empty, but when creating
data channels some additional options are required. This function
can generate those additional options and intelligently combine any
user defined constraints (in constraints
) with shorthand flags that
might be passed while using the rtc.createConnection
helper.
rtc-tools/monitor
monitor(pc, targetId, signaller, parentBus) => mbus
The monitor is a useful tool for determining the state of pc
(an
RTCPeerConnection
) instance in the context of your application. The
monitor uses both the iceConnectionState
information of the peer
connection and also the various
signaller events
to determine when the connection has been connected
and when it has
been disconnected
.
A monitor created mbus
is returned as the result of a
couple between a local peer
connection and it's remote counterpart.
License(s)
Apache 2.0
Copyright 2015 National ICT Australia Limited (NICTA)
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


{% extends 'base.html' %} {% block title %}UWCS | Unsubscribed{% endblock %} {% block content %} Unsubscribe successful {{ email }} has been successfully unsubscribed from the University of Warwick Computing Society newsletter Back to the home page {% endblock %}
{{ email }} has been successfully unsubscribed from the University of Warwick Computing Society newsletter
Back to the home page


SEA OF LOVE A film review by Peter Reiher Copyright 1989 Peter Reiher
Throughout the history of film, great screen actors frequently appear in films that really aren't worthy of them. Bogart, Tracy, Garbo, Brando, anyone you care to name, really, all appeared in films that not only were not great, but clearly had no chance of being great from the word "go." Their scripts were unoriginal and average, their directors were not top-flight, sometimes the production values weren't all that great. But the classic film actors were always able to make such films worth watching, despite the fact that the same film made with a perfectly competent actor in the role would have been just another piece of mediocrity. Perhaps even more than their successes in strong roles, great film actors can be defined by the interest they bring to lesser roles.
Al Pacino establishes that he is that kind of actor in SEA OF LOVE. The script, while acceptable, is only a bit above average, and of a genre we really see too much of today, the police thriller. Director Harold Becker has done a couple of good films, but none that stand far out from the pack. The entire film is reasonably well made, the supporting cast gives a couple of strong performances, but, if it weren't for Pacino, this film would be indistinguishable from any of a dozen other police thrillers released this year.
The script's central premise owes something to JAGGED EDGE -- instead of an attorney falling for a client who may be guilty of murder, it's a cop falling for a suspect who may be guilty of murder, with sexes reversed. Pacino plays a twenty-year man whose life is hollow and meaningless. While investigating the murder of a couple of men who had advertised in a singles paper, he finds himself increasingly attracted to a woman who may have answered their ads. Is he really falling for a murderer? His instincts are too ambivalent to trust, evidence is present but weak, and he has so far lost track of his center that he has no resources to fall back on.
While not fully original, the central idea behind SEA OF LOVE has possibilities. And having a woman as the suspect, rather than a man, adds another layer of complexity. But the script does not play with the idea all that well.  But the film takes nearly an hour to introduce the woman, and screenwriter Richard Price does not build up the suspense as well as he could have. There are too few moments when the woman may suddenly pull out a gun and blow the hero away.
However, Pacino takes over where Price leaves off. Pacino is always best as a man under heavy pressure. As Michael Corleone, Pacino contained the pressure. In DOG DAY AFTERNOON, he let it explode. Here, he charts a middle course, trying to keep it in, but ultimately unable to hold it back. While not up to the standard of these earlier performances, Pacino demonstrates that he has lost none of his fire. Pacino also does a nice job of differentiating this character from his previous parts -- this isn't just Michael Corleone as a disillusioned cop, or Serpico as an alcoholic sellout.
 Ellen Barkin is a nice choice for the mystery woman. Barkin's odd looks always suggest more beneath the surface than what shows, and that is precisely the quality that this part demands. Price has not gone quite far enough in drawing her character to make it completely successful, but Barking does a good job of filling in the blanks. John Goodman is strong in the only other major part in the film, Pacino's partner. Oddly, his performance, good as it is, probably detracts more from the films intentions than it adds, since his basic good humor and niceness undercut the suspense. By offering Pacino's character a mechanism to release some of the steam, Goodman also releases some of the film's tension.
Price has not constructed his screenplay as well as he could have, but his dialog is excellent, excepting only the final scene. That scene lacks the snap necessary to provide a satisfactory wrapup to the story. If Price had any really great lines saved up for a rainy day, this scene was the place to use them. This deficiency is partially compensated by a few sharp observations that Price manages to fit in around the edges of the story. His plot plays the police thriller game fairly, but is not sufficiently clever to stand out.
Harold Becker proves to be a reasonable choice for the director. He does particularly well at capturing Pacino's performance. He succeeds in providing a few tense moments, and keeps up the mood well. Becker also does nicely in shading in some minor characters who were probably only vague suggestions in the script. On the whole, his direction is unobtrusive. One can imagine that Martin Scorsese or Sidney Lumet could have done much more, but Price does enough. The technical credits also are fairly average.
SEA OF LOVE is worth seeing, for those who like the genre or those who like Pacino. The various elements of the film are at least average, and Pacino's performance raises the overall effort to a higher level. SEA OF LOVE may never be remembered as a great film, but twenty years from now it's likely to be regarded as a nice minor film of a great actor.
Peter Reiher<EMAIL_ADDRESS>(DO NOT send to<EMAIL_ADDRESS>. . . cit-vax!elroy!jato!jade!reiher
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Clocker-Mobile is designed to be used in tandem with the Clocker web app, enabling users to sign in remotely to clocker via their smartphone. I used the Ionic framework, which allowed me to the use JavaScript and Angular to build an app that will run natively on an iPhone or Android device (currently only tested on ios, however). I also used WebSockets to enable real-time communication between the Clocker Mobile app and the Clocker 2.0 wep app.
Important Note:
Currently, an organization must be logged in to the clocker web app in order to accept remote sign-ins from the clocker-mobile app. Upcoming versions, however, will support remote sign-in even if the parent organization is not logged in.
Clocker-mobile is designed to run natively on your smartphone. For demoing purposes, however, please visit clocker-mobile.com to try out the app.


Windows Phone 8.0 Progress Helper Assembly
http://temporalwars.com/CodeHelpers/WpProgressBar
This WP8.0 Progress Helper assembly is used to display progress feedback using the built-in WP progress-bar using a separate thread to avoid visual stalls.
This is one of my first WP8.0 assemblies used to help ease development on Windows Phone. I will be adding additional WP8.0 assemblies in the near future.
I use a default namespace string for all helper assemblies, making it easier to organize and locate assemblies within projects. Each helper assembly will be marked with the following default namespace: "BenScharbach.WP8.Helpers", with the actual namespace's
specific name at the end of the default namespace; for example, 'WPProgressHelper' for this assembly.
Windows Phone 8.0 SDK contains a ProgressIndicator class to communicate with the visual bar at the top of the phone. This built-in bar, located at the top of the phone, allows communication for iteration operations to the end-user.
The ProgressIndicator in Window Phone requires a fully non-blocked UI mode in order to see progress updates in real-time.. Consequently, this requires any calling code to use a separate thread to run their progress iteration tasks. Communication to this ProgressIndicator
then must be done through the UI dispatcher thread to achieve the real-time updates end-users demand.
To use this helper, create the Progress<generic> instance and pass in the collection of <generic> items via the constructor. Now simply iterate the collection in C# using the Items method call, which will then take care of the per index calls to
the ProgressIndicator within the phone.
Note: The calling code should have a thread created; otherwise, the UI updates will be blocked. In a future update, this requirement will be handled by the Progress<generic> class helper.
Thanks,
Ben Scharbach


MARINA WALK
Puteri Harbour
Global retail in F&B
the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five.


Dear Honorable Sir, I draw your kind attention to the fact that I am a trainee of Round-43 [Batch - CF/BITI-A/43/01] Trainee ID: 1255613. I am familiar with some programming languages. So I am very interested to learn programming languages.


Try the Latest Xamarin.Forms 4.7 Features Today! | Xamarin Blog Xamarin.Forms 4.7 is a collection of new feature additions and improvements to unleash your creative application development skills!
Introducing AWS Snowcone – A Small, Lightweight, Rugged, Secure Edge Computing, Edge Storage, and Data Transfer Device | Amazon Web Services Last month I published my AWS Snowball Edge Update and told you about the latest updates to Snowball Edge, including faster storage-optimized devices with more memory & vCPUs, the AWS OpsHub for Snow Family GUI-based management tool, IAM for Snowball Edge...
A virtual developer conference with a SciFi/Fantasy comic-con flair SciFiDevCon is a three day conference with a SciFi/Comic/Fantasy flair. We are filling a gap for holding a tech conference online due to missing out on a number of our favorite conferences due to the Covid19 pandemic
Time to upgrade your monitor A non-comprehensive and opinionated guide to best monitor for programming
End-to-End Encryption Update - Zoom Blog Since releasing the draft design of Zoom’s end-to-end encryption (E2EE) on May 22, we have engaged with a number of organizations to gather feedback.
Learn Python for Data Science Full Course - Kharpann Learn Python for Data Science in this full course curated by the data science team at Kharpann. This course will take you from zero to hero in Python.
Simplify DisplayName Calls In Razor Views Razor is a sharp user interface language, but it can also cut into our sensibilities and aesthetic code choices. ASP.NET ships with many HTML helpers to help reduce the amount of code we write to ship user interfaces, and for the most part, they work pret...
The Grandmaster Who Got Twitch Hooked on Chess Hikaru Nakamura is the top-ranked blitz chess player in the world—and his channel has seen a meteoric rise as he coaches streamers in the ancient game.
Running NServiceBus Endpoints in Azure App Services Part 3: Pulling Back the Curtain on Visual Studio Publish In Part 2, we used Visual Studio's Publish feature to deploy our NServiceBus endpoint to an Azure App Service, and after only one manual change in the Azure Portal, saw our endpoint successfully running by viewing the app service logs. In this post, we'll...
Proxyjump, the SSH option you probably never heard of Today, it is becoming more and more common for Penetration Testers, Security Researchers, Red Teams, and the like to require some sort of…
Fix IL interpreter to run on Hello World by yuchong-pan · Pull Request #37825 · dotnet/runtime Bug fix: Fix type casts in interpreter.cpp to make the codebase compile on Windows when FEATURE_INTERPRETER is turned on. Bug fix: Special case get_IsSupported in the interpreter to semantically co...
Fun with Bit Hacks in C# What are bit hacks and why would you want to use them? This video will show you why they are important for performance reasons and how use them to do Batching and Branch elimination. Source code: https://github.com/badamczewski/DataOrientedDesign/blob/ma...
Workshop: Web performance matters 1/2 - NDC Melbourne 2020 Module 1/2Yas has been optimising performance for many web applications throughout his career, and along the way has learnt a ton of techniques which easily will result in performance boost. He also has an extensive blog series on web per...
GitHub isn't fun anymore At first I thought it was just me getting older and more experienced. But after several conversations about it with colleagues and other open source maintainers, I'm not the only one who feels this way.
https://www.linqpad.net/linqpad6.aspx#beta LINQPad 6 targets .NET Core 3 for Windows. This means that your queries run under the .NET Core 3 runtime, and you can reference .NET Core assemblies. You can run LINQPad 5 side-by-side for .NET Framework compatibility.
A Jupyter kernel for SQLite While it is well known in the Python scientific computing community, Jupyter is in fact a language-agnostic development environment…

Make your PWA feel more like an app Learn how to make your Progressive Web App feel like a "real" app by understanding how to implement native app patterns with web technologies.
Standalone Q# console applications | StrathWeb. A free flowing web tech monologue. Last week I wrote a guest post on the Q# community blog about the new standalone/self-contained Q# applications that were introduced in Microsoft Quantum Development Kit 0.11.2004.2825.
Monsters Weekly 169 - Giraffe Writing your ASP.NET in C# is not the only option. With Giraffe you can write you controllers in F#. Also covered: Tech Empower benchmarks https://www.techempower.com/benchmarks/#section=data-r19&
Explore the stunning LEGO® Technic Lamborghini Sián View the LEGO® Technic Lamborghini Sián FKP 37 with V12 engine and scissor doors, the ultimate adult LEGO collectible model, perfect for display
Zoom to Introduce New Censorship Features After Doing China's Bidding If you are into discussing private matters or sensitive topics like the Tiananmen Square tragedy over video calls, don't use Zoom for that. The service announced a new feature that would make it easier to ban people from the desired country at their gover...
FreeBSD 11.4-RELEASE Announcement The FreeBSD Release Engineering Team is pleased to announce the availability of FreeBSD 11.4-RELEASE. This is the fifth and final release of the stable/11 branch.
Introducing C# 9: Init only properties Introduction .NET 5 brings a new version of the C# language: C# 9. In this...
The Importance of Nesting when Remote Working and Quarantine Working We've all learned the hard way that Quarantine work is not Remote work. It doesn't feel the same because it's not the ...
Honoring Our Beloved Melody Lo organized by Amineta Lo On June 15th, 2020, my family and I lost the most important person in our lives. My mother … Amineta Lo needs your support for Honoring Our Beloved Melody Lo
ASP.NET Community Standup - June 16, 2020 - Performance Infrastructure (David Fowler & Sébasten Ros) Join members from the ASP.NET teams for our community standup covering great community contributions for ASP.NET, ASP.NET Core, and more. Community links for this week: https://www.theurlist.com/aspnet-standup-2020-06-16
Home | Geany Many parts of Geany are heavily customizable like color themes (Geany Themes) or adding new filetypes.
GitHub Terms of Service - GitHub Help Thank you for using GitHub! We're happy you're here. Please read this Terms of Service agreement carefully before accessing or using GitHub. Because it is such an important contract between us and our users, we have tried to make it as clear as possible. ...
The Russian Disinfo Operation You Never Heard About The campaign known as Secondary Infektion appears to be a distinct effort from the meddling of the IRA and GRU—and it went undetected for years.
Super secretive Russian disinfo operation discovered dating back to 2014 | ZDNet Researchers uncover six-years-worth of Russian attempts to mold international politics using fake news and forged documents.
Executive Summary Exposing Secondary Infektion - Forgeries, interference, and attacks on Kremlin critics across six years and 300 sites and platforms.
Linux GUI applications in the Windows Subsystem for Linux (WSL) survey Linux GUI applications in the Windows Subsystem for Linux (WSL) survey
Apple Threatens to Remove Email App 'Hey' From App Store Over Lack of In-App Subscription Option [Updated] A new email app called "Hey" from the team at Basecamp has run into trouble with Apple for refusing to offer a subscription option that can...
Are 14 people currently looking at this product? Blatant lies revealed in the source code for an online shop.
Bootstrap 5 alpha! Bootstrap 5’s very first alpha has arrived! We’ve been working hard for several months to refine the work we started in v4, and while we’re feeling great about our progress, there’s still even more to do.
Introducing Sdkbin - The Marketplace for Software Developers. Sell support plans, licenses, trials, and more directly to end-users using NuGet and other package managers.


package textformat
Ordering
- Alphabetic
Visibility
- Public
- All
Type Members
- class Parser extends AnyRef
- trait ParserCompat extends AnyRef
- case class Position(line: Int, col: Int) extends Product with Serializable
- trait ProtoAsciiParsing extends AnyRef
- final case class TArray(position: Position, values: Seq[TValue]) extends TValue with Product with Serializable
- final case class TBytes(position: Position, value: String) extends TPrimitive with Product with Serializable
- final case class TField(position: Position, name: String, value: TValue) extends Product with Serializable
- final case class TIntLiteral(position: Position, value: BigInt) extends TPrimitive with Product with Serializable
- final case class TLiteral(position: Position, value: String) extends TPrimitive with Product with Serializable
- final case class TMessage(position: Position, fields: Seq[TField]) extends TValue with Product with Serializable
- sealed trait TPrimitive extends TValue
- sealed trait TValue extends AnyRef
- class TextGenerator extends AnyRef
- class Tokenizer extends AnyRef


We'll only contact you when it's important.
Select one:
We'll ask you to confirm this before you can use the service


{% load staticfiles %}
An introduction
See what's happening around your area in a map, calendar or list view. Use the sidebar to filter by tags (green boxes), groups (red boxes), or collections (grey boxes). If you prefer to search for a specific title, location, or tag, you can do that as well.
If you want to watch Game of Thrones with others, skip the e-mail and make an event on OC. Missed dinner? Find the free food event or study break closest to you by clicking "food" and checking the map view - no need to comb through "FreeFood" e-mails.
Simply check "Private" in the Make view, select the group you want to restrict this event to, and hit Save to ensure that only they can see it.
Facebook integration allows you to easily import friends and groups from Facebook and export any events you have created in OC for easy cross-posting.
While the map defaults to Princeton, the default location can easily be changed within the Settings view - use OC around the world.


Project Information
Name
Priority
Estimated Hours
Start Date
Email contact
Staging URL
Project Color


| ^a${value} Second(s) Recharge | 8 |
| ${value}% Chance of Activating | 25 |
| ${value} Energy Reserved | 100 |
| ${value}m Radius | 3 |
| ${value} Physical Damage | min: [15.0, 30.0, 45.0, 60.0, 75.0, 90.0, 105.0, 120.0, 135.0, 150.0, 165.0, 180.0, 195.0, 210.0] |
| MaxLevel | 10 |
| UltimateLevel | 14 |


×
Browse
Upload
Dashboard
Logout
☰ Menu
Logout
×
Are you sure you want to logout?
{% block content %} {% endblock %}


Jana Garage
Status
UNKNOWN
Operate Door
Visual
Start Camera
Other Details
Temperature:
Time
Sensor Range:


The basic user interface of MLD2P4 consists of eight methods. The six
methods init
, set
, build
,
hierarchy_build
, smoothers_build
and apply
encapsulate all the functionalities for the setup and the application
of any multilevel and one-level preconditioner implemented in the
package.
The method free
deallocates the preconditioner data structure, while
descr
prints a description of the preconditioner setup by the user.
For backward compatibility, methods are also accessible as
stand-alone subroutines.
For each method, the same user interface is overloaded with respect to the real/ complex case and the single/double precision; arguments with appropriate data types must be passed to the method, i.e.,
psb_
xspmat_type
with x = s
for real single precision, x = d
for real double precision, x = c
for complex single precision,
x = z
for complex double precision;
mld_
xprec_type
, with x =
s
, d
, c
, z
, according to the sparse
matrix data structure;
psb_
xvect_type
with x =
s
, d
, c
, z
, in a manner completely
analogous to the sparse matrix type;


| Opcode | Instruction | 64-Bit Mode | Compat/Leg Mode | Description |
| DB F0+i | FCOMI ST, ST(i) | Valid | Valid | Compare ST(0) with ST(i) and set status flags accordingly. |
| DF F0+i | FCOMIP ST, ST(i) | Valid | Valid | Compare ST(0) with ST(i), set status flags accordingly, and pop register stack. |
| DB E8+i | FUCOMI ST, ST(i) | Valid | Valid | Compare ST(0) with ST(i), check for ordered values, and set status flags accordingly. |
| DF E8+i | FUCOMIP ST, ST(i) | Valid | Valid | Compare ST(0) with ST(i), check for ordered values, set status flags accordingly, and pop register stack. |
Performs an unordered comparison of the contents of registers ST(0) and ST(i) and sets the status flags ZF, PF, and CF in the EFLAGS register according to the results (see the table below). The sign of zero is ignored for comparisons, so that -0.0 is equal to +0.0.
| Comparison Results* | ZF | PF | CF |
| ST0 > ST(i) | 0 | 0 | 0 |
| ST0 < ST(i) | 0 | 0 | 1 |
| ST0 = ST(i) | 1 | 0 | 0 |
| Unordered** | 1 | 1 | 1 |
Notes: * See the IA-32 Architecture Compatibility section below. ** Flags not set if unmasked invalid-arithmetic-operand (#IA) exception is generated.
An unordered comparison checks the class of the numbers being compared (see “FXAM—Examine ModR/M” in this chapter). The FUCOMI/FUCOMIP instructions perform the same operations as the FCOMI/FCOMIP instructions. The only difference is that the FUCOMI/FUCOMIP instructions raise the invalid-arithmetic-operand exception (#IA) only when either or both operands are an SNaN or are in an unsupported format; QNaNs cause the condition code flags to be set to unordered, but do not cause an exception to be generated. The FCOMI/FCOMIP instructions raise an invalid-operation exception when either or both of the operands are a NaN value of any kind or are in an unsupported format.
If the operation results in an invalid-arithmetic-operand exception being raised, the status flags in the EFLAGS register are set only if the exception is masked.
The FCOMI/FCOMIP and FUCOMI/FUCOMIP instructions set the OF, SF and AF flags to zero in the EFLAGS register (regardless of whether an invalid-operation exception is detected).
The FCOMIP and FUCOMIP instructions also pop the register stack following the comparison operation. To pop the register stack, the processor marks the ST(0) register as empty and increments the stack pointer (TOP) by 1.
This instruction’s operation is the same in non-64-bit modes and 64-bit mode.
The FCOMI/FCOMIP/FUCOMI/FUCOMIP instructions were introduced to the IA-32 Architecture in the P6 family processors and are not available in earlier IA-32 processors.
CASE (relation of operands) OF ST(0) > ST(i): ST(0) < ST(i): ST(0) = ST(i): ESAC; IF Instruction is FCOMI or FCOMIP THEN IF ST(0) or ST(i) = NaN or unsupported format THEN #IA IF FPUControlWord.IM = 1 THEN ZF, PF, CF ← 111; FI; FI; FI; IF Instruction is FUCOMI or FUCOMIP THEN IF ST(0) or ST(i) = QNaN, but not SNaN or unsupported format THEN ZF, PF, CF ← 111; ELSE (* ST(0) or ST(i) is SNaN or unsupported format *) #IA; IF FPUControlWord.IM = 1 THEN ZF, PF, CF ← 111; FI; FI; FI; IF Instruction is FCOMIP or FUCOMIP THEN PopRegisterStack; FI;
| C1 | Set to 0. |
| C0, C2, C3 | Not affected. |
| #IS | Stack underflow occurred. |
| #IA | (FCOMI or FCOMIP instruction) One or both operands are NaN values or have unsupported formats. (FUCOMI or FUCOMIP instruction) One or both operands are SNaN values (but not QNaNs) or have undefined formats. Detection of a QNaN value does not raise an invalid-operand exception. |
| #NM | CR0.EM[bit 2] or CR0.TS[bit 3] = 1. |
| #MF | If there is a pending x87 FPU exception. |
| #UD | If the LOCK prefix is used. |
Same exceptions as in protected mode.
Same exceptions as in protected mode.
Same exceptions as in protected mode.
Same exceptions as in protected mode.


Genelia D'Souza pens a heartfelt note for son Riaan Deshmukh on his birthday today
by FilmfareGenelia D'Souza and Riteish Deshmukh's son Riaan turns a year older today. On this special day, mommy Genelia took to her social media handle and shared a warm note full of love for her little bundle of joy. The couple recently hosted a special birthday bash which was attended by the who's who of the tinsel town and their kids.
In her special birthday note, Genelia wrote, "Dearest Riaan, Every parent says 'I don’t want him to grow up, I want to freeze this age forever'... But I don’t... I want to enjoy every year of yours, I want to see you grow into a fine young man, I want to give you wings to fly and I’d like to be the wind beneath those wings. I want to tell you that life is tough but you are tougher, I want you to always believe in yourself no matter what happens cause I will always believe in you...Apart from everything I want and I wish for you, the one thing I never want to fail to let you know, is that I love you so so so much and you are the greatest thing that happened to me... There is nothing I’d rather see than your smile and nothing I’d rather hear than your laughter. For all the things my hands have held, the best by far is you. Happy Birthday to the little boy who made me a Mom-My First Born
ï¸Â."
This surely speaks volumes of Genelia's love for her baby boy Riaan.


Challenge Source: Defcon 28 - Red Team Village CTF
Challenge Category: programming
Programming - Roll for Initiative 1
When connecting to the server, the “Backdoors and Breaches” game begins and we need to “Roll for Initiative”:
Experimenting a bit we find:
An integer between 1 and 20 needs to be provided as an input.
The number needs to match an expected value.
If it does we’re asked to “Roll again” and provide another input. We’re told that doing this 10 times will result in a “prize” which we can hope is the flag.
If it does not, we’re told it does not match, what the number should have been and the connection is broken.
The expected numbers and their order do not change when we re-establish a connection to the server.
Our code therefore needs to open a connection to the server, submit some values, keep track of the correct values, restart the connect when an incorrect value is submitted, and find the flag, which we know will probably have ‘{‘ in it.


--- layout: post title: "The Business of Ed-Tech: October 2018 Funding Data" date: 2018-11-01 18:50:00 +0000 tags: image: https://s3.amazonaws.com/hackedu/2017-03-01-money.jpg imagecredits: https://www.flickr.com/photos/chrisdlugosz/3403776466 ---
Here is the latest data on “the business of education” for October 2018:
Although the amount of money invested in education companies ticked up this month (following very low levels of investment in August and September), it’s worth noting that almost half of the total invested went to one company: BYJU’s. This is a test-prep/tutoring company, and this sub-sector of education companies remains the best funded – this year as in previous ones. Just a reminder: tutoring exacerbates inequality by expecting families to pay for education (as opposed to, say, publicly funding high quality education for everyone). So congrats to everyone who’s in on this one, notably this month Arielle Zuckerberg – yes, that’s Mark’s little sister. And yes, the Chan Zuckerberg Initiative is one of BYJU’s many investors
The companies that have raised the most money so far this year (not including the venture capital firms that have raised new funds):
As far as I can tell, these are now the most well-funded ed-tech startups (that is, those education companies which have not gone public):
As part of this project, you can review information from the last few years who’s received funding, who’s been acquired, who’s IPO’d, which startups have closed, and who’s investing in the stories that Edsurge tells you about the shape of the education technology industry.
I have created separate GitHub repositories for all areas of funding that I monitor:
These sites include human- and machine-readable versions of this funding data. For more ed-tech data sets, visit Hack Education Data on GitHub.
(If you see an error or omission, please file a GitHub issue. You’re welcome to fork or download the repositories too, of course.)


Lorem ipsum dolor sit amet event landing template
A visual approach is an approach to a runway at an airport
conducted under instrument flight rules. The pilot must at all times have either the airport or the preceding aircraft in approach correct sight. conducted under instrument flight rules. The pilot must at all times.
Preceding aircraft in approach correct sight. conducted under instrument flight rules.
A visual approach is an approach to a runway at an airport conducted under instrument flight rules. The preceding aircraft in approach correct sight.
Lorem ipsum dolor sit amet event landing template
Lorem ipsum dolor sit amet event landing template
Our most popular service is our Virtual Receptionist. We know that sometimes it’s something and you middle most this job was posted less than five minutes ago, and we think it’s a good match for you. If you submit a proposal now, you’ll be one of the first candidates. You may even catch the client while they’re still online. Know More →
Our most popular service is our we know that sometimes it’s something and you middle most.. Know More →
Our most popular service is our Virtual Receptionist. We know that ... Know More →
We know that sometimes it’s something and you middle most.. Know More →
Our most popular service is our new virtual Receptionist you middle most.. Know More →
Our most popular service is our Virtual Receptionist. We know that sometimes it’s something and you middle most.. Know More →
Lorem ipsum dolor sit amet event landing template
Lorem ipsum dolor sit amet event landing template
Anna Lee / Web Designer
Lorem Ipsum is not simply is an action designer random text It has roots in a piece.


--- title: Accessibility ---
Care about accessibility or want to contribute? Submit a Pull Request or get into the conversation on GitHub.
*** ## Basic Concepts - OverviewThe most common impairments for web users are those with problems seeing, hearing or a physical inability to use a mouse. For that reason, the site must be navigatable by keyboard. Most commonly the tab key is used to tab through the content. For a vision impaired person will have a screenreader installed that reads the content out loud. We used Chromevox to test with. You can find a list of popular screen readers below in the resource list.
### How to Test a Website’s Keyboard AccessibilityOn a desktop or laptop in Firefox, IE, Chrome, or Safari, click into the browser address bar.
 Using the Tab button, navigate until you’ve reached the link below. (You can use Shift+Tab to navigate back one step.)
Give the person the ability to skip the navigation at the top of the page. If you have menu with 40 links, you can imagine how long it would take someone to tab through all that. Here's one way to do it:
Note: A person who can see may be slightly confused that their focus is off screen. This is a minor compromise for this method.
*** ### Nested HeadingsWhen nesting headings `


| 1 |
Lin_X_2017 |
Attitudes of consumers and live-poultry workers to central slaughtering in controlling H7N9: a cross-sectional study |
Lin, Xiao; Zhang, Dingmei; Wang, Xinwei; Huang, Yun; Du, Zhicheng; Zou, Yaming; Lu, Jiahai; Hao, Yuantao |
2017 |
2017-05-26 |
COMM-USE |
N |
PMC5446744 |
28549473.0 |
10.1186/s12889-017-4374-9 |
dpgbq2zz |
0.845578 |
|
|
| 2 |
Qi_X_2014 |
Calculating the burden of disease of avian-origin H7N9 infections in China |
Qi, Xiaopeng; Jiang, Dong; Wang, Hongliang; Zhuang, Dafang; Ma, Jiaqi; Fu, Jingying; Qu, Jingdong; Sun, Yan; Yu, Shicheng; Meng, Yujie; Huang, Yaohuan; Xia, Lanfang; Li, Yingying; Wang, Yong; Wang, Guohua; Xu, Ke; Zhang, Qun; Wan, Ming; Su, Xuemei; Fu, Gang; Gao, George F |
2014 |
2014-01-17 |
None |
N |
PMC3902515 |
24441057.0 |
10.1136/bmjopen-2013-004189 |
ayxfsx1q |
0.842148 |
|
|
| 3 |
Huang_2017 |
Comparison of E-commerce Regulations in Chinese and American FTAs: Converging Approaches, Diverging Contents, and Polycentric Directions? |
Huang, Jie |
2017 |
2017-08-08 |
PMC |
N |
PMC7149125 |
|
10.1007/s40802-017-0094-1 |
uxcce0mt |
0.704008 |
|
Song_2005, Cho_M_2007, Liou_2020, Cooke_2017 |
| 4 |
Xiao_2006 |
Supply chain disruption management and evolutionarily stable strategies of retailers in the quantity-setting duopoly situation with homogeneous goods |
Xiao, Tiaojun; Yu, Gang |
2006 |
2006-09-01 |
PMC |
N |
PMC7127244 |
|
10.1016/j.ejor.2005.02.076 |
5xlrcjtr |
0.703627 |
Chen_2007 |
Feng_2017, Zhang_2013, Cooke_2017 |
| 5 |
Qiu_S_2015 |
Is Tuberculosis Treatment Really Free in China? A Study Comparing Two Areas with Different Management Models |
Qiu, Sangsang; Pan, Hongqiu; Zhang, Simin; Peng, Xianzhen; Zheng, Xianzhi; Xu, Guisheng; Wang, Min; Wang, Jianming; Lu, Hui |
2015 |
2015-05-20 |
COMM-USE |
N |
PMC4439067 |
25993411.0 |
10.1371/journal.pone.0126770 |
6n7aq4k9 |
0.701234 |
|
|
| 6 |
Zhou_2016 |
Fear and trust: How risk perceptions of avian influenza affect Chinese consumers’ demand for chicken |
Zhou, Li; Turvey, Calum G.; Hu, Wuyang; Ying, Ruiyao |
2016 |
2016-09-30 |
PMC |
N |
PMC7148954 |
|
10.1016/j.chieco.2016.06.003 |
rk7ijexa |
0.661125 |
|
Lin_X_2017, Sealy_2019 |
| 7 |
Sealy_2019 |
Poultry trading behaviours in Vietnamese live bird markets as risk factors for avian influenza infection in chickens |
Sealy, Joshua E.; Fournie, Guillaume; Trang, Pham Hong; Dang, Nguyen Hoang; Sadeyen, Jean‐Remy; Thanh, To Long; van Doorn, H. Rogier; Bryant, Juliet E.; Iqbal, Munir |
2019 |
2019-08-09 |
COMM-USE |
N |
PMC6899644 |
31357255.0 |
10.1111/tbed.13308 |
17twe8bv |
0.651628 |
|
|
| 8 |
Ng_E_2006 |
Exploring the Major Factors Influencing Consumer Selection of Travel Agencies in a Regional Setting |
Ng, Eric; Cassidy, Frances; Brown, Les |
2006 |
2006-04-30 |
PMC |
N |
|
|
10.1375/jhtm.13.1.75 |
fmsa7ket |
0.649940 |
|
Ladkin_2005, Yang_2010, Li_M_2015, Law_R_2008 |
| 9 |
Weng_2004 |
Feature-based recommendations for one-to-one marketing |
Weng, Sung-Shun; Liu, Mei-Ju |
2004 |
2004-05-31 |
PMC |
N |
PMC7127642 |
|
10.1016/j.eswa.2003.10.008 |
4nnqw8gn |
0.635633 |
|
Cho_V_2010, Cosmas_2013 |
| 10 |
Pendell_2015 |
Economic Assessment of FMDv Releases from the National Bio and Agro Defense Facility |
Pendell, Dustin L.; Marsh, Thomas L.; Coble, Keith H.; Lusk, Jayson L.; Szmania, Sara C. |
2015 |
2015-06-26 |
COMM-USE |
N |
PMC4482686 |
26114546.0 |
10.1371/journal.pone.0129134 |
w7q5o8wc |
0.594315 |
|
|
| 11 |
Nghiem_2013 |
Economic and Environmental Impacts of Harmful Non-Indigenous Species in Southeast Asia |
Nghiem, Le T. P.; Soliman, Tarek; Yeo, Darren C. J.; Tan, Hugh T. W.; Evans, Theodore A.; Mumford, John D.; Keller, Reuben P.; Baker, Richard H. A.; Corlett, Richard T.; Carrasco, Luis R. |
2013 |
2013-08-09 |
COMM-USE |
N |
PMC3739798 |
23951120.0 |
10.1371/journal.pone.0071255 |
976j65ji |
0.558363 |
|
|
| 12 |
de_Melo_2014 |
Profile of international air passengers intercepted with illegal animal products in baggage at Guarulhos and Galeão airports in Brazil |
de Melo, Cristiano Barros; Pinheiro de Sá, Marcos Eielson; Alves, Flaviane Faria; McManus, Concepta; Aragão, Lucas Fernandes; Belo, Bruno Benin; Campani, Paulo Ricardo; da Matta Ribeiro, Antonio Cavalcanti; Seabra, Christina Isoldi; Seixas, Luiza |
2014 |
2014-02-06 |
COMM-USE |
N |
PMC3925492 |
24567878.0 |
10.1186/2193-1801-3-69 |
o3hibw1h |
0.530056 |
|
Lin_X_2017 |
| 13 |
Pendell_2014 |
Economic Assessment of Zoonotic Diseases: An Illustrative Study of Rift Valley Fever in the United States |
Pendell, D. L.; Lusk, J. L.; Marsh, T. L.; Coble, K. H.; Szmania, S. C. |
2014 |
2014-07-23 |
PMC |
N |
PMC7169821 |
25052324.0 |
10.1111/tbed.12246 |
y1mp2uv7 |
0.433898 |
|
|
| 14 |
Chen_2017 |
Transshipment hub selection from a shipper's and freight forwarder's perspective |
Chen, Gang; Cheung, Waiman; Chu, Sung-Chi; Xu, Liang |
2017 |
2017-10-15 |
PMC |
N |
PMC7125789 |
|
10.1016/j.eswa.2017.04.044 |
8ak0o0pv |
0.359550 |
|
Campa_2016, Yang_2010, Cho_M_2007 |
| 15 |
Yun_Q_2019 |
Chapter 8 Politics, Profit and Digital Prospect Guangdong Provincial Publishing Group as a Case |
Yun, Qidong |
2019 |
2019-12-31 |
PMC |
N |
PMC7155546 |
|
10.1016/b978-0-08-100919-2.00008-5 |
meptnlum |
0.350769 |
|
Cooke_2017, Guo_R_2013 |
| 16 |
Rosen_2010 |
Summarizing the Evidence on the International Trade in Illegal Wildlife |
Rosen, Gail Emilia; Smith, Katherine F. |
2010 |
2010-06-04 |
PMC |
N |
PMC7087942 |
20524140.0 |
10.1007/s10393-010-0317-y |
rhxvqzqu |
0.338778 |
|
Zhang_2008 |
| 17 |
Tse_A_2003 |
Disintermediation of travel agents in the hotel industry |
Tse, Alan Ching-biu |
2003 |
2003-12-31 |
PMC |
N |
|
|
10.1016/s0278-4319(03)00049-5 |
w664j7z5 |
0.307045 |
|
Anderson_2006, Yim_B_2010, Jang_2008 |
| 18 |
Feng_2017 |
Warehouse capacity sharing via transshipment for an integrated two-echelon supply chain |
Feng, Xuehao; Moon, Ilkyeong; Ryu, Kwangyeol |
2017 |
2017-08-31 |
PMC |
N |
|
|
10.1016/j.tre.2017.04.014 |
it5pj8ub |
0.304523 |
|
Xiao_2006, Yoon_2015, Chen_2017 |


+++ title = "Italian Ilha Grande guys" slug = "italian-ilha-grande-guys" date = 2007-10-03T12:00:00+10:00 tags = ["eccentric-encounters", "fellow-travellers"] locations = ["brazil/ilha-grande"] draft = false summary = """
I made acquaintance with these two boys, on today's hike to Dos Rios. Both of them are from Italy, and they're old friends: however, one is just in Brazil for a short holiday; and the other one is currently living in São Paulo. When we finished the hike, they invited the lot of us back to their cosy little guesthouse, for a barbeque and some drinks. Great lads: warm to all around them, and always ready to have a good time.
""" +++I made acquaintance with these two boys, on today's hike to Dos Rios. Both of them are from Italy, and they're old friends: however, one is just in Brazil for a short holiday; and the other one is currently living in São Paulo. When we finished the hike, they invited the lot of us back to their cosy little guesthouse, for a barbeque and some drinks. Great lads: warm to all around them, and always ready to have a good time.