public ActionResult approveday(string selectedday)
{
DateTime day = DateTime.ParseExact(selectedday, "yyyyMMdd", CultureInfo.InvariantCulture);
day = new DateTime(day.Year, day.Month, day.Day, day.Hour, day.Minute, day.Second, DateTimeKind.Utc);
var query = new DBQuery("workentries", "unacceptedentrydata");
query.AddParameter("start", day);
query.AddParameter("end", day);
query.AddParameter("user", new ObjectId(Runtime.SessionManager.CurrentUser[DBQuery.Id]));
DBResponse response = query.Find();
DBCollection timesheetEntries = response["timesheetentry"];
DBCollection abseneceEntries = response["absenceentry"];
DBCollection dayEntries = response["dayentry"];
DBCollection articleEntries = response["articleentry"];
DBCollection assetEntries = response["assetentry"];
var tasks = new List <Task <DBUpdateResponse> >();
tasks.Add(ApproveEntriesInCollection(timesheetEntries));
tasks.Add(ApproveEntriesInCollection(abseneceEntries));
tasks.Add(ApproveEntriesInCollection(dayEntries));
tasks.Add(ApproveEntriesInCollection(articleEntries));
tasks.Add(ApproveEntriesInCollection(assetEntries));
Task.WaitAll(tasks.ToArray());
return(new AjaxResult("success"));
}
internal DataTree GetSuggestedAllocationsForUser(string userId, DateTime dayInitial, int days)
{
if (string.IsNullOrEmpty(userId))
{
userId = Runtime.SessionManager.CurrentUser[DBQuery.Id];
}
// Get all allocation entries
var allocationEntryQuery = new DBQuery();
DateTime dayStart = new DateTime(dayInitial.Year, dayInitial.Month, dayInitial.Day);
DateTime dayEnd;
// From start of today to start of tomorrow
dayEnd = dayInitial.AddDays(days);
dayEnd = new DateTime(dayEnd.Year, dayEnd.Month, dayEnd.Day);
// StartDate is less than end of the day and end date is more than start of the day
List <IMongoQuery> dateRangeQueries = new List <IMongoQuery>();
dateRangeQueries.Add(Query.LT("starttimestamp", new BsonDateTime(dayEnd)));
dateRangeQueries.Add(Query.GT("endtimestamp", new BsonDateTime(dayStart)));
List <IMongoQuery> searchQueries = new List <IMongoQuery>();
searchQueries.Add(Query.And(dateRangeQueries));
searchQueries.Add(Query.EQ("user", new ObjectId(userId)));
allocationEntryQuery["allocationentry"][DBQuery.Condition] = Query.And(searchQueries).ToString();
allocationEntryQuery["allocationentry"][DBQuery.OrderBy] = "endtimestamp";
return((DataTree)allocationEntryQuery.Find().FirstCollection);
}
private bool CheckForUnapprovedEntries(DBDocument allocationEntry)
{
logger.LogTrace("Checking whether allocation has unapproved entries");
bool hasUnapprovedEntries = false;
var query = new DBQuery("homescreenprojects", "unapprovedentriesforproject");
query.AddParameter("project", allocationEntry["project"]);
query.AddParameter("user", allocationEntry["user"]);
DBResponse response = query.Find();
if (response["timesheetentry"].Count > 0)
{
hasUnapprovedEntries = true;
}
else if (response["absenceentry"].Count > 0)
{
hasUnapprovedEntries = true;
}
else if (response["dayentry"].Count > 0)
{
hasUnapprovedEntries = true;
}
else if (response["articleentry"].Count > 0)
{
hasUnapprovedEntries = true;
}
return(hasUnapprovedEntries);
}
public ActionResult getprojects(
string projectmanager,
string searchterms,
string orderby,
bool ascending,
int documentsperpage,
int page)
{
var splitters = new char[] { ' ' };
string[] splitTerms = searchterms.Split(splitters, StringSplitOptions.RemoveEmptyEntries);
DBQuery query = QueryGetProjects(
splitTerms,
orderby,
ascending,
documentsperpage,
page,
projectmanager);
if (query != null)
{
DBResponse response = query.Find();
DataTree qi = response.QueryInfo;
return(new AjaxResult(GetJsonFromProjectsCollection((DataTree)response.FirstCollection)));
int totalRecords = (int)qi["totalrecords"];
// Max page to refer to is number of pages -1
int maxPage = (int)Math.Ceiling((decimal)totalRecords / (decimal)documentsperpage) - 1;
totalRecords = (int)qi["totalrecords"];
return(new AjaxResult(GetJsonFromProjectsCollection((DataTree)query.Find().FirstCollection)));
}
else
{
return(new AjaxResult(""));
}
}
public ActionResult getresultscollection(
string terms,
string rootschema,
string collection,
int documentperpage = -1,
string filtercontroller = "",
string filteraction = "")
{
var splitters = new char[] { ' ' };
string[] splitTerms = terms.Split(splitters, StringSplitOptions.RemoveEmptyEntries);
if (removeWildcards)
{
RemoveWildcards(splitTerms);
}
DataTree schema = Runtime.RunBlock("core", "schemafor", collection);
var filterQueries = new List <IMongoQuery>();
IMongoQuery query = Runtime.Filters.GetFilterQuery(filtercontroller, filteraction);
if (query != null)
{
filterQueries.Add(query);
}
DBQuery resultsQuery = QuerySearchFilterTerm(splitTerms, schema, collection, documentperpage, filterQueries.ToArray());
DBResponse response = null;
if (resultsQuery != null)
{
response = resultsQuery.Find();
List <string> nameFields = Schema.GetNameFields(schema);
// Todo: consider not casting to datatree and using the collection.
FilterResults((DataTree)response.FirstCollection, Schema.GetSearchFields(schema), nameFields);
}
if (response != null && response.FirstCollection.Count > 0)
{
return(NamedView("searchfilter", "searchfilterresult", (MC2Value)response.FirstCollection, response.QueryInfo));
}
else
{
return(NamedView("searchfilter", "searchfilterresult", MC2EmptyValue.EmptyValue));
}
}
public ActionResult projectallocations(string projectid, string selectedday, string projectname)
{
DateTime day = DateTime.ParseExact(selectedday, "yyyyMMdd", CultureInfo.InvariantCulture);
day = new DateTime(day.Year, day.Month, day.Day, day.Hour, day.Minute, day.Second, DateTimeKind.Utc);
var query = new DBQuery("homescreenprojects", "allocationsforproject");
query.AddParameter("project", new ObjectId(projectid));
query.AddParameter("start", day);
query.AddParameter("end", day);
return(View((DataTree)query.Find().FirstCollection, projectname));
}
public ActionResult getEntryData(DateTime start, DateTime end)
{
var entriesQuery = new DBQuery("workdatawidget", "entrydata");
entriesQuery.AddParameter("user", Runtime.SessionManager.CurrentUser[DBQuery.Id]);
entriesQuery.AddParameter("start", start);
entriesQuery.AddParameter("end", end);
DBResponse response = entriesQuery.Find();
var allocations = response["allocationentry"];
foreach (DBDocument allocation in allocations)
{
allocation["project"] = DBDocument.FindOne("project", allocation["project"][DBDocument.Id]);
}
return(new AjaxResult((DataTree)response));
}
public ActionResult getprojectresults(string terms, string userid)
{
var splitters = new char[] { ' ' };
string[] splitTerms = terms.Split(splitters, StringSplitOptions.RemoveEmptyEntries);
if (removeWildcards)
{
RemoveWildcards(splitTerms);
}
DataTree resultData = null;
if (splitTerms.Length > 0)
{
var dbQueries = new List <DBQuery>();
DataTree schema = Runtime.RunBlock("core", "schemafor", "project");
DBQuery resultsQuery = QuerySearchFilterTerm(splitTerms, schema, "project");
if (resultsQuery != null)
{
resultData = (DataTree)resultsQuery.Find().FirstCollection;
List <string> nameFields = Schema.GetNameFields(schema);
FilterResults(resultData, Schema.GetSearchFields(schema), nameFields);
}
}
if (resultData != null && resultData.Count > 0)
{
return(NamedView("searchfilter", "searchfilterresult", resultData));
}
else
{
return(NamedView("searchfilter", "searchfilterresult", MC2EmptyValue.EmptyValue));
}
}
/// <summary>
/// Generated code for MC2 widget "approveworkhelper".
/// </summary>
public ActionResult getdetailsdata(string detailids)
{
string[] identifiers = detailids.Split(',');
var query = new DBQuery();
query["details"][DBQuery.CollectionName] = "timesheetentry";
var orQueries = new List <IMongoQuery>();
foreach (string strId in identifiers)
{
var id = new ObjectId(strId);
orQueries.Add(Query.EQ("parent", id));
}
query["details"][DBQuery.Condition] = Query.Or(orQueries).ToString();
DBCollection results = query.Find().FirstCollection;
return(new AjaxResult((DataTree)results));
}
private void UpdatePayTypesIfNeeded()
{
if (payTypeUpdateStopwatch.Elapsed.Minutes > PayTypeUpdateIntervalMinutes ||
expenseTypes == null || payTypes == null)
{
var query = new DBQuery("totalwork", "paytypes");
var result = query.Find();
lock (payTypeLock)
{
payTypes = result["timesheetentrydetailpaytype"];
expenseTypes = result["dayentrytype"];
if (result["socialproject"].Count >= 0)
{
socialProject = result["socialproject"][0];
}
}
payTypeUpdateStopwatch.Restart();
}
}
public ActionResult getsubprojects(
string parentproject)
{
int MaxSubProjects = (int)Runtime.Config["tro"]["dataview"]["maxsubprojects"].GetValueOrDefault(300);
DBQuery query = QueryGetProjects(
null,
"name",
false,
MaxSubProjects,
0,
string.Empty);
if (query != null)
{
DBResponse response = query.Find();
DataTree qi = response.QueryInfo;
return(new AjaxResult(GetJsonFromProjectsCollection((DataTree)response.FirstCollection)));
}
else
{
return(new AjaxResult(""));
}
}
public ActionResult pasteday(string sourceday, string targetday)
{
if ((bool)Runtime.Features["timetracking"])
{
return(new AjaxResult("Copying not supported for timetracking."));
}
logger.LogInfo("copying entries from one date to another", sourceday, targetday);
DateTime sourceDay = DateTime.ParseExact(sourceday, "yyyyMMdd", CultureInfo.InvariantCulture);
sourceDay = new DateTime(sourceDay.Year, sourceDay.Month, sourceDay.Day, sourceDay.Hour, sourceDay.Minute, sourceDay.Second, DateTimeKind.Utc);
DateTime targetDay = DateTime.ParseExact(targetday, "yyyyMMdd", CultureInfo.InvariantCulture);
targetDay = new DateTime(targetDay.Year, targetDay.Month, targetDay.Day, targetDay.Hour, targetDay.Minute, targetDay.Second, DateTimeKind.Utc);
var query = new DBQuery("workentries", "workforday");
query.AddParameter("start", sourceDay);
query.AddParameter("end", sourceDay);
query.AddParameter("user", new ObjectId(Runtime.SessionManager.CurrentUser[DBQuery.Id]));
DBResponse response = query.Find();
DBCollection timesheetEntries = response["timesheetentry"];
DBCollection abseneceEntries = response["absenceentry"];
DBCollection dayEntries = response["dayentry"];
var tasks = new List <Task <bool> >();
bool isTargetInThePast = (DateTime.Compare(DateTime.UtcNow, targetDay) > 0);
// Only ever copy absences for future
if (isTargetInThePast)
{
tasks.Add(CopyEntriesToDay(timesheetEntries, targetDay));
tasks.Add(CopyEntriesToDay(dayEntries, targetDay));
tasks.Add(CopyEntriesToDay(abseneceEntries, targetDay));
}
else
{
logger.LogDebug("Copy target date is in the future");
if ((bool)Runtime.Features["allowfutureabsences"])
{
tasks.Add(CopyEntriesToDay(abseneceEntries, targetDay));
}
}
Task.WaitAll(tasks.ToArray());
bool somethingFiltered = false;
foreach (var task in tasks)
{
if (task.Result)
{
somethingFiltered = true;
}
}
return(new AjaxResult(somethingFiltered ? "filtered" : "success"));
}
public ActionResult getresultsrelation(
string terms,
string rootschema,
string collection,
string valuename,
string relationtarget,
string itemid = "",
string filtercontroller = "",
string filteraction = "")
{
var splitters = new char[] { ' ' };
string[] splitTerms = terms.Split(splitters, StringSplitOptions.RemoveEmptyEntries);
if (removeWildcards)
{
RemoveWildcards(splitTerms);
}
// In case there are no search terms, use the default value.
if (splitTerms.Length == 0)
{
DataTree results =
GetDefaultResults(
rootschema,
collection,
valuename,
relationtarget,
itemid,
filtercontroller,
filteraction);
if (results == null)
{
return(NamedView("searchfilter", "searchfilterresult", MC2EmptyValue.EmptyValue));
}
else
{
return(NamedView("searchfilter", "searchfilterresult", results));
}
}
List <IMongoQuery> filterQueries = new List <IMongoQuery>();
IMongoQuery query = Runtime.Filters.GetFilterQuery(filtercontroller, filteraction);
if (query != null)
{
filterQueries.Add(query);
}
string relationTarget = Runtime.Schema.GetRelationTarget(rootschema, collection, valuename);
DataTree schema = Runtime.RunBlock("core", "schemafor", relationTarget);
DBQuery resultsQuery = QuerySearchFilterTerm(splitTerms, schema, relationTarget, -1, filterQueries.ToArray());
DBResponse response = null;
if (resultsQuery != null)
{
response = resultsQuery.Find();
List <string> nameFields = Schema.GetNameFields(schema);
FilterResults((DataTree)response.FirstCollection, Schema.GetSearchFields(schema), nameFields);
}
if (response != null && response.FirstCollection.Count > 0)
{
return(NamedView("searchfilter", "searchfilterresult", (MC2Value)response.FirstCollection, response.QueryInfo));
}
else
{
return(NamedView("searchfilter", "searchfilterresult", MC2EmptyValue.EmptyValue));
}
}
public ActionResult relationdropdown(
string collection,
string filtercontroller = "",
string filteraction = "")
{
DataTree schema = Runtime.Schema.First[collection];
string filter = schema["collection"]["listfilter"];
string orderBy = schema["collection"]["orderby"];
bool ascending = (bool)schema["collection"]["ascending"].GetValueOrDefault(false);
// Combine given filter and filter from schema.
if (!string.IsNullOrEmpty(filtercontroller) && !string.IsNullOrEmpty(filteraction))
{
IMongoQuery customFilter = this.Runtime.Filters.GetFilterQuery(filtercontroller, filteraction);
if (string.IsNullOrEmpty(filter))
{
}
else
{
BsonDocument doc = MongoDB.Bson.Serialization
.BsonSerializer.Deserialize <BsonDocument>(filter);
var combinedFilter = Query.And(new QueryDocument(doc), customFilter);
filter = combinedFilter.ToString();
}
}
var query = new DBQuery();
if (!string.IsNullOrEmpty(orderBy))
{
query[collection][DBQuery.OrderBy] = orderBy;
query[collection][DBQuery.Ascending] = ascending;
}
if (string.IsNullOrEmpty(filter))
{
query[collection][DBQuery.Condition] = DBQuery.All;
}
else
{
query[collection][DBQuery.Condition] = filter;
}
query[collection][DBQuery.DocumentsPerPage] = DropdownMaxDocuments;
DBResponse response = query.Find();
DataTree filteredResults = new DataTree("results");
foreach (DataTree result in response.FirstCollection)
{
DataTree filteredResult = filteredResults.Add(result.Name);
List <string> nameFields = Schema.GetNameFields(Runtime.Schema.First[collection]);
string displayName = "";
bool first = false;
foreach (string nameField in nameFields)
{
if (first)
{
first = false;
}
else if (!displayName.EndsWith(" ") && !string.IsNullOrEmpty(displayName))
{
displayName += " ";
}
displayName += result[nameField];
}
filteredResult["name"] = displayName;
}
return(new AjaxResult(filteredResults));
}
public AjaxResult gettotals(
string userfilter,
string projectfilter,
string assetfilter,
string profitcenterfilter,
string resourceprofitcenterfilter,
string resourcebusinessarea,
string resourcefunctionalarea,
string managerprojectsfilter,
string payrollperiodfilter,
string favouriteusersfilter,
bool showonlyentriesnotaccepted,
MC2DateTimeValue daterangestart = null,
MC2DateTimeValue daterangeend = null)
{
int maxTotalDocuments = (int)Runtime.Config["totalwork"]["maxdocuments"].GetValueOrDefault(1000);
var timesheetQueries = new List <IMongoQuery>();
var absenceQueries = new List <IMongoQuery>();
var expenseQueries = new List <IMongoQuery>();
SystemsGarden.mc2.tro.approveworklistview.AddFiltersToQuery(
"timesheetentry",
userfilter, projectfilter, assetfilter, profitcenterfilter, resourceprofitcenterfilter,
resourcebusinessarea, resourcefunctionalarea, managerprojectsfilter, payrollperiodfilter,
favouriteusersfilter, daterangestart, daterangeend, showonlyentriesnotaccepted, timesheetQueries);
SystemsGarden.mc2.tro.approveworklistview.AddFiltersToQuery(
"absenceentry",
userfilter, projectfilter, assetfilter, profitcenterfilter, resourceprofitcenterfilter,
resourcebusinessarea, resourcefunctionalarea, managerprojectsfilter, payrollperiodfilter,
favouriteusersfilter, daterangestart, daterangeend, showonlyentriesnotaccepted, absenceQueries);
SystemsGarden.mc2.tro.approveworklistview.AddFiltersToQuery(
"dayentry",
userfilter, projectfilter, assetfilter, profitcenterfilter, resourceprofitcenterfilter,
resourcebusinessarea, resourcefunctionalarea, managerprojectsfilter, payrollperiodfilter,
favouriteusersfilter, daterangestart, daterangeend, showonlyentriesnotaccepted, expenseQueries);
DBQuery totalsQuery = new DBQuery();
totalsQuery["timesheetentry"][DBQuery.Condition] = Query.And(timesheetQueries).ToString();
totalsQuery["timesheetentry"][DBQuery.DocumentsPerPage] = maxTotalDocuments;
totalsQuery["timesheetentry"][DBQuery.SpecifiedFieldsOnly] = true;
totalsQuery["timesheetentry"]["duration"].Create();
totalsQuery["timesheetentry"]["timesheetentrydetailpaytype"].Create();
totalsQuery["timesheetentry"]["user"].Create();
totalsQuery["timesheetentry"]["project"].Create();
totalsQuery["absenceentry"][DBQuery.Condition] = Query.And(absenceQueries).ToString();
totalsQuery["absenceentry"][DBQuery.DocumentsPerPage] = maxTotalDocuments;
totalsQuery["absenceentry"][DBQuery.SpecifiedFieldsOnly] = true;
totalsQuery["absenceentry"]["duration"].Create();
totalsQuery["absenceentry"]["absenceentrytype"].Create();
totalsQuery["absenceentry"]["user"].Create();
totalsQuery["dayentry"][DBQuery.Condition] = Query.And(expenseQueries).ToString();
totalsQuery["dayentry"][DBQuery.DocumentsPerPage] = maxTotalDocuments;
totalsQuery["dayentry"][DBQuery.SpecifiedFieldsOnly] = true;
totalsQuery["dayentry"]["amount"].Create();
totalsQuery["dayentry"]["dayentrytype"].Create();
totalsQuery["dayentry"]["user"].Create();
DBResponse totalsResult = totalsQuery.Find();
if (totalsResult["timesheetentry"].Count >= maxTotalDocuments ||
totalsResult["dayentry"].Count >= maxTotalDocuments ||
totalsResult["absenceentry"].Count >= maxTotalDocuments)
{
return(new AjaxResult("too many results"));
}
DataTree userTotals = CountResults(totalsResult);
return(new AjaxResult((DataTree)userTotals));
}
