public IList <Product> GetRangeInCategory(int categoryId, int start, int end)
{
var criteria = DetachedCriteria.For <Product>()
.CreateCriteria("Categories")
.Add(Expression.Eq("Id", categoryId));
return((IList <Product>)ActiveRecordMediator.SlicedFindAll(typeof(Product), start, end, criteria));
}
public static T FindAndCheck <T>(uint id) where T : Service
{
var client = ActiveRecordMediator <T> .FindByPrimaryKey(id);
SecurityContext.Administrator.CheckRegion(client.HomeRegion.Id);
SecurityContext.Administrator.CheckType(client.Type);
return(client);
}
/// <summary>
/// Closes the passed in session.
/// Intended to be used in conjunction with checkSession.
/// </summary>
/// <param name="collection"></param>
/// <param name="session">The session to close</param>
/// <param name="sessionConfirmed">Used to remember if a session created by checkSession is still open.</param>
internal static void cleanupSession(this IPersistentCollection collection, ISession session, ref bool sessionConfirmed)
{
if (session != null)
{
sessionConfirmed = false;
ActiveRecordMediator.GetSessionFactoryHolder().ReleaseSession(session);
}
}
public void delete(int id)
{
users auth = ActiveRecordBase <users> .Find(id);
ActiveRecordMediator <users> .Delete(auth);
RedirectToReferrer();
}
public void delete_usertags(int id)
{
usertags tag = ActiveRecordBase <usertags> .Find(id);
ActiveRecordMediator <usertags> .Delete(tag);
RedirectToReferrer();
}
/// <summary>
/// Starts a <see cref="UnitOfWork" /> and creates the in memory db schema.
/// </summary>
/// <example>Using <see cref="RhinoContainer" />, <see cref="IoC" />, and <see cref="UnitOfWork" /> in your tests.
/// <code lang="c#" escaped="true">
/// using NUnit.Framework;
/// using Rhino.Commons;
/// using Rhino.Commons.ForTesting;
///
/// [TestFixture]
/// public class FooTest : NHibernateInMemoryTest
/// {
/// [TestFixtureSetup]
/// public void TestFixtureSetup()
/// {
/// OneTimeInitialize("RhinoContainer.boo", typeof(Foo).Assembly);
/// }
///
/// [Setup]
/// public void TestSetup()
/// {
/// /// Creates a top level UnitOfWork, remember to clean me up
/// CreateUnitOfWork();
/// }
///
/// [TearDown]
/// public void TestTearDown()
/// {
/// /// Cleanup the top level UnitOfWork
/// UnitOfWork.Current.Dispose();
/// }
///
/// [Test]
/// public void CanSaveFoo()
/// {
/// Foo f = new Foo();
/// Foo res = null;
/// f.Name = "Bar";
///
/// Assert.AreEqual(Guid.Empty, f.Id);
///
/// With.Transaction(delegate
/// {
/// IoC.Resolve<IRepository<Foo>>.Save(f);
/// });
///
/// Assert.AreNotEqual(Guid.Empty, f.Id);
///
/// using(UnitOfWork.Start())
/// res = IoC.Resolve<IRepository<Foo>>.Load(f.Id);
///
/// Assert.IsNotNull(res);
/// Assert.AreEqual("Bar", res.Name);
/// }
/// }
/// </code>
/// </example>
/// <seealso cref="RhinoContainer" />
/// <seealso cref="IoC" />
/// <seealso cref="UnitOfWork" />
public void CreateUnitOfWork()
{
UnitOfWork.Start();
ISession session = ActiveRecordMediator.GetSessionFactoryHolder().CreateSession(typeof(ActiveRecordBase));
dbConnection = session.Connection;
SetupDB();
}
public static Estabelecimento FindByCNPJ(string cnpj)
{
DetachedCriteria crit = DetachedCriteria.For <Estabelecimento>();
crit.Add(Expression.Eq("CNPJ", cnpj));
return(ActiveRecordMediator <Estabelecimento> .FindFirst(crit));
}
public IList <T> GetOtherMapBySql(string sql)
{
return((IList <T>) ActiveRecordMediator <T> .Execute(
delegate(ISession session, object instance)
{
return session.CreateSQLQuery(sql).AddEntity("synonym", typeof(T)).List <T>();
}, new T()));
}
public void CountQuery_ByType()
{
Prepare();
CountQuery cq = new CountQuery(typeof(Post));
int recordCount = (int)ActiveRecordMediator.ExecuteQuery(cq);
Assert.AreEqual(3, recordCount);
}
public long CountAllInCategory(int categoryId)
{
var criteria = DetachedCriteria.For <Product>()
.CreateCriteria("Categories")
.Add(Expression.Eq("Id", categoryId));
return(ActiveRecordMediator.Count(typeof(Product), criteria));
}
private static uint GetNextHighestPlayerId()
{
ScalarQuery idQuery = new ScalarQuery(typeof(CharacterRecord), QueryLanguage.Hql,
"select max(chr.EntityId) from CharacterRecord chr");
object highestId = ActiveRecordMediator.ExecuteQuery(idQuery);
return(highestId == null ? 0 : (highestId as CharacterRecord).EntityLowId + 1);
}
public void delete(int id)
{
person person = ActiveRecordBase <person> .Find(id);
ActiveRecordMediator <person> .Delete(person);
RedirectToAction("list");
}
public static Org GetSystemOrg()
{
if (_systemOrg == null)
{
_systemOrg = ActiveRecordMediator <Org> .FindAllByProperty("Name", "OIF")[0];
}
return(_systemOrg);
}
public void TearDown()
{
if (_session != null)
{
var holder = ActiveRecordMediator.GetSessionFactoryHolder();
holder.ReleaseSession(session);
_session = null;
}
}
public void reorder_nav([ARDataBind("navs", Validate = true, AutoLoad = AutoLoadBehavior.NewRootInstanceIfInvalidKey)] categories[] navs)
{
HelperService.writelog("Editing reordering nav categories");
foreach (categories nav in navs)
{
ActiveRecordMediator <categories> .Save(nav);
}
RedirectToAction("list_nav");
}
public void Delete(T entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
ActiveRecordMediator <T> .Delete(entity);
}
public List <Answer> GetTopAnswers(int questionId, int answerStart, int maxResults)
{
var answeres = ActiveRecordMediator <Answer> .SlicedFindAll(answerStart, maxResults,
DetachedCriteria.For <Answer>().
Add(Restrictions.Eq("QuestionId", questionId)),
Order.Desc("Votes"));
return(new List <Answer>(answeres));
}
public Token(MembershipUser user)
{
_user = user;
_BTTUser = (BTTUser)HttpContext.Current.Cache["user" + user.UserName];
if (_BTTUser == null)
{
_BTTUser = ActiveRecordMediator <BTTUser> .FindByPrimaryKey(new Guid(user.ProviderUserKey.ToString()));
}
}
public void CountQuery_PositionalParameters()
{
Prepare();
object[] parameters = new object[] { "c" };
CountQuery cq = new CountQuery(typeof(Post), "Category = ?", parameters);
int recordCount = (int)ActiveRecordMediator.ExecuteQuery(cq);
Assert.AreEqual(2, recordCount);
}
public void NHibernateNoTxVerification()
{
InitModel();
using (ISession session = ActiveRecordMediator.GetSessionFactoryHolder().GetSessionFactory(typeof(ActiveRecordBase)).OpenSession())
{
session.Save(new SSAFEntity("example"));
Assert.AreEqual(1, session.CreateQuery("from SSAFEntity").List <SSAFEntity>().Count);
}
}
public void Evict(T entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
ActiveRecordMediator.Evict(entity);
}
private static ISession GetSession()
{
if (SessionScope.Current == null)
{
throw new InvalidOperationException("No active SessionScope found.");
}
return(ActiveRecordMediator.GetSessionFactoryHolder().CreateSession(typeof(ActiveRecordBase)));
}
public void Setup()
{
Environment.CurrentDirectory = TestContext.CurrentContext.TestDirectory;
Global.Config.DocsPath = "../../../AdminInterface/Docs/";
Global.Config.RegisterListEmail = "*****@*****.**";
ForTest.InitialzeAR();
IntegrationFixture2.Factory = ActiveRecordMediator.GetSessionFactoryHolder().GetSessionFactory(typeof(ActiveRecordBase));
}
public void DeleteTag(int id, int advertisementId)
{
tags tag = ActiveRecordBase <tags> .Find(id);
advertisement advertisement = ActiveRecordBase <advertisement> .Find(advertisementId);
advertisement.Tags.Remove(tag);
ActiveRecordMediator <advertisement> .Save(advertisement);
}
public void InsertOrUpdate(T entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
ActiveRecordMediator <T> .Save(entity);
}
public void Dispose()
{
ISessionFactoryHolder holder = ActiveRecordMediator.GetSessionFactoryHolder();
foreach (ISessionFactory factory in holder.GetSessionFactories())
{
factory.Dispose();
}
}
/// <summary>
/// Atualiza um relacionamento "N para N".
/// </summary>
/// <typeparam name="I">O tipo da tabela intermediária</typeparam>
/// <typeparam name="F">O tipo do dado da outra ponta do relacionamento</typeparam>
/// <param name="itens">A coleção que armazena os registros <typeparamref name="I"/>, da tabela intermediária</param>
/// <param name="selecionados">Uma lista de elementos <typeparamref name="F"/>, da outra ponta do relacionamento</param>
/// <param name="creator">Um delegate especificando a criação de novos registros na tabela intermediária</param>
/// <param name="getter">Um delegate especificando a obtenção de um registro do tipo <typeparamref name="I"/> (tabela da outra ponta do relacionamento) a partir de um registro <typeparamref name="F"/> (tabela intermediária)</param>
/// <param name="delete">Um delegate especificando a exclusão de um registro da lista de itens</param>
public static void AtualizaRelacionamento <I, F>(IList <I> itens, IEnumerable <F> selecionados,
Converter <F, I> creator, Converter <I, F> getter,
Action <I> delete)
where I : class, IRecord
where F : class, IRecord
{
if (itens == null)
{
throw new ArgumentNullException("itens");
}
if (creator == null)
{
throw new ArgumentNullException("creator");
}
if (getter == null)
{
throw new ArgumentNullException("getter");
}
if (selecionados == null)
{
selecionados = new F[0];
}
// preenche lista com todas as possibilidades de selecionados
var todos = new List <F>(ActiveRecordMediator <F> .FindAll());
// preenche mapa com os registros de relacionamento atuais
var atuais = new Dictionary <F, I>();
foreach (I item in itens)
{
atuais.Add(getter(item), item);
}
// cria novos registros selecionados novos, e previne exclusão de já existentes
foreach (F selecionado in selecionados)
{
I item;
if (!atuais.TryGetValue(selecionado, out item))
{
item = creator(selecionado);
itens.Add(item);
atuais.Add(selecionado, item);
}
todos.Remove(selecionado);
}
// exclui os relacionamentos já existentes
foreach (F selecionado in todos)
{
I item;
if (atuais.TryGetValue(selecionado, out item))
{
delete(item);
}
}
}
protected override int ExecuteInsert(IDictionary values)
{
ActiveRecordDataSourceCreateEventArgs args = new ActiveRecordDataSourceCreateEventArgs();
args.ModelType = BuildManager.GetType(Source.TypeName, false, true);
args.CreateValues = values;
CreateValuesFromCreateParameters(args);
IClassMetadata meta = ActiveRecordMediator.GetSessionFactoryHolder().GetSessionFactory(args.ModelType).GetClassMetadata(args.ModelType);
if (!meta.HasIdentifierProperty)
{
throw new ApplicationException("ActiveRecordDataSourceView requires a primary key for the update method.");
}
Source.OnBeforeCreate(args);
if (args.Cancel)
{
return(0);
}
try
{
if (args.Entity == null)
{
args.Entity = Activator.CreateInstance(args.ModelType);
}
foreach (string key in args.CreateValues.Keys)
{
meta.SetPropertyValue(args.Entity, key, args.CreateValues[key]);
}
ActiveRecordMediator.Create(args.Entity);
}
catch (Exception e)
{
args.Exception = e;
args.WasError = true;
Source.OnCreateError(args);
if (Source.ThrowOnError && !args.DoNotThrow)
{
throw;
}
return(0);
}
Source.OnCreate(args);
return(1);
}
/// <summary> </summary>
public void Update(int id, [DataBind("tag")] taxonomy tag)
{
try {
ActiveRecordMediator <taxonomy> .Save(tag);
} catch (Exception ex) {
Flash["error"] = ex.Message;
Flash["tag"] = tag;
}
RedirectToAction("index");
}
/// <summary> </summary>
public void massDeleteTags(int[] ids)
{
foreach (int id in ids)
{
taxonomy tag = ActiveRecordBase <taxonomy> .Find(id);
ActiveRecordMediator <taxonomy> .Delete(tag);
}
RedirectToReferrer();
}
