public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
{
instance.Key.Column(instance.EntityType.Name + "Id");
instance.Cascade.AllDeleteOrphan();
instance.Inverse();
instance.Access.CamelCaseField(CamelCasePrefix.Underscore);//http://stackoverflow.com/questions/781443/private-collection-mapping-in-fluent-nhibernate
}
protected override string GetKeyName(FluentNHibernate.Member property, Type type)
{
if (property == null)
return type.Name + "ID"; // many-to-many, one-to-many, join
return property.Name + "ID"; // many-to-one
}
// POST api/inventory
//public HttpResponseMessage Post(List<order> ords)
public events Post(events evt)
{
//DetailsRepository.saveAll(ords);
DetailsRepository.saveAll(evt);
var sessionFactory = FluentNHibernate.CreateSessionFactory();
using (var session = sessionFactory.OpenSession())
{
// retreive all stores and display them
using (session.BeginTransaction())
{
evt = session.Load <events>(evt.id);
IList <order> ord = evt.orderList.ToList();
foreach (order o in ord)
{
o.orderEvent = null;
}
}
}
return(evt);
//string msg = "Items updated";
//var response = Request.CreateResponse(HttpStatusCode.Created, evt);
//string url = Url.Link("DefaultApi", new { evt.id });
//response.Headers.Location = new Uri(url);
//return response;
}
public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
{
if (instance.EntityType.BaseType != typeof (IntEntity))
instance.GeneratedBy.Assigned();
instance.UniqueKey("PK_" + instance.EntityType.Name);
}
protected override string GetKeyName(FluentNHibernate.Member property, Type type)
{
if (property == null)
return "fk_" + type.Name;
return "fk_" + property.Name;
}
public void Apply(FluentNHibernate.Conventions.Instances.IVersionInstance instance)
{
instance.Column("RowVersion");
instance.Not.Nullable();
instance.UnsavedValue("0");
instance.Default(1);
}
protected override string GetKeyName(FluentNHibernate.Member property, Type type)
{
if (property == null)
return type.Name + "ID";
return property.Name + "ID";
}
public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
{
instance.Column("Id");
instance.UnsavedValue("0");
//instance.GeneratedBy.Identity();
//instance.GeneratedBy.HiLo("1000");
}
public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
{
if (Attribute.IsDefined(instance.EntityType, typeof(GeneratedByAssignedAttribute)))
instance.GeneratedBy.Assigned();
else
instance.Column("Id");
}
public List <Igrac> nisuPlatiliClanarinu(Clanarina c)
{
List <Igrac> igraci;
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Igrac> query = (from i in nSession.Query <Igrac>()
orderby i.Prezime
select i);
igraci = query.ToList <Igrac>();
}
List <Igrac> a = new List <Igrac>();
foreach (Igrac i in igraci)
{
bool flag = false;
foreach (Igrac i2 in c.PlatiliClanarinu)
{
if (i.Id == i2.Id)
{
flag = true;
break;
}
}
if (flag == false)
{
a.Add(i);
}
flag = false;
}
//return igraci.Except(c.PlatiliClanarinu).ToList();
return(a);
}
public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
{
instance.Generic();
instance.LazyLoad();
instance.Fetch.Select();
instance.BatchSize(10);
}
public void Apply(FluentNHibernate.Conventions.Instances.IPropertyInstance instance)
{
var regexString = @"([A-Z][\w^[A-Z]]*)([A-Z][\w^[A-Z]]*)*";
var newName = Regex.Replace(instance.Name, regexString, (m => (m.Index != 0 ? "_" : "") + m.Value.ToLower()));
instance.Column(newName);
}
protected override string GetKeyName(FluentNHibernate.Member property, Type type)
{
if (property == null)
return type.Name + "Id";
// make foreign key compatible with Entity Framework
return type.Name + "_" + property.Name + "Id";
}
public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
{
instance.Key.Column(instance.EntityType.Name + "Id");
instance.Key.ForeignKey(instance.EntityType.Name+"_"+instance.ChildType.Name+"_FK");
instance.Cascade.AllDeleteOrphan();
instance.Inverse();
instance.LazyLoad();
}
public override bool ShouldMap(FluentNHibernate.Member member)
{
if (member.IsProperty && !member.CanWrite)
{
return false;
}
return base.ShouldMap(member);
}
protected override string GetKeyName(FluentNHibernate.Member property, Type type)
{
if (property == null || typeof(Entity) == type.BaseType)
{
return type.Name + "Id";
}
return property.Name + "Id";
}
public List <Natjecanje> dohvatiSvaNatjecanja()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Natjecanje> query = (from i in nSession.Query <Natjecanje>()
select i);
List <Natjecanje> natjecanja = query.ToList <Natjecanje>();
return(natjecanja);
}
}
public List <GrupaTreninga> dohvatiSveGrupe()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <GrupaTreninga> query = (from i in nSession.Query <GrupaTreninga>()
orderby i.NazivGrupe
select i);
List <GrupaTreninga> grupe = query.ToList <GrupaTreninga>();
return(grupe);
}
}
public List <ProtivnickiKlub> dohvatiSveKlubove()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <ProtivnickiKlub> query = (from i in nSession.Query <ProtivnickiKlub>()
orderby i.NazivKluba
select i);
List <ProtivnickiKlub> klubovi = query.ToList <ProtivnickiKlub>();
return(klubovi.ToList());
}
}
public List <Clanarina> dohvatiClanarine()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Clanarina> query = (from i in nSession.Query <Clanarina>()
orderby i.Godina, i.Mjesec
select i);
List <Clanarina> clanarine = query.ToList <Clanarina>();
return(clanarine);
}
}
public void Apply(FNH.Conventions.Instances.IManyToOneInstance instance)
{
//instance.Column(instance.Property.Name); --seems to be superfluous, and moveover, breaks with newer versions
if (instance.Property.MemberInfo.IsDefined(typeof(RequiredAttribute), false))
instance.Not.Nullable();
instance.ForeignKey(string.Format("FK_{0}_{1}",
instance.EntityType.Name,
instance.Name));
}
public void izmijeni(Natjecanje n)
{
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(n);
transaction.Commit();
}
}
}
public List <BiljeskaOIgracu> dohvatiSveBiljeske()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <BiljeskaOIgracu> query = (from i in nSession.Query <BiljeskaOIgracu>()
orderby i.Datum descending
select i);
List <BiljeskaOIgracu> biljeske = query.ToList <BiljeskaOIgracu>();
return(biljeske);
}
}
public List <Trening> DohvatiSveTreninge()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Trening> query = (from i in nSession.Query <Trening>()
orderby i.Datum
select i);
List <Trening> treninzi = query.ToList <Trening>();
return(treninzi);
}
}
public IList <Igrac> dohvatiSveIgrace()
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Igrac> query = (from i in nSession.Query <Igrac>()
orderby i.Prezime
select i);
IList <Igrac> igraci = query.ToList <Igrac>();
return(igraci);
}
}
public IList <Statistika> dohvatiStatistike(string id)
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Utakmica> query = (from i in nSession.Query <Utakmica>()
where i.Id.ToString() == id
orderby i.Datum descending
select i);
Utakmica u = query.ToList <Utakmica>().ElementAt(0);
return(u.StatistikeIgraca);
}
}
public void DodajNoviTrening(Trening trening)
{
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
trening.IgraciNaTreningu = trening.IgraciNaTreningu;
session.Save(trening);
transaction.Commit();
}
}
}
public Igrac dohvatiIgracePoOIBu(string oib)
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Igrac> query = (from i in nSession.Query <Igrac>()
where i.OIB.ToString() == oib
orderby i.Prezime
select i);
IList <Igrac> igraci = query.ToList <Igrac>();
return(igraci.ElementAt(0));
}
}
public IList <Igrac> dohvatiIgraceMladeIliJednake(int godiste)
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Igrac> query = (from i in nSession.Query <Igrac>()
where i.DatumRodenja.Year >= godiste
orderby i.Prezime
select i);
IList <Igrac> igraci = query.ToList <Igrac>();
return(igraci);
}
}
public Natjecanje dohvatiNatjecanjeID(string id)
{
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <Natjecanje> query = (from i in nSession.Query <Natjecanje>()
where i.Id.ToString() == id
select i);
Natjecanje natjecanja = query.ToList <Natjecanje>().ElementAt(0);
return(natjecanja);
}
throw new NatjecanjeDoesntExists();
}
public void dodajUtakmicuNaNatjecanje(Natjecanje n, Utakmica u)
{
using (ISession session = FluentNHibernate.OpenSession())
{
n.dodajUtakmicu(u);
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(n);
transaction.Commit();
}
}
}
public void platioClanarinu(Clanarina c, Igrac i)
{
using (ISession session = FluentNHibernate.OpenSession())
{
c.dodajIgraca(i);
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(c);
transaction.Commit();
}
}
}
public List <BiljeskaOIgracu> dohvatiBiljeskeOIgracu(Igrac i)
{
List <BiljeskaOIgracu> bilj = new List <BiljeskaOIgracu>();
using (ISession nSession = FluentNHibernate.OpenSession())
{
IQueryable <BiljeskaOIgracu> query = (from b in nSession.Query <BiljeskaOIgracu>()
where b.Igrac.OIB == i.OIB
orderby b.Datum descending
select b);
List <BiljeskaOIgracu> biljeske = query.ToList <BiljeskaOIgracu>();
return(biljeske);
}
}
public void dodajNovoNatjecanje(Natjecanje n)
{
if (n.Naziv == "")
{
throw new NatjecanjeNazivPrazno();
}
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(n);
transaction.Commit();
}
}
}
public void dodajBiljesku(BiljeskaOIgracu b)
{
if (b.Biljeska == "")
{
throw new BiljeskaTekstPrazno();
}
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(b);
transaction.Commit();
}
}
}
public void Apply(FluentNHibernate.Conventions.Instances.IManyToManyCollectionInstance instance)
{
if (instance.OtherSide == null)
{
instance.Table(
string.Format(
"{0}To{1}",
instance.EntityType.Name + "_Id",
instance.ChildType.Name + "_Id"));
}
else
{
instance.Inverse();
}
instance.Cascade.All();
}
private static ISessionFactory BuildSessionFactory(string connectionString, FluentNHibernate.Conventions.IConvention[] conventions, Assembly[] assemblies, params Assembly[] overrides)
{
var persistenceModel = AutoMap.Assemblies(assemblies)
.Conventions.Add(conventions)
.Conventions.Add(Cache.Is(x => x.NonStrictReadWrite()))
.IgnoreBase<Entity>()
.Where(t => typeof(EntityWithTypedId<Guid>).IsAssignableFrom(t));
if (overrides != null)
{
overrides.Each(a => persistenceModel.UseOverridesFromAssembly(a));
}
var config = Fluently.Configure()
.ProxyFactoryFactory<DefaultProxyFactoryFactory>()
.Database(
MsSqlConfiguration.MsSql2008
.ConnectionString(connectionString)
.Provider<ContextDriverConnectionProvider>())
.CurrentSessionContext<LazySessionContext>()
.Cache(c => c.ProviderClass<SysCacheProvider>().UseSecondLevelCache().UseQueryCache())
.Mappings(m =>
{
m.AutoMappings.Add(persistenceModel);
if (overrides != null)
overrides.Each(a => m.HbmMappings.AddFromAssembly(a));
})
.BuildConfiguration();
#if DEBUG
persistenceModel.WriteMappingsTo(AppDomain.CurrentDomain.BaseDirectory + @"Hbm");
using (ISession session = config.BuildSessionFactory().OpenSession())
{
string syntax = AppDomain.CurrentDomain.BaseDirectory + @"Hbm\{0}.sql";
string filename = string.Format(syntax, session.Connection.Database);
using (TextWriter stringWriter = new StreamWriter(filename))
{
new SchemaExport(config).Execute(false, false, false, session.Connection, stringWriter);
}
}
#endif
return config.BuildSessionFactory();
}
public void Apply(FluentNHibernate.Conventions.Instances.IPropertyInstance instance)
{
// instance.CustomType
if (instance.Type.IsGenericType && instance.Type.GetGenericTypeDefinition() == tp)
{
var realType = instance.Type.GenericArguments.First();
if (realType.IsEnum)
{
instance.CustomType(realType);
}
}
var list = instance.Property.MemberInfo.GetCustomAttributes(typeof(FieldLengthAttribute), true);
if (list.Length > 0)
{
instance.Length(((FieldLengthAttribute)list[0]).Length);
}
}
public void dodajClanarinu(Clanarina c)
{
List <Clanarina> clanarine = dohvatiClanarine();
foreach (Clanarina clanarina in clanarine)
{
if (clanarina.Godina == c.Godina && clanarina.Mjesec == c.Mjesec)
{
throw new ClanarinaAlreadyExists();
}
}
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(c);
transaction.Commit();
}
}
}
public void dodajStatistiku(Natjecanje natjecanje, Utakmica utakmica, Statistika s)
{
using (ISession session = FluentNHibernate.OpenSession())
{
if (s != null)
{
s.PostignutiKosevi = s.PostignutiKosevi;
s.Asistencije = s.Asistencije;
s.Skokovi = s.Skokovi;
s.OsobnePogreske = s.OsobnePogreske;
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(s);
transaction.Commit();
}
}
}
}
public void dodajIgracaUGrupu(Igrac igrac, GrupaTreninga grupa)
{
if (igrac == null)
{
throw new IgracDoesntExists();
}
List <GrupaTreninga> grupe = dohvatiSveGrupe();
foreach (GrupaTreninga g in grupe)
{
foreach (Igrac i in g.IgraciUGrupi)
{
if (i.OIB == igrac.OIB)
{
using (ISession session = FluentNHibernate.OpenSession())
{
g.IgraciUGrupi.Remove(i);
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(g);
transaction.Commit();
}
}
break;
}
}
if (g.NazivGrupe == grupa.NazivGrupe)
{
grupa.dodajIgraca(igrac);
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(grupa);
transaction.Commit();
}
}
}
}
}
public void dodajIgraca(Igrac igrac)
{
IList <Igrac> igraci = dohvatiSveIgrace();
if (igrac.Ime == "" || igrac.Prezime == "" || igrac.ImeRoditelja == "" ||
igrac.PrezimeRoditelja == "" || igrac.BrojTelefona == "")
{
throw new IgracPraznoPolje();
}
try
{
Convert.ToInt64(igrac.OIB);
}
catch (Exception)
{
throw new OIBFormatException();
}
if (igrac.OIB.Length != 11)
{
throw new OIBLengthException();
}
foreach (Igrac i in igraci)
{
if (i.OIB == igrac.OIB)
{
throw new IgracOIBAlreadyExists();
}
if (i.Ime == igrac.Ime && i.Prezime == igrac.Prezime && i.Nadimak == igrac.Nadimak)
{
throw new IgracNadimakAlreadyExists();
}
}
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(igrac);
transaction.Commit();
}
}
}
public void dodajGrupu(GrupaTreninga grupa)
{
if (grupa.NazivGrupe == "")
{
throw new GrupaTreningaPraznoImeExists();
}
List <GrupaTreninga> grupe = dohvatiSveGrupe();
foreach (GrupaTreninga g in grupe)
{
if (g.NazivGrupe == grupa.NazivGrupe)
{
throw new GrupaTreningaAlreadyExists();
}
}
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(grupa);
transaction.Commit();
}
}
}
public void dodajKlub(ProtivnickiKlub klub)
{
List <ProtivnickiKlub> klubovi = dohvatiSveKlubove();
if (klub.NazivKluba == "" || klub.BrojTelefona == "")
{
throw new KlubPraznoPolje();
}
foreach (ProtivnickiKlub k in klubovi)
{
if (k.NazivKluba == klub.NazivKluba)
{
throw new KlubAlreadyExists();
}
}
using (ISession session = FluentNHibernate.OpenSession())
{
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(klub);
transaction.Commit();
}
}
}
public void Apply(FluentNHibernate.Conventions.Instances.IClassInstance instance)
{
instance.Table(Inflector.Net.Inflector.Pluralize(instance.EntityType.Name));
}
public void Apply(FluentNHibernate.Conventions.Instances.IClassInstance instance)
{
instance.Table(instance.EntityType.Name.InflectTo().Pluralized);
}
public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
{
instance.Key.ForeignKey(String.Format("FK_{0}_{1}", instance.Member.Name, instance.EntityType.Name));
}
public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
{
instance.Column(instance.EntityType.Name + "Id");
}
public void LogSource(FluentNHibernate.Diagnostics.IDiagnosticLogger logger)
{
}
public void Apply(FluentNHibernate.Conventions.Instances.IManyToOneInstance instance)
{
instance.Column(instance.Property.Name + "Fk");
}
public void Accept(FluentNHibernate.Conventions.AcceptanceCriteria.IAcceptanceCriteria<FluentNHibernate.Conventions.Inspections.IPropertyInspector> criteria)
{
criteria.Expect(x => x.Property.PropertyType.IsEnum);
}
public void Apply(FluentNHibernate.Conventions.Instances.IPropertyInstance instance)
{
instance.CustomType(instance.Property.PropertyType);
}
public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
{
instance.Key.Column(instance.EntityType.Name + "ID");
}
public override bool IsId(FluentNHibernate.Member member)
{
// return base.IsId(member);
return member.Name == member.DeclaringType.Name + "Id";
}
static private void SetInvAvailability(int EventId, Available avlType)
{
// create our NHibernate session factory
var sessionFactory = FluentNHibernate.CreateSessionFactory();
using (var session = sessionFactory.OpenSession())
{
// retreive all stores and display them
using (session.BeginTransaction())
{
events evt = session.Load <events>(EventId);
IList <order> ordList = evt.orderList.ToList();
if (ordList.Count == 0)
{
session.Close();
return;
}
var MaxDate = evt.checkIn; // ordList.Max(x => x.checkin);
var MinDate = evt.checkOut; // ordList.Min(x => x.checkout);
if (avlType == Available.Red)
{
MaxDate = evt.eventDate; MinDate = evt.eventDate;
}
DateTime dMax = Convert.ToDateTime(MaxDate);
DateTime dMin = Convert.ToDateTime(MinDate);
IList <order> ord = session.CreateCriteria(typeof(order)).List <order>();
IList <inventory> inv = session.CreateCriteria(typeof(inventory)).List <inventory>();
IList <bom> bom = session.CreateCriteria(typeof(bom)).List <bom>();
IList <loadlist> tmp = session.CreateCriteria(typeof(loadlist)).List <loadlist>();
TimeSpan DaysDiff = dMin - dMax;
int Days = 1;
if (DaysDiff.Days > 0)
{
Days = DaysDiff.Days;
}
DateTime[] myDate = new DateTime[Days];
myDate[0] = dMin;
for (int i = 1; i < DaysDiff.Days; i++)
{
myDate[i] = dMin.AddDays(i);
}
IList <compOrdInv> CompQty = (from o in ord
join b in bom on o.item equals b.item
join i in inv on b.component equals i.item
from d in myDate
where d >= o.orderEvent.checkOut &&
d <= o.orderEvent.checkIn &&
avlType == Available.Yellow ||
d.ToShortDateString() == o.orderEvent.eventDate.ToShortDateString() &&
avlType == Available.Red
select new compOrdInv
{
myDate = d
,
item = b.component
,
InvQty = i.qty
,
ordQty = o.orderQty
,
extQty = b.qty * o.orderQty
})
.ToList();
IList <compOrdInv> Short = (from s in CompQty
group s by new { s.myDate, s.item, s.InvQty }
into g
where g.Key.InvQty - g.Sum(x => x.extQty) < 0
select new compOrdInv
{
myDate = g.Key.myDate
,
item = g.Key.item
,
InvQty = g.Key.InvQty
,
extQty = g.Sum(x => x.extQty)
,
avl = g.Key.InvQty - g.Sum(x => x.extQty)
}).ToList();
IList <order> ordAffected = (from o in ord
join b in bom on o.item equals b.item
join s in Short on b.component equals s.item
join ol in ordList on o.id equals ol.id
where s.myDate >= o.checkout &&
s.myDate <= o.checkin
select o
).ToList();
if (avlType == Available.Yellow)
{
foreach (order o in ordList)
{
o.available = (int)Available.Green;
o.orderEvent.available = (int)Available.Green;
session.SaveOrUpdate(o.orderEvent);
}
}
foreach (order o in ordAffected)
{
o.available = (int)avlType;
o.orderEvent.available = (int)avlType;
session.SaveOrUpdate(o);
session.SaveOrUpdate(o.orderEvent);
}
session.Transaction.Commit();
session.Close();
}
}
}
public override bool IsId(FluentNHibernate.Member member)
{
return member.Name == "ID";
}
public override bool ShouldMap(FluentNHibernate.Member member)
{
return member.IsProperty;
}
