public ClientModel Post([FromUri] string option, [FromBody] ClientModel model, int id)
{
ClientModel result = null;
switch (option)
{
case "current":
ClientOrg co = DataSession.Single <ClientOrg>(id);
ClientOrg mo = DataSession.Single <ClientOrg>(model.ClientOrgID);
if (co != null && mo != null)
{
var cm = DataSession.Query <ClientManager>().FirstOrDefault(x => x.ClientOrg == co && x.ManagerOrg == mo);
if (cm == null)
{
//no existing ClientManager record so create a new one
cm = new ClientManager()
{
ClientOrg = co,
ManagerOrg = mo
};
DataSession.Insert(cm);
}
Provider.Data.ActiveLog.Enable(cm);
result = ApiUtility.CreateClientModel(cm.ManagerOrg.CreateModel <IClient>());
}
break;
}
return(result);
}
public object[] GetActiveReservations()
{
IList <Reservation> query = DataSession.Query <Reservation>().Where(x => x.IsStarted && x.IsActive && x.ActualEndDateTime == null && x.ActualBeginDateTime <= DateTime.Now).ToList();
var items = query.Select(GetReservation).ToArray();
return(items);
}
public Department[] GetDepartments()
{
return(DataSession.Query <Department>()
.Where(x => x.Org.OrgID == OrgID)
.OrderBy(x => x.DepartmentName)
.ToArray());
}
public NewsItem[] Get(string option = "")
{
IEnumerable <News> query = DataSession
.Query <News>()
.Where(x =>
x.NewsActive &&
!x.NewsDeleted &&
(x.NewsPublishDate == null || x.NewsPublishDate.Value < DateTime.Now) &&
(x.NewsExpirationDate == null || x.NewsExpirationDate.Value > DateTime.Now))
.OrderBy(x => x.NewsSortOrder);
if (query.Count() == 0)
{
query = DataSession.Query <News>().Where(x => x.NewsDefault);
}
if (option == "ticker")
{
return(query.Where(x => x.NewsTicker).Select(CreateNewsItem).ToArray());
}
else
{
return(query.Where(x => !x.NewsTicker).Select(CreateNewsItem).ToArray());
}
}
private void GetResourceInfoItems()
{
if (resInfoItems == null)
{
resInfoItems = DataSession.Query <ResourceInfo>().Where(x => x.ResourceIsActive).ToList();
}
}
public void CanSaveOrg()
{
IClient currentUser = new LNF.Data.ClientItem
{
ClientID = 1301,
UserName = "******",
LName = "Getty",
FName = "James"
};
var model = new OrgModel()
{
CurrentUser = currentUser,
OrgName = string.Format("Test Org [{0:yyyyMMddHHmmss}]", DateTime.Now),
OrgTypeID = 2
};
var result = model.Save();
var message = model.GetMessage();
Assert.IsNull(message);
Assert.IsTrue(result);
var alog = DataSession.Query <ActiveLog>().FirstOrDefault(x => x.TableName == "Org" && x.Record == model.OrgID);
Assert.IsNotNull(alog);
Assert.AreEqual(alog.EnableDate, DateTime.Now.Date);
Assert.IsNull(alog.DisableDate);
Console.WriteLine(model.OrgID);
}
public IEnumerable <Vendor> GetAllVendors()
{
// returns both active and inactive
var query = DataSession.Query <Ordering.Vendor>();
return(CreateVendors(query));
}
public SubsidyModel[] Get(DateTime period, int clientId = 0, bool calculate = false)
{
if (calculate)
{
CalculateSubsidy(period, clientId);
}
IEnumerable <TieredSubsidyBilling> query;
if (clientId == 0)
{
query = DataSession.Query <TieredSubsidyBilling>().Where(x => x.Period == period);
}
else
{
query = DataSession.Query <TieredSubsidyBilling>().Where(x => x.Client.ClientID == clientId && x.Period == period);
}
var result = query.ToArray().Select(x => new SubsidyModel()
{
ClientID = clientId,
Period = period,
Room = x.RoomSum,
RoomMisc = x.RoomMiscSum,
Tool = x.ToolSum,
ToolMisc = x.ToolMiscSum
}).ToArray();
return(result);
}
// This replaces a constructor that set the AccountTypes property using LNF.DataAccess.ISession. It doesn't seem to ever be used so
// it's an extra dependency that is no longer needed. This function is here for historical reference.
private ToolUsageSummaryOptions ToolUsageSummaryOptions(IEnumerable <AccountType> items)
{
return(new ToolUsageSummaryOptions
{
AccountTypes = string.Join(",", DataSession.Query <AccountType>().ToArray().Select(x => x.AccountTypeID.ToString()))
});
}
public IEnumerable <Client> ClientSearch()
{
IList <Client> query;
if (string.IsNullOrEmpty(Search))
{
query = DataSession.Query <Client>().ToList();
}
else
{
query = new List <Client>();
if (GetSingle <Client>("client", query))
{
return(query.ToArray());
}
else
{
query = DataSession.Query <Client>().Where(x =>
x.ClientID.ToString() == Search ||
x.UserName.ToLower().Contains(Search.ToLower()) ||
x.LName.ToLower().Contains(Search.ToLower()) ||
x.FName.ToLower().Contains(Search.ToLower()) ||
(x.LName + ", " + x.FName).ToLower().Contains(Search.ToLower()) ||
(x.FName + " " + x.LName).ToLower().Contains(Search.ToLower())).ToList();
}
}
return(query.ToArray());
}
private void GenerateMaterialGrid()
{
//Dim allPIPs As IEnumerable(Of ProcessInfoLineParam) = DA.Search(Of ProcessInfoLineParam)(Function(x) x.IsPremiumMaterial = True).OrderBy(Function(x) x.Resource.ResourceID)
var allPIPs = DataSession.Query <ProcessInfoLineParam>().OrderBy(x => x.ResourceID).ToArray();
int currentResourceId = -1;
var resources = Provider.Scheduler.Resource.GetActiveResources();
foreach (var item in allPIPs)
{
var tRow = new TableRow();
tRow.Attributes["class"] = "cost-item";
if (currentResourceId != item.ResourceID)
{
if (item.ResourceID > 0)
{
//tRow.Attributes("class") = tRow.Attributes("class") + " tr-top"
var res = resources.First(x => x.ResourceID == item.ResourceID);
AddResourceNameRow(res, tblmaterial);
}
currentResourceId = item.ResourceID;
}
AddMaterial(item, tRow, item.ResourceID);
AddChargeRow(tRow, UMICH);
AddChargeRow(tRow, OTHER_ACADEMIC);
AddChargeRow(tRow, NON_ACADEMIC);
tblmaterial.Rows.Add(tRow);
}
}
public IEnumerable <Purchaser> GetAvailablePurchasers()
{
var current = DataSession.Query <Ordering.Purchaser>().Where(x => !x.Deleted).Select(x => x.Client.ClientID).ToArray();
var query = DataSession.Query <Data.ClientInfo>().Where(x => x.ClientActive && !current.Contains(x.ClientID) && (x.Privs & PurchaserPrivilege) > 0);
return(CreatePurchasers(query));
}
protected UserClientSelectItem[] GetClientSelectItems(DateTime period)
{
// clear the session variable whenever the period changes
if (Session["ClientSelectPeriod"] == null || Convert.ToDateTime(Session["ClientSelectPeriod"]) != period)
{
Session.Remove("ClientSelectItems");
}
Session["ClientSelectPeriod"] = period;
if (Session["ClientSelectItems"] == null)
{
DateTime sd = period;
DateTime ed = sd.AddMonths(1);
Session["ClientSelectItems"] = DataSession.Query <LNF.Impl.Repository.Data.ActiveLogClientAccount>()
.Where(x => x.EnableDate < ed && (x.DisableDate == null || x.DisableDate > sd))
.Select(x => new UserClientSelectItem()
{
ClientID = x.ClientID,
LName = x.LName,
FName = x.FName,
AccountID = x.AccountID,
Manager = x.Manager
})
.ToArray();
}
return((UserClientSelectItem[])Session["ClientSelectItems"]);
}
public IEnumerable <Detail> GetInvalidCategoryItems(int poid)
{
var result = new List <Detail>();
var parents = SelectParentCategories();
var details = DataSession.Query <Ordering.PurchaseOrderDetail>().Where(x => x.PurchaseOrder.POID == poid);
foreach (var d in details)
{
if (!d.Category.Active)
{
result.Add(CreateDetail(d));
}
else
{
if (!d.Category.IsParent())
{
var p = parents.FirstOrDefault(x => x.CatID == d.Category.ParentID);
if (p == null)
{
throw new Exception($"No parent category found for CatID = {d.Category.CatID}");
}
if (!p.Active)
{
result.Add(CreateDetail(d));
}
}
}
}
return(result);
}
// GET: Posts
public ActionResult Index(string q)
{
List <Post> listOfPost;
if (!string.IsNullOrEmpty(q))
{
if (!q.EndsWith("*"))
{
q = q + "*";
}
listOfPost =
DataSession.Query <Post, Posts_View>()
.Search(o => o.Title, q, escapeQueryOptions: EscapeQueryOptions.AllowAllWildcards)
.ToList();
}
else
{
listOfPost = DataSession.Query <Post, Posts_View>().OrderByDescending(o => o.Created).ToList();
}
if (Request.IsAjaxRequest())
{
return(PartialView("_ListOfPosts", listOfPost));
}
return(View(listOfPost));
}
public int AddCategory(int parentId, string categoryName, string categoryNumber)
{
var existing = DataSession.Query <Ordering.PurchaseOrderCategory>().FirstOrDefault(x => x.ParentID == parentId && x.CatNo == categoryNumber);
if (existing != null)
{
if (existing.Active)
{
throw new Exception($"A category already exists with category number: {categoryNumber}");
}
else
{
existing.Active = true;
return(existing.CatID);
}
}
var cat = new Ordering.PurchaseOrderCategory()
{
ParentID = parentId,
CatName = categoryName,
CatNo = categoryNumber,
Active = true
};
DataSession.Insert(cat);
return(cat.CatID);
}
public ResourceState[] GetResources()
{
DataTable dt = new DataTable();
dt.Columns.Add("ResourceID", typeof(int));
dt.Columns.Add("ResourceName", typeof(string));
dt.Columns.Add("BuildingName", typeof(string));
dt.Columns.Add("LabName", typeof(string));
dt.Columns.Add("ProcessTechName", typeof(string));
ResourceInfo[] query = DataSession.Query <ResourceInfo>().Where(x => x.ResourceIsActive).ToArray();
foreach (var r in query)
{
dt.Rows.Add(r.ResourceID, r.ResourceName, r.BuildingName, r.LabName, r.ProcessTechName);
}
WagoInterlock.AllToolStatus(dt);
ResourceState[] result = dt.AsEnumerable().Select(x => new ResourceState()
{
ResourceID = x.Field <int>("ResourceID"),
ResourceName = x.Field <string>("ResourceName"),
BuildingName = x.Field <string>("BuildingName"),
LabName = x.Field <string>("LabName"),
ProcessTechName = x.Field <string>("ProcessTechName"),
PointID = x.Field <int>("PointID"),
InterlockStatus = x.Field <string>("InterlockStatus"),
InterlockState = x.Field <bool>("InterlockState"),
InterlockError = x.Field <bool>("InterlockError"),
IsInterlocked = x.Field <bool>("IsInterlocked")
}).ToArray();
return(result);
}
public ActionResult Delete(int orgId, int accountId)
{
var acct = DataSession.Single <Account>(accountId);
if (acct != null)
{
// disable ClientAccounts
var clientAccounts = DataSession.Query <ClientAccount>().Where(x => x.Account == acct && x.Active).ToList();
foreach (var ca in clientAccounts)
{
// disable access to this account
Provider.Data.ActiveLog.Disable(ca);
// check that all clients still have another account
var co = ca.ClientOrg;
var c = co.Client;
throw new Exception("need to do this");
// check if client has any active accounts
//bool hasActiveAcct = false;
//hasActiveAcct = DataUtility.HasActiveAccount(clientDataRow, dsAccount.Tables["ClientOrg"], dsAccount.Tables["ClientAccount"]);
//if (!hasActiveAcct && c != null)
//clientDataRow["EnableAccess"] = false;
}
Provider.Data.ActiveLog.Disable(acct);
}
return(RedirectToAction("Index", new { orgId }));
}
public IEnumerable <Account> GetAllAccounts()
{
var query = DataSession.Query <Ordering.PurchaseOrderAccount>();
var result = CreateAccounts(query);
return(result);
}
public Purchaser GetPurchaser(Client client)
{
var purch = DataSession.Query <Ordering.Purchaser>().FirstOrDefault(x => x.Client.ClientID == client.ClientID);
var c = Require <Data.ClientInfo>(x => x.ClientID, client.ClientID);
return(CreatePurchaser(purch, c));
}
public IEnumerable <SelectListItem> GetRoleSelectItems()
{
return(DataSession.Query <Role>().Select(x => new SelectListItem()
{
Text = x.RoleName, Value = x.RoleID.ToString()
}));
}
public IEnumerable <Approver> GetAvailableApprovers(int clientId)
{
var current = GetActiveApprovers(clientId).Select(x => x.ApproverID).ToArray();
var query = DataSession.Query <Data.ClientInfo>().Where(x => !current.Contains(x.ClientID) && (x.Privs & AdministratorPrivilege) > 0 && x.ClientActive);
return(CreateApprovers(query));
}
public Purchaser AddOrUpdatePurchaser(int clientId, bool active)
{
var client = Require <Data.ClientInfo>(x => x.ClientID, clientId);
var purch = DataSession.Query <Ordering.Purchaser>().FirstOrDefault(x => x.Client.ClientID == clientId);
if (purch == null)
{
purch = new Ordering.Purchaser()
{
Client = Require <Data.Client>(x => x.ClientID, clientId),
Active = active,
Deleted = false
};
DataSession.Insert(purch);
}
else
{
purch.Active = active;
purch.Deleted = false;
}
return(CreatePurchaser(purch, client));
}
public Account[] AccountSearch()
{
IList <Account> query = new List <Account>();
if (string.IsNullOrEmpty(Search))
{
query = DataSession.Query <Account>().ToList();
}
else
{
if (GetSingle("acct", query))
{
return(query.ToArray());
}
else if (GetMultiple("org", query, id => x => x.Org.OrgID == id))
{
return(query.ToArray());
}
else
{
query = DataSession.Query <Account>().Where(x =>
x.AccountID.ToString() == Search ||
x.Name.ToLower().Contains(Search.ToLower()) ||
x.Number.ToLower().Contains(Search.ToLower()) ||
x.ShortCode.ToLower().Contains(Search.ToLower()) ||
x.AccountType.AccountTypeName.ToLower().Contains(Search.ToLower())).ToArray();
}
}
return(query.ToArray());
}
protected void Page_Load(object sender, EventArgs e)
{
IEnumerable <OrgListItem> dataSource = null;
if (CurrentUser.HasPriv(ClientPrivilege.Administrator))
{
IList <Org> allOrgs = DataSession.Query <Org>().ToList();
dataSource = allOrgs.Select(x => new OrgListItem()
{
OrgID = x.OrgID, OrgName = x.OrgName
}).OrderBy(x => x.OrgName);
}
else if (CurrentUser.HasPriv(ClientPrivilege.Executive))
{
var allClientOrgs = ContextBase.GetCurrentUserClientOrgs();
dataSource = allClientOrgs.Select(x => new OrgListItem()
{
OrgID = x.OrgID, OrgName = x.OrgName
}).OrderBy(x => x.OrgName);
}
if (dataSource.Count() > 1)
{
ddlOrg.AppendDataBoundItems = true;
}
ddlOrg.DataSource = dataSource;
ddlOrg.DataTextField = "OrgName";
ddlOrg.DataValueField = "OrgID";
ddlOrg.DataBind();
}
public Org[] OrgSearch()
{
IList <Org> query = new List <Org>();
if (string.IsNullOrEmpty(Search))
{
query = DataSession.Query <Org>().ToList();
}
else
{
if (GetSingle("org", query))
{
return(query.ToArray());
}
else
{
query = DataSession.Query <Org>().Where(x =>
x.OrgID.ToString() == Search ||
x.OrgName.ToLower().Contains(Search.ToLower()) ||
x.OrgType.OrgTypeName.ToLower().Contains(Search.ToLower())).ToArray();
}
}
return(query.ToArray());
}
private IEnumerable <Ordering.PurchaseOrderCategory> SelectParentCategories()
{
if (_parents == null)
{
_parents = DataSession.Query <Ordering.PurchaseOrderCategory>().Where(x => x.ParentID == 0).ToList();
}
return(_parents);
}
private Point GetPoint(int pointId)
{
if (_point == null)
{
_point = DataSession.Query <Point>().First(x => x.PointID == pointId);
}
return(_point);
}
public IList <ServiceLog> GetLogEntries(string service)
{
DateTime sd = LogStartDate;
DateTime ed = LogEndDate.AddDays(1);
IList <ServiceLog> result = DataSession.Query <ServiceLog>().Where(x => x.ServiceName == service && x.LogDateTime >= sd && x.LogDateTime < ed).OrderBy(x => x.LogDateTime).ToList();
return(result);
}
public IEnumerable <Account> GetAvailableAccounts(int clientId)
{
var current = GetActiveAccounts(clientId).Select(x => x.AccountID).ToArray();
var query = DataSession.Query <Data.ClientAccountInfo>().Where(x => x.ClientID == clientId && x.ClientAccountActive && !current.Contains(x.AccountID));
var result = CreateAccounts(query);
return(result);
}
